POJ 3469 Dual Core CPU 网络流

转化为最小割，dinic

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>

using namespace std;

const int maxn=20000+5;
const int inf=0x3f3f3f3f;
const int s=0;
int t;

inline int min(const int x,const int y)
{
    return x<y?x:y;
}

struct Edge
{
    int to,cap,rev;
};
vector<Edge>edge[maxn];
int level[maxn];
int iter[maxn];

void addedge(int from,int to,int cap)
{
    edge[from].push_back((Edge){to,cap,edge[to].size()});
    edge[to].push_back((Edge){from,0,edge[from].size()-1});
}

void build_graph(int n,int m)
{
    t=n+1;
    for(int i=0;i<=t;i++)
    {
        edge[i].clear();
    }
    int u,v,w;
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&u,&v);
        addedge(i,t,u);
        addedge(s,i,v);
    }
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        addedge(u,v,w);
        addedge(v,u,w);
    }
}

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

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

int max_flow()
{
    int ret=0;
    while(1)
    {
        bfs();
        if(level[t]<0)
            return ret;
        memset(iter,0,sizeof iter);
        int f;
        while(f=dfs(s,inf))
        {
            ret+=f;
        }
    }
}

int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        build_graph(n, m);
        printf("%d
",max_flow());
    }
    return 0;
}