HDU 3416：Marriage Match IV（最短路+最大流）

http://acm.hdu.edu.cn/showproblem.php?pid=3416

题意：给出n个点m条边，边信息分别是两个端点和一个费用，再给出一个起点和一个终点，问从起点到终点的完全不相同的最短路径有多少条。（即走过的边不能在走过了）。

思路：因为是在网络流专题里面，所以一开始以为先用SPFA跑一个最小费用出来，然后再用最小费用最大流（然而是最小费用最大流是满足最大流的前提下再考虑最小费用的，很明显是行不通的）。后来想要保证路径不重复，就跑完一次最短路就删除路径（好像也是行不通）。然后只能看下题解了= =。

从起点到终点跑一次SPFA，再从终点到起点跑一次SPFA，这里第一次SPFA跑出来的距离数组是d[0]，第二次跑出来的是d[1]，如果d[0][u] + w(u, v) + d[1][v] == d[0][T]，那么这条w(u,v)边一定是最短路上的边。这里说说我对这个定理的看法：d[0][u]是从起点到u点的最短距离，而d[1][v]是从v到终点的最短距离，那么如果加上这条边刚好等于从起点到终点的最短距离，那么这条边就必定是最短路的边，嗯。好像很明显。然后将这些必定在最短路上的边建起网络，容量是1，跑一遍从起点到终点的最大流，就是最终答案了。这样就符合最大流的思想了。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 using namespace std;
 #define N 1010
 #define M 200010
 #define INF 0x3f3f3f3f
 struct Edge {
     int v, cap, nxt;
     Edge () {}
     Edge (int v, int nxt, int cap) : v(v), nxt(nxt), cap(cap) {}
 } edge[M], e[M];
 int cur[N], pre[N], gap[N], dis[N], d[][N], vis[N], head[N], h[N], uu[M], vv[M], ww[M], tot, tt, S, T, n, m;

 void Add(int u, int v, int cap, int tag) {
     if(tag == ) { e[tt] = Edge(v, h[u], cap); h[u] = tt++; }
     else { edge[tot] = Edge(v, head[u], cap); head[u] = tot++; edge[tot] = Edge(u, head[v], ); head[v] = tot++; }
 }

 void SPFA(int st, int ed, int id) {
     for(int i = ; i <= n; i++) d[id][i] = INF;
     memset(vis, , sizeof(vis));
     queue<int> que; que.push(st);
     vis[st] = ; d[id][st] = ;
     while(!que.empty()) {
         int u = que.front(); que.pop(); vis[u] = ;
         for(int i = h[u]; ~i; i = e[i].nxt) {
             int v = e[i].v, w = e[i].cap;
             if(d[id][v] > d[id][u] + w) {
                 d[id][v] = d[id][u] + w;
                 if(vis[v]) continue;
                 que.push(v); vis[v] = ;
             }
         }
     }
 }

 void BFS() {
     memset(dis, INF, sizeof(dis));
     memset(gap, , sizeof(gap));
     queue<int> que; que.push(T);
     dis[T] = ; gap[]++;
     while(!que.empty()) {
         int u = que.front(); que.pop();
         for(int i = head[u]; ~i; i = edge[i].nxt) {
             int v = edge[i].v;
             if(dis[v] != INF) continue;
             dis[v] = dis[u] + ;
             gap[dis[v]]++;
             que.push(v);
         }
     }
 }

 int ISAP(int n) {
     BFS();
     memcpy(cur, head, sizeof(cur));
     int u = pre[S] = S, ans = , flow, i, index;
     while(dis[S] < n) {
         if(u == T) {
             flow = INF;
             for(i = S; i != T; i = edge[cur[i]].v)
                 if(flow > edge[cur[i]].cap) flow = edge[cur[i]].cap, index = i;
             for(i = S; i != T; i = edge[cur[i]].v)
                 edge[cur[i]].cap -= flow, edge[cur[i]^].cap += flow;
             u = index; ans += flow;
         }
         for(i = cur[u]; ~i; i = edge[i].nxt) if(edge[i].cap >  && dis[edge[i].v] +  == dis[u]) break;
         if(~i) { cur[u] = i; pre[edge[i].v] = u; u = edge[i].v; }
         else {
             if(--gap[dis[u]] == ) break;
             int md = n + ;
             for(i = head[u]; ~i; i = edge[i].nxt)
                 if(dis[edge[i].v] < md && edge[i].cap > ) md = dis[edge[i].v], cur[u] = i;
             gap[dis[u] = md + ]++;
             u = pre[u];
         }
     }
     return ans;
 }

 int main() {
     int t;
     scanf("%d", &t);
     while(t--) {
         scanf("%d%d", &n, &m);
         int edgenum = ;
         for(int i = ; i <= m; i++) {
             int u, v, w;
             scanf("%d%d%d", &u, &v, &w);
             //if(u == v) continue;
             edgenum++; uu[edgenum] = u; vv[edgenum] = v; ww[edgenum] = w;
         }
         scanf("%d%d", &S, &T);
         memset(h, -, sizeof(h)); tt = ;
         for(int i = ; i <= edgenum; i++) Add(uu[i], vv[i], ww[i], );
         SPFA(S, T, );
         memset(h, -, sizeof(h)); tt = ;
         for(int i = ; i <= edgenum; i++) Add(vv[i], uu[i], ww[i], );
         SPFA(T, S, );
         memset(head, -, sizeof(head)); tot = ;
         for(int i = ; i <= edgenum; i++)
             if(d[][uu[i]] + d[][vv[i]] + ww[i] == d[][T]) Add(uu[i], vv[i], , ); // 容量设成1.而不是ww
         int ans = ISAP(n + );
         printf("%d\n", ans);
     }
     return ;
 }