HDU 3468-Treasure Hunting 网络流or二分匹配

最新推荐文章于 2020-09-13 22:01:02 发布
最新推荐文章于 2020-09-13 22:01:02 发布
阅读量176 收藏
点赞数
分类专栏： 模板 二分匹配 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41955236/article/details/81835863
版权
图论 同时被 3 个专栏收录
100 篇文章 0 订阅
订阅专栏
模板
86 篇文章 0 订阅
订阅专栏
二分匹配
5 篇文章 0 订阅
订阅专栏

Treasure Hunting

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others)
Total Submission(s): 2208    Accepted Submission(s): 604

 

Problem Description

Do you like treasure hunting? Today, with one of his friend, iSea is on a venture trip again. As most movie said, they find so many gold hiding in their trip.
Now iSea’s clever friend has already got the map of the place they are going to hunt, simplify the map, there are three ground types:

● '.' means blank ground, they can get through it
● '#' means block, they can’t get through it
● '*' means gold hiding under ground, also they can just get through it (but you won’t, right?)

What makes iSea very delighted is the friend with him is extraordinary justice, he would not take away things which doesn’t belong to him, so all the treasure belong to iSea oneself!
But his friend has a request, he will set up a number of rally points on the map, namely 'A', 'B' ... 'Z', 'a', 'b' ... 'z' (in that order, but may be less than 52), they start in 'A', each time friend reaches to the next rally point in the shortest way, they have to meet here (i.e. iSea reaches there earlier than or same as his friend), then start together, but you can choose different paths. Initially, iSea’s speed is the same with his friend, but to grab treasures, he save one time unit among each part of road, he use the only one unit to get a treasure, after being picked, the treasure’s point change into blank ground.
Under the premise of his friend’s rule, how much treasure iSea can get at most?
 

 

 

Input

There are several test cases in the input.

Each test case begin with two integers R, C (2 ≤ R, C ≤ 100), indicating the row number and the column number.
Then R strings follow, each string has C characters (must be ‘A’ – ‘Z’ or ‘a’ – ‘z’ or ‘.’ or ‘#’ or ‘*’), indicating the type in the coordinate.

The input terminates by end of file marker.

 

 

Output

For each test case, output one integer, indicating maximum gold number iSea can get, if they can’t meet at one or more rally points, just output -1.
 

 

 

Sample Input

 

2 4

A.B.

***C

2 4

A#B.

***C

 

 

Sample Output

 

1

2

 

题意：

      简化一下题意吧。n*m的地图，上面有#（不能走），.（可以走），*（宝藏）和字母。有两个人小A和小B，两人都会从地图A出发，小A会从A开始按顺序走到B,C...Z,a,b..z，一直走到最后一个单词为止，即如果只有ABC就走到C，如果只有ABD那么就不合法，每次都走最短路。小B也会按小A的速度走最短路（即同时到达下一个点），但是他可以走不同的路线，如果路线上有宝藏，他就会挖宝藏，但是从一个字母走到另一个字母的过程中他只能挖一个宝藏。

      如果过程不合法请输出-1，如果合法，请输出小B最多可以获得多少个宝藏。

 

做法：

    首先处理最短路的问题，可以因为地图不是很大只有100*100，所以可以枚举每个字母作为起点进行bfs，处理出每个字母到图上任一点的最短路径，然后再枚举每一对起点和终点（即A和B，B和C），看看他们两个到每个宝藏的路径之和是否等于他们彼此相互到达的距离，如果是，那么这个宝藏就是在最短路上的，否则就不是。

    对于在最短路上的宝藏，这里有两种做法。

    1.最大流：将超级原点和每一个字母都增加1的流量，再把每个字母出发能到的宝藏的流量也设为1，每个宝藏都与超级汇点相连接，流量设为1，因为有超级远点到字母流量只有1的限制，所以每个字母只能对应着一个宝藏进入超级汇点，这样跑出来的最大流就是我们想要的答案。

     2.二分匹配：在判断出该字母出发可以到达该宝藏之后，就给字母到该宝藏增加一条单向边，然后跑一边二分匹配即可，因为这样每个字母只能对应一个宝藏，匹配出来的肯定是最优的。

网络流代码如下：

  

#include<bits/stdc++.h>
using namespace std;
const int Ni = 2000005;
const int inf=0x3f3f3f3f;
const int MAX = 1<<26;
struct Edge{
    int u,v,c;
    int next;
}edge[3*Ni];
int n,m;
int edn;//边数
int p[Ni];//父亲
int d[Ni];
int sp,tp;//原点，汇点
char mp[105][105];
int afterdeal[105][105];
void addedge(int u,int v,int c){
    edge[edn].u=u; edge[edn].v=v; edge[edn].c=c;
    edge[edn].next=p[u]; p[u]=edn++;

    edge[edn].u=v; edge[edn].v=u; edge[edn].c=0;
    edge[edn].next=p[v]; p[v]=edn++;
}
int bfs(){
    queue <int> q;
    memset(d,-1,sizeof(d));
    d[sp]=0;
    q.push(sp);
    while(!q.empty()){
        int cur=q.front();
        q.pop();
        for(int i=p[cur];i!=-1;i=edge[i].next){
            int u=edge[i].v;
            if(d[u]==-1 && edge[i].c>0){
                d[u]=d[cur]+1;
                q.push(u);
            }
        }
    }
    return d[tp] != -1;
}
int dfs(int a,int b){
    int r=0;
    if(a==tp)return b;
    for(int i=p[a];i!=-1 && r<b;i=edge[i].next)
    {
        int u=edge[i].v;
        if(edge[i].c>0 && d[u]==d[a]+1)
        {
            int x=min(edge[i].c,b-r);
            x=dfs(u,x);
            r+=x;
            edge[i].c-=x;
            edge[i^1].c+=x;
        }
    }
    if(!r)d[a]=-2;
    return r;
}

int dinic(int sp,int tp){
    int total=0,t;
    while(bfs()){
        while(t=dfs(sp,MAX))
        total+=t;
    }
    return total;
}
int gainpo(int x,int y){
    return (x-1)*m+y;
}
int dir[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
struct node{
    int x,y,step;
    node(){}
    node(int x,int y,int step):x(x),y(y),step(step){}
    bool operator < (const node &a) const {
        return step>a.step;
    }
};
struct Rest{
    int x,y;
}rest[60];
struct Tsure{
    int x,y;
}treasure[10010];
int dis[60][10010],whe[60],mmax,vis[105][105];
void init(){
    memset(whe,0,sizeof(whe));
    edn=0;
    memset(p,-1,sizeof(p));
}
void bfss(int sx,int sy,int now){
    priority_queue<node> q;
    q.push(node(sx,sy,0));
    memset(vis,0,sizeof(vis));
    vis[sx][sy]=1;
    for(int i=0;i<10010;i++){
        dis[now][i]=inf;
    }
    while(!q.empty()){
        node a=q.top(); q.pop();
        dis[now][gainpo(a.x,a.y)]=a.step;
        for(int i=0;i<4;i++){
            int dx=a.x+dir[i][0],dy=a.y+dir[i][1];
            if(dx<=0||dy<=0||dx>n||dy>m||vis[dx][dy]||mp[dx][dy]=='#') continue;
            vis[dx][dy]=1;q.push(node(dx,dy,a.step+1));
        }
    }
}
int main(){
    while(~scanf("%d%d",&n,&m)){
        init();
        sp=0,tp=10500;
        int numtre=0;
        mmax=-1;
        for(int i=1;i<=n;i++)
            scanf("%s",mp[i]+1);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(mp[i][j]=='*'){
                    treasure[numtre].x=i,treasure[numtre++].y=j;
                    addedge(gainpo(i,j)+100,tp,1);
                }
                else if(mp[i][j]>='A'&&mp[i][j]<='Z'){
                    int th=mp[i][j]-'A'+1;
                    if(th>mmax) mmax=th;
                    whe[th]=1,rest[th].x=i,rest[th].y=j;
                }
                else if(mp[i][j]>='a'&&mp[i][j]<='z'){
                    int th=mp[i][j]-'a'+27;
                    if(th>mmax) mmax=th;
                    whe[th]=1,rest[th].x=i,rest[th].y=j;
                }
            }
        }
        int flag=0,nowid=1;
        for(int i=1;i<=mmax;i++){
            if(!whe[i]){
                flag=1;break;
            }
            bfss(rest[i].x,rest[i].y,i);
        }
        if(flag) {
            cout<<"-1"<<endl;
            continue;
        }
        for(int i=1;i<mmax;i++){
            int alldis=dis[i][gainpo(rest[i+1].x,rest[i+1].y)];
            if(alldis==inf){
                flag=1; break;
            }
            for(int j=0;j<numtre;j++){
                int dis1=dis[i][gainpo(treasure[j].x,treasure[j].y)];
                int dis2=dis[i+1][gainpo(treasure[j].x,treasure[j].y)];
                if(dis1+dis2==alldis) addedge(i,gainpo(treasure[j].x,treasure[j].y)+100,1);
            }
        }
        if(flag){
            cout<<"-1"<<endl;
            continue;
        }
        for(int i=1;i<60;i++)
            addedge(0,i,1);
        int ans=dinic(sp,tp);
        printf("%d\n",ans);
    }
    return 0;
}

 

 

二分匹配代码如下：

   

#include<bits/stdc++.h>
using namespace std;
const int Ni = 2000005;
const int inf=0x3f3f3f3f;
const int MAX = 1<<26;
struct Edge{
    int u,v;
    int next;
}edge[3*Ni];
int n,m;
int edn;//边数
int p[Ni];
char mp[105][105];
int dir[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
struct node{
    int x,y,step;
    node(){}
    node(int x,int y,int step):x(x),y(y),step(step){}
    bool operator < (const node &a) const {
        return step>a.step;
    }
};
struct Rest{
    int x,y;
}rest[60];
struct Tsure{
    int x,y;
}treasure[10010];
int dis[60][10010],whe[60],mmax,vis[105][105],duixiang[10500],viss[10500];
void addedge(int u,int v){
    edge[edn].u=u; edge[edn].v=v;
    edge[edn].next=p[u]; p[u]=edn++;
}
int gainpo(int x,int y){
    return (x-1)*m+y;
}

void init(){
    memset(whe,0,sizeof(whe));
    memset(duixiang,-1,sizeof(duixiang));
    edn=0;
    memset(p,-1,sizeof(p));
}
void bfss(int sx,int sy,int now){
    priority_queue<node> q;
    q.push(node(sx,sy,0));
    memset(vis,0,sizeof(vis));
    vis[sx][sy]=1;
    for(int i=0;i<10010;i++){
        dis[now][i]=inf;
    }
    while(!q.empty()){
        node a=q.top(); q.pop();
        dis[now][gainpo(a.x,a.y)]=a.step;
        for(int i=0;i<4;i++){
            int dx=a.x+dir[i][0],dy=a.y+dir[i][1];
            if(dx<=0||dy<=0||dx>n||dy>m||vis[dx][dy]||mp[dx][dy]=='#') continue;
            vis[dx][dy]=1;q.push(node(dx,dy,a.step+1));
        }
    }
}
int match(int x){
    for(int i=p[x];~i;i=edge[i].next){
        int v=edge[i].v;
        if(!viss[v]){
            viss[v]=1;
            if(duixiang[v]==-1||match(duixiang[v])){
                duixiang[v]=x;
                 return 1;
            }
        }
    }
    return 0;
}
int main(){
    while(~scanf("%d%d",&n,&m)){
        init();
        int numtre=0;
        mmax=-1;
        for(int i=1;i<=n;i++)
            scanf("%s",mp[i]+1);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(mp[i][j]=='*'){
                    treasure[numtre].x=i,treasure[numtre++].y=j;
                }
                else if(mp[i][j]>='A'&&mp[i][j]<='Z'){
                    int th=mp[i][j]-'A'+1;
                    if(th>mmax) mmax=th;
                    whe[th]=1,rest[th].x=i,rest[th].y=j;
                }
                else if(mp[i][j]>='a'&&mp[i][j]<='z'){
                    int th=mp[i][j]-'a'+27;
                    if(th>mmax) mmax=th;
                    whe[th]=1,rest[th].x=i,rest[th].y=j;
                }
            }
        }
        int flag=0,nowid=1;
        for(int i=1;i<=mmax;i++){
            if(!whe[i]){
                flag=1;break;
            }
            bfss(rest[i].x,rest[i].y,i);
        }
        if(flag) {
            cout<<"-1"<<endl;
            continue;
        }
        for(int i=1;i<mmax;i++){
            int alldis=dis[i][gainpo(rest[i+1].x,rest[i+1].y)];
            if(alldis==inf){
                flag=1; break;
            }
            for(int j=0;j<numtre;j++){
                int dis1=dis[i][gainpo(treasure[j].x,treasure[j].y)];
                int dis2=dis[i+1][gainpo(treasure[j].x,treasure[j].y)];
                if(dis1+dis2==alldis) addedge(i,gainpo(treasure[j].x,treasure[j].y));
            }
        }
        if(flag){
            cout<<"-1"<<endl;
            continue;
        }
        int sum=0;
        for(int i=1;i<=mmax;i++){
            memset(viss,0,sizeof(viss));
            if(match(i)) sum++;
        }
        printf("%d\n",sum);
    }
    return 0;
}

 

余西子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU二分匹配及其应用
07-10
HDU二分匹配及其应用，此PPT是刘春英老师版权所有， 特此贡献给广大编程爱好者，特别是对于ACMer
Java入门超简单程序Treasure Hunting
康雨城
10-24 512
Treasure Hunting The goal of this assignment is to write a program, TreasureHunting, that plays the game of finding a treasure that is located in the 10-by-10 grid. The player has 10 chances to gue...
CF - 817A. Treasure Hunt - 思维
终有绿洲摇曳在沙漠
06-17 1058
1.题目描述： A. Treasure Hunt time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output Captain Bill the Hummingbird a
D. Treasure Hunting （ 思维题 ， 贪心）
weixin_30765577的博客
08-05 256
传送门 题意： 在一个 n * m 的地图里，有 k 个宝藏，你的起点在 （1， 1）， 每次你能 向下向右向左移动（只要在地图里）； 　　 现在，有 q 个安全的列， 你只有在这些列上面，你才能向下走。 问你收集所有宝藏，需要走的最少步数 解： 首先，我们对每一行 维护数组 L, R，分别代表 这一行的所有宝藏中，最左的那个和最右的那个的 纵坐标 　　然后 维护两...
HDU 3468 BFS + 二分匹配
九野的博客
09-03 2330
开始建图打搓了，参考了大牛的题解打的版本比较清爽 题意：给定n，m表示下面地图大小 .表示空地 #表示墙 *表示黄金 行走的路线是A->Z->a->z 规则，必须从字母依次走最短路到下一个字母（字母必须连续走，如果走不到下一个字母或者地图上不存在下一个字母则输出-1） 每次走到下一个字母可以取走路途上的一个黄金，问最多能取走几个黄金   思路：走到最后一个字母就结束了，所以希望从
HDU-3468-Treasure Hunting(最短路转最大流)
jziwjxjd的博客
09-13 280
挺有意思的一题 不难,但是写起来处理不好会比较繁琐 我们把所有宝藏记录下来,把所有汇合点记录下来 由于每个汇合点去下一个汇合点的路上最多只能拿一个宝藏 所有可以对每个汇合点bfsbfsbfs,这样就知道那些保证在相邻汇合点的最短路上 那现在问题就转化成每个汇合点到下一个汇合点路上可以选择若干宝藏的一种 这不就是裸的二分图最大匹配了么 #include <bits/stdc++.h> using namespace std; const int inf=0x3f3f3f3f; const int
hdu-3468 Treasure Hunting（BFS+二分匹配）
Amove
07-09 222
Treasure HuntingTime Limit: 4000/2000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others)Total Submission(s): 2198    Accepted Submission(s): 598Problem DescriptionDo you like treasure hunt...
HDU 3468 Treasure Hunting(二分匹配+最短路)
Must so
07-31 920
Problem Description Do you like treasure hunting? Today, with one of his friend, iSea is on a venture trip again. As most movie said, they find so many gold hiding in their trip. Now iSea’s clever
Treasure Hunting　（hdu 3468 二分匹配+bfs最短路径）
@you！
05-01 704
题意：在一个R*C的地图内，字母表示集合点，‘*’表示宝藏，‘.’表示空地，现在沿着A->....->Z->a->....->z的方向走，途中从一个集合点到下一个集合点之间只能捡一个宝藏，问最后最多能捡多少宝藏。 思路：将集合点和宝藏分别看成两个集合，若在集合点x到y的最短路径上有‘*’，那么就在x和‘*’之间连边。bfs求出所有集合点到下一个集合点的最短路径。
HDUACM2010版13二分匹配及其应用.ppt
09-15
HDUACM2010版13二分匹配及其应用.ppt
HDU-2000-2099.rar_hdu
09-19
HDU 里面的2000~2099道题目的源码。谢谢支持
HDU-2000-2099.zip_hdu2000
09-23
杭电ACM2000-2099题的解题报告
HDU-Coder-X#Daily-question-of-Leetcode#2022-03-20-2039. 网络空闲的时刻1
07-25
从第 1 秒开始，每 一秒最 开始 时，每个数据服务器都会检查它是否收到了主服务器的回复信息（包括新发出信息的回复信息）：如果还没收到任何回复信息，那么该服务器
Treasure Hunting（最短路 最大流）
jkchen's Haven
01-26 1011
原题： http://acm.hdu.edu.cn/showproblem.php?pid=3468 题意： 解析： 先排-1的情况有： 只有ABDE 出现AABC A走不到B 做一遍最短路。对于一个宝藏点p，第i个目标点xix_ixi​，如果dis(p,xi)+dis(p,xi+1)==dis(xi,xi+1)dis(p,x_i)+dis(p,x_{i+1})==dis(x_i,x_{i+1...
竞赛图 哈密顿图
人生如戏
02-27 3378
竞赛图 竞赛图是通过在无向完整图中为每个边缘分配方向而获得的有向图（有向图）。 也就是说，它是一个完整图形的方向，等价于一个有向图，其中每对不同的顶点通过单个有向边连接，即每对顶点之间都有一条边相连的有向图称为竞赛图。 总的概括就是一个有向完全图。 与哈密顿路径的关系 任何有限数量n个顶点的竞赛图都包含一个哈密尔顿路径，即所有n个顶点上的直线路径。假设该语句适用于n，并考虑n + 1个顶点上的...
HDU 5934 Bomb tarjan强连通缩点 模板
人生如戏
08-08 483
Bomb Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 3352    Accepted Submission(s): 1046   Problem Description There are N bombs needing ex...
线性求逆元等 数论板子
人生如戏
08-14 448
#pragma GCC optimize(2) 逆元板子块 先来一个线性求逆元 #include<bits/stdc++.h> using namespace std; typedef long long ll; const int maxn=100005; const int mod=(int)1e9+7; ll inv[maxn],a[maxn],n; int m...
hdu-1569(网络流)-最大点权独立集
最新发布
05-30
这是一道经典的网络流问题，可以使用最小割模型进行建模。 首先，将所有点拆成两个点，分别表示该点被选中和不被选中两种状态。对于每个点，如果它被选中，则将它的点权加入最终结果中。接下来，对于每条边 $(u,v)$...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值