计蒜客 31447 - Fantastic Graph - [有源汇上下界可行流][2018ICPC沈阳网络预赛F题]

题目链接：https://nanti.jisuanke.com/t/31447

"Oh, There is a bipartite graph.""Make it Fantastic."

X wants to check whether a bipartite graph is a fantastic graph. He has two fantastic numbers, and he wants to let all the degrees to between the two boundaries. You can pick up several edges from the current graph and try to make the degrees of every point to between the two boundaries. If you pick one edge, the degrees of two end points will both increase by one. Can you help X to check whether it is possible to fix the graph?

Input

There are at most 3030 test cases.

For each test case,The first line contains three integers $N$ the number of left part graph vertices, $M$ the number of right part graph vertices, and $K$ the number of edges ($1 \le N \le 2000,0 \le M \le 2000,0 \le K \le 6000$). Vertices are numbered from $1$ to $N$.

The second line contains two numbers L, RL,R ($0 \le L \le R \le 300$). The two fantastic numbers.

Then $K$ lines follows, each line containing two numbers $U, V (1 \le U \le N,1 \le V \le M)$. It shows that there is a directed edge from $U$-th spot to $V$-th spot.

Note. There may be multiple edges between two vertices.

Output

One line containing a sentence. Begin with the case number. If it is possible to pick some edges to make the graph fantastic, output "Yes" (without quote), else output "No" (without quote).

样例输出

3 3 7
2 3
1 2
2 3
1 3
3 2
3 3
2 1
2 1
3 3 7
3 4
1 2
2 3
1 3
3 2
3 3
2 1
2 1

样例输入

Case 1: Yes
Case 2: No

题意：

给出一个二分图，左侧 $n$ 个节点，右侧 $m$ 个节点，之间用 $k$ 条边相连接，现在初始化每个节点的权值为 $0$，

现在你可以挑选若干条边，使得这条边的两个端点上的权值各加一，对于给出的区间 $[L,R]$，问是否能够使得所有节点的权值在区间内。

题解：

添加源点 $s$，汇点 $t$， 对于原二分图中的 $k$ 条边，定义流量上下界为 $[0,1]$，

$s$ 对于左侧的 $N$个点都连边，流量为 $[L,R]$；右侧的 $M$ 个点对 $t$ 都连边，流量为 $[L,R]$。

问题就变成有源汇上下界可行流问题（根据官方题解）。

若我们从汇点 $t$ 向源点 $s$ 连一条边，令其容量上下界为 $[0,INF]$，则转化为无源汇上下界可行流问题，

如何求解无源汇上下界可行流问题？ZOJ2314：https://www.cnblogs.com/dilthey/p/9622051.html

AC代码：

#include<bits/stdc++.h>
using namespace std;
const int INF=0x3f3f3f3f;
const int maxn=;
const int maxk=;

struct Edge{
    int u,v,c,f;
};
struct Dinic
{
    int s,t; //源点汇点
    vector<Edge> E;
    vector<int> G[maxn];
    void init(int l,int r)
    {
        E.clear();
        for(int i=l;i<=r;i++) G[i].clear();
    }
    void addedge(int from,int to,int cap)
    {
        E.push_back((Edge){from,to,cap,});
        E.push_back((Edge){to,from,,});
        G[from].push_back(E.size()-);
        G[to].push_back(E.size()-);
    }
    int dist[maxn],vis[maxn];
    queue<int> q;
    bool bfs() //在残量网络上构造分层图
    {
        memset(vis,,sizeof(vis));
        while(!q.empty()) q.pop();
        q.push(s);
        dist[s]=;
        vis[s]=;
        while(!q.empty())
        {
            int now=q.front(); q.pop();
            for(int i=;i<G[now].size();i++)
            {
                Edge& e=E[G[now][i]]; int nxt=e.v;
                if(!vis[nxt] && e.c>e.f)
                {
                    dist[nxt]=dist[now]+;
                    q.push(nxt);
                    vis[nxt]=;
                }
            }
        }
        return vis[t];
    }
    int dfs(int now,int flow)
    {
        if(now==t || flow==) return flow;
        int rest=flow,k;
        for(int i=;rest> && i<G[now].size();i++)
        {
            Edge &e=E[G[now][i]]; int nxt=e.v;
            if(e.c>e.f && dist[nxt]==dist[now]+)
            {
                k=dfs(nxt,min(rest,e.c-e.f));
                if(!k) dist[nxt]=; //剪枝，去掉增广完毕的点
                e.f+=k; E[G[now][i]^].f-=k;
                rest-=k;
            }
        }
        return flow-rest;
    }
    int mf; //存储最大流
    int maxflow()
    {
        mf=;
        int flow=;
        while(bfs()) while(flow=dfs(s,INF)) mf+=flow;
        return mf;
    }
}dc;

int n,m,k;
int L,R;
int M[maxn];
int main()
{
    int kase=;
    while(cin>>n>>m>>k)
    {

        cin>>L>>R;

        dc.init(,n+m+);
        dc.s=n+m+;
        dc.t=n+m+;

        int S=,T=n+m+;
        for(int u,v,i=;i<=k;i++)
        {
            scanf("%d%d",&u,&v);
            dc.addedge(u,n+v,-);
        }
        memset(M,,sizeof(M));
        for(int i=;i<=n;i++)
        {
            dc.addedge(S,i,R-L);
            M[i]+=L;
            M[S]-=L;
        }
        for(int i=;i<=m;i++)
        {
            dc.addedge(n+i,T,R-L);
            M[T]+=L;
            M[n+i]-=L;
        }
        dc.addedge(T,S,INF-);

        int tmp=;
        for(int i=;i<=n+m+;i++)
        {
            if(M[i]>=) dc.addedge(dc.s,i,M[i]),tmp+=M[i];
            else dc.addedge(i,dc.t,-M[i]);
        }

        printf("Case %d: ",++kase);
        if(dc.maxflow()==tmp) printf("Yes\n");
        else printf("No\n");
    }
}

相当于添加了两次源汇点，第一次是为了建起一个有源汇的网络，然后再把它变成无源汇的，再添加源汇点为了求是否有可行流。