网络流专题

最新推荐文章于 2022-04-09 18:45:57 发布
最新推荐文章于 2022-04-09 18:45:57 发布
阅读量476 收藏 1
点赞数
分类专栏： 网络流 # 系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nike0good/article/details/52141487
版权

Chips Challenge

填坑

Perspective

一个小组若干球队，已知每个球队已经赢的场次，组内的场次和组间的场次，问1队是否能在组内获胜场次最多？
考虑让1队所有场次获胜，其他队组间场次落败。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<iostream>
#include<cmath>
#include<cctype>
#include<ctime>
#include<iomanip> 
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<map>
#include<sstream>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=pre[x];p;p=next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,0x3f3f3f3f,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (1e16)
#define F (1000000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case #%d: %I64d\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return ((a-b)%F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
#define MAXN (5100) 
#define MAXM (2*70000)
class Max_flow  //dinic+当前弧优化   
{    
public:    
    int n,s,t;    
    int q[MAXN],size;    
    int edge[MAXM],next[MAXM],pre[MAXN];
    ll weight[MAXM];    
    void addedge(int u,int v,ll w)      
    {      
        edge[++size]=v;      
        weight[size]=w;      
        next[size]=pre[u];      
        pre[u]=size;      
    }      
    void addedge2(int u,int v,ll w){addedge(u,v,w),addedge(v,u,0);}     
    bool b[MAXN];    
    ll d[MAXN];    
    bool SPFA(int s,int t)      
    {      
        For(i,n) d[i]=INF;    
        MEM(b)    
        d[q[1]=s]=0;b[s]=1;      
        int head=1,tail=1;      
        while (head<=tail)      
        {      
            int now=q[head++];      
            Forp(now)      
            {      
                int &v=edge[p];      
                if (weight[p]&&!b[v])      
                {      
                    d[v]=d[now]+1;      
                    b[v]=1,q[++tail]=v;      
                }      
            }          
        }      
        return b[t];      
    }     
    int iter[MAXN];  
    int dfs(int x,ll f)  
    {  
        if (x==t) return f;  
        Forpiter(x)  
        {  
            int v=edge[p];  
            if (weight[p]&&d[x]<d[v])  
            {  
                  int nowflow=dfs(v,min(weight[p],f));  
                  if (nowflow)  
                  {  
                    weight[p]-=nowflow;  
                    weight[p^1]+=nowflow;  
                    return nowflow;  
                  }  
            }  
        }  
        return 0;  
    }  
    ll max_flow(int s,int t)  
    {  
        ll flow=0;  
        while(SPFA(s,t))  
        {  
            For(i,n) iter[i]=pre[i];  
            ll f;  
            while (f=dfs(s,INF))  
                flow+=f;   
        }  
        return flow;  
    }   
    void mem(int n,int s,int t)    
    {    
        (*this).n=n;  
        (*this).t=t;    
        (*this).s=s;    

        size=1;    
        MEM(pre)   
    }    
}S; 
int n;
int w[MAXN],r[MAXN];
int main()
{
//  freopen("B.in","r",stdin);
//  freopen(".out","w",stdout);

    while(cin>>n) {
        For(i,n) w[i]=read();
        For(i,n) r[i]=read();
        int s=n+n*n+1,t=s+1;
        S.mem(t,s,t);
        int siz=0;
        int ma=w[1]+r[1];
        Fork(i,2,n) {
            if(w[i]>ma) {puts("NO"); return 0;      }
            S.addedge2(s,i,ma-w[i]);
        }
        int c=0;
        For(i,n) For(j,n) {
            int p=read();
            if (p&&i<j&&i!=1) {
                siz++; c+=p;
                S.addedge2(i,n+siz,p);
                S.addedge2(j,n+siz,p);
                S.addedge2(n+siz,t,p);
            }
        }
        if (c==S.max_flow(s,t)) puts("YES"); else puts("NO");
    }


    return 0;
}

Sightseeing tour

混合图欧拉路径存在判断：
先把边随机定向，这时所有点入度-出度=2k,然后考虑修改边的方向使入度-出度=0
令 di 为入度-出度
如果存在 di 为奇数则无解
建图：S向 di >0的点连边，容量 di/2 ， di <0的点向T连边，容量 −di/2 ,对没定向的边，建立 u→v 的边，容量1

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<iostream>
#include<cmath>
#include<cctype>
#include<ctime>
#include<iomanip> 
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<map>
#include<sstream>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=pre[x];p;p=next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,0x3f3f3f3f,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (1000000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case #%d: %I64d\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return ((a-b)%F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
#define MAXn (200+10)
#define MAXN (1000) 
#define MAXM (1000000)
class Max_flow  //dinic+当前弧优化   
{    
public:    
    int n,s,t;    
    int q[MAXN];    
    int edge[MAXM],next[MAXM],pre[MAXN],weight[MAXM],size;    
    void addedge(int u,int v,int w)      
    {      
        edge[++size]=v;      
        weight[size]=w;      
        next[size]=pre[u];      
        pre[u]=size;      
    }      
    void addedge2(int u,int v,int w){addedge(u,v,w),addedge(v,u,0);}     
    bool b[MAXN];    
    int d[MAXN];    
    bool SPFA(int s,int t)      
    {      
        For(i,n) d[i]=INF;    
        MEM(b)    
        d[q[1]=s]=0;b[s]=1;      
        int head=1,tail=1;      
        while (head<=tail)      
        {      
            int now=q[head++];      
            Forp(now)      
            {      
                int &v=edge[p];      
                if (weight[p]&&!b[v])      
                {      
                    d[v]=d[now]+1;      
                    b[v]=1,q[++tail]=v;      
                }      
            }          
        }      
        return b[t];      
    }     
    int iter[MAXN];  
    int dfs(int x,int f)  
    {  
        if (x==t) return f;  
        Forpiter(x)  
        {  
            int v=edge[p];  
            if (weight[p]&&d[x]<d[v])  
            {  
                  int nowflow=dfs(v,min(weight[p],f));  
                  if (nowflow)  
                  {  
                    weight[p]-=nowflow;  
                    weight[p^1]+=nowflow;  
                    return nowflow;  
                  }  
            }  
        }  
        return 0;  
    }  
    int max_flow(int s,int t)  
    {  
        int flow=0;  
        while(SPFA(s,t))  
        {  
            For(i,n) iter[i]=pre[i];  
            int f;  
            while (f=dfs(s,INF))  
                flow+=f;   
        }  
        return flow;  
    }   
    void mem(int n,int s,int t)    
    {    
        (*this).n=n;  
        (*this).t=t;    
        (*this).s=s;    

        size=1;    
        MEM(pre)   
    }    
}S; 
int n,m;   
int d[MAXN];
int edge[MAXM][2],siz;
bool check() {
    For(i,n) if (d[i]%2) {
        return 0;       
    }
    int s=n+1,t=s+1;
    S.mem(t,s,t);
    int c=0,c2=0;
    For(i,n) if (d[i]>0) S.addedge2(i,t,d[i]/2),c+=d[i]/2;
    else S.addedge2(s,i,-d[i]/2),c2-=d[i]/2;
    For(i,siz) S.addedge2(edge[i][0],edge[i][1],1);
    int fl=S.max_flow(s,t);
    return c==fl && c==c2;
} 
int main()
{
//  freopen("D.in","r",stdin);
//  freopen(".out","w",stdout);
    int T=read();
    while(T--) {
        n=read(),m=read();
        MEM(d)
        siz=0;
        For(i,m) {
            int u=read(),v=read(),w=read();
            d[v]++,d[u]--;
            if (!w) edge[++siz][0]=u,edge[siz][1]=v;  
        }
        if(check()) puts("possible"); else {
            puts("impossible");
        } 
    }
    return 0;
}

Ombrophobic Bovines

二分网络流

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<iostream>
#include<cmath>
#include<cctype>
#include<ctime>
#include<iomanip> 
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<map>
#include<sstream>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=pre[x];p;p=next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,0x3f3f3f3f,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (1000000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case #%d: %I64d\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return ((a-b)%F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
#define MAXn (200+10)
#define MAXN (1000) 
#define MAXM (1000000)
class Max_flow  //dinic+当前弧优化   
{    
public:    
    int n,s,t;    
    int q[MAXN];    
    int edge[MAXM],next[MAXM],pre[MAXN],weight[MAXM],size;    
    void addedge(int u,int v,int w)      
    {      
        edge[++size]=v;      
        weight[size]=w;      
        next[size]=pre[u];      
        pre[u]=size;      
    }      
    void addedge2(int u,int v,int w){addedge(u,v,w),addedge(v,u,0);}     
    bool b[MAXN];    
    int d[MAXN];    
    bool SPFA(int s,int t)      
    {      
        For(i,n) d[i]=INF;    
        MEM(b)    
        d[q[1]=s]=0;b[s]=1;      
        int head=1,tail=1;      
        while (head<=tail)      
        {      
            int now=q[head++];      
            Forp(now)      
            {      
                int &v=edge[p];      
                if (weight[p]&&!b[v])      
                {      
                    d[v]=d[now]+1;      
                    b[v]=1,q[++tail]=v;      
                }      
            }          
        }      
        return b[t];      
    }     
    int iter[MAXN];  
    int dfs(int x,int f)  
    {  
        if (x==t) return f;  
        Forpiter(x)  
        {  
            int v=edge[p];  
            if (weight[p]&&d[x]<d[v])  
            {  
                  int nowflow=dfs(v,min(weight[p],f));  
                  if (nowflow)  
                  {  
                    weight[p]-=nowflow;  
                    weight[p^1]+=nowflow;  
                    return nowflow;  
                  }  
            }  
        }  
        return 0;  
    }  
    int max_flow(int s,int t)  
    {  
        int flow=0;  
        while(SPFA(s,t))  
        {  
            For(i,n) iter[i]=pre[i];  
            int f;  
            while (f=dfs(s,INF))  
                flow+=f;   
        }  
        return flow;  
    }   
    void mem(int n,int s,int t)    
    {    
        (*this).n=n;  
        (*this).t=t;    
        (*this).s=s;    

        size=1;    
        MEM(pre)   
    }    
}S; 
int n,m;   
int a[MAXN],v[MAXN],c=0;
ll f[MAXN][MAXN];
bool check(ll p) {
    int s=2*n+1,t=s+1;
    S.mem(2*n+2,s,t);
    For(i,n) For(j,n) if (f[i][j]<=p) S.addedge2(i,n+j,INF);
    For(i,n) S.addedge2(s,i,a[i]),S.addedge2(n+i,t,v[i]);
    int fl=S.max_flow(s,t); 
    return fl==c; 
} 
int main()
{
//  freopen("E.in","r",stdin);
//  freopen(".out","w",stdout);

    n=read(),m=read();
    For(i,n) a[i]=read(),v[i]=read();
    For(i,n) c+=a[i];
    For(i,n) For(j,n) f[i][j]=1e17;
    For(i,n) f[i][i]=0;
    For(i,m) {
        int u=read(),v=read(),w=read();
        f[v][u]=f[u][v]=min(f[u][v],(ll)w);
    }
    For(k,n) For(i,n) For(j,n) 
        f[i][j]=min(f[i][j],f[i][k]+f[k][j]);   


    ll l=0,r=1e17,ans=r;
    while(l<=r) {
        ll m=(l+r)/2;
        if (check(m)) ans=m,r=m-1;else l=m+1;
    }
    if (ans==1e17) puts("-1"); else cout<<ans<<endl;    

    return 0;
}

The Maximum Number of Strong Kings

贪心，判断胜场数最多的那几个人是否能同时成王

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<iostream>
#include<cmath>
#include<cctype>
#include<ctime>
#include<iomanip> 
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<map>
#include<sstream>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=pre[x];p;p=next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,0x3f3f3f3f,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (1e16)
#define F (1000000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case #%d: %I64d\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return ((a-b)%F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
#define MAXN (20000) 
#define MAXM (2*70000)
class Max_flow  //dinic+当前弧优化   
{    
public:    
    int n,s,t;    
    int q[MAXN],size;    
    int edge[MAXM],next[MAXM],pre[MAXN];
    ll weight[MAXM];    
    void addedge(int u,int v,ll w)      
    {      
        edge[++size]=v;      
        weight[size]=w;      
        next[size]=pre[u];      
        pre[u]=size;      
    }      
    void addedge2(int u,int v,ll w){addedge(u,v,w),addedge(v,u,0);}     
    bool b[MAXN];    
    ll d[MAXN];    
    bool SPFA(int s,int t)      
    {      
        For(i,n) d[i]=INF;    
        MEM(b)    
        d[q[1]=s]=0;b[s]=1;      
        int head=1,tail=1;      
        while (head<=tail)      
        {      
            int now=q[head++];      
            Forp(now)      
            {      
                int &v=edge[p];      
                if (weight[p]&&!b[v])      
                {      
                    d[v]=d[now]+1;      
                    b[v]=1,q[++tail]=v;      
                }      
            }          
        }      
        return b[t];      
    }     
    int iter[MAXN];  
    int dfs(int x,ll f)  
    {  
        if (x==t) return f;  
        Forpiter(x)  
        {  
            int v=edge[p];  
            if (weight[p]&&d[x]<d[v])  
            {  
                  int nowflow=dfs(v,min(weight[p],f));  
                  if (nowflow)  
                  {  
                    weight[p]-=nowflow;  
                    weight[p^1]+=nowflow;  
                    return nowflow;  
                  }  
            }  
        }  
        return 0;  
    }  
    ll max_flow(int s,int t)  
    {  
        ll flow=0;  
        while(SPFA(s,t))  
        {  
            For(i,n) iter[i]=pre[i];  
            ll f;  
            while (f=dfs(s,INF))  
                flow+=f;   
        }  
        return flow;  
    }   
    void mem(int n,int s,int t)    
    {    
        (*this).n=n;  
        (*this).t=t;    
        (*this).s=s;    

        size=1;    
        MEM(pre)   
    }    
}S; 
int n,m;
char s[10000];
int N,st,t;
int a[100];
bool check(int p) {
    int N=n+n*(n-1)/2,s=N+1,t=s+1;
    S.mem(t,s,t);
    For(i,n) S.addedge2(s,i,a[i]);
    int sz=n;
    For(i,n) Fork(j,i+1,n) {
        ++sz;
        if (a[i]<a[j] && n-p+1<=i) S.addedge2(i,sz,1);
        else S.addedge2(i,sz,1),S.addedge2(j,sz,1);
        S.addedge2(sz,t,1);
    }
    return n*(n-1)/2==S.max_flow(s,t);
}
int calc() {
    RepD(i,n) if (check(i)) return i;
    return 0;
}
int main()
{
//  freopen("F.in","r",stdin);
//  freopen(".out","w",stdout);
    int T;
    scanf("%d\n",&T);
    while(T--) {
        cin.getline(s,100);
        stringstream ss;
        ss<<s;
        n=0;
        while(!ss.eof()) {
            int p;
            if (ss>>p) a[++n]=p; else break;

        }
        cout<<calc()<<endl;

    }
    return 0;
}

Smart Network Administrator

二分网络流

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<iostream>
#include<cmath>
#include<cctype>
#include<ctime>
#include<iomanip> 
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<map>
#include<sstream>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=pre[x];p;p=next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,0x3f3f3f3f,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (1000000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case #%d: %I64d\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return ((a-b)%F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
#define MAXn (500+10)
#define MAXN (500+10) 
#define MAXM (1000000)
class Max_flow  //dinic+当前弧优化   
{    
public:    
    int n,s,t;    
    int q[MAXN];    
    int edge[MAXM],next[MAXM],pre[MAXN],weight[MAXM],size;    
    void addedge(int u,int v,int w)      
    {      
        edge[++size]=v;      
        weight[size]=w;      
        next[size]=pre[u];      
        pre[u]=size;      
    }      
    void addedge2(int u,int v,int w){addedge(u,v,w),addedge(v,u,0);}     
    bool b[MAXN];    
    int d[MAXN];    
    bool SPFA(int s,int t)      
    {      
        For(i,n) d[i]=INF;    
        MEM(b)    
        d[q[1]=s]=0;b[s]=1;      
        int head=1,tail=1;      
        while (head<=tail)      
        {      
            int now=q[head++];      
            Forp(now)      
            {      
                int &v=edge[p];      
                if (weight[p]&&!b[v])      
                {      
                    d[v]=d[now]+1;      
                    b[v]=1,q[++tail]=v;      
                }      
            }          
        }      
        return b[t];      
    }     
    int iter[MAXN];  
    int dfs(int x,int f)  
    {  
        if (x==t) return f;  
        Forpiter(x)  
        {  
            int v=edge[p];  
            if (weight[p]&&d[x]<d[v])  
            {  
                  int nowflow=dfs(v,min(weight[p],f));  
                  if (nowflow)  
                  {  
                    weight[p]-=nowflow;  
                    weight[p^1]+=nowflow;  
                    return nowflow;  
                  }  
            }  
        }  
        return 0;  
    }  
    int max_flow(int s,int t)  
    {  
        int flow=0;  
        while(SPFA(s,t))  
        {  
            For(i,n) iter[i]=pre[i];  
            int f;  
            while (f=dfs(s,INF))  
                flow+=f;   
        }  
        return flow;  
    }   
    void mem(int n,int s,int t)    
    {    
        (*this).n=n;  
        (*this).t=t;    
        (*this).s=s;    

        size=1;    
        MEM(pre)   
    }    
}S; 
int n,m;   
int a[MAXN],c=0,u[MAXM],v[MAXM];
bool check(int p) {
    int s=n+1,t=1;
    S.mem(n+1,s,t);
    For(i,m) S.addedge2(u[i],v[i],p),S.addedge2(v[i],u[i],p);
    For(i,n) if (a[i]) S.addedge2(s,i,1);
    int fl=S.max_flow(s,t); 
    return fl==c; 
}
int main()
{
//  freopen("H.in","r",stdin);
//  freopen(".out","w",stdout);
    int T=read();
    while(T--) { 
        n=read(),m=read(),c=read();
        For(i,n) a[i]=0;
        For(i,c) a[read()]=1;
        For(i,m) {
            u[i]=read(),v[i]=read();
        }

        ll l=0,r=c,ans=r;
        while(l<=r) {
            ll m=(l+r)/2;
            if (check(m)) ans=m,r=m-1;else l=m+1;
        }
        cout<<ans<<endl;    
    } 

    return 0;
}

Intergalactic Map

同计蒜客-http://blog.csdn.net/nike0good/article/details/51870584#菜鸟物流的运输网络

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<vector>
#include<iostream>
#include<cmath>
#include<cctype>
#include<ctime>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=pre[x];p;p=next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=next[p])  
#define Lson (x<<1)
#define Rson ((x<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define MAXN (60111+10)
#define MAXM (1000000)
#define MAXAi (35000)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define eps (1e-3)
long long mul(long long a,long long b){return (a*b)%F;}
long long add(long long a,long long b){return (a+b)%F;}
long long sub(long long a,long long b){return (a-b+(a-b)/F*F+F)%F;}
typedef long long ll;
int nex[MAXN];
class Cost_Flow  
{  
public:  
    int n,s,t;  
    int q[MAXM];  
    int edge[MAXM],next[MAXM],pre[MAXN],weight[MAXM],size;  
    int cost[MAXM],cp[MAXM];  
    void addedge(int u,int v,int w,int c)    
    {    
        edge[++size]=v;    
        weight[size]=cp[size]=w;    
        cost[size]=c;    
        next[size]=pre[u];    
        pre[u]=size;    
    }    
    void addedge2(int u,int v,int w,int c){addedge(u,v,w,c),addedge(v,u,0,-c);}   
    bool b[MAXN];  
    int d[MAXN];  
    int pr[MAXN],ed[MAXN];  
    bool SPFA(int s,int t)    
    {    
        For(i,n) d[i]=INF,b[i]=0; 
        d[q[1]=s]=0;b[s]=1;    
        int head=1,tail=1;    
        while (head<=tail)    
        {    
            int now=q[head++];    
            Forp(now)    
            {    
                int &v=edge[p];    
                if (weight[p]&&d[now]+cost[p]<d[v])    
                {    
                    d[v]=d[now]+cost[p];    
                    if (!b[v]) b[v]=1,q[++tail]=v;    
                    pr[v]=now,ed[v]=p;    
                }    
            }    
            b[now]=0;    
        }    
        return d[t]!=INF;    
    }   
    int totcost;    

    int CostFlow(int s,int t)    
    {    
        int maxflow=0;
        while (SPFA(s,t))    
        {    
            int flow=INF;    
            for(int x=t;x^s;x=pr[x]) {
                flow=min(flow,weight[ed[x]]);
            }
            totcost+=flow*d[t]; 
            maxflow+=flow;   
            for(int x=t;x^s;x=pr[x]) weight[ed[x]]-=flow,weight[ed[x]^1]+=flow;         
        }    
        return maxflow;    
    }    

    void mem(int n,int t)  
    {  
        (*this).n=n;  
        size=1;  
        totcost=0;  
        MEM(pre) MEM(next)   
    }  
}S1;  
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
int n,m,s,mid,t;
int main()
{
//  freopen("I.in","r",stdin);
//  freopen(".out","w",stdout);

    int T2=read();
    while(T2--) {
        n=read();m=read();
        int S=2*n+1,T=S+1;
        S1.mem(T,T);
        s=1,t=3,mid=2;
        Rep(i,m) {
            int u,v;
            scanf("%d%d",&u,&v);
            if (u<1||v<1||u>n||v>n) continue;
            if (u==v) continue;
            S1.addedge2(u+n,v,1,0);
            S1.addedge2(v+n,u,1,0);
        }
        For(i,n) S1.addedge2(i,i+n,1,0);
        S1.addedge2(S,mid+n,2,0);
        S1.addedge2(s+n,T,1,0);
        S1.addedge2(t+n,T,1,0);
        if (S1.CostFlow(S,T)==2) puts("YES");
        else puts("NO");
    }

    return 0;
}

Fast Maximum Flow

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<iostream>
#include<cmath>
#include<cctype>
#include<ctime>
#include<iomanip> 
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<map>
#include<sstream>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=pre[x];p;p=next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,0x3f3f3f3f,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (1e16)
#define F (1000000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define Pr(kcase,ans) printf("Case #%d: %I64d\n",kcase,ans);
#define PRi(a,n) For(i,n-1) cout<<a[i]<<' '; cout<<a[n]<<endl;
#define PRi2D(a,n,m) For(i,n) { \
                        For(j,m-1) cout<<a[i][j]<<' ';\
                        cout<<a[i][m]<<endl; \
                        } 
#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return ((a-b)%F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
#define MAXN (5100) 
#define MAXM (2*70000)
class Max_flow  //dinic+当前弧优化   
{    
public:    
    int n,s,t;    
    int q[MAXN],size;    
    int edge[MAXM],next[MAXM],pre[MAXN];
    ll weight[MAXM];    
    void addedge(int u,int v,ll w)      
    {      
        edge[++size]=v;      
        weight[size]=w;      
        next[size]=pre[u];      
        pre[u]=size;      
    }      
    void addedge2(int u,int v,ll w){addedge(u,v,w),addedge(v,u,0);}     
    bool b[MAXN];    
    ll d[MAXN];    
    bool SPFA(int s,int t)      
    {      
        For(i,n) d[i]=INF;    
        MEM(b)    
        d[q[1]=s]=0;b[s]=1;      
        int head=1,tail=1;      
        while (head<=tail)      
        {      
            int now=q[head++];      
            Forp(now)      
            {      
                int &v=edge[p];      
                if (weight[p]&&!b[v])      
                {      
                    d[v]=d[now]+1;      
                    b[v]=1,q[++tail]=v;      
                }      
            }          
        }      
        return b[t];      
    }     
    int iter[MAXN];  
    int dfs(int x,ll f)  
    {  
        if (x==t) return f;  
        Forpiter(x)  
        {  
            int v=edge[p];  
            if (weight[p]&&d[x]<d[v])  
            {  
                  int nowflow=dfs(v,min(weight[p],f));  
                  if (nowflow)  
                  {  
                    weight[p]-=nowflow;  
                    weight[p^1]+=nowflow;  
                    return nowflow;  
                  }  
            }  
        }  
        return 0;  
    }  
    ll max_flow(int s,int t)  
    {  
        ll flow=0;  
        while(SPFA(s,t))  
        {  
            For(i,n) iter[i]=pre[i];  
            ll f;  
            while (f=dfs(s,INF))  
                flow+=f;   
        }  
        return flow;  
    }   
    void mem(int n,int s,int t)    
    {    
        (*this).n=n;  
        (*this).t=t;    
        (*this).s=s;    

        size=1;    
        MEM(pre)   
    }    
}S; 
int n,m;   
int main()
{
//  freopen("J.in","r",stdin);
//  freopen(".out","w",stdout);
    n=read(),m=read();
    S.mem(n,1,n);
    For(i,m) {
        int u=read(),v=read(),w=read();
        S.addedge2(v,u,w);
        S.addedge2(u,v,w);
    }
    cout<<S.max_flow(1,n)<<endl;
    return 0;
}
nike0good
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2007冬令营-专题网络流算法
05-24
图论算法 ---最大流问题 网络流算法
acm最短路与网络流
08-06
暑期集训专题---最短路与网络流，对解题很有帮助
网络流专题（最大流与费用流）例题总结
qq_35975367的博客
01-15 2719
文章目录NC 106056 poj1459 Power Network题目大意：题解：NC213817 [网络流24题]最小路径覆盖问题题目：题解：例2：NC213818 [网络流24题]魔术球问题题目：题解：方法2：NC 213820 [网络流24题]最长递增子序列问题题目:题解：NC19939 [CQOI2015]网络吞吐量题目： NC 106056 poj1459 Power Network 题目大意： 总共有n个节点，其中有发电站np个、用户nc个和调度器n-np-nc个三种节点，每个发电站有一个最
网络流专题练习题
天羽屠龙舞
07-28 1304
转自夏天的风：http://blog.csdn.net/shahdza/article/details/7779537 【HDU】 1532 Drainage Ditches(入门)    [最大流] 3549 Flow Problem(入门)    [最大流] 3572 Task Schedule(基础)    [最大流]任务分配,判断满流 2732 Leapin' Liza
【网络流专题】
Evil.livE
10-24 1121
<br />最近做了两道网络流神题，里面用了几个非常巧妙的技巧，在今后很多题目中都可以使用得到。<br />第一题：WC2007石头剪刀布<br />      这题是网络流，简直太难想到了，总之这道题有几个非常巧妙的转化。<br />      首先是补集转化，我要统计一个完全有向图中的三元环的个数，就等于所有环的个数-非三元环的个数。非三元环的个数怎么统计呢？观察三元环的特点，发现一个三元环必然有一个点在这个环中入度为二（出度为二），由此我们便可以得到一个计算三元环的公式（设d[i]为i的入度）<br
网络流专题训练材料收集
___简言
07-24 2192
我这次上传2本书，还有我写的一个简短的paper。分别是：《Network Flows - Theory, Algorithms, And Applications》包括习题解答《Combinatorial optimization:networks and matroids》"
专题·网络流【资源集合
樱狸✨愿携清风归来处
02-02 1690
首先是入门：https://oi-wiki.org/graph/flow/ 各个专题：最大流，最小割，费用流【最大和最小差不多，上下界网络流 建模技巧总汇：https://www.cnblogs.com/victorique/p/8560656.html ...
图论--网络流--费用流--POJ 2156 Minimum Cost
日拱一卒,功不唐捐
11-10 2577
Description Dearboy, a goods victualer, now comes to a big problem, and he needs your help. In his sale area there are N shopkeepers (marked from 1 to N) which stocks goods from him.Dearboy has M sup...
计算机网络专题
qq_43589672的博客
04-09 2641
复试常见计算机网络问题
Java IO流专题
weixin_46015018的博客
03-20 1653
一、IO流是什么？ 1、IO流概念 IO（Input Output）用于实现对数据的输入与输出操作，Java把不同的输入/输出源（键盘、文件、网络等）抽象表述为流（Stream），简单来说就是对于数据的输入/输出操作以流的方式进行。流是从起源到接收的有序数据，有了它程序就可以采用同一方式访问不同的输入/输出源。 Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。 2、IO流原理及流的分类 ①、按照数据流向，可以将流分为输入流和输出流，其中输入流只能读取数据
C++ 【蓝书】网络流问题（网络流基础概念+三个算法+做题时的选择+模板整合）【网络流从入门到放弃】
超逸の学习技术博客
08-10 1438
明天写。。。
【专题】网络流之最大流算法
AIDreamer
05-01 1777
网络流之最大流算法AIDreamer2017/4/29 最大流问题在一个有向无环图中，用S和T来分别表示源点和汇点，每条边有一个权值cijc_{ij}代表容量限制，问从S最多可以流多少流量到T用fijf_{ij}表示每条边实际的流量，需要满足一下限制条件非负性:实际流量fij≥0f_{ij}\ge 0 容量条件:fij≤cijf_{ij}\le c_{ij} 流量守恒条件:每个节点流出的流量等于流入
网络流算法专题PPT学习教案.pptx
10-06
网络流算法专题PPT学习教案.pptx
网络老爬虫第9期-无线新技术专题1
08-03
【网络老爬虫第9期-无线新技术专题1】是一篇深入探讨无线通信技术的文章，主要聚焦于WLAN（Wireless Local Area Network）领域的新技术和应用。WLAN是无线局域网的缩写，它是利用电磁波进行数据传输，实现设备间的...
POJ 1325(2部图匹配）
热门推荐
nike0good |Oier&ACMer | 熟能生巧
08-15 2万+
2部图匹配，不能考虑0 Program P1325; var n,m,k,i,j:longint; p,x,y,level:longint; map,f,list:array[-1..300,-1..300] of longint; d,e:array[-1..300] of longint; queue:array[1..300] of longint;
POJ 2195(多源多汇最小费用最大流）
nike0good |Oier&ACMer | 熟能生巧
08-20 3876
这题 居然一次就过了^_^ Program P2195; const maxn=200; maxm=200; maxh=200; maxd=1000; var n,m,i,j,k,ut,vt:longint; s:string; form:array[1..maxn,1..maxm] of longint; u,v:array[1..max
BZOJ 4808(马-二分图最大独立集)
nike0good |Oier&ACMer | 熟能生巧
04-11 2074
4808: 马 Time Limit: 10 Sec Memory Limit: 128 MB Submit: 111 Solved: 46 [Submit][Status][Discuss] Description 众所周知，马后炮是中国象棋中很厉害的一招必杀技。”马走日字”。本来，如果在要去的方向有别的棋子挡住（俗 称”蹩马腿”），则不允许走过去。为了简化问题，我们不考虑这一点。
上学路线(递归sap-不完全)
nike0good |Oier&ACMer | 熟能生巧
04-10 1569
Problem 2 上学路线(route.cpp/c/pas) 【题目描述】 可可和卡卡家住马赛克市的东郊，每天上学他们都要转车多次才能到达市区西端的学校。直到有一天他们两人参加了学校的信息学奥林匹克竞赛小组才发现每天上学的乘车路线不一定是最优的。 马赛克市一共设有N个公交车站，不妨将它们编号为1…N的自然数，并认为可可和卡卡家住在1号汽车站附近，而他们学校在N号汽车站。市内有M条直达汽车路
C语言教学专题网站1毕业设计.doc
最新发布
07-04
"C语言教学专题网站1毕业设计.doc" 这篇文档描述的是一个基于C语言的网络教学系统的毕业设计项目。该系统充分利用了现代教育技术，旨在改变传统的教学方式，强调学生的主体地位，使得在线学习和课堂活动更加活跃。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值