最大流最小割合集

最新推荐文章于 2021-09-15 19:43:35 发布
最新推荐文章于 2021-09-15 19:43:35 发布
阅读量872 收藏 1
点赞数
分类专栏： 费用流|网络流 文章标签： 最大流最小割
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/solotzg/article/details/38794795
版权

hdu 3452 Bonsai

一颗带权的树，求最小割使根和叶不连通
添加汇点，每个叶子向其连权值为inf的边，求根到汇点的最小割

hdu 3491 Thieves

基于点的最小割，将每个点拆分成入和出两点

hdu 3987 Harry Potter and the Forbidden Forest

求最少割边数的最小割集，实际上就是求原图有多少次扩增。
借鉴了别人的方法，建图的时候将原权值变为 A = A*(N+1)+1，那么最后得到的maxFlow = (.....)*(N+1)+B，而B就是扩增次数。

hdu 2435 There is a war

在原有向图中可以添加或修改一条原有的边使其权值为inf。求最大的最小割
分析：
如果是修改原有边，则该边的端点必然在原图的割集中，假设修改的边为e{a, b}，则再跑一边最大流maxFlow = min(maxFlow(S, a), maxFlow(b,T))。因为原图的割集互不影响，所以可以枚举找出以每个割集中割点为新汇点的最大流，最后求出两者中的最小值即为解。
若添加新边，如果原图中S和T连通则同上。否则，由于S和T所在部分已经构成了割集，所以解法同上。 
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
const int MAXN = 105;
const int MAXM = MAXN*MAXN*2;
int n, m;
struct _edge
{
    int v, nxt;
    int w;
    _edge(int vv, int ww, int nnxt):v(vv),w(ww),nxt(nnxt){}
    _edge(){}
}ee[MAXM];
int head[MAXN], cnt, sto[MAXM], n1, n2;
int cur[MAXN], dis[MAXN], gap[MAXN], pre[MAXN], ff[MAXN];
void add(int u, int v, int w)
{
    ee[cnt] = _edge(v,w,head[u]); head[u] = cnt++;
    ee[cnt] = _edge(u,0,head[v]); head[v] = cnt++;
}
int sap(int start,int end,int nodenum)
{
    memset(dis,0,4*MAXN);
    memset(gap,0,4*MAXN);
    memcpy(cur,head,4*MAXN);
    int u=pre[start]=start;
    int maxflow=0,aug=-1;
    gap[0]=nodenum;
    while(dis[start]<nodenum)
    {
        loop:
        for(int &i=cur[u];i!=-1;i=ee[i].nxt)
        {
            int v=ee[i].v;
            if(ee[i].w&&dis[u]==dis[v]+1)
            {
                if(aug==-1||aug>ee[i].w)
                    aug=ee[i].w;
                pre[v]=u;
                u=v;
                if(v==end)
                {
                    maxflow+=aug;
                    for(u=pre[u];v!=start;v=u,u=pre[u])
                    {
                        ee[cur[u]].w-=aug;
                        ee[cur[u]^1].w+=aug;
                    }
                    aug=-1;
                }
                goto loop;
            }
        }
        int mindis=nodenum;
        for(int i=head[u];i!=-1;i=ee[i].nxt)
        {
            int v=ee[i].v;
            if(ee[i].w && mindis>dis[v])
            {
                cur[u]=i;
                mindis=dis[v];
            }
        }
        if((--gap[dis[u]])==0)break;
        gap[dis[u]=mindis+1]++;
        u=pre[u];
    }
    return maxflow;
}
void dfs(int u)
{
    ff[u] = 1;
    ++n1;
    for (int i = head[u]; ~i; i=ee[i].nxt)
    {
        int v = ee[i].v;
        if (!ff[v] && (i&1)==0 &&ee[i].w > 0) dfs(v);
    }
}
void _dfs(int u)
{
    ff[u] = 2;
    ++n2;
    for (int i = head[u]; ~i; i=ee[i].nxt)
    {
        int v = ee[i].v;
        if (!ff[v] && (i&1) == 1 && ee[i^1].w > 0) _dfs(v);
    }
}
void init()
{
    cnt = 0;
    memset(head, -1, sizeof head);
    memset(ff, 0, sizeof ff);
    n1 = n2 = 0;
}
int main()   
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    int t, res, a, b;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d", &n, &m);
        init();
        while (m--)
        {
            int u, v, c;
            scanf("%d%d%d", &u, &v, &c);
            add(u, v, c);
        }
        int pp = sap(1, n, n);
        a = 0, b = 0;
        dfs(1); _dfs(n);
        for (int i = 0; i< cnt; ++i) sto[i] = ee[i].w;
        for (int u = 2; u< n; ++u)
        {
            if (ff[u] == 1)
            {
                for (int i = 0; i< cnt; ++i) ee[i].w = sto[i];
                a = max(a, sap(1,u,n1));
            }
            else if (ff[u] == 2)
            {
                for (int i = 0; i< cnt; ++i) ee[i].w = sto[i];
                b = max(b, sap(u,n,n2));
            }
        }
        printf("%d\n", min(a,b)+pp);
    }
    return 0;
}

hdu 3996 Gold Mine（最大闭合权图）

闭合图的概念：在一个图中，我们选取一些点构成集合，记为V，且集合中的出边(即集合中的点的向外连出的弧)，所指向的终点(弧头)也在V中，则我们称V为闭合图。最大权闭合图即在所有闭合图中，集合中点的权值之和最大的V，我们称V为最大权闭合图。
构造方法：一个点的权值如果为正，则与S相连，且边权为该点的权值，如果为负，则与T相连，且边权为该点权值的绝对值，原来的边的权值设为正无穷。
 
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
typedef __int64 LL;
const int MAXN = 3010;
const int MAXM = MAXN*55*2;
const LL INF = LL(1)<<55;
int n, m;
struct _edge
{
    int v, nxt;
    LL w;
    _edge(int vv, LL ww, int nnxt):v(vv),w(ww),nxt(nnxt){}
    _edge(){}
}ee[MAXM];
int head[MAXN], cnt;
int cur[MAXN], dis[MAXN], gap[MAXN], pre[MAXN];
void add(int u, int v, LL w)
{
    ee[cnt] = _edge(v,w,head[u]); head[u] = cnt++;
    ee[cnt] = _edge(u,0,head[v]); head[v] = cnt++;
}
LL sap(int start,int end,int nodenum)
{
    memset(dis,0,4*MAXN);
    memset(gap,0,4*MAXN);
    memcpy(cur,head,4*MAXN);
    int u=pre[start]=start;
    LL maxflow=0,aug=-1;
    gap[0]=nodenum;
    while(dis[start]<nodenum)
    {
        loop:
        for(int &i=cur[u];i!=-1;i=ee[i].nxt)
        {
            int v=ee[i].v;
            if(ee[i].w&&dis[u]==dis[v]+1)
            {
                if(aug==-1||aug>ee[i].w)
                    aug=ee[i].w;
                pre[v]=u;
                u=v;
                if(v==end)
                {
                    maxflow+=aug;
                    for(u=pre[u];v!=start;v=u,u=pre[u])
                    {
                        ee[cur[u]].w-=aug;
                        ee[cur[u]^1].w+=aug;
                    }
                    aug=-1;
                }
                goto loop;
            }
        }
        int mindis=nodenum;
        for(int i=head[u];i!=-1;i=ee[i].nxt)
        {
            int v=ee[i].v;
            if(ee[i].w && mindis>dis[v])
            {
                cur[u]=i;
                mindis=dis[v];
            }
        }
        if((--gap[dis[u]])==0)break;
        gap[dis[u]=mindis+1]++;
        u=pre[u];
    }
    return maxflow;
}
void init()
{
    cnt = 0;
    memset(head, -1, sizeof head);
}
int main()   
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    int t, cs = 0, nl, ng, ww, ed = 3000;
    LL cost, val, res;
    scanf("%d", &t);
    while (t--)
    {
        res = 0;
        n = 0;
        init();
        printf("Case #%d: ", ++cs);
        scanf("%d", &nl);
        for (int i = 1; i<= nl; ++i)
        {
            scanf("%d", &ng);
            for (int j = 1; j<= ng; ++j)
            {
                int d = (i-1)*25+j, a, b;
                ++n;
                scanf("%I64d%I64d%d", &cost, &val, &ww);
                val = val - cost;
                if (val > 0) add(0, d, val), res+=val;
                else if (val < 0) add(d, ed, -val);
                while (ww--)
                {
                    scanf("%d%d", &a, &b);
                    a = (a-1)*25+b;
                    add(d, a, INF);
                }
            }
        }
        printf("%I64d\n", res-sap(0,ed,2+n));
    }
    return 0;
}

hdu 3870 Catch the Theves（平面图最小割最短路）

将平面图的最小割问题转化为最短路问题 
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#include <vector>
using namespace std;
typedef __int64 LL;
const int MAXN = 405*405;
const int MAXM = MAXN*4;
int n, m;
struct _edge
{
    int v, nxt;
    int w;
    _edge(int vv, int ww, int nnxt):v(vv),w(ww),nxt(nnxt){}
    _edge(){}
}ee[MAXM];
int head[MAXN], cnt;
int vis[MAXN];
void add(int u, int v, int w)
{
    ee[cnt] = _edge(v,w,head[u]); head[u] = cnt++;
    ee[cnt] = _edge(u,w,head[v]); head[v] = cnt++;
}
void init()
{
    cnt = 0;
    memset(head, -1, sizeof head);
    memset(vis, 0, sizeof vis);
}
struct _node
{
    int u, w;
    _node(int a, int b):u(a),w(b){}
    _node(){}
    bool operator < (const _node & a) const
    {
        return w > a.w;
    }
};
priority_queue<_node> qq;
int solve(int S, int T)
{
    while (!qq.empty()) qq.pop();
    _node tn(S, 0); 
    int v, w, res;
    qq.push(tn);
    while (!qq.empty())
    {
        tn = qq.top(); qq.pop();
        if (vis[tn.u]) continue;
        vis[tn.u] = 1;
        if (tn.u == T)
        {
            res = tn.w;
            break;
        }
        for (int i = head[tn.u]; ~i; i=ee[i].nxt)
        {
            if (vis[v=ee[i].v]) continue;
            qq.push(_node(v, tn.w+ee[i].w));
        }
    }
    return res;
}
int main()   
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    int t, a, p, S, T, k;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        S = n*n; T = S+1;
        init();
        for (int i = 0; i< n; ++i)
        for (int j = 0; j< n; ++j)
        {
            scanf("%d", &a);
            p = i*n+j;
            if (j == 0 && i != n-1)
                add(T, p, a);
            if (i == n-1 && j != n-1)
                add(T, p-n, a);
            if (i == 0 && j != n-1)
                add(S, p, a);
            if (j == n-1 && i != n-1)
                add(S, p-1, a);
            if (j > 0 && j < n-1 && i < n-1)
                add(p, p-1, a);
            if (i > 0 && i < n-1 && j < n-1)
                add(p-n, p, a);
        }
        printf("%d\n", solve(S, T));
    }
    return 0;
}
deprecated_tzg
关注
专栏目录
最大流与最小割问题：网络流算法解析
一键难忘的博客
08-04 3668
最大流问题是指在一个有向图中，从源点到汇点传输的最大流量。图中的每条边都有一个容量，表示其最大能通过的流量。我们的目标是找到从源点到汇点的路径，使得流量最大化。给定一个有向图 ( G = (V, E) )，其中 ( V ) 是顶点集合，( E ) 是边集合。每条边 ( (u, v) ) 具有一个容量 ( c(u, v) )。源点 ( s ) 和汇点 ( t ) 是两个特殊的顶点。我们的目标是找到从 ( s ) 到 ( t ) 的最大流量。
求最大流最小割--图割方法
08-18
立体匹配会用到，新的图割方法 是程序，可以直接调用的
hihocoder 网络流二·最大流最小割定理
weixin_30483697的博客
09-20 401
网络流二·最大流最小割定理 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 小Hi：在上一周的Hiho一下中我们初步讲解了网络流的概念以及常规解法，小Ho你还记得内容么？ 小Ho：我记得！网络流就是给定了一张图G=(V,E)，以及源点s和汇点t。每一条边e(u,v)具有容量c(u,v)。网络流的最大流问题求解的就是从s到t最...
最大流/最小割算法总结
热门推荐
euler1983的专栏
10-20 2万+
1。基本定理：最小割集的流量之和=网络中的最大流。2。求最大流和求最小割集是两类不同的算法。3。解决最大流问题的常用到Ford-Fulkerson方法，之所以称其方法而不是算法，是因为在这种思想下包含着若干种时间复杂度不同的实现，其中较多地是使用Edmonds-Karp算法。与此相对，Push-relabel算法采用了与Ford-Fulkerson方法完全不同的思考角度，降低了渐进意义下的时间复杂度。而relabel-to-front算法则是对Push-relabel算法的改良和精炼，效率更佳。关于这三种常
最大流最小割合集 II
solotzg
08-30 609
hdu 1569 方格取数(2)
最小割与最大流（mincut & maxflow）
PeaceInMind的博客
11-30 9760
这里先介绍mincut和maxflow,为介绍Grabcut打下基础。Grabcut可以用在图像分割和文字二值化中。 1首先介绍Mincut问题。这部分内容主要翻译自[1],可以看原版理解的更深.由于个人没有看过中文教材，因此可能一些专业术语翻译的不太对，敬请见谅。一个有向图，并有一个源顶点（source vertex）和目标顶点（target vertex）.边的权值为正,又称之为容量（capa...
最大流最小割经典例题_最大流最小割基本
weixin_42514709的博客
12-23 1243
小Hi：在上一周的Hiho一下中我们初步讲解了网络流的概念以及常规解法，小Ho你还记得内容么？小Ho：我记得！网络流就是给定了一张图G=(V,E)，以及源点s和汇点t。每一条边e(u,v)具有容量c(u,v)。网络流的最大流问题求解的就是从s到t最多能有多少流量。小Hi：那这个问题解决办法呢？小Ho：解决网络流的基本思路就是寻找增广路，不断更新残留网络。直到找不到新的增广路，此时得到的流就是该网络...
最大流最小割
08-24
最大流最小割百度文库讲解
max_min_segment.zip_min图像_min图割_图最小割_最大流最小割_最小割
07-14
有趣的是，图的最大流值等于最小割的值，这是由最大流最小割定理保证的。 在图像处理中，图割算法常被用于图像分割任务。图像可以被看作一个二维网格，每个像素点可以视为图的一个节点，像素之间的相似性或连接关系...
最大流最小割+grabcut文献.zip
05-07
Grabcut可以用在图像分割和文字二值化中。grabcut最基础、最核心的内容就是最大流与最小割（mincut & maxflow）。代码是mincut & maxflow 的matlab版，压缩包里放了grabcut 文献，欢迎图像分割爱好者下载学习。
hihocode#1378 : 网络流二·最大流最小割定理(最大流求最小割集)
Zhangcan233的博客
10-04 976
题目链接EK求最小割集模板代码：#include<cstdio> #include<cstring> #include<algorithm> #include<iostream> #include<string> #include<vector> #include<stack> #include<bitset> #include<cstdlib> #include<cmath> #include<s
最大流-最小割点集
H_ang的博客
11-30 333
题目链接：http://hihocoder.com/problemset/problem/1378?sid=1551012 题目大意： 思路：跑出最大流，再bfs一次残剩网络，满流的边不跑就得到了割点集。 #include<bits/stdc++.h> using namespace std; const int maxn=1e5+10; const int maxm=2e5+10;...
uva 11248 - Frequency Hopping 最大流最小割入门题 求割集模板
hnust_xiehonghao的专栏
08-27 1467
232/UK44i/334sda#nh$X3y/Appx-301a At this moment, through out Europe, our base station numbers 1 to N are actively operational through wireless channels. Immediately we require sending C secret mess
网络流之最小割hihocoder116，最小割==最大流，点属于的割集，最小割性质，关键割边，最小割边
Dave_lzw的博客
10-21 376
点属于的割集： 必在S割集的点: 所有由S开始bfs到达的点 必在T割集的点: 所有由T开始bfs到达的点 求一组最小割边： 从S开始dfs，标记为true，对于一条边，如果一端为true，另一端为false，那么这条边就属于割边。 关键割边： 1.对于该边如果该边容量增加，那么网络的总流量增加。 2.在最大流后的残量网络中，从S开始dfs标记点属于S集合，从T反向dfs标记属于T集合，如果一个边...
max flow&min cut最大流-最小割
cxy_hust的博客
09-15 391
1 最大流-最小割本身含义 首先 起始点 s, 终止点 t, 从s->t的所有通路中，能够流过来的最大流量就是最大流，这里举个例子： 比如有如下的图： 1 -> 2 管道是5的容量， 2 -> 4 管道是4的容量， 1 -> 3 管道是3的容量， 3 -> 4 管道是6的容量， 那么从1->4的最大流，就是4 + 3 = 7 最小割： 最小割是指，从图中移除一些边的集合以达到隔断从s到t的目的，成为一个图割，然后最小割，就是所有图割中，边权(管道的流量)之和最小的一个图割
图形分割算法<==>最小割<==>最大流<==>网络流问题
jingmiaa的博客
10-14 2万+
最近研究图形分割算法，然后就牵扯出了网络流问题中的最大流最小割问题。 反过来学习才是最好的掌握和理解路线： 第一、什么是网络流问题？ 第二、最大流、最小割 上图网络流就是求解最大流的一个实例。由此，可以引出最大流的一些基本的定义和概念 可以这样看，图就是一种管道，管道有最大通过流量的限制，图中边的权值就是所谓的“容量”。同时，注意有唯一的源点和汇点。
0-1分数规划 网络流 最小割 最大流最小割 zoj2676 network
lyc
08-30 1691
【题目大意】 选取一边集E，使得边集的平均值最小 注意边集中必须包含割(题目要求) 于是 分数规划，二分. 对于二分的每一个 mid , 将 weight 最后输出边集既可 一个无向图，求最小的平均割：，其中，wi表示边权，该表达式的意思就是选择某些边集构成S-T割，使得平均割最小。 分析：0-1分数规划问题，设，则令mincut=因为ci只能取0或1所以转换模型，边权值变为
（转）最大流最小割定理
。
12-30 2248
网络流中的割是指S-T割，即一个边集合E，使得网络流中所有点被划分成2个集合，一个集合含起点S，一个含终点T。E中边的流量就是割，最小割就是使得E的流量最小。那么最小割为什么等于最大流？ 直观理解：假设最大流为30，找一个割集，把网络流分割成了2部分，那现在最大流就是0了。相当于找的割集得把原来的流阻断，割要最小，就要恰好阻断所有流，如果割<30，说明一定存在一条S->T的路径有流...
最大流与最小割
蒟蒻QMQ
04-18 455
   注：本人只是一个萌新，有一些地方的用语会不太专业（大佬：是十分不专业），我不会用什么技术用语，这些文章对那些跟我一样的萌新会比较适用！   最大流：       原题地址 　　最大流我讲的是我自己对dinic算法的一些思想，希望对你会有用！ 　　我记网络流靠三个关键字：       1.找最短路径 　　将流量流向终点，且损害最少的边，这是找路径的一个关键，那么，便可以把分出最少...
图论算法详解：最大流最小割
"本文主要介绍了图论中的网络流模型，特别是最大流最小切的概念，以及相关的图论算法。网络流图是一种特殊的有向图，其中包含源点S和汇点T，每条边都有非负的容量限制。文章讨论了可行流的定义，流量平衡条件，以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值