• java实现解数独的算法

    BeginIndexRangeVO.java：
    1.  
    2.  
    3. import lombok.Getter;
    4. import lombok.Setter;
    5.  
    6. import java.io.Serializable;
    7.  
    8. @Getter
    9. @Setter
    10. public class BeginIndexRangeVO implements Serializable {
    11.  
    12.     private int beginRowNum;
    13.     private int beginColNum;
    14.  
    15.     public BeginIndexRangeVO(int beginRowNum, int beginColNum) {
    16.         this.beginRowNum = beginRowNum;
    17.         this.beginColNum = beginColNum;
    18.     }
    19. }

    PointVO.java：
    1.  
    2.  
    3. import lombok.Getter;
    4. import lombok.Setter;
    5.  
    6. import java.io.Serializable;
    7. import java.util.List;
    8.  
    9. @Getter
    10. @Setter
    11. public class PointVO implements Serializable {
    12.     /*
    13.         2  -  9    6  -  -    8  5  4
    14.         4  8  6    9  5  2    7  3  1
    15.         -  -  -    -  4  -    6  2  9
    17.         -  -  2    4  -  9    5  8  6
    18.         5  -  4    -  -  -    3  9  2
    19.         -  9  -    2  -  5    1  4  7
    21.         -  -  1    -  2  4    9  -  3
    22.         9  4  -    3  1  -    2  -  5
    23.         -  2  -    -  9  -    4  1  8
    24.      */
    25.  
    26.     private String number;
    27.     private String tryNumber;
    28.     private int rowNum;
    29.     private int colNum;
    30.     private int gongNum=0;
    31.     private String code;
    32.     private List possibleNumbers;
    33.     private List possibleNumbers_bak;
    34.  
    35.     public PointVO(String number, int rowNum, int colNum) {
    36.         this.number = number;
    37.         this.rowNum = rowNum;
    38.         this.colNum = colNum;
    39.     }
    40.  
    41.     public String getCode(){
    42.         if( this.code != null ){
    43.             return this.code;
    44.         }
    45.         this.code = this.rowNum + "-" + this.colNum;
    46.         return this.code;
    47.     }
    48.  
    49.     public int getGongNum(){
    50.         if( this.gongNum > 0 ){
    51.             return this.gongNum;
    52.         }
    53.         if( this.rowNum <= 3 ){
    54.             if( this.colNum <= 3 ){
    55.                 this.gongNum = 1;
    56.             }else if( this.colNum <= 6 ){
    57.                 this.gongNum = 2;
    58.             }else {
    59.                 this.gongNum = 3;
    60.             }
    61.         }else if( this.rowNum <= 6 ){
    62.             if( this.colNum <= 3 ){
    63.                 this.gongNum = 4;
    64.             }else if( this.colNum <= 6 ){
    65.                 this.gongNum = 5;
    66.             }else {
    67.                 this.gongNum = 6;
    68.             }
    69.         }else {
    70.             if( this.colNum <= 3 ){
    71.                 this.gongNum = 7;
    72.             }else if( this.colNum <= 6 ){
    73.                 this.gongNum = 8;
    74.             }else {
    75.                 this.gongNum = 9;
    76.             }
    77.         }
    78.         return this.gongNum;
    79.     }
    80. }

    RowColVO.java：
    1.  
    2.  
    3. import lombok.Getter;
    4. import lombok.Setter;
    5.  
    6. import java.io.Serializable;
    7.  
    8.  
    9. @Getter
    10. @Setter
    11. public class RowColVO implements Serializable {
    12.  
    13.     private int rowNum;
    14.     private int colNum;
    15.  
    16.     public RowColVO(int rowNum, int colNum) {
    17.         this.rowNum = rowNum;
    18.         this.colNum = colNum;
    19.     }
    20. }

    ShuduSolver.java：
    1.  
    2.  
    3. import com.alibaba.fastjson.JSONObject;
    4.  
    5. import java.util.*;
    6.  
    7.  
    8. public class ShuduSolver {
    9.     private static final Map map_gongNum_beginIndexRange = new HashMap<>();
    10.  
    11.     private static final Map> map_gongNum_numbers = new HashMap<>();
    12.     private static final Map> map_rowNum_numbers = new HashMap<>();
    13.     private static final Map> map_colNum_numbers = new HashMap<>();
    14.  
    15.     private static Map map_code_point;
    16.  
    17.     private static int count_fill = 0;
    18.  
    19.     static {
    20.         map_gongNum_beginIndexRange.put(1, new BeginIndexRangeVO(1, 1));
    21.         map_gongNum_beginIndexRange.put(2, new BeginIndexRangeVO(1, 4));
    22.         map_gongNum_beginIndexRange.put(3, new BeginIndexRangeVO(1, 7));
    23.  
    24.         map_gongNum_beginIndexRange.put(4, new BeginIndexRangeVO(4, 1));
    25.         map_gongNum_beginIndexRange.put(5, new BeginIndexRangeVO(4, 4));
    26.         map_gongNum_beginIndexRange.put(6, new BeginIndexRangeVO(4, 7));
    27.  
    28.         map_gongNum_beginIndexRange.put(7, new BeginIndexRangeVO(7, 1));
    29.         map_gongNum_beginIndexRange.put(8, new BeginIndexRangeVO(7, 4));
    30.         map_gongNum_beginIndexRange.put(9, new BeginIndexRangeVO(7, 7));
    31.     }
    32.  
    33.     /**
    34.      * 优化：储存一个存储已经正确填写多少个格子的全局变量，没进行操作前先判断下是否等于81，如果已经结束了，就直接返回
    35.      * @param args
    36.      */
    37.     public static void main(String[] args) {
    38.       /*  int[][] chupan ={
    39.                             { 0,0,0,  0,0,0,  0,0,0 },
    40.                             { 0,0,0,  0,0,0,  0,0,0 },
    41.                             { 0,0,0,  0,0,0,  0,0,0 },
    43.                             { 0,0,0,  0,0,0,  0,0,0 },
    44.                             { 0,0,0,  0,0,0,  0,0,0 },
    45.                             { 0,0,0,  0,0,0,  0,0,0 },
    47.                             { 0,0,0,  0,0,0,  0,0,0 },
    48.                             { 0,0,0,  0,0,0,  0,0,0 },
    49.                             { 0,0,0,  0,0,0,  0,0,0 }
    50.                         };*/
    51.  
    52.         /*int[][] chupan = {
    53.                             { 2,0,0,  0,8,0,  0,1,0 },
    54.                             { 0,4,0,  1,0,0,  3,0,0 },
    55.                             { 0,0,0,  0,9,0,  0,0,0 },
    57.                             { 0,0,0,  7,0,0,  8,4,0 },
    58.                             { 0,9,0,  0,2,1,  0,0,0 },
    59.                             { 0,0,6,  0,0,0,  0,0,0 },
    61.                             { 0,3,0,  0,0,0,  5,8,0 },
    62.                             { 1,0,0,  8,0,0,  0,0,7 },
    63.                             { 0,2,7,  0,5,3,  0,0,0 }
    64.                          };*/
    65.  
    66.         /*int[][] chupan ={
    67.                 { 0,9,0,  3,0,0,  0,0,0 },
    68.                 { 0,0,0,  0,2,9,  0,0,1 },
    69.                 { 6,0,0,  0,0,0,  0,0,7 },
    71.                 { 0,7,0,  0,0,0,  0,1,0 },
    72.                 { 5,0,0,  0,0,0,  0,6,4 },
    73.                 { 0,0,0,  8,0,4,  0,0,9 },
    75.                 { 0,1,0,  2,0,0,  6,0,0 },
    76.                 { 7,8,0,  0,9,0,  0,0,0 },
    77.                 { 0,0,4,  0,5,0,  0,0,3 }
    78.         };*/
    79.  
    80.         int[][] chupan ={
    81.                 { 1,0,4,  0,0,0,  0,0,0 },
    82.                 { 0,0,0,  0,0,5,  0,0,0 },
    83.                 { 0,6,0,  0,8,0,  0,7,3 },
    84.  
    85.                 { 0,0,0,  8,0,1,  9,0,0 },
    86.                 { 6,5,0,  0,0,0,  0,0,0 },
    87.                 { 0,0,0,  3,0,0,  0,0,8 },
    88.  
    89.                 { 0,2,0,  0,3,0,  0,0,7 },
    90.                 { 0,0,0,  0,0,7,  1,3,0 },
    91.                 { 4,7,0,  0,0,0,  8,9,0 }
    92.         };
    93.  
    94.         List points = initChuPan( chupan );
    95.         map_code_point = points2CodeAndPointMap(points);
    96.  
    97.         init_map_xxxNum_numbers(  );
    98.  
    99.         print( );
    100.  
    101.         makeACommonTest( );
    102.         print( );
    103.  
    104.         //  做笔记，记录每个空格子可能得候选数字
    105.         calculatePossibleNumbers(  );
    106.         printPossibles(  );
    107.  
    108.         tryFill();
    109.         printPossibles();
    110.     }
    111.  
    112.     /**
    113.      *
    114.      * @param rowNum
    115.      * @param colNum
    116.      * @return true：通过尝试的方式已经为该行该列填了正确的数字了，false：通过尝试的方式暂无法为该行该列填正确的数字
    117.      */
    118.     private static boolean tryFill( int rowNum,int colNum){
    119.         String code = getCode(rowNum, colNum);
    120.         PointVO point = map_code_point.get(code);
    121.         if( point.getNumber() != null ){
    122.             // 排除非空格子
    123.             return false;
    124.         }
    125.         List possibleNumbers = deepCopyList( point.getPossibleNumbers() );
    126.         List numbers_canNotFill = new ArrayList<>();
    127.         for( String possibleNumber:possibleNumbers ){
    128.             calculatePossibleNumbers();
    129.             String errorMsg = tryFill(rowNum, colNum, possibleNumber);
    130.             if( errorMsg != null ){
    131.                 // 发生了错误，所以 possibleNumber 不能填到该格子上
    132.                 numbers_canNotFill.add( possibleNumber );
    133.             }
    134.         }
    135.         calculatePossibleNumbers();
    136.         possibleNumbers.removeAll( numbers_canNotFill );
    137.         String pointName = getPointName(rowNum, colNum);
    138.         if( possibleNumbers.size() == 1 ){
    139.             String number = possibleNumbers.get(0);
    140.             fillNumber( rowNum,colNum,number );
    141.             System.out.println( "通过尝试的方式确定 " + pointName + " 填写数字 " + JSONObject.toJSONString( numbers_canNotFill ) + " 都会产生矛盾，所以 " + pointName + " 的正确数字是 " + number );
    142.             return true;
    143.         }else {
    144.             // System.out.println( "通过尝试的方式只能确定 " + pointName + " 填写数字 " + JSONObject.toJSONString( numbers_canNotFill )  + " 会产生矛盾，但是还无法确定填写数字 " + JSONObject.toJSONString( possibleNumbers )  + " 是否会产生矛盾，所以暂时无法为 " + pointName + " 填写正确的数字" );
    145.         }
    146.         return false;
    147.     }
    148.  
    149.     private static boolean gameSuccess(){
    150.         return count_fill == 81;
    151.     }
    152.  
    153.     private static void tryFill(){
    154.         for (int rowNum = 1; rowNum <=9 ; rowNum++) {
    155.             for (int colNum = 1; colNum <=9 ; colNum++) {
    156.                 boolean setSuccess = tryFill(rowNum, colNum);
    157.                 if( setSuccess ){
    158.                     makeACommonTest();
    159.                 }
    160.                 if( gameSuccess() ){
    161.                     return;
    162.                 }
    163.             }
    164.         }
    165.     }
    166.  
    167.     /**
    168.      *
    169.      * @param rowNum
    170.      * @param colNum
    171.      * @param number
    172.      * @return 返回 errorMsg，为 null 表示让该行该列填该数字暂未导致错误( 即不确定该行该列能否填该数字 )，
    173.      *          否则表示让该行该列填该数字导致出现了错误( 即该行该列不能填该数字 )
    174.      */
    175.     private static String tryFill(int rowNum, int colNum, String number) {
    176.         String code = getCode(rowNum, colNum);
    177.         PointVO point = map_code_point.get(code);
    178.         List possibleNumbers = new ArrayList<>();
    179.         possibleNumbers.add( number );
    180.         point.setPossibleNumbers( possibleNumbers );
    181.         boolean findConflict = scanAndTryToFindConflict();
    182.         String pointName = getPointName(rowNum, colNum);
    183.         if( findConflict ){
    184.             return "为 " + pointName + " 格子设置数字" + number + " 会导致冲突";
    185.         }else {
    186.             // System.out.println( "为 " + pointName + " 格子设置数字" + number + " 暂时不会导致冲突，所以暂不确定 " + pointName + " 能否设置数字" + number );
    187.             return null;
    188.         }
    189.     }
    190.  
    191.     private static String getPointName(int rowNum, int colNum) {
    192.         return rowNum + "行" + colNum + "列";
    193.     }
    194.  
    195.     /**
    196.      * 初始化三个缓存map( map_rowNum_numbers、map_colNum_numbers、map_gongNum_numbers )
    197.      */
    198.     private static void init_map_xxxNum_numbers( ) {
    199.         for (int rowNum = 1; rowNum <=9 ; rowNum++) {
    200.             for (int colNum = 1; colNum <=9 ; colNum++) {
    201.                 String code = getCode(rowNum, colNum);
    202.                 PointVO point = map_code_point.get(code);
    203.                 String number = point.getNumber();
    204.                 if( number == null ){
    205.                     continue;
    206.                 }
    207.                 // 行
    208.                 Set numbers = map_rowNum_numbers.get(rowNum);
    209.                 if( numbers == null ){
    210.                     numbers = new HashSet<>();
    211.                     map_rowNum_numbers.put( rowNum,numbers );
    212.                 }
    213.                 numbers.add( number );
    214.  
    215.                 // 列
    216.                 numbers = map_colNum_numbers.get(colNum);
    217.                 if( numbers == null ){
    218.                     numbers = new HashSet<>();
    219.                     map_colNum_numbers.put( colNum,numbers );
    220.                 }
    221.                 numbers.add( number );
    222.  
    223.                 // 宫
    224.                 int gongNum = getGongNum(rowNum, colNum);
    225.                 numbers = map_gongNum_numbers.get(gongNum);
    226.                 if( numbers == null ){
    227.                     numbers = new HashSet<>();
    228.                     map_gongNum_numbers.put( gongNum,numbers );
    229.                 }
    230.                 numbers.add( number );
    231.             }
    232.         }
    233.     }
    234.  
    235.     public static boolean scanAndTryToFindConflict( ){
    236.         //  寻找 possibleNumber.size = 1的空格子
    237.         Set codes = map_code_point.keySet();
    238.         boolean needReScan = false;
    239.         for( String code:codes ){
    240.             PointVO point = map_code_point.get(code);
    241.             if( point.getNumber() != null ){
    242.                 continue;
    243.             }
    244.             if( point.getPossibleNumbers().size() != 1 ){
    245.                 continue;
    246.             }
    247.             //  找到一个 possibleNumber.size = 1 的空格子
    248.             String possibleNumber = point.getPossibleNumbers().get(0);
    249.             //  将 possibleNumber 从同行、同列、同宫的空格子的 possibleNumbers 集合中删除，删除如果会导致集合的长度变味0，则发生了矛盾，return true
    250.             //  删除后如果出现了新的 size=1的空格子，则后面需要重新扫描，已经检查过的 size=1的空格子就不需要重建检查了，防止死循环
    251.             //  如果过程中有产生新的  size=1的，则需要递归重新扫描
    252.  
    253.             // 同行
    254.             for (int colNum = 1; colNum <=9 ; colNum++) {
    255.                 String code_sameRow = getCode(point.getRowNum(), colNum);
    256.                 PointVO point_sameRow = map_code_point.get(code_sameRow);
    257.                 if( point_sameRow.getCode().equals( code ) ){
    258.                     // 排除自己
    259.                     continue;
    260.                 }
    261.                 if( point_sameRow.getNumber() != null ){
    262.                     // 排除非空格子
    263.                     continue;
    264.                 }
    265.                 boolean remove = point_sameRow.getPossibleNumbers().remove(possibleNumber);
    266.                 if( point_sameRow.getPossibleNumbers().size() == 0 ){
    267.                     // 发生了矛盾的地方
    268.                     return true;
    269.                 }
    270.                 if( remove && point_sameRow.getPossibleNumbers().size() == 1 ){
    271.                     // 产生了新的 size =1的格子，需要递归重新扫描
    272.                     needReScan = true;
    273.                 }
    274.             }
    275.  
    276.             // 同列
    277.             for (int rowNum = 1; rowNum <=9 ; rowNum++) {
    278.                 String code_sameCol = getCode(rowNum, point.getColNum());
    279.                 PointVO point_sameCol = map_code_point.get(code_sameCol);
    280.                 if( point_sameCol.getCode().equals( code ) ){
    281.                     // 排除自己
    282.                     continue;
    283.                 }
    284.                 if( point_sameCol.getNumber() != null ){
    285.                     // 排除非空格子
    286.                     continue;
    287.                 }
    288.                 boolean remove = point_sameCol.getPossibleNumbers().remove(possibleNumber);
    289.                 if( point_sameCol.getPossibleNumbers().size() == 0 ){
    290.                     // 发生了矛盾的地方
    291.                     return true;
    292.                 }
    293.                 if( remove && point_sameCol.getPossibleNumbers().size() == 1 ){
    294.                     // 产生了新的 size = 1的格子，需要递归重新扫描
    295.                     needReScan = true;
    296.                 }
    297.             }
    298.  
    299.             // 同宫
    300.             int gongNum = getGongNum(point.getRowNum(), point.getColNum());
    301.             BeginIndexRangeVO beginIndexRange = map_gongNum_beginIndexRange.get(gongNum);
    302.             int beginRowNum = beginIndexRange.getBeginRowNum();
    303.             int endRowNum = beginRowNum + 2;
    304.             int beginColNum = beginIndexRange.getBeginColNum();
    305.             int endColNum = beginColNum + 2;
    306.             for (int rowNum = beginRowNum; rowNum <=endRowNum ; rowNum++) {
    307.                 for (int colNum = beginColNum; colNum <=endColNum ; colNum++) {
    308.                     String code_sameGong = getCode(rowNum, colNum);
    309.                     PointVO point_sameGong = map_code_point.get(code_sameGong);
    310.                     if( point_sameGong.getCode().equals( code ) ){
    311.                         // 排除自己
    312.                         continue;
    313.                     }
    314.                     if( point_sameGong.getNumber() != null ){
    315.                         // 排除非空格子
    316.                         continue;
    317.                     }
    318.                     boolean remove = point_sameGong.getPossibleNumbers().remove(possibleNumber);
    319.                     if( point_sameGong.getPossibleNumbers().size() == 0 ){
    320.                         // 发生了矛盾的地方
    321.                         return true;
    322.                     }
    323.                     if( remove && point_sameGong.getPossibleNumbers().size() == 1 ){
    324.                         // 产生了新的 size =1的格子，需要递归重新扫描
    325.                         needReScan = true;
    326.                     }
    327.                 }
    328.             }
    329.         }
    330.         if( needReScan ){
    331.             return scanAndTryToFindConflict(  );
    332.         }else {
    333.             return false;
    334.         }
    335.     }
    336.  
    337.     private static List deepCopyList(List list) {
    338.         List list_copy = new ArrayList<>();
    339.         for( String item:list ){
    340.             list_copy.add( item );
    341.         }
    342.         return list_copy;
    343.     }
    344.  
    345.     private static void calculatePossibleNumbers( ) {
    346.         for (int rowNum = 1; rowNum <=9 ; rowNum++) {
    347.             for (int colNum = 1; colNum <=9 ; colNum++) {
    348.                 calculatePossibleNumberForTargetRowAndCol( rowNum,colNum );
    349.             }
    350.         }
    351.     }
    352.  
    353.     private static void calculatePossibleNumberForTargetRowAndCol(int targetRowNum, int targetColNum) {
    354.         String code = getCode(targetRowNum, targetColNum);
    355.         PointVO point = map_code_point.get(code);
    356.         if( point.getNumber() != null ){
    357.             return;
    358.         }
    359.         Set numbers_canNotFill = new HashSet<>();
    360.         numbers_canNotFill.addAll( map_rowNum_numbers.get(targetRowNum) );
    361.         numbers_canNotFill.addAll( map_colNum_numbers.get(targetColNum) );
    362.         int gongNum = getGongNum(targetRowNum, targetColNum);
    363.         numbers_canNotFill.addAll( map_gongNum_numbers.get(gongNum) );
    364.  
    365.         List numbers_possible = new ArrayList<>();
    366.         for (int i = 1; i <=9 ; i++) {
    367.             numbers_possible.add( String.valueOf( i ) );
    368.         }
    369.         numbers_possible.removeAll( numbers_canNotFill );
    370.         point.setPossibleNumbers( numbers_possible );
    371.         point.setPossibleNumbers_bak( deepCopyList( numbers_possible ) );
    372.         point.setTryNumber( null );
    373.     }
    374.  
    375.     private static void makeACommonTest( ) {
    376.         if( gameSuccess() ){
    377.             // 已经结束了
    378.             return;
    379.         }
    380.         int testTime_max = 10;
    381.         int testTime = 0;
    382.         while ( true ){
    383.             testTime++;
    384.             if( testTime > testTime_max ){
    385.                 break;
    386.             }
    387.             // method1( map_code_point );
    388.             // method2( map_code_point );
    389.             method_hangBingChuxxx(  );
    390.             method_lieBingChuxxx(  );
    391.             method_gongBingChu(  );
    392.         }
    393.     }
    394.  
    395.     private static void method_lieBingChu( ) {
    396.         // 遍历每一列
    397.         for (int colNum = 1; colNum <=9 ; colNum++) {
    398.             // 对于当前列，遍历该列每一行的空格子：
    399.             for (int rowNum = 1; rowNum <=9 ; rowNum++) {
    400.                 String code = getCode(rowNum, colNum);
    401.                 PointVO point = map_code_point.get(code);
    402.                 if( point.getNumber() != null ){
    403.                     continue;
    404.                 }
    405.                 // 对于该列当前行的空格子：
    406.                 // 计算该格子所在的行、列、宫已经填写的数字的并集去重，如果该集合的长度为8，表示已经确定了该格子填什么数字了，即为缺失的数字
    407.                 Set numbers_canNotFill = new HashSet<>();
    408.                 numbers_canNotFill.addAll( map_rowNum_numbers.get( rowNum ) );
    409.                 numbers_canNotFill.addAll( map_colNum_numbers.get( colNum ) );
    410.                 int gongNum = getGongNum(rowNum, colNum);
    411.                 numbers_canNotFill.addAll( map_gongNum_numbers.get( gongNum ) );
    412.                 String number_shouldFill = getSingleMissingNumber( numbers_canNotFill );
    413.                 if( number_shouldFill != null ){
    414.                     fillNumber( point,number_shouldFill );
    415.                     // System.out.println( "列摒除：" + colNum + "列第" + rowNum + "行的数字不能填写" + JSONObject.toJSONString( numbers_canNotFill ) + "，只能填写" + number_shouldFill );
    416.                 }
    417.             }
    418.         }
    419.     }
    420.  
    421.     private static String getShouldFillNumber(int rowNum, int colNum) {
    422.         Set numbers_canNotFill = new HashSet<>();
    423.         numbers_canNotFill.addAll( map_rowNum_numbers.get( rowNum ) );
    424.         numbers_canNotFill.addAll( map_colNum_numbers.get( colNum ) );
    425.         numbers_canNotFill.addAll( map_gongNum_numbers.get( getGongNum(rowNum, colNum) ) );
    426.         return getSingleMissingNumber( numbers_canNotFill );
    427.     }
    428.  
    429.     /*
    430.        -  -  -    -  2  -    -  8  5
    431.        6  5  2    -  7  -    -  -  -
    432.        3  -  -    -  5  -    -  1  2
    434.        7  2  3    9  -  4    -  5  -
    435.        5  4  -    2  -  -    -  3  -
    436.        -  6  9    -  -  5    -  2  -
    438.        -  -  5    -  -  -    2  6  -
    439.        2  -  -    5  8  6    1  -  3
    440.        -  3  6    -  -  2    5  7  -
    441.    */
    442.     private static void method_gongBingChu( ) {
    443.         if( gameSuccess() ){
    444.             // 已经结束了
    445.             return;
    446.         }
    447.         // 遍历每一个宫：
    448.         for (int gongNum = 1; gongNum <=9 ; gongNum++) {
    449.             // 对于当前宫，遍历每一个空格子：
    450.             BeginIndexRangeVO beginIndexRange = map_gongNum_beginIndexRange.get(gongNum);
    451.             // 计算该宫全部的数字
    452.             int beginRowNum = beginIndexRange.getBeginRowNum();
    453.             int endRowNum = beginRowNum + 2;
    454.             int beginColNum = beginIndexRange.getBeginColNum();
    455.             int endColNum = beginColNum + 2;
    456.             for (int rowNum = beginRowNum; rowNum <=endRowNum ; rowNum++) {
    457.                 for (int colNum = beginColNum; colNum <=endColNum ; colNum++) {
    458.                     // 对于当前的空格子，计算该格子所处的行、列、宫的已填数字的并集并去重，从集合[1,2,3,4,5,6,7,8,9]
    459.                     // 中删除这个集合，产生的新集合就是可填数字的集合，如果可填数字的集合的长度为1，表示已经确定了该格子需要填写的数字了
    460.                     String code = getCode(rowNum, colNum);
    461.                     PointVO point = map_code_point.get(code);
    462.                     if( point.getNumber()  != null ){
    463.                         continue;
    464.                     }
    465.                     String number_shouldFill = getShouldFillNumber( rowNum,colNum );
    466.                     if( number_shouldFill != null ){
    467.                         // 已经确定该格子该填什么数字了
    468.                         fillNumber( point,number_shouldFill );
    469.                         // System.out.println( "宫摒除：" + gongNum + "宫的格子( " + rowNum + "行" + colNum + "列 )不能填写 xxx，只能填写" + number_shouldFill );
    470.                     }
    471.                 }
    472.             }
    473.         }
    474.     }
    475.  
    476.     private static String getSingleMissingNumber(Set numbers) {
    477.         if( numbers == null || numbers.size() != 8 ){
    478.             return null;
    479.         }
    480.         int sum = 0;
    481.         for( String number:numbers ){
    482.             sum += Integer.valueOf( number );
    483.         }
    484.         // ps：45 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
    485.         return String.valueOf( 45 - sum );
    486.     }
    487.  
    488.     private static boolean fillNumber( PointVO point,String number ) {
    489.         if( point == null || number == null ){
    490.             return false;
    491.         }
    492.         point.setNumber( number );
    493.         count_fill++;
    494.         // System.out.println( "count_fille = " + count_fill + "：" + point.getRowNum() + "行" + point.getColNum() + "列 填写数字 " + number );
    495.         // 更新三个 map_xxxNum_numbers
    496.         addNumber2_map_xxxNum_numbers( point.getRowNum(),point.getColNum(),number );
    497.         if( gameSuccess() ){
    498.             printPossibles();
    499.             System.exit( 0 );
    500.         }
    501.         return true;
    502.     }
    503.  
    504.     /**
    505.      * 更新三个 map_xxxNum_numbers
    506.      * @param rowNum
    507.      * @param colNum
    508.      * @param number
    509.      */
    510.     private static void addNumber2_map_xxxNum_numbers(int rowNum, int colNum, String number) {
    511.         int gongNum = getGongNum(rowNum, colNum);
    512.         map_gongNum_numbers.get( gongNum ).add( number );
    513.         map_rowNum_numbers.get( rowNum ).add( number );
    514.         map_colNum_numbers.get( colNum ).add( number );
    515.     }
    516.  
    517.     private static boolean fillNumber(int rowNum, int colNum, String number) {
    518.         String code = getCode(rowNum, colNum);
    519.         PointVO point = map_code_point.get(code);
    520.         if( point == null ){
    521.             return false;
    522.         }
    523.         return fillNumber( point,number );
    524.     }
    525.  
    526.     /*
    527.         -  -  -    -  2  -    -  8  5
    528.         6  5  2    -  7  -    -  -  -
    529.         3  -  -    -  5  -    -  1  2
    531.         7  2  3    9  -  4    -  5  -
    532.         5  4  -    2  -  -    -  3  -
    533.         -  6  9    -  -  5    -  2  -
    535.         -  -  5    -  -  -    2  6  -
    536.         2  -  -    5  8  6    1  -  3
    537.         -  3  6    -  -  2    5  7  -
    538.     */
    539.     private static void method2( ) {
    540.         if( gameSuccess() ){
    541.             // 已经结束了
    542.             return;
    543.         }
    544.         //  遍历每一个空格子
    545.         //  找到该格子所在的宫、行、列中全部数字的并集再去重后得到一个新的集合，如果新集合的大小为8，则缺少的那个数字即是需要填写到该格子中的数字
    546.         for (int rowNum = 1; rowNum <=9 ; rowNum++) {
    547.             for (int colNum = 1; colNum <=9 ; colNum++) {
    548.                 String code = getCode(rowNum, colNum);
    549.                 PointVO point = map_code_point.get(code);
    550.                 if( point.getNumber() != null ){
    551.                     continue;
    552.                 }
    553.                 String number_confirm = getShouldFillNumber( rowNum,colNum );
    554.                 if( number_confirm != null ){
    555.                     System.out.println( rowNum + "行" + colNum + "列的格子不能填写 xxx，所以只能填写" + number_confirm );
    556.                     fillNumber( point,number_confirm );
    557.                 }
    558.             }
    559.         }
    560.     }
    561.  
    562.     /*
    563.       -  2  -    4  -  9    1  -  -
    564.       4  -  6    -  5  -    -  8  9
    565.       -  7  -    -  8  3    -  2  4
    567.       7  1  -    5  3  -    -  -  -
    568.       -  -  -    -  9  -    2  -  -
    569.       -  -  -    -  4  -    -  -  7
    571.       -  6  -    -  -  -    -  -  -
    572.       -  -  7    3  -  -    8  -  1
    573.       3  4  -    -  -  5    -  6  -
    574.    */
    575.     private static int getGongNum(int rowNum, int colNum) {
    576.         if( rowNum <= 3 ){
    577.             if( colNum <= 3 ){
    578.                 return 1;
    579.             }else if( colNum <= 6 ){
    580.                 return 2;
    581.             }else {
    582.                 return 3;
    583.             }
    584.         }else if( rowNum <= 6 ){
    585.             if( colNum <= 3 ){
    586.                 return 4;
    587.             }else if( colNum <= 6 ){
    588.                 return 5;
    589.             }else {
    590.                 return 6;
    591.             }
    592.         }else {
    593.             if( colNum <= 3 ){
    594.                 return 7;
    595.             }else if( colNum <= 6 ){
    596.                 return 8;
    597.             }else {
    598.                 return 9;
    599.             }
    600.         }
    601.     }
    602.  
    603.     private static void method1( ) {
    604.         if( gameSuccess() ){
    605.             // 已经结束了
    606.             return;
    607.         }
    608.         for (int i = 1; i <=9 ; i++) {
    609.             String targetNumber = String.valueOf( i );
    610.             for (int gongNum = 1; gongNum <=9 ; gongNum++) {
    611.                 setTargetNumberForTargetGong( gongNum,targetNumber );
    612.             }
    613.         }
    614.     }
    615.  
    616.  
    617.     /*
    618.         -  -  -    -  2  -    -  8  5
    619.         6  5  2    -  7  -    -  -  -
    620.         3  -  -    -  5  -    -  1  2
    622.         7  2  3    9  -  4    -  5  -
    623.         5  4  -    2  -  -    -  3  -
    624.         -  6  9    -  -  5    -  2  -
    626.         -  -  5    -  -  -    2  6  -
    627.         2  -  -    5  8  6    1  -  -
    628.         -  3  6    -  -  2    5  7  -
    629.      */
    630.     private static void method_hangBingChuxxx( ) {
    631.         if( gameSuccess() ){
    632.             // 已经结束了
    633.             return;
    634.         }
    635.         //  遍历每一行，对于某一行，看该行缺少什么数字，比如缺1，则看该行空缺的格子，哪些不能填1，如果排除后只剩下一个格子了，则该格子必须填1，
    636.         //  不能填1的依据是该格子所在的宫或者所在的列或者所在的行已经存在1了
    637.         for (int rowNum = 1; rowNum <=9 ; rowNum++) {
    638.             for( int number = 1;number<=9;number++ ){
    639.                 //  检查该行是否存在当前数字
    640.                 String number_str = String.valueOf( number );
    641.                 if( map_rowNum_numbers.get( rowNum ).contains( number_str ) ){
    642.                     continue;
    643.                 }
    644.                 //  该行不存在该数字
    645.                 //  检测该行哪些格子不能填写该数字，也即确定该行第几列可以填写该数字
    646.                 int colNum = getColNumThatCanFillTargetNumberInTargetRow( rowNum,number_str );
    647.                 if( colNum > 0 & colNum < 10 ){
    648.                     fillNumber( rowNum,colNum,number_str );
    649.                 }
    650.             }
    651.         }
    652.     }
    653.  
    654.     /*
    655.        -  -  -    -  2  -    -  8  5
    656.        6  5  2    -  7  -    -  -  -
    657.        3  -  -    -  5  -    -  1  2
    659.        7  2  3    9  -  4    -  5  -
    660.        5  4  -    2  -  -    -  3  -
    661.        -  6  9    -  -  5    -  2  -
    663.        -  -  5    -  -  -    2  6  -
    664.        2  -  -    5  8  6    1  -  -
    665.        -  3  6    -  -  2    5  7  -
    666.     */
    667.     private static int getColNumThatCanFillTargetNumberInTargetRow(int targetRowNum, String targetNumber) {
    668.         List colNumList_blank = new ArrayList();
    669.         List colNumList_canNotFill = new ArrayList();
    670.         for (int colNum = 1; colNum <=9 ; colNum++) {
    671.             String code = getCode(targetRowNum, colNum);
    672.             PointVO point = map_code_point.get(code);
    673.             if( point.getNumber() != null ){
    674.                continue;
    675.             }
    676.             colNumList_blank.add( colNum );
    677.  
    678.             //  检测当前格子所在的宫是否存在该数字
    679.             int gongNum = getGongNum(targetRowNum, colNum);
    680.             if( map_gongNum_numbers.get( gongNum ).contains( targetNumber ) ){
    681.                 colNumList_canNotFill.add( colNum );
    682.                 continue;
    683.             }
    684.             //  检测当前格子所在的列是否存在该数字
    685.             if( map_colNum_numbers.get( colNum ).contains( targetNumber ) ){
    686.                 colNumList_canNotFill.add( colNum );
    687.             }
    688.         }
    689.         colNumList_blank.removeAll(colNumList_canNotFill);
    690.         if( colNumList_blank.size() == 1 ){
    691.             Integer colNum_canFill = colNumList_blank.get(0);
    692.             // System.out.println( "行摒除：第" + targetRowNum + "行的第" + JSONObject.toJSONString( colNumList_canNotFill ) + "列不能填写数字" + targetNumber + "了，只能是第" + colNum_canFill + "列可以填写数字" + targetNumber + "了" );
    693.             return colNum_canFill;
    694.         }
    695.         return -1;
    696.     }
    697.  
    698.  
    699.     /*
    700.       -  -  -    -  2  -    -  8  5
    701.       6  5  2    -  7  -    -  -  -
    702.       3  -  -    -  5  -    -  1  2
    704.       7  2  3    9  -  4    -  5  -
    705.       5  4  -    2  -  -    -  3  -
    706.       -  6  9    -  -  5    -  2  -
    708.       -  -  5    -  -  -    2  6  -
    709.       2  -  -    5  8  6    1  -  -
    710.       -  3  6    -  -  2    5  7  -
    711.    */
    712.     private static void method_lieBingChuxxx( ) {
    713.         if( gameSuccess() ){
    714.             // 已经结束了
    715.             return;
    716.         }
    717.         for (int colNum = 1; colNum <=9 ; colNum++) {
    718.             //  遍历该列的每一个空的格子
    719.             for( int number=1;number<=9;number++ ){
    720.                 //  检测该列是否存在该数字
    721.                 String number_str = String.valueOf( number );
    722.                 if( map_colNum_numbers.get( colNum ).contains( number_str ) ){
    723.                     continue;
    724.                 }
    725.                 // 该列不存在该数字
    726.                 int rowNum_canFill = getRowNumThatCanFillTargetNumberInTargetCol( colNum,number_str );
    727.                 if( rowNum_canFill > 0 && rowNum_canFill < 10 ){
    728.                     fillNumber( rowNum_canFill,colNum,number_str );
    729.                 }
    730.             }
    731.         }
    732.     }
    733.  
    734.     /*
    735.         -  -  -    -  2  -    -  8  5
    736.         6  5  2    -  7  -    -  -  -
    737.         3  -  -    -  5  -    -  1  2
    739.         7  2  3    9  -  4    -  5  -
    740.         5  4  -    2  -  -    -  3  -
    741.         -  6  9    -  -  5    -  2  -
    743.         -  -  5    -  -  -    2  6  -
    744.         2  -  -    5  8  6    1  -  -
    745.         -  3  6    -  -  2    5  7  -
    746.      */
    747.  
    748.     /**
    749.      * 在指定列中找到可以填写指定数字的行号
    750.      * @param targetColNum
    751.      * @param targetNumber
    752.      * @return 1~9表示找到了可以填写该数字的行号，其他表示未找到可以填写该数字的行号
    753.      */
    754.     private static int getRowNumThatCanFillTargetNumberInTargetCol(int targetColNum, String targetNumber) {
    755.         List rowNumList_blank = new ArrayList<>();
    756.         List rowNumList_canNotFill = new ArrayList<>();
    757.         for (int rowNum = 1; rowNum <=9 ; rowNum++) {
    758.             String code = getCode(rowNum, targetColNum);
    759.             PointVO point = map_code_point.get(code);
    760.             if( point.getNumber() != null ){
    761.                 continue;
    762.             }
    763.             rowNumList_blank.add( rowNum );
    764.  
    765.             // 检测当前格子所在的行和宫是否已经存在该数字
    766.             if( map_rowNum_numbers.get( rowNum ).contains( targetNumber ) ){
    767.                 rowNumList_canNotFill.add( rowNum );
    768.                 continue;
    769.             }
    770.             int gongNum = getGongNum(rowNum, targetColNum);
    771.             if( map_gongNum_numbers.get( gongNum ).contains( targetNumber ) ){
    772.                 rowNumList_canNotFill.add( rowNum );
    773.             }
    774.         }
    775.         rowNumList_blank.removeAll(rowNumList_canNotFill);
    776.         if( rowNumList_blank.size() == 1 ){
    777.             Integer rowNum_canFill = rowNumList_blank.get(0);
    778.             // System.out.println( "列摒除：" + targetColNum + "列的第" + JSONObject.toJSONString( rowNumList_canNotFill ) + "行都不能填写数字" + targetNumber + "，所以数字" + targetNumber + "只能填写在第" + rowNum_canFill + "行" );
    779.             // 列摒除：9列的第[]行都不能填写数字5，所以数字5只能填写在第3行
    780.             return rowNum_canFill;
    781.         }
    782.         return -1;
    783.     }
    784.  
    785.     /**
    786.      * 为指定的宫设置指定的数字
    787.      * @param targetGongNum
    788.      * @param targetNumber
    789.      * @return true 表示找到了合适的位置设置数字了，fasle无法确定哪里需要填写该数字
    790.      */
    791.     private static boolean setTargetNumberForTargetGong(int targetGongNum, String targetNumber) {
    792.         if( map_gongNum_numbers.get( targetGongNum ).contains( targetNumber ) ){
    793.             // 该宫内已经存在该数字
    794.             return false;
    795.         }
    796.  
    797.         // 未填写数字的格子的个数
    798.         int pointCount_blank = 0;
    799.         // 不能填写目标数字的格子的个数
    800.         int pointCount_canNotBeTargetNumber = 0;
    801.  
    802.         //  逐个检查该宫的9个位置中还没有填写数字的位置，
    803.         //  如果该位置所在的行或列已经存在该数字了，则该位置不能填该数字，假设空位置有n个，检测到不能填该数字的空位置有n-1个，则剩下的一个位置必须填该数字，否则无法判断哪个空位置需要填该数字
    804.         BeginIndexRangeVO beginIndexRange = map_gongNum_beginIndexRange.get(targetGongNum);
    805.         int beginRowNum = beginIndexRange.getBeginRowNum();
    806.         int endRowNum = beginRowNum + 2;
    807.         int beginColNum = beginIndexRange.getBeginColNum();
    808.         int endColNum = beginColNum + 2;
    809.  
    810.         int rowNum_maybeFind = 0;
    811.         int colNum_maybeFind = 0;
    812.  
    813.         for (int rowNum = beginRowNum; rowNum <=endRowNum ; rowNum++) {
    814.             for (int colNum = beginColNum; colNum <=endColNum ; colNum++) {
    815.                 String code = getCode(rowNum, colNum);
    816.                 PointVO point = map_code_point.get(code);
    817.                 if( point.getNumber() != null ){
    818.                     // 该位置已经有数字了
    819.                    continue;
    820.                 }
    821.                 pointCount_blank++;
    822.  
    823.                 if( map_rowNum_numbers.get( rowNum ).contains( targetNumber ) ){
    824.                     // 该位置所在的行已经存在 targetNumber 了
    825.                     pointCount_canNotBeTargetNumber++;
    826.                     continue;
    827.                 }
    828.                 if( map_colNum_numbers.get( colNum ).contains( targetNumber ) ){
    829.                     // 该位置所在的列已经存在targetNumber 了
    830.                     pointCount_canNotBeTargetNumber++;
    831.                     continue;
    832.                 }
    833.                 //  该位置为空，并且所在的行和列都没有出现过 targetNumber,所以该位置可能需要填写 targetNumber
    834.                 rowNum_maybeFind = rowNum;
    835.                 colNum_maybeFind = colNum;
    836.             }
    837.         }
    838.         if( ( pointCount_blank - pointCount_canNotBeTargetNumber ) == 1 ){
    839.             // 此时找到了填写 targetNumber 的地方了
    840.             return fillNumber( rowNum_maybeFind,colNum_maybeFind,targetNumber );
    841.         }else {
    842.             // 该宫无法确定当前数字需要填写到哪个位置
    843.             return false;
    844.         }
    845.     }
    846.  
    847.     private static String getCode(int rowNum, int colNum) {
    848.         return rowNum + "-" + colNum;
    849.     }
    850.  
    851.     public static  Map points2CodeAndPointMap( List points ){
    852.         Map map_code_point = new HashMap<>();
    853.         for( PointVO point:points ){
    854.             map_code_point.put( point.getCode(),point );
    855.         }
    856.         return map_code_point;
    857.     }
    858.  
    859.     public static void print( ){
    860.         System.out.println();
    861.         System.out.println( "--------------------------------------------------------------------------------------" );
    862.         for (int rowNum = 1; rowNum <=9 ; rowNum++) {
    863.             for (int colNum = 1; colNum <=9 ; colNum++) {
    864.                 String code = getCode( rowNum,colNum );
    865.                 PointVO point = map_code_point.get(code);
    866.                 if( point.getNumber() == null ){
    867.                     System.out.print( "-"  + "  ");
    868.                 }else {
    869.                     System.out.print( point.getNumber()  + "  ");
    870.                 }
    871.                 if( colNum % 3 == 0 ){
    872.                     System.out.print("  ");
    873.                 }
    874.             }
    875.             System.out.println();
    876.             if( rowNum % 3 ==0 ){
    877.                 System.out.println();
    878.             }
    879.         }
    880.     }
    881.  
    882.     public static void printPossibles( ){
    883.         System.out.println();
    884.         System.out.println( "--------------------------------------------------------------------------------------" );
    885.         Map map_colNum_maxLen = new HashMap<>();
    886.         for (int colNum = 1; colNum <=9; colNum++) {
    887.             int maxLen = 1;
    888.             for (int rowNum = 1; rowNum <=9 ; rowNum++) {
    889.                 String code = getCode(rowNum, colNum);
    890.                 PointVO point = map_code_point.get(code);
    891.                 if( point.getNumber() != null ){
    892.                     continue;
    893.                 }
    894.                 List possibleNumbers = point.getPossibleNumbers();
    895.                 if( possibleNumbers.size() > maxLen ){
    896.                     maxLen = possibleNumbers.size();
    897.                 }
    898.             }
    899.             maxLen+=2;
    900.             map_colNum_maxLen.put( colNum,maxLen );
    901.         }
    902.  
    903.         for (int rowNum = 1; rowNum <=9 ; rowNum++) {
    904.             for (int colNum = 1; colNum <=9 ; colNum++) {
    905.                 String code = getCode( rowNum,colNum );
    906.                 PointVO point = map_code_point.get(code);
    907.                 String value = null;
    908.                 if( point.getNumber() == null ){
    909.                     value = "[" + getStickTogetherFormat( point.getPossibleNumbers() ) + "]";
    910.                 }else {
    911.                     value = point.getNumber();
    912.                 }
    913.                 int maxLen = map_colNum_maxLen.get( colNum );
    914.                 if( value.length() < maxLen ){
    915.                     value += getBlank( maxLen - value.length() );
    916.                 }
    917.                 System.out.print( value  + "  ");
    918.                 if( colNum % 3 == 0 ){
    919.                     System.out.print("    ");
    920.                 }
    921.             }
    922.             System.out.println();
    923.             if( rowNum % 3 ==0 ){
    924.                 System.out.println();
    925.                 System.out.println();
    926.             }
    927.         }
    928.     }
    929.  
    930.     private static String getBlank(int count) {
    931.         String blank = "";
    932.         for (int i = 0; i < count; i++) {
    933.             blank += " ";
    934.         }
    935.         return blank;
    936.     }
    937.  
    938.     private static String getStickTogetherFormat(List list) {
    939.         if( list == null || list.size() == 0 ){
    940.             return "";
    941.         }
    942.         String str = "";
    943.         for( String item:list ){
    944.             str += item;
    945.         }
    946.         return str;
    947.     }
    948.  
    949.     public static List initChuPan(int[][] chupan) {
    950.         List points = new ArrayList<>();
    951.         for (int rowNum = 0; rowNum < 9; rowNum++) {
    952.             int[] row = chupan[rowNum];
    953.             for (int colNum = 0; colNum <9 ; colNum++) {
    954.                 int number = row[colNum];
    955.                 String number_str = null;
    956.                 if( number > 0 && number < 10 ){
    957.                     count_fill++;
    958.                     number_str = String.valueOf( number );
    959.                 }
    960.                 points.add( new PointVO(number_str,rowNum+1,colNum+1 ) );
    961.             }
    962.         }
    963.         return points;
    964.     }
    965. }

    测试输出样例：

    1. --------------------------------------------------------------------------------------
    2. 1  -  4    -  -  -    -  -  -    
    3. -  -  -    -  -  5    -  -  -    
    4. -  6  -    -  8  -    -  7  3    
    5.  
    6. -  -  -    8  -  1    9  -  -    
    7. 6  5  -    -  -  -    -  -  -    
    8. -  -  -    3  -  -    -  -  8    
    9.  
    10. -  2  -    -  3  -    -  -  7    
    11. -  -  -    -  -  7    1  3  -    
    12. 4  7  -    -  -  -    8  9  -    
    13.  
    14.  
    15. --------------------------------------------------------------------------------------
    16. 1  8  4    -  -  3    5  -  9    
    17. 7  3  -    -  -  5    -  8  1    
    18. -  6  5    1  8  -    -  7  3    
    19.  
    20. 3  4  7    8  -  1    9  -  -    
    21. 6  5  8    -  -  -    3  1  -    
    22. -  1  -    3  -  -    7  -  8    
    23.  
    24. 5  2  1    9  3  8    -  -  7    
    25. 8  9  6    -  -  7    1  3  -    
    26. 4  7  3    -  1  -    8  9  -    
    27.  
    28.  
    29. --------------------------------------------------------------------------------------
    30. 1     8    4         [267]  [267]    3           5      [26]    9          
    31. 7     3    [29]      [246]  [2469]   5           [246]  8       1          
    32. [29]  6    5         1      8        [249]       [24]   7       3          
    33.  
    34.  
    35. 3     4    7         8      [256]    1           9      [256]   [256]      
    36. 6     5    8         [247]  [2479]   [249]       3      1       [24]       
    37. [29]  1    [29]      3      [24569]  [2469]      7      [2456]  8          
    38.  
    39.  
    40. 5     2    1         9      3        8           [46]   [46]    7          
    41. 8     9    6         [245]  [245]    7           1      3       [245]      
    42. 4     7    3         [256]  1        [26]        8      9       [256]      
    43.  
    44.  
    45. 通过尝试的方式确定 1行8列 填写数字 ["2"] 都会产生矛盾，所以 1行8列 的正确数字是 6
    46. 通过尝试的方式确定 2行3列 填写数字 ["2"] 都会产生矛盾，所以 2行3列 的正确数字是 9
    47.  
    48. --------------------------------------------------------------------------------------
    49. 1    8    4        2    7    3        5    6    9        
    50. 7    3    9        6    4    5        2    8    1        
    51. 2    6    5        1    8    9        4    7    3        
    52.  
    53.  
    54. 3    4    7        8    5    1        9    2    6        
    55. 6    5    8        7    9    2        3    1    4        
    56. 9    1    2        3    6    4        7    5    8        
    57.  
    58.  
    59. 5    2    1        9    3    8        6    4    7        
    60. 8    9    6        4    2    7        1    3    5        
    61. 4    7    3        5    1    6        8    9    2

  • 相关阅读:
    Java Spring Boot 写 API 接口
    《web课程设计》使用HTML+CSS制作大学生校园二手交易网站
    【2022 小目标检测综述】Towards Large-Scale Small Object Detection: Survey and Benchmarks
    java面试题之 int和Integer的区别
    聊聊并发编程——多线程之AQS
    Typora~阿里云OSS+Typora+PicGo解决方案
    「网络安全」SQL注入攻击的真相
    【C语言步行梯】分支语句if...else、switch详谈
    数据结构＜5＞二叉树和堆——原理+实现
    缺口的大利润！伦敦银如何使用缺口交易
  • 原文地址：https://blog.csdn.net/heshiyuan1406146854/article/details/133812049