图的广度优先搜索（BFS）与图的深度优先搜索（DFS）详解及其代码实现

深碍√TFBOYSˉ_ 2023-05-28 05:05 14阅读 0赞

**参考文章：**[https://blog.csdn.net/weixin\_40953222/article/details/80544928][https_blog.csdn.net_weixin_40953222_article_details_80544928]

**1.概述**

与树的遍历类似，图的遍历也是从图中某个顶点出发，然后按照某种方法对图中所有顶点进行访问，且仅访问一次  
但是图的遍历相对树而言要更为复杂，因为图中的任意顶点都可能与其他顶点相邻，所以在图的遍历中必须记录已被访问的顶点，避免重复访问  
根据搜索路径的不同，可以将遍历图的方法分为两种：广度优先搜索（BFS）与深度优先搜索（DFS）

注意：图的广度优先遍历（搜索） 与 图的深度优先遍历（搜索） 不一定 会得到相同的顶点输出顺序

**2.图的基本概念**

2.1无向图与有向图

顶点对(u,v)是无序的，即（u,v）和（v,u）是同一条边，常用一对圆括号表示

![70][]

图2.1.1 无向图

顶点对<u,v>是有序的，它是指从顶点u到顶点 v的一条有向边，其中u是有向边的始点，v是有向边的终点，常用一对尖括号表示

![70 1][]

图2.1.2 有向图

2.2权与网

图的每条边上可能存在具有某种含义的数值，称该数值为该边上的权，而这种带权的图被称为网

**3.广度优先搜索（BFS）**

3.1广度优先搜索的基本思路

广度优先搜索类似于树的层次遍历过程，它需要借助一个队列来实现，如图2.1.1所示，要想遍历从v0到v6的每一个顶点，我们可以设v0为第一层，v1、v2、v3为第二层，v4、v5为第三层，v6为第四层，再逐个遍历每一层的每个顶点  
具体过程如下：  
1.创建一个visited数组，用来记录已经被访问过的顶点，创建一个队列，用来存放每一层的顶点，初始化图G  
2.从图中的v0开始访问，将visited\[v0\]的值设置为true，表示该顶点已经被访问，同时将v0入队  
3.只要队列不空，则重复如下操作：  
(1)队头顶点u出队  
(2)依次检查u的所有邻接顶点w，若visited\[w\]的值为false，则访问w，并将visited\[w\]置为true，同时将w入队  
3.2图解过程

白色表示未被访问，黑色表示已访问  
visited数组：0表示未访问，1表示以访问  
队列：队头出元素，队尾进元素

1.初始时全部顶点均未被访问，visited数组初始化为0，队列中没有元素

![70 2][]

2.访问顶点v0，并置visited\[0\]的值为1，同时将v0入队

![70 3][]

3.将v0出队，访问v0的邻接点v2，判断visited\[2\]，因为visited\[2\]的值为0，访问v2 ，将visited\[2\]置为1，并将v2入队

![70 4][]

4.访问v0邻接点v1，判断visited\[1\],因为visited\[1\]的值为0，访问v1 ，将visited\[1\]置为0，并将v1入队

![70 5][]

5.访问v0邻接点v3,判断visited\[3\],因为visited\[3\]的值为0，访问v3, 将visited\[3\]置为0，并将v3入队

![70 6][]

6.v0的全部邻接点均已被访问完毕，将队头元素v2出队，开始访问v2的所有邻接点

开始访问v2邻接点v0，判断visited\[0\]，因为其值为1，不进行访问

继续访问v2邻接点v4，判断visited\[4\]，因为其值为0，访问v4，将visited\[4\]置为1，并将v4入队

![70 7][]

7. v2的全部邻接点均已被访问完毕，将队头元素v1出队，开始访问v1的所有邻接点

开始访问v1邻接点v0，因为visited\[0\]值为1，不进行访问

继续访问v1邻接点v4，因为visited\[4\]的值为1，不进行访问

继续访问v1邻接点v5，因为visited\[5\]值为0，访问v5，将visited\[5\]置为1，并将v5入队

![70 8][]

8.v1的全部邻接点均已被访问完毕，将队头元素v3出队，开始访问v3的所有邻接点

开始访问v3邻接点v0，因为visited\[0\]值为1，不进行访问

继续访问v3邻接点v5，因为visited\[5\]值为1，不进行访问

![70 9][]

9.v3的全部邻接点均已被访问完毕，将队头元素v4出队，开始访问v4的所有邻接点

开始访问v4的邻接点v2，因为visited\[2\]的值为1，不进行访问

继续访问v4的邻接点v1，因为visited\[1\]的值为1，不进行访问

继续访问v4的邻接点v6，因为visited\[6\]的值为0，访问v6，将visited\[6\]值为1，并将v6入队

![70 10][]

10.v4的全部邻接点均已被访问完毕，将队头元素v5出队，开始访问v5的所有邻接点

开始访问v5邻接点v1，因为visited\[1\]的值为1，不进行访问

继续访问v5邻接点v3，因为visited\[3\]的值为1，不进行访问

继续访问v5邻接点v6，因为visited\[6\]的值为1，不进行访问

![70 11][]

11.v5的全部邻接点均已被访问完毕，将队头元素v6出队，开始访问v6的所有邻接点

开始访问v6邻接点v4，因为visited\[4\]的值为1，不进行访问

继续访问v6邻接点v5，因为visited\[5\]的值文1，不进行访问

![70 12][]

12.队列为空，退出循环，全部顶点均访问完毕

![70 13][]

3.3代码实现

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjQ1MDk5_size_16_color_FFFFFF_t_70][]

核心代码

/**
     * 图的广度优先遍历 算法
     *
     * @param initVertex 从哪个顶点开始遍历
     */
    public void bfs(String initVertex) {
        // 记录顶点是否已经被访问，数组的下标即为顶点在图中顶点集合的索引
        boolean[] visited = new boolean[this.vertexList.size()];
        // 记录顶点的访问顺序，用linkedList模拟队列
        LinkedList<String> linkedList = new LinkedList<>();
    
        // 获取initVertex顶点在图中顶点集合的对应索引
        int indexVertex = this.getIndexOfVertex(initVertex);
    
        // 输出顶点initVertex
        System.out.print(initVertex + "\t");
        // 标记为已经被访问
        visited[indexVertex] = true;
        // 加入到队列中
        linkedList.addLast(initVertex);
    
        while(!linkedList.isEmpty()) {
            // 取出队列linkedList中的第一个元素
            String vertex = linkedList.removeFirst();
            // 获取顶点vertex在图中顶点集合的对应索引
            int index = this.getIndexOfVertex(vertex);
            // 记录顶点所在集合的索引对应的值
            String valueOfVertex;
            for(int i = 0; i < this.vertexList.size(); i++) {
                // 队列中取出的顶点 都要与 图的顶点集合中所有顶点进行遍历比较
                // this.edgeArray[index][i] > 0 顶点连通
                // !visited[i] 顶点未被访问
                if(this.edgeArray[index][i] > 0 && !visited[i]) {
                    // 获取顶点所在集合的索引对应的值
                    valueOfVertex = this.getValueOfVertex(i);
                    System.out.print(valueOfVertex + "\t");
                    // 标记为已经被访问
                    visited[i] = true;
                    // 加入到队列中
                    linkedList.addLast(valueOfVertex);
                }
            }
        }
    }

完整代码

package com.zzb.datastructure.graph;
    
    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;
    
    /**
     * @Auther: Administrator
     * @Date: 2020/3/27 12:50
     * @Description: 图的广度优先遍历（搜索） 与 图的深度优先遍历（搜索） 代码实现
     *
     * 注意：图的广度优先遍历（搜索） 与 图的深度优先遍历（搜索） 不一定 会得到相同的顶点输出顺序
     */
    public class BFSandDFSofGraph {
        public static void main(String[] args) {
            // 顶点总数
            int totalOfVertex = 5;
            // 顶点值
            String[] vertexArray = {"A", "B", "C", "D", "E"};
            // 创建图对象
            Graph graph = new Graph(totalOfVertex);
            // 添加定点
            for(int i = 0; i < vertexArray.length; i++) {
                graph.addVertex(vertexArray[i]);
            }
            // 添加边
            // A-B A-C B-C B-D B-E
            graph.addEdge(0, 1, 1);
    		graph.addEdge(0, 2, 1);
    		graph.addEdge(1, 2, 1);
    		graph.addEdge(1, 3, 1);
    		graph.addEdge(1, 4, 1);
    		// 显示图的邻接矩阵
            graph.showGraph();
          /*0	1	1	0	0
            1	0	1	1	1
            1	1	0	0	0
            0	1	0	0	0
            0	1	0	0	0*/
            // 图的广度优先遍历
            graph.bfs("A");
            /*A	  B	  C	  D	  E*/
        }
    }
    
    /**
     * 图对象
     */
    class Graph implements Serializable {
        private static final long serialVersionUID = -6363517010637626584L;
    
        // 存储图中各个顶点的集合
        private List<String> vertexList;
        // 存储图中各条边的邻接矩阵
        private int[][] edgeArray;
        // 存储图中边的总数
        private int totalOfedge;
    
        /**
         * 构造初始化
         *
         * @param totalOfVertex 顶点个数
         */
        public Graph(int totalOfVertex) {
            // 顶点个数
            vertexList = new ArrayList<>(totalOfVertex);
            // 邻接矩阵大小
            edgeArray = new int[totalOfVertex][totalOfVertex];
            // 边的总数
            totalOfedge = 0;
        }
    
        /**
         * 图的广度优先遍历 算法
         *
         * @param initVertex 从哪个顶点开始遍历
         */
        public void bfs(String initVertex) {
            // 记录顶点是否已经被访问，数组的下标即为顶点在图中顶点集合的索引
            boolean[] visited = new boolean[this.vertexList.size()];
            // 记录顶点的访问顺序，用linkedList模拟队列
            LinkedList<String> linkedList = new LinkedList<>();
    
            // 获取initVertex顶点在图中顶点集合的对应索引
            int indexVertex = this.getIndexOfVertex(initVertex);
    
            // 输出顶点initVertex
            System.out.print(initVertex + "\t");
            // 标记为已经被访问
            visited[indexVertex] = true;
            // 加入到队列中
            linkedList.addLast(initVertex);
    
            while(!linkedList.isEmpty()) {
                // 取出队列linkedList中的第一个元素
                String vertex = linkedList.removeFirst();
                // 获取顶点vertex在图中顶点集合的对应索引
                int index = this.getIndexOfVertex(vertex);
                // 记录顶点所在集合的索引对应的值
                String valueOfVertex;
                for(int i = 0; i < this.vertexList.size(); i++) {
                    // 队列中取出的顶点 都要与 图的顶点集合中所有顶点进行遍历比较
                    // this.edgeArray[index][i] > 0 顶点连通
                    // !visited[i] 顶点未被访问
                    if(this.edgeArray[index][i] > 0 && !visited[i]) {
                        // 获取顶点所在集合的索引对应的值
                        valueOfVertex = this.getValueOfVertex(i);
                        System.out.print(valueOfVertex + "\t");
                        // 标记为已经被访问
                        visited[i] = true;
                        // 加入到队列中
                        linkedList.addLast(valueOfVertex);
                    }
                }
            }
    
        }
    
        /**
         * 获取顶点个数
         *
         * @return 获取顶点个数
         */
        public int getTotalOfvertex() {
            return this.vertexList.size();
        }
    
        /**
         * 显示图对应的邻接矩阵
         */
        public void showGraph() {
            for(int i = 0; i < vertexList.size(); i++) {
                for(int j = 0; j < vertexList.size(); j++) {
                    System.out.print(edgeArray[i][j] + "\t");
                }
                System.out.println();
            }
        }
    
        /**
         * 获取边的总数
         *
         * @return 获取边的总数
         */
        public int getTotalOfedge() {
            return this.totalOfedge;
        }
    
        /**
         * 获取各个定点所对应的值
         *
         * @param indexOfVertex 顶点所在集合的索引
         * @return 获取各个顶点所对应的值
         */
        public String getValueOfVertex(int indexOfVertex) {
            return this.vertexList.get(indexOfVertex);
        }
    
        /**
         * 获取各个定点所对应的索引
         *
         * @param vertex 顶点所在集合的值
         * @return 获取各个顶点所对应的索引
         */
        public int getIndexOfVertex(String vertex) {
            for(int i = 0; i < this.vertexList.size(); i++) {
                if(vertex.equals(this.vertexList.get(i))) {
                    return i;
                }
            }
            return -1;
        }
    
        /**
         * 获取两个顶点之间的权值
         *
         * @param vertex1
         * @param vertex2
         * @return 获取两个顶点之间的权值
         */
        public int getWeight(int vertex1, int vertex2) {
            return this.edgeArray[vertex1][vertex2];
        }
    
        /**
         * 向图中添加顶点
         *
         * @param vertex
         */
        public void addVertex(String vertex) {
            this.vertexList.add(vertex);
        }
    
        /**
         * 向图中添加边
         *
         * @param vertex1
         * @param vertex2
         * @param weight
         */
        public void addEdge(int vertex1, int vertex2, int weight) {
            edgeArray[vertex1][vertex2] = weight; // 无向图
            edgeArray[vertex2][vertex1] = weight; // 无向图
            this.totalOfedge++;
        }
    }

**4.深度优先搜索（DFS）**

4.1深度优先搜索的基本思路

深度优先搜索类似于树的先序遍历，具体过程如下：  
准备工作：创建一个visited数组，用于记录所有被访问过的顶点  
1.从图中v0出发，访问v0  
2.找出v0的第一个未被访问的邻接点，访问该顶点，以该顶点为新顶点，重复此步骤，直至刚访问过的顶点没有未被访问的邻接点为止  
3.返回前一个访问过的仍有未被访问邻接点的顶点，继续访问该顶点的下一个未被访问领接点  
4.重复2,3步骤，直至所有顶点均被访问，搜索结束

4.2图解过程

待续...

4.3代码实现

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjQ1MDk5_size_16_color_FFFFFF_t_70 1][]

核心代码

/**
     * 图的深度优先遍历 算法
     * @param visited 记录顶点是否已经被访问，数组的下标即为顶点在图中顶点集合的索引
     * @param initVertex 从哪个顶点开始遍历
     */
    public void dfs(boolean[] visited, String initVertex) {
        // 输出顶点initVertex
        System.out.print(initVertex + "\t");
    
        // 获取initVertex顶点在图中顶点集合的对应索引
        int indexVertex = this.getIndexOfVertex(initVertex);
    
        // 标记为已经被访问
        visited[indexVertex] = true;
    
        // 递归调用
        for(int i = 0; i < this.vertexList.size(); i++) {
            if(this.edgeArray[indexVertex][i] > 0 && !visited[i]) {
                dfs(visited, this.getVertexList().get(i));
            }
        }
    }

完整代码（包括广度优先搜索代码在内）

package com.zzb.datastructure.graph;
    
    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;
    
    /**
     * @Auther: Administrator
     * @Date: 2020/3/27 12:50
     * @Description: 图的广度优先遍历（搜索） 与 图的深度优先遍历（搜索） 代码实现
     *
     * 注意：图的广度优先遍历（搜索） 与 图的深度优先遍历（搜索） 不一定 会得到相同的顶点输出顺序
     */
    public class BFSandDFSofGraph {
        public static void main(String[] args) {
            // 顶点总数
    //        int totalOfVertex = 5;
            int totalOfVertex = 8;
    
            // 顶点值
    //        String[] vertexArray = {"A", "B", "C", "D", "E"};
            String[] vertexArray = {"1", "2", "3", "4", "5", "6", "7", "8"};
    
            // 创建图对象
            Graph graph = new Graph(totalOfVertex);
            // 添加定点
            for(int i = 0; i < vertexArray.length; i++) {
                graph.addVertex(vertexArray[i]);
            }
    
            // 添加边
            // A-B A-C B-C B-D B-E
            /*graph.addEdge(0, 1, 1);
    		graph.addEdge(0, 2, 1);
    		graph.addEdge(1, 2, 1);
    		graph.addEdge(1, 3, 1);
    		graph.addEdge(1, 4, 1);*/
    
            // 添加边
            graph.addEdge(0, 1, 1);
            graph.addEdge(0, 2, 1);
            graph.addEdge(1, 3, 1);
            graph.addEdge(1, 4, 1);
            graph.addEdge(3, 7, 1);
            graph.addEdge(4, 7, 1);
            graph.addEdge(2, 5, 1);
            graph.addEdge(2, 6, 1);
            graph.addEdge(5, 6, 1);
    
    		// 显示图的邻接矩阵
    //        graph.showGraph();
            // 图的广度优先遍历
            graph.bfs("1");
            /*1	2	3	4	5	6	7	8*/
    
            System.out.println();
    
            // 图的深度优先遍历
            // 记录顶点是否已经被访问，数组的下标即为顶点在图中顶点集合的索引
            boolean[] visited = new boolean[graph.getVertexList().size()];
            graph.dfs(visited, "1");
            /*1	2	4	8	5	3	6	7*/
        }
    }
    
    /**
     * 图对象
     */
    class Graph implements Serializable {
        private static final long serialVersionUID = -6363517010637626584L;
    
        // 存储图中各个顶点的集合
        private List<String> vertexList;
        // 存储图中各条边的邻接矩阵
        private int[][] edgeArray;
        // 存储图中边的总数
        private int totalOfedge;
    
        /**
         * 构造初始化
         *
         * @param totalOfVertex 顶点个数
         */
        public Graph(int totalOfVertex) {
            // 顶点个数
            vertexList = new ArrayList<>(totalOfVertex);
            // 邻接矩阵大小
            edgeArray = new int[totalOfVertex][totalOfVertex];
            // 边的总数
            totalOfedge = 0;
        }
    
        /**
         * 图的广度优先遍历 算法
         *
         * @param initVertex 从哪个顶点开始遍历
         */
        public void bfs(String initVertex) {
            // 记录顶点是否已经被访问，数组的下标即为顶点在图中顶点集合的索引
            boolean[] visited = new boolean[this.vertexList.size()];
            // 记录顶点的访问顺序，用linkedList模拟队列
            LinkedList<String> linkedList = new LinkedList<>();
    
            // 获取initVertex顶点在图中顶点集合的对应索引
            int indexVertex = this.getIndexOfVertex(initVertex);
    
            // 输出顶点initVertex
            System.out.print(initVertex + "\t");
            // 标记为已经被访问
            visited[indexVertex] = true;
            // 加入到队列中
            linkedList.addLast(initVertex);
    
            while(!linkedList.isEmpty()) {
                // 取出队列linkedList中的第一个元素
                String vertex = linkedList.removeFirst();
                // 获取顶点vertex在图中顶点集合的对应索引
                int index = this.getIndexOfVertex(vertex);
                // 记录顶点所在集合的索引对应的值
                String valueOfVertex;
                for(int i = 0; i < this.vertexList.size(); i++) {
                    // 队列中取出的顶点 都要与 图的顶点集合中所有顶点进行遍历比较
                    // this.edgeArray[index][i] > 0 顶点连通
                    // !visited[i] 顶点未被访问
                    if(this.edgeArray[index][i] > 0 && !visited[i]) {
                        // 获取顶点所在集合的索引对应的值
                        valueOfVertex = this.getValueOfVertex(i);
                        System.out.print(valueOfVertex + "\t");
                        // 标记为已经被访问
                        visited[i] = true;
                        // 加入到队列中
                        linkedList.addLast(valueOfVertex);
                    }
                }
            }
        }
    
        /**
         * 图的深度优先遍历 算法
         * @param visited 记录顶点是否已经被访问，数组的下标即为顶点在图中顶点集合的索引
         * @param initVertex 从哪个顶点开始遍历
         */
        public void dfs(boolean[] visited, String initVertex) {
            // 输出顶点initVertex
            System.out.print(initVertex + "\t");
    
            // 获取initVertex顶点在图中顶点集合的对应索引
            int indexVertex = this.getIndexOfVertex(initVertex);
    
            // 标记为已经被访问
            visited[indexVertex] = true;
    
            // 递归调用
            for(int i = 0; i < this.vertexList.size(); i++) {
                if(this.edgeArray[indexVertex][i] > 0 && !visited[i]) {
                    dfs(visited, this.getVertexList().get(i));
                }
            }
        }
    
        /**
         * 获取顶点个数
         *
         * @return 获取顶点个数
         */
        public int getTotalOfvertex() {
            return this.vertexList.size();
        }
    
        /**
         * 显示图对应的邻接矩阵
         */
        public void showGraph() {
            for(int i = 0; i < vertexList.size(); i++) {
                for(int j = 0; j < vertexList.size(); j++) {
                    System.out.print(edgeArray[i][j] + "\t");
                }
                System.out.println();
            }
        }
    
        /**
         * 获取各个定点所对应的值
         *
         * @param indexOfVertex 顶点所在集合的索引
         * @return 获取各个顶点所对应的值
         */
        public String getValueOfVertex(int indexOfVertex) {
            return this.vertexList.get(indexOfVertex);
        }
    
        /**
         * 获取各个定点所对应的索引
         *
         * @param vertex 顶点所在集合的值
         * @return 获取各个顶点所对应的索引
         */
        public int getIndexOfVertex(String vertex) {
            for(int i = 0; i < this.vertexList.size(); i++) {
                if(vertex.equals(this.vertexList.get(i))) {
                    return i;
                }
            }
            return -1;
        }
    
        /**
         * 获取两个顶点之间的权值
         *
         * @param vertex1
         * @param vertex2
         * @return 获取两个顶点之间的权值
         */
        public int getWeight(int vertex1, int vertex2) {
            return this.edgeArray[vertex1][vertex2];
        }
    
        /**
         * 向图中添加顶点
         *
         * @param vertex
         */
        public void addVertex(String vertex) {
            this.vertexList.add(vertex);
        }
    
        /**
         * 向图中添加边
         *
         * @param vertex1
         * @param vertex2
         * @param weight
         */
        public void addEdge(int vertex1, int vertex2, int weight) {
            edgeArray[vertex1][vertex2] = weight; // 无向图
            edgeArray[vertex2][vertex1] = weight; // 无向图
            this.totalOfedge++;
        }
    
        public List<String> getVertexList() {
            return vertexList;
        }
    
        public void setVertexList(List<String> vertexList) {
            this.vertexList = vertexList;
        }
    
        public int[][] getEdgeArray() {
            return edgeArray;
        }
    
        public void setEdgeArray(int[][] edgeArray) {
            this.edgeArray = edgeArray;
        }
    
        /**
         * 获取边的总数
         *
         * @return 获取边的总数
         */
        public int getTotalOfedge() {
            return this.totalOfedge;
        }
    
        public void setTotalOfedge(int totalOfedge) {
            this.totalOfedge = totalOfedge;
        }
    }

[https_blog.csdn.net_weixin_40953222_article_details_80544928]: https://blog.csdn.net/weixin_40953222/article/details/80544928
[70]: /images/20230528/d958cd1a32db452c8f54fcfe7dae6f13.png
[70 1]: /images/20230528/38711a483a5e4458b2cccd47a02710a1.png
[70 2]: /images/20230528/16f7d302a04f40dbb40a0ebd78650c18.png
[70 3]: /images/20230528/f1dda1f853344e77baa13c8b62fc39ee.png
[70 4]: /images/20230528/2679264731a343cd92b0843b814c64ce.png
[70 5]: /images/20230528/6240785e5aea4a819d4ebb82fa7c3e74.png
[70 6]: /images/20230528/b7366e8c739141ab8dad9c4282c4c724.png
[70 7]: /images/20230528/3f203c88455841fea3dfa96c4225ddd8.png
[70 8]: /images/20230528/85a32f854ad3405f9703284a12407faa.png
[70 9]: /images/20230528/11d4f3e7aec54fd1966b5ac7360a524f.png
[70 10]: /images/20230528/e53087945a024227a4011e576d5e3e96.png
[70 11]: /images/20230528/4e7994d7001b41d692a40183a3cd1528.png
[70 12]: /images/20230528/4d3ea69b4edb41fcaf375e1d51f6db43.png
[70 13]: /images/20230528/8b463dfa23564779bc033e6c64de2c9a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjQ1MDk5_size_16_color_FFFFFF_t_70]: /images/20230528/2aefa762f96d40caa3203efe6b3eac0f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjQ1MDk5_size_16_color_FFFFFF_t_70 1]: /images/20230528/e79ef5b53b38404aacd09327ed691730.png