(网络流各种题型应用及解决方法)的源代码

最新推荐文章于 2022-10-27 18:31:04 发布
最新推荐文章于 2022-10-27 18:31:04 发布
阅读量1.2k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/carryheart/article/details/52470992
版权


hdu 1532

#include<cstdio>
 #include<cstring>
 #include<queue>
 #include<cmath>
 using namespace std;
 const int Ni = 210;
 const int MAX = 1<<26;
 struct Edge{
     int u,v,c;
     int next;
 }edge[20*Ni];
 int n,m;
 int edn;//边数
 int p[Ni];//父亲
 int d[Ni];
 int sp,tp;//原点，汇点

 void addedge(int u,int v,int c)
 {
     edge[edn].u=u; edge[edn].v=v; edge[edn].c=c;
     edge[edn].next=p[u]; p[u]=edn++;

     edge[edn].u=v; edge[edn].v=u; edge[edn].c=0;
     edge[edn].next=p[v]; p[v]=edn++;
 }
 int bfs()
 {
     queue <int> q;
     memset(d,-1,sizeof(d));
     d[sp]=0;
     q.push(sp);
     while(!q.empty())
     {
         int cur=q.front();
         q.pop();
         for(int i=p[cur];i!=-1;i=edge[i].next)
         {
             int u=edge[i].v;
             if(d[u]==-1 && edge[i].c>0)
             {
                 d[u]=d[cur]+1;
                 q.push(u);
             }
         }
     }
     return d[tp] != -1;
 }
 int dfs(int a,int b)
 {
     int r=0;
     if(a==tp)return b;
     for(int i=p[a];i!=-1 && r<b;i=edge[i].next)
     {
         int u=edge[i].v;
         if(edge[i].c>0 && d[u]==d[a]+1)
         {
             int x=min(edge[i].c,b-r);
             x=dfs(u,x);
             r+=x;
             edge[i].c-=x;
             edge[i^1].c+=x;
         }
     }
     if(!r)d[a]=-2;
     return r;
 }

 int dinic(int sp,int tp)
 {
     int total=0,t;
     while(bfs())
     {
         while(t=dfs(sp,MAX))
         total+=t;
     }
     return total;
 }
 int main()
 {
     int i,u,v,c;
     while(~scanf("%d%d",&m,&n))
     {
         edn=0;//初始化
         memset(p,-1,sizeof(p));
         sp=1;tp=n;
         for(i=0;i<m;i++)
         {
             scanf("%d%d%d",&u,&v,&c);
             addedge(u,v,c);
         }
         printf("%d\n",dinic(sp,tp));
     }
     return 0;
 }

hdu 3572 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#define INF 0x7fffffff
#define maxn 25000
using namespace std;
struct Edge{
    int from,to,cap,flow;
};
class Dinic{
private:
    int s,t,c;
    vector<Edge>edges;
    vector<int>G[maxn];//结点
    bool vis[maxn];
    int dist[maxn];
    int cur[maxn];
public:
    int n,m;
    void AddEdge(int from,int to,int cap){
        edges.push_back((Edge){from,to,cap,0});
        edges.push_back((Edge){to,from,0,0});
        c=edges.size();
        G[from].push_back(c-2);
        G[to].push_back(c-1);
    }
    bool BFS(){
        queue<int>Q;
        memset(vis,0,sizeof(vis));
        Q.push(s);
        dist[s]=0;
        vis[s]=1;
        while(!Q.empty()){
            int x=Q.front();Q.pop();
            for(int i=0;i<G[x].size();i++){
                Edge& e=edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow){
                    vis[e.to]=1;
                    dist[e.to]=dist[x]+1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x,int a){
        if(x==t||a==0)return a;
        int flow=0,f;
        for(int& i=cur[x];i<G[x].size();i++){
            Edge& e=edges[G[x][i]];
            if(dist[x]+1==dist[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0){
                e.flow+=f;
                edges[G[x][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a==0)break;
            }
        }
        return flow;
    }
    int Maxflow(int s,int t){
        this->s=s;this->t=t;
        int flow=0;
        while(BFS()){
            memset(cur,0,sizeof(cur));
            flow+=DFS(s,INF);
            flow+=DFS(s,INF);
        }
        return flow;
    }
    void init(){
        edges.clear();
        for(int i=0;i<maxn;i++){
            G[i].clear();
            dist[i]=0;
        }
    }
}Do;


 int main()
 {
     int N,M,T,cns=1,tp,sp;
     scanf("%d",&T);
     while(T--)
     {
         Do.init();
         int sum=0;
         scanf("%d%d",&N,&M);
         int Max=-1;
         sp=0;
         for(int i=1;i<=N;i++)
         {
             int p,s,e;
             scanf("%d%d%d",&p,&s,&e);
             Max=max(Max,e);
             sum+=p;
             Do.AddEdge(sp,i,p);
             for(int j=s;j<=e;j++)
             {
                 Do.AddEdge(i,N+j,1);
             }
         }
         tp=N+Max+1;
         for(int i=N+1;i<N+Max;i++)
         {
             Do.AddEdge(i,tp,M);
         }
         if(sum==Do.Maxflow(0,tp))
             cout<<"Case "<<cns++<<": "<<"Yes"<<endl;
             else
                 cout<<"Case "<<cns++<<": "<<"No"<<endl;
                 cout<<endl;
     }     
 }

hdu 3081 

#include<iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 205;
bool bmap[maxn][maxn];
bool bmask[maxn];
int nx,ny;
int cx[maxn];
int cy[maxn];
int fa[maxn];
int getfa(int x)
{
    if(fa[x]!=x)
        fa[x]=getfa(fa[x]);
        return fa[x];
}
int findpath(int u )
{
      int i;
      for(i=1; i<=ny; i++)
      {
            if(bmap[u][i] && ! bmask[i])
            {

                  bmask[i] = 1;
                  if(cy[i] == -1 || findpath(cy[i]))
                  {
                        cy[i] = u;
                        cx[u] = i;
                        return 1;
                  }
            }
      }
      return 0;
}

int maxmatch()
{
      int res(0);
      int i,j;
      for(i=1; i<=nx; i++)
      {
            cx[i]=-1;
      }
      for(j=1; j<=ny; j++)
      {
            cy[j]=-1;
      }
      for( i = 1; i <= nx ; i++ )
      {
            if ( cx [ i ] == -1)
            {
                  for(j = 1; j <= ny ;  j++ )
                  {
                        bmask[j] = 0;
                  }
                  res+=findpath(i);
            }
      }
      return res;
}
int main()
{
      int sz;
      scanf("%d",&sz);
      while(sz--)
      {
          int n,m,f,a,b;
            scanf("%d%d%d",&n,&m,&f);
            nx=ny=n;
            for(int j=0; j<=nx; j++)
            {
                  for(int k=0; k<=ny; k++)
                  {
                        bmap[j][k]=0;
                  }
            }
            for(int i=0;i<=n;i++)
            {
                fa[i]=i;
            }
            for(int i=0;i<m;i++)
            {
                scanf("%d%d",&a,&b);
                bmap[a][b]=1;
            }
            for(int i=0;i<f;i++)
            {
                scanf("%d%d",&a,&b);
                int A=getfa(a);
                int B=getfa(b);
                if(A!=B)
                {
                    fa[A]=B;
                }
            }
            for(int i=1;i<=n;i++)
            {
                for(int j=1;j<=n;j++)
                {
                    if(getfa(i)==getfa(j))
                    {
                        for(int k=1;k<=n;k++)
                        {
                            if(bmap[i][k]==1||bmap[j][k]==1)
                                bmap[i][k]=bmap[j][k]=1;
                        }
                    }
                }
            }
            int ans;
            for(ans=0;ans<=n;)
            {
                int res=maxmatch();
                if(res==n)
                {
                    ans++;
                    for(int i=1;i<=n;i++)
                    {
                        bmap[i][cx[i]]=0;
                    }
                }
                else
                    break;
            }
            cout<<ans<<endl;

            
      }

}

hdu 1533 

/*
1.WA  关于二分图匹配的数据范围要注意是否要乘以2 切记
 * 考虑范围要考虑反向边
*/
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <queue>
#define oo 0x13131313
using namespace std;
const int MAXN=400;
const int MAXM=200000;
const int INF=0x3f3f3f3f;
struct Edge
{
    int to,next,cap,flow,cost;
    void get(int a,int b,int c,int d)
    {
        to=a,cap=b,cost=c;next=d;flow=0;
    }
}edge[MAXM];
int head[MAXN],tol;
int pre[MAXN],dis[MAXN];
bool vis[MAXN];
int N;
void init(int n)
{
    N=n;
    tol=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v,int cap,int cost)
{
    edge[tol].get(v,cap,cost,head[u]);head[u]=tol++;
    edge[tol].get(u,0,-cost,head[v]);head[v]=tol++;
}
bool spfa(int s,int t)
{
    queue<int>q;
    for(int i=0;i<N;i++)
    {
        dis[i]=INF;
        vis[i]=false;
        pre[i]=-1;
    }
    dis[s]=0;
    vis[s]=true;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=false;
        for(int i= head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            if(edge[i].cap>edge[i].flow&&
               dis[v]>dis[u]+edge[i].cost )
            {
                dis[v]=dis[u]+edge[i].cost;
                pre[v]=i;
                if(!vis[v])
                {
                    vis[v]=true;
                    q.push(v);
                }
            }
        }
    }
    if(pre[t]==-1) return false;
    else return true;
}
int minCostMaxflow(int s,int t,int &cost)
{
    int flow=0;
    cost = 0;
    while(spfa(s,t))
    {
        int Min=INF;
        for(int i=pre[t];i!=-1;i=pre[edge[i^1].to])
        {
            if(Min >edge[i].cap-edge[i].flow)
              Min=edge[i].cap-edge[i].flow;
        }
        for(int i=pre[t];i!=-1;i=pre[edge[i^1].to])
        {
            edge[i].flow+=Min;
            edge[i^1].flow-=Min;
            cost+=edge[i].cost*Min;
        }
        flow+=Min;
    }
    return flow;
}
struct Home
{
    int x,y;
}H[MAXN],P[MAXN];
int totH,totP;
int NN,MM;
void input()
{
    char c;
    totH=0;totP=0;
    for(int i=1;i<=NN;i++)
   {
       for(int j=1;j<=MM;j++)
    {
        scanf("%c",&c);
        if(c=='H') totH++,H[totH].x=i,H[totH].y=j;
            else if(c=='m') totP++,P[totP].x=i,P[totP].y=j;
    }
      getchar();
   }
}
void CreatGraph()
{
    int ANS=0;
    int NNN=totP+totH;//該题选择NNN+1为起点，NNN+2为终点，其实大部分时候选择0为起点
    for(int i=1;i<=totP;i++)
      for(int j=1;j<=totH;j++)
    {
        int t=abs(P[i].x-H[j].x)+abs(P[i].y-H[j].y);
        addedge(i,j+totP,1,t);
    }
    for(int i=1;i<=totP;i++)
    addedge(NNN+1,i,1,0);
    for(int i=totP+1;i<=NNN;i++)
    addedge(i,NNN+2,1,0);
    minCostMaxflow(NNN+1,NNN+2,ANS);
    printf("%d\n",ANS);
}

int main()
{
    while(cin>>NN>>MM&&NN&&MM)
    {
        getchar();
        init(MAXN);
        input();
        CreatGraph();
    }
    return 0;
}

hdu 3667 

/*
1.WA  关于二分图匹配的数据范围要注意是否要乘以2 切记
 * 考虑范围要考虑反向边
*/
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <queue>
#define oo 0x13131313
using namespace std;
const int MAXN=400;
const int MAXM=200000;
const int INF=0x3f3f3f3f;
struct Edge
{
    int to,next,cap,flow,cost;
    void get(int a,int b,int c,int d)
    {
        to=a,cap=b,cost=c;next=d;flow=0;
    }
}edge[MAXM];
int head[MAXN],tol;
int pre[MAXN],dis[MAXN];
bool vis[MAXN];
int N;
void init(int n)
{
    N=n;
    tol=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v,int cap,int cost)
{
    edge[tol].get(v,cap,cost,head[u]);head[u]=tol++;
    edge[tol].get(u,0,-cost,head[v]);head[v]=tol++;
}
bool spfa(int s,int t)
{
    queue<int>q;
    for(int i=0;i<N;i++)
    {
        dis[i]=INF;
        vis[i]=false;
        pre[i]=-1;
    }
    dis[s]=0;
    vis[s]=true;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=false;
        for(int i= head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            if(edge[i].cap>edge[i].flow&&
               dis[v]>dis[u]+edge[i].cost )
            {
                dis[v]=dis[u]+edge[i].cost;
                pre[v]=i;
                if(!vis[v])
                {
                    vis[v]=true;
                    q.push(v);
                }
            }
        }
    }
    if(pre[t]==-1) return false;
    else return true;
}
int minCostMaxflow(int s,int t,int &cost)
{
    int flow=0;
    cost = 0;
    while(spfa(s,t))
    {
        int Min=INF;
        for(int i=pre[t];i!=-1;i=pre[edge[i^1].to])
        {
            if(Min >edge[i].cap-edge[i].flow)
              Min=edge[i].cap-edge[i].flow;
        }
        for(int i=pre[t];i!=-1;i=pre[edge[i^1].to])
        {
            edge[i].flow+=Min;
            edge[i^1].flow-=Min;
            cost+=edge[i].cost*Min;
        }
        flow+=Min;
    }
    return flow;
}
struct Home
{
    int x,y;
}H[MAXN],P[MAXN];
int totH,totP;
int NN,MM;
void input()
{
    char c;
    totH=0;totP=0;
    for(int i=1;i<=NN;i++)
   {
       for(int j=1;j<=MM;j++)
    {
        scanf("%c",&c);
        if(c=='H') totH++,H[totH].x=i,H[totH].y=j;
            else if(c=='m') totP++,P[totP].x=i,P[totP].y=j;
    }
      getchar();
   }
}
void CreatGraph()
{
    int ANS=0;
    int NNN=totP+totH;//該题选择NNN+1为起点，NNN+2为终点，其实大部分时候选择0为起点
    for(int i=1;i<=totP;i++)
      for(int j=1;j<=totH;j++)
    {
        int t=abs(P[i].x-H[j].x)+abs(P[i].y-H[j].y);
        addedge(i,j+totP,1,t);
    }
    for(int i=1;i<=totP;i++)
    addedge(NNN+1,i,1,0);
    for(int i=totP+1;i<=NNN;i++)
    addedge(i,NNN+2,1,0);
    minCostMaxflow(NNN+1,NNN+2,ANS);
    printf("%d\n",ANS);
}

int main()
{
    while(cin>>NN>>MM&&NN&&MM)
    {
        getchar();
        init(MAXN);
        input();
        CreatGraph();
    }
    return 0;
}

hdu 2255 

//网络流做法，会超时
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

const int INF=0x7FFFFFFF;
const int maxn=610;
struct Edge
{
    int from,to,cap,flow,cost;
};
int N,M,K,len,s,t;
vector<Edge> edges;
vector<int> G[maxn];
int inq[maxn];
int d[maxn];
int p[maxn];
int a[maxn];

void init()
{
    for(int i=0; i<maxn; i++) G[i].clear();
    edges.clear();
}

void Addedge(int from,int to,int cap,int cost)
{
    edges.push_back((Edge)
    {
        from,to,cap,0,cost
    });
    edges.push_back((Edge)
    {
        to,from,0,0,-cost
    });
    len=edges.size();
    G[from].push_back(len-2);
    G[to].push_back(len-1);
}

bool BellmanFord(int s,int t,int &flow,int &cost)
{

    for(int i=0; i<maxn; i++) d[i]=INF;

    memset(inq,0,sizeof(inq));
    memset(p,-1,sizeof(p));

    d[s]=0;
    inq[s]=1;
    p[s]=0;
    a[s]=INF;

    queue<int>Q;
    Q.push(s);
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        inq[u]=0;
        for(int i=0; i<G[u].size(); i++)
        {
            Edge& e=edges[G[u][i]];
            if(e.cap>e.flow&&d[e.to]>d[u]+e.cost)
            {
                d[e.to]=d[u]+e.cost;
                p[e.to]=G[u][i];
                a[e.to]=min(a[u],e.cap-e.flow);
                if(!inq[e.to])
                {
                    Q.push(e.to);
                    inq[e.to]=1;
                }
            }
        }
    }
    if(d[t]==INF) return false;
    flow+=a[t];
    cost+=d[t]*a[t];
    int u=t;
    while(u!=s)
    {
        edges[p[u]].flow+=a[t];
        edges[p[u]^1].flow-=a[t];
        u=edges[p[u]].from;
    }
    return true;
}

void Mincost (int s,int t)
{
    int flow=0,cost=0;
    while(BellmanFord(s,t,flow,cost));

    printf("%d\n",-cost);
}

int NN,MM;
void input()
{
    for(int i=1;i<=NN;i++)
   {
       int x;
       for(int j=NN+1;j<=NN*2;j++)
       {
           scanf("%d",&x);
           Addedge(i,j,1,-x);
       }
   }
   int ans=0;
   int st=0,sd=NN*2+1;
   for(int i=1;i<=NN;i++)
   {
       Addedge(st,i,1,0);
   }
   for(int i=1+NN;i<=NN*2;i++)
   {
       Addedge(i,sd,1,0);
   }

   Mincost(st,sd);
}

int main()
{
    while(scanf("%d",&NN)!=EOF)
    {
        init();
        input();
    }
}

hdu 5644 

/*
1.WA  关于二分图匹配的数据范围要注意是否要乘以2 切记
 * 考虑范围要考虑反向边
*/
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <queue>
#define oo 0x13131313
using namespace std;
const int MAXN=405;
const int MAXM=400010;
const int INF=0x3f3f3f3f;
struct Edge
{
    int to,next,cap,flow,cost;
    void get(int a,int b,int c,int d)
    {
        to=a,cap=b,cost=c;next=d;flow=0;
    }
}edge[MAXM];
int head[MAXN],tol;
int pre[MAXN],dis[MAXN];
bool vis[MAXN];
int N;
void init(int n)
{
    N=n;
    tol=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v,int cap,int cost)
{
    edge[tol].get(v,cap,cost,head[u]);head[u]=tol++;
    edge[tol].get(u,0,-cost,head[v]);head[v]=tol++;
}
bool spfa(int s,int t)
{
    queue<int>q;
    for(int i=0;i<=N;i++)
    {
        dis[i]=INF;
        vis[i]=false;
        pre[i]=-1;
    }
    dis[s]=0;
    vis[s]=true;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=false;
        for(int i= head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            if(edge[i].cap>edge[i].flow&&
               dis[v]>dis[u]+edge[i].cost )
            {
                dis[v]=dis[u]+edge[i].cost;
                pre[v]=i;
                if(!vis[v])
                {
                    vis[v]=true;
                    q.push(v);
                }
            }
        }
    }
    if(pre[t]==-1) return false;
    else return true;
}
int minCostMaxflow(int s,int t,int &cost)
{
    int flow=0;
    cost = 0;
    while(spfa(s,t))
    {
        int Min=INF;
        for(int i=pre[t];i!=-1;i=pre[edge[i^1].to])
        {
            if(Min >edge[i].cap-edge[i].flow)
              Min=edge[i].cap-edge[i].flow;
        }
        for(int i=pre[t];i!=-1;i=pre[edge[i^1].to])
        {
            edge[i].flow+=Min;
            edge[i^1].flow-=Min;
            cost+=edge[i].cost*Min;
        }
        flow+=Min;
    }
    return flow;
}
int n,k;
int p[402];
int s[402],t[402];
int m,P,q;
void input()
{
    int sum=0;
   int ans=0;
   scanf("%d%d",&n,&k);
   for(int i=1;i<=n;i++)
   {
       scanf("%d",&p[i]);
       sum+=p[i];
   }
   scanf("%d%d%d",&m,&P,&q);
   int st=0,sd=n*2+1;
   for(int i=1;i<=m;i++)
   {
       scanf("%d%d",&s[i],&t[i]);
       for(int j=1;j<=n;j++)
       {
           if(j+n+t[i]<=n*2)
            addedge(j,j+n+t[i],INF,s[i]);
       }
   }

   for(int i=1;i<=n;i++)
   {
       addedge(st,i,p[i],0);
   }
   for(int i=n+1;i<=2*n;i++)
   {
       addedge(i,sd,p[i-n],0);
   }
   addedge(st,n+1,k,0);
   for(int i=P+n;i<=2*n;i++)
   {
       addedge(st,i,INF,q);
   }
   for(int i=1;i<n;i++)
   {
       addedge(i,i+1,INF,0);
       addedge(i+n,i+n+1,INF,0);
   }

   if(minCostMaxflow(st,sd,ans)==sum)
   cout<<ans<<endl;
   else
    cout<<"No solution"<<endl;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        init(MAXN);
        input();
    }
    return 0;
}

zoj 3933 

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

const int INF=0x7FFFFFFF;
const int maxn=510;
struct Edge
{
    int from,to,cap,flow,cost;
};
int N,M,K,len,s,t;
vector<Edge> edges;
vector<int> G[maxn];
int inq[maxn];
int d[maxn];
int p[maxn];
int a[maxn];
int zh[maxn][maxn];
char a1[510],a2[510];
void init()
{
    for(int i=0; i<maxn; i++) G[i].clear();
    edges.clear();
}

void Addedge(int from,int to,int cap,int cost)
{
    edges.push_back((Edge)
    {
        from,to,cap,0,cost
    });
    edges.push_back((Edge)
    {
        to,from,0,0,-cost
    });
    len=edges.size();
    G[from].push_back(len-2);
    G[to].push_back(len-1);
}

bool BellmanFord(int s,int t,int &flow,int &cost)
{

    for(int i=0; i<maxn; i++) d[i]=INF;

    memset(inq,0,sizeof(inq));
    memset(p,-1,sizeof(p));

    d[s]=0;
    inq[s]=1;
    p[s]=0;
    a[s]=INF;

    queue<int>Q;
    Q.push(s);
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        inq[u]=0;
        for(int i=0; i<G[u].size(); i++)
        {
            Edge& e=edges[G[u][i]];
            if(e.cap>e.flow&&d[e.to]>d[u]+e.cost)
            {
                d[e.to]=d[u]+e.cost;
                p[e.to]=G[u][i];
                a[e.to]=min(a[u],e.cap-e.flow);
                if(!inq[e.to])
                {
                    Q.push(e.to);
                    inq[e.to]=1;
                }
            }
        }
    }
    if(d[t]==INF) return false;
    flow+=a[t];
    cost+=d[t]*a[t];
    int u=t;
    while(u!=s)
    {
        edges[p[u]].flow+=a[t];
        edges[p[u]^1].flow-=a[t];
        u=edges[p[u]].from;
    }
    return true;
}

void Mincost (int s,int t)
{
    int flow=0,cost=0;
    while(BellmanFord(s,t,flow,cost));
    printf("%d ",flow);
    printf("%d\n",-cost);
}
int NN;
int main()
{
    int t;
        scanf("%d",&t);
        while(t--)
        {
            init();
            scanf("%d",&NN);
            scanf(" %s",a1);
            scanf(" %s",a2);
            memset(zh,0,sizeof(zh));
            for(int i=0;i<NN;i++)
            {
                int m;
                scanf("%d",&m);
                for(int j=0;j<m;j++)
                {
                    int x;
                    scanf("%d",&x);
                    zh[i][x-1]=zh[x-1][i]=1;
                }
            }
            int st=NN,sd=NN+1;
            for(int i=0;i<NN;i++)
            {
                if(a1[i]=='0')
                    {Addedge(st,i,1,0);
                    for(int j=0;j<NN;j++)
                    {
                        if(zh[i][j]==0&&zh[j][i]==0&&a1[j]=='1')
                        {
                            if(a2[i]=='0'&&a2[j]=='0')
                            {
                                Addedge(i,j,1,-2);
                            }
                            else if(a2[i]=='0'&&a2[j]=='1')
                                Addedge(i,j,1,-1);
                            else if(a2[i]=='1'&&a2[j]=='0')
                                Addedge(i,j,1,-1);
                            else
                                Addedge(i,j,1,0);
                        }
                    }
            }

        }
        for(int i=0;i<NN;i++)
        {
            if(a1[i]=='1')
                Addedge(i,sd,1,0);
        }

        Mincost(st,sd);
        int ss=edges.size();
		for(int i=0;i<ss;i=i+2)
		{
			if(edges[i].from==st||edges[i].to==st||edges[i].from==sd||edges[i].to==sd)
				continue;
			if(edges[i].flow)
				cout<<edges[i].to+1<<" "<<edges[i].from+1<<endl;
		}
    }

    return 0;
}


Kblacksmith
关注
两款免费的软键盘,适合平板电脑等无键盘系统
02-17
这是两款免费的软键盘,其中VB的带有源码,可以参考学习,至于输入秀还是不错的,网上免费的太少了,所以给大家分享一下.
windows虚拟键盘透明化小软件（AdjustTouchKeyboardOpacity）（无意发现的好东西）
Kblacksmith的博客
11-01 7162
今天逛贴吧时发现一个很好用的小软件，名字 叫AdjustTouchKeyboardOpacity。 百度云连接 如果用windows平板的时候被虚拟键盘挡住输入框肯定很郁闷，这个软件可以将其透明化，下载下来解压选择是32位还是64位运行一下就可以见到效果，修改另外一个配置文件里面的参数即可修改透明程度。 我的平板的效果如下： 但是想要一直保持这样可以进入控制面板里的计划
android 透明屏幕??
qq_40024033的博客
08-17 366
配置清单文件设置权限 &lt;?xml version="1.0" encoding="utf-8"?&gt; &lt;manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.hlsk.touming01"&gt; &lt;uses-permissi
网络流解析及其应用
aisebu7819的博客
10-29 470
摘要 　　本文主要讲述了网络流中的最大流问题和费用流中的最小费用流问题，简单说明了Dinic算法和最小费用流算法，以题为例展示了使用算法的一些细节，意在能够根据问题建立模型，建图并套用该算法的模板解决问题。　 　 网络和网络流 　　在图论中，边附带容量的图称为网络，表示为G(V, E, C, s, t)，其中V表示顶点集， E表示边集，C便是每条边的容量限制，s是源点，t是汇...
poj2449 Remmarguts' Date
Kblacksmith的博客
11-01 388
这题题意为给一张有向图，还有起点s，终点e，求s到e的第k短的路。思路：此题要用到A*算法，先求反向的从终点e到各个点的最短路径，定义结构体struct node { int p,h,g; bool operator <(const node a)const { return g+h<a.g+a.h; } }即p为该点，h为从原点走到p的已花费代价，g为预估到终点的花费，即p到终
美赛各题型常见参考代码：34种数据降维方法代码.zip
08-05
本资料包提供了34种不同的数据降维方法的代码实现，下面将对这些方法进行详细阐述。 1. 主成分分析PCA（Principal Component Analysis）：通过线性变换将原始数据转换为一组各维度线性无关的表示，降低数据的复杂性...
美赛各题型常见参考代码：基于动态规划离散优化问题代码.zip
08-05
这个压缩包文件"美赛各题型常见参考代码：基于动态规划离散优化问题代码.zip"显然是为了提供一系列解决此类问题的代码示例。 动态规划是一种强大的算法设计方法，用于解决多阶段决策过程中的最优化问题。它的核心...
基于springboot+vue+MySQL实现的在线考试系统+源代码+文档
最新发布
06-07
综上所述，这个项目提供了从后端服务到前端展示的完整解决方案，对于学习和实践Web开发，尤其是Spring Boot、Vue.js和MySQL的集成应用，是一个很好的案例。通过研究和实践这个项目，开发者可以深入了解现代Web开发的...
JAVA+SQL离散数学题库管理系统(源代码+论文+外文翻译).rar
04-25
离散数学作为计算机科学的基础，对于理解数据结构、算法以及...此外，源代码分析和论文阅读能够培养独立解决问题、分析系统架构和评估性能的能力。对于计算机科学的学生和从业人员来说，这是一个宝贵的实践和学习资源。
企业QQ系统C#(VS2008)源代码
12-14
这个源代码项目包含多个子模块，旨在提供一套全面的企业内部沟通与管理解决方案。通过分析给出的描述，我们可以看到这个压缩包内包含了以下几个部分： 1. **家庭视频监控系统**：这是一个家庭安全监控的实现，可能...
网络流源代码
01-17
一份网络流源代码，信息竞赛NOI入门教程，不知道有没有用。
网络流及其应用
07-19
里面详细介绍了关于网络流的知识，基本上看完这个文件夹里的文件，网络流就没有问题了！
网络中的最大流算法及其matlab实现
10-18
用matlab编程实现了最大流问题，简洁明了。
虚拟键盘软件
06-27
虚拟建盘好用不用说
好用的屏幕键盘
09-22
好用的屏幕键盘有了它就可以在没有键盘的情况下 使用电脑
网络流应用（一）
Galaxy_Su的博客
10-27 406
网络流应用
JAVA基础-网络编程概述及应用(示例代码)
向上的"狼"的博客
05-04 528
一、网络编程入门 1.1、网络编程概述 计算机网络 是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统 网络编程 在网络通信协议下，不同计算机上运行的程序，可以进行数据传输 1.2、网络编程三要素 IP地址 要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而IP地址就是这个..
网络流的最大流c语言程序,网络流总结(一)最大流(示例代码)
weixin_35909443的博客
05-17 397
网络流模型的性质1>容量限制:$f(x,y)$<=$c(x,y)$2>斜对称:$f(x,y)$=-$f(y,x)$3>流守恒:除了S或者T,每个点的流出流量等于流入流量最大流最大流问题是指给定S和T，求出S到T的最大流量这个图的最大流就是2，但是假如我们把这个图给skyh的话，他一定会走S->2->3->T,流量为1之后他就写比了我们如何该用一些反悔的操作...
网络流基础与应用
weixin_43870697的博客
08-16 327
目录 Dinic算法 例题 A:POJ-3436 ACM Computer Factory B:POJ-3281 Dining C:POJ-1087 A Plug for UNIX D:POJ-2195 Going Home E:POJ-2516 Minimum Cost F:POJ-1459 Power Network G:HDU-4280 Island Transport ...
全国计算机等级考试三级网络技术上机考试分类题型定义及解决方案
全国计算机等级考试三级网络技术上机考试分类题型（新思路）定义 本资源是关于全国计算机等级考试三级网络技术上机考试的分类题型定义，涵盖了七个不同的题型，每个题型都涉及到不同的算法和编程思想。 **题型1：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值