hdu 1532 求1~n的最大流

  1. #include<stdio.h>
  2. #include<string.h>
  3. #include<algorithm>
  4. #include<iostream>
  5. using namespace std;
  6.  
  7. const int MAXN = ; //点数的最大值
  8. const int MAXM = ; //边数的最大值
  9. const int INF = 0x3f3f3f3f;
  10.  
  11. struct Node
  12. {
  13.         int from, to, next;
  14.         int cap;
  15. } edge[MAXM];
  16. int tol;
  17. int head[MAXN];
  18. int dep[MAXN];
  19. int gap[MAXN];//gap[x]=y :说明残留网络中dep[i]==x的个数为y
  20.  
  21. int n;//n是总的点的个数，包括源点和汇点
  22.  
  23. void init()
  24. {
  25.         tol = ;
  26.         memset(head, -, sizeof(head));
  27. }
  28.  
  29. void addedge(int u, int v, int w)
  30. {
  31.         edge[tol].from = u;
  32.         edge[tol].to = v;
  33.         edge[tol].cap = w;
  34.         edge[tol].next = head[u];
  35.         head[u] = tol++;
  36.         edge[tol].from = v;
  37.         edge[tol].to = u;
  38.         edge[tol].cap = ;
  39.         edge[tol].next = head[v];
  40.         head[v] = tol++;
  41. }
  42. void BFS(int start, int end)
  43. {
  44.         memset(dep, -, sizeof(dep));
  45.         memset(gap, , sizeof(gap));
  46.         gap[] = ;
  47.         int que[MAXN];
  48.         int front, rear;
  49.         front = rear = ;
  50.         dep[end] = ;
  51.         que[rear++] = end;
  52.         while (front != rear)
  53.         {
  54.                 int u = que[front++];
  55.                 if (front == MAXN)
  56.                 {
  57.                         front = ;
  58.                 }
  59.                 for (int i = head[u]; i != -; i = edge[i].next)
  60.                 {
  61.                         int v = edge[i].to;
  62.                         if (dep[v] != -)
  63.                         {
  64.                                 continue;
  65.                         }
  66.                         que[rear++] = v;
  67.                         if (rear == MAXN)
  68.                         {
  69.                                 rear = ;
  70.                         }
  71.                         dep[v] = dep[u] + ;
  72.                         ++gap[dep[v]];
  73.                 }
  74.         }
  75. }
  76. int SAP(int start, int end)
  77. {
  78.         int res = ;
  79.         BFS(start, end);
  80.         int cur[MAXN];
  81.         int S[MAXN];
  82.         int top = ;
  83.         memcpy(cur, head, sizeof(head));
  84.         int u = start;
  85.         int i;
  86.         while (dep[start] < n)
  87.         {
  88.                 if (u == end)
  89.                 {
  90.                         int temp = INF;
  91.                         int inser;
  92.                         for (i = ; i < top; i++)
  93.                                 if (temp > edge[S[i]].cap)
  94.                                 {
  95.                                         temp = edge[S[i]].cap;
  96.                                         inser = i;
  97.                                 }
  98.                         for (i = ; i < top; i++)
  99.                         {
  100.                                 edge[S[i]].cap -= temp;
  101.                                 edge[S[i] ^ ].cap += temp;
  102.                         }
  103.                         res += temp;
  104.                         top = inser;
  105.                         u = edge[S[top]].from;
  106.                 }
  107.                 if (u != end && gap[dep[u] - ] == ) //出现断层，无增广路
  108.                 {
  109.                         break;
  110.                 }
  111.                 for (i = cur[u]; i != -; i = edge[i].next)
  112.                         if (edge[i].cap !=  && dep[u] == dep[edge[i].to] + )
  113.                         {
  114.                                 break;
  115.                         }
  116.                 if (i != -)
  117.                 {
  118.                         cur[u] = i;
  119.                         S[top++] = i;
  120.                         u = edge[i].to;
  121.                 }
  122.                 else
  123.                 {
  124.                         int min = n;
  125.                         for (i = head[u]; i != -; i = edge[i].next)
  126.                         {
  127.                                 if (edge[i].cap == )
  128.                                 {
  129.                                         continue;
  130.                                 }
  131.                                 if (min > dep[edge[i].to])
  132.                                 {
  133.                                         min = dep[edge[i].to];
  134.                                         cur[u] = i;
  135.                                 }
  136.                         }
  137.                         --gap[dep[u]];
  138.                         dep[u] = min + ;
  139.                         ++gap[dep[u]];
  140.                         if (u != start)
  141.                         {
  142.                                 u = edge[S[--top]].from;
  143.                         }
  144.                 }
  145.         }
  146.         return res;
  147. }
  148.  
  149. int main()
  150. {
  151.         // freopen("in.txt","r",stdin);
  152.         //  freopen("out.txt","w",stdout);
  153.         int start, end;
  154.         int m;
  155.         int u, v, z;
  156.         int T;
  157.         while (~scanf("%d%d", &m, &n))
  158.         {
  159.                 init();
  160.                 while (m--)
  161.                 {
  162.                         scanf("%d%d%d", &u, &v, &z);
  163.                         addedge(u, v, z);
  164.                         //addedge(v, u, z);
  165.                 }
  166.                 //n一定是点的总数，这是使用SAP模板需要注意的
  167.                 int ans = SAP(, n);
  168.                 printf("%d\n", ans);
  169.         }
  170.         return ;
  171. }

hdu 4280  给你岛的坐标求最西边到最东边的最大流

  1. /*
  2. 最大流模板
  3. sap
  4. */
  5. #include<stdio.h>
  6. #include<string.h>
  7. #include<algorithm>
  8. #include<iostream>
  9. using namespace std;
  10.  
  11. const int MAXN=;//点数的最大值
  12. const int MAXM=;//边数的最大值
  13. const int INF=0x3f3f3f3f;
  14.  
  15. struct Node
  16. {
  17.     int from,to,next;
  18.     int cap;
  19. }edge[MAXM];
  20. int tol;
  21. int head[MAXN];
  22. int dep[MAXN];
  23. int gap[MAXN];//gap[x]=y :说明残留网络中dep[i]==x的个数为y
  24.  
  25. int n;//n是总的点的个数，包括源点和汇点
  26.  
  27. void init()
  28. {
  29.     tol=;
  30.     memset(head,-,sizeof(head));
  31. }
  32.  
  33. void addedge(int u,int v,int w)
  34. {
  35.     edge[tol].from=u;
  36.     edge[tol].to=v;
  37.     edge[tol].cap=w;
  38.     edge[tol].next=head[u];
  39.     head[u]=tol++;
  40.     edge[tol].from=v;
  41.     edge[tol].to=u;
  42.     edge[tol].cap=;
  43.     edge[tol].next=head[v];
  44.     head[v]=tol++;
  45. }
  46. void BFS(int start,int end)
  47. {
  48.     memset(dep,-,sizeof(dep));
  49.     memset(gap,,sizeof(gap));
  50.     gap[]=;
  51.     int que[MAXN];
  52.     int front,rear;
  53.     front=rear=;
  54.     dep[end]=;
  55.     que[rear++]=end;
  56.     while(front!=rear)
  57.     {
  58.         int u=que[front++];
  59.         if(front==MAXN)front=;
  60.         for(int i=head[u];i!=-;i=edge[i].next)
  61.         {
  62.             int v=edge[i].to;
  63.             if(dep[v]!=-)continue;
  64.             que[rear++]=v;
  65.             if(rear==MAXN)rear=;
  66.             dep[v]=dep[u]+;
  67.             ++gap[dep[v]];
  68.         }
  69.     }
  70. }
  71. int SAP(int start,int end)
  72. {
  73.     int res=;
  74.     BFS(start,end);
  75.     int cur[MAXN];
  76.     int S[MAXN];
  77.     int top=;
  78.     memcpy(cur,head,sizeof(head));
  79.     int u=start;
  80.     int i;
  81.     while(dep[start]<n)
  82.     {
  83.         if(u==end)
  84.         {
  85.             int temp=INF;
  86.             int inser;
  87.             for(i=;i<top;i++)
  88.                if(temp>edge[S[i]].cap)
  89.                {
  90.                    temp=edge[S[i]].cap;
  91.                    inser=i;
  92.                }
  93.             for(i=;i<top;i++)
  94.             {
  95.                 edge[S[i]].cap-=temp;
  96.                 edge[S[i]^].cap+=temp;
  97.             }
  98.             res+=temp;
  99.             top=inser;
  100.             u=edge[S[top]].from;
  101.         }
  102.         if(u!=end&&gap[dep[u]-]==)//出现断层，无增广路
  103.           break;
  104.         for(i=cur[u];i!=-;i=edge[i].next)
  105.            if(edge[i].cap!=&&dep[u]==dep[edge[i].to]+)
  106.              break;
  107.         if(i!=-)
  108.         {
  109.             cur[u]=i;
  110.             S[top++]=i;
  111.             u=edge[i].to;
  112.         }
  113.         else
  114.         {
  115.             int min=n;
  116.             for(i=head[u];i!=-;i=edge[i].next)
  117.             {
  118.                 if(edge[i].cap==)continue;
  119.                 if(min>dep[edge[i].to])
  120.                 {
  121.                     min=dep[edge[i].to];
  122.                     cur[u]=i;
  123.                 }
  124.             }
  125.             --gap[dep[u]];
  126.             dep[u]=min+;
  127.             ++gap[dep[u]];
  128.             if(u!=start)u=edge[S[--top]].from;
  129.         }
  130.     }
  131.     return res;
  132. }
  133.  
  134. int main()
  135. {
  136.    // freopen("in.txt","r",stdin);
  137.   //  freopen("out.txt","w",stdout);
  138.     int start,end;
  139.     int m;
  140.     int u,v,z;
  141.     int T;
  142.     scanf("%d",&T);
  143.  
  144.     while(T--)
  145.     {
  146.         init();
  147.         scanf("%d%d",&n,&m);
  148.         int minx=;
  149.         int maxx=-;
  150.         int x,y;
  151.         for(int i=;i<=n;i++)
  152.         {
  153.             scanf("%d%d",&x,&y);
  154.             if(minx>x)
  155.             {
  156.                 minx=x;
  157.                 start=i;
  158.             }
  159.             if(maxx<x)
  160.             {
  161.                 maxx=x;
  162.                 end=i;
  163.             }
  164.         }
  165.  
  166.         while(m--)
  167.         {
  168.             scanf("%d%d%d",&u,&v,&z);
  169.             addedge(u,v,z);
  170.             addedge(v,u,z);
  171.         }
  172.         //n一定是点的总数，这是使用SAP模板需要注意的
  173.         int ans=SAP(start,end);
  174.         printf("%d\n",ans);
  175.     }
  176.     return ;
  177. }

网络流 最大流SAPkuangbin模板的更多相关文章

  1. 网络流--最大流dinic模板

    标准的大白书式模板,除了变量名并不一样……在主函数中只需要用到 init 函数.add 函数以及 mf 函数 #include<stdio.h> //差不多要加这么些头文件 #includ ...

  2. 网络流--最大流ek模板

    标准大白书式模板,代码简单但由于效率并不高,所以并不常用,就是这样 #include<stdio.h> #include<string.h> #include<queue ...

  3. 网络流-最大流 Dinic模板

    #include <bits/stdc++.h> using namespace std; #define MP make_pair #define PB push_back #defin ...

  4. 网络流--最大流--Dinic模板矩阵版（当前弧优化+非当前弧优化）

    //非当前弧优化版 #include <iostream> #include <cstdio> #include <math.h> #include <cst ...

  5. 网络流--最大流--EK模板

    #include <iostream> #include <cstdio> #include <cstring> #include <cmath> #i ...

  6. （通俗易懂小白入门）网络流最大流——EK算法

    网络流 网络流是模仿水流解决生活中类似问题的一种方法策略,来看这么一个问题,有一个自来水厂S,它要向目标T提供水量,从S出发有不确定数量和方向的水管,它可能直接到达T或者经过更多的节点的中转,目前确定 ...

  7. HDU1532 网络流最大流【EK算法】(模板题)

    <题目链接> 题目大意: 一个农夫他家的农田每次下雨都会被淹,所以这个农夫就修建了排水系统,还聪明的给每个排水管道设置了最大流量:首先输入两个数n,m ;n为排水管道的数量,m为节点的数量 ...

  8. [POJ1273][USACO4.2]Drainage Ditches (网络流最大流)

    题意 网络流最大流模板 思路 EK也不会超时 所以说是一个数据比较水的模板题 但是POJ有点坑,多组数据,而且题目没给 哭得我AC率直掉 代码 用的朴素Dinic #include<cstdio ...

  9. [讲解]网络流最大流dinic算法

    网络流最大流算法dinic ps:本文章不适合萌新,我写这个主要是为了复习一些细节,概念介绍比较模糊,建议多刷题去理解 例题:codevs草地排水,方格取数 [抒情一下] 虽然老师说这个多半不考,但是 ...

随机推荐

  1. 如何使用Jetbrains Clion 在一个工程里 编译单个C++源文件 （实现一键编译且运行）

    这篇文章主要在下面这篇文章的基础上,先是实现了一键编译和一键运行两个单个功能,最后又进一步使用Clion自带的Custom Build Application实现编译且运行一键实现. https:// ...

  2. leetcode234 回文链表 两种做法（stack(空间非O(1)），空间O(1)）

    link: leetcode234 回文链表 方法1, 快慢指针,把前半部分存入栈中和后半部分比较 public boolean isPalindrome(ListNode head) { if(he ...

  3. HTTP学习记录：二、请求方法

    学习资源主要为:@小坦克HTTP相关博客 最基础的是4种,GET.POST.PUT.DELETE对应着对资源的查.改.增.删.最常用的是GET和POST. GET一般用于获取/查询资源信息: POST ...

  4. c++ 事件回调 java

    #pragma once #ifdef __cplusplus extern "C" { #endif typedef void(*sig_t)(int); int FirstEl ...

  5. sentos7忘记root密码，重置密码

    一.两种模式:单用户模式和救援模式 下面示例救援模式 1.重启linux系统主机并出现引导界面,按e键进入内核编辑界面: 2.在linux16参数那一行的最后面追加“rd.break”参数,记住要空开 ...

  6. 【Qt开发】foreach用法

    If you just want to iterate over all the items in a container in order, you can use Qt's foreach key ...

  7. 【Qt开发】Linux下Qt开发环境的安装与集成

    近期工作需要在Linux下用Qt进行C++开发,所以就在linux下尝试装QT开发环境.本人用的linux是CentOS 6.5.现在对安装过程做出总结.有两种安装方式,下面分别详述: 1 图形化安装 ...

  8. 使用原生js 获取用户访问项目的浏览器类型

    想要获取浏览器的类型很简单,网上提供了很多方法,但是看过之后,都是根据浏览器内核来判断是ie,谷歌,火狐,opeara的, 所以不能进一步判断在国内使用的主流浏览器类型,比如360,百度,搜狐浏览器等 ...

  9. Java中类和接口

    很形象的接口的使用——针对初学者 里氏代换原则是什么?听起来很高深,不过我们也不是什么学院派,就不讲大道理了,直接拿个例子来说一下. 我们拿人和程序员举个例子.人是一个大类,程序员是继承自人的子类.看 ...

  10. Java合并数组的实现方式

    String[] aa = {"11","22","33"};String[] bb = {"44","55& ...