最大流&&最小割&&最大权闭子图题集

最新推荐文章于 2021-02-12 06:17:45 发布
最新推荐文章于 2021-02-12 06:17:45 发布
阅读量256 收藏
点赞数
分类专栏： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41183791/article/details/95242458
版权

链接:https://vjudge.net/problem/POJ-3281

题意:

一头牛需要吃1个drink和1个food,给定牛的喜好,每个food和drink只能给1头牛吃,问最多满足多少头牛

解析:

匹配问题,第一个想到是二分图匹配,但是这里要匹配两个东西,所以二分图匹配无效

解法为最大流.

如果建图为:food->牛->drink,解决了一个食物饮料给1头牛吃,但是无法解决牛吃多个食物,多个drink

正确的建图为:food->牛->牛'->drink,这样就保证牛只会吃一个food和drink

网络流建图才是关键

0,2*n+f+d+1分别为源点和汇点

1~f为food,   f+1~2*n+f为牛与niu',  2*n+f+1~2*n+f+d为drink.

ac:

#include <cstdio>
#include<iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
 
const int MAXN = 1005;
const int inf = 1e9 + 7;
 
int G[MAXN][MAXN],layer[MAXN], G1[MAXN][MAXN];
int P, N;
 
struct node
{
    int in[MAXN],
        out[MAXN],
        flow;
}a[MAXN];
 
void init()
{
    memset(G, 0, sizeof G);
    memset(G1, 0 ,sizeof G1);
    for (int i = 1; i <= P; i++)
    {
        a[1].out[i] = 0;
        a[1].in[i] = 0;
        a[N + 2].in[i] = 1;
        a[N + 2].out[i] = 1;
    }
    a[1].flow = inf;
    a[N + 2].flow = inf;
}
 
bool BFS(int front, int tail) {
    int vis[MAXN] = {0};
    queue<int> que;
    que.push(front);
    memset(layer,-1,sizeof(layer));
    vis[front] = 1;
    layer[front] = 0;
 
    while (!que.empty()){
        int u=que.front();
        que.pop();
        if (u == tail) return true;
        for(int i=1;i<=tail;i++){
            if (G[u][i] && !vis[i]){
                vis[i] = true;
                layer[i] = layer[u] + 1;
                que.push(i);
            }
        }
    }
    return false;
}
 
int dfs(int u, int MaxFlow, int tail){
    if (u == tail) return MaxFlow;
    int uFlow = 0;
    for (int i = 0; i<= tail; i++){
        if (layer[u] + 1 == layer[i] && G[u][i]){
            int flow = min(MaxFlow - uFlow , G[u][i]);
            flow = dfs(i, flow, tail);
            G[u][i] -= flow;
            G[i][u] += flow;
            uFlow += flow;
            if (uFlow == MaxFlow) break;
        }
    }
    return uFlow ;
}
 
int dinic(int front, int tail){
    int MaxFlow = 0;
    while (BFS(front, tail))
        MaxFlow += dfs(front, inf, tail);
    return MaxFlow;
}
 
int main()
{
    int n,f,d,x,y,c;
    scanf("%d%d%d",&n,&f,&d);
    int st=0,ed=f+2*n+d+1;
 
    for(int i=1;i<=f;i++)
        G[st][i]=1;
    for(int i=1;i<=n;i++)
        G[i+f][i+n+f]=1;
    for(int i=1;i<=d;i++)
        G[2*n+f+i][ed]=1;
 
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&x,&y);
        while(x--)
        {
            scanf("%d",&c);
            G[c][f+i]=1;
        }
        while(y--)
        {
            scanf("%d",&c);
            G[i+n+f][2*n+f+c]=1;
        }
    }
    printf("%d\n",dinic(st,ed));
}

 

链接:https://codeforces.com/gym/101981/attachments

题意:

有n个英雄,m个野怪,k瓶药水

1个英雄只能打1个野怪

野怪只能被打死1次

k瓶药,可以让一个英雄额外打死一个野怪

一个英雄最多吃1瓶药

问最多打死几个野怪?

解析:

最大流问题,模板题

建图方法:

源点->(1)英雄->(2)英雄'->(1)野怪->(1)野怪'->(1)终点

源点->(k)药->(1)英雄

ac:

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define ll long long
#define MAXN 2100
using namespace std;

/* n,m,k  英雄数目,野怪数,药水数
   ti ti个mij
*/

int G[MAXN][MAXN];
const int inf = 1e9 + 7;

int layer[MAXN], G1[MAXN][MAXN];
int P, N;

struct node
{
    int in[MAXN],
        out[MAXN],
        flow;
}a[MAXN];

void init()
{
    memset(G, 0, sizeof G);
    memset(G1, 0 ,sizeof G1);
    for (int i = 1; i <= P; i++)
    {
        a[1].out[i] = 0;
        a[1].in[i] = 0;
        a[N + 2].in[i] = 1;
        a[N + 2].out[i] = 1;
    }
    a[1].flow = inf;
    a[N + 2].flow = inf;
}

bool BFS(int front, int tail) {
    int vis[MAXN] = {0};
    queue<int> que;
    que.push(front);
    memset(layer,-1,sizeof(layer));
    vis[front] = 1;
    layer[front] = 0;

    while (!que.empty()){
        int u=que.front();
        que.pop();
        if (u == tail) return true;
        for(int i=1;i<=tail;i++){
            if (G[u][i] && !vis[i]){
                vis[i] = true;
                layer[i] = layer[u] + 1;
                que.push(i);
            }
        }
    }
    return false;
}

int dfs(int u, int MaxFlow, int tail){
    if (u == tail) return MaxFlow;
    int uFlow = 0;
    for (int i = 0; i<= tail; i++){
        if (layer[u] + 1 == layer[i] && G[u][i]){
            int flow = min(MaxFlow - uFlow , G[u][i]);
            flow = dfs(i, flow, tail);
            G[u][i] -= flow;
            G[i][u] += flow;
            uFlow += flow;
            if (uFlow == MaxFlow) break;
        }
    }
    return uFlow ;
}

int dinic(int front, int tail){
    int MaxFlow = 0;
    while (BFS(front, tail))
        MaxFlow += dfs(front, inf, tail);
    return MaxFlow;
}

int main()
{
    int n,m,k,g,t;
    scanf("%d%d%d",&n,&m,&k);
    int st=0;//起点
    int ed=2*n+2*m+2;///终点(终点一定为坐标最大的)
    int gv=ed-1;//药水点
    ///建图
    G[st][gv]=k;//连药水
    for(int i=1;i<=n;i++)//英雄连英雄',源点连英雄,药水连英雄
    {
        G[st][i]=1;
        G[i][i+n]=2;
        G[gv][i]=1;
    }
    for(int i=1;i<=m;i++)//野怪连野怪'
    {
        G[2*n+i][2*n+m+i]=1;
        G[2*n+m+i][ed]=1;
    }
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&t);
        for(int j=1;j<=t;j++)
        {
            scanf("%d",&g);
            G[n+i][2*n+g]=1;
        }
    }
    printf("%d\n",dinic(st,ed));
    return 0;
}

hdu-6582:http://acm.hdu.edu.cn/showproblem.php?pid=6582

解析:

给定一个图,让你切断一些边,使得最短路变大或者断路

解析:

用最短路点建图求最小割

ac:

#include<bits/stdc++.h>
#define ll long long
#define MAXN 100005
using namespace std;

struct Edge
{
    ll v, w, nxt;
};

bool isFind;
ll head[MAXN];
Edge edge[MAXN<<1];
ll dis[MAXN], gap[MAXN];
ll n, m, ecnt, aug, maxFlow;
ll u[MAXN],v[MAXN],w[MAXN];
ll to[MAXN<<1],val[MAXN<<1],next1[MAXN<<1],head2[MAXN<<1];
ll tot=0;
ll dist[MAXN];


void init(){
    tot=ecnt = maxFlow = 0;
    memset(gap, 0, sizeof(gap));
    memset(dis, 0, sizeof(dis));
    memset(edge, 0, sizeof(edge));
    memset(head, -1, sizeof(head));

    memset(dist,0,sizeof(dist));
    memset(to,0,sizeof(to));
    memset(head2,0,sizeof(head2));
    memset(val,0,sizeof(val));
    memset(next1,0,sizeof(next1));
    gap[0] = n;
}

void addEdge(ll u, ll v, ll w){
    edge[ecnt].v = v;
    edge[ecnt].w = w;
    edge[ecnt].nxt = head[u];
    head[u] = ecnt++;
}

void Find(ll s)
{
    ll dx, augc;
    ll minDis;
    if(s == n){
        isFind = true;
        maxFlow += aug;
        return;
    }
    augc = aug;
    minDis = n - 1;
    for(ll i = head[s]; i + 1; i = edge[i].nxt){
        if(edge[i].w > 0){
            if(dis[s] == dis[edge[i].v] + 1){
                aug = min(aug, edge[i].w);
                Find(edge[i].v);
                if(dis[1] >= n) return;
                if(isFind){
                    dx = i;
                    break;
                }
                aug = augc;
            }
            minDis = min(minDis, dis[edge[i].v]);
        }
    }
    if(!isFind){
        gap[dis[s]]--;
        if(gap[dis[s]] == 0) dis[1] = n;
        dis[s] = minDis + 1;
        gap[dis[s]]++;
    }else{
        edge[dx].w -= aug;
        edge[dx ^ 1].w += aug;
    }
}

struct node
{
    ll to;
    ll dis;
    friend bool operator <(node a,node b)
    {
        return a.dis>b.dis;
    }
};

void add(ll u,ll v,ll x)
{
    to[++tot]=v;
    val[tot]=x;
    next1[tot]=head2[u];
    head2[u]=tot;
}

void dij(ll st)
{
    for(ll i=0;i<MAXN;i++)
        dist[i]=1e18;
    dist[st]=0;
    priority_queue<node> que;
    que.push(node{st,0});
    while(!que.empty())
    {
        ll u=que.top().to;que.pop();
        for(ll i=head2[u];i;i=next1[i])
        {
            ll v=to[i];
            if(dist[v]>dist[u]+val[i])
            {
                dist[v]=dist[u]+val[i];
                que.push(node{v,dist[v]});
            }
        }
    }
}

int main()
{
    ll t;
    scanf("%lld",&t);
    while(t--)
    {
        init();
        scanf("%lld%lld", &n, &m);
        init();
        for(ll i = 0; i < m; i++)
        {
            scanf("%lld%lld%lld", &u[i], &v[i], &w[i]);
            add(u[i],v[i],w[i]);
        }
        dij(1);
        for(ll i=0;i<m;i++)
        {
            if(dist[v[i]]==dist[u[i]]+w[i])
            {
                addEdge(u[i],v[i],w[i]);
                addEdge(v[i],u[i],0);
            }
        }
        while(dis[1]<n)
        {
            isFind = 0;
            aug = 1e18;
            Find(1);
        }
        printf("%lld\n",maxFlow);
    }
    return 0;
}

最大权闭合子图:

链接：https://ac.nowcoder.com/acm/contest/116/D

众所周知，杨老师是一位十分勤奋的老师，他非常的热爱学习。

勤奋的他为自己罗列了一个学习清单，共有n个知识点，他可以有选择的进行学习。

每个知识点都会对应0个或1个或多个先修知识点（只有学会了先修知识点才能学习该知识点），同时每个知识点都有一个智慧值和一个智力消耗值。

杨老师希望在进行过激烈的学习之后，他的收获可以·量化为所有学过的题的智慧值的和与智力消耗值的和的差值。请问，这个值最大是多少？

解析:

最大权闭合子图

经典的费用流问题，什么是最大权闭合子图呢？就是给你一个带权图，我们要取出一个连通块使之权值最大

杨老师获得的智慧-智力消耗最大=>全图中的正权点-最小割

ac:

#include<bits/stdc++.h>
#define mm1(a) memset((a),-1,sizeof((a)))
#define mm0(a) memset((a),0,sizeof((a)))
#define mmx(a) memset((a),0x3f,sizeof((a)))
using namespace std;

typedef long long LL;       //https://blog.csdn.net/qq_39599067/article/details/80178357
const int N = 100005;
const int INF = 0x3f3f3f3f;
int n,m,tot,vt,vs;
int d[N],head[N];

struct lp
{
    int to,w,nex;
    lp(){}
    lp(int a,int b,int c){to=a;w=b;nex=c;}
}cw[N<<2];

int pigNum[N],pigTo[N];
inline void add(int a,int b,int c)
{
    cw[++tot]=lp(b,c,head[a]);
    head[a]=tot;
    cw[++tot]=lp(a,0,head[b]);
    head[b]=tot;
}

bool bfs()
{
    mm1(d);
    queue<int>Q;
    Q.push(vt);d[vt]=0;
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        for(int i=head[u];i!=-1;i=cw[i].nex)
        {
            int v=cw[i].to;
            if(cw[i^1].w&&d[v]==-1)
            {
                d[v]=d[u]+1;
                Q.push(v);
            }
        }
    }
    return d[vs]!=-1;
}

int dfs(int x,int f)
{
    if(x==vt||f==0) return f;
    int use=0,w;
    for(int i=head[x];i!=-1;i=cw[i].nex)
    {
        int to=cw[i].to;
        if(d[to]==d[x]-1 && cw[i].w)
        {
            w=dfs(to,min(cw[i].w,f-use));
            cw[i].w-=w,cw[i^1].w+=w;
            use+=w;
            if(use==f) return f;
        }
    }
    return use;
}

inline void init()
{
    tot=-1;
    mm1(head);
    mm0(pigTo);
    vs=0,vt=n+1;
}

int main()
{
    int x,y;
    scanf("%d",&n);
    init();
    int sum=0;
    for(int i=1;i<=n;++i)
    {
        scanf("%d%d",&x,&y);
        if(x-y>=0)
        {
            sum+=x-y;
            add(vs,i,x-y);
        }
        else{
            add(i,vt,y-x);
        }
    }
    int cc=0;
    while(~scanf("%d%d",&x,&y))
    {
        add(y,x,INF);
        cc++;
        if(cc==3)
            break;
    }
    int ans=0;
    while(bfs())
        ans+=dfs(vs,INF);
    printf("%d\n",sum-ans);
    return 0;
}

https://www.cnblogs.com/wangwangyu/p/9802513.html

费用流:https://blog.csdn.net/weixin_41183791/article/details/88956873

Tao_oc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Ford-Fulkerson 最大流求解方法
Desgard_Duan
03-03 1880
在上一节《初识最大流问题》中，已经讲到了网络流中的一个经典问题 - 最大流问题。同上一篇的方式一样，这篇文章你要带着以下两个问题来阅读：怎样搜索到一条增广路？如何利用搜索到的增广路求解最...
最大流最小割经典例题_最大流
weixin_39875167的博客
01-04 3197
在前面的章节我们介绍了很多关于图的无环路应用，比如最短路径、拓扑排序、关键路径等，以及如何使用拓扑排序和DFS检测图中是否有环。本节将介绍一些含环路的图应用，主要是最大流以及求网络中最大流的典型算法Ford-Fulkerson方法、Dinic算法和前置推送-标签重贴方法。很多系统中涉及流量问题，例如公路系统中车流量、网络中的数据信息流、供油管道的油流量等，往往需要求从源节点到目的节点的最大负载，如...
网络流入门——最大流与最小割
wljoi的博客
07-15 859
网络流的定义 网络流(network-flows)是一种类比水流的解决问题方法，与线性规划密切相关。 例题 水要从S流到T，一共n个点，m根管道，每条管道有一个最大容量，求最多有多少水能流到T。 n<=100000,m<=800000 以下面这张图为例： ...
最大流最小割经典例题_最大流, 最小割问题及算法实现
weixin_30229479的博客
12-23 952
最大流(MaxFlow)问题给定指定的一个有向图,其中有两个特殊的点源S(Sources)和汇T(Sinks),每条边有指定的容量(Capacity),求满足条件的从S到T的最大流(MaxFlow).想象一条多条不同水流量的水管组成的网络, s为供水广, t为水用户, 最大流问题就是找到能够在s到t流通的最大水流量一个流是最大流当且仅当其残存网络不包含任何增广路径(里面的名称在后面有详细解释)流(...
最大流最小割经典例题_最大流最小割基本
weixin_42514709的博客
12-23 1201
小Hi：在上一周的Hiho一下中我们初步讲解了网络流的概念以及常规解法，小Ho你还记得内容么？小Ho：我记得！网络流就是给定了一张图G=(V,E)，以及源点s和汇点t。每一条边e(u,v)具有容量c(u,v)。网络流的最大流问题求解的就是从s到t最多能有多少流量。小Hi：那这个问题解决办法呢？小Ho：解决网络流的基本思路就是寻找增广路，不断更新残留网络。直到找不到新的增广路，此时得到的流就是该网络...
图论- 网络流- 最小割- 最大权闭合子图.rar
09-16
例如，通过将网络流图的边逆向，并赋予每条边反向的容量为负的权重，然后寻找最大权闭合子图，实际上就是寻找原网络流图中的最小割。 在学习和应用这些理论时，理解它们的基本概念、性质以及相应的算法至关重要。...
最小割算法
01-28
最大权闭合图和最大密度子图是与最小割密切相关的概念。最大权闭合图是寻找一个具有最大加权边数的子图，其中所有顶点都相互连接。而最大密度子图则是在保持子图连通性的前提下，找到一个边权重之和与顶点数比值最大...
网络流相关论文
09-01
《最小割模型在信息学竞赛中的应用》 《两极相通——浅谈最大—最小定理在信息学竞赛中的应用》 《从一套题目的解法试谈网络流的构造与算法》 《浅谈网络流算法的应用》 《最大流在信息学竞赛中应用的一个模型》 ...
网络最大流-最小割问题
11-03
最大流-最小割问题都是用于S-T图中，最大流是所有可能流函数中的有最大值的流。
最大流最小割经典例题_图割-最大流最小切割的最直白解读
weixin_35822833的博客
01-13 1324
导读： 本文主要针对图像分割中提及的图割算法作一个最直白的介绍，面向的读者是所有对这个方面感兴趣的同学。从目标上来说，希望所有读者在阅读本文后，都能够自己通过自己熟悉的编程语言实现这个算法。什么是图？本文针对的图主要是有向图，具体定义先不给出，先看一个具体例子：图1：示例有向图上图就是一个有向图，不用看官方定义，我们自己就能给出自己的定义：1. 有向图包含了顶点与边；2. 每一条边有两个端点，...
最大流最小割经典例题_算法: 最大流与最小割
weixin_31968831的博客
02-12 1881
什么是最大流最大流要解决的问题是从 S 到 T 怎么才能最大地将数据运到另一边。这个“数据”可以是水，或者网络数据包。举个例子在上面这个图中将数据从 S 运到 T，其中边的权值称为 Capacity 即，在这条边中流动的数据不能超过 Capacity 值，。这个图很简单，我们很容易就看出来最大流是 5。流动方向为S - 1 - T: 2S - 1 - 2 - T: 1S - 2 - T: 2那最小...
整理一下最大流模板 - 题目是洛谷P3376
weixin_38169562的博客
12-26 58
#include<iostream> #include<cstdio> #include<cstring> #include<algorithm> #include<queue> #include<cmath> #include<bitset> #define mme(a,b) memset((a),(b...
网络流题集
热门推荐
夏天的风
07-24 1万+
【HDU】 1532 Drainage Ditches(入门)    [最大流] 3549 Flow Problem(入门)    [最大流] 3572 Task Schedule(基础)    [最大流]任务分配,判断满流 2732 Leapin' Lizards(较难)    [最大流] 3338 Kakuro Extension(较难，好题)    [最大流][数和]神奇最大流行进
（POJ3308）Paratroopers 最大流最小割，建图，模板题
STILLxjy
07-27 1059
Paratroopers Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 8373 Accepted: 2516 DescriptionIt is year 2500 A.D. and there is a terrible war between the forces of th
浅谈最大权闭合子图
月殇
08-15 310
闭合图：对于一个有向图G，存在点集合V，任取点u属于V，u的出边的另一个点也属于V，则为闭合图。 理解：任取一起点，终点必定是无出度的点。 最大权闭合子图：当每个点有一个权值w（有正有负），点权和最大的闭合图为最大权闭合子图。 如图： 最大权闭合子图为点集{3,4,5}，最大权为7+0-3=4。 求解方法：网络流。 建立超级源点s，超级汇点t。 所有点权为正数的点i，建边 s-&...
【题解】Dining POJ - 3281 ⭐⭐⭐ 【拆点 最大流】
Suprit's blog
07-31 534
Dining POJ - 3281 农夫为他的 N (1 ≤ N ≤ 100) 牛准备了 F (1 ≤ F ≤ 100)种食物和 D (1 ≤ D ≤ 100) 种饮料。每头牛都有各自喜欢的食物和饮料，而每种食物或饮料只能分配给一头牛。最多能有多少头牛可以同时得到喜欢的食物和饮料？ Input 第一行输入三个整数N, F, D 接下来n行，每行先输入两个整数 Fi 和 Di，分别表示编号为 i ...
最大权闭合子图（模板）
仰望星空
08-21 4917
参考博客： http://www.cnblogs.com/kane0526/archive/2013/04/05/3001557.htmlhttp://www.cnblogs.com/wuyiqi/archive/2012/03/12/2391960.htmlhttp://blog.csdn.net/sdj222555/article/details/7797534http://www.cnblo
最大流最小割经典例题_滑轮滑轮组知识点汇总整理——经典笔记
weixin_34255938的博客
12-31 967
滑轮:一个周边有槽，可绕轴转动、滑动的轮。定滑轮：滑轮的轴位置固定不动。动滑轮：轴随物体一起移动。定滑轮的实质是等臂杠杆定滑轮在重物质量一定时，绳子自由端施加任何方向的力匀速拉动物体，力的大小都是相等的(忽略绳子与滑轮的摩擦)典型例题1.小明利用如图所示的简单机械移动物体A时，当沿不同方向分别用F1，F2，F3的力，以不同速度匀速拉动物体时，忽略绳子与滑轮的摩擦，下列说法正确的是()2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值