BZOJ2893:征服王(费用流)

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。

Solution

打死白学家

首先第一感觉这个题很像最小路径覆盖……但他并不是一个$DAG$。所以我们自己动手丰衣足食把它缩成一个$DAG$。

现在变成了一个多起点多终点的最小路径覆盖问题。我们首先把一个点拆成$u$和$u'$，并且$u$连向$u'$一条流量为$1$，费用为1的边。

然后原图的边就$u'$连向$v$一条流量为$INF$，费用为$0$的边。

源点$S$向图中的起点$s$连流量为$INF$，费用为$0$的边，终点$t'$向图中的汇点$E$连流量为$INF$，费用为$0$的边。

跑一边最大费用最大流。如果费用为点数那么说明每个点都经过了，答案为增广次数。

否则无解。

Code

 #include<iostream>

 #include<cstring>

 #include<cstdio>

 #include<queue>

 #define N (10009)

 using namespace std;

 struct Edge{int to,next,flow,cost;}edge[N*];

 int DFN[N],Low[N],Stack[N],ID[N],Vis[N],top,dfs_num,id_num;

 int T,n,m,A,B,a[N],b[N],u[N*],v[N*],x,INF,s,e=;

 int dis[N],pre[N],vis[N];

 int head[N],num_edge;

 queue<int>q;

 void Clear()

 {

     memset(head,,sizeof(head));

     memset(DFN,,sizeof(DFN));

     memset(Low,,sizeof(Low));

     memset(ID,,sizeof(ID));

     memset(Vis,,sizeof(Vis));

     num_edge=top=dfs_num=id_num=;

 }

 void add(int u,int v,int l,int c)

 {

     edge[++num_edge].to=v;

     edge[num_edge].next=head[u];

     edge[num_edge].flow=l;

     edge[num_edge].cost=c;

     head[u]=num_edge;

 }

 bool SPFA(int s,int e)

 {

     memset(dis,0x7f,sizeof(dis));

     memset(pre,-,sizeof(pre));

     dis[s]=; q.push(s); vis[s]=;

     while (!q.empty())

     {

         int x=q.front(); q.pop();

         for (int i=head[x]; i; i=edge[i].next)

             if (edge[i].flow && dis[x]+edge[i].cost<dis[edge[i].to])

             {

                 dis[edge[i].to]=dis[x]+edge[i].cost;

                 pre[edge[i].to]=i;

                 if (!vis[edge[i].to])

                 {

                     vis[edge[i].to]=;

                     q.push(edge[i].to);

                 }

             }

         vis[x]=;

     }

     return dis[e]!=INF;

 }

 void MCMF(int s,int e)

 {

     int fee=,ans=;

     while (SPFA(s,e))

     {

         if (dis[e]==) break;

         else ans++;

         int d=INF;

         for (int i=e; i!=s; i=edge[((pre[i]-)^)+].to)

             d=min(d,edge[pre[i]].flow);

         for (int i=e; i!=s; i=edge[((pre[i]-)^)+].to)

         {

             edge[pre[i]].flow-=d;

             edge[((pre[i]-)^)+].flow+=d;

         }

         fee+=d*dis[e];

     }

     if (-fee==id_num) printf("%d\n",ans);

     else puts("no solution");

 }

 void Tarjan(int x)

 {

     DFN[x]=Low[x]=++dfs_num;

     Stack[++top]=x; Vis[x]=;

     for (int i=head[x]; i; i=edge[i].next)

         if (!DFN[edge[i].to])

         {

             Tarjan(edge[i].to);

             Low[x]=min(Low[x],Low[edge[i].to]);

         }

         else if (Vis[edge[i].to])

             Low[x]=min(Low[x],DFN[edge[i].to]);

     if (DFN[x]==Low[x])

     {

         ID[x]=++id_num; Vis[x]=;

         while (Stack[top]!=x)

         {

             ID[Stack[top]]=id_num;

             Vis[Stack[top--]]=;

         }

         top--;

     }

 }

 int main()

 {

     memset(&INF,0x7f,sizeof(INF));

     scanf("%d",&T);

     while (T--)

     {

         Clear();

         scanf("%d%d%d%d",&n,&m,&A,&B);

         for (int i=; i<=A; ++i) scanf("%d",&a[i]);

         for (int i=; i<=B; ++i) scanf("%d",&b[i]);

         for (int i=; i<=m; ++i) scanf("%d%d",&u[i],&v[i]), add(u[i],v[i],,);

         for (int i=; i<=n; ++i) if (!DFN[i]) Tarjan(i);

         memset(head,,sizeof(head)); num_edge=;

         for (int i=; i<=A; ++i)

             add(s,ID[a[i]],INF,), add(ID[a[i]],s,,);

         for (int i=; i<=B; ++i)

             add(ID[b[i]]+,e,INF,), add(e,ID[b[i]]+,,);

         for (int i=; i<=m; ++i)

             if (ID[u[i]]!=ID[v[i]])

                 add(ID[u[i]]+,ID[v[i]],INF,), add(ID[v[i]],ID[u[i]]+,,);

         for (int i=; i<=id_num; ++i)

         {

             add(i,i+,,-); add(i+,i,,);

             add(i,i+,INF,); add(i+,i,,);

         }

         MCMF(s,e);

     }

 }

巴特西