最大流poj1273

裸题：注意边可能重复；

代码如下：

#include<stdio.h>
#include<string.h>
#include<queue>
#define maxn 202
int map[maxn][maxn];
int vis[maxn];
int pre[maxn];
bool bfs(int n)
{
    memset(vis,0,sizeof(vis));
    std::queue<int>q;
    q.push(1);
    vis[1]=0;
    while(!q.empty())
    {
        int x=q.front(); q.pop();
        for(int i=1;i<=n;i++)
        {
            if(!vis[i]&&map[x][i])
            {
                vis[i]=1;
                pre[i]=x;
                if(i==n) return true;
                q.push(i);
            }
        }
    }
    return false;
}
int EK(int n)
{
    int ret=0;
    while(bfs(n))
    {
        int i=n,max=0x7fffffff;
        while(i!=1)
        {
            if(max>map[pre[i]][i]) max=map[pre[i]][i];
            i=pre[i];
        }
        i=n;
        while(i!=1)
        {
            map[pre[i]][i]-=max;
            map[i][pre[i]]+=max;
            i=pre[i];
        }
        ret+=max;
    }
    return ret;
}
int main()
{
    //freopen("Input.txt","r",stdin);
    int ncase,n;
    while(~scanf("%d%d",&ncase,&n))
    {
        int a,b,val;
        memset(map,0,sizeof(map));
        while(ncase--)
        {
            scanf("%d%d%d",&a,&b,&val);
            map[a][b]+=val;
        }
        int ret=EK(n);
        printf("%d\n",ret);
    }
}

#include<stdio.h>
#include<queue>
#include<string.h>
using namespace std;
#define maxn 202
int map[maxn][maxn];
int h[maxn];
int bfs(int n)
{
    int u,i;
    memset(h,0,sizeof(h));
    queue<int>q;
    q.push(1);
    h[1]=1;
    while(!q.empty())
    {
        u=q.front();
        q.pop();
        for(i=1;i<=n;i++)
            if(!h[i]&&map[u][i])
            {
                h[i]=h[u]+1;
                q.push(i);
            }
    }
    return h[n]!=0;
}
int MIN(int a,int b) { return a>b?b:a;}
int dfs(int n,int u,int ff)
{
    int i,z;
    int tt=ff;
    if(u==n) return ff;
    for(i=1;i<=n&&tt;i++)
       if(h[i]==h[u]+1&&map[u][i]>0)
       {
           z=dfs(n,i,MIN(tt,map[u][i]));
           map[u][i]-=z;
           map[i][u]+=z;
           tt-=z;
       }
    return ff-tt;
}
int main()
{
    int m,n;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        int a,b,c;
        memset(map,0,sizeof(map));
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&c);
            map[a][b]+=c;
        }
        int ret=0;
        while(bfs(n))
          ret+=dfs(n,1,0x7fffffff);
        printf("%d\n",ret);
    }
    return 0;
}

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
#define INF 0x7fffffff
#define maxn 205
struct Edge
{
       int v,f,next;
}e[2*maxn];
bool visit[maxn];
int level[maxn],head[maxn];
int s=1,t,size;
bool BFS()
{
     memset(visit,0,sizeof(visit));
     memset(level,0,sizeof(level));
     int v,i;
     queue<int>q;
     q.push(s);
     level[s]=1;
     while(!q.empty())
     {
            int u=q.front();q.pop();
            if(u==t) return true;
            for(i=head[u]; i!=-1; i=e[i].next)
            {
                 v=e[i].v;
                 if(!level[v]&&e[i].f)
                 {
                     level[v]=level[u]+1;
                     q.push(v);
                 }
            }
     }
    return false;
}
void AddEdge(int a,int b,int c)
{
     e[size].v=b;
     e[size].f=c;
     e[size].next=head[a];
     head[a]=size++;
}
int DFS(int u,int mimf)
{
    if(u==t) return mimf;
    int ret,f,i;
    ret=0;
    for(i=head[u];i!=-1;i=e[i].next)
    {
         if( e[i].f&&level[e[i].v]==level[u]+1)
         {
             f=DFS(e[i].v,min(mimf-ret,e[i].f));
             e[i].f-=f;
             e[i^1].f+=f;
             ret+=f;
             if( mimf==ret) return ret;
         }
    }
    return ret;
}
int main()
{
    int n,m,a,b,c,ret;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
           size=0;
           s=1; t=n;
           memset(e,0,sizeof(e));
           memset(head,-1,sizeof(head));
           while( m--)
           {
                  scanf("%d%d%d",&a,&b,&c);
                  AddEdge(a,b,c);
                  AddEdge(b,a,0);
           }
           ret=0;
           while(BFS())
           {
                ret+=DFS(s,INF);
           }
           printf("%d\n",ret);
    }
    return 0;
}