最短路径生成树：

（[HAOI2012]道路）

题目描述

C国有n座城市，城市之间通过m条[b]单向[/b]道路连接。一条路径被称为最短路，当且仅当不存在从它的起点到终点的另外一条路径总长度比它小。两条最短路不同，当且仅当它们包含的道路序列不同。我们需要对每条道路的重要性进行评估，评估方式为计算有多少条不同的最短路经过该道路。现在，这个任务交给了你。

输入输出格式

输入格式：

第一行包含两个正整数n、m

接下来m行每行包含三个正整数u、v、w，表示有一条从u到v长度为w的道路

输出格式：

输出应有m行，第i行包含一个数，代表经过第i条道路的最短路的数目对[b]1000000007取模[/b]后的结果

输入输出样例

输入样例#1：

4 4
1 2 5
2 3 5
3 4 5
1 4 8

输出样例#1：

2
3
2
1

说明

数据规模

30%的数据满足：n≤15、m≤30

60%的数据满足：n≤300、m≤1000

100%的数据满足：n≤1500、m≤5000、w≤10000

个人思路：

  • 枚举源点S，跑最短路径生成树，在每次得到的DAG上进行拓扑排序计数即可（正向反向各一次，计数依据乘法原理）

题目地址：https://www.luogu.org/problemnew/show/P2573

参考代码：

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
inline int read() {
    int res = 0; bool bo = 0; char c;
    while (((c = getchar()) < '0' || c > '9') && c != '-');
    if (c == '-') bo = 1; else res = c - 48;
    while ((c = getchar()) >= '0' && c <= '9')
        res = (res << 3) + (res << 1) + (c - 48);
    return bo ? ~res + 1 : res;
}
const int N = 1505, M = 5005, INF = 0x3f3f3f3f, PYZ = 1e9 + 7;
int n, m, ecnt, nxt[M], adj[N], st[M], go[M], val[M], dis[M], len, que[M << 1],
cnt[N], cnt1[N], cnt2[N], H, T, tot, q[N], ans[M];
bool vis[N], ins[M];
void add_edge(int u, int v, int w) {
    nxt[++ecnt] = adj[u]; adj[u] = ecnt; st[ecnt] = u; go[ecnt] = v; val[ecnt] = w;
}
void spfa(int S) {
    int i; memset(dis, INF, sizeof(dis));
    memset(ins, 0, sizeof(ins));
    dis[que[len = 1] = S] = 0;
    for (i = 1; i <= len; i++) {
        int u = que[i]; vis[u] = 0;
        for (int e = adj[u], v; e; e = nxt[e])
            if (dis[u] + val[e] < dis[v = go[e]]) {
                dis[v] = dis[u] + val[e];
                if (!vis[v]) vis[que[++len] = v] = 1;
            }
    }
    for (i = 1; i <= m; i++)
        if (dis[st[i]] + val[i] == dis[go[i]])
            ins[i] = 1;
}
void topo(int S) {
    memset(cnt, 0, sizeof(cnt));
    memset(cnt1, 0, sizeof(cnt1));
    memset(cnt2, 0, sizeof(cnt2));
    int i; H = tot = 0; cnt1[que[T = 1] = S] = 1;
    for (i = 1; i <= m; i++) if (ins[i]) cnt[go[i]]++;
    while (H < T) {
        int u = que[++H]; q[++tot] = u;
        for (int e = adj[u], v; e; e = nxt[e]) {
            if (!ins[e]) continue;
            v = go[e]; if (!(--cnt[v])) que[++T] = v;
            (cnt1[v] += cnt1[u]) %= PYZ;
        }
    }
    for (i = tot; i; i--) {
        int u = q[i]; cnt2[u]++;
        for (int e = adj[u], v; e; e = nxt[e]) {
            if (!ins[e]) continue;
            (cnt2[u] += cnt2[v = go[e]]) %= PYZ;
        }
    }
}
void solve(int S) {
    int i; spfa(S); topo(S);
    for (i = 1; i <= m; i++) if (ins[i])
        (ans[i] += 1ll * cnt1[st[i]] * cnt2[go[i]] % PYZ) %= PYZ;
}
int main() {
    int i, x, y, z; n = read(); m = read();
    for (i = 1; i <= m; i++) x = read(), y = read(),
        z = read(), add_edge(x, y, z);
    for (i = 1; i <= n; i++) solve(i);
    for (i = 1; i <= m; i++) printf("%d\n", ans[i]);
    return 0;
}

最小生成树：

（[SCOI2012]滑雪）

题目描述

a180285非常喜欢滑雪。他来到一座雪山，这里分布着M条供滑行的轨道和N个轨道之间的交点（同时也是景点），而且每个景点都有一编号i(1≤i≤N)和一高度H_i。a180285能从景点ii滑到景点jj当且仅当存在一条i和j之间的边，且ii的高度不小于j。 与其他滑雪爱好者不同，a180285喜欢用最短的滑行路径去访问尽量多的景点。如果仅仅访问一条路径上的景点，他会觉得数量太少。于是a180285拿出了他随身携带的时间胶囊。这是一种很神奇的药物，吃下之后可以立即回到上个经过的景点（不用移动也不被认为是a180285 滑行的距离）。请注意，这种神奇的药物是可以连续食用的，即能够回到较长时间之前到过的景点（比如上上个经过的景点和上上上个经过的景点）。 现在，a180285站在1号景点望着山下的目标，心潮澎湃。他十分想知道在不考虑时间胶囊消耗的情况下，以最短滑行距离滑到尽量多的景点的方案（即满足经过景点数最大的前提下使得滑行总距离最小）。你能帮他求出最短距离和景点数吗？

输入输出格式

输入格式：

输入的第一行是两个整数N,M。

接下来1行有N个整数H_i，分别表示每个景点的高度。

接下来M行，表示各个景点之间轨道分布的情况。每行3个整数，U_i,V_i,K_i​。表示编号为U_iU的景点和编号为V_i的景点之间有一条长度为K_i的轨道。

输出格式：

输出一行，表示a180285最多能到达多少个景点，以及此时最短的滑行距离总和。

输入输出样例

输入样例#1：

3 3 
3 2 1 
1 2 1 
2 3 1 
1 3 10

输出样例#1：

3 2

说明

【数据范围】

对于30\%的数据，保证 1 \le N \le 2000

对于100\%的数据，保证 1 \le N \le 10^5

对于所有的数据，保证 1 \le M \le 10^6 , 1 \le H_i \le 10^9 ，1 \le K_i \le 10^9。

个人思路：由题意可以发现，正解为求一个从源点1出发的最小生成树，在Kruskal的过程中，将终点的高度作为第一关键字，边权作为第二关键字，结果即为最短滑行距离总和

题目地址：https://www.luogu.org/problemnew/show/P2573

参考代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<cstdlib>
#include<string>
#include<queue>
#include<map>
#include<vector>
#define ll long long
#define R register
#define Rf(a,b,c) for(R int (a)=(b);(a)<=(c);++(a))
#define Tf(a,b,c) for(R int (a)=(b);(a)>=(c);--(a))
using namespace std;
const int N=2000000+5,M=100000+5;
ll n,m,tot,ans,num,sum,cnt,ql,qr;
struct it{
    ll u,v,w;//新图 
};
struct node {
    ll to,nx,val;//初始图（链式前向星） 
};
it a[N];node b[N];
ll fa[M],h[M],head[M],q[M];
bool vis[M];
inline ll read()//读入优化 
{
    ll x=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x*=10;x+=(ch-'0');ch=getchar();}
    return x*f;
}
bool cmp1(it x,it y) {
//比较函数，以终点的高度为第一关键字从大到小排序，边长为第二关键字从小到大排序 
    if(h[x.v]!=h[y.v]) return h[x.v]>h[y.v];
    return x.w<y.w;
}
inline ll find(ll x) {//并查集找父亲 
    if(fa[x]!=x) fa[x]=find(fa[x]);
    return fa[x];
}
inline void add(int u,int v,int c) {//链式前向星加边 
    b[++num].to=v;
    b[num].nx=head[u];
    head[u]=num;
    b[num].val=c;
}
void bfs(){//宽搜，拓展可到达的点，建新图 
    q[++qr]=1;vis[1]=1;
    while(ql<qr) {
        int now=q[++ql];
        for(int i=head[now];i;i=b[i].nx) {
            a[++cnt].u=now;a[cnt].v=b[i].to;a[cnt].w=b[i].val;//建立新图的边 
            if(!vis[b[i].to]) {
                vis[b[i].to]=1;sum++;//sum计数器计可到达的点 
                q[++qr]=(b[i].to);
            }
        }
    }
}
int main()
{
//    freopen("steep.in","r",stdin);
//    freopen("steep.out","w",stdout);
    n=read();m=read();//读入数据 
    Rf(i,1,n) h[i]=read(),fa[i]=i;
    Rf(i,1,m) {
        R int u=read(),v=read(),c=read();
        if(h[u]>=h[v]) add(u,v,c);//根据边两边的点的高度，建立一条由高到低的单向边 
        if(h[u]<=h[v]) add(v,u,c);//当高度相等时会建两条边 
    }
    bfs();//广搜拓展点 
    sort(a+1,a+1+cnt,cmp1);//对新图的点跑Kruskal求最小生成树 
    Rf(i,1,cnt) {
        R int rx=find(a[i].u),ry=find(a[i].v);
        if(rx!=ry) {
            fa[rx]=ry;ans+=a[i].w;//求最短距离 
        }
    }
    printf("%lld %lld",sum+1,ans);//sum+1，还有初始的1点可到 
    return 0;
}