挑战程序设计竞赛（算法和数据结构）——15.3 关节点的JAVA实现

Posted 2022-01-31 小乖乖的臭坏坏

题目：

代码：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class ArticulationPoint 
    public static void main(String[] args) 
        Scanner cin = new Scanner(System.in);
        int N = cin.nextInt();
        int m = cin.nextInt();
        ArrayList<Integer> G[] = new ArrayList[N];
        int[] prenum = new int[N];
        int[] parent = new int[N];
        int lowest[] = new int[N];
        boolean visited[] = new boolean[N];
        for (int i=0;i<N;i++)
            G[i] = new ArrayList<>();
        
        for (int i=0;i<m;i++)
            int s = cin.nextInt();
            int t = cin.nextInt();
            G[s].add(t);
            G[t].add(s);
        

        art_point(N, visited, prenum, parent, lowest,G);
    

    public static void art_point(int N, boolean[] visited, int[]  prenum, int[]  parent, int[]  lowest, ArrayList<Integer> G[])
        int timer = 1;
        //计算lowest
        dfs(0, -1, visited, prenum, parent, lowest, timer, G);//0==root

        HashSet<Integer> ap = new HashSet<Integer>();
        int np = 0;
        for (int i=1;i<N;i++)
            int p = parent[i];
            if(p==0)np++;
            else if(prenum[p]<=lowest[i])ap.add(p);
        
        if(np>1)ap.add(0);
        for (int element : ap)
            System.out.println(element);
        
    

    public static void dfs(int current, int prev, boolean[] visited, int[]  prenum, int[]  parent, int[]  lowest, int timer, ArrayList<Integer> G[])
        //访问节点current之后立刻执行的处理;current为当前节点，prev为上一节点
        //让当前节点的顺序prenum和比较直lowest设置为timer。
        prenum[current] = lowest[current] = timer;
        //timer值增加
        timer++;

        //当前节点状态设置为已被访问过了
        visited[current] = true;

        //定义下一节点
        int next;

        //针对当前节点的所有邻接点
        for (int i=0;i<G[current].size();i++)
            next = G[current].get(i);//next为current的邻接点
            if(!visited[next])//如果邻接点没有被访问过
                //即将通过节点current访问节点next时执行的处理
                parent[next] = current;//先将next的父节点设置为current

                //对下一个几点next执行dfs操作
                dfs(next, current, visited, prenum, parent, lowest, timer, G);

                //节点next搜索完毕之后立刻执行的处理
                lowest[current] = Math.min(lowest[current], lowest[next]);
            else if(next!=prev)//如果邻接点被访问过但下一个节点不等于
                //边current-->next为Back-edge时的处理
                lowest[current] = Math.min(lowest[current], prenum[next]);
            
        
        //节点current搜索完毕之后立刻执行的处理
    

输入1：

4 4
0 1
0 2
1 2
2 3

输出1：

2

输入2：

8 10
0 1
1 2
0 2
0 3
2 3
3 4
3 5
5 6
5 7
6 7

输出2：

3
5

输入3：

8 10
0 1
0 2
1 2
1 3
2 3
3 4
4 6
4 7
4 5
5 7

输出3：

3
4