Python multiprocessing 使用多处理的数独解决方案

我尝试了使用回溯的数独解决方案，但给出输出大约需要12秒的时间。我试图实现一种多处理技术，但它比回溯要花费更多的时间。我从来没有完全跑过--太慢了。请说明我遗漏了什么？如果有人也能告诉我如何通过我的GPU运行，那就更好了。（使用CUDA）

import concurrent.futures
导入副本
A=[[0]*9表示范围（9）]
A[0][6]=2
A[1][1]=8
A[1][5]=7
A[1][7]=9
A[2][0]=6
A[2][2]=2
A[2][6]=5
A[3][1]=7
A[3][4]=6
A[4][3]=9
A[4][5]=1
A[5][4]=2
A[5][7]=4
A[6][2]=5
A[6][6]=6
A[6][8]=3
A[7][1]=9
A[7][3]=4
A[7][7]=7
A[8][2]=6
董事会=[A]
L=[]
对于范围（9）内的i：
对于范围（9）内的j：
如果A[i][j]==0：
L.append（[i，j]）
def RC_检查（A、值、N）：
全局L
i、 j=L[N]
对于范围（9）内的x：
如果A[x][j]==值：
返回错误
如果[i][x]==值：
返回错误
返回真值
def平方检查（A，值，N）：
全局L
i、 j=L[N]
十、 Y=int（i/3）*3，int（j/3）*3
对于范围内的x（x，x+3）：
对于范围内的y（y，y+3）：
如果[x][y]==值：
返回错误
返回真值
def新_板（板，N）：
全局L
i、 j=L[N]
董事会=[]
以concurrent.futures.ProcessPoolExecutor（）作为执行器：
RC_进程=executor.map（RC_检查，[Board]*10，列表（范围（1,10）），[N]*10）
Square\u Process=executor.map（Square\u Check，[Board]*10，list（范围（1,10）），[N]*10）
对于枚举（zip（RC_进程，Square_进程））中的值（RC_进程，Square_进程）：
如果采用RC_工艺和方形_工艺：
板[i][j]=值+1
板。附加（副本。深度副本（板））
返回板
def Solve_板（板，N）：
结果=[]
以concurrent.futures.ProcessPoolExecutor（）作为执行器：
进程=执行器.map（新的_板，板，[N]*len（板））
对于正在进行中的新电路板：
如果是len（新电路板）：
结果：扩展（新的_板）
返回结果
如果名称=“\uuuuu main\uuuuuuuu”：
N=0
当N

多重处理不是万能的。在大多数情况下，回溯比并行穷举搜索更有效。我试着在我有32核64线程的PC上运行这段代码，但这需要很长时间

你看起来想用GPGPU来解决这个问题，但我不适合，因为电路板的状态取决于以前的状态，所以不能有效地分割计算。

多处理不是万能的。在大多数情况下，回溯比并行穷举搜索更有效。我试着在我有32核64线程的PC上运行这段代码，但这需要很长时间

---

您似乎希望使用GPGPU解决此问题，但我不适合，因为电路板的状态取决于以前的状态，因此无法有效地拆分计算。

非常感谢您的澄清，但因为大部分时间都用于计算下一个可用的电路板。我们可以使用GPU并行计算下一个可用的电路板，直到找到解决方案。那不是很有效吗？我认为GPU要快得多，所以在GPU上运行它应该能够节省大量的时间。或者即使我们这样做了，也要比回溯花费更长的时间？我不是这个领域的专家，但我假设数独输入模式的数量要比GPU单元的数量多得多。甚至只有4608个内核。另一方面，如果彻底搜索。能做到这一点的一定只有量子计算机。非常感谢您的澄清，但由于大部分时间都在计算下一个可用的电路板。我们可以使用GPU并行计算下一个可用的电路板，直到找到解决方案。那不是很有效吗？我认为GPU要快得多，所以在GPU上运行它应该能够节省大量的时间。或者即使我们这样做了，也要比回溯花费更长的时间？我不是这个领域的专家，但我假设数独输入模式的数量要比GPU单元的数量多得多。甚至只有4608个内核。另一方面，如果彻底搜索。只有量子计算机才能做到这一点。

import concurrent.futures
import copy

A = [[0]*9 for _ in range(9)]
A[0][6] = 2
A[1][1] = 8
A[1][5] = 7
A[1][7] = 9
A[2][0] = 6
A[2][2] = 2
A[2][6] = 5
A[3][1] = 7
A[3][4] = 6
A[4][3] = 9
A[4][5] = 1
A[5][4] = 2
A[5][7] = 4
A[6][2] = 5
A[6][6] = 6
A[6][8] = 3
A[7][1] = 9
A[7][3] = 4
A[7][7] = 7
A[8][2] = 6

Boards = [A]

L = []
for i in range(9):
    for j in range(9):
        if A[i][j] == 0:
            L.append([i,j])
            
def RC_Check(A,Value,N):
    global L
    i,j = L[N]
    
    for x in range(9):
        if A[x][j] == Value:
            return False
        if A[i][x] == Value:
            return False
    return True

def Square_Check(A,Value,N):
    global L
    i,j = L[N]
    
    X, Y = int(i/3)*3,int(j/3)*3
    for x in range(X,X+3):
        for y in range(Y,Y+3):
            if A[x][y] == Value:
                return False
    return True

def New_Boards(Board,N):
    global L
    i,j = L[N]

    Boards = []
    with concurrent.futures.ProcessPoolExecutor() as executor:
        RC_Process = executor.map(RC_Check,[Board]*10,list(range(1,10)),[N]*10)
        Square_Process = executor.map(Square_Check,[Board]*10,list(range(1,10)),[N]*10)

        for Value, (RC_Process, Square_Process) in enumerate(zip(RC_Process,Square_Process)):
            if RC_Process and Square_Process:
                Board[i][j] = Value+1
                Boards.append(copy.deepcopy(Board))

    return Boards

def Solve_Boards(Boards,N):
    Results = []
    with concurrent.futures.ProcessPoolExecutor() as executor:
        Process = executor.map(New_Boards,Boards,[N]*len(Boards))

        for new_boards in Process:
            if len(new_boards):
                Results.extend(new_boards)

    return Results

if __name__ == "__main__":
    N = 0
    while N < len(L):
        Boards = Solve_Boards(Boards,N)
        N+=1
        print(len(Boards),N)
print(Boards)