hdu 3416(最短路+最大流)

题意： 有 n 个城市，知道了起点和终点，有 m 条有向边，问从起点到终点的最短路一共有多少条。

解题思路：这题的关键就是找到哪些边可以构成最短路，其实之前做最短路的题目接触过很多，反向建一个图，求两边最短路，即从src到任一点的最短路dis1[]和从des到任一点的最短路dis2[]，那么假设这条边是(u,v,w)，如果dis1[u] + w + dis2[v] = dis1[des],说明这条边是构成最短路的边。找到这些边，就可以把边的容量设为1，跑一边最大流即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;

const int maxn = 1005;
const int inf = 0x3f3f3f3f;
struct Edge
{
	int from,to,next,w;
}edge[800005],E[100005];
int n,m,st,ed;
int cnt,head[maxn],pre[2][maxn];
int dis[2][maxn],level[maxn];
bool inq[maxn];

void addedge(int u,int v,int w)
{
	edge[cnt].to = v;
	edge[cnt].w = w;
	edge[cnt].next = head[u];
	head[u] = cnt++;
	swap(u,v);
	edge[cnt].to = v;
	edge[cnt].w = 0;
	edge[cnt].next = head[u];
	head[u] = cnt++;
}

void addedge1(int u,int v,int w)
{
	edge[cnt].to = v;
	edge[cnt].w = w;
	edge[cnt].next = pre[0][u];
	pre[0][u] = cnt++;
}

void addedge2(int u,int v,int w)
{
	edge[cnt].to = v;
	edge[cnt].w = w;
	edge[cnt].next = pre[1][u];
	pre[1][u] = cnt++;
}

void build()
{
	int u,v,w;
	memset(head,-1,sizeof(head));
	for(int i = 1; i <= m; i++)
	{
		u = E[i].from, v = E[i].to, w = E[i].w;
		if(dis[0][u] + w + dis[1][v] == dis[0][ed])
			addedge(u,v,1);
	}
}

void spfa(int src,int des,int idx)
{
	queue<int> q;
	memset(dis[idx],inf,sizeof(dis[idx]));
	memset(inq,false,sizeof(inq));
	dis[idx][src] = 0;
	q.push(src);
	inq[src] = true;
	while(!q.empty())
	{
		int u = q.front();
		q.pop();
		inq[u] = false;
		for(int i = pre[idx][u]; i != -1; i = edge[i].next)
		{
			int v = edge[i].to;
			if(dis[idx][v] > dis[idx][u] + edge[i].w)
			{
				dis[idx][v] = dis[idx][u] + edge[i].w;
				if(inq[v] == false)
				{
					inq[v] = true;
					q.push(v);
				}
			}
		}
	}
}

int BFS(int src,int des){
    queue<int> q;
    memset(level,0,sizeof(level));
    level[src]=1;
    q.push(src);
    while(!q.empty()){
        int u = q.front();
        q.pop();
        if(u==des) return 1;
        for(int k = head[u];k!=-1;k=edge[k].next){
            int v = edge[k].to,w=edge[k].w;
            if(level[v]==0 && w!=0){
                level[v]=level[u]+1;
                q.push(v);
            }
        }
    }
    return -1;
}
int dfs(int u,int des,int increaseRoad){
    if(u==des) return increaseRoad;
    int ret=0;
    for(int k=head[u];k!=-1;k=edge[k].next){
        int v = edge[k].to,w=edge[k].w;
        if(level[v]==level[u]+1&&w!=0){
            int MIN = min(increaseRoad-ret,w);
            w = dfs(v,des,MIN);
			if(w > 0)
			{
				edge[k].w -=w;
				edge[k^1].w+=w;
				ret+=w;
				if(ret==increaseRoad) return ret;
			}
			else level[v] = -1; 
        }
    }
    return ret;
}
int Dinic(int src,int des){
    int ans = 0;
    while(BFS(src,des)!=-1) ans+=dfs(src,des,inf);
    return ans;
}

int main()
{
	int t,u,v,w;
	scanf("%d",&t);
	while(t--)
	{
		cnt = 0;
		memset(pre,-1,sizeof(pre));
		scanf("%d%d",&n,&m);
		for(int i = 1; i <= m; i++)
		{
			scanf("%d%d%d",&u,&v,&w);
			E[i].from = u,E[i].to = v,E[i].w = w;
			addedge1(u,v,w);
			addedge2(v,u,w);
		}
		scanf("%d%d",&st,&ed);
		spfa(st,ed,0);
		spfa(ed,st,1);
		build();
		int maxflow = Dinic(st,ed);
		printf("%d\n",maxflow);
	}
	return 0;
}