JAVA解数独

最新推荐文章于 2023-07-11 11:11:13 发布
最新推荐文章于 2023-07-11 11:11:13 发布
阅读量137 收藏
点赞数
分类专栏： 工具类 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_38740436/article/details/119572958
版权

版本一



import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Suduku3 {

    public static final Set<Integer> nums = Stream.iterate(1, n -> n + 1).limit(9).collect(Collectors.toSet());

    public static int round = 0;

    public static int[][] solve(int[][] sudo) {
        round++;
        if (check(sudo)) {
            return sudo;
        }
        Map<String, Object> map = find(sudo);
        Set<Integer> backs = (Set<Integer>) map.get("result");
        if (backs != null && backs.size() > 0) {
            for (Integer back : backs) {
                int[][] cpsudo = copy(sudo);
                int i = (int) map.get("i");
                int j = (int) map.get("j");
                cpsudo[i][j] = back;
                cpsudo = solve(cpsudo);
                if (check(cpsudo)) {
                    return cpsudo;
                }
            }

        }
        return sudo;
    }

    private static Map<String, Object> find(int[][] sudo) {
        Map<String, Object> map = new HashMap<>();
        Set<Integer> result = new HashSet<>(nums);
        for (int i = 0; i < sudo.length; i++) {
            for (int j = 0; j < sudo[i].length; j++) {
                if (sudo[i][j] == 0) {
                    Set<Integer> backs = new HashSet<>(nums);
                    for (int m = 0; m < sudo.length; m++) {
                        for (int n = 0; n < sudo[m].length; n++) {
                            if (sudo[m][n] > 0) {
                                if (m == i || n == j) {
                                    backs.remove(sudo[m][n]);
                                }
                                if (m / 3 == i / 3 && n / 3 == j / 3) {
                                    backs.remove(sudo[m][n]);
                                }

                            }
                        }
                    }
                    if (backs.size() < result.size()) {
                        result = new HashSet<>(backs);
                        map.put("i", i);
                        map.put("j", j);
                        map.put("result", result);
                    }
                }
            }
        }
        return map;
    }

    public static void print(int[][] sudo) {
        for (int[] ints : sudo) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
        System.out.println("===============================================");
    }

    public static boolean check(int[][] sudo) {
        if (null == sudo) {
            return false;
        }
        for (int i = 0; i < sudo.length; i++) {
            for (int j = 0; j < sudo[i].length; j++) {
                if (sudo[i][j] == 0) {
                    return false;
                }
                int num = sudo[i][j];
                for (int m = 0; m < sudo.length; m++) {
                    for (int n = 0; n < sudo[m].length; n++) {
                        if (m == i && n == j) {
                            continue;
                        }
                        if (sudo[m][n] == num) {
                            if (m == i || n == j) {
                                return false;
                            }
                            if (m / 3 == i / 3 && n / 3 == j / 3) {
                                return false;
                            }
                        }
                    }
                }
            }
        }
        return true;
    }

    public static int[][] copy(int[][] arrays) {
        int[][] result = new int[arrays.length][arrays[0].length];
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                result[i][j] = arrays[i][j];
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[][] sudo = new int[][]{
                {0, 0, 0, 0, 0, 3, 0, 0, 5},
                {8, 0, 0, 0, 0, 0, 0, 9, 0},
                {0, 5, 0, 2, 0, 0, 8, 0, 6},
                {0, 0, 0, 8, 2, 0, 0, 5, 9},
                {0, 0, 4, 0, 0, 0, 6, 0, 0},
                {2, 9, 0, 0, 3, 1, 0, 0, 0},
                {9, 0, 2, 0, 0, 8, 0, 4, 0},
                {0, 4, 0, 0, 0, 0, 0, 0, 7},
                {3, 0, 0, 1, 0, 0, 0, 0, 0}
        };
        Date start = new Date();
        sudo = solve(sudo);
        print(sudo);
        System.out.println(round);
        System.out.println(new Date().getTime() - start.getTime());
    }
}

版本二（减少递归调用）



import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Suduku2 {

    public static int round = 0;
    public static final Set<Integer> nums = Stream.iterate(1, n -> n + 1).limit(9).collect(Collectors.toSet());

    public static int[][] solve(int[][] sudo) {
        round++;
        if (check(sudo)) {
            return sudo;
        }
        int[][] cpsudo = copy(sudo);
        List<Map<String, Integer>> mapList = findOnlyOne(sudo);
        for (Map<String, Integer> objectMap : mapList) {
            int i = objectMap.get("i");
            int j = objectMap.get("j");
            int n = objectMap.get("result");
            cpsudo[i][j] = n;
            if (check(cpsudo)) {
                return cpsudo;
            }
        }
        Map<String, Object> map = find(sudo);
        Set<Integer> backs = (Set<Integer>) map.get("result");
        if (backs != null && backs.size() > 0) {
            for (Integer back : backs) {
                int[][] cp2 = copy(cpsudo);
                int i = (int) map.get("i");
                int j = (int) map.get("j");
                cp2[i][j] = back;
                cp2 = solve(cp2);
                if (check(cp2)) {
                    return cp2;
                }
            }

        }
        return cpsudo;
    }

    /**
     * 寻找唯一解
     *
     * @param sudo
     * @return
     */
    private static List<Map<String, Integer>> findOnlyOne(int[][] sudo) {
        List<Map<String, Integer>> list = new ArrayList<>();
        for (int i = 0; i < sudo.length; i++) {
            for (int j = 0; j < sudo[i].length; j++) {
                if (sudo[i][j] != 0) {
                    continue;
                }
                Set<Integer> backs = new HashSet<>(nums);
                for (int m = 0; m < sudo.length; m++) {
                    for (int n = 0; n < sudo[m].length; n++) {
                        if (sudo[m][n] == 0) {
                            continue;
                        }
                        if (m == i || n == j
                                || (m / 3 == i / 3 && n / 3 == j / 3)) {
                            backs.remove(sudo[m][n]);
                        }
                    }
                }
                if (backs.size() == 1) {//单元格有唯一解
                    Map<String, Integer> map = new HashMap<>();
                    map.put("i", i);
                    map.put("j", j);
                    map.put("result", backs.iterator().next());
                    sudo[i][j] = map.get("result");
                    list.add(map);
                }
            }
        }
        if (list.size() > 0) {//根据已知唯一解继续寻找
            list.addAll(findOnlyOne(sudo));
            return list;
        } else {//直到找不到
            return list;
        }
    }

    /**
     * 当没有唯一解时
     * 寻找解最少的单元格
     * @param sudo
     * @return
     */
    private static Map<String, Object> find(int[][] sudo) {
        Map<String, Object> map = new HashMap<>();
        Set<Integer> result = new HashSet<>(nums);
        for (int i = 0; i < sudo.length; i++) {
            for (int j = 0; j < sudo[i].length; j++) {
                if (sudo[i][j] != 0) {
                    continue;
                }
                Set<Integer> backs = new HashSet<>(nums);
                for (int m = 0; m < sudo.length; m++) {
                    for (int n = 0; n < sudo[m].length; n++) {
                        if (sudo[m][n] == 0) {
                            continue;
                        }
                        if (m == i || n == j
                                || (m / 3 == i / 3 && n / 3 == j / 3)) {
                            backs.remove(sudo[m][n]);
                        }
                    }
                }
                if (backs.size() < result.size()) {
                    result = new HashSet<>(backs);
                    map.put("i", i);
                    map.put("j", j);
                    map.put("result", result);
                }
            }
        }
        return map;
    }

    public static void print(int[][] sudo) {
        for (int[] ints : sudo) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
        System.out.println("===============================================");
    }

    /**
     * 检验数独是否完成
     * @param sudo
     * @return
     */
    public static boolean check(int[][] sudo) {
        if (null == sudo) {
            return false;
        }
        for (int i = 0; i < sudo.length; i++) {
            for (int j = 0; j < sudo[i].length; j++) {
                if (sudo[i][j] == 0) {
                    return false;
                }
                int num = sudo[i][j];
                for (int m = 0; m < sudo.length; m++) {
                    for (int n = 0; n < sudo[m].length; n++) {
                        if ((m == i && n == j) || sudo[m][n] != num) {
                            continue;
                        }
                        if (m == i || n == j
                                || (m / 3 == i / 3 && n / 3 == j / 3)) {
                            return false;
                        }
                    }
                }
            }
        }
        return true;
    }

    /**
     * 数组拷贝
     * @param arrays
     * @return
     */
    public static int[][] copy(int[][] arrays) {
        int[][] result = new int[arrays.length][arrays[0].length];
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                result[i][j] = arrays[i][j];
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[][] sudo = new int[][]{
                {8, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 3, 6, 0, 0, 0, 0, 0},
                {0, 7, 0, 0, 9, 0, 2, 0, 0},
                {0, 5, 0, 0, 0, 7, 0, 0, 0},
                {0, 0, 0, 0, 4, 5, 7, 0, 0},
                {0, 0, 0, 1, 0, 0, 0, 3, 0},
                {0, 0, 1, 0, 0, 0, 0, 6, 8},
                {0, 0, 8, 5, 0, 0, 0, 1, 0},
                {0, 9, 0, 0, 0, 0, 4, 0, 0}
        };
        Date start = new Date();
        print(solve(sudo));
        System.out.println(round);
        Date parse1 = new Date();
        System.out.println(parse1.getTime() - start.getTime());
    }
}
离墨狂客Z
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java解数独
04-07
NULL 博文链接：https://sleepyy.iteye.com/blog/1582979
解数独（Java）
m0_57248981的博客
08-09 433
我们使用三个boolean数组，多开一个位置让下标与数字映射。37. 解数独t编写一个程序，通过填充空格来解决数独问题。数独部分空格内已填入了数字，空白格用。
Java编程实战12：解数独
Code Writers
12-06 930
编写一个程序，通过填充空格来解决数独问题。数独的解法需 遵循如下规则：输入：board = [[“5”,“3”,“.”,“.”,“7”,“.”,“.”,“.”,“.”],[“6”,“.”,“.”,“1”,“9”,“5”,“.”,“.”,“.”],[“.”,“9”,“8”,“.”,“.”,“.”,“.”,“6”,“.”],[“8”,“.”,“.”,“.”,“6”,“.”,“.”,“.”,“3”],[“4”,“.”,“.”,“8”,“.”,“3”,“.”,“.”,“1”],[“7”,“.”,“.”,“.”,“2
使用java解数独
sinat_34067387的博客
08-05 2028
说明 先根据规则解数独, 规则1: 如果备选数字只有一个, 那么就填入这个数字 规则2: 如果在3*3单元格中, 或者一行, 或者一列中, 某个备选数字在所有的备选数字中只出现了一次, 那么就填入这个数字. 再暴力破解数独, 依次填入备选数字, 如果不能解开, 换下一个备选数字, 直到数独完全解开. 代码 package com.example.springboot01; import org.junit.Test; import org.junit.platform.commons.util.
用java解数独
Darvec的博客
05-01 495
大家好，很久没更新了，今天写一写解数独的算法吧，这是一道leetcode困难级别的题目，本人的算法跟真正的大神相比效率一般，花费的时间和空间都很多。不过对于大多数人来说应该是最直观，最易懂的。 这道题目考虑的是最基本的数独，也就是每行，每列，每宫都是1到9。没有其他更加复杂的规则 题目当中数独是以一种二维字符矩阵（char[][]）来呈现的。那么首先我们可以创立一个全局变量nums char[] ...
java解数独_用java解数独
weixin_28892727的博客
02-12 355
package info.frady;public class SudokuSolver {public void solveSudoku(char[][] board) {solve(board);}public boolean solve(char[][] board){for(int i=0;i<9;i++){for(int j=0;j<9;j++){if(board[i][j]...
Java实现解数独的小程序
08-31
最近在学习Java，然后上个月迷上了九宫格数独，玩了几天，觉得实在有趣，就想着能不能用编程来解决，于是就自己写了个，还真解决了...下面这篇文章就给大家主要介绍了Java实现解数独的小程序,需要的朋友可以参考借鉴。
java回溯算法解数独问题
08-26
主要为大家详细介绍了java回溯算法解数独问题，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
解数独的---APP
08-18
本来写了一个C语言纯代码的解数独代码，运行前需要修改数组的元素（将题目输入进去），但是感觉用户体验不好，想做出一个使用移动平台的APP在手机运行。在此分享给大家。本软件解数独分两部分，一部分是通过数独的...
Java数独求解
tango_wolf的博客
12-25 421
package shudu; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.OutputStream; import java.io.PrintStream; import java.sql.Date; import java.util.Arrays; import java.util.HashMap; import java.util.M
不同方法解数独 java代码
03-12
内涵若干未解数独和已解数独 通过comment和uncomment Sudoku.java里的注解选择不同方法解数独 数独分2^2乘2^2的和3^2乘3^2的，注意BruteForceSolver 和StaticSolver 两个方法不要解2^2乘2^2以上的数独，否则太慢
java解决数独_Java解决“数独”之三
weixin_28847199的博客
02-13 399
数独是一个我们都非常熟悉的经典游戏，运用计算机我们可以很快地解开数独难题，现在有一些简单的数独题目，请编写一个程序求解。输入描述:输入9行，每行为空格隔开的9个数字，为0的地方就是需要填充的。输出描述:输出九行，每行九个空格隔开的数字，为解出的答案。分析：这里的数独就是9行9列的数组，满足每一行、每一列、每一个粗线宫内的数字均含1-9，不重复。这里粗线宫要分清楚，开始我以为是任意的九宫格内的1-9...
解数独 - Java版
永远sayYES的博客
09-15 235
问题: 编写一个程序，解决数独问题。 一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 ‘.’ 表示，比如一个数独的题目为：[[“5”,“3”,".",".",“7”,".",".",".","."],[“6”,".",".",“1”,“9”,“5”,".",".","."],[".",“9”,“8”,".",".",".",".",“6”,"."],[“8”,"
JAVA 回溯算法解数独
weixin_43995607的博客
11-11 391
数独，回溯算法，java，递归
简单的Java代码示例：数独游戏
Gdhjdjdvdg的博客
07-11 1025
​ 方法需要根据实际需求进行实现，以与玩家进行交互并验证移动的合法性。你可以根据自己的喜好和具体情况来设计这些方法的实现方式。此外，你还需要在构造函数中初始化数独棋盘，并根据实际需求填入具体的数独初始数字。请注意，上述代码中的 ​。
Java快乐小游戏---数独
qq_42594306的博客
06-28 861
想着这个数组不行，进入了死循环的话就再利用核心代码重新刷新就好，想了用boolean值，用秒数等都出了好多的错误。最近学各种工具和框架概念学麻了，效果的养分和热情严重不足，背负着要搞黄面试，自己做了两个小游戏。本以为会顺顺利利的，结果显示数组的时候直接卡死在某个数字上，这个位置填哪个数字都不行。在刚开始想组合数独的时候想着这在每行每列里进行重复性判断，思路图和代码如下。再经过遮挡+点击增加的功能+渲染+点击位置和显示数字的调整，数独就完成了。实在不行，找我的GPT小助手在线提供答案，思路和核心代码如下。
Java数独游戏的实现
QQ21503882的博客
02-13 525
数独是一款逻辑游戏，起源于18世纪末的瑞士，在美国发展起来，并在日本发展到顶峰，它使用纸张和笔来进行数字游戏。玩家需要基于9×9的磁盘已知的数字,推理出所有剩余的空间数据,并满足每一行,每一列、每一个小宫3 * 3)中的数字1 - 9不重复，数独游戏可以锻炼人的逻辑思维能力,并不是测试人的计算能力,是一个老少咸宜的益智游戏。本课题主要使用了Eclipse平台、java swing、awt等技术进行开发。游戏界面简洁美观，操作便捷，功能齐全，具有一定的实用性和游戏性，适合广大数独爱好者们进行数独游戏。
解数独java实现
WukongGo的博客
04-25 764
题目描述 https://leetcode-cn.com/problems/sudoku-solver 编写一个程序，通过已填充的空格来解决数独问题。 一个数独的解法需遵循如下规则： 数字1-9在每一行只能出现一次。 数字1-9在每一列只能出现一次。 数字1-9在每一个以粗实线分隔的3x3宫内只能出现一次。 空白格用'.'表示。 一个数独。 答案被标成红色。...
python java 解压缩
最新发布
09-18
Python和Java都有一些解压缩库可以用来解压缩文件。对于Python，您可以使用zipfile模块，它提供了用于解压缩zip文件的功能。下面是一个示例代码，演示了如何使用zipfile模块解压缩zip文件： ```python import zipfile zip_file = "path/to/your/zip/file.zip" extract_dir = "path/to/extract/folder" with zipfile.ZipFile(zip_file, 'r') as zip_ref: zip_ref.extractall(extract_dir) ``` 对于Java，您可以使用java.util.zip包中的ZipInputStream类来解压缩zip文件。下面是一个示例代码，演示了如何使用ZipInputStream解压缩zip文件： ```java import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.util.zip.ZipEntry; import java.util.zip.ZipInputStream; public class UnzipExample { public static void main(String[] args) { String zipFile = "path/to/your/zip/file.zip"; String extractDir = "path/to/extract/folder"; try { byte[] buffer = new byte[1024]; File folder = new File(extractDir); if (!folder.exists()) { folder.mkdir(); } ZipInputStream zipInputStream = new ZipInputStream(new FileInputStream(zipFile)); ZipEntry zipEntry = zipInputStream.getNextEntry(); while (zipEntry != null) { String fileName = zipEntry.getName(); File newFile = new File(extractDir + File.separator + fileName); new File(newFile.getParent()).mkdirs(); FileOutputStream fileOutputStream = new FileOutputStream(newFile); int length; while ((length = zipInputStream.read(buffer)) > 0) { fileOutputStream.write(buffer, 0, length); } fileOutputStream.close(); zipEntry = zipInputStream.getNextEntry(); } zipInputStream.closeEntry(); zipInputStream.close(); } catch (Exception e) { e.printStackTrace(); } } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值