算法：用Java实现图论算法中欧拉回路的求解(一笔画问题)，并求出 "奥运五环" 的所有一笔画画法

最新推荐文章于 2022-12-31 02:15:00 发布
最新推荐文章于 2022-12-31 02:15:00 发布
阅读量3.9k 收藏 11
点赞数 1
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39448458/article/details/103181653
版权

今天我准备用Java来求解图论算法中的欧拉回路(EulerCircuit)问题，这个名字可能对大家有些陌生，如果我说一笔画，大家肯定就都清楚了。原来有一个"七桥问题"，不知道的可以百度，这里就不详述。继而引出了一笔画的问题。后来欧拉大神就提出了一笔画的一个原则，那就是一个图形如果可以一笔画，那么把它抽象为图的话，度为奇数的顶点只能是0个或两个。意思也就是，可以一笔画的图形，顶点要么全部都是度为偶数的，要么有且仅有两个度为奇数的顶点，而且一笔画路径的开始和结束，都得是这两个度为奇数的顶点。然后一笔画问题就又叫欧拉回路了

如何用Java编程，来实现图论算法的欧拉回路问题，求解出图的一笔画路径呢？今天我准备以大家都熟知的奥运五环为例，来告诉大家我的实现思路和过程：

在这里插入图片描述
以上就是奥运五环，共有八个顶点，每个顶点的度都是偶数。根据欧拉定理，可以从任意顶点出发对奥运五环进行一笔画。我们可以先把奥运五环的顶点进行标记，如下图：

在这里插入图片描述
以下是我的实现思路：

  1. 检查一笔画图形每个顶点的度，如果不是全偶数度顶点或有且仅有两个奇数度顶点，则该图形无法一笔画
  2. 先将一笔画图形的所有顶点进行编号，如上图
  3. 然后计算每个顶点之间的连线数，如奥运五环图，A和B之间有3条连线，C和D之间有两条连线，D和E之间有1条连线
  4. 将一笔画图形抽象为新的图，重新分布顶点，将所有有连线的顶点都加上一条边，边是无向边，且权重为他们之间的连线数
  5. 从某一点出发（有且仅有两个度为奇数的顶点的图，则必须以其中一个奇数度顶点出发），然后递归用深度优先搜索DFS来探索一笔画路径，每走过一条边，则边的权重减一。如果当前顶点和下一个顶点之间的权重减到了0，或者本来就是0，则两点之间不可达，就换其他可达的顶点，继续递归往深处遍历，直到完成一笔画，或者接下来所有相邻顶点之间的边权重都为0，无路可走
  6. 如果无路可走但完成了一笔画（所有边的权重都为0了），则可以输出正确结果，完美结束递归。如果未完成一笔画且无路可走，直接结束当前分支递归
  7. 初始化决定一个开始顶点，求出所有下一个可达的顶点集，遍历下一个顶点集，多批次递归寻路，以求出图形的所有一笔画路径

下面这张图，就是上面步骤4中说的奥运五环抽象的图，顶点间的边的权重，就是在奥运五环中的连线数：
在这里插入图片描述
以下是上面的奥运五环抽象图的邻接矩阵：
在这里插入图片描述

下面是我用Java实现的欧拉回路的求解算法代码，并以奥运五环为例，用该算法求出 “奥运五环” 的所有一笔画画法路径。画的时候如果从A点到B点有多条路径，随意画一条路径即可，都是等价的。算法的原理和精髓都在下面的代码和其间的注释之中：

import java.util.ArrayList;
import java.util.List;

/**
 * @author LiYang
 * @ClassName EulerCircuit
 * @Description 求解欧拉回路(一笔画)问题
 * @date 2019/11/20 16:05
 */
public class EulerCircuit {

    /**
     * 返回奥运五环图的邻接矩阵（顶点间有几条连线，权重就是几）
     * @return 奥运五环图的邻接矩阵
     */
    public static int[][] initOlympicRingsMatrix() {
        //生成奥运五环图的邻接矩阵
        return new int[][] {
                {0, 3, 0, 1, 0, 0, 0, 0},
                {3, 0, 1, 0, 0, 0, 0, 0},
                {0, 1, 0, 2, 0, 1, 0, 0},
                {1, 0, 2, 0, 1, 0, 0, 0},
                {0, 0, 0, 1, 0, 2, 0, 1},
                {0, 0, 1, 0, 2, 0, 1, 0},
                {0, 0, 0, 0, 0, 1, 0, 3},
                {0, 0, 0, 0, 1, 0, 3, 0}
        };
    }

    /**
     * 判断一笔画是否完成，也就是看是否
     * 已经形成了欧拉回路
     * @param matrix 一笔画图邻接矩阵的中间状态
     * @return 是否已经完成
     */
    public static boolean isFinished(int[][] matrix) {
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix.length; j++) {
                
                //如果还有边没有走过
                if (matrix[i][j] > 0) {
                    //判定为未完成
                    return false;
                }
            }
        }
        
        //所有边已走过，判定为已完成
        return true;
    }

    /**
     * 深度拷贝Set<Integer>对象
     * @param source 拷贝源
     * @return 深度拷贝的副本
     */
    public static List<Integer> copyList(List<Integer> source) {
        //拷贝副本
        List<Integer> copy = new ArrayList<>();

        //加入所有元素
        for (Integer item : source) {
            copy.add(item);
        }

        //返回拷贝副本
        return copy;
    }

    /**
     * 深度拷贝邻接矩阵二维数组对象
     * @param matrix 邻接矩阵拷贝源
     * @return 深度拷贝的邻接矩阵副本
     */
    public static int[][] copyMatrix(int[][] matrix) {
        //拷贝副本
        int[][] newMatrix = new int[matrix.length][matrix.length];

        //复制所有值
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix.length; j++) {
                newMatrix[i][j] = matrix[i][j];
            }
        }

        //返回拷贝副本
        return newMatrix;
    }

    /**
     * 求解欧拉回路，探索一笔画路径
     * @param matrix 当前的邻接矩阵
     * @param nextVertex 下一步的路径
     * @param route 当前的路线图
     * @param vertexName 顶点名称字符串数组
     */
    public static void runEulerCircuit(int[][] matrix, int nextVertex, List<Integer> route, String[] vertexName) {
        //先复制一份当前的邻接矩阵
        int[][] newMatrix = copyMatrix(matrix);
        
        //当前驻足的顶点
        int currentVertex = route.get(route.size() - 1);
        
        //走过nextVertex，更新邻接矩阵
        //更新方式为边权重减1，两边通路都要减
        newMatrix[currentVertex][nextVertex] --;
        newMatrix[nextVertex][currentVertex] --;
        
        //再复制一份路径图
        List<Integer> newRoute = copyList(route);
        
        //路径图加入nextVertex
        newRoute.add(nextVertex);
        
        //找到nextVertex的所有下步顶点
        List<Integer> nextList = new ArrayList<>();
        
        //收集下一步可达的顶点
        for (int i = 0; i < newMatrix.length; i++) {
            if (newMatrix[nextVertex][i] > 0) {
                nextList.add(i);
            }
        }
        
        //如果有下一个可达的顶点
        if (nextList.size() > 0) {
            
            //遍历所有的下一步顶点
           for (Integer next : nextList) {
               
               //递归调用本方法，继续往下求解
               runEulerCircuit(copyMatrix(newMatrix), next, copyList(newRoute), vertexName);
           }
            
       //如果现在已经没有任何可达顶点了
        } else {
            
            //如果已经完成了一笔画，求解了欧拉回路
            if (isFinished(newMatrix)) {
                
                //字符串路径集合
                List<String> solutionRoute = new ArrayList<>();
                
                //根据顶点名称字符串数组，得到字符串的路径
                for (Integer vertexIndex : newRoute) {
                    solutionRoute.add(vertexName[vertexIndex]);
                }
                
                //整理路径信息
                String solution = solutionRoute.toString()
                        .replaceAll("\\[", "")
                        .replaceAll("]", "")
                        .replaceAll(", ", " -> ");

                //打印求得的一笔画路径（欧拉回路）
                System.out.println("找到奥运五环一笔画路径：" + solution);
            }
        }
    }

    /**
     * 求解欧拉回路，探索一笔画路径的驱动程序
     * @param matrix 一笔画图的邻接矩阵
     * @param startVertex 开始顶点，如果有且仅有两个度为三的顶点，
     *                    则必须以这两个顶点之一作为起点
     * @param vertexName 顶点名称字符串数组
     */
    public static void runEulerCircuit(int[][] matrix, int startVertex, String[] vertexName) {
        //路径
        List<Integer> route = new ArrayList<>();
        
        //从起点出发
        route.add(startVertex);
        
        //下一个顶点的集合
        List<Integer> nextVertexList = new ArrayList<>();

        //找到下一个可达的顶点
        for (int i = 0; i < matrix.length; i++) {
            if (matrix[startVertex][i] > 0) {
                nextVertexList.add(i);
            }
        }

        //遍历所有下一步可达顶点
        for (Integer nextVertex : nextVertexList) {
            
            //多分支递归调用求解欧拉回路的算法程序
            runEulerCircuit(matrix, nextVertex, route, vertexName);
        }
    }

    /**
     * 运行欧拉回路求解算法，解出奥运五环的所有一笔画路径
     * @param args
     */
    public static void main(String[] args) {
        //奥运五环图的初始邻接矩阵
        int[][] matrix = initOlympicRingsMatrix();
        
        //奥运五环图的顶点名称字符串数组
        String[] vertexName = new String[]{"A", "B", "C", "D", "E", "F", "G", "H"};
        
        //从A点出发，运行算法，解出奥运五环的所有一笔画路径
        runEulerCircuit(matrix, 0, vertexName);
    }
    
}

运行上面代码的main方法，控制台输出所有的奥运五环的一笔画画法路径（大家感兴趣可以自己尝试照着画一下），算法测试通过：

找到奥运五环一笔画路径：A -> B -> A -> B -> C -> D -> C -> F -> E -> F -> G -> H -> G -> H -> E -> D -> A
找到奥运五环一笔画路径：A -> B -> A -> B -> C -> D -> C -> F -> E -> H -> G -> H -> G -> F -> E -> D -> A
找到奥运五环一笔画路径：A -> B -> A -> B -> C -> D -> C -> F -> G -> H -> G -> H -> E -> F -> E -> D -> A
找到奥运五环一笔画路径：A -> B -> A -> B -> C -> D -> E -> F -> E -> H -> G -> H -> G -> F -> C -> D -> A
找到奥运五环一笔画路径：A -> B -> A -> B -> C -> D -> E -> F -> G -> H -> G -> H -> E -> F -> C -> D -> A
找到奥运五环一笔画路径：A -> B -> A -> B -> C -> D -> E -> H -> G -> H -> G -> F -> E -> F -> C -> D -> A
找到奥运五环一笔画路径：A -> B -> A -> B -> C -> F -> E -> F -> G -> H -> G -> H -> E -> D -> C -> D -> A
找到奥运五环一笔画路径：A -> B -> A -> B -> C -> F -> E -> H -> G -> H -> G -> F -> E -> D -> C -> D -> A
找到奥运五环一笔画路径：A -> B -> A -> B -> C -> F -> G -> H -> G -> H -> E -> F -> E -> D -> C -> D -> A
找到奥运五环一笔画路径：A -> B -> A -> D -> C -> D -> E -> F -> E -> H -> G -> H -> G -> F -> C -> B -> A
找到奥运五环一笔画路径：A -> B -> A -> D -> C -> D -> E -> F -> G -> H -> G -> H -> E -> F -> C -> B -> A
找到奥运五环一笔画路径：A -> B -> A -> D -> C -> D -> E -> H -> G -> H -> G -> F -> E -> F -> C -> B -> A
找到奥运五环一笔画路径：A -> B -> A -> D -> C -> F -> E -> F -> G -> H -> G -> H -> E -> D -> C -> B -> A
找到奥运五环一笔画路径：A -> B -> A -> D -> C -> F -> E -> H -> G -> H -> G -> F -> E -> D -> C -> B -> A
找到奥运五环一笔画路径：A -> B -> A -> D -> C -> F -> G -> H -> G -> H -> E -> F -> E -> D -> C -> B -> A
找到奥运五环一笔画路径：A -> B -> A -> D -> E -> F -> E -> H -> G -> H -> G -> F -> C -> D -> C -> B -> A
找到奥运五环一笔画路径：A -> B -> A -> D -> E -> F -> G -> H -> G -> H -> E -> F -> C -> D -> C -> B -> A
找到奥运五环一笔画路径：A -> B -> A -> D -> E -> H -> G -> H -> G -> F -> E -> F -> C -> D -> C -> B -> A
找到奥运五环一笔画路径：A -> B -> C -> D -> C -> F -> E -> F -> G -> H -> G -> H -> E -> D -> A -> B -> A
找到奥运五环一笔画路径：A -> B -> C -> D -> C -> F -> E -> H -> G -> H -> G -> F -> E -> D -> A -> B -> A
找到奥运五环一笔画路径：A -> B -> C -> D -> C -> F -> G -> H -> G -> H -> E -> F -> E -> D -> A -> B -> A
找到奥运五环一笔画路径：A -> B -> C -> D -> E -> F -> E -> H -> G -> H -> G -> F -> C -> D -> A -> B -> A
找到奥运五环一笔画路径：A -> B -> C -> D -> E -> F -> G -> H -> G -> H -> E -> F -> C -> D -> A -> B -> A
找到奥运五环一笔画路径：A -> B -> C -> D -> E -> H -> G -> H -> G -> F -> E -> F -> C -> D -> A -> B -> A
找到奥运五环一笔画路径：A -> B -> C -> F -> E -> F -> G -> H -> G -> H -> E -> D -> C -> D -> A -> B -> A
找到奥运五环一笔画路径：A -> B -> C -> F -> E -> H -> G -> H -> G -> F -> E -> D -> C -> D -> A -> B -> A
找到奥运五环一笔画路径：A -> B -> C -> F -> G -> H -> G -> H -> E -> F -> E -> D -> C -> D -> A -> B -> A
找到奥运五环一笔画路径：A -> D -> C -> D -> E -> F -> E -> H -> G -> H -> G -> F -> C -> B -> A -> B -> A
找到奥运五环一笔画路径：A -> D -> C -> D -> E -> F -> G -> H -> G -> H -> E -> F -> C -> B -> A -> B -> A
找到奥运五环一笔画路径：A -> D -> C -> D -> E -> H -> G -> H -> G -> F -> E -> F -> C -> B -> A -> B -> A
找到奥运五环一笔画路径：A -> D -> C -> F -> E -> F -> G -> H -> G -> H -> E -> D -> C -> B -> A -> B -> A
找到奥运五环一笔画路径：A -> D -> C -> F -> E -> H -> G -> H -> G -> F -> E -> D -> C -> B -> A -> B -> A
找到奥运五环一笔画路径：A -> D -> C -> F -> G -> H -> G -> H -> E -> F -> E -> D -> C -> B -> A -> B -> A
找到奥运五环一笔画路径：A -> D -> E -> F -> E -> H -> G -> H -> G -> F -> C -> D -> C -> B -> A -> B -> A
找到奥运五环一笔画路径：A -> D -> E -> F -> G -> H -> G -> H -> E -> F -> C -> D -> C -> B -> A -> B -> A
找到奥运五环一笔画路径：A -> D -> E -> H -> G -> H -> G -> F -> E -> F -> C -> D -> C -> B -> A -> B -> A
李先森LeeCode
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
欧拉回路程序java
11-24
package hamierton; import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Random; public class EularCircuit { public EularCircuit() { } public static void main(String[] args) { // System.out.println("please input n:"); // BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int n = 4; try { // n = Integer.parseInt(br.readLine()); } catch (Exception ex) { return; } try { Graph g = new Graph(n); g.printg(); g.circuit(); } catch (Exception e) { System.out.println(e.toString()); e.printStackTrace(); return; } } } class Node { private static int count = 0; private String name; private ArrayList adjacencyList; private boolean visited =false; public Node() { name = "node " + count; adjacencyList = new ArrayList(); } public Node(String name) { this.name = name; adjacencyList = new ArrayList(); } public boolean isAllVisited() { for (int i = 0; i < adjacencyList.size(); i++) { SNode sn = (SNode) adjacencyList.get(i); if (sn.visited == false) { return false; } } return true; } public boolean isvisited(){ return visited; } public void setvisited(){ visited = true; } public int getAdjacencyCount() { return adjacencyList.size(); } public boolean contains(int i) { return this.adjacencyList.contains(new SNode(i)); } public void removeAdjacencyNode(int i) { this.adjacencyList.remove(new SNode(i)); } public void addAdjacencyNode(int i) { this.adjacencyList.add(new SNode(i)); } public SNode getAdjacencyNode(int i) { return (SNode) this.adjacencyList.get(i); } public SNode getAdjacencyNodeEX(int i_ref) { for (int i = 0; i < this.getAdjacencyCount(); i++) { if (getAdjacencyNode(i).index == i_ref) { return getAdjacencyNode(i); } } return null; } public String toString() { return this.name; } } class SNode { public boolean visited = false; public int index = 0; public SNode(int index) { this.index = index; } public boolean equals(Object o) { if (((SNode) o).index == this.index) { return true; } return false; } public String toString() { return "adjacency " + index; } } class Graph { private ArrayList nodeList; private ArrayList path; private int count; public Graph(int n) throws Exception { this.count = n; nodeList = new ArrayList(count); ginit(); } public void circuit() { path = new ArrayList(); int top = 0; int k = 0; path.add(new Integer(0)); while (true) { int i, j; i = top; ArrayList path1 = new ArrayList(); path1.add(new Integer(top)); while (true) { Node node = (Node) nodeList.get(i); for (j = 0; j < this.count; j++) { if (node.contains(j) && node.getAdjacencyNodeEX(j).visited == false) { path1.add(new Integer(j)); node.getAdjacencyNodeEX(j).visited = true; // ((Node) nodeList.get(j)).getAdjacencyNodeEX(i).visited = true; i = j; break; } } if (i == top) { break; } } path.remove(k); path.addAll(k, path1); k++; if (k >= path.size()) { break; } top = ((Integer) path.get(k)).intValue(); } for (int z = 0; z < path.size(); z++) { System.out.print(path.get(z).toString() + " "); } } private void ginit() { int i; for (i = 0; i < 4; i++) { nodeList.add(new Node("node" + i)); } ((Node)nodeList.get(0)).addAdjacencyNode(3); ((Node)nodeList.get(1)).addAdjacencyNode(0); ((Node)nodeList.get(2)).addAdjacencyNode(1); ((Node)nodeList.get(3)).addAdjacencyNode(2); // ((Node)nodeList.get(0)).addAdjacencyNode(3); // ((Node)nodeList.get(1)).addAdjacencyNode(0); // ((Node)nodeList.get(2)).addAdjacencyNode(1); // ((Node)nodeList.get(3)).addAdjacencyNode(2); // for (i = 0; i < n; i++) { // nodeList.add(new Node("node" + i)); // } // ArrayList linked = new ArrayList(); // linked.add(new Integer(0)); // Random rand = new Random(); // // for (i = 1; i < n; i++) { // int size = linked.size(); // // int top = ((Integer) (linked.get(size - 1))).intValue(); // Node node = (Node) (nodeList.get(top)); // // while (true) { // int randint = rand.nextInt(n); // if (randint == top) { // continue; // } // if (node.contains(randint)) { // continue; // } else { // if (!linked.contains(new Integer(randint))) { // linked.add(new Integer(randint)); // } else if (node.getAdjacencyCount() >= (linked.size() - 1 > 6 ? 6 // : linked.size() - 1)) { // continue; // } else { // i--; // } // node.addAdjacencyNode(randint); // Node randnode = (Node) nodeList.get(randint); // randnode.addAdjacencyNode(top); // break; // } // } // } // // for (i = 0; i < this.count - 1; i++) { // Node node = (Node) nodeList.get(i); // if (node.getAdjacencyCount() % 2 != 0) { // int j = 0; // for (j = i + 1; j < this.count; j++) { // Node nn = (Node) nodeList.get(j); // if (nn.getAdjacencyCount() % 2 != 0) { // if (node.contains(j)) { // // if (nn.getAdjacencyCount() != 1 // && node.getAdjacencyCount() != 1) { // node.removeAdjacencyNode(j); // nn.removeAdjacencyNode(i); // break; // } else { // continue; // } // } else { // // node.addAdjacencyNode(j); // nn.addAdjacencyNode(i); // break; // } // } // } // // if (j == this.count) { // int k; // Node nk = null; // for (k = i + 1; k < this.count; k++) { // // nk = (Node) nodeList.get(k); // if (nk.getAdjacencyCount() % 2 != 0) { // break; // } // } // int kk = k; // for (k = 0; k < i; k++) { // Node n1 = (Node) nodeList.get(k); // if (!n1.contains(kk) && !n1.contains(i)) { // n1.addAdjacencyNode(kk); // nk.addAdjacencyNode(k); // n1.addAdjacencyNode(i); // node.addAdjacencyNode(k); // break; // } // } // boolean retry = false; // // if (k == i) { // int vv; // for (vv = 0; vv < this.count; vv++) { // Node vn = (Node) nodeList.get(vv); // if (!vn.contains(i) && i != vv) { // vn.addAdjacencyNode(i); // node.addAdjacencyNode(vv); // retry = true; // break; // } // } // if (vv == count) { // for (vv = 0; vv < count; vv++) { // Node vnn = (Node) nodeList.get(vv); // if (vnn.getAdjacencyCount() > 1) { // vnn.removeAdjacencyNode(i); // node.removeAdjacencyNode(vv); // retry = true; // break; // } // } // } // } // if (retry) { // i = -1; // } // } // } // // } // return this.isEularG(); } public boolean isEularG() { boolean isEular = true; for (int i = 0; i < this.count; i++) { Node n = (Node) nodeList.get(i); if (n.getAdjacencyCount() % 2 != 0) { isEular = false; break; } } return isEular; } public void printg() { for (int i = 0; i < this.count; i++) { Node n = (Node) nodeList.get(i); System.out.print(n.toString() + " "); for (int j = 0; j < n.getAdjacencyCount(); j++) { System.out.print(n.getAdjacencyNode(j).toString() + " "); } System.out.println(); } } }
欧拉通路回路和一笔画问题1
08-03
欧拉通路回路和一笔画问题1
数据结构--一笔画问题
丫丫的博客
08-22 1847
描述       zyc从小就比较喜欢玩一些小游戏，其中就包括画一笔画，他想请你帮他写一个程序，判断一个图是否能够用一笔画下来。      规定，所有的边都只能画一次，不能重复画。   输入      第一行只有一个正整数N(N&lt;=10)表示测试数据的组数。      每组测试数据的第一行有两个正整数P,Q(P&lt;=1000,Q&lt;=2000)，分别表示这个画中有多少个顶...
欧拉路径（一笔画问题）
ROOM
11-02 1万+
定理一 连通的无向图有欧拉路径的充要条件是： G中奇顶点（连接的边数量为奇数的顶点）的数目等于0或者2。 连通的无向图是欧拉环（存在欧拉回路）的充要条件是： G中每个顶点的度都是偶数。 定理二 如果连通无向图G 有 2k 个奇顶点，那么它可以用 k 笔画成，并且至少要用 k 笔画成 对有向图来说，一笔画不仅指遍历所有边，而且要遵循正确的方向。 严谨地说，一个连通有向图G有欧拉路径，指
java破解微信小游戏一笔画完.zip
最新发布
10-13
java破解微信小游戏一笔画完.zipjava破解微信小游戏一笔画完.zip java破解微信小游戏一笔画完.zipjava破解微信小游戏一笔画完.zip java破解微信小游戏一笔画完.zipjava破解微信小游戏一笔画完.zip java破解微信小游戏一笔画完.zipjava破解微信小游戏一笔画完.zip java破解微信小游戏一笔画完.zipjava破解微信小游戏一笔画完.zip java破解微信小游戏一笔画完.zipjava破解微信小游戏一笔画完.zip java破解微信小游戏一笔画完.zipjava破解微信小游戏一笔画完.zip java破解微信小游戏一笔画完.zipjava破解微信小游戏一笔画完.zip java破解微信小游戏一笔画完.zipjava破解微信小游戏一笔画完.zip java破解微信小游戏一笔画完.zipjava破解微信小游戏一笔画完.zip
java实现欧拉路径_你了解欧拉回路吗？（附Java实现代码）
weixin_32532029的博客
02-28 453
文章目录一：什么是欧拉回路？二： 无向图中欧拉回路存在的条件三：如何得到欧拉回路四：Java实现一：什么是欧拉回路？不知道你有没有玩过这样一种叫“一笔画”，从某一点开始画一个图形或图案，期间笔不能从纸上离开而且每条边只能画一次。下面有三个例子，你可以先试一试看看能不能“一笔画” 第一个图其实是根本画不出来的，第二个图可以画出，但是不存在起点和终点为同一点的情况，第三个图可以轻松画出...
树形递归算法解决一笔画问题（Java）
LLittleF的博客
04-06 2156
下面要说的一笔画问题指的并不是经典的欧拉回路或汉密尔顿路径问题 而是我前几天接触的一款小游戏 ↓ 核心算法在下边，前边部分讲的是具体实现（Java） 这款游戏的玩法就是从起点（绿色点）出发，一笔画过所有的方块。部分关卡还是有一定的难度的，于是便心血来潮的想了个算法来算出正确路径。 大致的思路是比较简单的，无非就是穷举出所有的路径，找到那条经过所有格子的路径。重点在于怎么用程序实现。 如果...
一笔画（AC）DFS算法
m0_53303926的博客
12-31 922
小丁最近迷恋上一个游戏，传说中的“一笔画”游戏。那么什么是一笔画？如下图，顾名思义就是一笔可以完成的图。一笔画最基本的要求是在画图的过程中，笔不能离开纸，且笔所画过的线不能重复，最后画完所有的线便算完成虽然小丁喜欢玩这个游戏，但有时候花费半天也找不到答案。小丁听说写一个计算机程序便能判断是否可以一笔画图，所以他希望善良可爱的你来帮帮他的忙。快来帮帮弱小，可怜，又无助的小丁。
算法笔记_148:有向图欧拉回路求解(Java)
weixin_34032779的博客
04-26 326
目录 1 问题描述 2 解决方案   1 问题描述 Description A catenym is a pair of words separated by a period such that the last letter of the first word is the same as the last letter of the second. For examp...
欧拉回路程序的java实现
05-07
实现了欧拉回路的程序实现即遍历图输出欧拉回路
一笔画程序 OneTouchDraw
01-13
一笔画小游戏的解答程序，可以手动画出图像，显示一笔画结果
一笔画问题
12-02
图的应用之一：一笔画问题 编程找出图的一笔画路线
欧拉回路和一笔画问题
09-30
信息学竞赛系列教程，欧拉回路和欧拉路径的基本性质，一笔画问题的两种不同解法。
一笔画问题的c++实现
05-25
NULL 博文链接：https://dlzjp123.iteye.com/blog/481358
基于Qt的一笔画小软件（欧拉回路算法的演示）
02-25
这是一款基于QT实现的一笔画软件，该项目的背景起源于中国邮递员问题，本程序用来模拟邮递员选择最短路径送完所有快递再回到出发点。具体来说，用户可以通过的工具栏在画板区域进行画点并连线，最后形成的图如果能够一笔画完，本程序将以动画的形式在画板上描绘出一笔画的路径，此即邮递员派送快递的最短路径。
java 一笔画问题
04-26
java 编写的小游戏 适合初学者学习
算法：通过迪杰斯特拉(Dijkstra)算法，求出图中任意顶点到其他顶点的最短路径
热门推荐
weixin_39448458的博客
09-11 2万+
请看如下的示例图，该图有 V1-V7 七个顶点，每个顶点之间的距离、路径走向如图所示： 假设这是一幅地图，我们很多时候都需要搜路径，比如从家到公司的路线图（也就是说，家是一个点，公司是另一个点）。上图的各个点可以想象成分岔路口。当然，如果你不在分岔路口，你在某条路上，也可以理解为你在一个有两条路的分岔路口上，也就是向前行或者向后退。由于有单行道的存在，所以有的路是只能单向通行的（本示例图全部为单...
算法：通过克鲁斯卡尔(Kruskal)算法，求出图的最小生成树
weixin_39448458的博客
10-27 8527
之前我给大家分享过用普利姆(Prim)算法来求出图的最小生成树(点我去看看)，今天我再给大家分享一个也是求图的最小生成树的克鲁斯卡尔(Kruskal)算法 这两个算法都是求图的最小生成树，有什么区别呢： 1、Prim算法是通过一个点来进行动态扩张，Kruskal是从零开始逐渐加入最小权的边 2、Prim算法是动态规划算法，Kruskal是将所有的边都遍历一遍，看哪些是组成最小生成树的边 接下来我们...
算法：根据四色定理(Four color theorem)，求出地图的所有着色方案
weixin_39448458的博客
12-08 7920
地图着色，需要每一个区域都使用一种颜色来进行填充，然后为了与相邻接壤的区域分开，就要求两个接壤的区域需要使用不同的颜色。四色定理的意思是，最多只需要四种颜色，就可以为所有的地图进行全部区域着色，且任意两个接壤的区域都是不同的颜色。在四色定理的指导下，我用Java来实现求解任意一副地图的所有可行的区域着色方案的算法，并求解下面这幅示例地图的所有着色方案： 算法思路： 将所有的区域进行编号，从0开...
用python解决一笔画问题的程序代码
06-01
下面是使用深度优先搜索算法来解决一笔画问题的Python代码： ```python def dfs(graph, v, visited): visited[v] = True for i in graph[v]: if not visited[i]: dfs(graph, i, visited) def can_draw(graph): n = len(graph) visited = [False] * n dfs(graph, 0, visited) return all(visited) def is_eulerian(graph): n = len(graph) degree = [0] * n for i in range(n): degree[i] = len(graph[i]) odd_degree_count = sum(1 for x in degree if x % 2 == 1) return odd_degree_count == 0 or odd_degree_count == 2 def one_stroke_drawing(graph): if not is_eulerian(graph): return False if not can_draw(graph): return False return True ``` 其中，`dfs`函数用于遍历连通图，`can_draw`函数用于判断图是否连通，`is_eulerian`函数用于判断图是否存在欧拉回路或欧拉路径。最后的`one_stroke_drawing`函数即为解决一笔画问题的函数，返回值为`True`表示可以用一笔画完成，否则返回`False`。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值