【无源汇有上下界可行流】ACdream1211-Reactor Cooling

【题意】

给出一些边流量的上界和下界，问能否循环流通。

【思路】

黄学长讲得很清楚，直接贴过来：

上界用ci表示，下界用bi表示。

下界是必须流满的，那么对于每一条边，去掉下界后，其自由流为ci– bi。

主要思想：每一个点流进来的流=流出去的流

对于每一个点i，令

Mi= sum(i点所有流进来的下界流)– sum(i点所有流出去的下界流)

*PO主注：下界流指的就是输入的下界

如果Mi大于0，代表此点必须还要流出去Mi的自由流，那么我们从源点连一条Mi的边到该点。

如果Mi小于0，代表此点必须还要流进来Mi的自由流，那么我们从该点连一条Mi的边到汇点。

如果求S->T的最大流，看是否满流(S的相邻边都流满)。

满流则有解，否则无解。

【错误点】

忘记清空vector和in数组了orz

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#define target n+1
using namespace std;
const int MAXM=100000+5;
const int MAXN=200+5; 
const int INF=0x7fffffff;
struct node
{
    int to,pos,cap;
}; 
vector<node> E[MAXM];
int n,m,sum=0;
int in[MAXN];
int dist[MAXN];
int low[MAXM];//记录下每条边的下界 
int edge[MAXM][2];

void addedge(int u,int v,int c)
{
    E[u].push_back((node){v,E[v].size(),c});
    E[v].push_back((node){u,E[u].size()-1,0});
}

void init()
{
    memset(in,0,sizeof(in));//不要忘记了要清空in 
    for (int i=0;i<target;i++) E[i].clear();//不要忘记了要清空vector 
    int u,v,c;
    for (int i=0;i<m;i++) 
    {
        scanf("%d%d%d%d",&u,&v,&low[i],&c);
        in[u]-=low[i];
        in[v]+=low[i];
        addedge(u,v,c-low[i]);
        edge[i][0]=v;
        edge[i][1]=E[v].size()-1;
    }
    sum=0;
    for (int i=1;i<=n;i++)
    {
        if (in[i]>0) 
        {
            addedge(0,i,in[i]);
            sum+=in[i];
        }
        else if (in[i]<0) addedge(i,target,-in[i]);
    }
}

int bfs()
{
    memset(dist,-1,sizeof(dist));
    queue<int> que;
    while (!que.empty()) que.pop();
    que.push(0);
    dist[0]=0;
    
    while (!que.empty()) 
    {
        int head=que.front();
        que.pop();
        for (int i=0; i<E[head].size(); i++) 
        {
            node &tmp=E[head][i];
            if (dist[tmp.to]==-1 && tmp.cap>0)
            {    
                dist[tmp.to]=dist[head]+1;
                que.push(tmp.to);
                if (tmp.to==target) return 1;
            }
        }
    }
    return 0;
}

int dfs(int s,int e,int maxflow)
{
    int ret=0;
    if (s==e || maxflow==0) return maxflow;
    for (int i=0;i<E[s].size();i++)
    {
        node &tmp=E[s][i];
        if (dist[tmp.to]==dist[s]+1 && tmp.cap>0)
        {
            int delta=dfs(tmp.to,e,min(maxflow,tmp.cap));
            if (delta>0)
            {
                ret+=delta;
                tmp.cap-=delta;
                E[tmp.to][tmp.pos].cap+=delta;
                maxflow-=delta;
            }
        }
    }
    return ret;
}

void dinic()
{
    int flow=0;
    while (bfs())
    {
        int f=dfs(0,target,INF);
        if (f>0)
            flow+=f;
        else break;
    }
    if (flow!=sum) cout<<"NO"<<endl;
    else
    {
        cout<<"YES"<<endl; 
        for (int i=0;i<m;i++) cout<<low[i]+E[edge[i][0]][edge[i][1]].cap<<endl;
    }
}

int main()
{
    while (~(scanf("%d%d",&n,&m)))
    {
        init();
        dinic(); 
    }
    return 0;
}