OD统一考试(C卷)
分值: 100分
题解: Java / Python / C++

题目描述
围棋棋盘由纵横各19条线垂直相交组成,棋盘上一共19x19=361个交点,对弈双方一方执白棋,一方执黑棋,落子时只能将棋子置于交点上。
“气”是围棋中很重要的一个概念,某个棋子有几口气,是指其上下左右方向四个相邻的交叉点中,有几个交叉点没有棋子,由此可知:
- 在棋盘的边缘上的棋子最多有3口气(黑1),在棋盘角点的棋子最多有2口气(黑2),其它情况最多有4口气(白1)

-  所有同色棋子的气之和叫作该色棋子的气,需要注意的是,同色棋子重合的气点,对于该颜色棋子来说,只能计算一次气,比如下图中,黑棋一共4口气,而不是5口气,因为黑1和黑2中间红色三角标出的气是两个黑棋共有的,对于黑棋整体来说只能算一个气。  
-  本题目只计算气,对于眼也按气计算,如果您不清楚“眼”的概念,可忽略,按照前面描述的规则计算即可现在,请根据输入的黑棋和白棋的坐标位置,计算黑棋和白起一共各有多少气? 
输入描述
输入包括两行数据,如:
0 5 8 9 9 10
5 0 9 9 9 8
1、每行数据以空格分隔,数据个数是2的整数倍,每两个数是一组,代表棋子在棋盘上的坐标;
2、坐标的原点在棋盘左上角点,第一个值是行号,范围从0到18;第二个值是列号,范围从0到18;
3、举例说明: 第一行数据表示三个坐标 (0,5)、 (8,9)、 (9,10);
4、第一行表示黑棋的坐标,第二行表示白棋的坐标。
5、题目保证输入两行数据,无空行且每行按前文要求是偶数个,每个坐标不会超出棋盘范围。
输出描述
8 7
两个数字以空格分隔,第一个数代表黑棋的气数,第二个数代表白棋的气数。
示例1
输入:
0 5 8 9 9 10
5 0 9 9 9 8
输出:
8 7


题解
首先,我们需要理解围棋中的气是如何计算的。题目中已经给出了相关的规则,根据这些规则,我们可以遍历每个棋子的上下左右四个相邻的位置,判断是否有气。遍历所有同色的棋子,累加其气的数量。
Java
import java.util.ArrayList;
import java.util.Scanner;
/**
 * @author code5bug
 */
public class Main {
    static int N = 19;
    static Scanner scanner = new Scanner(System.in);
    // 围棋棋盘
    static int[][] g = new int[N][N];
    // 位置四周坐标偏移量
    static int[][] dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    public static void main(String[] args) {
        ArrayList<int[]> black = readInput(1);
        ArrayList<int[]> white = readInput(2);
        int bcnt = solve(black), wcnt = solve(white);
        System.out.println(bcnt + " " + wcnt);
    }
    // 读取棋子并安放到棋盘对应位置
    static ArrayList<int[]> readInput(int color) {
        ArrayList<int[]> locations = new ArrayList<>();
        String[] splits = scanner.nextLine().split(" ");
        for (int i = 0; i < splits.length; i += 2) {
            int r = Integer.parseInt(splits[i]);
            int c = Integer.parseInt(splits[i + 1]);
            locations.add(new int[]{r, c});
            g[r][c] = color;
        }
        return locations;
    }
    // 判断是否在棋盘内部
    static boolean valid(int r, int c) {
        return 0 <= r && r < N && 0 <= c && c < N;
    }
    // 计算所有棋子的气
    static int solve(ArrayList<int[]> locations) {
        boolean[][] vis = new boolean[N][N];
        int cnt = 0;
        for (int[] loc : locations) {
            int r = loc[0], c = loc[1];
            for (int[] dir : dirs) {
                int nr = r + dir[0];
                int nc = c + dir[1];
                if (valid(nr, nc) && !vis[nr][nc] && g[nr][nc] == 0) {
                    vis[nr][nc] = true;
                    cnt++;
                }
            }
        }
        return cnt;
    }
}
Python
N = 19
# 围棋棋盘
g = [[0] * N for _ in range(N)]
# 位置四周坐标偏移量
dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)]
def read_input(color):
    """ 读取棋子并安放到棋盘对应位置"""
    global g
    locations = []
    arr = list(map(int, input().split()))
    for i in range(0, len(arr), 2):
        r, c = arr[i], arr[i+1]
        locations.append((r, c))
        g[r][c] = color
    return locations
def valid(r, c):  # 判断是否在棋盘内部
    global N
    return 0 <= r < N and 0 <= c < N
def solve(locations):
    """ 计算所有棋子的气 """
    vis = [[False] * N for _ in range(N)]
    cnt = 0
    for r, c in locations:
        for dr, dc in dirs:
            nr, nc = r + dr, c + dc
            if valid(nr, nc) and not vis[nr][nc] and g[nr][nc] == 0:
                vis[nr][nc] = True
                cnt += 1
    return cnt
if __name__ == "__main__":
    black = read_input(1)
    white = read_input(2)
    bcnt, wcnt = solve(black), solve(white)
    print(bcnt, wcnt)
C++
#include <iostream>
#include <vector>
#define N 19
using namespace std;
// 围棋棋盘
int g[N][N];
// 位置四周坐标偏移量
int dirs[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
// 读取棋子并安放到棋盘对应位置
vector<vector<int>> readInput(int color) {
    vector<vector<int>> locations;
    int r, c;
    while (cin >> r >> c) {
        locations.push_back({r, c});
        g[r][c] = color;
        if(cin.peek() == '\n') {
            break;
        }
    }
    return locations;
}
// 判断是否在棋盘内部
bool valid(int r, int c) {
    return 0 <= r && r < N && 0 <= c && c < N;
}
// 计算所有棋子的气
int solve(const vector<vector<int>>& locations) {
    vector<vector<bool>> vis(N, vector<bool>(N, false));
    int cnt = 0;
    for (const auto& loc : locations) {
        int r = loc[0], c = loc[1];
        for (const auto& dir : dirs) {
            int nr = r + dir[0];
            int nc = c + dir[1];
            if (valid(nr, nc) && !vis[nr][nc] && g[nr][nc] == 0) {
                vis[nr][nc] = true;
                cnt++;
            }
        }
    }
    return cnt;
}
int main() {
    vector<vector<int>> black = readInput(1);
    vector<vector<int>> white = readInput(2);
    int bcnt = solve(black);
    int wcnt = solve(white);
    cout << bcnt << " " << wcnt << endl;
    return 0;
}
相关练习题
| 题号 | 题目 | 难易 | 
|---|---|---|
| LeetCode 130 | 130. 被围绕的区域 | 中等 | 
❤️华为OD机试面试交流群(每日真题分享): 加V时备注“华为od加群”
🙏整理题解不易, 如果有帮助到您,请给点个赞 ❤️ 和收藏 ⭐,让更多的人看到。🙏🙏🙏



















