最大流

 1 #include <vector>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <queue>
 5 #include <algorithm>
 6 #define INF 0x3f3f3f3f
 7 using namespace std;
 8 typedef long long LL;
 9 
10 const int maxv = 1e3 + 10;
11 
12 struct edge {
13     int to, cap, rev;
14     edge(int to, int cap, int rev): to(to), cap(cap), rev(rev) {}
15 };
16 
17 vector<edge> G[maxv];
18 
19 int level[maxv];
20 int iter[maxv];
21 
22 void add_edge(int from, int to, int cap) {
23     G[from].push_back(edge(to, cap, G[to].size()));
24     G[to].push_back(edge(from, 0, G[from].size() - 1));
25 }
26 
27 void bfs(int s) {
28     memset(level, -1, sizeof(level));
29     queue<int> que;
30     level[s] = 0;
31     que.push(s);
32     while (!que.empty()) {
33         int v = que.front(); que.pop();
34         for (int i = 0; i < G[v].size(); i++) {
35             edge &e = G[v][i];
36             if (e.cap > 0 && level[e.to] < 0) {
37                 level[e.to] = level[v] + 1;
38                 que.push(e.to);
39             }
40         }
41     }
42 }
43 
44 int dfs(int v, int t, int f) {
45     if (v == t) return f;
46     for (int &i = iter[v]; i < G[v].size(); i++) {
47         edge &e = G[v][i];
48         if (e.cap > 0 && level[v] < level[e.to]) {
49             int d = dfs(e.to, t, min(f, e.cap));
50             if (d > 0) {
51                 e.cap -= d;
52                 G[e.to][e.rev].cap += d;
53                 return d;
54             }
55         }
56     }
57     return 0;
58 }
59 
60 int max_flow(int s, int t) {
61     int flow = 0;
62     while (1) {
63         bfs(s);
64         if (level[t] < 0) return flow;
65         memset(iter, 0, sizeof(iter));
66         int f;
67         while ((f = dfs(s, t, INF)) > 0) {
68             flow += f;
69         }
70     }
71 }
72 
73 
74 int main() {
75     int n, m;
76     while (~scanf("%d%d", &m, &n)) {
77         for (int i = 0; i <= n + 1; i++) G[i].clear();
78         int u, v, c;
79         for (int i = 0; i < m; i++) {
80             scanf("%d%d%d", &u, &v, &c);
81             add_edge(u, v, c);
82         }
83         int ans = 0;
84         ans = max_flow(1, n);
85         printf("%d\n", ans);
86     }
87     
88     return 0;
89 }

  1 #include <vector>
  2 #include <cstdio>
  3 #include <cstring>
  4 #include <queue>
  5 #include <algorithm>
  6 #define INF 0x3f3f3f3f
  7 using namespace std;
  8 typedef long long LL;
  9 
 10 const int maxv = 300;
 11 int graph[maxv][maxv];
 12 int K, C, M, V;
 13 
 14 struct edge {
 15     int to, cap, rev;
 16     edge(int to, int cap, int rev): to(to), cap(cap), rev(rev) {}
 17 };
 18 
 19 vector<edge> G[maxv];
 20 
 21 int level[maxv];
 22 int iter[maxv];
 23 
 24 void add_edge(int from, int to, int cap) {
 25     G[from].push_back(edge(to, cap, G[to].size()));
 26     G[to].push_back(edge(from, 0, G[from].size() - 1));
 27 }
 28 
 29 void bfs(int s) {
 30     memset(level, -1, sizeof(level));
 31     queue<int> que;
 32     level[s] = 0;
 33     que.push(s);
 34     while (!que.empty()) {
 35         int v = que.front(); que.pop();
 36         for (int i = 0; i < G[v].size(); i++) {
 37             edge &e = G[v][i];
 38             if (e.cap > 0 && level[e.to] < 0) {
 39                 level[e.to] = level[v] + 1;
 40                 que.push(e.to);
 41             }
 42         }
 43     }
 44 }
 45 
 46 int dfs(int v, int t, int f) {
 47     if (v == t) return f;
 48     for (int &i = iter[v]; i < G[v].size(); i++) {
 49         edge &e = G[v][i];
 50         if (e.cap > 0 && level[v] < level[e.to]) {
 51             int d = dfs(e.to, t, min(f, e.cap));
 52             if (d > 0) {
 53                 e.cap -= d;
 54                 G[e.to][e.rev].cap += d;
 55                 return d;
 56             }
 57         }
 58     }
 59     return 0;
 60 }
 61 
 62 int max_flow(int s, int t) {
 63     int flow = 0;
 64     while (1) {
 65         bfs(s);
 66         if (level[t] < 0) return flow;
 67         memset(iter, 0, sizeof(iter));
 68         int f;
 69         while ((f = dfs(s, t, INF)) > 0) {
 70             flow += f;
 71         }
 72     }
 73 }
 74 
 75 bool ck(int limit) {
 76     int s= V, t = V + 1;
 77     for (int i = 0; i < V + 2; i++) G[i].clear();
 78     for (int i = 0; i < K; i++) add_edge(i, t, M);
 79     for (int i = K; i < V; i++) add_edge(s, i, 1);
 80     for (int i = 0; i < K; i++) {
 81         for (int j = K; j < V; j++) {
 82             if (graph[i][j] <= limit) add_edge(j, i, 1);
 83         }
 84     }
 85     return max_flow(s, t) == C;
 86 }
 87 
 88 int solve() {
 89     for (int k = 0; k < V; k++) {
 90         for (int i = 0; i < V; i++) {
 91             for (int j = 0; j < V; j++) {
 92                 graph[i][j] = min(graph[i][j], graph[i][k] + graph[k][j]);
 93             }
 94         }
 95     }
 96     int l = 0, r = 200 * V;
 97     while (r - l > 1) {
 98         int mid = (r + l) >> 1;
 99         (ck(mid) ? r : l) = mid;
100     }
101     return r;
102 }
103 
104 
105 int main() {
106     scanf("%d%d%d", &K, &C, &M);
107     V = K + C;
108     int t;
109     for (int i = 0; i < V; i++) {
110         for (int j = 0; j < V; j++) {
111             scanf("%d", &t);
112             graph[i][j] = t ? t : INF;
113         }
114     }
115     printf("%d\n", solve());
116     return 0;
117 }

  1 #include <vector>
  2 #include <cstdio>
  3 #include <cstring>
  4 #include <queue>
  5 #include <algorithm>
  6 #define INF 0x3f3f3f3f
  7 using namespace std;
  8 typedef long long LL;
  9 
 10 const int maxv = 5e2 + 10;
 11 const int maxe = 5e3 + 10;
 12 
 13 bool Fw[maxv], Bk[maxv];
 14 int u[maxe], v[maxe];
 15 
 16 
 17 struct edge {
 18     int to, cap, rev;
 19     bool f;
 20     edge(int to, int cap, int rev, bool f): to(to), cap(cap), rev(rev), f(f) {}
 21 };
 22 
 23 vector<edge> G[maxv];
 24 
 25 int level[maxv];
 26 int iter[maxv];
 27 
 28 void add_edge(int from, int to, int cap) {
 29     G[from].push_back(edge(to, cap, G[to].size(), true));
 30     G[to].push_back(edge(from, 0, G[from].size() - 1, false));
 31 }
 32 
 33 void bfs(int s) {
 34     memset(level, -1, sizeof(level));
 35     queue<int> que;
 36     level[s] = 0;
 37     que.push(s);
 38     while (!que.empty()) {
 39         int v = que.front(); que.pop();
 40         for (int i = 0; i < G[v].size(); i++) {
 41             edge &e = G[v][i];
 42             if (e.cap > 0 && level[e.to] < 0) {
 43                 level[e.to] = level[v] + 1;
 44                 que.push(e.to);
 45             }
 46         }
 47     }
 48 }
 49 
 50 int dfs(int v, int t, int f) {
 51     if (v == t) return f;
 52     for (int &i = iter[v]; i < G[v].size(); i++) {
 53         edge &e = G[v][i];
 54         if (e.cap > 0 && level[v] < level[e.to]) {
 55             int d = dfs(e.to, t, min(f, e.cap));
 56             if (d > 0) {
 57                 e.cap -= d;
 58                 G[e.to][e.rev].cap += d;
 59                 return d;
 60             }
 61         }
 62     }
 63     return 0;
 64 }
 65 
 66 int max_flow(int s, int t) {
 67     int flow = 0;
 68     while (1) {
 69         bfs(s);
 70         if (level[t] < 0) return flow;
 71         memset(iter, 0, sizeof(iter));
 72         int f;
 73         while ((f = dfs(s, t, INF)) > 0) {
 74             flow += f;
 75         }
 76     }
 77 }
 78 
 79 void f(int x) {
 80     Fw[x] = true;
 81     for (int i = 0; i < G[x].size(); i++) {
 82         edge &e = G[x][i];
 83         if (e.f && !Fw[e.to] && e.cap) {
 84             f(e.to);
 85         }
 86     }
 87 }
 88 
 89 void b(int x) {
 90     Bk[x] = true;
 91     for (int i = 0; i < G[x].size(); i++) {
 92         edge &e = G[x][i];
 93         if (!e.f && !Bk[e.to] && G[e.to][e.rev].cap) {
 94             b(e.to);
 95         }
 96     }
 97 }
 98 
 99 int main() {
100     int n, m;
101     scanf("%d%d", &n, &m);
102     memset(Fw, false, sizeof(Fw)); memset(Bk, false, sizeof(Bk));
103     for (int i = 0; i <= n + 1; i++) G[i].clear();
104     int c;
105     for (int i = 0; i < m; i++) {
106         scanf("%d%d%d", &u[i], &v[i], &c);
107         
108         add_edge(u[i], v[i], c);
109     }
110     max_flow(0, n - 1);
111     f(0); b(n - 1);
112     int ans = 0;
113     for (int i = 0; i < n; i++) {
114         for (int j = 0; j < G[i].size(); j++) {
115             edge &e = G[i][j];
116             if (e.f && Fw[i] && Bk[e.to] && e.cap == 0) ans++;
117         }
118     }
119     printf("%d\n", ans);
120     return 0;
121 }

 1 #include <cstdio>
 2 #include <cstring>
 3 #include <algorithm>
 4 #define INF 0x3f3f3f3f
 5 using namespace std;
 6 typedef long long LL;
 7 
 8 const int maxn = 5e2 + 10;
 9 
10 int G[maxn][maxn];
11 int v[maxn];
12 int w[maxn];
13 bool visited[maxn];
14 
15 int stoer_wagner(int n) {
16     int min_cut = INF;
17     for (int i = 0; i < n; i++) {
18         v[i] = i;
19     }
20     while (n > 1) {
21         int pre = 0;
22         memset(visited, 0, sizeof(visited));
23         memset(w, 0, sizeof(w));
24         for (int i = 1; i < n; i++) {
25             int k = -1;
26             for (int j = 1; j < n; j++) {
27                 if (!visited[v[j]]) {
28                     w[v[j]] += G[v[pre]][v[j]];
29                     if (k == -1 || w[v[k]] < w[v[j]]) k = j;
30                 }
31             }
32             visited[v[k]] = true;
33             if (i == n - 1) {
34                 const int s = v[pre], t = v[k];
35                 min_cut = min(min_cut, w[t]);
36                 for (int j = 0; j < n; j++) {
37                     G[s][v[j]] += G[v[j]][t];
38                     G[v[j]][s] += G[v[j]][t];
39                 }
40                 v[k] = v[--n];
41             }
42             pre = k;
43         }
44     }
45     return min_cut;
46 }
47 
48 int main() {
49     int n, m;
50     while (~scanf("%d%d", &n, &m)) {
51         memset(G, 0, sizeof(G));
52         int u, v, w;
53         while (m--) {
54             scanf("%d%d%d", &u, &v, &w);
55             G[u][v] += w;
56             G[v][u] += w;
57         }
58         printf("%d\n", stoer_wagner(n));
59     }
60     return 0;
61 }

  1 #include <vector>
  2 #include <cstdio>
  3 #include <cstring>
  4 #include <queue>
  5 #include <algorithm>
  6 #define INF 0x3f3f3f3f
  7 using namespace std;
  8 typedef long long LL;
  9 
 10 const int maxv = 1e3 + 10;
 11 const int maxe = 4e4 + 10;
 12 
 13 int in[maxv], out[maxv], lb[maxe];
 14 int u[maxe], v[maxe];
 15 int S, T;
 16 int ans[maxe];
 17 
 18 struct edge {
 19     int to, cap, rev;
 20     edge(int to, int cap, int rev): to(to), cap(cap), rev(rev) {}
 21 };
 22 
 23 vector<edge> G[maxv];
 24 
 25 int level[maxv];
 26 int iter[maxv];
 27 
 28 
 29 void add_edge(int from, int to, int cap) {
 30     ans[++ans[0]] = G[from].size();
 31     G[from].push_back(edge(to, cap, G[to].size()));
 32     G[to].push_back(edge(from, 0, G[from].size() - 1));
 33 }
 34 
 35 void bfs(int s) {
 36     memset(level, -1, sizeof(level));
 37     queue<int> que;
 38     level[s] = 0;
 39     que.push(s);
 40     while (!que.empty()) {
 41         int v = que.front(); que.pop();
 42         for (int i = 0; i < G[v].size(); i++) {
 43             edge &e = G[v][i];
 44             if (e.cap > 0 && level[e.to] < 0) {
 45                 level[e.to] = level[v] + 1;
 46                 que.push(e.to);
 47             }
 48         }
 49     }
 50 }
 51 
 52 int dfs(int v, int t, int f) {
 53     if (v == t) return f;
 54     for (int &i = iter[v]; i < G[v].size(); i++) {
 55         edge &e = G[v][i];
 56         if (e.cap > 0 && level[v] < level[e.to]) {
 57             int d = dfs(e.to, t, min(f, e.cap));
 58             if (d > 0) {
 59                 e.cap -= d;
 60                 G[e.to][e.rev].cap += d;
 61                 return d;
 62             }
 63         }
 64     }
 65     return 0;
 66 }
 67 
 68 int max_flow(int s, int t) {
 69     int flow = 0;
 70     while (1) {
 71         bfs(s);
 72         if (level[t] < 0) return flow;
 73         memset(iter, 0, sizeof(iter));
 74         int f;
 75         while ((f = dfs(s, t, INF)) > 0) {
 76             flow += f;
 77         }
 78     }
 79 }
 80 
 81 void init(int n) {
 82     S = 0, T = n + 1;
 83     memset(out, 0, sizeof(out)); memset(in, 0, sizeof(in));
 84     memset(lb, 0, sizeof(lb));   ans[0] = 0;
 85     for (int i = 0; i <= T; i++) G[i].clear();
 86 }
 87 
 88 
 89 int main() {
 90     int n, m;
 91     int b, c;
 92     scanf("%d%d", &n, &m);
 93     init(n);
 94     for (int i = 0; i < m; i++) {
 95         scanf("%d%d%d%d", &u[i], &v[i], &b, &c);
 96         out[u[i]] += b;
 97         in[v[i]] += b;
 98         lb[i] = b;
 99         add_edge(u[i], v[i], c - b);
100     }    
101     for (int i = 1; i <= n; i++) {
102         int dif = in[i] - out[i];
103         if (dif > 0) {
104             add_edge(S, i, dif);
105             out[S] += dif;
106         } else if (dif < 0) {
107             add_edge(i, T, -dif);
108         }
109     }
110     int flow = max_flow(S, T);
111     if (flow != out[S]) {
112         puts("NO");
113     } else {
114         puts("YES");
115         for (int i = 0; i < m; i++) {
116             edge &e = G[u[i]][ans[i + 1]];
117             printf("%d\n", lb[i] + G[v[i]][e.rev].cap);
118         }
119     }
120     
121 
122     return 0;
123 }

  1 #include <vector>
  2 #include <cstdio>
  3 #include <cstring>
  4 #include <queue>
  5 #include <algorithm>
  6 #define INF 0x3f3f3f3f
  7 using namespace std;
  8 typedef long long LL;
  9 
 10 const int maxv = 2e2 + 10;
 11 
 12 int N, S, T;
 13 
 14 struct edge {
 15     int to, cap, rev, flow;
 16     edge(int to, int cap, int rev, int flow): to(to), cap(cap), rev(rev), flow(flow) {}
 17 };
 18 
 19 vector<edge> G[maxv * 2];
 20 
 21 int kn[maxv][maxv];
 22 
 23 int level[maxv * 2];
 24 int iter[maxv * 2];
 25 int isf[maxv];
 26 bool vis[maxv * 2];
 27 
 28 void add_edge(int from, int to, int cap) {
 29     G[from].push_back(edge(to, cap, G[to].size(), 0));
 30     G[to].push_back(edge(from, 0, G[from].size() - 1, 0));
 31 }
 32 
 33 void bfs(int s) {
 34     memset(level, -1, sizeof(level));
 35     queue<int> que;
 36     level[s] = 0;
 37     que.push(s);
 38     while (!que.empty()) {
 39         int v = que.front(); que.pop();
 40         for (int i = 0; i < G[v].size(); i++) {
 41             edge &e = G[v][i];
 42             if ((e.cap - e.flow) > 0 && level[e.to] < 0) {
 43                 level[e.to] = level[v] + 1;
 44                 que.push(e.to);
 45             }
 46         }
 47     }
 48 }
 49 
 50 int dfs(int v, int t, int f) {
 51     if (v == t) return f;
 52     for (int &i = iter[v]; i < G[v].size(); i++) {
 53         edge &e = G[v][i];
 54         if ((e.cap - e.flow) > 0 && level[v] < level[e.to]) {
 55             int d = dfs(e.to, t, min(f, (e.cap - e.flow)));
 56             if (d > 0) {
 57                 e.flow += d;
 58                 G[e.to][e.rev].flow -= d;
 59                 return d;
 60             }
 61         }
 62     }
 63     return 0;
 64 }
 65 
 66 int max_flow(int s, int t) {
 67     int flow = 0;
 68     while (1) {
 69         bfs(s);
 70         if (level[t] < 0) return flow;
 71         memset(iter, 0, sizeof(iter));
 72         int f;
 73         while ((f = dfs(s, t, INF)) > 0) {
 74             flow += f;
 75         }
 76     }
 77 }
 78 
 79 bool find(int s, int t) {
 80     vis[s] = true;
 81     if (s == t) return true;
 82     for (int i = 0; i < G[s].size(); i++) {
 83         edge &e = G[s][i];
 84         if (e.cap - e.flow && !vis[e.to]) {
 85             if (find(e.to, t)) return true;
 86         }
 87     }
 88     return false;
 89 }
 90 
 91 int main() {
 92     
 93     scanf("%d%d%d", &N, &S, &T);
 94     for (int i = 1; i <= N; i++) {
 95         for (int j = 1; j <= N; j++) {
 96             scanf("%d", &kn[i][j]);
 97         }
 98     }
 99     for (int i = 1; i <= N; i++) {
100         isf[i] = G[i].size();
101         add_edge(i, i + N, (i == S || i == T) ? INF : 1);
102         for (int j = i + 1; j <= N; j++) {
103             if (kn[i][j]) add_edge(i + N, j, INF), add_edge(j + N, i, INF);
104         }
105     }
106     int ans = max_flow(S, T + N);
107     if (ans == INF) {
108         puts("NO ANSWER!");
109     } else {
110         printf("%d\n", ans);
111         for (int i = 1; i <= N && ans; i++) {
112             if (i == S || i == T) continue;
113             int tmp = isf[i];
114             edge &e = G[i][tmp];
115             if (e.cap == e.flow) {
116                 memset(vis, false, sizeof(vis));
117                 if (!find(i, i + N)) {
118                     memset(iter, 0, sizeof(iter)); bfs(i); dfs(i, S, INF);
119                     memset(iter, 0, sizeof(iter)); bfs(T); dfs(T, i + N, INF);
120                     printf("%d ", i);
121                 }
122             }
123         }
124         puts("");
125     }
126     return 0;
127 }

  1 #include <cstdio>
  2 #include <cstring>
  3 #include <algorithm>
  4 #include <vector>
  5 #include <queue>
  6 #define INF 0x3f3f3f
  7 #define capType int
  8 using namespace std;
  9 typedef long long LL;
 10 
 11 const int maxv = 100;
 12 
 13 char str[10];
 14 
 15 struct edge {
 16     int to, rev;
 17     capType cap;
 18     edge(int to, capType cap, int rev): to(to), cap(cap), rev(rev) {}
 19 };
 20 
 21 
 22 vector<edge> G[maxv];
 23 
 24 
 25 int level[maxv];
 26 int iter[maxv];
 27 
 28 
 29 void add_edge(int from, int to, int cap) {
 30     G[from].push_back(edge(to, cap, G[to].size()));
 31     G[to].push_back(edge(from, 0, G[from].size() - 1));
 32 }
 33 
 34 void bfs(int s) {
 35     memset(level, -1, sizeof(level));
 36     level[s] = 0;
 37     queue<int> que;
 38     que.push(s);
 39     while (!que.empty()) {
 40         int v = que.front(); que.pop();
 41         for (int i = 0;i < G[v].size(); i++) {
 42             edge &e = G[v][i];
 43             if (e.cap > 0 && level[e.to] < 0) {
 44                 level[e.to] = level[v] + 1;
 45                 que.push(e.to);
 46             }
 47         }
 48     }
 49 }
 50 
 51 int dfs(int v, int t, int f) {
 52     if (v == t) return f;
 53     for (int &i = iter[v]; i < G[v].size(); i++) {
 54         edge &e = G[v][i];
 55         if (e.cap && level[v] < level[e.to]) {
 56             int d = dfs(e.to, t, min(f, e.cap));
 57             if (d > 0) {
 58                 e.cap -= d;
 59                 G[e.to][e.rev].cap += d;
 60                 return d;
 61             }
 62         }
 63     }
 64     return 0;
 65 }
 66 
 67 
 68 int max_flow(int s, int t) {
 69     int flow = 0;
 70     while (1) {
 71         bfs(s);
 72         if (level[t] < 0) return flow;
 73         memset(iter, 0, sizeof(iter));
 74         int f;
 75         while ((f = dfs(s, t, INF)) > 0) {
 76             flow += f;
 77         }
 78     }
 79 }
 80 
 81 int main() {
 82     int S; int T; int cnt;
 83     int Te; scanf("%d", &Te);
 84     while (Te--) {
 85         scanf("%d%d", &cnt, &T);
 86         S = cnt + 1;
 87         int c;
 88         for (int i = 0; i <= S; i++) G[i].clear();
 89         for (int i = 0; i < cnt; i++) {
 90             scanf("%s", str);
 91             if (str[0] == ‘I‘) add_edge(S, i, INF);
 92             scanf("%d", &c);
 93             int u;
 94             for (int j = 0; j < c; j++) {
 95                 scanf("%d", &u);
 96                 add_edge(i, u, INF); add_edge(u, i, 1);
 97             }
 98         }
 99         int ans = max_flow(S, T);
100         if (ans >= INF) {
101             puts("PANIC ROOM BREACH");
102         } else {
103             printf("%d\n", ans);
104         }
105     }
106     return 0;
107 }

 1 #include <cstdio>
 2 #include <cstring>
 3 #include <algorithm>
 4 #include <vector>
 5 #include <queue>
 6 #define INF 0x3f3f3f
 7 #define capType int
 8 using namespace std;
 9 typedef long long LL;
10 
11 const int maxv = 2e4 + 10;
12 
13 struct edge {
14     int to, rev;
15     capType cap;
16     edge(int to, capType cap, int rev): to(to), cap(cap), rev(rev) {}
17 };
18 
19 
20 vector<edge> G[maxv];
21 
22 
23 int level[maxv];
24 int iter[maxv];
25 
26 
27 void add_edge(int from, int to, int cap) {
28     G[from].push_back(edge(to, cap, G[to].size()));
29     G[to].push_back(edge(from, 0, G[from].size() - 1));
30 }
31 
32 void bfs(int s) {
33     memset(level, -1, sizeof(level));
34     level[s] = 0;
35     queue<int> que;
36     que.push(s);
37     while (!que.empty()) {
38         int v = que.front(); que.pop();
39         for (int i = 0;i < G[v].size(); i++) {
40             edge &e = G[v][i];
41             if (e.cap > 0 && level[e.to] < 0) {
42                 level[e.to] = level[v] + 1;
43                 que.push(e.to);
44             }
45         }
46     }
47 }
48 
49 int dfs(int v, int t, int f) {
50     if (v == t) return f;
51     for (int &i = iter[v]; i < G[v].size(); i++) {
52         edge &e = G[v][i];
53         if (e.cap && level[v] < level[e.to]) {
54             int d = dfs(e.to, t, min(f, e.cap));
55             if (d > 0) {
56                 e.cap -= d;
57                 G[e.to][e.rev].cap += d;
58                 return d;
59             }
60         }
61     }
62     return 0;
63 }
64 
65 
66 int max_flow(int s, int t) {
67     int flow = 0;
68     while (1) {
69         bfs(s);
70         if (level[t] < 0) return flow;
71         memset(iter, 0, sizeof(iter));
72         int f;
73         while ((f = dfs(s, t, INF)) > 0) {
74             flow += f;
75         }
76     }
77 }
78 
79 int main() {
80     int N, M;
81     int S, T;
82     scanf("%d%d", &N, &M);
83     S = 0; T = N + 1;
84     int a, b, w;
85     for (int i = 1; i <= N; i++) {
86         scanf("%d%d", &a, &b);
87         add_edge(S, i, a); add_edge(i, T, b);
88     }
89     for (int i = 0; i < M; i++) {
90         scanf("%d%d%d", &a, &b, &w);
91         add_edge(a, b, w); add_edge(b, a, w);
92     }
93     printf("%d\n", max_flow(S, T));
94     return 0;
95 }

  1 #include <cstdio>
  2 #include <cstring>
  3 #include <algorithm>
  4 #include <vector>
  5 #include <queue>
  6 #include <cmath>
  7 #define INF 0x3f3f3f3f
  8 #define capType int
  9 using namespace std;
 10 typedef long long LL;
 11 
 12 
 13 const int maxv = 2e2 + 10;
 14 int x[maxv], y[maxv], n[maxv], m[maxv];
 15 int v[maxv][maxv];
 16 
 17 struct edge {
 18     int to, rev;
 19     capType cap;
 20     edge(int to, capType cap, int rev): to(to), cap(cap), rev(rev) {}
 21 };
 22 
 23 
 24 vector<edge> G[maxv];
 25 
 26 int level[maxv];
 27 int iter[maxv];
 28 
 29 
 30 void add_edge(int from, int to, int cap) {
 31     G[from].push_back(edge(to, cap, G[to].size()));
 32     G[to].push_back(edge(from, 0, G[from].size() - 1));
 33 }
 34 
 35 void bfs(int s) {
 36     memset(level, -1, sizeof(level));
 37     level[s] = 0;
 38     queue<int> que;
 39     que.push(s);
 40     while (!que.empty()) {
 41         int v = que.front(); que.pop();
 42         for (int i = 0;i < G[v].size(); i++) {
 43             edge &e = G[v][i];
 44             if (e.cap > 0 && level[e.to] < 0) {
 45                 level[e.to] = level[v] + 1;
 46                 que.push(e.to);
 47             }
 48         }
 49     }
 50 }
 51 
 52 int dfs(int v, int t, int f) {
 53     if (v == t) return f;
 54     for (int &i = iter[v]; i < G[v].size(); i++) {
 55         edge &e = G[v][i];
 56         if (e.cap && level[v] < level[e.to]) {
 57             int d = dfs(e.to, t, min(f, e.cap));
 58             if (d > 0) {
 59                 e.cap -= d;
 60                 G[e.to][e.rev].cap += d;
 61                 return d;
 62             }
 63         }
 64     }
 65     return 0;
 66 }
 67 
 68 
 69 int max_flow(int s, int t) {
 70     int flow = 0;
 71     while (1) {
 72         bfs(s);
 73         if (level[t] < 0) return flow;
 74         memset(iter, 0, sizeof(iter));
 75         int f;
 76         while ((f = dfs(s, t, INF)) > 0) {
 77             flow += f;
 78         }
 79     }
 80 }
 81 
 82 
 83 double dist(int a, int b, int c, int d) {
 84     return sqrt(1.0 * (a - c) * (a - c) + 1.0 * (b - d) * (b - d));
 85 }
 86 
 87 int N, sum;
 88 
 89 void init() {
 90     for (int i = 0; i <= N + N; i++) G[i].clear();
 91     memset(v, 0, sizeof(v));
 92     sum = 0;
 93 }
 94 
 95 int main() {
 96     int Te;
 97     int S;
 98     double dis;
 99     scanf("%d", &Te);
100     while (Te--) {
101         scanf("%d%lf", &N, &dis);
102         init();
103         for (int i = 0; i < N; i++) {
104             scanf("%d%d%d%d", &x[i], &y[i], &n[i], &m[i]);
105             sum += n[i];
106         }
107         for (int i = 0; i < N; i++) {
108             for (int j = i + 1; j < N; j++) {
109                 if (dist(x[i], y[i], x[j], y[j]) <= dis) {
110                     v[i][++v[i][0]] = j;
111                     v[j][++v[j][0]] = i;
112                 }
113             }
114         }
115         bool flag = false;
116         S = N + N;
117         for (int T = 0; T < N; T++) {
118             for (int i = 0; i <= N + N; i++) G[i].clear();
119             for (int i = 0; i < N; i++) {
120                 add_edge(S, i, n[i]);
121                 add_edge(i, i + N, m[i]);
122                 for (int j = 1; j <= v[i][0]; j++) {
123                     add_edge(i + N, v[i][j], INF);
124     //                printf("there is a edge between %d and %d\n", i, v[i][j]);
125                 }
126             }
127             int ans = max_flow(S, T);
128             if (ans == sum) {
129                 if (flag) printf(" ");
130                 printf("%d", T);
131                 flag = true;
132             }
133         }
134         if (!flag) printf("-1");
135         puts("");
136 
137     }
138     
139     return 0;
140 }

  1 #include <vector>
  2 #include <queue>
  3 #include <cstdio>
  4 #include <cstring>
  5 #include <algorithm>
  6 #define INF 0x3f3f3f3f
  7 using namespace std;
  8 typedef long long LL;
  9 typedef int capType;
 10 
 11 const int maxv = 2e2 + 10;
 12 const int maxh = 1e3 + 10;
 13 
 14 int N, M;
 15 int pre[maxh], pig[maxh];
 16 
 17 struct edge {
 18     int to, rev;
 19     capType cap;
 20     edge(int to, capType cap, int rev): to(to), cap(cap), rev(rev) {}
 21 };
 22 
 23 
 24 vector<edge> G[maxv];
 25 int level[maxv], iter[maxv];
 26 
 27 
 28 void add_edge(int from, int to, capType cap) {
 29     G[from].push_back(edge(to, cap, G[to].size()));
 30     G[to].push_back(edge(from, 0, G[from].size() - 1));
 31 }
 32 
 33 
 34 void bfs(int s) {
 35     memset(level, -1, sizeof(level));
 36     level[s] = 0;
 37     queue<int> que;
 38     que.push(s);
 39     while (!que.empty()) {
 40         int v = que.front(); que.pop();
 41         for (int i = 0; i < G[v].size(); i++) {
 42             edge &e = G[v][i];
 43             if (e.cap > 0 && level[e.to] < 0) {
 44                 level[e.to] = level[v] + 1;
 45                 que.push(e.to);
 46             } 
 47         }
 48     }
 49 }
 50 
 51 capType dfs(int v, int t, int f) {
 52     if (v == t) return f;
 53     for (int &i = iter[v]; i < G[v].size(); i++) {
 54         edge &e = G[v][i];
 55         if (e.cap > 0 && level[v] < level[e.to]) {
 56             capType d = dfs(e.to, t, min(f, e.cap));
 57             if (d > 0) {
 58                 e.cap -= d;
 59                 G[e.to][e.rev].cap += d;
 60                 return d;
 61             }
 62         }
 63     }
 64     return 0;
 65 }
 66 
 67 capType max_flow(int s, int t) {
 68     capType flow = 0;
 69     while (1) {
 70         bfs(s);
 71         if (level[t] < 0) return flow;
 72         memset(iter, 0, sizeof(iter));
 73         capType f;
 74         while ((f = dfs(s, t, INF)) > 0) flow += f;
 75     }
 76 }
 77 
 78 
 79 int main() {
 80     memset(pre, 0, sizeof(pre)); 
 81     scanf("%d%d", &M, &N);
 82     int S, T;
 83     S = 0; T = N + 1;
 84     for (int i = 1; i <= M; i++) {
 85         scanf("%d", &pig[i]);
 86     }
 87     int cnt, t, sum;
 88     for (int i = 1; i <= N; i++) {
 89         scanf("%d", &cnt);
 90         sum = 0;
 91         for (int j = 1; j <= cnt; j++) {
 92             scanf("%d", &t);
 93             if (pre[t]) {
 94                 add_edge(pre[t], i, INF);
 95             } else {
 96                 sum += pig[t];
 97             }
 98             pre[t] = i;
 99         }
100         scanf("%d", &cnt);
101         add_edge(i, T, cnt);
102         add_edge(S, i, sum);
103     }
104     capType ans = max_flow(S, T);
105     printf("%d\n", ans);
106     return 0;
107 }

  1 #include <vector>
  2 #include <queue>
  3 #include <cstdio>
  4 #include <cstring>
  5 #include <algorithm>
  6 #define INF 0x3f3f3f3f
  7 using namespace std;
  8 typedef long long LL;
  9 typedef int capType;
 10 
 11 const int maxv = 2e2 + 10;
 12 
 13 int in[maxv], out[maxv];
 14 
 15 struct edge {
 16     int to, rev;
 17     capType cap;
 18     edge(int to, capType cap, int rev): to(to), cap(cap), rev(rev) {}
 19 };
 20 
 21 
 22 vector<edge> G[maxv];
 23 int level[maxv], iter[maxv];
 24 
 25 
 26 void add_edge(int from, int to, capType cap) {
 27     G[from].push_back(edge(to, cap, G[to].size()));
 28     G[to].push_back(edge(from, 0, G[from].size() - 1));
 29 }
 30 
 31 
 32 void bfs(int s) {
 33     memset(level, -1, sizeof(level));
 34     level[s] = 0;
 35     queue<int> que;
 36     que.push(s);
 37     while (!que.empty()) {
 38         int v = que.front(); que.pop();
 39         for (int i = 0; i < G[v].size(); i++) {
 40             edge &e = G[v][i];
 41             if (e.cap > 0 && level[e.to] < 0) {
 42                 level[e.to] = level[v] + 1;
 43                 que.push(e.to);
 44             } 
 45         }
 46     }
 47 }
 48 
 49 capType dfs(int v, int t, int f) {
 50     if (v == t) return f;
 51     for (int &i = iter[v]; i < G[v].size(); i++) {
 52         edge &e = G[v][i];
 53         if (e.cap > 0 && level[v] < level[e.to]) {
 54             capType d = dfs(e.to, t, min(f, e.cap));
 55             if (d > 0) {
 56                 e.cap -= d;
 57                 G[e.to][e.rev].cap += d;
 58                 return d;
 59             }
 60         }
 61     }
 62     return 0;
 63 }
 64 
 65 capType max_flow(int s, int t) {
 66     capType flow = 0;
 67     while (1) {
 68         bfs(s);
 69         if (level[t] < 0) return flow;
 70         memset(iter, 0, sizeof(iter));
 71         capType f;
 72         while ((f = dfs(s, t, INF)) > 0) flow += f;
 73     }
 74 }
 75 
 76 void init(int n) {
 77     for (int i = 0; i <= n + 1; i++) G[i].clear();
 78     memset(in, 0, sizeof(in)); memset(out, 0, sizeof(out));
 79 }
 80 
 81 
 82 int main() {
 83     int Te, n, m;
 84     scanf("%d", &Te);
 85     while (Te--) {
 86         scanf("%d%d", &n, &m);
 87         init(n);
 88         int u, v, dir;
 89         for (int i = 0; i < m; i++) {
 90             scanf("%d%d%d", &u, &v, &dir);
 91             out[u]++; in[v]++;
 92             if (dir == 0) add_edge(u, v, 1);
 93         }
 94         bool flag = true;
 95         int S = 0, T = n + 1;
 96         int sum = 0;
 97         for (int i = 1; i <= n && flag; i++) {
 98             if (out[i] - in[i] > 0) {
 99                 int t = (out[i] - in[i]) / 2;
100                 sum += t;
101                 add_edge(S, i, t);
102             } else if (in[i] - out[i] > 0) {
103                 add_edge(i, T, (in[i] - out[i]) / 2);    
104             }
105             if ((out[i] - in[i]) & 1) flag = false;
106         }
107         if (!flag) {
108             puts("impossible");
109         } else {
110             int ans = max_flow(S, T);
111             if (ans == sum) {
112                 puts("possible");
113             } else {
114                 puts("impossible");
115             }
116         }
117     }
118     return 0;
119 }

 1 #include <cstdio>
 2 #include <cstring>
 3 #include <algorithm>
 4 #include <vector>
 5 #include <queue>
 6 #define INF 0x3f3f3f3f
 7 #define capType int 
 8 using namespace std;
 9 typedef long long LL;
10 
11 const int maxv = 1e3 + 10;
12 
13 struct edge {
14     int to, rev;
15     capType cap;
16     edge(int to, capType cap, int rev): to(to), cap(cap), rev(rev) {}
17 };
18 
19 int level[maxv];
20 int iter[maxv];
21 vector<edge> G[maxv];
22 
23 void add_edge(int from, int to, capType cap) {
24     G[from].push_back(edge(to, cap, G[to].size()));
25     G[to].push_back(edge(from, 0, G[from].size() - 1));
26 }
27 
28 void bfs(int s) {
29     memset(level, -1, sizeof(level));
30     level[s] = 0;
31     queue<int> que;
32     que.push(s);
33     while (!que.empty()) {
34         int v = que.front(); que.pop();
35         for (int i = 0; i < G[v].size(); i++) {
36             edge &e = G[v][i];
37             if (e.cap > 0 && level[e.to] < 0) {
38                 level[e.to] = level[v] + 1;
39                 que.push(e.to);
40             }
41         }
42     }
43 }
44 
45 
46 capType dfs(int v, int t, capType f) {
47     if (v == t) return f;
48     for (int &i = iter[v]; i < G[v].size(); i++) {
49         edge &e = G[v][i];
50         if (e.cap > 0 && level[v] < level[e.to]) {
51             capType d = dfs(e.to, t, min(f, e.cap));
52             if (d > 0) {
53                 e.cap -= d;
54                 G[e.to][e.rev].cap += d;
55                 return d;
56             }
57         }
58     }
59     return 0;
60 }
61 
62 capType max_flow(int s, int t) {
63     capType flow = 0;
64     while (1) {
65         bfs(s);
66         if (level[t] < 0) return flow;
67         memset(iter, 0, sizeof(iter));
68         int f;
69         while ((f = dfs(s, t, INF)) > 0) {
70             flow += f;
71         }
72     }
73 }
74 
75 
76 int main() {
77     int N, F, D; int S, T;
78     int f, d;
79     scanf("%d%d%d", &N, &F, &D);
80     S = 0; T = N + N + F + D + 1;
81     for (int i = 1; i <= F; i++) add_edge(S, N + N + i, 1);
82     for (int i = 1; i <= D; i++) add_edge(N + N + F + i, T, 1);
83     for (int i = 1; i <= N; i++) {
84         add_edge(i, i + N, 1);
85         scanf("%d%d", &f, &d);
86         int t;
87         for (int j = 0; j < f; j++) {
88             scanf("%d", &t);
89             add_edge(t + N + N, i, 1);
90         }
91         for (int j = 0; j < d; j++) {
92             scanf("%d", &t);
93             add_edge(i + N, t + N + N + F, 1);
94         }
95     }
96     printf("%d\n", max_flow(S, T));
97     return 0;
98 }

  1 #include <vector>
  2 #include <queue>
  3 #include <cstdio>
  4 #include <cstring>
  5 #include <algorithm>
  6 #define capType int
  7 #define INF 0x3f3f3f3f
  8 using namespace std;
  9 typedef long long LL;
 10 
 11 const int maxv = 110;
 12 int mp[maxv][maxv];
 13 
 14 struct edge {
 15     int to, cost;
 16     edge(int to, int cost): to(to), cost(cost) {}
 17 };
 18 typedef pair<int, int> P;
 19 
 20 int V;
 21 vector<edge> G1[maxv];
 22 vector<edge> G2[maxv];
 23 int d1[maxv], d2[maxv];
 24 
 25 void dij(int s, int *d, vector<edge> G[]) {
 26     //memset(d, INF, sizeof(d));
 27     fill(d, d + V + 1, INF);
 28     d[s] = 0;
 29     priority_queue<P, vector<P>, greater<P> > que;
 30     que.push(P(0, s));
 31     while (!que.empty()) {
 32         P p = que.top(); que.pop();
 33         int v = p.second;
 34         if (d[v] < p.first) continue;
 35         for (int i = 0; i < G[v].size(); i++) {
 36             edge &e = G[v][i];
 37             if (d[e.to] > d[v] + e.cost) {
 38                 d[e.to] = d[v] + e.cost;
 39                 que.push(P(d[e.to], e.to));
 40             }
 41         }
 42     }
 43 }
 44 
 45 struct _edge {
 46     int to, rev;
 47     capType cap;
 48     _edge(int to, capType cap, int rev): to(to), cap(cap), rev(rev) {}
 49 };
 50 
 51 vector<_edge> _G[maxv];
 52 int level[maxv];
 53 int iter[maxv];
 54 
 55 void add_edge(int from, int to, int cap) {
 56     _G[from].push_back(_edge(to, cap, _G[to].size()));
 57     _G[to].push_back(_edge(from, 0, _G[from].size() - 1));
 58 }
 59 
 60 void bfs(int s) {
 61     memset(level, -1, sizeof(level));
 62     level[s] = 0;
 63     queue<int> que;
 64     que.push(s);
 65     while (!que.empty()) {
 66         int v = que.front(); que.pop();
 67         for (int i = 0; i < _G[v].size(); i++) {
 68             _edge &e = _G[v][i];
 69             if (e.cap > 0 && level[e.to] < 0) {
 70                 level[e.to] = level[v] + 1;
 71                 que.push(e.to);
 72             }
 73         }
 74     }
 75 }
 76 
 77 capType dfs(int v, int t, int f) {
 78     if (v == t) return f;
 79     for (int &i = iter[v]; i < _G[v].size(); i++) {
 80         _edge &e = _G[v][i];
 81         if (e.cap && level[v] < level[e.to]) {
 82             capType d = dfs(e.to, t, min(f, e.cap));
 83             if (d > 0) {
 84                 e.cap -= d;
 85                 _G[e.to][e.rev].cap += d;
 86                 return d;
 87             }
 88         }
 89     }
 90     return 0;
 91 }
 92 
 93 capType max_flow(int s, int t) {
 94     capType flow = 0;
 95     while (1) {
 96         bfs(s);
 97         if (level[t] < 0) return flow;
 98         memset(iter, 0, sizeof(iter));
 99         capType f;
100         while ((f = dfs(s, t, INF)) > 0) {
101             flow += f;
102         }
103     }
104 }
105 
106 int main() {
107     int tmp;
108     int S, T;
109     while (~scanf("%d", &V)) {
110         for (int i = 0; i <= V + 1; i++) G1[i].clear(), G2[i].clear(), _G[i].clear();
111         for (int i = 0; i < V; i++) {
112             for (int j = 0; j < V; j++) {
113                 scanf("%d", &mp[i][j]);
114                 if (mp[i][j] >= 0 && i != j) {
115                     G1[i].push_back(edge(j, mp[i][j]));
116                     G2[j].push_back(edge(i, mp[i][j]));
117                 }
118             }
119         }
120         scanf("%d%d", &S, &T);
121         if (S == T) {
122             puts("inf");
123         } else {
124             dij(S, d1, G1);
125             dij(T, d2, G2);
126             for (int i = 0; i < V; i++) {
127                 for (int j = 0; j < V; j++) {
128                     if (i == j || mp[i][j] == -1) continue;
129                     if (d1[i] + d2[j] + mp[i][j] == d1[T]) {
130                         add_edge(i, j, 1);
131                     }
132                 }
133             }
134             printf("%d\n", max_flow(S, T));
135         }
136         
137     }
138     return 0;
139 }