Python生成n阶行列唯一值矩阵及动态组合实现咨询

1. 构造n×n的1~n唯一值矩阵（拉丁方） #

你要的其实是拉丁方——每行每列都包含1到n的所有数字且无重复。这里有两种实用的实现方式：

方法1：纯Python循环移位实现 #

最直观的思路是从第一行的1~n开始，之后每一行把上一行的元素循环移位，这样天然保证每行每列的唯一性：

def create_latin_square(n):
    matrix = []
    current_row = list(range(1, n+1))
    matrix.append(current_row.copy())
    for _ in range(1, n):
        # 循环右移一位，也可以改成左移：current_row = current_row[1:] + current_row[:1]
        current_row = [current_row[-1]] + current_row[:-1]
        matrix.append(current_row)
    return matrix

# 测试n=3的情况
print(create_latin_square(3))
# 输出：[[1, 2, 3], [3, 1, 2], [2, 3, 1]]

方法2：用numpy快速生成 #

如果习惯用numpy库，代码会更简洁，利用数组的内置移位操作：

import numpy as np

def create_latin_square_np(n):
    base_array = np.arange(1, n+1)
    return np.array([np.roll(base_array, i) for i in range(n)])

# 测试n=3
print(create_latin_square_np(3))
# 输出：
# [[1 2 3]
#  [3 1 2]
#  [2 3 1]]

2. 基于列表P和D生成不同的n阶唯一值矩阵 #

假设P是每行的基准排列（要求是1~n的唯一值列表），D的元素控制每行的移位方向/步数，我们可以结合随机化来保证每次生成的矩阵组合不同。下面是具体实现：

实现思路 #

1. 以P为基准，根据D中对应元素的移位步数生成每行
2. 加入随机化调整（移位偏移、打乱基准排列），确保每次输出不同
3. 内置合法性校验，保证生成的矩阵满足每行每列唯一的要求

代码实现 #

import random

def generate_unique_matrix(n, P, D):
    # 先校验输入合法性
    assert sorted(P) == list(range(1, n+1)), "P必须是1到n的唯一值列表"
    assert len(D) == n, "D的长度必须等于n"
    
    matrix = []
    temp_p = P.copy()
    for i in range(n):
        # 处理移位步数，兼容负数
        shift_step = D[i] % n
        # 加入随机偏移，保证每次生成不同组合
        random_offset = random.randint(0, n-1)
        total_shift = (shift_step + random_offset) % n
        
        # 生成当前行：循环移位
        current_row = temp_p[-total_shift:] + temp_p[:-total_shift] if total_shift != 0 else temp_p.copy()
        matrix.append(current_row)
        # 打乱基准排列，为下一行生成不同基础
        random.shuffle(temp_p)
    
    # 校验矩阵合法性（可选，用于调试）
    def is_valid(mat):
        for row in mat:
            if len(set(row)) != n:
                return False
        for col in zip(*mat):
            if len(set(col)) != n:
                return False
        return True
    
    # 极端情况如果生成不合法，重新生成
    if not is_valid(matrix):
        return generate_unique_matrix(n, P.copy(), D)
    
    return matrix

# 测试n=3的情况，随便选一组P和D
P = [1, 2, 3]
D = [1, -1, 2]
print(generate_unique_matrix(3, P, D))
# 示例输出（每次运行不同）：[[2, 3, 1], [3, 1, 2], [1, 3, 2]]

可选调整 #

如果不需要随机化，直接去掉random_offset和random.shuffle(temp_p)即可，严格按照P和D的规则生成矩阵。

内容的提问来源于stack exchange，提问作者Prasad Honrao