hdu 4859 海岸线（最小割）

最新推荐文章于 2019-03-05 17:24:48 发布

原创最新推荐文章于 2019-03-05 17:24:48 发布 · 236 阅读

0 ·

CC 4.0 BY-SA版权

网络流专栏收录该内容

15 篇文章

订阅专栏

本文介绍了一种基于最小割算法解决特定问题的方法，并详细展示了如何通过编程实现该算法。通过对给定问题进行建模，利用Dinic算法计算最小割，从而求解问题。文章还提供了完整的代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：http://acm.split.hdu.edu.cn/showproblem.php?pid=4859

建模：一种新的建图思路

周围加了一圈D，令D为奇，" . "为偶，若D确实为奇，与ss连inf，若为偶，与tt 连 inf。“.”同理。

然后与周围的点连 1 。

尽量保持不变的代码习惯，最小割就从（1,1）开始建。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<iostream>
#define mem(a,x) memset(a,x,sizeof(a))
using namespace std;
const int inf =  0x3f3f3f3f;
const int maxn = 50 + 5;
const int maxs = maxn*maxn + 5;
int n,m;
char mp[maxn][maxn];

struct Edge{
    int from,to,cap,flow;
};

struct Dicnic{
    int n,m,s,t;
    int d[maxs],cur[maxs],vis[maxs];
    vector<int>G[maxs];
    vector<Edge>edges;
    void AddEdge(int from,int to,int cap){
        Edge e1 = {from,to,cap,0};
        Edge e2 = {to,from,0,0};
        edges.push_back(e1);
        edges.push_back(e2);
        int m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
    void init(int n){
        this -> n = n;
        for(int i = 0;i<=n;i++){
            G[i].clear();
        }
        edges.clear();
    }
    bool BFS(){     //就是用BFS分了个层而已，一看代码便知
        mem(vis,0);
        queue<int>Q;
        Q.push(s);
        vis[s] = 1;
        d[s] = 0;
        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(!vis[e.to]&&e.cap>e.flow){
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x ,int a){  //就是顺着层次dfs而已
        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,min(a,e.cap-e.flow)))>0){  //a是路径上的最小残存容量
                e.flow += f;
                edges[G[x][i]^1].flow -= f;  //反向边
                flow += f;
                a -= f;
                if(a==0) break;   //a等于0及时退出，再从s那找一遍，因为从哪断的不知道
            }
        }
        return flow;
    }
    int MaxFlow(int s,int t){
        this -> s = s;      this ->t  = t;
        int flow = 0;
        while(BFS()){
            mem(cur,0);
            flow += DFS(s,inf);
        }
        return flow;
    }
}g;
int drx[] = {0,1,0,-1};
int dry[] = {1,0,-1,0};
bool valid(int x,int y){
    if(x<1||x>n+2||y<1||y>m+2)
        return false;
    else
        return true;
}
int id(int x,int y){
    return (x-1)*(m+2)+y;
}
int main(){
    int t,cases=1;
    scanf("%d",&t);
    while(t--){
        memset(mp,0,sizeof(mp));
        scanf("%d%d",&n,&m);
        g.init((n+2)*(m+2)+2);
        int ss=0,tt=(n+3)*(m+3)+1;
        for(int i=2;i<=n+1;i++)
            scanf("%s",mp[i]+2);  //空两个输入（从mp[2][2]开始）
        for(int i=1;i<=n+2;i++)
            for(int j=1;j<=m+2;j++)
                if(mp[i][j]==0)
                    mp[i][j]='D';
        for(int i=1;i<=n+2;i++)
            for(int j=1;j<=m+2;j++){
                if(mp[i][j]=='D'&&(i+j)%2==1||mp[i][j]=='.'&&(i+j)%2==0)  //D放在奇数点里，放对了
                    g.AddEdge(ss,id(i,j),inf);
                if(mp[i][j]=='D'&&(i+j)%2==0||mp[i][j]=='.'&&(i+j)%2==1)
                    g.AddEdge(id(i,j),tt,inf);
                for(int k = 0;k < 4;k++){
                    int nx = i + drx[k];
                    int ny = j + dry[k];
                    if(valid(nx,ny))
                        g.AddEdge(id(i,j),id(nx,ny),1);
                }
            }
        printf("Case %d: %d\n",cases++,(n+2)*(m+1)+(n+1)*(m+2)-g.MaxFlow(ss,tt));
    }
    return 0;
}