ZOJ 2760 网络流

首先注意一点，邻接矩阵对角线上的数据（如map[2][2],map[3][3]）未必是0,非常坑。
首先求出最短路的长度（复杂度n² 或n³都可以），然后对于每条边，假设两个端点分别为a,b,如果起点到a的距离加上ab边长再加上b到终点的距离恰巧等于最短路的长度，则可以判断这条边在最短路上，我们便在网络流中加入这条边。把该加入的边都加入后跑一遍网络流即可。

#include<iostream>
#include<math.h>
#include<iomanip>
#include <string>
#include <cstdio>
#include<stdio.h>
#include <cstring>
#include <algorithm>
#include <queue>
#include<vector>
#define INF 0x3f3f3f3f
#define N 220
#define ll long long
using namespace std;int stop;
int map[N][N],maz[N][N];

struct Edge{
    int to,cap,rev;
    Edge(int b = 0,int c = 0,int d = 0){
        to = b,cap = c,rev = d;
    }
};
vector<Edge>G[N];
void add_edge(int from,int to,int cap)
{
	G[from].push_back((Edge){to,cap,G[to].size()});
	G[to].push_back((Edge){from,0,G[from].size()-1});
}

bool vis[N];
int deep[N],cur[N];

void bfs(int s)
{
	memset(deep,-1,sizeof(deep));
	queue<int>que;
	deep[s]=0;
	que.push(s);
	while(!que.empty())
	{
		int v=que.front();
		que.pop();
		for(int i=0;i<G[v].size();i++)
		{
			Edge& e=G[v][i];
			if(e.cap>0&&deep[e.to]<0)
			{
				deep[e.to]=deep[v]+1;
				que.push(e.to);
			}
		}
	}
}


int dfs(int v,int t,int f)
{
	if(v==t)
	return f;
	for(int &i=cur[v];i<G[v].size();i++)
	{
		Edge& e=G[v][i];
		if(e.cap>0&&deep[v]<deep[e.to])
		{
			int d=dfs(e.to,t,min(f,e.cap));
			if(d>0)
			{
				e.cap-=d;
				G[e.to][e.rev].cap+=d;
				return d;
			}
		}
	}
	return 0;
}

int max_flow(int s,int t)
{
	int flow=0;
	for(;;)
	{
		bfs(s);
		if(deep[t]<0)return flow;
		memset(cur,0,sizeof(cur));
		int f;
		while((f=dfs(s,t,INF))>0)
		{
			flow+=f;
		}
	}
}


int  floyd(int n)
{
	int i,j,k;
	for( k=1;k<=n;k++)
	{
		for( i=1;i<=n;i++)
		{
			for( j=1;j<=n;j++)
			{
				maz[i][j]=min(maz[i][j],maz[i][k]+maz[k][j]);
			}
		}
	}
}


void buildmap(int s,int t,int n)
{
	for(int i=1;i<=n;i++)
	{
		if(maz[s][i]==INF)continue;
		for(int j=1;j<=n;j++)
		{
			if(i==j||maz[j][t]==INF||maz[i][j]==INF)continue;
			if(maz[s][t]==maz[s][i]+map[i][j]+maz[j][t])
			{
				add_edge(i,j,1);
			}
		}
	}
}


int main(){
    int i,j,k,x;
    int n,s,t;
    while(scanf("%d",&n)!= EOF){
        for(i=1;i<=n;i++){
            G[i].clear();
        }
        memset(map,0x3f,sizeof(map));
        memset(maz,0x3f,sizeof(maz));
        for(i=1;i<=n;i++){
            for(j=1;j<=n;j++){
                scanf("%d",&x);
                maz[i][j] = x;
                if(x == -1){maz[i][j] = INF;}
                if(i == j){
                    maz[i][j] = 0;
                }
                map[i][j] = maz[i][j];
            }
        }
        scanf("%d%d",&s,&t);
        s++;t++;
        if(s == t){
            printf("inf\n");
            continue;
        }
        
        floyd(n);
        buildmap(s,t,n);
        int ans = max_flow(s,t);
        printf("%d\n",ans);
    }

    return 0;
}