poj 2135 最小费用流

#include<stdio.h>

#include<string.h>

#include<algorithm>

#include<queue>

using namespace std;

#define SIZE 1010

const int inf = 100000000;

struct node{

	int s,t,f,w;

	int next;

}edge[100010];

int head[2010];

int mincost,tot;

int s,t,pre[2010];

void add(int s,int t,int w,int f)

{

	edge[tot].f=f;

	edge[tot].w=w;

	edge[tot].t=t;

	edge[tot].s=s;

	edge[tot].next=head[s];

	head[s]=tot++;

}

void addedge(int s,int t,int w,int f)

{

	add(s,t,w,f);

	add(t,s,-w,0);

}

int n;

bool spfa()

{

    bool vis[SIZE];

    memset(vis,false,sizeof(vis));

    int d[SIZE];

    int i=n+2;

    while(i--)d[i]= inf;

    d[s]=0;

    vis[s]=true;

    queue<int >Q;

    Q.push(s);

    pre[s]=-1;

    while(!Q.empty())

    {

        int u=Q.front();

        Q.pop();

        vis[u]=false;

		

        for(int i=head[u];i!=-1;i=edge[i].next)

        {

            if(edge[i].f>0&&d[u]+edge[i].w<d[edge[i].t])

            {

                d[edge[i].t]=d[u]+edge[i].w;

                pre[edge[i].t]=i;

                if(!vis[edge[i].t])

                {

                    Q.push(edge[i].t);

                    vis[edge[i].t]=true;

                }

            }

        }

    }

    if(d[t]==inf)

		return false;

    return true;

}   

void solve()

{

	for(int i=pre[t];i!=-1;i=pre[edge[i].s])

	{

		edge[i].f-=1;

		edge[i^1].f+=1;

		mincost+=edge[i].w;

	}

}

int main()

{

	int m,cases=1;

    while(scanf("%d%d",&n,&m),(n||m))

	{

		s=0;t=n+1;

		tot=0;

		mincost=0;

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

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

		{

			int a,b,c;

			scanf("%d%d%d",&a,&b,&c);

			a++,b++;

			addedge(a,b,c,1);

			addedge(b,a,c,1);

		}

		addedge(s,1,0,2);

		addedge(n,t,0,2);

		while(spfa())

		{

			solve();

		}

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

	}

    return 0;

}

 

从起点走到终点，再从终点走到起点，不能有重复的路径

不能单纯的求最短路径两遍，因为第一次选的点会影响第二次走最短路的选择

因为每条边只能选一次，所以给每条边一个容量1，即只能流一次，费用为路径的长度

然后利用最小费用流来求解