poj 3204 Ikki's Story I - Road Reconstruction

最大流最小割

分析都在代码注释中

/*

题意：对于一个有向图的最大流，在每条流路中，只能修改一条边，使得修改后，整个网络的最大流可以增大，问有多少条这样的边

注意一点，在一条流路中只能修改一条，好像s->1->2->t,假设每条边的容量都是2，那么最大流的流路只有一条，但是这条流路中，

要想增大一条边的容量而使整个网络的最大流增加是不行的，一定要把所有边容量都增大，这与题意不符，所以这个case输出是0，表示1条都没有



首先我们运行一次最大流，得到最终的残余网络，那么我们怎么找到我们要的割边呢？首先割边一定已经是满流的了，假设我们得到一条满流的边u->v

如果源点s可以到达点u，且点v能到达汇点t的话，那么这条满流边就是我们要找的，那么什么是能到达呢？

原来的有向边中，只有非满流的边才能继续走，满流的边我们看做已经是断开的不能再走（即按残余网络来遍历）

所以我们从源点s出发遍历一次整个图，去到的点染色为1。然后从汇点t出发遍历一次整个图，去到的点染色为2

因为要从汇点反过来遍历整个图，所以我们被迫要另外建一个逆邻接表，同样的，我们就算从源点开始遍历，而原始的邻接表有太多无用的信息

（每条有向边还带出一条反边，这些都是没用的信息），所以我们干脆重新建一个顺邻接表，其实就是把原邻接表有用的信息拿出来单独保存

后来拿出来的顺邻接表放在order[]数组中，而逆邻接表放在reorder[]数组中

而我们最后要检查所有满流的边，看两个顶点是不是分别染色为1,2，所以我们开辟一个队列来专门保存这些满流的边，在full队列中

*/



#include <cstdio>

#include <cstring>

#include <vector>

#include <queue>

using namespace std;

#define N 510

#define M 5010

#define INF 0x3f3f3f3f

#define min(a,b) a<b?a:b



int nume;

struct edge

{

    int u,v,cap,flow,next;

}e[10*M];

int first[N],n,m;

int col[N]; //点染色

vector<int>order[N],reorder[N]; //顺邻接表，逆邻接表，保存不满流的边

queue<int>full; //保存满流的边(边的编号)



void add(int u ,int v ,int cap)

{

    e[nume].u=u; e[nume].v=v; e[nume].cap=cap; 

    e[nume].flow=0; 

    e[nume].next=first[u]; first[u]=nume++;

}



void build()

{

    memset(first,-1,sizeof(first));

    nume=0;

    scanf("%d%d",&n,&m);

    for(int i=1; i<=m; i++)

    {

        int u,v,cap;

        scanf("%d%d%d",&u,&v,&cap);

        if(!cap) continue;

        add(u,v,cap);

        add(v,u,0);

    }

}



void EK(int s, int t)

{

    queue<int>q;

    int a[N],p[N],FLOW=0;

    while(1)

    {

        memset(a,0,sizeof(a));

        a[s]=INF;

        memset(p,-1,sizeof(p));

        q.push(s);

        while(!q.empty())

        {

            int u,v,cap,flow;

            u=q.front(); q.pop();

            for(int k=first[u]; k!=-1; k=e[k].next)

            {

                v=e[k].v; cap=e[k].cap; flow=e[k].flow;

                if(!a[v] && cap>flow) //没有计算过并且可以增流

                {

                    a[v]=min(a[u],cap-flow);

                    p[v]=k;

                    q.push(v);

                }

            }

        }



        if(!a[t]) break;

        for(int k=p[t]; k!=-1; k=p[e[k].u])

        {

            e[k].flow += a[t];

            e[k^1].flow -= a[t];

        }

        FLOW += a[t];

    }



}



void dfs1(int u ,int c) //从源点出发进行遍历

{

    col[u]=c;

    int len=order[u].size();

    for(int i=0; i<len; i++)

    {

        int v=order[u][i];

        if(!col[v]) dfs1(v,c);

    }

}



void dfs2(int u ,int c) //从汇点出发逆遍历

{

    col[u]=c;

    int len=reorder[u].size();

    for(int i=0; i<len; i++)

    {

        int v=reorder[u][i];

        if(!col[v]) dfs2(v,c);

    }

}



void search(int s ,int t)

{

    while(!full.empty()) full.pop();

    for(int i=0; i<n; i++) 

    {

        order[i].clear();

        reorder[i].clear();

    }



    for(int k=0; k<nume; k+=2)

        if(e[k].cap==e[k].flow) //满流的边

            full.push(k);

        else                    //非满流的边

        {

            int u=e[k].u , v=e[k].v;

            order[u].push_back(v);  //保存顺邻接表

            reorder[v].push_back(u); //保存逆邻接表

        }



    memset(col,0,sizeof(col));

    dfs1(s,1);  dfs2(t,2);



    int ans=0;

    while(!full.empty()) //检查所有满流的边

    {

        int x,u,v;

        x=full.front();

        full.pop();

        u=e[x].u; v=e[x].v;

        if(col[u]==1 && col[v]==2) ans++;

    }

    printf("%d\n",ans);

}



int main()

{

    build();

    EK(0,n-1);

    search(0,n-1);

    return 0;

}