精华内容
下载资源
问答
  • 扫雷游戏算法

    2020-04-13 09:40:43
    这道其实最“烦”的地方在于,字符串的输入,我直接采用了网上的一种做法就是,输入二维数组的时候,把它当做一维数组,也就是在输入的时候,直接把一行当做一整个字符串。 也即是二维字符数组和普通二维数组之间...

    在这里插入图片描述

    这道题其实最“烦”的地方在于,字符串的输入,我直接采用了网上的一种做法就是,输入二维数组的时候,把它当做一维数组,也就是在输入的时候,直接把一行当做一整个字符串。
    也即是二维字符数组和普通二维数组之间的区别

    #include<stdio.h>
    #include<string.h>
    #include<algorithm>
    #include<iostream>
    #include<math.h>
    #include<queue>
    using namespace std;
    int stepx[8]={-1,1,0,0,-1,-1,1,1};
    int stepy[8]={0,0,-1,1,-1,1,-1,1};
    int main(){
        //首先输入是n行m列的雷区,然后输出也是n行n列的来表示周围的地雷个数(也就是从不同方向上能出现的最大地雷个数)
        char mmap[20][20]={'0'};//先初始化
        char result[20][20];//一个是用来输入的,一个是用来输出的
        int n,m,i,j;
         scanf("%d%d",&n,&m);
        //再开始输入
        for(i=0;i<n;i++)
                scanf("%s",mmap[i]);
        //然后就是开始统计了,先创建两个数组用来表明方向
        for(i=0;i<n;i++)
            for(j=0;j<m;j++){
                int sum=0;
                //先判断是不是雷区,如果是雷,直接加入
                if(mmap[i][j]=='*')
                    result[i][j]='*';
                //如果不是雷的话,就要这八个方位都判断依稀
                else{
                for(int k=0;k<8;k++){
                    int newi=i+stepx[k];
                    int newj=j+stepy[k];
                    if(mmap[newi][newj]=='*')
                        sum++;
                }
                //最后统计这些位置的*值
                result[i][j]=sum+'0';
                }
            }
        //再开始输出
        for(i=0;i<n;i++){
            for(j=0;j<m;j++)
                printf("%c",result[i][j]);
                //并且要注意格式
            printf("\n");
        }
    
    }
    
    
    展开全文
  • 扫雷游戏 扫雷是Windows自带的游戏。游戏的目标是尽快找到雷区中的所有地雷,而不许踩到地雷。如果方块上的是地雷,将输掉游戏。如果方块上出现数字,则表示在其周围的八个方块中共有多少颗地雷 你的任务是在已知...

    扫雷游戏

    扫雷是Windows自带的游戏。游戏的目标是尽快找到雷区中的所有地雷,而不许踩到地雷。如果方块上的是地雷,将输掉游戏。如果方块上出现数字,则表示在其周围的八个方块中共有多少颗地雷
    你的任务是在已知地雷出现位置的情况下,得到各个方块中的数据

    … “ * ”表示有地雷
    .
    … “.”表示无

    经过处理应得到
    100
    2210
    1
    10
    1110

    Input

    输入有多组数据,每组数据的第一行有两个数字,m,n(0<m,n<100)表示游戏中雷区的范围为m×n。接下来m行每行有n个字符。“*” 表示有地雷,“.”表示无地雷。最后一组数据m=0,n=0表示输入结束,不需要处理。

    Output

    对于每组输入数据,输出结果,各方块数字间不留空格。每组结果之后有一个空行。

    Sample Input

    2 3
    ***
    ...
    4 4
    *...
    ....
    .*..
    ....
    0 0
    

    Sample Output

    ***
    232
    
    *100
    2210
    1*10
    1110
    
    
    

    AC代码:

    #include <stdio.h>
    #include <string.h>
    
    int main() {
    	int n, m;
    	int dx[8] = {0, 0, -1, 1, -1, 1, -1, 1};
    	int dy[8] = {-1, 1, 0, 0, -1, -1, 1, 1};
    	while(scanf("%d %d", &n, &m) && (n || m)) {
    		char s[105][105];
    		memset(s, 0, sizeof(s));
    		for(int i = 1; i <= n; i++)
    			for(int j = 1; j <= m; j++)
    				scanf(" %c", &s[i][j]);
    		for(int i = 1; i <= n; i++) {
    			for(int j = 1; j <= m; j++) {
    				int sum = 0;
    				if(s[i][j] == '.'){
    					for(int k = 0; k < 8; k++) {
    						if(s[i + dy[k]][j + dx[k]] == '*') sum++;
    					}
    					printf("%d", sum);
    				}
    				else {
    					printf("*");
    				}
    			}
    			printf("\n");
    		}
    		printf("\n");
    	}
    	return 0;
    }
    

    End

    展开全文
  • 529. 扫雷游戏

    2020-08-20 00:36:27
    i++ { tx, ty := x + dirX[i], y + dirY[i] if tx || tx >= len(board) || ty || ty >= len(board[0]) { continue } // 不用判断 M,因为如果有 M 的话游戏已经结束了 if board[tx][ty] == 'M' { cnt++ } } if cnt ...

    C++

    class Solution {
    public:
        vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
            int height = board.size(), width = board[0].size(), row = click[0], col = click[1];
            if (board[row][col] == 'M') {
                board[row][col] = 'X';
            }
            else {
                int count = 0;
                for (int i = -1; i <= 1; i++) {
                    for (int j = -1; j <= 1; j++) {
                        if (i == 0 && j == 0) {
                            continue;
                        }
                        int r = row + i, c = col + j;
                        if (r < 0 || r >= height || c < 0 || c >= width) {
                            continue;
                        }
                        if (board[r][c] == 'M') {
                            count++;
                        }
                    }
                }
                if (count > 0) {
                    board[row][col] = count + '0';
                }
                else {
                    board[row][col] = 'B';
                    for (int i = -1; i <= 1; i++) {
                        for (int j = -1; j <= 1; j++) {
                            if (i == 0 && j == 0) {
                                continue;
                            }
                            int r = row + i, c = col + j;
                            if (r < 0 || r >= height || c < 0 || c >= width) {
                                continue;
                            }
                            if (board[r][c] == 'E') {
                                vector<int> v;
                                v.push_back(r);
                                v.push_back(c);
                                updateBoard(board, v);
                            }
                        }
                    }
                }
            }
            return board;
        }
    };

    C++

    class Solution {
    public:
        int dir_x[8] = {0, 1, 0, -1, 1, 1, -1, -1};
        int dir_y[8] = {1, 0, -1, 0, 1, -1, 1, -1};
    
        void dfs(vector<vector<char>>& board, int x, int y) {
            int cnt = 0;
            for (int i = 0; i < 8; ++i) {
                int tx = x + dir_x[i];
                int ty = y + dir_y[i];
                if (tx < 0 || tx >= board.size() || ty < 0 || ty >= board[0].size()) {
                    continue;
                }
                // 不用判断 M,因为如果有 M 的话游戏已经结束了
                cnt += board[tx][ty] == 'M';
            }
            if (cnt > 0) {
                // 规则 3
                board[x][y] = cnt + '0';
            } else {
                // 规则 2
                board[x][y] = 'B';
                for (int i = 0; i < 8; ++i) {
                    int tx = x + dir_x[i];
                    int ty = y + dir_y[i];
                    // 这里不需要在存在 B 的时候继续扩展,因为 B 之前被点击的时候已经被扩展过了
                    if (tx < 0 || tx >= board.size() || ty < 0 || ty >= board[0].size() || board[tx][ty] != 'E') {
                        continue;
                    }
                    dfs(board, tx, ty);
                }
            }
        }
    
        vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
            int x = click[0], y = click[1];
            if (board[x][y] == 'M') {
                // 规则 1
                board[x][y] = 'X';
            } else {
                dfs(board, x, y);
            }
            return board;
        }
    };

    Java

    class Solution {
        int[] dirX = {0, 1, 0, -1, 1, 1, -1, -1};
        int[] dirY = {1, 0, -1, 0, 1, -1, 1, -1};
    
        public char[][] updateBoard(char[][] board, int[] click) {
            int x = click[0], y = click[1];
            if (board[x][y] == 'M') {
                // 规则 1
                board[x][y] = 'X';
            } else{
                dfs(board, x, y);
            }
            return board;
        }
    
        public void dfs(char[][] board, int x, int y) {
            int cnt = 0;
            for (int i = 0; i < 8; ++i) {
                int tx = x + dirX[i];
                int ty = y + dirY[i];
                if (tx < 0 || tx >= board.length || ty < 0 || ty >= board[0].length) {
                    continue;
                }
                // 不用判断 M,因为如果有 M 的话游戏已经结束了
                if (board[tx][ty] == 'M') {
                    ++cnt;
                }
            }
            if (cnt > 0) {
                // 规则 3
                board[x][y] = (char) (cnt + '0');
            } else {
                // 规则 2
                board[x][y] = 'B';
                for (int i = 0; i < 8; ++i) {
                    int tx = x + dirX[i];
                    int ty = y + dirY[i];
                    // 这里不需要在存在 B 的时候继续扩展,因为 B 之前被点击的时候已经被扩展过了
                    if (tx < 0 || tx >= board.length || ty < 0 || ty >= board[0].length || board[tx][ty] != 'E') {
                        continue;
                    }
                    dfs(board, tx, ty);
                }
            }
        }
    }

    Golang

    var dirX = []int{0, 1, 0, -1, 1, 1, -1, -1}
    var dirY = []int{1, 0, -1, 0, 1, -1, 1, -1}
    
    func updateBoard(board [][]byte, click []int) [][]byte {
        x, y := click[0], click[1]
        if board[x][y] == 'M' {
            board[x][y] = 'X'
        } else {
            dfs(board, x, y)
        }
        return board
    }
    
    func dfs(board [][]byte, x, y int) {
        cnt := 0
        for i := 0; i < 8; i++ {
            tx, ty := x + dirX[i], y + dirY[i]
            if tx < 0 || tx >= len(board) || ty < 0 || ty >= len(board[0]) {
                continue
            }
            // 不用判断 M,因为如果有 M 的话游戏已经结束了
            if board[tx][ty] == 'M' {
                cnt++
            }
        }
        if cnt > 0 {
            board[x][y] = byte(cnt + '0')
        } else {
            board[x][y] = 'B'
            for i := 0; i < 8; i++ {
                tx, ty := x + dirX[i], y + dirY[i]
                // 这里不需要在存在 B 的时候继续扩展,因为 B 之前被点击的时候已经被扩展过了
                if tx < 0 || tx >= len(board) || ty < 0 || ty >= len(board[0]) || board[tx][ty] != 'E' {
                    continue
                }
                dfs(board, tx, ty)
            }
        }
    }

    C

    const int dir_x[8] = {0, 1, 0, -1, 1, 1, -1, -1};
    const int dir_y[8] = {1, 0, -1, 0, 1, -1, 1, -1};
    
    int n, m;
    
    void dfs(char** board, int x, int y) {
        int cnt = 0;
        for (int i = 0; i < 8; ++i) {
            int tx = x + dir_x[i];
            int ty = y + dir_y[i];
            if (tx < 0 || tx >= n || ty < 0 || ty >= m) {
                continue;
            }
            // 不用判断 M,因为如果有 M 的话游戏已经结束了
            cnt += board[tx][ty] == 'M';
        }
        if (cnt > 0) {
            // 规则 3
            board[x][y] = cnt + '0';
        } else {
            // 规则 2
            board[x][y] = 'B';
            for (int i = 0; i < 8; ++i) {
                int tx = x + dir_x[i];
                int ty = y + dir_y[i];
                // 这里不需要在存在 B 的时候继续扩展,因为 B 之前被点击的时候已经被扩展过了
                if (tx < 0 || tx >= n || ty < 0 || ty >= m || board[tx][ty] != 'E') {
                    continue;
                }
                dfs(board, tx, ty);
            }
        }
    }
    
    char** updateBoard(char** board, int boardSize, int* boardColSize, int* click, int clickSize, int* returnSize, int** returnColumnSizes) {
        n = boardSize, m = boardColSize[0];
        int x = click[0], y = click[1];
        if (board[x][y] == 'M') {
            // 规则 1
            board[x][y] = 'X';
        } else {
            dfs(board, x, y);
        }
        *returnSize = n;
        **returnColumnSizes = malloc(sizeof(int*) * n);
        for (int i = 0; i < n; i++) {
            (*returnColumnSizes)[i] = m;
        }
        return board;
    }

    C++

    class Solution {
    public:
        int dir_x[8] = {0, 1, 0, -1, 1, 1, -1, -1};
        int dir_y[8] = {1, 0, -1, 0, 1, -1, 1, -1};
    
        void bfs(vector<vector<char>>& board, int sx, int sy) {
            queue<pair<int, int>> Q;
            vector<vector<int>> vis(board.size(), vector<int>(board[0].size(), 0));
            Q.push({sx, sy});
            vis[sx][sy] = true;
            while (!Q.empty()) {
                auto pos = Q.front();
                Q.pop();
                int cnt = 0, x = pos.first, y = pos.second;
                for (int i = 0; i < 8; ++i) {
                    int tx = x + dir_x[i];
                    int ty = y + dir_y[i];
                    if (tx < 0 || tx >= board.size() || ty < 0 || ty >= board[0].size()) {
                        continue;
                    }
                    // 不用判断 M,因为如果有 M 的话游戏已经结束了
                    cnt += board[tx][ty] == 'M';
                }
                if (cnt > 0) {
                    // 规则 3
                    board[x][y] = cnt + '0';
                } else {
                    // 规则 2
                    board[x][y] = 'B';
                    for (int i = 0; i < 8; ++i) {
                        int tx = x + dir_x[i];
                        int ty = y + dir_y[i];
                        // 这里不需要在存在 B 的时候继续扩展,因为 B 之前被点击的时候已经被扩展过了
                        if (tx < 0 || tx >= board.size() || ty < 0 || ty >= board[0].size() || board[tx][ty] != 'E' || vis[tx][ty]) {
                            continue;
                        }
                        Q.push(make_pair(tx, ty));
                        vis[tx][ty] = true;
                    }
                }
            }
        }
    
        vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
            int x = click[0], y = click[1];
            if (board[x][y] == 'M') {
                // 规则 1
                board[x][y] = 'X';
            } else {
                bfs(board, x, y);
            }
            return board;
        }
    };

    Java

    class Solution {
        int[] dirX = {0, 1, 0, -1, 1, 1, -1, -1};
        int[] dirY = {1, 0, -1, 0, 1, -1, 1, -1};
    
        public char[][] updateBoard(char[][] board, int[] click) {
            int x = click[0], y = click[1];
            if (board[x][y] == 'M') {
                // 规则 1
                board[x][y] = 'X';
            } else{
                bfs(board, x, y);
            }
            return board;
        }
    
        public void bfs(char[][] board, int sx, int sy) {
            Queue<int[]> queue = new LinkedList<int[]>();
            boolean[][] vis = new boolean[board.length][board[0].length];
            queue.offer(new int[]{sx, sy});
            vis[sx][sy] = true;
            while (!queue.isEmpty()) {
                int[] pos = queue.poll();
                int cnt = 0, x = pos[0], y = pos[1];
                for (int i = 0; i < 8; ++i) {
                    int tx = x + dirX[i];
                    int ty = y + dirY[i];
                    if (tx < 0 || tx >= board.length || ty < 0 || ty >= board[0].length) {
                        continue;
                    }
                    // 不用判断 M,因为如果有 M 的话游戏已经结束了
                    if (board[tx][ty] == 'M') {
                        ++cnt;
                    }
                }
                if (cnt > 0) {
                    // 规则 3
                    board[x][y] = (char) (cnt + '0');
                } else {
                    // 规则 2
                    board[x][y] = 'B';
                    for (int i = 0; i < 8; ++i) {
                        int tx = x + dirX[i];
                        int ty = y + dirY[i];
                        // 这里不需要在存在 B 的时候继续扩展,因为 B 之前被点击的时候已经被扩展过了
                        if (tx < 0 || tx >= board.length || ty < 0 || ty >= board[0].length || board[tx][ty] != 'E' || vis[tx][ty]) {
                            continue;
                        }
                        queue.offer(new int[]{tx, ty});
                        vis[tx][ty] = true;
                    }
                }
            }
        }
    }

    C

    const int dir_x[8] = {0, 1, 0, -1, 1, 1, -1, -1};
    const int dir_y[8] = {1, 0, -1, 0, 1, -1, 1, -1};
    
    int n, m;
    
    typedef struct {
        int x, y;
    } pair;
    
    void bfs(char** board, int sx, int sy) {
        bool vis[n][m];
        memset(vis, 0, sizeof(vis));
        pair Q[n * m];
        int l = 0, r = 1;
        Q[0].x = sx, Q[0].y = sy;
        vis[sx][sy] = true;
        while (l < r) {
            pair pos = Q[l++];
            int cnt = 0, x = pos.x, y = pos.y;
            for (int i = 0; i < 8; ++i) {
                int tx = x + dir_x[i];
                int ty = y + dir_y[i];
                if (tx < 0 || tx >= n || ty < 0 || ty >= m) {
                    continue;
                }
                // 不用判断 M,因为如果有 M 的话游戏已经结束了
                cnt += board[tx][ty] == 'M';
            }
            if (cnt > 0) {
                // 规则 3
                board[x][y] = cnt + '0';
            } else {
                // 规则 2
                board[x][y] = 'B';
                for (int i = 0; i < 8; ++i) {
                    int tx = x + dir_x[i];
                    int ty = y + dir_y[i];
                    // 这里不需要在存在 B 的时候继续扩展,因为 B 之前被点击的时候已经被扩展过了
                    if (tx < 0 || tx >= n || ty < 0 || ty >= m || board[tx][ty] != 'E' || vis[tx][ty]) {
                        continue;
                    }
                    Q[r].x = tx, Q[r++].y = ty;
                    vis[tx][ty] = true;
                }
            }
        }
    }
    
    char** updateBoard(char** board, int boardSize, int* boardColSize, int* click, int clickSize, int* returnSize, int** returnColumnSizes) {
        n = boardSize, m = boardColSize[0];
        int x = click[0], y = click[1];
        if (board[x][y] == 'M') {
            // 规则 1
            board[x][y] = 'X';
        } else {
            bfs(board, x, y);
        }
        *returnSize = n;
        **returnColumnSizes = malloc(sizeof(int*) * n);
        for (int i = 0; i < n; i++) {
            (*returnColumnSizes)[i] = m;
        }
        return board;
    }

    Golang

    var dirX = []int{0, 1, 0, -1, 1, 1, -1, -1}
    var dirY = []int{1, 0, -1, 0, 1, -1, 1, -1}
    
    func updateBoard(board [][]byte, click []int) [][]byte {
        x, y := click[0], click[1]
        if board[x][y] == 'M' {
            board[x][y] = 'X'
        } else {
            bfs(board, x, y)
        }
        return board
    }
    
    func bfs(board [][]byte, sx, sy int) {
        queue := [][]int{}
        vis := make([][]bool, len(board))
        for i := 0; i < len(vis); i++ {
            vis[i] = make([]bool, len(board[0]))
        }
        queue = append(queue, []int{sx, sy})
        vis[sx][sy] = true
        for i := 0; i < len(queue); i++ {
            cnt, x, y := 0, queue[i][0], queue[i][1]
            for i := 0; i < 8; i++ {
            tx, ty := x + dirX[i], y + dirY[i]
                if tx < 0 || tx >= len(board) || ty < 0 || ty >= len(board[0]) {
                    continue
                }
                // 不用判断 M,因为如果有 M 的话游戏已经结束了
                if board[tx][ty] == 'M' {
                    cnt++
                }
            }
            if cnt > 0 {
                board[x][y] = byte(cnt + '0')
            } else {
                board[x][y] = 'B'
                for i := 0; i < 8; i++ {
                    tx, ty := x + dirX[i], y + dirY[i]
                    // 这里不需要在存在 B 的时候继续扩展,因为 B 之前被点击的时候已经被扩展过了
                    if tx < 0 || tx >= len(board) || ty < 0 || ty >= len(board[0]) || board[tx][ty] != 'E' || vis[tx][ty] {
                        continue
                    }
                    queue = append(queue, []int{tx, ty})
                    vis[tx][ty] = true
                }
            }
        }
    }

    展开全文
  • 扫雷游戏场地是一副n行,m列的字符组成的地图; * ? ? ? ? * ? ? ? 这其中*表示地雷,?表示安全区域 现在要求计算每个安全区域周围的地雷数量; 周围的定义为:安全区域位置的“上”、“下”、“左”、...

    2019-07-31  11:11:25

    扫雷游戏场地是一副n行,m列的字符组成的地图;

    * ? ?
    ? ? *
    ? ? ?

    这其中*表示地雷,?表示安全区域

    现在要求计算每个安全区域周围的地雷数量;

    周围的定义为:安全区域位置的“上”、“下”、“左”、“右”、“左上”、“右上”、“左下”、“右下”八个区域

    如上个地图所示的安全区域 “?”内填入周围的地雷数量:

    * 2 1
    1 2 *
    0 1 1

    输入样例:

    3 3
    *  ? ?
    ? ? ?
    ? *  ?

    输出样例

     

    * 1 0
    2 2 1
    1 * 1

     


    问题分解

    定义一个二维字符数组来存储雷区,再定义一个二维整数数组来存储每个位置周围地雷的个数。

    输入雷区时,可以用gets逐行读入,也可以用getchar逐个读入字符。

    输出字符数组时,可以用putchar逐个字符输出;

     

    转载于:https://www.cnblogs.com/lightworkshopnoi/p/11275045.html

    展开全文
  • FoJ 水题扫雷游戏

    2014-03-23 15:49:12
    扫雷游戏 #include #include using namespace std; int main() {int i,j,k,m,n; char a[105][105];int b[105][105]={0}; while(cin>>m>>n&&m!=0&&n!=0) { for(i=1;i;i++) for(j=1;j;j++) cin>>a[i][j]
  • 题目:扫雷游戏 (点它) Description 让我们一起来玩扫雷游戏! 给定一个代表游戏板的二维字符矩阵。 ‘M’ 代表一个未挖出的地雷,‘E’ 代表一个未挖出的空方块,‘B’ 代表没有相邻(上,下,左,右,和所有4个对...
  • 扫雷游戏

    2017-08-14 19:09:31
    今天,嘟嘟老师讲一道水——扫雷游戏。 题目描述 扫雷游戏是一款十分经典的单击小游戏。 在n行m列的雷区中有一些格子含有地雷(称之为地雷格),其他格子不含地雷(称之为非地雷格)。 玩家翻开一个非地...
  • 让我们一起来玩扫雷游戏! 给定一个代表游戏板的二维字符矩阵。 ‘M’ 代表一个未挖出的地雷,‘E’ 代表一个未挖出的空方块,‘B’ 代表没有相邻(上,下,左,右,和所有4个对角线)地雷的已挖出的空白方块,...
  • Leetcode 529 扫雷游戏题目描述解题思路代码版本1for循环优化数组优化 题目描述 让我们一起来玩扫雷游戏! 给定一个代表游戏板的二维字符矩阵。 ‘M’ 代表一个未挖出的地雷,‘E’ 代表一个未挖出的空方块,‘B’ ...
  • 2015年普及组复赛第2扫雷游戏 题目描述: 扫雷游戏是一款十分经典的单机小游戏。在n行m列的雷区中有一些格子含有地雷(称之为地雷格),其他格子不含地雷(称之为非地雷格)。玩家翻开一个非地雷格时,该格将会...
  •  扫雷游戏你一定玩过吧!现在给你若干个n×m的地雷阵,请你计算出每个矩阵中每个单元格相邻单元格内地雷的个数,每个单元格最多有8个相邻的单元格。 0<n,m<=100 输入格式  输入包含若干个矩阵,对于每个...
  • 初级java笔试CSCI 1302 - 扫雷Alpha v2020.sp 周五 2020-01-31(1 月 31 日)下午 11:55。 该存储库包含分配给佐治亚大学 2020 年Spring CSCI 1302 课程学生的扫雷器 Alpha 项目的框架代码。 在开始您的项目之前,...
  • 新手在学习完二维数组的基本知识以后,就可以尝试着来实现一个简易的扫雷游戏了。 在完成之前首先要有一个基本的框架即怎样一步一步的实现游戏: 1.打印菜单,让用户选择开始或者结束游戏。 2.建立两个二维数组表示...
  • 扫雷游戏 让我们一起来玩扫雷游戏! 给定一个代表游戏板的二维字符矩阵。 ‘M’ 代表一个未挖出的地雷,‘E’ 代表一个未挖出的空方块,‘B’ 代表没有相邻(上,下,左,右,和所有4个对角线)地雷的已挖出的空白...
  • 让我们一起来玩扫雷游戏! 给定一个代表游戏板的二维字符矩阵。 ‘M’ 代表一个未挖出的地雷,‘E’ 代表一个未挖出的空方块,‘B’ 代表没有相邻(上,下,左,右,和所有4个对角线)地雷的已挖出的空白方块,数字...
  • luogu2670 扫雷游戏(NOIP2015普及组第2) 时空限制 1000ms/128MB 题目描述 扫雷游戏是一款十分经典的单机小游戏。在n行m列的雷区中有一些格子含有地雷(称之为地雷格),其他格子不含地雷(称之为非地雷格)。...
  • 2015年普及组复赛第2扫雷游戏》CA代码 1、题目 【题目描述】 扫雷游戏是一款十分经典的单机小游戏。在n行m列的雷区中有一些格子含有地雷(称之为地雷格),其他格子不含地雷(称之为非地雷格)。玩家翻开一个非...
  • 这个应该暴力模拟就可以过 代码 #include&amp;amp;amp;lt;cstdio&amp;amp;amp;gt; using namespace std; int n,m,a[101][101];//初始化 int main() { char d;//初始化 scanf(&amp;amp;quot;...
  • 扫雷游戏 实现功能: 打印扫雷界面 随机放置地雷,数量有后台自己设定 玩家输入游戏坐标,以此判断输入的位置是否有雷 如果有雷,游戏结束 如果该位置没有雷,则统计该位置周围一圈有没有雷,有几个雷,并打印...
  • 扫雷游戏是一款十分经典的单击小游戏。在n行m列的雷区中有一些格子含有地雷(称之为地雷格),其他格子不含地雷(称之为非地雷格)。玩家翻开一个非地雷格时,该格将会出现一个数字——提示周围格子中有多少个是地雷...
  • NKOJ 3751 扫雷游戏 时间限制 : - MS 空间限制 : 65536 KB 评测说明 : 时限1000ms问题描述 有一款有趣的手机游戏。棋盘上有n颗地雷,玩家需要至少扫掉其中的k颗雷。 每一步,玩家可以用手指在手机屏幕上划一条...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 270
精华内容 108
关键字:

扫雷游戏题