POJ 3436 ：ACM Computer Factory：网络流拆点应用

ACM Computer Factory

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 5384		Accepted: 1858		Special Judge

Description

As you know, all the computers used for ACM contests must be identical, so the participants compete on equal terms. That is why all these computers are historically produced at the same factory.

Every ACM computer consists of P parts. When all these parts are present, the computer is ready and can be shipped to one of the numerous ACM contests.

Computer manufacturing is fully automated by using N various machines. Each machine removes some parts from a half-finished computer and adds some new parts (removing of parts is sometimes necessary as the parts cannot be added to a computer in
arbitrary order). Each machine is described by its performance (measured in computers per hour), input and output specification.

Input specification describes which parts must be present in a half-finished computer for the machine to be able to operate on it. The specification is a set of P numbers 0, 1 or 2 (one number for each part), where 0 means that corresponding part
must not be present, 1 — the part is required, 2 — presence of the part doesn't matter.

Output specification describes the result of the operation, and is a set of P numbers 0 or 1, where 0 means that the part is absent, 1 — the part is present.

The machines are connected by very fast production lines so that delivery time is negligibly small compared to production time.

After many years of operation the overall performance of the ACM Computer Factory became insufficient for satisfying the growing contest needs. That is why ACM directorate decided to upgrade the factory.

As different machines were installed in different time periods, they were often not optimally connected to the existing factory machines. It was noted that the easiest way to upgrade the factory is to rearrange production lines. ACM directorate decided to
entrust you with solving this problem.

Input

Input file contains integers P N, then N descriptions of the machines. The description of ith machine is represented as by 2 P + 1 integers Qi Si,1 Si,2...Si,P Di,1 Di,2...Di,P,
where Qi specifies performance, Si,j — input specification for part j, Di,k — output specification for part k.

Constraints

1 ≤ P ≤ 10, 1 ≤ N ≤ 50, 1 ≤ Qi ≤ 10000

Output

Output the maximum possible overall performance, then M — number of connections that must be made, then M descriptions of the connections. Each connection between machines A and B must be described by three positive numbers A B W,
where W is the number of computers delivered from A to B per hour.

If several solutions exist, output any of them.

Sample Input

Sample input 1
3 4
15  0 0 0  0 1 0
10  0 0 0  0 1 1
30  0 1 2  1 1 1
3   0 2 1  1 1 1
Sample input 2
3 5
5   0 0 0  0 1 0
100 0 1 0  1 0 1
3   0 1 0  1 1 0
1   1 0 1  1 1 0
300 1 1 2  1 1 1
Sample input 3
2 2
100  0 0  1 0
200  0 1  1 1

Sample Output

Sample output 1
25 2
1 3 15
2 3 10
Sample output 2
4 5
1 3 3
3 5 3
1 2 1
2 4 1
4 5 1
Sample output 3
0 0

Hint

Bold texts appearing in the sample sections are informative and do not form part of the actual data.
Source

Northeastern Europe 2005, Far-Eastern Subregion

这道题目是最大流非常不错的应用，并且编码声势浩大的样子。题目的意思是，有p块电脑部件要组装，有n台机器。每台机器针对电脑的完成度，更换零件，速度是每小时几个电脑。有意思的是，每台机器的输入输出状态是不确定的。这样，每个机器看做一个节点的话，会有若干条边指向该机器，也会由该机器发出若干条边。但是每条边的电脑流量是未知的，只知道流过该节点的电脑数量上限。

我们可以将每个节点拆分成两个节点：输入点和输出点，那么这两个节点只有一条“节点内部边”连接该节点的输入输出，并且这条边的流量上限是知道的。若x机器可以后面指向y机器，那么我们就将x机器的输出点连接上y机器的输入点。该连接边的流量上限是min{x，y}，然后再添加源点S是全0状态和汇点T是完整状态。这样就构造出一个有向图，求解由S到T的最大流。

该题目的另外一个难点是要输出满足最大流时，每条有流量的边及流量。那么在SAT算法中还要加上流量图，方便后面输出，只要是正，就是i指向j的流量；是负，表示由j指向i的流量，若零，表示没有流量。

这道题目虽然繁复，但是本质的最大流，构件图是需要技巧，拆分点。

这次的最大图SAP算法是比较标准的写法：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct node
{
int input[15],output[15];
int speed;
}road;
road a[55];
int p,n,liu[55][55],sum;
int can[150][150],use[150],pre[150],que[1000000];
int min(int x,int y)
{
return (x<y?x:y);
}
int pei(int x,int y)
{
int i,j;
for(i=0;i<p;i++)
{
if(a[y].input[i]!=2)
{
if(a[y].input[i]!=a[x].output[i])
return 0;
}
}
return 1;
}
void construct()
{
int i,j;
int tx,ty;
for(i=0;i<=n;i++)
{
for(j=1;j<=n+1;j++)
{
if(i!=j&&pei(i,j))
{
tx=2*i;
ty=2*j-1;
can[tx][ty]=min(a[i].speed,a[j].speed);
}
}
if(i)
can[2*i-1][2*i]=a[i].speed;
}
}
void init()
{
int i,j;
for(i=1;i<=n;i++)
{
scanf("%d",&a[i].speed);
for(j=0;j<p;j++)
scanf("%d",&a[i].input[j]);
for(j=0;j<p;j++)
scanf("%d",&a[i].output[j]);
}
for(i=0;i<p;i++)
{
a[0].output[i]=0;
a[0].speed=100000;
a[n+1].input[i]=1;
a[n+1].speed=100000;
}
memset(liu,0,sizeof(liu));
memset(can,0,sizeof(can));
construct();
}
int BFS(int s, int t)
{
int head,end;
memset(pre, -1, sizeof(pre));
memset(use, 0, sizeof(use));
head=end=0;
pre[s] = s;
use[s] = 1;
que[end++]=s;

int p;
while(head<end)
{
p = que[head++];
for(int i=1; i<=2*n+1; ++i)
{
if(can[p][i]>0 && !use[i])
{
pre[i] = p;
use[i] = 1;
if(i == t)  // 存在增广路径
return 1;
que[end++]=i;
}
}
}
return 0;
}

void EK(int s, int t)
{
int d;
int tx,ty;
sum = 0;
while(BFS(s,t))
{
d= 100000;
// 若有增广路径，则找出最小的delta
for(int i=t; i!=s; i=pre[i])
d = min(d, can[pre[i]][i]);//两者求最小值
// 这里是反向边，看讲解
for(int i=t; i!=s; i=pre[i])
{
can[pre[i]][i] -= d;
can[i][pre[i]] += d;
tx=(pre[i]+1)/2;
ty=(i+1)/2;
if(tx!=ty)
{
liu[tx][ty] += d;
liu[ty][tx] -= d;
}
}
sum += d;
}
}
void print()
{
int i,j;
int num=0;
if(sum==0)
printf("0 0\n");
else
{
for(i=1;i<=n;i++)
for(j=1;j<i;j++)
if(liu[i][j])
num++;
printf("%d %d\n",sum,num);
for(i=1;i<=n;i++)
for(j=i+1;j<=n;j++)
if(liu[i][j]>0)
printf("%d %d %d\n",i,j,liu[i][j]);
else
if(liu[i][j]<0)
printf("%d %d %d\n",j,i,-1*liu[i][j]);
}
}
int main()
{
int i,j;
while(scanf("%d%d",&p,&n)!=EOF)
{
init();
EK(0,2*n+1);
print();
}
return 0;
}