Question

我试图解决以下数学问题：

标准国际象棋的骑士坐在棋盘上如下

0  1  2  3
4  5  6  7
8  9  10 11
12 13 14 15

骑士从正方形开始＆＃34; 0＆＃34;并根据国际象棋中允许的移动跳转到其他方格（这样在每个空间，它有两到四个有效移动）。骑士在每次跳跃中随机均匀地选择允许的移动，并跟踪其落地的键的运行总和 S 。

一个。在 T = 16次移动之后，数量S modulo 13的平均值是多少？

湾什么是标准偏差？

℃。 T = 512移动后， S 模数311的平均值是多少？

d。什么是标准偏差？

即在 T = 16次移动之后，如果它可以被13整除，则总和可被5整除的概率是多少？

F。在 T = 512移动之后，总和可以被7整除的概率是多少，因为它可以被43整除？

到目前为止，我已经编写了一个程序来计算 S 的概率质量函数（pmf）：

from itertools import chain, product
import numpy as np
import pytest


def index_to_grid(index):
    return index // 4, index % 4

def grid_to_index(i, j):
    return 4*i + j

def in_board(i, j):
    return (0 <= i < 4) and (0 <= j < 4)

def available_moves(index):
    pos = np.array(index_to_grid(index))
    knight_hops = [np.array(hop) for hop in chain(product([-2, 2], [-1, 1]), product([-1, 1], [-2, 2]))]
    return set(grid_to_index(*newpos) for newpos in pos + knight_hops if in_board(*newpos))

def transition_matrix():
    T = np.zeros((16, 16))
    for i in range(16):
        js = available_moves(i)
        for j in js:
            T[i, j] = 1/len(js)
    return T

def calculate_S(N):
    '''Calculate the matrix S(i, n) of the expected value of S given initial state i after n transitions'''
    T = transition_matrix()
    S = np.zeros((16, N+1))
    for i in range(16):
        S[i, 0] = i

    # Use a bottom-up dynamic programming approach
    for n in range(1, N+1):
        for i in range(16):
            S[i, n] = sum(T[i, j] * (i + S[j, n-1]) for j in range(16))
    return S

以下是我用于检查目前结果的一些单元测试：

def test_available_moves():
    assert available_moves(0) == {6, 9}
    assert available_moves(1) == {8, 10, 7}
    assert available_moves(10) == {4, 1, 12, 3}

def test_transition_matrix():
    T = transition_matrix()
    assert T[0, 6] == T[0, 9] == 1/2
    assert all(T[0, j] == 0 for j in set(range(16)) - {6, 9})
    assert T[1, 8] == T[1, 10] == T[1, 7] == 1/3
    assert all(T[1, j] == 0 for j in set(range(16)) - {8, 10, 7})
    assert T[10, 4] == T[10, 1] == T[10, 12] == T[10, 3] == 1/4
    assert all(T[10, j] == 0 for j in set(range(16)) - {4, 1, 12, 3})

def test_calculate_S():
    S = calculate_S(2)
    assert S[15, 1] == 15 + 1/2 * 6 + 1/2 * 9
    assert S[4, 1] == 4 + 1/3 * 2 + 1/3 * 10 + 1/3 * 13
    assert S[15, 2] == 15 + 1/2 * 9 + 1/2 * (1/4 * 0 + 1/4 * 2 + 1/4 * 7 + 1/4 * 15) \
                          + 1/2 * 6 + 1/2 * (1/4 * 0 + 1/4 * 8 + 1/4 * 13 + 1/4 * 15)


if __name__ == "__main__":
    pytest.main([__file__, "-s"])

例如，要计算 T = 16之后 S 本身的预期值，我会评估calculate_S()[0, 16]。

问题在于我无法将其概括为预期值S % 13（ S modulo 13）。考虑到13（及其后续问题中的所有＆＃39;等等）都是素数，我怀疑使用＆＃39; primeness＆＃39;有一个关键的观察结果，但到目前为止我还没有＃39;弄明白了。有什么想法吗？

Answer 1

诀窍是使用动态编程，并对所有计算进行修改。对于每一步，你需要它在每个方格的概率，其中一些和mod是一些数字。

例如对于问题f，您需要进行总和计算mod 7*43 = 301。因此，对于每个步骤，您需要处于所有16*301 = 4816可能的位置组合和运行总和mod 301的概率。

这使您所需的转换矩阵更大。

如何计算随机变量模N的概率质量函数，其中N是素数？

1 个答案: