ZOJ 2760 How Many Shortest Path

题目大意为：求解不相交的最短路径的条数,在这里每条边只能经过一次.

自己首先想到了最小费用最大流,因为最小费用最大流在增广的时候总是选择费用最小的增广路进行增广,我们记录第一次增广时的费用,然后记录最小费用最大流在增广的时候能够增广多少次,然后理所当然的交了上去WA. 后来自己画了一个图发现,最小费用最大流在增广的时候,边的选择是任意的,由于一次增广导致一条边被用了，然后该条边对这条最短路无所谓,却是另一条最短路的必经之边,因此这样会破坏了另一条最短路,因此利用最小费用最大流增广的过程中增广出的不相交的最短路径的条数总是小于等于正确答案的.

我们采用的正确的方法如下:预处理所有顶点之间的最短路径,可以利用Floyd算法进行预处理,对于属于最短路径上的一条边(u,v)满足dis[s][u]+w(u,v)+dis[v][t]=dis[s][t],因此我们采用的办法枚举所有的边,判断该边是否属于最短路径上的边,.如果属于则在构建的容量网络上增加一条容量为1的弧,利用这种方法构建相应的容量网络,接下来只需要在构建的容量网络上跑一次最大流算法即可... 其实想通了,这题属于一道水题的...

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;
const int MAXN = 110;
const int INF  = 0x3f3f3f3f;
int G[MAXN][MAXN], d[MAXN][MAXN], res[MAXN][MAXN];
int dis[MAXN];
int source, sink, n, maxflow;

int bfs()
{
    int k;
    queue<int> Q;
    memset(dis, -1, sizeof(dis));
    dis[sink] = 0;
    Q.push(sink);
    while(!Q.empty())
    {
        k = Q.front(); Q.pop();
        for(int i = 0; i < n; ++i)
        {
            if(dis[i] == -1 && res[i][k])
            {
                dis[i] = dis[k] + 1;
                Q.push(i);
            }
        }
        if(k == source) return 1;
    }
    return 0;
}

int dfs(int cur, int cp)
{
    if(cur == sink) return cp;
    int tmp = cp, t;
    for(int i = 0; i < n && tmp; ++i)
    {
        if(dis[i] + 1 == dis[cur] && res[cur][i])
        {
            t = dfs(i, min(res[cur][i], tmp));
            res[cur][i] -= t;
            res[i][cur] += t;
            tmp -= t;
        }
    }
    return cp - tmp;
}

void dinic()
{
    maxflow = 0;
    while(bfs()) maxflow += dfs(source, INF);
}

void floyd()
{
    for(int k = 0; k < n; ++k)
    {
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < n; ++j)
            {
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
            }
        }
    }
}

int main()
{
    //freopen("aa.in", "r", stdin);

    while(scanf("%d", &n) != EOF)
    {
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < n; ++j)
            {
                scanf("%d", &G[i][j]);
                if(G[i][j] == -1)
                    G[i][j] = INF;
                if(i == j)
                    G[i][j] = 0;
                d[i][j] = G[i][j];
            }
        }
        scanf("%d %d", &source, &sink);
        if(source == sink)
        {
            printf("inf\n");
            continue;
        }
        floyd();
        memset(res, 0, sizeof(res));
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < n; ++j)
            {
                if(d[source][i] + G[i][j] + d[j][sink] == d[source][sink] && G[i][j] < INF)
                {
                    res[i][j] = 1;
                }
            }
        }
        dinic();
        printf("%d\n", maxflow);
    }
    return 0;
}