Question

我有一个功课需要在Java中实现数独求解器的顺序和并行版本（使用ForkJoin Framework作为并行版）。

我写了顺序一个，它工作正常。算法的想法是一个简单的回溯练习：对于每个单元格（从表格的左上角开始）尚未填充，用所有 legal 填充它（按顺序，一次一个）候选者（整数从1到9）直到你到达矩阵的结尾（第9行第9行）。如果已达到最后，则递增解决方案编号。

我想实现并行版本只为每个为特定单元格找到的有效候选者生成一个新线程，然后等待它们。它似乎无法工作，我无法找到原因。

我发布了应该完成整个工作的课程，希望找到一个好的建议：

class SolveSudoku extends RecursiveAction{
    private int i, j;
    private int[][] cells;

    SolveSudoku(int i, int j, int[][] cells){
        this.i = i;
        this.j = j;
        this.cells = cells;
    }

    @Override
    protected  void compute(){
        if (j == 9) {
            j = 0;
            if (++i == 9){
                solutions++;
                System.out.println(solutions);
                return;
            }
        }

        if (cells[i][j] != 0 ){                             // skip filled cells
            SolveSudoku s =  new SolveSudoku(i, j+1, cells);
            s.compute();
            return;
        }


        ArrayList<Integer> vals = new ArrayList<Integer>();
        for (int val = 1; val <= 9; val++)                 // try all the legal candidates for i, j
            if (legal(i,j,val,cells))
                vals.add(val);


        if(vals.size() == 1){                            // only one, no new threads
            cells[i][j] = vals.get(0);
            new SolveSudoku(i, j+1, cells).compute();
        }
        else{
            SolveSudoku threads[] = new SolveSudoku[vals.size()];
            int n = 0;
            int first;
            for(int k=0; k<vals.size(); k++){
                if(k == vals.size()-1){
                    cells[i][j] = vals.get(k);
                    threads[n] = new SolveSudoku(i, j+1, cells);
                    threads[n].compute();
                }
                else{
                    cells[i][j] = vals.get(k);
                    threads[n] = new SolveSudoku(i, j+1, cells);
                    threads[n].fork();
                }
                n++;
            }


            for(int k=0; k<threads.length-1; k++)
                if(k != vals.size()-1)
                    threads[k].join();

        }

        cells[i][j] = 0;
        return;
    }}

new ForkJoinPool().invoke(new SolveSudoku(0, 0, M)); // where *M* is a sudoku instance to solve where all the unfilled cells contain '0'

Answer 1

首先，您应该考虑如果一个线程完成它的工作会发生什么。您应该注意它尝试将单元格重置为0，但是如果有另一个子线程与单元格一起工作会怎么样？

显然，如果访问同一Cell的另一个线程试图检查它是否合法，它可能必须输入一个错误的值，因为另一个线程将零返回其中！

Answer 2

我认为您应该将数组的副本传递给新线程。在您的代码中，您将相同的数组传递给所有线程，并尝试同时插入正确的值。

Java中的并行数独求解器

2 个答案: