笔试时间：2023年9月9日 秋招

第一题

题目：小红的棋盘

小红有一个大小为8 x 8的国际象棋棋盘，棋盘的(x1,y1)位置上是骑士，可以向八个方向移动，棋盘的(x2,y2)位置上是主教，可以向四个方向移动，但是不能越过其他棋子。小红想知道，有多少个地方可以放一个新棋子，不会被骑士和主教吃掉。新棋子只能放置在空的格子上。

骑士位置在(x1,y1)，那么会吃掉(x1 + dx，y1+dy)的棋子，|dx| + |dy| = 3，dx != 0, dy !=0。

主教位置在(x2,y2)，那么会吃掉(x2 + dx，y2 + dy)的棋子，|dx| = |dy| > 0。

输入描述

一行四个整数x1、y1、x2、y2，表示骑士和主教的位置。

 1 <= x1,y1,x2,y2 <= 8

(x1,y1) != (x2,y2)

输出描述

输出一个整数，表示可以放置新棋子的位置数。

样例输入

1 2 4 5

样例输出

45

参考题解

遍历模拟，对两颗棋子的攻击范围进行遍历，模拟的过程中主教的攻击范围遇到骑士时，应当停止。

C++：[此代码未进行大量数据的测试，仅供参考]

#include<iostream>
#include<vector>
using namespace std;

typedef long long ll;
const int N = 8;
const int dx[N] = {-1, 1, -1, 1, -2, 2, -2, 2};
const int dy[N] = {2, 2, -2, -2, 1, 1, -1, -1};

const int da[4] = {-1, 1, 0, 0};
const int db[4] = {0, 0, -1, 1};

int grid[N + 2][N + 2]; // Increase array size to simplify boundary checks

int main() {
    int xa, ya, xb, yb;
    scanf("%d %d %d %d", &xa, &ya, &xb, &yb);
    grid[xa][ya] = grid[xb][yb] = 2;

    for (int i = 0; i < N; i++) {
        int x = xa + dx[i], y = ya + dy[i];
        if (x >= 1 && x <= N && y >= 1 && y <= N) {
            grid[x][y] = 1;
        }
    }

    for (int i = 0; i < 4; i++) {
        for (int k = 1; k <= N; k++) {
            int x = xb + da[i] * k, y = yb + db[i] * k;
            if (x < 1 || y < 1 || x > N || y > N || grid[x][y]) break;
            grid[x][y] = 1;
        }
    }

    int ans = 0;
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            ans += !grid[i][j];
        }
    }
    printf("%d\n", ans);
}

Java：[此代码未进行大量数据的测试，仅供参考]

import java.util.Scanner;

class ChessboardOptimization {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = 8;
        int[] dx = {-1, 1, -1, 1, -2, 2, -2, 2};
        int[] dy = {2, 2, -2, -2, 1, 1, -1, -1};
        int[][] grid = new int[N + 2][N + 2];

        int xa = scanner.nextInt();
        int ya = scanner.nextInt();
        int xb = scanner.nextInt();
        int yb = scanner.nextInt();

        grid[xa][ya] = grid[xb][yb] = 2;

        for (int i = 0; i < N; i++) {
            int x = xa + dx[i];
            int y = ya + dy[i];
            if (x >= 1 && x <= N && y >= 1 && y <= N) {
                grid[x][y] = 1;
            }
        }

        int[] da = {-1, 1, 0, 0};
        int[] db = {0, 0, -1, 1};

        for (int i = 0; i < 4; i++) {
            for (int k = 1; k <= N; k++) {
                int x = xb + da[i] * k;
                int y = yb + db[i] * k;
                if (x < 1 || y < 1 || x > N || y > N || grid[x][y] != 0) {
                    break;
                }
                grid[x][y] = 1;
            }
        }

        int ans = 0;
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= N; j++) {
                if (grid[i][j] == 0) {
                    ans++;
                }
            }
        }
        System.out.println(ans);
    }
}

Python：[此代码未进行大量数据的测试，仅供参考]

N = 8
dx = [-1, 1, -1, 1, -2, 2, -2, 2]
dy = [2, 2, -2, -2, 1, 1, -1, -1]
grid = [[0 for _ in range(N + 2)] for _ in range(N + 2)]

xa, ya, xb, yb = map(int, input().split())
grid[xa][ya] = grid[xb][yb] = 2

for i in range(N):
    x = xa + dx[i]
    y = ya + dy[i]
    if 1 <= x <= N and 1 <= y <= N:
        grid[x][y] = 1

da = [-1, 1, 0, 0]
db = [0, 0, -1, 1]

for i in range(4):
    for k in range(1, N + 1):
        x = xb + da[i] * k
        y = yb + db[i] * k
        if x < 1 or y < 1 or x > N or y > N or grid[x][y] != 0:
            break
        grid[x][y] = 1

ans = 0
for i in range(1, N + 1):
    for j in range(1, N + 1):
        if grid[i][j] == 0: