藏宝图

最新推荐文章于 2022-11-12 15:31:36 发布
最新推荐文章于 2022-11-12 15:31:36 发布
阅读量500 收藏
点赞数 1
分类专栏： 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011747888/article/details/79728790
版权

蒜头君得到一张藏宝图。藏宝图是一个 10 \times 1010×10的方格地图，图上一共有 1010 个宝藏。有些方格地形太凶险，不能进入。

整个图只有一个地方可以出入，即是入口也是出口。蒜头君是一个贪心的人，他规划要获得所有宝藏以后才从出口离开。

藏宝图上从一个方格到相邻的上下左右的方格需要 11 天的时间，蒜头君从入口出发，找到所有宝藏以后，回到出口，最少需要多少天。


这道题的思路是，把每个宝藏的坐标标出来，然后将宝藏进行全排列，用广搜找每个宝藏之间的最短距离加上两个路口的距离，然后求出一个距离，只需要找出来所有距离的最小距离就为这道题的最优解

但是，我写了好长时间，到现在都没有跑出来正确答案，有哪位大佬帮我找找bug也是很不错的！（下面第二个是正确答案）

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <windows.h>

using namespace std;

bool book[10][10];
int minn = 99999;
int bz[10][2] = {0,7,1,6,2,4,3,1,3,8,4,4,6,8,7,6,8,1,9,6};//每个宝藏的坐标
int Map[10][10]={//整个地图 2表示不能走 1表示宝藏
{0,0,0,0,0,0,0,1,0,0},
{0,0,0,2,0,0,1,0,0,0},
{0,2,0,0,1,0,0,2,0,0},
{0,1,0,0,0,2,0,0,1,0},
{0,2,0,0,1,0,2,0,0,0},
{0,0,2,0,0,0,0,2,0,0},
{0,0,0,0,0,2,0,0,1,0},
{0,2,0,2,0,0,1,0,0,0},
{0,1,0,0,0,0,2,2,0,0},
{0,0,2,0,0,2,1,0,0,0}
};
struct node
{
    int x,y,step;
}Now,Next;
int dir[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};

int bfs(int sx,int sy,int ex,int ey)//用来寻找两个宝藏之间的最短距离
{
    memset(book,0,sizeof(book));
    queue<node> q;
    Now.x = sx;
    Now.y = sy;
    book[sx][sy] = true;
    Now.step = 0;
    q.push(Now);
    while(!q.empty())
    {
        Now = q.front();
        q.pop();
        if(Now.x == ex && Now.y == ey)
        {
            return Now.step;
        }
        for(int i = 0; i < 4; i++)
        {
            Next.x = dir[i][0] + Now.x;
            Next.y = dir[i][1] + Now.y;
            Next.step = Now.step+1;
            if(Next.x >= 0 && Next.y >=0 && Next.x <= 9 && Next.y <= 9 && Map[Next.x][Next.y] != 2 && book[Next.x][Next.y] == false)
            {
                book[Next.x][Next.y] = true;
                q.push(Next);
            }
        }
    }
    return -1;
}
int res[10];
bool bookres[10];
void dfs(int step)//用来枚举宝藏的寻找顺序
{
    if(step == 10)
    {
        int sum = 0;
        for(int i = 0; i < 10; i++)
        {
            if(i == 0)
            {
                sum+=bfs(0,0,bz[res[i]][0],bz[res[i]][1]);
            }else if(i == 9)
            {
                sum+=bfs(0,0,bz[res[i]][0],bz[res[i]][1]);
            }
            else
            {
                sum+=bfs(bz[res[i]][0],bz[res[i]][1],bz[res[i+1]][0],bz[res[i+1]][1]);
            }
        }
        cout << sum ;
        cout << endl;
        Sleep(100);

        minn = min(sum,minn);
        //cout << minn << endl;

        return ;
    }
    for(int i = 0; i <= 9; i++)
    {
        if(bookres[i] == false)
        {
            bookres[i] = true;
            res[step] = i;
            dfs(step+1);
            bookres[i] = false;
        }
    }
    return ;
}

int main()
{
    memset(bookres,0,sizeof(bookres));
    dfs(0);
    cout << minn << endl;
    //cout << bfs(0,0,3,3) << endl;
    //记住清空bookres标记数组
    return 0;
}

在我不屑的努力下，终于在电脑跑5分钟的情况下，把答案跑了出来，真是不容易啊

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <windows.h>

using namespace std;

bool book[10][10];

int bz[10][2] = {0,7,1,6,2,4,3,1,3,8,4,4,6,8,7,6,8,1,9,6};//每个宝藏的坐标
int Map[10][10]= //整个地图 2表示不能走 1表示宝藏
{
    {0,0,0,0,0,0,0,1,0,0},
    {0,0,0,2,0,0,1,0,0,0},
    {0,2,0,0,1,0,0,2,0,0},
    {0,1,0,0,0,2,0,0,1,0},
    {0,2,0,0,1,0,2,0,0,0},
    {0,0,2,0,0,0,0,2,0,0},
    {0,0,0,0,0,2,0,0,1,0},
    {0,2,0,2,0,0,1,0,0,0},
    {0,1,0,0,0,0,2,2,0,0},
    {0,0,2,0,0,2,1,0,0,0}
};
struct node
{
    int x,y,step;
} Now,Next;

int dir[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};

int bfs(int sx,int sy, int ex, int ey)
{
    memset(book,0,sizeof(book));
    Now.x = sx;
    Now.y = sy;
    Now.step = 0;
    queue<node> q;
    q.push(Now);
    book[sx][sy] = true;
    while(!q.empty())
    {
        Now = q.front();
        q.pop();
        if(Now.x == ex && Now.y == ey)
        {
            return Now.step;
        }
        for(int i = 0; i < 4; i++)
        {
            Next.x = Now.x + dir[i][0];
            Next.y = Now.y + dir[i][1];
            Next.step = Now.step + 1;
            if(Next.x >= 0 && Next.x <= 9 && Next.y >= 0 && Next.y <= 9 && Map[Next.x][Next.y] != 2 && book[Next.x][Next.y] == false)
            {
                book[Next.x][Next.y] = true;
                q.push(Next);
            }
        }
    }
    return -1;
}

int main()
{
    int minn = 999999;
    int num[10] = {0,1,2,3,4,5,6,7,8,9};
    do
    {
        int sum = 0;
        sum+=bfs(0,0,bz[num[0]][0],bz[num[0]][1]);
        for(int i = 0; i < 9; i++)
        {

            sum+=bfs(bz[num[i]][0],bz[num[i]][1],bz[num[i+1]][0],bz[num[i+1]][1]);
            //cout << sum << " ";
        }

        //cout << sum << " ";
        sum+=bfs(bz[num[9]][0],bz[num[9]][1],0,0);
        //cout << sum << " "<< endl;
        minn = min(minn,sum);
        //Sleep(300);
    }
    while(next_permutation(num,num+10));
    cout << minn << endl;
    return 0;
}

最后一次代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <windows.h>

using namespace std;

bool book[10][10];

int bz[11][2] = {0,7,1,6,2,4,3,1,3,8,4,4,6,8,7,6,8,1,9,6,0,0};//每个宝藏的坐标
int Map[10][10]= //整个地图 2表示不能走 1表示宝藏
{
    {0,0,0,0,0,0,0,1,0,0},
    {0,0,0,2,0,0,1,0,0,0},
    {0,2,0,0,1,0,0,2,0,0},
    {0,1,0,0,0,2,0,0,1,0},
    {0,2,0,0,1,0,2,0,0,0},
    {0,0,2,0,0,0,0,2,0,0},
    {0,0,0,0,0,2,0,0,1,0},
    {0,2,0,2,0,0,1,0,0,0},
    {0,1,0,0,0,0,2,2,0,0},
    {0,0,2,0,0,2,1,0,0,0}
};
struct node
{
    int x,y,step;
} Now,Next;

int dir[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};

int bfs(int sx,int sy, int ex, int ey)
{
    memset(book,0,sizeof(book));
    Now.x = sx;
    Now.y = sy;
    Now.step = 0;
    queue<node> q;
    q.push(Now);
    book[sx][sy] = true;
    while(!q.empty())
    {
        Now = q.front();
        q.pop();
        if(Now.x == ex && Now.y == ey)
        {
            return Now.step;
        }
        for(int i = 0; i < 4; i++)
        {
            Next.x = Now.x + dir[i][0];
            Next.y = Now.y + dir[i][1];
            Next.step = Now.step + 1;
            if(Next.x >= 0 && Next.x <= 9 && Next.y >= 0 && Next.y <= 9 && Map[Next.x][Next.y] != 2 && book[Next.x][Next.y] == false)
            {
                book[Next.x][Next.y] = true;
                q.push(Next);
            }
        }
    }
    return -1;
}

int main()
{
    int minn = 999999;
    int ans[11][11];
    for(int i = 0; i < 11; i++)
    {
        for(int j = 0; j < 11; j++)
        {
            ans[i][j] = bfs(bz[i][0],bz[i][1],bz[j][0],bz[j][1]);
        }
    }

    int num[10] = {0,1,2,3,4,5,6,7,8,9};
    do
    {
        int sum = 0;
        sum += ans[10][num[0]];
        for(int i = 0; i < 9; i++)
        {
            sum += ans[num[i]][num[i+1]];
        }
        sum += ans[num[9]][10];

        minn = min(minn,sum);

    }
    while(next_permutation(num,num+10));
    cout << minn << endl;
    return 0;
}



海上飞棚
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
GEE引擎藏宝图脚本
10-10
《GEE引擎藏宝图脚本详解：开启传奇商业化的技术之旅》 在网络游戏领域，GEE引擎（Game Engine Everything）是一款广泛应用于开发MMORPG（大型多人在线角色扮演游戏）的强力工具。它以其丰富的功能和易用性，为游戏...
P3959 宝藏
weixin_43891419的博客
08-10 143
题目描述 参与考古挖掘的小明得到了一份藏宝图，藏宝图上标出了 nn 个深埋在地下的宝藏屋， 也给出了这 nn 个宝藏屋之间可供开发的 mm 条道路和它们的长度。 小明决心亲自前往挖掘所有宝藏屋中的宝藏。但是，每个宝藏屋距离地面都很远， 也就是说，从地面打通一条到某个宝藏屋的道路是很困难的，而开发宝藏屋之间的道路 则相对容易很多。 小明的决心感动了考古挖掘的赞助商，赞助商决定免费赞助他打通一条从地...
网易2017内推-藏宝图
a1223031949的专栏
09-07 455
牛牛拿到了一个藏宝图，顺着藏宝图的指示，牛牛发现了一个藏宝盒，藏宝盒上有一个机关，机关每次会显示两个字符串 s 和 t，根据古老的传说，牛牛需要每次都回答 t 是否是 s 的子序列。注意，子序列不要求在原字符串中是连续的，例如串 abc，它的子序列就有 {空串, a, b, c, ab, ac, bc, abc} 8 种。  输入描述: 每个输入包含一个测试用例。每个测试用例包含两行长
[C++]牛客 WY12 藏宝图
cpb____的博客
08-13 244
描述 牛牛拿到了一个藏宝图，顺着藏宝图的指示，牛牛发现了一个藏宝盒，藏宝盒上有一个机关，机关每次会显示两个字符串 s 和 t，根据古老的传说，牛牛需要每次都回答 t 是否是 s 的子序列。注意，子序列不要求在原字符串中是连续的，例如串 abc，它的子序列就有 {空串, a, b, c, ab, ac, bc, abc} 8 种。 输入描述： 每个输入包含一个测试用例。每个测试用例包含两行长度不超过 10 的不包含空格的可见 ASCII 字符串。 输出描述： 输出一行 “Yes” 或者 “No” 表示结果。
CSP 寻宝！大冒险！ C++
weixin_50953388的博客
11-12 2250
思路：遍历绿化图的每个树，先判断藏宝图里树的数量和当前树的右上边长为s的正方形的树的数量是否一致，如果一致，再循环遍历判断是否相等。
蓝桥杯 模拟赛 F藏宝图
小女不才
03-25 379
蒜头君得到一张藏宝图。藏宝图是一个 10 \times 1010×10 的方格地图，图上一共有 1010 个宝藏。有些方格地形太凶险，不能进入。整个图只有一个地方可以出入，即是入口也是出口。蒜头君是一个贪心的人，他规划要获得所有宝藏以后才从出口离开。藏宝图上从一个方格到相邻的上下左右的方格需要 11 天的时间，蒜头君从入口出发，找到所有宝藏以后，回到出口，最少需要多少天。48...
软件测试的两张藏宝图和三个层次
03-03
软件测试藏宝图，和我的软件测试全景图（如：基于过程的软件测试全景图）差异挺大，内容要丰富得多，覆盖了所有的知识点。而我的全景图，忽略细节和一般知识的具体内容，强调内涵和测试各环节的内在关系，逻辑清晰、...
探索阿里数据藏宝图——数据地图管理实践.pdf
09-18
阿里数据藏宝图是阿里巴巴内部的数据管理平台，它旨在解决大数据环境下的数据发现、管理和使用问题。这个系统通过数据地图提供了全面的数据管理解决方案，涵盖了元数据管理、数据血缘、数据质量、数据安全等多个关键...
测试藏宝图
07-16
1、本资料侧重产品开发周期中的测试管理。 2、说明了测试在产品开发及质量控制中的重要性，并提供了科学的工程管理工具及指导方法。
通达信股市藏宝图主图指标.doc
08-11
通达信股市藏宝图主图指标.doc
2018 蓝桥杯省赛 B 组模拟赛（五） F. 结果填空：藏宝图
JUST CODE IT
03-26 944
蒜头君得到一张藏宝图。藏宝图是一个 10 \times 1010×10 的方格地图，图上一共有 1010 个宝藏。有些方格地形太凶险，不能进入。整个图只有一个地方可以出入，即是入口也是出口。蒜头君是一个贪心的人，他规划要获得所有宝藏以后才从出口离开。藏宝图上从一个方格到相邻的上下左右的方格需要 11 天的时间，蒜头君从入口出发，找到所有宝藏以后，回到出口，最少需要多少天。跑了1分钟左右。才出来48...
2018 蓝桥杯省赛 B 组模拟赛（五） F. 结果填空：藏宝图
Become hunger become strong
03-27 424
蒜头君得到一张藏宝图。藏宝图是一个 10 \times 1010×10 的方格地图，图上一共有 1010 个宝藏。有些方格地形太凶险，不能进入。 整个图只有一个地方可以出入，即是入口也是出口。蒜头君是一个贪心的人，他规划要获得所有宝藏以后才从出口离开。 藏宝图上从一个方格到相邻的上下左右的方格需要 11 天的时间，蒜头君从入口出发，找到所有宝藏以后，回到出口，最少需要多少天
藏宝图（蓝桥杯模拟5）
java后端程序猿日常总结
03-28 295
蒜头君得到一张藏宝图。藏宝图是一个 10 \times 1010×10 的方格地图，图上一共有 1010 个宝藏。有些方格地形太凶险，不能进入。整个图只有一个地方可以出入，即是入口也是出口。蒜头君是一个贪心的人，他规划要获得所有宝藏以后才从出口离开。藏宝图上从一个方格到相邻的上下左右的方格需要 11 天的时间，蒜头君从入口出发，找到所有宝藏以后，回到出口，最少需要多少天。解析：        思路...
计蒜客 藏宝图 （bfs + 状压）
Marcus-Bao的个人主页
03-30 700
传送门思路：典型的bfs + 状压啊，一个入口出口，还要拿到地图中多个东西，而且同一个点重复走的话不好标记，这时候就标记状态啊/。。md，退役垃圾狗。。。答案 ：48    PS：    这里走回出口没必要在跑一遍bfs，只需要走到出口时判断一下是否所有箱子都拿到了即可。#include &lt;bits/stdc++.h&gt; using namespace std; int a[15][1...
结果填空：藏宝图
海绵的博客
03-31 546
蒜头君得到一张藏宝图。藏宝图是一个 10×1010 \times 1010×10 的方格地图，图上一共有 101010 个宝藏。有些方格地形太凶险，不能进入。整个图只有一个地方可以出入，即是入口也是出口。蒜头君是一个贪心的人，他规划要获得所有宝藏以后才从出口离开。藏宝图上从一个方格到相邻的上下左右的方格需要 111 天的时间，蒜头君从入口出发，找到所...
2018年计蒜客蓝桥杯模拟赛（2018.3.25）题解（未完待续）
cr496352127的博客
03-25 5943
（题解参考：2018年蓝桥杯模拟赛第五场题解  by islands）一、题目列表1. (3')矩阵求和        给你一个n×n的矩阵，里面填充1到n×n。例如当n等于3的时候，填充的矩阵如下。        1 2 3        4 5 6        7 8 9        现在我们把矩阵中的每条边的中点连起来，这样形成了一个新的矩形，请你计算一下这个新的矩形的覆盖的数字的和。比...
计蒜客-藏宝图（bfs+状压）
codeswarrior的博客
03-28 594
藏宝图 蒜头君得到一张藏宝图。藏宝图是一个 10×1010 \times 1010×10 的方格地图，图上一共有 101010 个宝藏。有些方格地形太凶险，不能进入。整个图只有一个地方可以出入，即是入口也是出口。蒜头君是一个贪心的人，他规划要获得所有宝藏以后才从出口离开。藏宝图上从一个方格到相邻的上下左右的方格需要 111 天的时间，蒜头君从入口出发，...
巡迹避障小车识别藏宝图走迷宫
最新发布
03-31
巡迹避障小车识别藏宝图走迷宫是一项基于机器视觉技术和自主导航技术的智能玩具设计。该小车能够通过摄像头识别藏在迷宫中的宝藏图案，并按照指定路线行驶，同时避开障碍物和边缘。 具体实现方法如下： 1. 摄像头识别宝藏图案 小车上安装有摄像头，可以实时拍摄迷宫内部的场景。通过图像处理技术，识别出藏在迷宫中的宝藏图案，确定它们的位置和方向。 2. 制定路线 根据宝藏图案的位置和方向，制定小车行驶的路线。路线应尽可能短且避开障碍物和边缘。 3. 自主导航 小车内置导航系统，可以根据制定的路线自主导航。在行驶过程中，小车能够自主避开障碍物和边缘，保证安全。 4. 宝藏获取 当小车到达宝藏的位置时，宝藏会被自动捕捉。小车会返回起点或下一个宝藏的位置，继续执行下一步任务。 总之，巡迹避障小车识别藏宝图走迷宫是一项富有创意和趣味性的智能玩具设计，可以激发孩子们的兴趣和想象力，同时也有益于培养他们的科技能力和创新思维。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值