hdu 3820 Golden Eggs（最小割+SAP）

最新推荐文章于 2019-10-06 08:17:21 发布
最新推荐文章于 2019-10-06 08:17:21 发布
阅读量181 收藏
点赞数
分类专栏： 网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33997572/article/details/78233881
版权

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

这题目略难啊，一是建图，而是还要用SAP（没学过....）。

题意：一个n*m的网格，放金蛋或银蛋，有各自对应的分数，相邻的颜色相同则要扣去对应分数，求最大分数。

建图：

还是奇偶建图，但要拆成两个点。奇点v：<vs , v , mp1[i][j]>，<v , v' , INF>，<v' , vt , mp2[i][j]>。与v相邻点u，<v , u' , G>。偶点u：<vs , u , mp2[i][j]>，<u , u' , INF>，<u' , vt , mp1[i][j]>。与u相邻点v，<u , v' , S>。


分析：

还是 sum - 最小割，将mp1与mp2相加，减去不要的。思路是  颜色不相同：减去另一种颜色的分值，相同：减去扣的分值

还有注意的一点：样例1是

2 3   不是  1  2

3 4             3  4

AC代码：

#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;

const int MAXN = 100010;   //点的总数
const int MAXM = 400010;    //边的总数
const int INF = 1<<30;
int n,m,source,sink,G,S;
int mp1[55][55],mp2[55][55];

struct EDG{
    int to,next,cap,flow;
} edg[MAXM];
int eid,head[MAXN];
int gap[MAXN];  //每种距离(或可认为是高度)点的个数
int dis[MAXN];  //每个点到终点eNode 的最短距离
int cur[MAXN];  //cur[u] 表示从u点出发可流经 cur[u] 号边
int pre[MAXN];

void init(){
    eid=0;
    memset(head,-1,sizeof(head));
}
//有向边 三个参数，无向边4个参数
void AddEdge(int u,int v,int c,int rc=0){
    edg[eid].to=v; edg[eid].next=head[u];
    edg[eid].cap=c; edg[eid].flow=0; head[u]=eid++;

    edg[eid].to=u; edg[eid].next=head[v];
    edg[eid].cap=rc; edg[eid].flow=0; head[v]=eid++;
}
int maxFlow_sap(int sNode,int eNode, int n){//n是包括源点和汇点的总点个数，这个一定要注意
    memset(gap,0,sizeof(gap));
    memset(dis,0,sizeof(dis));
    memcpy(cur,head,sizeof(head));
    pre[sNode] = -1;
    gap[0]=n;
    int ans=0;  //最大流
    int u=sNode;
    while(dis[sNode]<n){   //判断从sNode点有没有流向下一个相邻的点
        if(u==eNode){   //找到一条可增流的路
            int Min=INF ;
            int inser;
            for(int i=pre[u]; i!=-1; i=pre[edg[i^1].to])    //从这条可增流的路找到最多可增的流量Min
            if(Min>edg[i].cap-edg[i].flow){
                Min=edg[i].cap-edg[i].flow;
                inser=i;
            }
            for(int i=pre[u]; i!=-1; i=pre[edg[i^1].to]){
                edg[i].flow+=Min;
                edg[i^1].flow-=Min;  //可回流的边的流量
            }
            ans+=Min;
            u=edg[inser^1].to;
            continue;
        }
        bool flag = false;  //判断能否从u点出发可往相邻点流
        int v;
        for(int i=cur[u]; i!=-1; i=edg[i].next){
            v=edg[i].to;
            if(edg[i].cap-edg[i].flow>0 && dis[u]==dis[v]+1){
                flag=true;
                cur[u]=pre[v]=i;
                break;
            }
        }
        if(flag){
            u=v;
            continue;
        }
        //如果上面没有找到一个可流的相邻点，则改变出发点u的距离（也可认为是高度）为相邻可流点的最小距离+1
        int Mind= n;
        for(int i=head[u]; i!=-1; i=edg[i].next)
        if(edg[i].cap-edg[i].flow>0 && Mind>dis[edg[i].to]){
            Mind=dis[edg[i].to];
            cur[u]=i;
        }
        gap[dis[u]]--;
        if(gap[dis[u]]==0) return ans;  //当dis[u]这种距离的点没有了，也就不可能从源点出发找到一条增广流路径
                                        //因为汇点到当前点的距离只有一种，那么从源点到汇点必然经过当前点，然而当前点又没能找到可流向的点，那么必然断流
        dis[u]=Mind+1;//如果找到一个可流的相邻点，则距离为相邻点距离+1，如果找不到，则为n+1
        gap[dis[u]]++;
        if(u!=sNode) u=edg[pre[u]^1].to;  //退一条边
    }
    return ans;
}
int drx[] = {0,1,0,-1};
int dry[] = {1,0,-1,0};
bool valid(int x,int y){
    if(x<1||x>n||y<1||y>m)
        return false;
    else
        return true;
}
int id(int x,int y){
    return ((x-1)*m+y)*2;
}
int main(){
    int t,cases=1;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d%d%d",&n,&m,&G,&S);
        init();
        int sum=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++){
                scanf("%d",&mp1[i][j]);
                sum+=mp1[i][j];
            }
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++){
                scanf("%d",&mp2[i][j]);
                sum+=mp2[i][j];
            }
        int ss=0,tt=n*m*2+1;
        for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            if((i+j)&1){
                AddEdge(ss,id(i,j)-1,mp1[i][j]);
                AddEdge(id(i,j),tt,mp2[i][j]);
                AddEdge(id(i,j)-1,id(i,j),INF);
                for(int k = 0;k<4;k++){
                    int nx = i + drx[k];
                    int ny = j + dry[k];
                    if(valid(nx,ny))
                        AddEdge(id(i,j)-1,id(nx,ny),G);
                }

            }
            else{
                AddEdge(ss,id(i,j)-1,mp2[i][j]);
                AddEdge(id(i,j),tt,mp1[i][j]);
                AddEdge(id(i,j)-1,id(i,j),INF);
                for(int k = 0;k<4;k++){
                    int nx = i + drx[k];
                    int ny = j + dry[k];
                    if(valid(nx,ny))
                        AddEdge(id(i,j)-1,id(nx,ny),S);
                }

            }
        }
        printf("Case %d: %d\n",cases++,sum-maxFlow_sap(ss,tt,2*n*m+2));
    }
    return 0;
}

超时的Dinic。。。偷笑

#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;

const int MAXN = 100010;   //点的总数
const int MAXM = 400010;    //边的总数
const int INF = 1<<30;
int n,m,source,sink,G,S;
int mp1[55][55],mp2[55][55];

struct EDG{
    int to,next,cap,flow;
} edg[MAXM];
int eid,head[MAXN];
int gap[MAXN];  //每种距离(或可认为是高度)点的个数
int dis[MAXN];  //每个点到终点eNode 的最短距离
int cur[MAXN];  //cur[u] 表示从u点出发可流经 cur[u] 号边
int pre[MAXN];

void init(){
    eid=0;
    memset(head,-1,sizeof(head));
}
//有向边 三个参数，无向边4个参数
void AddEdge(int u,int v,int c,int rc=0){
    edg[eid].to=v; edg[eid].next=head[u];
    edg[eid].cap=c; edg[eid].flow=0; head[u]=eid++;

    edg[eid].to=u; edg[eid].next=head[v];
    edg[eid].cap=rc; edg[eid].flow=0; head[v]=eid++;
}
int maxFlow_sap(int sNode,int eNode, int n){//n是包括源点和汇点的总点个数，这个一定要注意
    memset(gap,0,sizeof(gap));
    memset(dis,0,sizeof(dis));
    memcpy(cur,head,sizeof(head));
    pre[sNode] = -1;
    gap[0]=n;
    int ans=0;  //最大流
    int u=sNode;
    while(dis[sNode]<n){   //判断从sNode点有没有流向下一个相邻的点
        if(u==eNode){   //找到一条可增流的路
            int Min=INF ;
            int inser;
            for(int i=pre[u]; i!=-1; i=pre[edg[i^1].to])    //从这条可增流的路找到最多可增的流量Min
            if(Min>edg[i].cap-edg[i].flow){
                Min=edg[i].cap-edg[i].flow;
                inser=i;
            }
            for(int i=pre[u]; i!=-1; i=pre[edg[i^1].to]){
                edg[i].flow+=Min;
                edg[i^1].flow-=Min;  //可回流的边的流量
            }
            ans+=Min;
            u=edg[inser^1].to;
            continue;
        }
        bool flag = false;  //判断能否从u点出发可往相邻点流
        int v;
        for(int i=cur[u]; i!=-1; i=edg[i].next){
            v=edg[i].to;
            if(edg[i].cap-edg[i].flow>0 && dis[u]==dis[v]+1){
                flag=true;
                cur[u]=pre[v]=i;
                break;
            }
        }
        if(flag){
            u=v;
            continue;
        }
        //如果上面没有找到一个可流的相邻点，则改变出发点u的距离（也可认为是高度）为相邻可流点的最小距离+1
        int Mind= n;
        for(int i=head[u]; i!=-1; i=edg[i].next)
        if(edg[i].cap-edg[i].flow>0 && Mind>dis[edg[i].to]){
            Mind=dis[edg[i].to];
            cur[u]=i;
        }
        gap[dis[u]]--;
        if(gap[dis[u]]==0) return ans;  //当dis[u]这种距离的点没有了，也就不可能从源点出发找到一条增广流路径
                                        //因为汇点到当前点的距离只有一种，那么从源点到汇点必然经过当前点，然而当前点又没能找到可流向的点，那么必然断流
        dis[u]=Mind+1;//如果找到一个可流的相邻点，则距离为相邻点距离+1，如果找不到，则为n+1
        gap[dis[u]]++;
        if(u!=sNode) u=edg[pre[u]^1].to;  //退一条边
    }
    return ans;
}
int drx[] = {0,1,0,-1};
int dry[] = {1,0,-1,0};
bool valid(int x,int y){
    if(x<1||x>n||y<1||y>m)
        return false;
    else
        return true;
}
int id(int x,int y){
    return ((x-1)*m+y)*2;
}
int main(){
    int t,cases=1;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d%d%d",&n,&m,&G,&S);
        init();
        int sum=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++){
                scanf("%d",&mp1[i][j]);
                sum+=mp1[i][j];
            }
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++){
                scanf("%d",&mp2[i][j]);
                sum+=mp2[i][j];
            }
        int ss=0,tt=n*m*2+1;
        for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            if((i+j)&1){
                AddEdge(ss,id(i,j)-1,mp1[i][j]);
                AddEdge(id(i,j),tt,mp2[i][j]);
                AddEdge(id(i,j)-1,id(i,j),INF);
                for(int k = 0;k<4;k++){
                    int nx = i + drx[k];
                    int ny = j + dry[k];
                    if(valid(nx,ny))
                        AddEdge(id(i,j)-1,id(nx,ny),G);
                }

            }
            else{
                AddEdge(ss,id(i,j)-1,mp2[i][j]);
                AddEdge(id(i,j),tt,mp1[i][j]);
                AddEdge(id(i,j)-1,id(i,j),INF);
                for(int k = 0;k<4;k++){
                    int nx = i + drx[k];
                    int ny = j + dry[k];
                    if(valid(nx,ny))
                        AddEdge(id(i,j)-1,id(nx,ny),S);
                }

            }
        }
        printf("Case %d: %d\n",cases++,sum-maxFlow_sap(ss,tt,2*n*m+2));
    }
    return 0;
}


Werky_blog
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hdu3820 Golden Eggs（最小割）
Iguodala的博客
11-03 513
http://acm.hdu.edu.cn/showproblem.php?pid=3820 题意：有一个n*m的格子，我们要往里面放金银蛋，还给了你两种对照表。一种是所有格子放金蛋获得的点数，另一种是所有格子放银蛋获得的点数，并且如果金蛋或者银蛋同种颜色的蛋相邻时，点数会减少，金蛋减少G点，银蛋减少S点。求最后能获得的最大点数。 思路：刚开始想到了两种属性棋盘错位的方法构建出两种
HDU - 3820
青烟绕指柔的博客
03-11 159
题目链接：HDU - 3820 首先，网格图中的相邻关系，我们不难想到二分图。 我们拆点，点的含义分别为金和银。 然后对于(i+j）为奇数的点，我们让S连向金点，否则S连向银点。 那么对于相邻的点，金到金流量为G，银到银流量为S。 AC代码： #pragma GCC optimize("-Ofast","-funroll-all-loops") #include<bits/stdc++....
HDU 3820 Golden Eggs （SAP | Dinic）
anvt77205的博客
10-06 86
Golden Eggs Time Limit: 6000/3000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 304Accepted Submission(s): 172 Problem Description There is a grid with ...
HDU 3820 Golden Eggs（最大独立集）
不要錯過才珍惜
08-28 395
题目地址 题意：你有n*m个格子，你可以选择往里面放金蛋或者是银蛋或者不放，放进去就会有价值的增加，但是如果你往相邻的格子里面放相同类型的蛋，如果是金蛋则花费G的代价，如果是银蛋则花费S的代价，求最大的价值是多少? 思路：奇点(i+j)%2==1的格子的第一种类型和源点S建边，第二种类型和汇点T建边，容量为该类型在该格子对应的权值。偶点(i+j)%2==0的格子的第一种类型和汇点T建边，第二种类
HDU3820 最小割
终究我要华丽逆袭
09-02 602
完全没思绪，看了大牛博客的构图才慢慢懂了。。太想不到啊#include #include const int inf=99999999; int t,n,m,s,cnt,G,S,sum,T; int a[60][60],b[60][60],head[10000],gap[10000],d[10000]; struct EDGE { int to,f,nxt; }edge[500000]; int
hdu 1569 最小割
Samaritan_infi的博客
10-11 305
给条件加边流量为inf，最小割求解 #include #include #include using namespace std; typedef long long ll ; #define captype int const int MAXN = 40010; //点的总数 const int MAXM = 400010; //边的总数 const int INF = 1<<30
最小割推荐题目源码
07-22
最小割推荐题目源码主要涉及图论中的一个重要概念——最小割问题，以及它在解决推荐系统问题中的应用。最小割问题通常与网络流问题密切相关，是计算机科学领域中图算法的一种经典应用。在这个主题中，我们主要关注...
【HDU 3993】田忌赛马 题解+勘误
12-14
【田忌赛马】是一道源自古代中国历史的著名策略问题，被转化为计算机科学中的算法题目，出现在HDU（杭州电子科技大学在线评测系统）的3993号问题中。该题目的主要目的是通过编程来解决如何在不确定的对手策略下，...
hdu 1695 GCD（欧拉函数+容斥原理）.docx
10-29
"hdu 1695 GCD（欧拉函数+容斥原理）" 题目大意是：给定 a, b, c, d, k，找到一队 x, y，满足 g(x, y) = k，且 x ∈ [1, b], y ∈ [1, d]，问有多少对符合要求的 (x, y)。 思路是：gcd(x, y) == k 解释 x, y 都能...
HDU刷题地图+精选详细笔记
10-26
本人准备2020年保研机试时刷的题目（虽然最后机试取消了，...来自某中流985，在HDU和vjudge平台上大概刷了400道。本文件地图（excel表格）包含了绝大部分我刷过的题目，笔记中具有思路、代码、总结和心得。 大佬勿入！
HDU+2000-2099+解题报告
08-31
HDU（杭州电子科技大学）在线评测系统是许多编程竞赛爱好者和学习者经常访问的平台，它提供了大量的算法题目供用户练习和挑战。这个压缩包文件“HDU 2000-2099 解题报告”显然包含了在这个题号范围内的一些问题、...
HDU 3820 Golden Eggs (最小割)
GentleH's
05-06 876
Golden Eggs Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 285    Accepted Submission(s): 161 Problem Description There is a grid with N
hdu 3820 Golden Eggs【最大流Dinic-------最小割】好题
mengxiang000000
08-20 852
Golden Eggs Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 559    Accepted Submission(s): 326 Problem Description There is a grid with
HDU 3820 Golden Eggs( 最小割 奇特建图)经典
青山绿水之辈 专栏
08-14 913
Golden Eggs Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 501    Accepted Submission(s): 281 Problem Description There is a grid
HDU-3820-Golden Eggs(最小割 好题)
qq_42576687的博客
02-17 174
题目 问题描述 有一个有N行M列的网格。在每个细胞里，你可以选择放入一个金蛋或银蛋，或者让它空着。如果你把一个鸡蛋放进细胞，你会得到一些点这取决于鸡蛋的颜色。但是对于每一对相邻的颜色相同的鸡蛋，如果是金色的就会失去G点，否则就会失去S点。当且仅当两个鸡蛋共享一条边时，两个鸡蛋是相邻的。试着把你的分数写得越高越好。 输入 第一行包含一个整数T，表示测试用例的数量。 在每个测试用例的第一行中有四个整数...
1111111111111111111111
08-13
1111111111111111
javascript笔试题参考整理(答案)(可编辑修改word版).docx
08-13
javascript笔试题参考整理(答案)(可编辑修改word版)
财务收支表-公式计算查询.xlsx
08-13
工资表，财务报表，对账表，付款申请，财务报告，费用支出表，财务收支 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
集团信息化顶层规划 .pptx
最新发布
08-13
集团信息化顶层规划 .pptx
HDU2222+WA
03-08
HDU2222+WA 是指杭电OJ（杭州电子科技大学在线评测系统）上的一道题目，题目编号为2222，题目名称为"WA"。这道题目是一个字符串匹配的问题，要求判断一个字符串中是否包含另一个字符串中的所有字符（不考虑顺序）。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值