poj_3281Dining（网络流+拆点）

标签： 网络流

题目链接

题意：

  1. 一头牛只吃特定的几种食物和特定的几种饮料，John手里每种食物和饮料都只有一个，问最多能够满足几头牛的需求(水和食物都必须和他们的胃口)。

题解：

  1. 网络流
  2. 建图：从源点向每个食物连一条边，容量为1，
  3. 将牛拆成两个点牛，牛'，中间连边，容量为1
  4. 从食物向牛连边，容量为1
  5. 连牛'和饮料，容量为1
  6. 连饮料和汇点，容量为1

网络流三种算法的理解和代码实现以及相应的模板

先介绍一个定理：

  1. 最大流最小割定理：
  2.     割：去掉某几条边使得源点和汇点不再联通，那么这几条边就叫一个割，这几条边的边权和最小的就叫做最小割。
  3.     一个图的最大流就是这个图对应的最小割，可以看做是一个沙漏，最大流是要求这个沙漏每个时刻最大的流量，那就相当于是求沙漏最细的地方的流量。而最小割就相当于是用一个刀子将这个沙漏一分为二，然后找横截切面最小的就是这个沙漏最细的地方。

再介绍一些网络流的一些基本性质

  1. 流网络G的流（flow）是一个实值函数   f ：V ×V → R，且满足下列三个性质

(1) 容量限制：对于∀u,v∈V ，要求 f (u,v) ≤ c(u,v)。

(2) 反对称性：对于∀u,v∈V ，要求 f (u,v) = −f (v,u)。

(3) 流守恒性：对于∀u,v∈V −{s,t}，要求∑f (u,v) =0。

f(u,v)即为u到v的流。流 f =∑f(S,v);

最大流顾名思义就是使流f最大，也就是水龙头里能放出的水要最多。

  • EdmondsKarp算法
  1. 算法思路：

    通过多次bfs每次bfs找到一条增广路，然后更新残留网络，来寻找最大流。
  2. 算法复杂度：这个是实现起来最慢的一个，对于这个题用时 79MS
  3. 算法模板：
  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. #include<vector>
  5. #include<queue>
  6. using namespace std;
  7. const int maxn = 1008;
  8. const int INF = 111111111;
  9. struct Edge{
  10.     int from,to,cap,flow;
  11.     Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f){}
  12. };
  13. int s,t;//源点。汇点
  14. struct EdmondsKarp{
  15.     int n,m;
  16.     vector<Edge>edge; //边数的两倍
  17.     vector<int>G[maxn]; //邻接表，G[i][j]表示i的第j条边在e数组中的序号
  18.     int a[maxn]; //当起点到i的可改进量
  19.     int p[maxn]; //最短路树上p的入弧编号
  21.     void init(int n){
  22.         for(int i=0;i<=n;i++) G[i].clear();
  23.         edge.clear();
  24.     }
  26.     void AddEdge(int from,int to,int cap){
  27.         edge.push_back(Edge(from,to,cap,0));
  28.         edge.push_back(Edge(to,from,0,0)); //反向弧
  29.         m=edge.size();
  30.         G[from].push_back(m-2);
  31.         G[to].push_back(m-1);
  32.     }
  34.     int Maxflow(int s,int t){
  35.         int flow=0;
  36.         for(;;){
  37.             memset(a,0,sizeof(a));
  38.             queue<int>q;
  39.             while(!q.empty()) q.pop();
  40.             q.push(s);
  41.             a[s]=INF;
  42.             while(!q.empty()){
  43.                 int x=q.front();q.pop();
  44.                 for(int i=0;i<G[x].size();i++){
  45.                     Edge& e=edge[G[x][i]];
  46.                     if(!a[e.to]&&e.cap>e.flow){
  47.                         p[e.to]=G[x][i];
  48.                         a[e.to]=min(a[x],e.cap-e.flow);
  49.                         q.push(e.to);
  50.                     }
  51.                 }
  52.                 if(a[t]) break;
  53.             }
  54.             if(!a[t]) return flow;
  55.             for(int u=t;u!=s;u=edge[p[u]].from){
  56.                 edge[p[u]].flow+=a[t];
  57.                 edge[p[u]^1].flow-=a[t];
  58.             }
  59.             flow+=a[t];
  60.         }
  61.     }
  62. };
  1. 这个题的代码：
  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. #include<vector>
  5. #include<queue>
  6. using namespace std;
  7. const int maxn = 1008;
  8. const int INF = 111111111;
  9. struct Edge{
  10.     int from,to,cap,flow;
  11.     Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f){}
  12. };
  13. int s,t;
  14. struct EdmondsKarp{
  15.     int n,m;
  16.     vector<Edge>edge; //边数的两倍
  17.     vector<int>G[maxn]; //邻接表，G[i][j]表示i的第j条边在e数组中的序号
  18.     int a[maxn]; //当起点到i的可改进量
  19.     int p[maxn]; //最短路树上p的入弧编号
  21.     void init(int n){
  22.         for(int i=0;i<=n;i++) G[i].clear();
  23.         edge.clear();
  24.     }
  26.     void AddEdge(int from,int to,int cap){
  27.         edge.push_back(Edge(from,to,cap,0));
  28.         edge.push_back(Edge(to,from,0,0)); //反向弧
  29.         m=edge.size();
  30.         G[from].push_back(m-2);
  31.         G[to].push_back(m-1);
  32.     }
  34.     int Maxflow(int s,int t){
  35.         int flow=0;
  36.         for(;;){
  37.             memset(a,0,sizeof(a));
  38.             queue<int>q;
  39.             while(!q.empty()) q.pop();
  40.             q.push(s);
  41.             a[s]=INF;
  42.             while(!q.empty()){
  43.                 int x=q.front();q.pop();
  44.                 for(int i=0;i<G[x].size();i++){
  45.                     Edge& e=edge[G[x][i]];
  46.                     if(!a[e.to]&&e.cap>e.flow){
  47.                         p[e.to]=G[x][i];
  48.                         a[e.to]=min(a[x],e.cap-e.flow);
  49.                         q.push(e.to);
  50.                     }
  51.                 }
  52.                 if(a[t]) break;
  53.             }
  54.             if(!a[t]) return flow;
  55.             for(int u=t;u!=s;u=edge[p[u]].from){
  56.                 edge[p[u]].flow+=a[t];
  57.                 edge[p[u]^1].flow-=a[t];
  58.             }
  59.             flow+=a[t];
  60.         }
  61.     }
  62. };
  64. int main()
  65. {
  66.     int N,F,D;
  67.     s = 0;
  68.     while(~scanf("%d%d%d",&N,&F,&D))
  69.     {
  70.         EdmondsKarp EK;
  71.         t = N*2+F+D+1;
  72.         EK.init(t+1);
  73.         int f,d;
  74.         for(int i = 1; i <= F; i++){//源点向各种食物连边
  75.             EK.AddEdge(s,i,1);
  76.         }
  77.         int tm;
  78.         for(int i = 1; i <= N; i++){
  79.             scanf("%d%d",&f,&d);
  80.             for(int j = 1; j <= f; j++){
  81.                 scanf("%d",&tm);
  82.                 EK.AddEdge(tm,F+i*2-1,1);//食物向喜欢它的牛连边
  83.             }
  84.             EK.AddEdge(F+i*2-1,F+i*2,1);//牛拆点
  85.             for(int j = 1; j <= d; j++){
  86.                 scanf("%d",&tm);
  87.                 EK.AddEdge(F+i*2,2*N+F+tm,1);//牛向喜欢的饮料连边
  88.             }
  89.         }
  90.         for(int i = 1; i <= D; i++){
  91.             EK.AddEdge(2*N+F+i,t,1);//所有饮料向汇点连边
  92.         }
  93.         //puts("haha");
  94.         int ans = EK.Maxflow(0,t);
  95.         printf("%d\n",ans);
  96.     }
  97.     return 0;
  98. }
  • Dinic算法
  1. 算法思路：

    一次bfs一次dfs,每次bfs给每个点一个层数值（当前点到源点的距离），然后dfs通过层数的限制一次可以更新多条增广路，来寻找最大流。
  2. 算法复杂度：这个是实现起来稍微快一点的一个，一般可以解决大多数问题，复杂度是\(O(n^2m)\)，对于这个题用时 32MS
  3. 算法模板：
  1. #include <cstdio>
  2. #include <cstring>
  3. #include <algorithm>
  4. #include <vector>
  5. #include <queue>
  6. using namespace std;
  8. const int maxn = 500 + 5;
  9. const int INF = 100000000;
  10. struct Edge{
  11.   int from, to, cap, flow;
  12. };
  14. struct Dinic{
  15.   int n, m, s, t;
  16.   vector<Edge> edges;
  17.   vector<int> G[maxn];
  18.   bool vis[maxn];
  19.   int d[maxn];
  20.   int cur[maxn];
  22.   void init(int n)
  23.   {
  24.     this->n = n;
  25.     for(int i=0; i<=n; ++i) G[i].clear();
  26.     edges.clear();
  27.   }
  29.   void AddEdge(int from, int to, int cap)
  30.   {
  31.     edges.push_back((Edge){from, to, cap, 0});
  32.     edges.push_back((Edge){to, from, 0, 0});
  33.     m = edges.size();
  34.     G[from].push_back(m-2);
  35.     G[to].push_back(m-1);
  36.   }
  38.   bool BFS()
  39.   {
  40.     memset(vis, 0, sizeof vis );
  41.     queue<int> Q;
  42.     Q.push(s);
  43.     vis[s] = 1;
  44.     d[s] = 0;
  45.     while(!Q.empty())
  46.     {
  47.       int x = Q.front(); Q.pop();
  48.       for(int i=0; i<G[x].size(); ++i)
  49.       {
  50.         Edge& e = edges[G[x][i]];
  51.         if(!vis[e.to] && e.cap > e.flow)
  52.         {
  53.           vis[e.to] = 1;
  54.           d[e.to] = d[x] + 1;
  55.           Q.push(e.to);
  56.         }
  57.       }
  58.     }
  59.     return vis[t];
  60.   }
  62.   int DFS(int x, int a)
  63.   {
  64.     if(x == t || a == 0) return a;
  65.     int flow = 0, f;
  66.     for(int& i = cur[x]; i<G[x].size(); ++i)
  67.     {
  68.       Edge& e = edges[G[x][i]];
  69.       if(d[x] + 1 == d[e.to] && (f=DFS(e.to, min(a,e.cap-e.flow)))>0)
  70.       {
  71.         e.flow += f;
  72.         edges[G[x][i]^1].flow -= f;
  73.         flow += f;
  74.         a -= f;
  75.         if(a==0) break;
  76.       }
  77.     }
  78.     return flow;
  79.   }
  81.   int Maxflow(int s, int t)
  82.   {
  83.     this->s = s; this->t =t;
  84.     int flow = 0;
  85.     while(BFS()){
  86.       memset(cur, 0, sizeof cur );
  87.       flow += DFS(s, INF);
  88.     }
  89.     return flow;
  90.   }
  91. }DD;
  93. /*初始化源点汇点，点数
  94. DD.s =
  95. DD.t =
  96. DD.n =
  97. DD.init(DD.n);
  98. //加边操作
  99. DD.AddEdge(DD.s,i,1);
  100. //计算结果
  101. int ans = DD.Maxflow(0,DD.t);

4.这个题ac代码：

  1. //ac了的dinic模板
  2. #include <cstdio>
  3. #include <cstring>
  4. #include <algorithm>
  5. #include <vector>
  6. #include <queue>
  7. using namespace std;
  9. const int maxn = 500 + 5;
  10. const int INF = 100000000;
  11. struct Edge{
  12.   int from, to, cap, flow;
  13. };
  15. struct Dinic{
  16.   int n, m, s, t;
  17.   vector<Edge> edges;
  18.   vector<int> G[maxn];
  19.   bool vis[maxn];
  20.   int d[maxn];
  21.   int cur[maxn];
  23.   void init(int n)
  24.   {
  25.     this->n = n;
  26.     for(int i=0; i<=n; ++i) G[i].clear();
  27.     edges.clear();
  28.   }
  30.   void AddEdge(int from, int to, int cap)
  31.   {
  32.     edges.push_back((Edge){from, to, cap, 0});
  33.     edges.push_back((Edge){to, from, 0, 0});
  34.     m = edges.size();
  35.     G[from].push_back(m-2);
  36.     G[to].push_back(m-1);
  37.   }
  39.   bool BFS()
  40.   {
  41.     memset(vis, 0, sizeof vis );
  42.     queue<int> Q;
  43.     Q.push(s);
  44.     vis[s] = 1;
  45.     d[s] = 0;
  46.     while(!Q.empty())
  47.     {
  48.       int x = Q.front(); Q.pop();
  49.       for(int i=0; i<G[x].size(); ++i)
  50.       {
  51.         Edge& e = edges[G[x][i]];
  52.         if(!vis[e.to] && e.cap > e.flow)
  53.         {
  54.           vis[e.to] = 1;
  55.           d[e.to] = d[x] + 1;
  56.           Q.push(e.to);
  57.         }
  58.       }
  59.     }
  60.     return vis[t];
  61.   }
  63.   int DFS(int x, int a)
  64.   {
  65.     if(x == t || a == 0) return a;
  66.     int flow = 0, f;
  67.     for(int& i = cur[x]; i<G[x].size(); ++i)
  68.     {
  69.       Edge& e = edges[G[x][i]];
  70.       if(d[x] + 1 == d[e.to] && (f=DFS(e.to, min(a,e.cap-e.flow)))>0)
  71.       {
  72.         e.flow += f;
  73.         edges[G[x][i]^1].flow -= f;
  74.         flow += f;
  75.         a -= f;
  76.         if(a==0) break;
  77.       }
  78.     }
  79.     return flow;
  80.   }
  82.   int Maxflow(int s, int t)
  83.   {
  84.     this->s = s; this->t =t;
  85.     int flow = 0;
  86.     while(BFS()){
  87.       memset(cur, 0, sizeof cur );
  88.       flow += DFS(s, INF);
  89.     }
  90.     return flow;
  91.   }
  92. }DD;
  93. int main()
  94. {
  95.     int N,F,D;
  96.     DD.s = 0;
  97.     while(~scanf("%d%d%d",&N,&F,&D))
  98.     {
  99.         DD.t = N*2+F+D+1;
  100.         DD.n = DD.t+1;
  101.         DD.init(DD.n);
  102.         int f,d;
  103.         for(int i = 1; i <= F; i++){//源点向各种食物连边
  104.             DD.AddEdge(DD.s,i,1);
  105.         }
  106.         int tm;
  107.         for(int i = 1; i <= N; i++){
  108.             scanf("%d%d",&f,&d);
  109.             for(int j = 1; j <= f; j++){
  110.                 scanf("%d",&tm);
  111.                 DD.AddEdge(tm,F+i*2-1,1);//食物向喜欢它的牛连边
  112.             }
  113.             DD.AddEdge(F+i*2-1,F+i*2,1);//牛拆点
  114.             for(int j = 1; j <= d; j++){
  115.                 scanf("%d",&tm);
  116.                 DD.AddEdge(F+i*2,2*N+F+tm,1);//牛向喜欢的饮料连边
  117.             }
  118.         }
  119.         for(int i = 1; i <= D; i++){
  120.             DD.AddEdge(2*N+F+i,DD.t,1);//所有饮料向汇点连边
  121.         }
  122.         //puts("haha");
  123.         int ans = DD.Maxflow(0,DD.t);
  124.         printf("%d\n",ans);
  125.     }
  126.     return 0;
  127. }

*ISAP算法

  1. 算法思路：

    只一次bfs和dfs动态更新标号值,bfs给每个点一个层数值（当前点到汇点的距离），然后dfs通过层数的限制一次可以更新多条增广路，来寻找最大流。这里注意，dfs过程中动态更新标号值，如果当前的这个点到汇点的边的残余流量值为0说明这个点不能再通过这个边到达汇点，所以要将这个点的标号标记为它链接的孩子的节点中标号最小的那个的标号值+1，具体的可以画个图来看一下。

    这个算法之所以快，是因为可以加一个gap优化，即设一个数组保存标号为i的节点个数为d[i]这样在d[i]出现在\(0<i<n\)的时候有d[i]==0则这个时候直接结束即可，说明从汇点已经不能到达源点了。已经没有增广路了
  2. 算法复杂度：这个是实现起来较快的一个，一般可以解决大多数问题，复杂度是\(O(n^2m)\)，如果用优先队列存图，复杂度可以到达\(O(n^2\sqrt{m})\),对于这个题用时 0MS
  3. 算法模板：
  1. const int inf = 0x3fffffff;
  2. template <int N, int M>
  3. struct Isap
  4. {
  5.     int top;
  6.     int d[N], pre[N], cur[N], gap[N];
  7.     struct Vertex{
  8.         int head;
  9.     } V[N];
  10.     struct Edge{
  11.         int v, next;
  12.         int c, f;
  13.     } E[M];
  14.     void init(){
  15.         memset(V, -1, sizeof(V));
  16.         top = 0;
  17.     }
  18.     void add_edge(int u, int v, int c){
  19.         E[top].v = v;
  20.         E[top].c = c;
  21.         E[top].f = 0;
  22.         E[top].next = V[u].head;
  23.         V[u].head = top++;
  24.     }
  25.     void add(int u,int v, int c){
  26.         add_edge(u, v, c);
  27.         add_edge(v, u, 0);
  28.     }
  29.     void set_d(int t){
  30.         queue<int> Q;
  31.         memset(d, -1, sizeof(d));
  32.         memset(gap, 0, sizeof(gap));
  33.         d[t] = 0;
  34.         Q.push(t);
  35.         while(!Q.empty()) {
  36.             int v = Q.front(); Q.pop();
  37.             ++gap[d[v]];
  38.             for(int i = V[v].head; ~i; i = E[i].next) {
  39.                 int u = E[i].v;
  40.                 if(d[u] == -1) {
  41.                     d[u] = d[v] + 1;
  42.                     Q.push(u);
  43.                 }
  44.             }
  45.         }
  46.     }
  47.     int sap(int s, int t, int num) {
  48.         set_d(t);
  49.         int ans = 0, u = s;
  50.         int flow = inf;
  51.         memcpy(cur, V, sizeof(V));
  52.         while(d[s] < num) {
  53.             int &i = cur[u];
  54.             for(; ~i; i = E[i].next) {
  55.                 int v = E[i].v;
  56.                 if(E[i].c > E[i].f && d[u] == d[v] + 1) {
  57.                     u = v;
  58.                     pre[v] = i;
  59.                     flow = min(flow, E[i].c - E[i].f);
  60.                     if(u == t) {
  61.                         while(u != s) {
  62.                             int j = pre[u];
  63.                             E[j].f += flow;
  64.                             E[j^1].f -= flow;
  65.                             u = E[j^1].v;
  66.                         }
  67.                         ans += flow;
  68.                         flow = inf;
  69.                     }
  70.                     break;
  71.                 }
  72.             }
  73.             if(i == -1) {
  74.                 if(--gap[d[u]] == 0)
  75.                     break;
  76.                 int dmin = num - 1;
  77.                 cur[u] = V[u].head;
  78.                 for(int j = V[u].head; ~j; j = E[j].next)
  79.                     if(E[j].c > E[j].f)
  80.                         dmin = min(dmin, d[E[j].v]);
  81.                 d[u] = dmin + 1;
  82.                 ++gap[d[u]];
  83.                 if(u != s)
  84.                     u = E[pre[u] ^ 1].v;
  85.             }
  86.         }
  87.         return ans;
  88.     }
  89. };
  90. Isap<1000, 1000000> Sap;
  92. 调用方式：
  93. Sap.init(); //建边前调用
  94. Sap.add(u, v, c); //在u->v之间建一条容量为c的边
  95. Sap.sap(s, t, num); //s为源点，t为汇点，num为边的数量
  1. 这个题AC代码：
  1. #include <cstdio>
  2. #include <cstring>
  3. #include <algorithm>
  4. #include <vector>
  5. #include <queue>
  6. using namespace std;
  8. const int inf = 0x3fffffff;
  9. template <int N, int M>
  10. struct Isap
  11. {
  12.     int top;
  13.     int d[N], pre[N], cur[N], gap[N];
  14.     struct Vertex{
  15.         int head;
  16.     } V[N];
  17.     struct Edge{
  18.         int v, next;
  19.         int c, f;
  20.     } E[M];
  21.     void init(){
  22.         memset(V, -1, sizeof(V));
  23.         top = 0;
  24.     }
  25.     void add_edge(int u, int v, int c){
  26.         E[top].v = v;
  27.         E[top].c = c;
  28.         E[top].f = 0;
  29.         E[top].next = V[u].head;
  30.         V[u].head = top++;
  31.     }
  32.     void add(int u,int v, int c){
  33.         add_edge(u, v, c);
  34.         add_edge(v, u, 0);
  35.     }
  36.     void set_d(int t){
  37.         queue<int> Q;
  38.         memset(d, -1, sizeof(d));
  39.         memset(gap, 0, sizeof(gap));
  40.         d[t] = 0;
  41.         Q.push(t);
  42.         while(!Q.empty()) {
  43.             int v = Q.front(); Q.pop();
  44.             ++gap[d[v]];
  45.             for(int i = V[v].head; ~i; i = E[i].next) {
  46.                 int u = E[i].v;
  47.                 if(d[u] == -1) {
  48.                     d[u] = d[v] + 1;
  49.                     Q.push(u);
  50.                 }
  51.             }
  52.         }
  53.     }
  54.     int sap(int s, int t, int num) {
  55.         set_d(t);
  56.         int ans = 0, u = s;
  57.         int flow = inf;
  58.         memcpy(cur, V, sizeof(V));
  59.         while(d[s] < num) {
  60.             int &i = cur[u];
  61.             for(; ~i; i = E[i].next) {
  62.                 int v = E[i].v;
  63.                 if(E[i].c > E[i].f && d[u] == d[v] + 1) {
  64.                     u = v;
  65.                     pre[v] = i;
  66.                     flow = min(flow, E[i].c - E[i].f);
  67.                     if(u == t) {
  68.                         while(u != s) {
  69.                             int j = pre[u];
  70.                             E[j].f += flow;
  71.                             E[j^1].f -= flow;
  72.                             u = E[j^1].v;
  73.                         }
  74.                         ans += flow;
  75.                         flow = inf;
  76.                     }
  77.                     break;
  78.                 }
  79.             }
  80.             if(i == -1) {
  81.                 if(--gap[d[u]] == 0)
  82.                     break;
  83.                 int dmin = num - 1;
  84.                 cur[u] = V[u].head;
  85.                 for(int j = V[u].head; ~j; j = E[j].next)
  86.                     if(E[j].c > E[j].f)
  87.                         dmin = min(dmin, d[E[j].v]);
  88.                 d[u] = dmin + 1;
  89.                 ++gap[d[u]];
  90.                 if(u != s)
  91.                     u = E[pre[u] ^ 1].v;
  92.             }
  93.         }
  94.         return ans;
  95.     }
  96. };
  97. Isap<1000, 1000000> Sap;
  98. int main()
  99. {
  100.     int N,F,D;
  101.     int s, t, num;
  102.     while(~scanf("%d%d%d",&N,&F,&D))
  103.     {
  104.         t = N*2+F+D+1;
  105.         s = 0;
  106.         num = t+1;
  107.         Sap.init();
  108.         int f,d;
  109.         for(int i = 1; i <= F; i++){//源点向各种食物连边
  110.             Sap.add(s,i,1);
  111.         }
  112.         int tm;
  113.         for(int i = 1; i <= N; i++){
  114.             scanf("%d%d",&f,&d);
  115.             for(int j = 1; j <= f; j++){
  116.                 scanf("%d",&tm);
  117.                 Sap.add(tm,F+i*2-1,1);//食物向喜欢它的牛连边
  118.             }
  119.             Sap.add(F+i*2-1,F+i*2,1);//牛拆点
  120.             for(int j = 1; j <= d; j++){
  121.                 scanf("%d",&tm);
  122.                 Sap.add(F+i*2,2*N+F+tm,1);//牛向喜欢的饮料连边
  123.             }
  124.         }
  125.         for(int i = 1; i <= D; i++){
  126.             Sap.add(2*N+F+i,t,1);//所有饮料向汇点连边
  127.         }
  128.         //puts("haha");
  129.         int ans = Sap.sap(s,t,num);
  130.         printf("%d\n",ans);
  131.     }
  132.     return 0;
  133. }

poj_3281Dining（网络流+拆点）的更多相关文章

  1. ACM/ICPC 之 网络流-拆点构图(POJ2391)

    需要直接到达,因此源点经过三条边后必须要达到汇点,但为了保证网络流的正确性(路径可反悔),因此不可限制层次网络的最高层次为3,最好的方法既是让所有点拆分成两个点,一个点从汇点进入,一个点通向汇点,任意 ...

  2. hiho# 1394最小路径覆盖 网络流拆点

    题目传送门 思路: 观察到路径上除了终点起点以外的每个点出度和入度都为1,和网络流的拆点很像,所以就把每个点都拆成两个点,若存在一条路径$(u,v)$,则建一条$(u,v+n,1)$的边,然后求出最大 ...

  3. poj 3281 Dining（网络流+拆点）

    Dining Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 20052   Accepted: 8915 Descripti ...

  4. POJ2391 Ombrophobic Bovines 网络流拆点+二分+floyed

    题目链接: id=2391">poj2391 题意: 有n块草地,每块草地上有一定数量的奶牛和一个雨棚,并给出了每一个雨棚的容(牛)量. 有m条路径连接这些草地  ,这些路径是双向的, ...

  5. ACM Computer Factory POJ - 3436 网络流拆点+路径还原

    http://poj.org/problem?id=3436 每台电脑有$p$个组成部分,有$n$个工厂加工电脑. 每个工厂对于进入工厂的半成品的每个组成部分都有要求,由$p$个数字描述,0代表这个部 ...

  6. Food HDU - 4292 网络流 拆点建图

    http://acm.hdu.edu.cn/showproblem.php?pid=4292 给一些人想要的食物和饮料,和你拥有的数量,问最多多少人可以同时获得一份食物和一份饮料 写的时候一共用了2种 ...

  7. poj 3281(网络流+拆点)

    题目链接:http://poj.org/problem?id=3281 思路:设一个超级源点和一个超级汇点,源点与食物相连,饮料与汇点相连,然后就是对牛进行拆点,一边喜欢的食物相连,一边与喜欢的饮料相 ...

  8. POJ 3281 Dining（网络流拆点）

    [题目链接] http://poj.org/problem?id=3281 [题目大意] 给出一些食物,一些饮料,每头牛只喜欢一些种类的食物和饮料, 但是每头牛最多只能得到一种饮料和食物,问可以最多满 ...

  9. hdu 4289 网络流拆点，类似最小割（可做模板）邻接矩阵实现

    Control Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Sub ...

随机推荐

  1. 谷歌浏览器插件-jsonView插件安装与使用

    本文转载:http://www.bubuko.com/infodetail-700647.html 1 安装 1.打开 https://github.com : 2.搜索 jsonView 链接:ht ...

  2. Python学习日记day3:数据类型

    1.数据类型int :如1.2.4等, 用于计算 bool: True , False ,用户判断 str: 储存少量数据,进行操作.如:'fdasklfjfladfl','而而噩噩','1234' ...

  3. 【NOIP模拟】从我背后出现

    Description 给定n个点m条边的无向连通图,对于每条边求出强制选这条边后的最⼩⽣成树⼤⼩. \(n\leq 10^5,m\leq 2*10^5\) Input Format 第 1 行包含两 ...

  4. 三菱Q系列PLC的智能功能模块程序

    一.模拟量输入模块Q64AD 1.模块开关或者参数设置 1.1I/O分配 1.2开关设置使用通道1,0-5v, 1.3使用GX configurator设置自动刷新PLC设置智能功能模块参数,即将模拟 ...

  5. Spring基础篇——DI和AOP初识

    前言 作为从事java开发的码农,Spring的重要性不言而喻,你可能每天都在和Spring框架打交道.Spring恰如其名的,给java应用程序的开发带了春天般的舒爽感觉.Spring,可以说是任何 ...

  6. 在win7下用net命令无法实现对用户的创建（未完成）

    ============================================================================================= 201307 ...

  7. 小白的Python之路 day4 软件目录结构规范

    软件目录结构规范 为什么要设计好目录结构? "设计项目目录结构",就和"代码编码风格"一样,属于个人风格问题.对于这种风格上的规范,一直都存在两种态度: 一类同 ...

  8. git 的回退

    今天下午写了一下午的代码给合并没了 然后晚上觉得还是要好好学习一下git的使用 推荐几个git的教程 https://www.liaoxuefeng.com/wiki/0013739516305929 ...

  9. 更好的小票打印体验，huanent.printer2.0发布

    huanent.printer2.0是一个专注消费小票打印的类库.拥有许多先进的特性例如居中打印.自动换行等特性,可以通过简洁的代码来打印出复杂的消费小票.huanent.printer通过MIT方式 ...

  10. python科学计算_numpy_广播与下标

    多维数组下标 多维数组的下标是用元组来实现每一个维度的,如果元组的长度比维度大则会出错,如果小,则默认元组后面补 : 表示全部访问: 如果一个下标不是元组,则先转换为元组,在转换过程中,列表和数组的转 ...