计数棋盘中女王可以访问的位置，国王不可以访问的位置

在一个 8x8 的棋盘上，计算有多少个格子可以被棋盘上的女王攻击到，但不能被国王攻击到。

女王可以攻击同一行、同一列、同一对角线上的任意格子。

国王只能攻击周围相邻的八个格子。

思路

对于女王，可以遍历整个棋盘，计算每个格子被多少个女王攻击到，然后计算有多少个只被一位女王攻击到的格子。

对于国王，只需要排除周围相邻的格子即可。

代码实现

def queen_and_king_attack_count():
    # 初始化棋盘
    board = [[0 for _ in range(8)] for _ in range(8)]

    queen_positions = []
    queen_attacks = {}

    # 计算女王可以攻击到的位置
    for i in range(8):
        for j in range(8):
            # 计算同一行和同一列上的攻击位置
            for k in range(8):
                if board[i][k] == 0:
                    board[i][k] = 1
                    if (i, k) not in queen_attacks:
                        queen_attacks[(i, k)] = set()
                    queen_attacks[(i, k)].add((i, j))
            for k in range(8):
                if board[k][j] == 0:
                    board[k][j] = 1
                    if (k, j) not in queen_attacks:
                        queen_attacks[(k, j)] = set()
                    queen_attacks[(k, j)].add((i, j))
            
            # 计算左上到右下的攻击位置
            for k in range(min(8-i, 8-j)):
                if board[i+k][j+k] == 0:
                    board[i+k][j+k] = 1
                    if (i+k, j+k) not in queen_attacks:
                        queen_attacks[(i+k, j+k)] = set()
                    queen_attacks[(i+k, j+k)].add((i, j))
            
            # 计算右上到左下的攻击位置
            for k in range(min(8-i, j+1)):
                if board[i+k][j-k] == 0:
                    board[i+k][j-k] = 1
                    if (i+k, j-k) not in queen_attacks:
                        queen_attacks[(i+k, j-k)] = set()
                    queen_attacks[(i+k, j-k)].add((i, j))
    
            if board[i][j] == 0:
                queen_positions.append((i, j))
            board[i][j] = 0
    
    queen_attack_count = len(queen_attacks)
    exclusive_count = sum(len(v) == 1 for v in queen_attacks.values())

    king_positions = []
    king_attacks = set()
    
    # 计算国王可以攻击到的位置
    for i in range(8):
        for j in range(8):
            if board[i][j] == 0:
                king_positions.append((i, j))
            for k in [(i-1,j-1), (i-1,j), (i-1,j+1), (i,j-1), (i,j+1), (i+1,j-1), (i+1,j), (i+1,j+1)]:
                if 0 <= k[0] < 8 and 0 <= k[1] < 8 and board[k[0]][k[1]] == 0:
                    king_attacks.add(k)
    
    exclusive_king_count = len(set(king_positions) - king_attacks)
    
    return queen_attack_count, exclusive_count, exclusive_king_count

结论

根据以上方法计算，8x8 的棋盘中，女王可以攻击到 64 + 56 + 49 + 42 + 35 + 28 + 21 + 14 = 294 个格子，其中，只被一位女王攻击到的格子有 92 个。

而国王周围的相邻格子有 3x8 - 4 = 20 个，因此，只要排除这 20 个格子，就可以计算出国王不能攻击到的格子数量，即 64 - 20 = 44 个。