编程暴力破解一笔画游戏。
    github地址：https://github.com/NPCDW/Unicursal
    demo地址：https://npcdw.github.io/Unicursal/

    1. public class Unicursal {
    2.     // 步骤从1开始
    3.     private static int count = 1;
    5.     /**
    6.      * 寻路 每走一步都会有三个方向可以走，如果无路可走，遍历一下是否还有未走的格子
    7.      * 如果没有，则寻路成功，打印出路径，如果有，则退一步，走其他方向
    8.      * 
    9.      * @param x 起始位置第几行
    10.      * @param y 起始位置第几列
    11.      * @param matrix 棋盘数组（0代表可以走的路，-1代表障碍，1,2,3....代表路径）
    12.      */
    13.     private static void pathfind(int x,int y,int[][] matrix){
    14.         matrix[x][y] = count++;
    15.         // 如果下一步没有超出y的最大边界，并且下一步可以走
    16.         if (y+1 < matrix[x].length && matrix[x][y+1]==0){
    17.             pathfind(x,y+1,matrix);
    18.         }
    19.         // 如果下一步没有超出y的最小边界，并且下一步可以走
    20.         if (y-1 >= 0 && matrix[x][y-1]==0){
    21.             pathfind(x,y-1,matrix);
    22.         }
    23.         // 如果下一步没有超出x的最大边界，并且下一步可以走
    24.         if (x+1 < matrix.length && matrix[x+1][y]==0){
    25.             pathfind(x+1,y,matrix);
    26.         }
    27.         // 如果下一步没有超出x的最小边界，并且下一步可以走
    28.         if (x-1 >= 0 && matrix[x-1][y]==0){
    29.             pathfind(x-1,y,matrix);
    30.         }
    32.         // 走到此，说明已经无路可走，遍历一下是否还有未走的格子
    33.         for (int i=0;i<matrix.length;i++){
    34.             for (int j=0;j<matrix[i].length;j++){
    35.                 // 如果有未走的格子，说明寻路失败，退一步继续寻路
    36.                 if (matrix[i][j]==0){
    37.                     matrix[x][y] = 0;
    38.                     count--;
    39.                     return;
    40.                 }
    41.             }
    42.         }
    44.         // 走到此，说明没有未走的格子，说明寻路成功，打印输出路径
    45.         for (int i=0;i<matrix.length;i++){
    46.             for (int j=0;j<matrix[i].length;j++){
    47.                 System.out.print(String.format("%3d", matrix[i][j]));
    48.             }
    49.             System.out.println();
    50.         }
    52.         // 退出程序
    53.         System.exit(-1);
    54.     }
    56.     /**
    57.      * 举个栗子
    58.      */
    59.     public static void main(String[] args) {
    60.         // 棋盘数组（0代表可以走的路，-1代表障碍）
    61.         int[][] matrix = {
    62.                 { 0, 0, 0, 0, 0, 0},
    63.                 {-1, 0, 0,-1, 0, 0},
    64.                 { 0, 0, 0, 0, 0, 0},
    65.                 { 0, 0, 0, 0, 0, 0},
    66.                 { 0,-1, 0, 0,-1, 0},
    67.                 { 0, 0, 0, 0, 0, 0}
    68.         };
    69.         // 起始位置 x:行数 y:列数
    70.         int x=2,y=5;
    71.         // 开始寻路
    72.         pathfind(x-1,y-1,matrix);
    73.     }
    74. }

    路径输出

    1.  32 31 28 27 26 25
    2.  -1 30 29 -1  1 24
    3.  10  9  6  5  2 23
    4.  11  8  7  4  3 22
    5.  12 -1 16 17 -1 21
    6.  13 14 15 18 19 20

    JS版本

    1. <!DOCTYPE html>
    2. <html lang="en">
    4. <head>
    5.     <meta charset="UTF-8">
    6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
    7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
    8.     <title>一笔画寻路暴力破解</title>
    9. </head>
    11. <body>
    12.     <div id="pathTable"></div>
    13. </body>
    14. <script>
    15.     var unicursal = function () {
    16.         // 步骤从1开始
    17.         this.count = 1;
    18.         this.path = null;
    19.         this.success = false;
    21.         this.matrix = null;
    22.         this.x = null;
    23.         this.y = null;
    24.     };
    26.     unicursal.prototype.run = function () {
    27.         this.path = this.copyArr(this.matrix);
    28.         this.pathfind(this.x - 1, this.y - 1, this.path)
    29.     }
    31.     unicursal.prototype.copyArr = function (obj) {
    32.         var out = [];
    33.         for (var i = 0, len = obj.length; i < len; i++) {
    34.             if (obj[i] instanceof Array) {
    35.                 out[i] = this.copyArr(obj[i]);
    36.             } else {
    37.                 out[i] = obj[i];
    38.             }
    39.         }
    40.         return out;
    41.     }
    43.     /**
    44.      * 寻路 每走一步都会有三个方向可以走，如果无路可走，遍历一下是否还有未走的格子
    45.      * 如果没有，则寻路成功，打印出路径，如果有，则退一步，走其他方向
    46.      * 
    47.      * @param x 起始位置第几行
    48.      * @param y 起始位置第几列
    49.      * @param matrix 棋盘数组（0代表可以走的路，-1代表障碍，1,2,3....代表路径）
    50.      */
    51.     unicursal.prototype.pathfind = function (x, y, matrix) {
    52.         matrix[x][y] = this.count++;
    53.         // 如果下一步没有超出y的最大边界，并且下一步可以走
    54.         if (y + 1 < matrix[x].length && matrix[x][y + 1] == 0) {
    55.             this.pathfind(x, y + 1, matrix);
    56.             if (this.success) {
    57.                 return
    58.             }
    59.         }
    60.         // 如果下一步没有超出y的最小边界，并且下一步可以走
    61.         if (y - 1 >= 0 && matrix[x][y - 1] == 0) {
    62.             this.pathfind(x, y - 1, matrix);
    63.             if (this.success) {
    64.                 return
    65.             }
    66.         }
    67.         // 如果下一步没有超出x的最大边界，并且下一步可以走
    68.         if (x + 1 < matrix.length && matrix[x + 1][y] == 0) {
    69.             this.pathfind(x + 1, y, matrix);
    70.             if (this.success) {
    71.                 return
    72.             }
    73.         }
    74.         // 如果下一步没有超出x的最小边界，并且下一步可以走
    75.         if (x - 1 >= 0 && matrix[x - 1][y] == 0) {
    76.             this.pathfind(x - 1, y, matrix);
    77.             if (this.success) {
    78.                 return
    79.             }
    80.         }
    82.         // 走到此，说明已经无路可走，遍历一下是否还有未走的格子
    83.         for (var i = 0; i < matrix.length; i++) {
    84.             for (var j = 0; j < matrix[i].length; j++) {
    85.                 // 如果有未走的格子，说明寻路失败，退一步继续寻路
    86.                 if (matrix[i][j] == 0) {
    87.                     matrix[x][y] = 0;
    88.                     this.count--;
    89.                     return;
    90.                 }
    91.             }
    92.         }
    94.         this.success = true;
    95.     }
    97.     /**
    98.      * 举个栗子
    99.      */
    100.     // 棋盘数组（0代表可以走的路，-1代表障碍）
    101.     var matrix = [
    102.         [0, 0, 0, 0, 0, 0],
    103.         [-1, 0, 0, -1, 0, 0],
    104.         [0, 0, 0, 0, 0, 0],
    105.         [0, 0, 0, 0, 0, 0],
    106.         [0, -1, 0, 0, -1, 0],
    107.         [0, 0, 0, 0, 0, 0]
    108.     ];
    109.     var instance = new unicursal();
    110.     instance.matrix = matrix;
    111.     // 起始位置 x:行数 y:列数
    112.     instance.x = 2;
    113.     instance.y = 5;
    114.     // 开始寻路
    115.     instance.run();
    117.     if (!instance.success) {
    118.         document.getElementById("pathTable").innerHTML = "无路径可寻";
    119.     } else {
    120.         // 走到此，说明没有未走的格子，说明寻路成功，打印输出路径
    121.         var table = "<table style=\"text-align: right\">";
    122.         for (var i = 0; i < instance.path.length; i++) {
    123.             table += "<tr>";
    124.             for (var j = 0; j < instance.path[i].length; j++) {
    125.                 table += "<td>" + instance.path[i][j] + "</td>";
    126.             }
    127.             table += "</tr>";
    128.         }
    129.         table += "</table>";
    130.         document.getElementById("pathTable").innerHTML = table;
    131.     }
    133. </script>
    135. </html>