说说建图吧…
poj1459:
增加超级源点，超级汇点，跑一遍即可。
#include <cstdio>
#include <cstring>
#include <vector>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
using namespace std;
const int MAX = 107;
const int INF = 0xfffffff;
struct node {
int to;
int cap;
int rev;
};
vector<node> G[MAX];
int level[MAX];
bool vis[MAX];
int n, np, nc, m, S, T;
inline void add_edge(int u, int v, int c) {
G[u].push_back((node){v, c, G[v].size()});
G[v].push_back((node){u, 0, G[u].size() - 1});
}
// from S to T, with max cap: C
bool BFS(int S, int T) {
queue<int> Q;
Q.push(S);
memset(level, -1, sizeof(level));
level[S] = 0;
while (!Q.empty()) {
int p = Q.front();
Q.pop();
for (vector<node>::iterator it = G[p].begin(); it != G[p].end(); ++it) {
if (level[it->to] < 0 && it->cap > 0) {
level[it->to] = level[p] + 1;
Q.push(it->to);
if (it->to == T) return true;
}
}
}
return false;
}
int DFS(int u, int v, int c) {
if (u == v) return c;
int sum = 0, tmp;
for (vector<node>::iterator it = G[u].begin(); it != G[u].end(); ++it) {
if (level[it->to] == level[u] + 1 && it->cap > 0) {
tmp = DFS(it->to, T, min(c - sum, it->cap));
sum += tmp;
it->cap -= tmp;
G[it->to][it->rev].cap += tmp;
}
}
return sum;
}
int dinic(int S, int T) {
int sum = 0;
while (BFS(S, T)) {
memset(vis, false, sizeof(vis));
sum += DFS(S, T, INF);
}
return sum;
}
int main() {
while (~scanf(" %d %d %d %d", &n, &np, &nc, &m)) {
S = n, T = n + 1;
for (int i = 0; i <= T; ++i) G[i].clear();
int a, b, c;
for (int i = 0; i < m; ++i) {
scanf(" (%d,%d)%d", &a, &b, &c);
add_edge(a, b, c);
}
for (int i = 0; i < np; ++i) {
scanf(" (%d)%d", &a, &c);
add_edge(S, a, c);
}
for (int i = 0; i < nc; ++i) {
scanf(" (%d)%d", &a, &c);
add_edge(a, T, c);
}
printf("%d\n", dinic(S, T));
}
return 0;
}poj3436 ACM Computer Factory:
题意：
好多机器生产电脑，每台机器对应的P个元器件。
输入：
0表示不能有
1表示一定要有
2表示可有可无
输出：
0表示没有
1表示有
另外还有一个流量值Q,即生产能力。
举例说明，如果有3种元器件，那么机器{15, [1, 2, 0], [1, 0, 1]}表示它可同时艹(即加工，编者注)15台产品{本题是生产电脑}，并且拿给它加工的产品必须有元件1(不然可能产生故障)，元件2可有可无(不影响)，一定不能有元件3(不然卡住了就拔不出来了)；同时，经过它加工后的产品会剩下元件1和元件3，不会有元件2.
深入理解后可以建图了：
①增加超级源点，超级汇点。对每个机器判断它是否能作为源点（输入的P的元器件要求不为’1’），是否能作为汇点（输出中P种原件均为’1’，也就是产品必须是完整哒）。对应与源汇点连边，容量INF。
②对每个机器，拆点，中间流量为对应那台机器的生产能力。
③ 两两检查每对机器，我们对每对组合判断一下：
如果对某元器件，机器1输出为x,机器2要求输入为y，那么
x,y=
0,0: OK
0,1: 不行
0,2:行
1,0：不行
1,1：行
1,2：行
所以只要检查
x+y==1?不行:行
即可。
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <climits>
#include <algorithm>
using namespace std;
const int MAX = 55;
const int INF = 0xfffffff;
int G[MAX << 1][MAX << 1];
int in[MAX][MAX], out[MAX][MAX];
int level[MAX << 1];
int N, P;
struct o_o {
int u;
int v;
int c;
};
bool BFS(int S, int T) {
queue<int> Q;
memset(level, -1, sizeof(level));
Q.push(S);
level[S] = 0;
while (!Q.empty()) {
int p = Q.front();
Q.pop();
if (p == T) return true;
//这里务必保证T的标号最大
for (int i = 0; i <= T; ++i) {
if (level[i] == -1 && G[p][i] > 0) {
level[i] = level[p] + 1;
Q.push(i);
}
}
}
return false;
}
int DFS(int s, int t, int flow) {
//printf("vis %d----------------\n", S);
if (s == t) return flow;
int sum = 0, tmp;
for (int i = 0; i <= t; ++i) {
if (level[i] == level[s] + 1 && G[s][i] > 0) {
tmp = DFS(i, t, min(flow - sum, G[s][i]));
sum += tmp;
//printf("(%d,%d)\n", s, sum);
G[s][i] -= tmp;
G[i][s] += tmp;
}
}
return sum;
}
int dinic(int S, int T) {
int sum = 0;
while (BFS(S, T)) {
//puts("---------------");
//for (int i = 0; i <= T; ++i) {
// printf("%d ", level[i]);
//}
//puts("\n----------------");
sum += DFS(S, T, INF);
//printf("sum = %d\n", sum);
//puts("-----------------------");
//getchar();
}
return sum;
}
int main() {
int GT[MAX << 1][MAX << 1];
while (~scanf(" %d %d", &P, &N)) {
memset(G, 0, sizeof(G));
for (int i = 1; i <= N; ++i) {
//拆点
scanf(" %d", &G[i][i + N]);
for (int j = 1; j <= P; ++j) {
scanf(" %d", &in[i][j]);
}
for (int j = 1; j <= P; ++j) {
scanf(" %d", &out[i][j]);
}
}
int S = 0, T = N << 1 | 1;
for (int i = 1; i <= N; ++i) {
bool flag1 = true, flag2 = true;;
for (int j = 1; j <= P; ++j) {
if (in[i][j] == 1) {
flag1 = false;
}
if (out[i][j] != 1) {
flag2 = false;
}
}
if (flag1) G[S][i] = INF; //source
if (flag2) G[i + N][T] = INF; //slink
for (int j = 1; j <= N; ++j) {
if (i == j) continue;
flag1 = true;
for (int k = 1; k <= P; ++k) {
if (out[i][k] + in[j][k] == 1) {
flag1 = false;
break;
}
}
if (flag1) G[i + N][j] = INF;
}
}
memcpy(GT, G, sizeof(G));
int ans = dinic(S, T);
vector<o_o> V;
o_o u_u;
if (ans) {
for (int i = 1; i < T; ++i) {
for (int j = 1; j < T; ++j) {
if (G[i][j] < GT[i][j]) {
u_u.u = i > N ? i - N : i;
u_u.v = j > N ? j - N : j;
u_u.c = GT[i][j] - G[i][j];
if (u_u.u == u_u.v) continue;
V.push_back(u_u);
}
}
}
printf("%d %d\n", ans, V.size());
for (vector<o_o>::iterator it = V.begin(); it != V.end(); ++it) {
printf("%d %d %d\n", it->u, it->v, it->c);
}
} else {
puts("0 0");
}
}
return 0;
}时间： 2024-10-11 01:18:49