代码随想录三刷day53

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

---

因为如果两个点所在的边在添加图之前如果就可以在并查集里找到了相同的根，那么这条边添加上之后 这个图一定不是树了

一、力扣463. 岛屿的周长

class Solution {
    int[][] arr = new int[][]{{0,-1},{0,1},{-1,0},{1,0}};
    boolean[][] flag;
    int count;
    public int islandPerimeter(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        flag = new boolean[m][n];
        count = 0;
        for(int i = 0; i < m; i ++){
            for(int j = 0; j < n; j ++){
                if(!flag[i][j] && grid[i][j] == 1){
                    flag[i][j] = true;
                    bfs(grid,i,j);
                }
            }
        }
        return count;
    }
    public void bfs(int[][] grid,int x, int y){
        Deque<int[]> deq = new LinkedList<>();
        deq.offerLast(new int[]{x,y});
        while(!deq.isEmpty()){
            int[] cur = deq.pollFirst();
            for(int i = 0; i < 4; i ++){
                int curX = cur[0] + arr[i][0];
                int curY = cur[1] + arr[i][1];
                if(curX < 0 || curX >= grid.length || curY < 0 || curY >= grid[0].length || grid[curX][curY] == 0){
                    count ++;
                    continue;
                }
                if(!flag[curX][curY] && grid[curX][curY] == 1){
                    deq.offerLast(new int[]{curX,curY});
                    flag[curX][curY] = true;
                }
            }
        }
    }
}

二、力扣1971. 寻找图中是否存在路径

class Solution {
    public int[] father;
    public boolean validPath(int n, int[][] edges, int source, int destination) {
        father = new int[n];
        init();
        for(int i = 0; i < edges.length; i ++){
            join(edges[i][0],edges[i][1]);
        }
        return isSame(source,destination);
    }
    public void init(){
        for(int i = 0; i < father.length; i ++){
            father[i] = i;
        }
    }
    public int find(int x){
        if(x == father[x]){
            return x;
        }
        return father[x] = find(father[x]);
    }
    public boolean isSame(int x, int y){
        int u = find(x);
        int v = find(y);
        return u == v;
    }
    public void join(int x,int y){
        int u = find(x);
        int v = find(y);
        if(u == v){
            return;
        }
        father[u] = v;
    }
}

三、力扣684. 冗余连接

class Solution {
    private int[] father = new int[1001];
    public int[] findRedundantConnection(int[][] edges) {
        init();
        int[] res = new int[2];
        for(int[] arr : edges){
            if(isSame(arr[0],arr[1])){
                res[0] = arr[0];
                res[1] = arr[1];
            }else{
                join(arr[0],arr[1]);
            }
        }
        return res;
    }
    public void init(){
        for(int i = 0; i < father.length; i ++){
            father[i] = i;
        }
    }
    public int find(int x ){
        if(x == father[x]){
            return x;
        }
        return father[x] = find(father[x]);
    }
    public void join(int x, int y){
        int u = find(x);
        int v = find(y);
        if( u == v){
            return;
        }
        father[u] = v;
    }
    public boolean isSame(int x, int y){
        int u = find(x);
        int v = find(y);
        return u == v;
    }
}

四、力扣685. 冗余连接 II

class Solution {

    private static final int N = 1010;  // 如题：二维数组大小的在3到1000范围内
    private int[] father;
    public Solution() {
        father = new int[N];

        // 并查集初始化
        for (int i = 0; i < N; ++i) {
            father[i] = i;
        }
    }

    // 并查集里寻根的过程
    private int find(int u) {
        if(u == father[u]) {
            return u;
        }
        father[u] = find(father[u]);
        return father[u];
    }

    // 将v->u 这条边加入并查集
    private void join(int u, int v) {
        u = find(u);
        v = find(v);
        if (u == v) return ;
        father[v] = u;
    }

    // 判断 u 和 v是否找到同一个根，本题用不上
    private Boolean same(int u, int v) {
        u = find(u);
        v = find(v);
        return u == v;
    }

    /**
     * 初始化并查集
     */
    private void initFather() {
        // 并查集初始化
        for (int i = 0; i < N; ++i) {
            father[i] = i;
        }
    }

    /**
     * 在有向图里找到删除的那条边，使其变成树
     * @param edges
     * @return 要删除的边
     */
    private int[] getRemoveEdge(int[][] edges) {
        initFather();
        for(int i = 0; i < edges.length; i++) {
            if(same(edges[i][0], edges[i][1])) { // 构成有向环了，就是要删除的边
                return edges[i];
            }
            join(edges[i][0], edges[i][1]);
        }
        return null;
    }

    /**
     * 删一条边之后判断是不是树
     * @param edges
     * @param deleteEdge 要删除的边
     * @return  true: 是树， false： 不是树
     */
    private Boolean isTreeAfterRemoveEdge(int[][] edges, int deleteEdge)
    {
        initFather();
        for(int i = 0; i < edges.length; i++)
        {
            if(i == deleteEdge) continue;
            if(same(edges[i][0], edges[i][1])) { // 构成有向环了，一定不是树
                return false;
            }
            join(edges[i][0], edges[i][1]);
        }
        return true;
    }

    public int[] findRedundantDirectedConnection(int[][] edges) {
        int[] inDegree = new int[N];
        for(int i = 0; i < edges.length; i++)
        {
            // 入度
            inDegree[ edges[i][1] ] += 1;
        }

        // 找入度为2的节点所对应的边，注意要倒序，因为优先返回最后出现在二维数组中的答案
        ArrayList<Integer> twoDegree = new ArrayList<Integer>();
        for(int i = edges.length - 1; i >= 0; i--)
        {
            if(inDegree[edges[i][1]] == 2) {
                twoDegree.add(i);
            }
        }

        // 处理图中情况1 和 情况2
        // 如果有入度为2的节点，那么一定是两条边里删一个，看删哪个可以构成树
        if(!twoDegree.isEmpty())
        {
            if(isTreeAfterRemoveEdge(edges, twoDegree.get(0))) {
                return edges[ twoDegree.get(0)];
            }
            return edges[ twoDegree.get(1)];
        }

        // 明确没有入度为2的情况，那么一定有有向环，找到构成环的边返回就可以了
        return getRemoveEdge(edges);
    }
}