看了这道题，然后重新开始练习自己的刚敲不久的网络流，发现还是难以一遍敲得完整啊，，，，，

调了。。。遍，改了。。。遍，测了。。。遍，交了，，，遍，总算是A了，，不简单啊

然后试着用了其他两种算法EK和dinic都试着去练习一下，慢慢A了，，，真是不简单有木有

题目大意是这样的，有一些小偷打算从城市S到城市T,但是我们不知道他们会走哪些边，为了确保一定可以能够抓住所有的小偷，现在需要在某些城市布置一些警察，已知在城市i布置的花费是P[i],现在要使的抓住小偷的同时我的花费最小，求最小花费。

这里用到了最大流的一个定理，最小割最大流定理：当起点到终点的最大流算出来时，这个最大流就是将图划分为两个互不连通的集合的最小割。证明可以自己百度或看其他神牛的博客。

有了这个定理，就变成了裸的最大流问题了

下面我试着用三种方法做了这道题，比较了一下发现最快的依然是SAP，其次是dinic，最后是EK算法

SAP

  1.  #include <map>
  2.  #include <set>
  3.  #include <stack>
  4.  #include <queue>
  5.  #include <cmath>
  6.  #include <ctime>
  7.  #include <vector>
  8.  #include <cstdio>
  9.  #include <cctype>
  10.  #include <cstring>
  11.  #include <cstdlib>
  12.  #include <iostream>
  13.  #include <algorithm>
  14.  using namespace std;
  15.  #define INF 0x3f3f3f3f
  16.  #define inf ((LL)1<<40)
  17.  #define lson k<<1, L, mid
  18.  #define rson k<<1|1, mid+1, R
  19.  #define mem0(a) memset(a,0,sizeof(a))
  20.  #define mem1(a) memset(a,-1,sizeof(a))
  21.  #define mem(a, b) memset(a, b, sizeof(a))
  22.  #define FOPENIN(IN) freopen(IN, "r", stdin)
  23.  #define FOPENOUT(OUT) freopen(OUT, "w", stdout)
  24.  template<class T> T ABS ( T a) { return a >=  ? a : -a;   }
  25.  template<class T> T CMP_MIN ( T a, T b ) { return a < b;   }
  26.  template<class T> T CMP_MAX ( T a, T b ) { return a > b;   }
  27.  template<class T> T MAX ( T a, T b ) { return a > b ? a : b; }
  28.  template<class T> T MIN ( T a, T b ) { return a < b ? a : b; }
  29.  template<class T> T GCD ( T a, T b ) { return b ? GCD ( b, a % b ) : a; }
  30.  template<class T> T LCM ( T a, T b ) { return a / GCD ( a, b ) * b;     }
  31.  template<class T> void SWAP( T& a, T& b ) { T t = a; a = b;  b = t;     }
  32.  
  33.  typedef __int64 LL;
  34.  //typedef long long LL;
  35.  const int MAXN = ;
  36.  const int MAXM = ;
  37.  const double eps = 1e-;
  38.  const double PI = 4.0 * atan(1.0);
  39.  const LL MOD = ;
  40.  
  41.  #define L(i) (i<<1)
  42.  #define R(i) (i<<1|1)
  43.  
  44.  int m, n, s, d;
  45.  struct Edge { int to, cap, next; }edge[MAXM<<];
  46.  int tot, head[MAXN];
  47.  
  48.  int src, des;
  49.  int gap[MAXN], dep[MAXN], aug[MAXN], cur[MAXN],  pre[MAXN];
  50.  
  51.  void addEdge(int u, int v, int c)
  52.  {
  53.      edge[tot].to  = v; edge[tot].cap = c; edge[tot].next = head[u];
  54.      head[u] = tot ++;
  55.      edge[tot].to  = u; edge[tot].cap = ; edge[tot].next = head[v];
  56.      head[v] = tot ++;
  57.  }
  58.  
  59.  void init()
  60.  {
  61.      int x, y;
  62.      tot = ;
  63.      mem1(head); mem0(edge);
  64.      scanf("%d %d", &s, &d);
  65.      for(int i = ; i <= n; i ++)
  66.      {
  67.          scanf("%d", &x);
  68.          addEdge(L(i), R(i), x);
  69.          addEdge(R(i), L(i), x);
  70.      }
  71.      for(int i = ; i < m; i ++)
  72.      {
  73.          scanf("%d %d", &x, &y);
  74.          addEdge(R(x), L(y), INF);
  75.          addEdge(R(y), L(x), INF);
  76.      }
  77.      src = ;
  78.      des = (n+)<<;
  79.      addEdge(src, L(s), INF);
  80.      addEdge(R(d), des, INF);
  81.  }
  82.  
  83.  int SAP(int n)
  84.  {
  85.      mem0(gap);
  86.      mem0(dep);
  87.      mem0(aug);
  88.      mem0(pre);
  89.      aug[src] = INF;
  90.      pre[src] = -;
  91.      gap[] = n;
  92.      int max_flow = , u = src;
  93.      for(int i = ; i <= n; i ++)
  94.          cur[i] = head[i];
  95.      while(dep[src] < n)
  96.      {
  97.          if(u == des)
  98.          {
  99.              max_flow += aug[des];
  100.              for(int v = pre[des]; v != -; v = pre[v])
  101.              {
  102.                  int id = cur[v];
  103.                  edge[id].cap   -= aug[des];
  104.                  edge[id^].cap += aug[des];
  105.                  aug[v] -= aug[des];
  106.                  if(edge[id].cap == )
  107.                      u = v;
  108.              }
  109.          }
  110.          int flag = ;
  111.          for(int i = cur[u]; i != -; i = edge[i].next)
  112.          {
  113.              int v = edge[i].to;
  114.              if(edge[i].cap >  && dep[u] == dep[v]+)
  115.              {
  116.                  flag = ;
  117.                  pre[v]= u;
  118.                  cur[u] = i;
  119.                  aug[v] = MIN(aug[u], edge[i].cap);
  120.                  u = v;
  121.                  break;
  122.              }
  123.          }
  124.          if(!flag)
  125.          {
  126.              if(--gap[dep[u]] == )
  127.                  break;
  128.              int min_dep = n;
  129.              cur[u] = head[u];
  130.              for(int i = head[u]; i != -; i = edge[i].next)
  131.              {
  132.                  int v = edge[i].to;
  133.                  if(edge[i].cap >  && dep[v] < min_dep)
  134.                  {
  135.                      min_dep = dep[v];
  136.                      cur[u] = i;
  137.                  }
  138.              }
  139.              dep[u] = min_dep + ;
  140.              gap[dep[u]] ++;
  141.              if(pre[u] != -) u = pre[u];
  142.          }
  143.      }
  144.      return max_flow;
  145.  }
  146.  
  147.  int main()
  148.  {
  149.      while(~scanf("%d %d", &n, &m))
  150.      {
  151.          init();
  152.          printf("%d\n", SAP(des));
  153.      }
  154.      return ;
  155.  }

dinic

  1.  #include <map>
  2.  #include <set>
  3.  #include <stack>
  4.  #include <queue>
  5.  #include <cmath>
  6.  #include <ctime>
  7.  #include <vector>
  8.  #include <cstdio>
  9.  #include <cctype>
  10.  #include <cstring>
  11.  #include <cstdlib>
  12.  #include <iostream>
  13.  #include <algorithm>
  14.  using namespace std;
  15.  #define INF 0x3f3f3f3f
  16.  #define inf ((LL)1<<40)
  17.  #define lson k<<1, L, mid
  18.  #define rson k<<1|1, mid+1, R
  19.  #define mem0(a) memset(a,0,sizeof(a))
  20.  #define mem1(a) memset(a,-1,sizeof(a))
  21.  #define mem(a, b) memset(a, b, sizeof(a))
  22.  #define FOPENIN(IN) freopen(IN, "r", stdin)
  23.  #define FOPENOUT(OUT) freopen(OUT, "w", stdout)
  24.  template<class T> T ABS ( T a) { return a >=  ? a : -a;   }
  25.  template<class T> T CMP_MIN ( T a, T b ) { return a < b;   }
  26.  template<class T> T CMP_MAX ( T a, T b ) { return a > b;   }
  27.  template<class T> T MAX ( T a, T b ) { return a > b ? a : b; }
  28.  template<class T> T MIN ( T a, T b ) { return a < b ? a : b; }
  29.  template<class T> T GCD ( T a, T b ) { return b ? GCD ( b, a % b ) : a; }
  30.  template<class T> T LCM ( T a, T b ) { return a / GCD ( a, b ) * b;     }
  31.  template<class T> void SWAP( T& a, T& b ) { T t = a; a = b;  b = t;     }
  32.  
  33.  typedef __int64 LL;
  34.  //typedef long long LL;
  35.  const int MAXN = ;
  36.  const int MAXM = ;
  37.  const double eps = 1e-;
  38.  const double PI = 4.0 * atan(1.0);
  39.  const LL MOD = ;
  40.  
  41.  #define L(i) (i<<1)
  42.  #define R(i) (i<<1|1)
  43.  
  44.  int m, n, s, d;
  45.  struct Edge { int to, cap, next; }edge[MAXM<<];
  46.  int tot, head[MAXN];
  47.  
  48.  int src, des;
  49.  int dis[MAXN];
  50.  
  51.  void addEdge(int u, int v, int c)
  52.  {
  53.      edge[tot].to  = v; edge[tot].cap = c; edge[tot].next = head[u];
  54.      head[u] = tot ++;
  55.      edge[tot].to  = u; edge[tot].cap = ; edge[tot].next = head[v];
  56.      head[v] = tot ++;
  57.  }
  58.  
  59.  void init()
  60.  {
  61.      int x, y;
  62.      tot = ;
  63.      mem1(head); mem0(edge);
  64.      scanf("%d %d", &s, &d);
  65.      for(int i = ; i <= n; i ++)
  66.      {
  67.          scanf("%d", &x);
  68.          addEdge(L(i), R(i), x);
  69.          addEdge(R(i), L(i), x);
  70.      }
  71.      for(int i = ; i < m; i ++)
  72.      {
  73.          scanf("%d %d", &x, &y);
  74.          addEdge(R(x), L(y), INF);
  75.          addEdge(R(y), L(x), INF);
  76.      }
  77.      src = ;
  78.      des = (n+)<<;
  79.      addEdge(src, L(s), INF);
  80.      addEdge(R(d), des, INF);
  81.  }
  82.  
  83.  bool bfs()
  84.  {
  85.      queue<int>q;
  86.      mem1(dis);
  87.      dis[src] = ;
  88.      q.push(src);
  89.      while(!q.empty())
  90.      {
  91.          int u = q.front(); q.pop();
  92.          for(int i = head[u]; i != -; i = edge[i].next)
  93.          {
  94.              int v = edge[i].to;
  95.              if(dis[v] == - && edge[i].cap > )
  96.              {
  97.                  dis[v] = dis[u] + ;
  98.                  q.push(v);
  99.              }
  100.          }
  101.      }
  102.      return dis[des] != -;
  103.  }
  104.  
  105.  int dfs(int cur, int aug)
  106.  {
  107.      if(cur == des || aug == )
  108.          return aug;
  109.      int flow = ;
  110.      for(int i = head[cur]; i != -; i = edge[i].next)
  111.      {
  112.          int v = edge[i].to;
  113.          if ( dis[v] == dis[cur]+ && edge[i].cap >  )
  114.          {
  115.              int f = dfs( v, MIN(edge[i].cap, aug) );
  116.              edge[i].cap   -= f;
  117.              edge[i^].cap += f;
  118.              flow += f;
  119.              aug -= f;
  120.              if(aug == )
  121.                  break;
  122.          }
  123.      }
  124.      return flow;
  125.  }
  126.  
  127.  int dinic()
  128.  {
  129.      int res = ;
  130.      while (bfs())
  131.      {
  132.          res += dfs(src, INF);
  133.      }
  134.      return res;
  135.  }
  136.  
  137.  int main()
  138.  {
  139.      //FOPENIN("in.txt");
  140.      while(~scanf("%d %d", &n, &m))
  141.      {
  142.          init();
  143.          printf("%d\n", dinic());
  144.      }
  145.      return ;
  146.  }

EK

  1.  #include <map>
  2.  #include <set>
  3.  #include <stack>
  4.  #include <queue>
  5.  #include <cmath>
  6.  #include <ctime>
  7.  #include <vector>
  8.  #include <cstdio>
  9.  #include <cctype>
  10.  #include <cstring>
  11.  #include <cstdlib>
  12.  #include <iostream>
  13.  #include <algorithm>
  14.  using namespace std;
  15.  #define INF 0x3f3f3f3f
  16.  #define inf ((LL)1<<40)
  17.  #define lson k<<1, L, mid
  18.  #define rson k<<1|1, mid+1, R
  19.  #define mem0(a) memset(a,0,sizeof(a))
  20.  #define mem1(a) memset(a,-1,sizeof(a))
  21.  #define mem(a, b) memset(a, b, sizeof(a))
  22.  #define FOPENIN(IN) freopen(IN, "r", stdin)
  23.  #define FOPENOUT(OUT) freopen(OUT, "w", stdout)
  24.  template<class T> T ABS ( T a) { return a >=  ? a : -a;   }
  25.  template<class T> T CMP_MIN ( T a, T b ) { return a < b;   }
  26.  template<class T> T CMP_MAX ( T a, T b ) { return a > b;   }
  27.  template<class T> T MAX ( T a, T b ) { return a > b ? a : b; }
  28.  template<class T> T MIN ( T a, T b ) { return a < b ? a : b; }
  29.  template<class T> T GCD ( T a, T b ) { return b ? GCD ( b, a % b ) : a; }
  30.  template<class T> T LCM ( T a, T b ) { return a / GCD ( a, b ) * b;     }
  31.  template<class T> void SWAP( T& a, T& b ) { T t = a; a = b;  b = t;     }
  32.  
  33.  typedef __int64 LL;
  34.  //typedef long long LL;
  35.  const int MAXN = ;
  36.  const int MAXM = ;
  37.  const double eps = 1e-;
  38.  const double PI = 4.0 * atan(1.0);
  39.  const LL MOD = ;
  40.  
  41.  #define L(i) (i<<1)
  42.  #define R(i) (i<<1|1)
  43.  
  44.  int n, m, s, d;
  45.  
  46.  int src, des;
  47.  int cap[MAXN][MAXN], flow[MAXN][MAXN], pre[MAXN], a[MAXN];
  48.  
  49.  void init()
  50.  {
  51.      int x, y;
  52.      src = ;
  53.      des = (n+)<<;
  54.      mem0(cap);mem0(pre);
  55.      scanf("%d %d", &s, &d);
  56.      cap[src][L(s)] = INF;
  57.      cap[R(d)][des] = INF;
  58.      for(int i = ; i <= n; i ++)
  59.      {
  60.          scanf("%d", &x);
  61.          cap[L(i)][R(i)] = x;
  62.          cap[R(i)][L(i)] = x;
  63.      }
  64.      for(int i = ; i < m; i ++)
  65.      {
  66.          scanf("%d %d", &x, &y);
  67.          cap[R(x)][L(y)] = INF;
  68.          cap[R(y)][L(x)] = INF;
  69.      }
  70.  }
  71.  
  72.  int EK(int n)
  73.  {
  74.      queue<int>q;
  75.      mem0(flow);
  76.      int max_flow = ;
  77.      while(true)
  78.      {
  79.          mem0(a);
  80.          a[src] = INF;
  81.          q.push(src);
  82.          while(!q.empty())
  83.          {
  84.              int u = q.front(); q.pop();
  85.              for(int v = ; v <= n; v ++) if(!a[v] && cap[u][v]>flow[u][v])
  86.              {
  87.                  pre[v]= u;
  88.                  q.push(v);
  89.                  a[v] = MIN(a[u], cap[u][v] - flow[u][v]);
  90.              }
  91.          }
  92.          if(a[des] == ) break;
  93.          for(int u = des; u != src; u = pre[u])
  94.          {
  95.              flow[pre[u]][u] += a[des];
  96.              flow[u][pre[u]] -= a[des];
  97.          }
  98.          max_flow += a[des];
  99.      }
  100.      return max_flow;
  101.  }
  102.  
  103.  int main()
  104.  {
  105.      //FOPENIN("in.txt");
  106.      while(~scanf("%d %d", &n, &m))
  107.      {
  108.          init();
  109.          printf("%d\n", EK(des));
  110.      }
  111.      return ;
  112.  }

HDU4289Control(最大流)的更多相关文章

  1. HDU4289Control 无向图拆点最大流

    /* ** 无向图拆点,求最大流,最大流即为割点个数. */ #include <iostream> #include <cstdio> #include <cstrin ...

  2. 使用C#处理基于比特流的数据

    使用C#处理基于比特流的数据 0x00 起因 最近需要处理一些基于比特流的数据,计算机处理数据一般都是以byte(8bit)为单位的,使用BinaryReader读取的数据也是如此,即使读取bool型 ...

  3. HTML 事件(三) 事件流与事件委托

    本篇主要介绍HTML DOM中的事件流和事件委托. 其他事件文章 1. HTML 事件(一) 事件的介绍 2. HTML 事件(二) 事件的注册与注销 3. HTML 事件(三) 事件流与事件委托 4 ...

  4. FILE文件流的中fopen、fread、fseek、fclose的使用

    FILE文件流用于对文件的快速操作,主要的操作函数有fopen.fseek.fread.fclose,在对文件结构比较清楚时使用这几个函数会比较快捷的得到文件中具体位置的数据,提取对我们有用的信息,满 ...

  5. java.IO输入输出流：过滤流：buffer流和data流

    java.io使用了适配器模式装饰模式等设计模式来解决字符流的套接和输入输出问题. 字节流只能一次处理一个字节,为了更方便的操作数据,便加入了套接流. 问题引入:缓冲流为什么比普通的文件字节流效率高? ...

  6. java 字节流与字符流的区别

    字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢?实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操作 ...

  7. BZOJ 3504: [Cqoi2014]危桥 [最大流]

    3504: [Cqoi2014]危桥 Time Limit: 10 Sec  Memory Limit: 128 MBSubmit: 1407  Solved: 703[Submit][Status] ...

  8. java I/O流

    输入流(读取数据的流) BufferedInputStream---继承--->FileInputStream--继承--->InputStream------> (1)字节流操作中 ...

  9. Ford-Fulkerson 最大流算法

    流网络(Flow Networks)指的是一个有向图 G = (V, E),其中每条边 (u, v) ∈ E 均有一非负容量 c(u, v) ≥ 0.如果 (u, v) ∉ E 则可以规定 c(u, ...

随机推荐

  1. Swustoj题目征集计划

    SWUST OJ题目征集计划   鉴于SWUST OJ长时间没有新题添加,题目数量和类型有限,同时也为加强同学们之间的算法交流,享受互相出题AC的乐趣,提高算法水平,现在启动题目征集计划啦~ 当你遇到 ...

  2. wxWidgets简单的多线程

    #include <wx/wx.h> #include <wx/thread.h> #include <wx/event.h> #include <wx/pr ...

  3. (转)每天一个Linux命令(4): mkdir

    http://www.cnblogs.com/peida/archive/2012/10/25/2738271.html linux mkdir 命令用来创建指定的名称的目录,要求创建目录的用户在当前 ...

  4. 每天一个Linux命令(3): cd

    Linux cd 命令可以说是Linux中最基本的命令语句,其他的命令语句要进行操作,都是建立在使用 cd 命令上的. 所以,学习Linux 常用命令,首先就要学好 cd 命令的使用方法技巧. 1.  ...

  5. 手动编译Spring4.2源码，以及把源码导入myEclipse中

    前提条件,先在本地配置好JDK1.8, 安装好Git 执行下面命令: 1,双击Git Bash, 进入源码存放路径 cd E:\Foler 2,git clone git@github.com:spr ...

  6. Shell教程5-Shell运算符

    Bash 支持很多运算符,包括算数运算符.关系运算符.布尔运算符.字符串运算符和文件测试运算符. 原生bash不支持简单的数学运算,但是可以通过其他命令来实现,例如 awk 和 expr,expr 最 ...

  7. Android NDK OpenCV C++

    NDK中的OpenCV http://blog.csdn.net/yanzi1225627/article/details/8525720

  8. php 实现 jsonp 数据接口

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 3 ...

  9. 分段统计与Oracle的分析函数、逻辑判断等知识点的综合运用

    重点部分:TOTAL层 项目要求: 统计每个巡检员(USER_ID)当前月的签到率及查询相关字段 签到率公式:以巡检员为单位, (当月至今天为止签到的所有点/该月巡检点的总个数)=(b.Point/a ...

  10. 2015-10-27 js

    1.声明变量: 2.prompt属性的使用: prompt("提示框的标题","提示框的输入提示内容"); prompt的调用结果就是他输入框内的内容!!! 3 ...