POJ 3436 ACM Computer Factory 最大流

題意就是說，現在有一個電腦生產工廠，一個電腦可分爲P個零件，工廠裏共有N臺機器

對於每臺機器，Q,S1,S2,,,Sp,D1,D2,,,Dp，可以描述它，

其中Q爲這臺機器每個小時能生產的電腦數量，Si表示它對第i個零件的需求，0爲這個零件必須爲空，1爲這個零件必須要有，2爲有無皆可，Di表示它生產完成之後的第i個零件的狀況，0爲這個零件爲空，1爲有這個零件

然後問你每小時最大生成數量和具體的流程方式

最大流，建立一個超級源點，對於初始可以全部爲空的，與超級源點連一條容量爲INF的邊，建一個超級匯點，對於生產之後全爲1的，表示組裝完成了，與超級匯點連一條容量爲INF的邊，對於每個點，拆成兩個，進和出，中間連一條容量爲它的生產速度的邊，對於那些它的產出可以作爲別人產入的，也連一條邊，容量>=這兩個機器的速度的最小值即可（因爲在拆點那裏對速度有了限制），然後從源點往匯點跑網絡流就行

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <string>
#include <fstream>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
using namespace std;
//ISAP+bfs 初始化+棧優化
#define maxn 120//點數的最大值
#define maxm 14400//邊數的最大值
#define INF 0x3f3f3f3f
struct Edge
{
	int to, next, cap, flow;
}edge[maxm];//注意是maxm
int tol;
int head[maxn];
int gap[maxn], dep[maxn], cur[maxn];
void init()
{
	tol = 0;
	memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int w, int rw = 0)
{
	edge[tol].to = v; edge[tol].cap = w; edge[tol].flow = 0;
	edge[tol].next = head[u]; head[u] = tol++;
	edge[tol].to = u; edge[tol].cap = rw; edge[tol].flow = 0;
	edge[tol].next = head[v]; head[v] = tol++;
}
int Q[maxn];
void BFS(int start, int end)
{
	memset(dep, -1, sizeof(dep));
	memset(gap, 0, sizeof(gap));
	gap[0] = 1;
	int front = 0, rear = 0;
	dep[end] = 0;
	Q[rear++] = end;
	while (front != rear)
	{
		int u = Q[front++];
		for (int i = head[u]; i != -1; i = edge[i].next)
		{
			int v = edge[i].to;
			if (dep[v] != -1)continue;
			Q[rear++] = v;
			dep[v] = dep[u] + 1;
			gap[dep[v]]++;
		}
	}
}
int S[maxn];
//N是總頂點數，編號[0,N-1]
int sap(int start, int end, int N)
{
	BFS(start, end);
	memcpy(cur, head, sizeof(head));
	int top = 0;
	int u = start;
	int ans = 0;
	while (dep[start] < N)
	{
		if (u == end)
		{
			int Min = INF;
			int inser;
			for (int i = 0; i < top; i++)
				if (Min > edge[S[i]].cap - edge[S[i]].flow)
				{
					Min = edge[S[i]].cap - edge[S[i]].flow;
					inser = i;
				}
			for (int i = 0; i < top; i++)
			{
				edge[S[i]].flow += Min;
				edge[S[i] ^ 1].flow -= Min;
			}
			ans += Min;
			top = inser;
			u = edge[S[top] ^ 1].to;
			continue;
		}
		bool flag = false;
		int v;
		for (int i = cur[u]; i != -1; i = edge[i].next)
		{
			v = edge[i].to;
			if (edge[i].cap - edge[i].flow && dep[v] + 1 == dep[u])
			{
				flag = true;
				cur[u] = i;
				break;
			}
		}
		if (flag)
		{
			S[top++] = cur[u];
			u = v;
			continue;
		}
		int Min = N;
		for (int i = head[u]; i != -1; i = edge[i].next)
			if (edge[i].cap - edge[i].flow && dep[edge[i].to] < Min)
			{
				Min = dep[edge[i].to];
				cur[u] = i;
			}
		gap[dep[u]]--;
		if (!gap[dep[u]])return ans;
		dep[u] = Min + 1;
		gap[dep[u]]++;
		if (u != start)u = edge[S[--top] ^ 1].to;
	}
	return ans;
}
int P, N;
int in[55][15], out[55][15];
int velocity[55];
int oper[3605][3];
int main()
{
	//freopen("input.txt", "r", stdin);
	while (scanf("%d%d", &P, &N) != EOF)
	{
		init();
		memset(in, 0, sizeof(int) * 55 * 15);
		memset(out, 0, sizeof(int) * 55 * 15);
		memset(velocity, 0, sizeof(int) * 55);
		memset(oper, 0, sizeof(int) * 3605 * 3);
		for (int i = 1; i <= N; ++i)
		{
			scanf("%d", &velocity[i]);
			for (int j = 0; j < P; ++j)
				scanf("%d", &in[i][j]);
			for (int j = 0; j < P; ++j)
				scanf("%d", &out[i][j]);
		}
		for (int i = 1; i <= N; ++i)
		{
			addedge(i * 2 - 1, i * 2, velocity[i]);
			bool flag = true;
			for (int j = 0; j < P; ++j)
			{
				if (in[i][j] == 1)
				{
					flag = false; break;
				}
			}
			if (flag)
			{
				addedge(0, i * 2 - 1, INF);
			}
			flag = true;
			for (int j = 0; j < P; ++j)
			{
				if (out[i][j] == 0)
				{
					flag = false; break;
				}
			}
			if (flag)
			{
				addedge(i * 2, 2 * N + 1, INF);
			}
			for (int j = 1; j <= N; ++j)
			{
				if (j == i)
					continue;
				flag = true;
				for (int k = 0; k < P; ++k)
				{
					if (out[i][k] + in[j][k] == 1)//不匹配
					{
						flag = false; break;
					}
				}
				if (flag)
				{
					addedge(2 * i, 2 * j - 1, min(velocity[i], velocity[j]));
				}
			}
		}
		int ans = sap(0, 2 * N + 1, 2 * N + 2);
		int sum = 0;
		for (int i = 1; i <= N; ++i)
		{
			for (int j = head[i * 2]; j != -1; j = edge[j].next)
			{
				if (edge[j].to == 2 * N + 1 || edge[j].to == 0 || edge[j].flow <= 0 || edge[j].flow >= INF)
					continue;
				oper[sum][0] = i; oper[sum][1] = (edge[j].to + 1) / 2; oper[sum++][2] = edge[j].flow;
			}
		}
		printf("%d %d\n", ans, sum);
		for (int i = 0; i < sum; ++i)
		{
			printf("%d %d %d\n", oper[i][0], oper[i][1], oper[i][2]);
		}
	}
	//while (1);
	return 0;
}