BZOJ2893: 征服王

题解:

裸的上下界最小流是有问题的。
因为在添加了附加源之后求出来的流，因为s，t以及其它点地位都是平等的。
如果有一个流经过了s和t，那么总可以认为这个流是从s出发到t的满足题意的流。

既然可能存在s到t的流，那么也可能会存在不经过s和t的流，而这是一条环流！！起点不是s，也不是t！显然不满足题意！！！

为了避免环流的出现，我们只好缩点。。。（本来想偷懒不缩的。。。）

所以整个算法就是缩点之后上下界最小流。

代码：无压力rank1了。。。

 #include<cstdio>

 #include<cstdlib>

 #include<cmath>

 #include<cstring>

 #include<algorithm>

 #include<iostream>

 #include<vector>

 #include<map>

 #include<set>

 #include<queue>

 #include<string>

 #define inf 1000000000

 #define maxn 100000+5

 #define maxm 100000+5

 #define eps 1e-10

 #define ll long long

 #define pa pair<int,int>

 #define for0(i,n) for(int i=0;i<=(n);i++)

 #define for1(i,n) for(int i=1;i<=(n);i++)

 #define for2(i,x,y) for(int i=(x);i<=(y);i++)

 #define for3(i,x,y) for(int i=(x);i>=(y);i--)

 #define for4(i,x) for(int i=head[x],y;i;i=e[i].next)

 #define mod 1000000007

 using namespace std;

 inline int read()

 {

     int x=,f=;char ch=getchar();

     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}

     while(ch>=''&&ch<=''){x=*x+ch-'';ch=getchar();}

     return x*f;

 }
 int  n,m,s,t,ss,tt,T,a[maxn],b[maxn],maxflow,tot=,head[maxn],cur[maxn],h[maxn],in[maxn];
 queue<int>q;
 struct edge{int go,next,v;}e[maxm];
 inline void add(int x,int y,int v)
 {
     e[++tot]=(edge){y,head[x],v};head[x]=tot;
     e[++tot]=(edge){x,head[y],};head[y]=tot;
 }
 inline void ins(int x,int y)
 {
     e[++tot]=(edge){y,head[x],};head[x]=tot;
 }
 inline void insert(int x,int y,int l,int r)
 {
     in[y]+=l;in[x]-=l;add(x,y,r-l);
 }
 void build()
 {
     for0(i,tt)if(in[i]>)add(ss,i,in[i]);else if(in[i]<)add(i,tt,-in[i]);
 }
 bool bfs()
 {
     for(int i=;i<=tt;i++)h[i]=-;
     q.push(s);h[s]=;
     while(!q.empty())
     {
         int x=q.front();q.pop();
         for(int i=head[x];i;i=e[i].next)
          if(e[i].v&&h[e[i].go]==-)
          {
             h[e[i].go]=h[x]+;q.push(e[i].go);
          }
     }
     return h[t]!=-;
 }
 int dfs(int x,int f)
 {
     if(x==t) return f;
     int tmp,used=;
     for(int i=cur[x];i;i=e[i].next)
      if(e[i].v&&h[e[i].go]==h[x]+)
     {
         tmp=dfs(e[i].go,min(e[i].v,f-used));
         e[i].v-=tmp;if(e[i].v)cur[x]=i;
         e[i^].v+=tmp;used+=tmp;
         if(used==f)return f;
     }
     if(!used) h[x]=-;
     return used;
 }
 void dinic()
 {
     maxflow=;
     while(bfs())
     {
         for (int i=;i<=tt;i++)cur[i]=head[i];maxflow+=dfs(s,inf);
     }
 }
 int ti,u[maxn],v[maxn],low[maxn],dfn[maxn],cnt,scc[maxn],top,sta[maxn];
 int minflow()
 {
     s=ss;t=tt;
     dinic();
     if(maxflow!=cnt)return -;
     int ans=e[tot].v;
     e[tot].v=e[tot^].v=;
     s=cnt+cnt+;t=;
     dinic();
     return ans-maxflow;
 }
 inline void tarjan(int x)
 {
     sta[++top]=x;low[x]=dfn[x]=++ti;
     for4(i,x)if(!dfn[y=e[i].go])
     {
         tarjan(y);
         low[x]=min(low[x],low[y]);
     }else if(!scc[y])low[x]=min(low[x],dfn[y]);
     if(low[x]==dfn[x])
     {
         cnt++;
         for(int y=;y!=x;)scc[y=sta[top--]]=cnt;
     }
 }

 int main()

 {

     freopen("input.txt","r",stdin);

     freopen("output.txt","w",stdout);

     T=read();
     while(T--)
     {
         memset(head,,sizeof(head));tot=;cnt=;
         memset(in,,sizeof(in));
         memset(low,,sizeof(low));
         memset(dfn,,sizeof(dfn));
         memset(scc,,sizeof(scc));
         n=read();m=read();a[]=read();b[]=read();
         for1(i,a[])a[i]=read();
         for1(i,b[])b[i]=read();
         for1(i,m){u[i]=read();v[i]=read();ins(u[i],v[i]);}
         for1(i,n)if(!dfn[i])tarjan(i);
         s=;t=cnt+cnt+;ss=t+;tt=t+;
         memset(head,,sizeof(head));tot=;
         for1(i,cnt)insert(i,i+cnt,,inf);
         for1(i,a[])insert(s,scc[a[i]],,inf);
         for1(i,b[])insert(scc[b[i]]+cnt,t,,inf);
         for1(i,m)if(scc[u[i]]!=scc[v[i]])insert(scc[u[i]]+cnt,scc[v[i]],,inf);
         build();
         insert(t,s,,inf);
         int x=minflow();
         if(x==-)printf("no solution\n");else printf("%d\n",x);
     }

     return ;

 }  

2893: 征服王

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit: 64  Solved: 17
[Submit][Status]

Description

虽然春希将信息传递给了雪菜，但是雪菜却好像完全不认得春希了。心急如焚的春希打开了第二世代机能，对雪菜的脑内芯片进行了直连-hack。

进入到雪菜内部的春希发现（这什么玩意。。），雪菜的脑部结构被分成了n个块落，并且一些块落之间被有向边连接着。由于四分五裂的脑部，雪菜关于春希的记忆也完全消失，春希为了恋人，启动了inversionprocess.

在inversion
process中，要想使雪菜回到正常状态，需要纳米机器人的帮助。纳米机器人可以从任意一个可以作为起点的块落出发进行修复，也可以在任意一个可以作为
终点的块落结束修复（并不是到了某个终点就一定要停止）。春希希望所有的节点都能被修复(只要纳米机器人到过该点就算修复过)，这样才能让雪菜重获新生。

作为纳米机器人1号的你能帮助春希算算至少需要多少个机器人才能拯救雪菜吗？

当然，如果无论如何都无法使得春希的愿望被满足的话，请输出”no solution”（不包括引号）

Input

题目包含多组数据

第1行有一个正整数t，表示数据的组数。

第2行有两个正整数n、m，a，b，分别表示块落的数量、有向边的数量、起点的数量、终点的数量。

第3行有a个正整数，表示可以作为起点的块落。

第4行有b个正整数，表示可以作为终点的块落。

第5行至第m+4行，每行有两个正整数u、v，表示能从编号为u的块落到编号为v的块落。

之后以此类推。

Output

输出共有t行，每行输出对应数据的答案。

Sample Input

2
2 1 1 1
1
2
2 1
3 2 3 3
1 2 3
1 2 3
1 2
1 3

Sample Output

no solution
2
【数据规模和约定】
对于30%的数据，满足n <= 10, m <= 100。
对于60%的数据，满足n <= 200, m <= 5000。
对于100%的数据，满足t<=10,n <= 1000, m <= 10000。