k6k4刷题--图-找环

2024年4月8日 234次阅读

原题链接：
http://www.k6k4.com/code/sshow/aaozlxizk1512721571778

给定一个有向带权图A，找出图中的环，返回构成环的所有顶点，并按顶点从小到大排序。
约定：
（1）使用邻接矩阵表示图
（2）若两个顶点i,j相连则A[i][j]=1,否则A[i][j]=0
（3）顶点编号从0开始
（4）图是有向的，需要考虑方向性
（5）图中最多存在一个环

例如：
（1）
矩阵A的邻接矩阵表示为：
0,1,0
0,0,1
1,0,0

图中的环为：0,1,2
（2）
矩阵A的邻接矩阵表示为：
0,1,0
0,0,0
1,1,0

图中不存在环（方向问题）：返回-1

输入、输出描述 输入：

A：有向图的邻接矩阵表示，若两个顶点i,j相连，则A[i][j]=1 否则A[i][j]=0
n：顶点的个数，顶点编号为：0，1，2...n-1

输出：

若存在环，则返回构成环的所有顶点，并按顶点从小到大排序。
若不存在环，则返回一个长度为1的数组，且元素值为-1

Example 输入：

A：
0,1,0
0,0,1
1,0,0
n：3

输出：

0,1,2

———————华丽分割线———————–

解题思路：

如果一个顶点p在图中的环上，则必然存在一条以p为起点同时又以p为终点的的轨迹如下：

p->a1->a2->a3->…->ak->p，用DFS递归遍历p点的各个后驱节点，只要判断这条轨迹的最后一个节点是否为p即可，为p则包含环，不为p则不存在环。

    import java.util.*;
     
    public class Main {
      private boolean[] marked;//用来标记节点是否已经被访问
      private int[] edgeTo;//记录当前节点之前路径上的所有节点
      private boolean[] onStack;
      private Stack<Integer> cycle;//记录环上的所有节点，没有环时为空
      
      public int[] solution(int[][] A,int n) {
        cycle = null;
        int[] cyclePointSort = new int[]{-1};
        marked = new boolean[n];
        onStack = new boolean[n];
        edgeTo = new int[n];
        for (int v = 0; v < n; v++)
          if (!marked[v] && cycle == null)
            dfs(A, n, v);
        if (cycle != null) {
          cycle.pop();//起点和终点是同一个点，将终点出栈
          int cycleSize = cycle.size();
          cyclePointSort = new int[cycleSize];
          int i = 0;
          for (int point : cycle)
            cyclePointSort[i++] = point;
          
          Arrays.sort(cyclePointSort);
        }
        return cyclePointSort;
      }
      
      private void dfs(int[][] A, int n, int v) {
        onStack[v] = true;
        marked[v] = true;
        for (int i = 0; i < n; i++) {
          if (A[v][i] == 1) {
            if (cycle != null)
              return;
            else if (!marked[i]) {
              edgeTo[i] = v;
              dfs(A, n, i);
            }
            else if (onStack[i]) {
              cycle = new Stack<Integer>();
              for (int x = v; x != i; x = edgeTo[x]) {
                cycle.push(x);
              }
              cycle.push(i);
              cycle.push(v);
              assert check();
            } 
          }
        }
        onStack[v] = false;
      }
      
      public boolean hasCycle() {
        return cycle != null;
      }
      
      public Iterable<Integer> cycle() {
        return cycle;
      }
      
      private boolean check() {
        if (hasCycle()) {
          int first = -1, last = -1;
          for (int v : cycle()) {
            if (first == -1)
              first = v;
            last = v;
          }
          if (first != last) {
            return false;
          }
        }
        return true;
      }
      
    }

欢迎加“算法刷题交流QQ羣（474397739）”一起研究讨论算法

点赞