hiho 小Hi小Ho的惊天大作战：扫雷·一 扫雷·三

最新推荐文章于 2023-08-01 21:01:16 发布
最新推荐文章于 2023-08-01 21:01:16 发布
阅读量1.7k 收藏
点赞数 1
分类专栏： 游戏相关 算法 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AXuan_K/article/details/46474509
版权

题目链接：

扫雷1

扫雷3


扫雷2并不科学（见扫雷3里的第一个提示,）然后就没写了- -





思路：


扫雷一：

只有一行

枚举第一个格子为有雷 或者 没有雷

然后再往下搜索 得到多个可行解

所有可行解的某个位置都为雷的一定为雷

所有可行解的某个位置都不为为雷的一定为不为雷


扫雷三：思路1：未知的位置只有不超过10个，直接爆力枚举所有未知的位置

得到多个可行解

所有可行解的某个位置都为雷的一定为雷

所有可行解的某个位置都不为为雷的一定为不为雷


思路2：根据条件1：.如果某一个被探明的格子里所标的数字为0，那么它相邻的8个格子里的未探明格子被认作是一定不是地雷的格子。

和条件2：如果某一个被探明的格子里所标的数字为K，且它相邻的8个格子里正好有K个没有探明的格子的话，则这K个没有探明的格子被认作是一定是地雷的格子。

反复处理 可以得出全部完整的地图（输出答案）

或   一副部分完整的地图

然后再  搜索枚举所有未知的位置为有雷或者没有雷

得到多个可行解

所有可行解的某个位置都为雷的一定为雷

所有可行解的某个位置都不为为雷的一定为不为雷






扫雷1代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#define maxn 100050
using namespace std;
int ans[105][maxn];
int mine[maxn];
int ans1[maxn],ans2[maxn];
int d[maxn];
int n;
int s;
void dfs(int loc)
{
    if(loc==n+1)
    {
        if(mine[loc-1]==d[loc-2]+d[loc-1])
        {
            s++;
            for(int i=1; i<=n; i++)
                ans[s][i]=d[i];
        }
        return;
    }
    if(mine[loc-1]==d[loc-2]+d[loc-1])
    {
        d[loc]=0;
        dfs(loc+1);
    }
    else if(mine[loc-1]==d[loc-2]+d[loc-1]+1)
    {
        d[loc]=1;
        dfs(loc+1);
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        s=0;
        scanf("%d",&n);
        for(int i=1; i<=n; i++)
            scanf("%d",&mine[i]);
        d[0]=d[1]=0;
        dfs(2);
        d[0]=0;
        d[1]=1;
        dfs(2);
        int s1=0,s2=0;
        if(s==1)
        {
            for(int j=1;j<=n;j++)
            {
                if(ans[1][j]==0)
                    ans1[s1++]=j;
                else
                    ans2[s2++]=j;
            }
        }
        else
        {
            for(int j=1;j<=n;j++)
            {
                if(ans[1][j]==0&&ans[2][j]==0)
                    ans1[s1++]=j;
                else if(ans[1][j]==1&&ans[2][j]==1)
                    ans2[s2++]=j;
            }
        }
        printf("%d",s2);
        for(int i=0;i<s2;i++)
            printf(" %d",ans2[i]);
        cout<<endl;
        printf("%d",s1);
        for(int i=0;i<s1;i++)
            printf(" %d",ans1[i]);
        cout<<endl;
    }
    return 0;
}



扫雷3代码1：

#include<cstdio>
//-2no -3yes
int s[12][12];
int a[10][2];
int f[10];
int n,m,le;
int remain[12][12];

bool check(int k)
{
	int i,j,sum;
	int x=a[k][0];
	int y=a[k][1];
	for(i=0;i<9;i++)
		if(remain[x+i/3-1][y+i%3-1]==0)
			return false;
	return true;
}

void work(int k)
{
	int i,j;
	int x=a[k][0];
	int y=a[k][1];
	if(k<le)
	{
		if(check(k))
		{
			s[x][y]=-3;
			for(i=0;i<9;i++)
				if(remain[x+i/3-1][y+i%3-1]>0)
					remain[x+i/3-1][y+i%3-1]--;
			work(k+1);
			for(i=0;i<9;i++)
				if(remain[x+i/3-1][y+i%3-1]>=0)
					remain[x+i/3-1][y+i%3-1]++;
		}
		s[x][y]=-2;
		work(k+1);
	}
	else 
	{
		for(i=0;i<le;i++)
			for(j=0;j<9;j++)
				if(remain[a[i][0]+j/3-1][a[i][1]+j%3-1]>0)
					return;
		for(i=0;i<le;i++)
			if(f[i]==0)
				f[i]=s[a[i][0]][a[i][1]];
			else if(f[i]!=s[a[i][0]][a[i][1]])
				f[i]=-1;
	}
}

int main(){
	int i,j,t,ans1,ans2;
	scanf("%d",&t);
	while(t--){
		le=0;
		scanf("%d%d",&n,&m);
		for(i=1;i<=n;i++)
			for(j=1;j<=m;j++)
			{
				scanf("%d",&s[i][j]);
				if(s[i][j]==-1)
				{
					a[le][0]=i;
					a[le][1]=j;
					le++;
				}
			}
		for(i=0;i<=n+1;i++){
			s[i][0]=-2;
			s[i][m+1]=-2;
		}
		for(j=0;j<=n+1;j++){
			s[0][j]=-2;
			s[n+1][j]=-2;
		}
		for(i=0;i<le;i++)
			f[i]=0;
		for(i=0;i<=n+1;i++)
			for(j=0;j<=m+1;j++)
				remain[i][j]=s[i][j];
		work(0);
		ans1=0;ans2=0;
		for(i=0;i<le;i++)
			if(f[i]==-3)
				ans1++;
			else if(f[i]==-2)
				ans2++;
		printf("%d %d\n",ans1,ans2);
	}
	return 0;
}

扫雷3代码2： 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define maxn 210
using namespace std;
struct node
{
    int x,y,d;
};
queue<node>q;
int map[maxn][maxn];
int remain[maxn][maxn];
int n_know[maxn][maxn];
int possible[maxn][2],possible_num;
int dir[8][2]= {1,0,-1,0,0,1,0,-1, 1,1,1,-1,-1,1,-1,-1};
int n,m;
int ans1,ans2;
int no_know;

int f[maxn];

void update(int x,int y,int d)       //更新remain 如果满足条件一二则继续处理
{
    int tx,ty;
    for(int i=0; i<8; i++)
    {
        tx=x+dir[i][0];
        ty=y+dir[i][1];
        if(x<1||y<1||x>n||y>m)
            continue;
        if(map[tx][ty]>=1&&map[tx][ty]<=8&&d==0)
        {
            n_know[tx][ty]--;
            if(n_know[tx][ty]==remain[tx][ty])
                q.push( {tx,ty,map[tx][ty]});
        }
        if(map[tx][ty]>=1&&map[tx][ty]<=8&&d==1)
        {
            remain[tx][ty]--;
            n_know[tx][ty]--;
            if(remain[tx][ty]==0)
                q.push( {tx,ty,0});
        }
    }
}


int judge(int x,int y,int d)   //d=-1:统计n_know  0:条件1  1~8：条件2
{
    int tx,ty,s=0;
    for(int i=0; i<8; i++)
    {
        tx=x+dir[i][0];
        ty=y+dir[i][1];
        if(x<1||y<1||x>n||y>m)
            continue;
        if(map[tx][ty]==-1&&d==-1)
            s++;

        if(map[tx][ty]==-1&&d==0)
        {
            map[tx][ty]=10;
            ans1++;
            no_know--;
            update(tx,ty,0);
        }

        if(map[tx][ty]==-1&&d>=1&&d<=8)
        {
            map[tx][ty]=-2;
            ans2++;
            no_know--;
            update(tx,ty,1);
        }
    }
    if(d==-1)
        return s;

}

bool check(int k)
{
    int x=possible[k][0];
    int y=possible[k][1];
    for(int i=0; i<9; i++)
        if(remain[x+i/3-1][y+i%3-1]==0)
            return false;
    return true;
}

void dfs(int loc)
{
    int x=possible[loc][0];
    int y=possible[loc][1];
    if(loc<possible_num)
    {
        if(check(loc))
        {
            map[x][y]=-2;
            for(int i=0; i<9; i++)
                if(remain[x+i/3-1][y+i%3-1]>0)
                    remain[x+i/3-1][y+i%3-1]--;
            dfs(loc+1);
            for(int i=0; i<9; i++)
                if(remain[x+i/3-1][y+i%3-1]>=0)
                    remain[x+i/3-1][y+i%3-1]++;
        }
        map[x][y]=10;
        dfs(loc+1);
    }
    else
    {
        for(int i=0; i<possible_num; i++)
            for(int j=0; j<9; j++)
                if(remain[possible[i][0]+j/3-1][possible[i][1]+j%3-1]>0)
                    return;
        for(int i=0; i<possible_num; i++)
            if(f[i]==0)
                f[i]=map[possible[i][0]][possible[i][1]];
            else if(f[i]!=map[possible[i][0]][possible[i][1]])
                f[i]=-1;
    }
}


void work()
{
    node head;
    while(!q.empty())
    {
        head=q.front();
        q.pop();
        judge(head.x,head.y,head.d);
    }

    if(no_know==0)
        cout<<ans2<<" "<<ans1<<endl;
    else             //地图未完整
    {
        for(int i=1; i<=n; i++)
            for(int j=1; j<=m; j++)
                if(map[i][j]==-1)
                    possible[possible_num][0]=i,possible[possible_num++][1]=j;

        dfs(0);

        for(int i=0; i<possible_num; i++)
            if(f[i]==10)
                ans1++;
            else if(f[i]==-2)
                ans2++;

        cout<<ans2<<" "<<ans1<<endl;
//        for(int i=1;i<=n;i++){
//            for(int j=1;j<=m;j++)
//            printf("%4d",map[i][j]);
//            cout<<endl;
//        }
    }
}



void init()
{
    memset(f,0,sizeof(f));
    while(!q.empty())
        q.pop();
    ans1=ans2=0;
    no_know=0;
    possible_num=0;
    for(int i=0; i<=n+1; i++)
    {
        map[i][0]=10;
        map[i][m+1]=10;
    }
    for(int j=0; j<=n+1; j++)
    {
        map[0][j]=10;
        map[n+1][j]=10;
    }
}



int main()
{
    freopen("in.txt","r",stdin);
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        init();
        for(int i=1; i<=n; i++)
            for(int j=1; j<=m; j++)
            {
                scanf("%d",&map[i][j]);
                remain[i][j]=map[i][j];
                if(map[i][j]==-1)
                    no_know++;
            }
        for(int i=1; i<=n; i++)
            for(int j=1; j<=m; j++)
            {
                n_know[i][j]=judge(i,j,-1);
                if(remain[i][j]==0||remain[i][j]==n_know[i][j])
                    q.push({i,j,map[i][j]});
            }
        work();
    }
    return 0;
}
//我简直是有强迫症.....


Kuro同学
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
WinXP扫雷·加强版
12-30
《WinXP》的“扫雷”游戏，是我们的集体回忆。这个小游戏既锻炼了推理能力，又练习了鼠标操作。 后来，尽管 Win7 也有扫雷游戏，但是已经找不到那种“年少”时期的感觉。而到了 Win10，干脆把这些游戏都取消了。 为了让这个经典游戏重新焕发光彩，我们对《WinXP扫雷》进行改进，称为《WinXP扫雷·加强版》，简称《ＪＦ扫雷》。 该版本可以在 WinXP/Win7/Win10 中运行。你不必辛辛苦苦去找XP的电脑，也不用辛辛苦苦装一套虚拟机。 ＪＦ是 Just Fun 的意思，所谓“世事无绝对，只有真情趣”，译成英文就是 No Worry, Just Fun ...
hiho 第三十周 小Hi小Ho的惊天大作战：扫雷·一
zht的专栏
02-01 967
如题：http://hihocoder.com/problemset/problem/1114   时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 故事背景：密室、监视器与充满危机的广场        ×         故事背景：密室、监视器与充满危机的广场 小Hi从昏迷中醒来……已经有2分17秒了，他环顾
【hihoCoder】#1120 : 小Hi小Ho的惊天大作战：扫雷·三
小拳头的博客
08-30 1404
时间限制:10000ms 单点时限:1000ms 内存限制:256MB 故事背景：重复、假设与堵上性命的一搏 于是问题来了：给出一张N*M（在经过三条规则的反复洗礼之后，N和M都并不会很大）的地图，其中的某些格子已经被探明，探明的格子中都标有一个数字，表明与它相邻的8个格子里的地雷数量，而没有探明的格子里可能会有一些地雷。 而现在小Ho需要做的便是：判断出这张地图中的
hiho一下 第三十周 小Hi小Ho的惊天大作战：扫雷·一
devbarry的专栏
01-25 2095
时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 故事背景：密室、监视器与充满危机的广场 “我们还是循序渐进，先来考虑这样一个简单化问题：”小Hi思索片刻，道：“在一个大小为2*N的广场，其中第一行里的某一些格子里可能会有至多一个地雷，而第二行的格子里全都为数字，表示第一行中距离与这个格子不超过2的格子里总共有多少个地雷，即第二行的
hihoCoder 1114 小Hi小Ho的惊天大作战：扫雷·一
piaocoder
08-03 832
#include #include #include using namespace std; const int N = 100005; int mine1[N],mine2[N]; int val[N]; int ans1[N],ans2[N]; int n; bool flag1,flag2; void solve() { flag1 = flag2 = true; mine
hihocoder和leetcode-hiho-and-leet:hiho-and-leet
07-06
【标题】"hihocoder和leetcode-hiho-and-leet:hiho-and-leet" 提供的项目，主要关注的是两个知名的在线编程挑战平台——hihocoder和LeetCode。这两个平台都致力于帮助程序员提升编程技能，尤其是对于算法和数据结构...
leetcode76-Hihocode:Hihocode经典算法问题
06-30
leetcode76 Hihocode 经典算法问题 字符串 ...小Hi小Ho的惊天大作战：扫雷一 （dfs） 1301 岛屿（dfs hash） 1304 搜索一·24点 1308 搜索二·骑士问题（bfs） 1474 拆字游戏（dfs,记录状态） 数论 1372
leetcode答案-CodingProblemReview:这是一个个人leetcode，hiho，kikstart问题解决和文书工作库，
06-30
leetcode,hiho, kikstart problem solving and paper work repository After work like a year, I am thinking my objective is cloud computing, focusing on storage, buildout, deployment. It is a little bit ...
hiho-pytorch-base
02-17
【标题】"hiho-pytorch-base"是一个与PyTorch相关的项目，它可能是为了提供一个基础框架或者学习资源，帮助用户快速上手PyTorch的使用。在PyTorch中，用户可以构建和训练深度学习模型，尤其适用于研究和实验环境中。...
小Hi小Ho的惊天大作战：扫雷·二
TL的博客
03-21 280
题目描述 输入 每个测试点（输入文件）存在多组测试数据。 每个测试点的第一行为一个整数Task，表示测试数据的组数。 在一组测试数据中： 第1行为2个整数N，M，表示迷宫的大小。 接下来的N行，每行M个整数，为一个矩阵A，用以描述整个迷宫，其中对于每一个格子A[i][j]，若A[i][j]=-1，则表示该格子没有被探明，若0&lt;=A[i][j]&lt;=8，则表示该格子已经被探明了...
hihoCoder#1119 小Hi小Ho的惊天大作战：扫雷·二
dicui3114的博客
03-22 86
原题地址 没有复杂算法，就是麻烦，写起来细节比较多，比较考验细心，一次AC好开心。 代码： 1 #include <iostream> 2 #include <vector> 3 #include <cstring> 4 #include <cstdlib> 5 6 using na...
hihoCoder#1120 小Hi小Ho的惊天大作战：扫雷·三
dicui3114的博客
03-23 92
原题地址 看上去非常复杂， 实际上是这一系列最简单的一步，本质上是个搜索过程，相比于前一道题，可以不用策略三，而且题目的数据规模超级小，所以暴力搜索就能过。 把尚未确定的点放在一个unsettled列表里，然后依次枚举每个点的情况：是地雷or不是地雷 优化方案一即：每次枚举后，使用规则一、规则二对列表里剩下的点进行判断，如果能直接判断出是不是地雷的就立即设置了，这样剩下的枚举...
hiho刷题日记——第三十天小Hi小Ho的惊天大作战：扫雷·一
AngcFun的博客
12-16 1118
题目简化版扫雷，只有一行。 给出一行的周围3格中是雷的数量。 判断哪些一定是雷，一定不是雷。 思路因为给出的信息是环环相扣的，不用一个一个去试。 只需要试第一格是否为雷就可以通过数据算出后面是否为雷。 所以只用试两次， 第一次把一格设为雷，算出后面的情况；第二次把第一格设为不是雷，算出后面的情况。 若两次都算出来了，则将两次的情况对比，没有变化的部分就是答案。 若只有一次满足条件，则
C语言基础：扫雷游戏的C语言实现（超详图解+源码）
最新发布
linsc_05的博客
08-01 5044
友友们好，今天和大家一起做一个简单的——扫雷小游戏。如下：扫雷的规则很简单。盘面上有许多方格，方格中随机分布着一些雷。你的目标是避开雷，打开其他所有格子。一个非雷格中的数字表示其相邻8格中的雷数，你可以利用这个信息推导出安全格和雷的位置。打开所有安全格将被判定为胜利，打开雷将被判定为失败。
hihoCoder#1114 小Hi小Ho的惊天大作战：扫雷·一
dicui3114的博客
03-22 101
原题地址 回溯+搜索 枚举每个位置上能否放地雷，当第i个位置枚举完成后，第i-1个位置的情况就确定了，此时，检查第i-1个位置是否满足要求，即左右间隔为1的范围内地雷数是否等于申明数字，如果满足条件，那么继续搜索下去，如果不满足条件，抛弃这个搜索分支。 搜索完成后，将所有可行解按位置“与”一下 ，找到那些一定为地雷或一定为空的格子。 最后输出即可。 代码： ...
hihocoder #1114 : 小Hi小Ho的惊天大作战：扫雷·一
yqtao的博客
08-26 968
题目链接：http://hihocoder.com/problemset/problem/1114?sid=860881此题需要注意：只需要试第一格是否为雷就可以通过数据算出后面是否为雷。 所以只用试两次， 第一次把一格设为雷，算出后面的情况；第二次把第一格设为不是雷，算出后面的情况。 若两次都算出来了，则将两次的情况对比，没有变化的部分就是答案。 若只有一次满足条件，则那一次直接就
大鱼吃小鱼游戏代码 基于java-swing
热门推荐
旧时光
04-10 1万+
上周是数据库课程设计周,学校为了让我们做出一个真正能用(能看见框体)的东西,同时为毕业设计做准备,找来了培训机构的老师,讲解了两天java-swing图形界面的东西 虽然swing算是过时了的东西,但学起来还是挺开心的,毕竟终于能自己用图形界面写出东西来了.不过代码思路主要还是老师提供的, 逻辑功能实现图 这是最后给同学更改了部分参数贴上图片后
游戏服务器中应对各种外挂/作弊的策略
旧时光
04-09 3997
在游戏开发过程中，游戏本身是十分脆弱的，在复杂的网络环境中，犹如一叶小舟，如果没有好的防守，可能说翻车就翻车。对于游戏开发者来说，与破坏者的斗争是长期的，艰苦卓绝的，也是一个斗智斗勇的过程，力量对比往往是此消彼长。所谓是道高一尺，魔高一丈，对于游戏守护者来说，要往往要做到的是魔高一尺，道高一丈。我们不可能完全避免作弊，只是在尽量增加作弊的成本。 游戏作弊的一般方式主要有以下几种常见的： 一

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值