2020软件工程作业03

这个作业属于哪个课程	2018级软件工程 - 中南林业科技大学涉外学院
这个作业要求在哪里	2020软件工程作业03
这个作业的目标	通过习题熟悉PSP流程
其他参考	【1】数独~编程作业 【2】数独(Sudoku)游戏之我见

 PSP表格

 

 

 注：加号代表在实际操作时未准确计时，只是一个保守的估计。

 

解题思路

作为一个算法菜鸡，看完题目的第一感觉就是.....没看懂。反复阅读后才冒出一个暴力扫描的想法。正当准备开始编码的时候，我突然看到题目描述中提到 “输入保证有且仅有一个解” ，我才意识到，数独宫格是拥有唯一解的（或者只有少数几个数字不同）。这意味着若是开始的几个格子未能填入正确答案，则后面的格子会出现无数可填的情况（又暴露了没玩过数独的事实😱）。若是出现了无数可填的情况则说明之前有答案是错误的，则需要回溯。可以用DFS来逐个试探答案。最终走到最后一个格子时。意味着所有的格子都已填入了正确答案，此时就可以把输出了。

 

设计实现

Sudoku.java

import java.io.*;

public class Sudoku {
    public static void main(String[] args){
        String inputPath = "";
        String outputPath = "";
        Integer numOfBoard = null;
        Integer size = null;
        for(int i=0;i<args.length;i++){
            if(args[i].equals("-i")){
                inputPath = args[i+1];
            }
            if(args[i].equals("-o")){
                outputPath = args[i+1];
            }
            if(args[i].equals("-m")){
               size = Integer.valueOf(args[i+1]);
            }
            if(args[i].equals("-n")){
                numOfBoard = Integer.valueOf(args[i+1]);
            }
        }

        if(inputPath.equals("") && outputPath.equals("") && numOfBoard == null && size == null){
            System.out.println("Parameter Error.");
            return;
        }

        try {
            SudokuUtil sudokuUtil = new SudokuUtil(size, numOfBoard, outputPath, inputPath);
            sudokuUtil.run();
        }catch (Exception e){
            System.out.println("Parameter Error,Please Check Your Format.");
        }

    }
}

 

首先是主函数入口类，这里主要包括的是输入参数验证以及错误处理。

SudokuUtil.java

package New.Learn;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;

public class SudokuUtil {

    Integer size;
    Integer numOfBoard;
    String outputPath;
    String inputPath;
    ArrayList<Integer[][]> arrayNumList = new ArrayList<Integer[][]>();
    //ArrayList用于容纳多个数独盘的结果

    public Integer getSize() {
        return size;
    }

    public Integer getNumOfBoard() {
        return numOfBoard;
    }

    public String getOutputPath() {
        return outputPath;
    }

    public String getInputPath() {
        return inputPath;
    }

    SudokuUtil(Integer size, Integer numOfBoard, String outputPath, String inputPath) {
        this.size = size;
        this.numOfBoard = numOfBoard;
        this.outputPath = outputPath;
        this.inputPath = inputPath;
    }

    public String inputFile(String filePath) throws IOException {
        File file = new File(filePath);
        if (file.isFile() && file.exists()) {
            InputStreamReader read =
                    new InputStreamReader(new FileInputStream(file), StandardCharsets.UTF_8);
            BufferedReader bufferedReader = new BufferedReader(read);
            String lineTxt = null;
            StringBuilder result = new StringBuilder();
            while ((lineTxt = bufferedReader.readLine()) != null) {
                result.append(lineTxt);
                result.append("\n");
            }
            read.close();
            return result.toString();
        } else {
            System.out.println("No such file or directory");
            System.exit(0);
        }
        return null;
    }

    public void outputFile(Integer size, ArrayList<Integer[][]> arrayNum, String filePath) throws IOException {
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
        for (Integer[][] num : arrayNum) {
            for (int i = 0; i < size; i++) {
                for (int j = 0; j < size; j++) {
                    bufferedWriter.write(num[i][j].toString());
                    bufferedWriter.write(" ");
                }
                bufferedWriter.newLine();
            }
            bufferedWriter.newLine();
        }
        bufferedWriter.close();
    }

    public ArrayList<Integer[][]> inData(Integer numOfBoard, Integer size, String input) {
        //分割多个数独盘
        String[] board = input.split("\n\n");
        ArrayList<Integer[][]> inputArrayNum = new ArrayList<Integer[][]>();

        for (int k = 0; k < numOfBoard; k++) {
            Integer[][] num = new Integer[size][size];

            String[] line = board[k].split("\n");
            for (int i = 0; i < size; i++) {
                String[] single = line[i].split(" ");
                for (int j = 0; j < size; j++) {
                    num[i][j] = Integer.valueOf(single[j]);
                }
            }
            inputArrayNum.add(num);
        }
        return inputArrayNum;
    }

    public void pr(Integer size, Integer[][] num) {
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                System.out.print(num[i][j]);
                System.out.print(" ");
            }
            System.out.print("\n");
        }
        System.out.println("-----------------------");
    }

    public boolean check(Integer size, Integer[][] num, Integer tar, Integer col, Integer line) {
        for (int i = 0; i < size; i++) {
            if (num[i][line].equals(tar) || num[col][i].equals(tar)) {
                return false;
            }
        }
        if (size == 4) {
            //可以把宫格看做是一个大的块
            int cellx = line / 2;
            int celly = col / 2;

            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 2; k++) {
                    if (num[celly * 2 + j][cellx * 2 + k].equals(tar)) {
                        return false;
                    }
                }
            }
        } else if (size == 6) {
            int cellx = line / 3;
            int celly = col / 2;

            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 3; k++) {
                    if (num[celly * 2 + j][cellx * 3 + k].equals(tar)) {
                        return false;
                    }
                }
            }
        } else if (size == 8) {
            int cellx = line / 2;
            int celly = col / 4;

            for (int j = 0; j < 4; j++) {
                for (int k = 0; k < 2; k++) {
                    if (num[celly * 4 + j][cellx * 2 + k].equals(tar)) {
                        return false;
                    }
                }
            }
        } else if (size == 9) {
            int cellx = line / 3;
            int celly = col / 3;

            for (int j = 0; j < 3; j++) {
                for (int k = 0; k < 3; k++) {
                    if (num[celly * 3 + j][cellx * 3 + k].equals(tar)) {
                        return false;
                    }
                }
            }
        }
        return true;
    }

    public void write(Integer size, Integer[][] num, Integer wy, Integer wx) {
        Integer nextx = wx + 1;
        Integer nexty = wy;

        if (nextx >= size) {
            nextx = 0;
            nexty++;
        }

        if (wy.equals(size) && wx.equals(0)) {
            pr(size, num);
            Integer[][] tempArray = new Integer[size][size];
            for (int i = 0; i < size; i++) {
                for (int j = 0; j < size; j++) {
                    tempArray[i][j] = num[i][j];
                }
            }
            //若直接传递num，则该num为递归栈顶值，因为只是传递了num地址
            //因而需要进行一次深拷贝
            arrayNumList.add(tempArray);
            return;
        }
        if (!num[wy][wx].equals(0)) {
            //若该项不为0，则递归走下一步
            write(size, num, nexty, nextx);
        } else {
            for (int x = 1; x <= size; x++) {
                if (check(size, num, x, wy, wx)) {
                    num[wy][wx] = x;
                    //DFS递归走下一步
                    write(size, num, nexty, nextx);
                    num[wy][wx] = 0;
                }
            }

        }

    }

    public void run() throws IOException {
        String in = inputFile(inputPath);
        ArrayList<Integer[][]> inArrayNum = inData(numOfBoard, size, in);
        for (Integer[][] num : inArrayNum) {
            write(size, num, 0, 0);
        }
        outputFile(size, arrayNumList, outputPath);
    }
}

 

SudokuUtil类是真正的计算数独的部分。方法调用关系如下。

 

•  inputFile 方法是文件读取方法。
•  inData 方法是将读取的字符串处理成为数组列表。
•  write 方法就是核心算法DFS部分，通过递归回溯生成最终答案。
•  check 方法则是用于检测该数字是否能在当前宫格内填入。
•  inputFile 方法是文件输出方法。

 

程序测试

九宫格

 

 八宫格

 七宫格

 

 六宫格

 

 五宫格

 

 四宫格

 

 

 三宫格

程序性能分析与优化

 JProfiler分析结果

 

 

 

 

 

关于优化

 使用回溯过深的递归调用必然会使用大量的栈空间，这样的算法效率显然是不高的。

  根据某个师傅的博客，还是有不少方法可以优过回溯的。可惜的是这位师傅没有自己造线性规划轮子而是调用的库函数。

 

 

除此之外，暂时未找到其他更优解

心路历程与收获

   这个作业最大的感受就是有点杀鸡用牛刀的感觉。我非常能理解PSP表格中各个项目对应软件开发的各个流程。但我认为PSP更适合做需要长期维护的项目，而不是像这次作业的算法练习题。例如算法题不需要非常详细的设计文档，往往三言两语就能将核心思想交代清楚、算法题不需要反复的review，因为算法题往往目标是更高效的计算某个东西而不是更好的代码可读性（当然这也是非常重要的，但许多算法高手写出来的代码通常可读性较差）和更好的可维护性等等。

  回到这道题上，这道题的编码时间其实是非常短的。但是因为递归不太好调试的原因（这也是我不喜欢递归的原因之一），我一步步调试了很久才调出来一些细节问题。期间参考了【2】数独(Sudoku)游戏之我见 判断方法，比我的妙多了🤣，虽然最后没用。而后在做文件IO和核心整合的时候遇到了一个递归后无法传最终值的问题。直到参考了【1】数独~编程作业 这篇文章使用的方法，瞬间明白了，相当于深拷贝之后再传递出来，再递归栈中传递的对象都是传递地址但递归栈再最后弹出时传递的值会回到栈底即初始状态。