Pool construction UVA - 1515 最小割模型

最新推荐文章于 2022-03-31 17:26:12 发布
最新推荐文章于 2022-03-31 17:26:12 发布
阅读量133 收藏
点赞数
分类专栏： # 紫书第十一章图论模型和算法
本文链接：https://blog.csdn.net/zpf1998/article/details/104445250
版权
该博客详细介绍了如何将UVA 1515问题转化为最小割问题，并建立了数学模型。通过源点s表示草，宿点t表示洞，利用最大流最小割定理来解决洞与草之间的转化费用问题。博主探讨了如何构建图，包括边的容量设置和相邻格子间的连接，并提到了拓扑结构。最终目标是求解最小代价的最大流，即最小割的大小。
摘要由CSDN通过智能技术生成

问题

分析

将问题转化为最小割问题，主要难点在数学模型的建立
将草和洞分隔开，使人联想到了割的概念，从而想到了最大流最小割定理，可以将问题转化为最大流模型
首先外围的格子上必须种草，如果有洞，就把洞变为草
里面的各自中有洞和草，如何表示洞和草之间的转化费用？添加源点s和宿点t，规定和s相连的是草，和t相连的是洞，那么把草和洞抽象成点，s->草 洞->t建立图，s->洞之间边的容量是d，洞->t之间的容量是f，表示切断费用，s->边缘点的容量是Inf，表示无法切断
相邻两个格子u,v，需要连接两条边u->v,v->u，如果u是草，v是洞，那么需要切断u->v，反之就要切断v->u，uv之间的容量是b，表示切断所需要的费用
画出的图可以分为五部分点，s，外围的草，内部的草，内部的洞，t
可以使用

###
#.#
###

这样的尝试画下拓扑
在这里插入图片描述
大概的拓扑是s->草 ，洞->t，相邻格子之间有边相连
洞->t之间的边达到最大容量就相当于洞变为草，草和洞之间有四条边相连，代表的是围栏费用
求出最大流，就是能把图分为两部分的最小割的大小，也就是最小代价
感觉还是挺抽象的

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <utility>
#include <map>
#include <string>
#include <queue>
#include <utility>
using namespace std;
const int maxn=2505,Inf=0x3f3f3f3f;

struct Edge{
    int from,to,cap,flow;
    Edge(int from,int to,int cap,int flow):from(from),to(to),cap(cap),flow(flow){}
};

struct EdmondsKarp{
    int n,m;
    vector<Edge> edges;
    vector<int> G[maxn];
    int a[maxn];
    int p[maxn];

    void init(int n){
        this->n=n;
        for(int i=0;i<n;++i) G[i].clear();
        edges.clear();
    }

    void AddEdges(int from,int to,int cap){
        edges.push_back(Edge(from,to,cap,0));
        edges.push_back(Edge(to,from,0,0));
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    int Maxflow(int s,int t){
        int flow=0;
        while(true){
            memset(a,0,sizeof(a));
            a[s]=Inf;
            queue<int> Q;
            Q.push(s);
            while(!Q.empty()){
                int x=Q.front();
                Q.pop();
                for(int i=0;i<G[x].size();++i){
                    Edge &e=edges[G[x][i]];
                    if(!a[e.to] && e.cap>e.flow){
                        a[e.to]=min(a[x],e.cap-e.flow);
                        p[e.to]=G[x][i];
                        Q.push(e.to);
                    }
                }
                if(a[t]) break;
            }
            if(!a[t]) break;
            flow+=a[t];
            for(int u=t;u!=s;u=edges[p[u]].from){
                edges[p[u]].flow+=a[t];
                edges[p[u]^1].flow-=a[t];
            }
        }
        return flow;
    }
};

int kase,w,h,d,f,b,cost,n;
char ch[55][55];
int dx[]={0,0,-1,1},dy[]={-1,1,0,0};
EdmondsKarp ek;
int main(void){
    scanf("%d",&kase);
    while(kase--){
        cost=0;
        n=0;
        scanf("%d%d",&w,&h);
        scanf("%d%d%d",&d,&f,&b);
        for(int i=0;i<h;++i){
            scanf("%s",ch[i]);
        }
        int t=w*h;
        ek.init(t+2);
        //处理外部的'.',将它们变成'#’
        for(int i=0;i<w;++i){
            if(ch[0][i]=='.'){ cost+=f;  ch[0][i]='#'; }
            if(ch[h-1][i]=='.'){ cost+=f; ch[h-1][i]='#'; }
        }
        for(int i=0;i<h;++i){
            if(ch[i][0]=='.'){ cost+=f; ch[i][0]='#'; }
            if(ch[i][w-1]=='.'){ cost+=f; ch[i][w-1]='#'; }
        }

        for(int i=0;i<h;++i){
            int t2=i*w;
            for(int j=0;j<w;++j){
                if(i==0 || j==0 || i==h-1 || j==w-1)
                    ek.AddEdges(t,t2+j,Inf);
                else if(ch[i][j]=='#') ek.AddEdges(t,t2+j,d);
                else ek.AddEdges(t2+j,t+1,f);
                for(int k=0;k<4;++k){
                    int nx=i+dx[k],ny=j+dy[k];
                    if(nx<0 || nx >=h || ny<0 || ny>=w) continue;
                    ek.AddEdges(t2+j,nx*w+ny,b);
                }
            }
        }
        int ans=ek.Maxflow(t,t+1);
        printf("%d\n",cost+ans);
    }
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <utility>
#include <map>
#include <string>
#include <queue>
#include <utility>
using namespace std;
const int maxn=2505,Inf=0x3f3f3f3f;

struct Edge{
    int from,to,cap,flow;
    Edge(int from,int to,int cap,int flow):from(from),to(to),cap(cap),flow(flow){}
};

struct Dinic{
    int n,m;
    vector<Edge> edges;
    vector<int> G[maxn];
    int d[maxn];

    void init(int n){
        this->n=n;
        for(int i=0;i<n;++i) G[i].clear();
        edges.clear();
    }

    void AddEdges(int from,int to,int cap){
        edges.push_back(Edge(from,to,cap,0));
        edges.push_back(Edge(to,from,0,0));
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BFS(int s,int t){
        memset(d,-1,sizeof(d));
        d[s]=0;
        queue<int> Q;
        Q.push(s);
        while(!Q.empty()){
            int x=Q.front();
            Q.pop();
            for(int i=0;i<G[x].size();++i){
                Edge &e=edges[G[x][i]];
                if(e.cap>e.flow && d[e.to]<0){
                    d[e.to]=d[x]+1;
                    Q.push(e.to);
                    if(e.to==t) return true;
                }
            }
        }
        return d[t]>=0;
    }

    int DFS(int cur,int t,int a){
        if(cur==t || a==0) return a;
        int flow=0,f;
        for(int i=0;i<G[cur].size();++i){
            Edge &e=edges[G[cur][i]];
            if(d[e.to]==d[cur]+1 && (f=DFS(e.to,t,min(a,e.cap-e.flow)))>0){
                flow+=f;
                a-=f;
                e.flow+=f;
                edges[G[cur][i]^1].flow-=f;
                if(a==0) return flow;
            }
        }
        return flow;
    }

    int Maxflow(int s,int t){
        int flow=0;
        while(BFS(s,t))
            flow+=DFS(s,t,Inf);
        return flow;
    }
};

int kase,w,h,d,f,b,cost,n;
char ch[55][55];
int dx[]={0,0,-1,1},dy[]={-1,1,0,0};
Dinic din;
int main(void){
    scanf("%d",&kase);
    while(kase--){
        cost=0;
        n=0;
        scanf("%d%d",&w,&h);
        scanf("%d%d%d",&d,&f,&b);
        for(int i=0;i<h;++i){
            scanf("%s",ch[i]);
        }
        int t=w*h;
        din.init(t+2);
        //处理外部的'.',将它们变成'#’
        for(int i=0;i<w;++i){
            if(ch[0][i]=='.'){ cost+=f;  ch[0][i]='#'; }
            if(ch[h-1][i]=='.'){ cost+=f; ch[h-1][i]='#'; }
        }
        for(int i=0;i<h;++i){
            if(ch[i][0]=='.'){ cost+=f; ch[i][0]='#'; }
            if(ch[i][w-1]=='.'){ cost+=f; ch[i][w-1]='#'; }
        }

        //计算格子(i,j)和左边，上面的格子之间是否有边存在
        for(int i=0;i<h;++i){
            int t2=i*w;
            for(int j=0;j<w;++j){
                if(i==0 || j==0 || i==h-1 || j==w-1)
                    din.AddEdges(t,t2+j,Inf);
                else if(ch[i][j]=='#') din.AddEdges(t,t2+j,d);
                else din.AddEdges(t2+j,t+1,f);
                for(int k=0;k<4;++k){
                    int nx=i+dx[k],ny=j+dy[k];
                    if(nx<0 || nx >=h || ny<0 || ny>=w) continue;
                    din.AddEdges(t2+j,nx*w+ny,b);
                }
            }
        }
        int ans=din.Maxflow(t,t+1);
        printf("%d\n",cost+ans);
    }
    return 0;
}

当前弧优化后的Dinic:

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <utility>
#include <map>
#include <string>
#include <queue>
#include <utility>
using namespace std;
const int maxn=2505,Inf=0x3f3f3f3f;

struct Edge{
    int from,to,cap,flow;
    Edge(int from,int to,int cap,int flow):from(from),to(to),cap(cap),flow(flow){}
};

struct Dinic{
    int n,m;
    vector<Edge> edges;
    vector<int> G[maxn];
    int d[maxn];
    int cur[maxn];
    void init(int n){
        this->n=n;
        for(int i=0;i<n;++i) G[i].clear();
        edges.clear();
    }

    void AddEdges(int from,int to,int cap){
        edges.push_back(Edge(from,to,cap,0));
        edges.push_back(Edge(to,from,0,0));
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BFS(int s,int t){
        memset(d,-1,sizeof(d));
        d[s]=0;
        queue<int> Q;
        Q.push(s);
        while(!Q.empty()){
            int x=Q.front();
            Q.pop();
            for(int i=0;i<G[x].size();++i){
                Edge &e=edges[G[x][i]];
                if(e.cap>e.flow && d[e.to]<0){
                    d[e.to]=d[x]+1;
                    Q.push(e.to);
                    if(e.to==t) return true;
                }
            }
        }
        return d[t]>=0;
    }

    int DFS(int x,int t,int a){
        if(x==t || a==0) return a;
        int flow=0,f;
        for(int &i=cur[x];i<G[x].size();++i){
            Edge &e=edges[G[x][i]];
            if(d[e.to]==d[x]+1 && (f=DFS(e.to,t,min(a,e.cap-e.flow)))>0){
                flow+=f;
                a-=f;
                e.flow+=f;
                edges[G[x][i]^1].flow-=f;
                if(a==0) return flow;
            }
        }
        return flow;
    }

    int Maxflow(int s,int t){
        int flow=0;
        while(BFS(s,t)) {
            memset(cur,0,sizeof(cur));
            flow += DFS(s, t, Inf);
        }
        return flow;
    }
};

int kase,w,h,d,f,b,cost,n;
char ch[55][55];
int dx[]={0,0,-1,1},dy[]={-1,1,0,0};
Dinic din;
int main(void){
    scanf("%d",&kase);
    while(kase--){
        cost=0;
        n=0;
        scanf("%d%d",&w,&h);
        scanf("%d%d%d",&d,&f,&b);
        for(int i=0;i<h;++i){
            scanf("%s",ch[i]);
        }
        int t=w*h;
        din.init(t+2);
        //处理外部的'.',将它们变成'#’
        for(int i=0;i<w;++i){
            if(ch[0][i]=='.'){ cost+=f;  ch[0][i]='#'; }
            if(ch[h-1][i]=='.'){ cost+=f; ch[h-1][i]='#'; }
        }
        for(int i=0;i<h;++i){
            if(ch[i][0]=='.'){ cost+=f; ch[i][0]='#'; }
            if(ch[i][w-1]=='.'){ cost+=f; ch[i][w-1]='#'; }
        }

        //计算格子(i,j)和左边，上面的格子之间是否有边存在
        for(int i=0;i<h;++i){
            int t2=i*w;
            for(int j=0;j<w;++j){
                if(i==0 || j==0 || i==h-1 || j==w-1)
                    din.AddEdges(t,t2+j,Inf);
                else if(ch[i][j]=='#') din.AddEdges(t,t2+j,d);
                else din.AddEdges(t2+j,t+1,f);
                for(int k=0;k<4;++k){
                    int nx=i+dx[k],ny=j+dy[k];
                    if(nx<0 || nx >=h || ny<0 || ny>=w) continue;
                    din.AddEdges(t2+j,nx*w+ny,b);
                }
            }
        }
        int ans=din.Maxflow(t,t+1);
        printf("%d\n",cost+ans);
    }
    return 0;
}
carut
关注
专栏目录
最小割模型汇总
DZYO的博客
08-22 2508
二分图点带权最小覆盖这个可以说是最小割模板了，简单来说就是选取一个点集，所有边都连接了这个点集，最小化这个点权和。首先假设只有一对点，一条边 要选出较小值，建边(s->1,v1),(1->2,INF),(2->t,INF) 显然割开最小值。 对于多个点边，求最大流（最小割）即可。
UVA 1515 - Pool construction（最小割）
Change the world by program.
08-29 177
题目链接 https://cn.vjudge.net/problem/UVA-1515 【题意】 输入一个h行w列的字符矩阵，草地用’#’表示，洞用’.’表示，可以把一个草地换成洞，费用为d，也可以把一个洞换成草地，费用为f，最后要在草地和洞之间修建围栏，单位围栏的费用为b，整个矩阵的边界必须是草地，求最小花费.（2&lt;=w,h&lt;=50,1&lt;=d,f,b&lt;=10000） ...
uva 1515 Pool construction（最大流）
总有那么一群人喜欢盯着我的博客看，估计这是他们见过最长的博客名，我必须得告诉他们博客名最长可以写多长
09-03 577
uva 1515 Pool construction题目大意：给一块n×m的地皮，上面有草地‘#’和洞‘.’ 。草地转换成洞需要d的费用，把洞填上种上草需要f的费用，在草地和洞之间加一道墙需要b的费用。现在问把这块n×m的地皮变成池子的最小费用是多少。（池子：边缘必须都是草地，每块草地与洞之间都有墙隔开）解题思路：建图方式非常巧妙。先把所有边界上的洞全部变成草地，并记录费用sum。设置超级源点，连向
Pool construction UVA - 1515 (最小割+建图)
肘子的博客
12-26 177
传送门 题意：输入一个h行w列的字符矩阵，草地用‘#’表示，洞用‘.'表示，可以把草改成洞，每格花费为d，也可以把洞填上草，每格花费为f。最后还需要在草和洞之间修围栏，每条边的花费为b。整个矩阵的四周必须是草，问最小花费是多少？ 题解：参考了传送门 附上代码： #include&lt;bits/stdc++.h&gt; using namespace std; const int ...
Uva-1515-Pool construction
z309241990的专栏
06-23 1130
这个题刚开始确实没想到是用最小割来做，建图也非常的巧妙，对于
UVA 1515 Pool construction [最小割]
C'est la vie.
08-15 538
Pool construction Time Limit: 3000MS 64bit IO Format: %lld & %llu 这道题可以用最小割来求解。 首先定义与S连通的是草，与T连通的是洞，那么需要切掉某些边使得S与T不连通，也就是要求最小割。 那么把S与原图所有草连上一条容量d的边，代表要把这个格子变成洞需要花费d的费用，同样所有洞与T连边。 然后对于
创建线程池报错解决:Exception in thread “pool-1-thread-3“ java.lang.IndexOutOfBoundsException
火锅机器猫的博客
03-31 5499
输入多个文件，按行反转文件内容。 要求使用接口、线程池
Exception in thread “HiveServer2-Handler-Pool: Thread-67“ java.lang.OutOfMemoryError: Java heap spac
wainageren的博客
03-05 2802
错误信息提示如下 Exception in thread "HiveServer2-Handler-Pool: Thread-67" java.lang.OutOfMemoryError: Java heap space at java.util.Arrays.copyOf(Arrays.java:3332) at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.ja
主线程的子线程信息pool-1-thread-1
热门推荐
zwq1457的专栏
11-03 1万+
11-02 05:19:00.989 912 931 I am_anr : [0,31740,com.android.vending,952811205,Broadcast of Intent { act=android.intent.action.PACKAGE_REMOVED dat=package:com.android.vending flg=0x4000010 cmp=com.
commons-pool2-2.3.jar
01-23
commons-pool2-2.3.jar
commons-dbcp-1.4.jar和commons-pool-1.5.6.jar
04-23
这两个JAR文件，`commons-dbcp-1.4.jar` 和 `commons-pool-1.5.6.jar`，在Java应用中起到了重要的角色，特别是对于那些需要高效管理数据库连接的大型系统。 Apache Commons DBCP是Apache Commons项目的一部分，它...
UVA 1515 Pool construction（最小割）
常胜将军的博客
06-19 159
题意：输入一个h行w列的字符矩阵，草地用“#”表示，洞用"."表示。你可以把草改成洞，每格花费为d，也可以把洞填上草，每格花费为f。最后还需要在草和洞之间修围栏，每条边花费为b。整个矩阵第一行/列和最后一行列必须是草。求最小花费。 分析：首先把边界全部变为草并累积费用。设一源点s，一汇点t，将s与所有草连边（所有非边界草容量为D，代表将其分到洞集合所花费用；所有边界草容量为INF，代表边界草不...
hdu 5076 Memory（最小割 数学建模）智商被爆出翔
solotzg
11-08 1338
hdu 5076 Memory
最小割基本模型及解决方案
Heret1c
12-19 1909
最小割概念 割：如果从图G中删除一个弧的集合c{f}，让S流不到T，那么这个集合成为图G的一个割。记做C（S,T），S,T为点集。 正向割边：对于集合c中的一条弧f{u,v}（u指向v）如果u∈S，v∈T则成为正向割边。 逆向割边：对于集合c中的一条弧f{u,v}（u指向v）如果u∈T，v∈S则成为逆向割边。 割的容量：割C{S,T}中所有正向割边的容量和称为割的容量。 最小割：容量最小的割Ci{S
最小割建模
qq_42852687的博客
03-26 921
最小割建模一，基础知识割割的性质最大流最小割定理二，理论常见技巧割的引申类型三，常见题型1，直接使用按照已知和未知区分两个集合按照定义找到（最小）割2，最大权闭合子图 一，基础知识 割 SSS 是一个点集，保证 SSS 内一定有源点 sss TTT 是一个点集，保证 TTT 内一定有源点 ttt [S,T][S,T][S,T] 定义为一个割 c(S,T)c(S,T)c(S,T) ： 一个割的容量（不考虑反向边，只考虑从S出发的） f(S,T)f(S,T)f(S,T) ： 一个割的流量（考虑到从T回来的退
最大流最小割定理与最小割的数学模型
hzk_cpp的博客
07-18 721
一.最大流最小割定理. 割：对于一张网络，我们称一个边集的子集为一个割，当且仅当去掉这个边集的子集后源点SSS无法到达汇点TTT. 最小割：边权和最小的割被称为最小割. 最大流-最小割定理：一张网络的最大流等于其最小割的边权之和. 这个东西太经典了这里就不证了. 二.最小割的可行边与必经边. 显然一张网络可能有不止一个最小割，那么我们如何确定一条边是最小割的可行边或者必经边？ 首先考虑对网络跑一遍最大流，此时我们会得到一张残余网络（算上反向边）. 首先，容易发现如果一条边没有满流，那么这条边必然不是任意
【网络流】线性规划的最小割建模方式
weixin_30273931的博客
03-30 380
前几天在师大附中听课，大概了解了一些关于网络流的建模方式，然后今天上午做了一些题目，在这里总结一下。 最小割的线性规划建模方式： 　　有一些0/1变量Xi，怎么怎么样之后会消耗某些代价或者获得某些利益，而最后的总收益可以写成如下的形式： 　　　　　　 min{ Σmax{Xi-Xj,0}*Wi } 其中Wi必须是正数。 那么假设源为1，汇为0，就将Xi连一条流量为...
《最小割模型在信息学竞赛中的应用》——学习笔记
Lynstery's blog
02-16 931
《最小割模型在信息学竞赛中的应用》学习笔记 基础 流网络的定义，容量限制，反对称性，流守恒性… 我们约定对于点集X,YX,YX,Y ,令 f(X,Y)=∑u∈X∑v∈Yf(u,v)f(X,Y)=∑u∈X∑v∈Yf(u,v)f(X,Y)=\sum_{u \in X}\sum_{v \in Y} f(u,v) ∀X,f(X,X)=0∀X,Y,f(X,Y)=−f(Y,X)∀X,Y,Z,&nb...
最小割连边模型
Freopen的博客
03-30 186
1.对于两个都有S方面的边和T方面的边的点，在他们之间连inf表示这两个点要么全割S方面的边要么都割T方面的边。 最小割的一种数学建模：$01$变量建模 连边： 对于一个$01$变量$a$,它在图中的点的编号我们也记作$a$ 边$(S,a,b)$表示$a=1$时要花费$b$的代价。 边$(a,T,b)$表示$a=0$时要花费$b$的代价。 边$(a,c,b)$表示$a=0,c=1$时要...
ForkJoinPool.commonPool-worker-12
最新发布
08-07
ForkJoinPool.commonPool-12 是 Java 中的一个内部线程池机制的一部分，它属于 Fork/Join 框架。`commonPool` 是一个全局共享的线程池，用于执行 ForkJoinTask 类的任务。`worker-12` 表示这个特定的 worker 线程，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值