算法学习（十一）

1.King and Queen

说明：像国际象棋这样的游戏算法编程有两个主要任务：

1.评估位置，检查哪些部分可以走；

2.构造一种极小的算法来选择移动到最优值的位置。

让我们先来解决一个简单的问题：有一个棋盘，有8 x 8个方格。上面有白色的国王和黑色的女王。检查女王是否能吃掉国王。

女王可以垂直、水平的或沿任何两个对角线移动到任何距离。

8  - Q - - - - - -     - - - - - - - -
7  - - - - Q - - -     - - - - - - Q -
6  - - - - - - - -     - - - - - - - -
5  - - - - - - - -     - - - Q - - - -
4  - K - - - - Q -     - - Q - - - - -
3  - - - - - - - -     - - - - - - - -
2  - - - Q - - - -     - - - - - K - -
1  - - - - - - - -     - Q - - - - - -
   a b c d e f g h     a b c d e f g h

看看这两个例子，用图表绘制的板。在这两种情况下，国王都用字母K表示，而字母Q则显示了女王的不同位置。

在左边的棋盘中，国王可以被四个女王中的任何一个“吃掉”；

在正确的棋盘中，国王处于安全的位置——四个女王中没有一个能吃掉他。

输入数据：第一行中包含测试用例数。

下面一行描述每个test_case的国王和王后的位置，通过指定它们的方块(国王是第一个)。

答案：每一个测试给出一个字母Y或N，这代表国王能否被吃掉。用空格间隔。

例如：

input data:
8
b4 b8
b4 e7
b4 d2
b4 g4
f2 b1
f2 c4
f2 d5
f2 g7

answer:
Y Y Y Y N N N N

测试数据：

26
f4 e8
c4 b6
h2 h8
h8 f8
e8 d3
a8 c6
g7 h8
d3 e2
g1 a2
e2 g5
c7 d3
f2 b3
a6 e2
e7 g4
f7 c2
b7 c1
h3 b5
e1 a7
g4 b5
e4 g6
a3 h5
b6 h7
e3 h6
a3 f1
e7 e1
g6 h6

代码如下：

horizontally = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']  # 水平的坐标表示

test_cases = int(input())  # 测试用例数

for i in range(test_cases):
    data = input().split()
    K, Q = data[0], data[1]  # 得到K,Q的坐标
    if K[0] and Q[0] in horizontally:
        if K[0] == Q[0] or K[1] == Q[1]:  # 当K,Q横纵坐标有一个相同，则为Y
            print('Y', end=' ')
        elif abs(horizontally.index(K[0]) - horizontally.index(Q[0])) == abs(int(K[1]) - int(Q[1])):
            print('Y', end=' ')   # 当两坐标的横纵坐标之差相等，也为Y
        else:   # 其他情况为N
            print('N', end=' ')

输出：N N Y Y N Y Y Y N N N N Y N N N N N N Y N N Y N Y Y

2.Cards Shuffling（洗牌问题）

说明：对于任何类型的纸牌游戏来说，洗牌是很重要的。因为只有很少的编程语言有内置函数来随机地对数组进行随机处理(比如PHP)，所以有必要学习一些有用的算法。

用下列符号来描述卡牌：

ranks: A, 2, 3, 4, 5, 6, 7, 8, 9, T, J, Q, K
suits: C, D, H, S

CQ是“梅花Q”，HT是“心桃10”，D2是“方块2”，SA是“黑桃A”。
总共有52张牌，所以在洗牌之前，它们应该被放入52个元素的数组中。该数组的初始顺序如下：13张梅花牌，13张方块牌，13张红心牌，最后13张黑桃牌。每个花色卡的内部都是由Ace排列到King的，所以整个甲板看起来是这样的：

[ CA, C2, C3, ..., CQ, CK, DA, D2, ..., DK, HA, H2, ..., HK, SA, S2, ..., SK ]

然后你应该对每张卡片产生一些随机数在0。将这张牌与另一张牌交换，占据所选的位置(让数组的索引从0开始)。

FOR i = 0 ... 51 :
    LET j = RANDOM(0 ... 51)
    SWAP deck[i] WITH deck[j]

例如，我们取第一张卡CA，并为它生成随机值15，这意味着该卡应该移动到位置15，D3在那里，D3应该被移回位置0。然后我们从位置1中取出C2然后生成下一个随机数50，所以C2和平方交换。等等。

你将会得到一个非负整数随机数字的序列——如果它们大于必要的数字，那么就把它们调整到需要的范围，取52的模数。

输入数据：将包含52个非负整数，您应该使用它们来像描述的那样进行洗牌。

答案：应该包含洗牌数组的卡片，和空格分开。

例如：

input data:
5814 1316 2080 2712 0 647 8098 315 44 6354 7867 100 61 763 6731 685 42 9309 569 92 701 562 85 8311 698 220 929 71 684 518 113 61 19 168 745 16 655 9548 6018 2686 25 785 81 721 964 85 44 614 4 509 8708 19

answer:
C5 D5 S4 C8 CQ S3 HK C9 H3 H6 D3 ST DT HT C6 CK DA H9 SJ SK DK C2 DQ S5 H4 D7 S7 S2 C4 D9 CT HJ HQ D2 SA CA H5 H2 C7 D4 CJ D6 S9 HA S8 D8 S6 SQ C3 DJ H8 H7

测试数据：

0 537 320 6335 7581 140 4682 9944 2755 438 897 48 17 406 82 2368 1402 3179 524 3802 37 81 4993 68 6792 32 206 1300 61 43 950 244 44 550 5140 2434 4513 72 4007 726 51 66 8439 9450 956 872 363 100 679 436 48 739

代码如下：

ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K']
suits = ['C', 'D', 'H', 'S']
start_deck = []  
for i in range(52):
    suit = i // 13
    rank = i % 13
    card = suits[suit] + ranks[rank]
    start_deck.append(card)   # 构造初始化牌组，按要求排好

num = input().split()
nums = []
for i in num:
    nums.append(int(i) % 52)  # 得到随机的位置数

m = 0
for n in range(52):
    start_deck[n], start_deck[nums[m]] = start_deck[nums[m]], start_deck[n]  # 按规则交换赋值卡牌
    m += 1

for i in start_deck:  # 格式化输出卡牌
    print(i, end=' ')

输出：H2 CT C7 S9 D6 HJ D7 C8 SK D3 DA S8 C2 S4 H6 HT DJ CK S3 C9 SJ H4 D5 SQ H7 DQ D4 CA DT C4 H8 C6 S6 H5 DK CJ C5 HQ D9 HA S7 D2 H3 S5 D8 C3 S2 CQ SA H9 HK ST