并集

 

有n个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。
省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。
给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。
返回矩阵中省份的数量。

输入：isConnected = [[1,1,0],[1,1,0],[0,0,1]]
输出：2
输入：isConnected = [[1,0,0],[0,1,0],[0,0,1]]
输出：3

提示：
1 <= n <= 200
n == isConnected.length
n == isConnected[i].length
isConnected[i][j] 为 1 或 0
isConnected[i][i] == 1
isConnected[i][j] == isConnected[j][i]
https://leetcode.cn/problems/number-of-provinces

 

package com.com.onetest;

import java.util.*;

public class MergeSolution {

    public static void main(String[] args) {
        test();
    }

    private static void test() {
        int[][] isConnected_1 = {
                {1, 1, 0},
                {1, 1, 0},
                {0, 0, 1}
        };//2
        int[][] isConnected_2 = {
                {1, 0, 0},
                {0, 1, 0},
                {0, 0, 1}
        };//3
        int[][] isConnected_3 = {
                {1, 0, 0, 1},
                {0, 1, 1, 0},
                {0, 1, 1, 1},
                {1, 0, 1, 1}
        };//1

        //通过率：111/113
        System.out.println(findCircleNum_1(isConnected_2));
        //通过率：113/113
        System.out.println(findCircleNum_2(isConnected_2));
    }

    public static int findCircleNum_1(int[][] isConnected) {
        int size = isConnected.length;
        List<Set<Integer>> list = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.println("i:" + i + ", j:" + j);
                insert(list, i, j, isConnected);
            }
        }

        return list.size();
    }

    private static void insert(List<Set<Integer>> list, int i, int j, int[][] isConnected) {
        int iIndex = -1, jIndex = -1;
        int listSize = list.size();
        for (int k = 0; k < listSize; k++) {
            Set set = list.get(k);
            if (set.contains(i)) {
                iIndex = k;
            }

            if (set.contains(j)) {
                jIndex = k;
            }
        }

        if (isConnected[i][j] == 1) {
            if (iIndex == -1 && jIndex == -1) {
                Set<Integer> set = new HashSet();
                set.add(i);
                set.add(j);
                list.add(set);
            } else if (iIndex != -1 && jIndex == -1) {
                Set<Integer> set = list.get(i);
                set.add(j);

            } else if (iIndex == -1 && jIndex != -1) {
                Set<Integer> set = list.get(j);
                set.add(i);
            } else if (iIndex != -1 && jIndex != -1 && iIndex != jIndex) {
                Set<Integer> iSet = list.get(iIndex);
                Set<Integer> jSet = list.get(jIndex);
                iSet.addAll(jSet);
                list.remove(jSet);
            }
        } else {
            if (iIndex == -1) {
                Set<Integer> set = new HashSet();
                set.add(i);
                list.add(set);
            }

            if (jIndex == -1) {
                Set<Integer> set = new HashSet();
                set.add(j);
                list.add(set);
            }
        }

        for (Set set : list) {
            System.out.println(set);
        }
        System.out.println("-------------");
    }


    public static int findCircleNum_2(int[][] isConnected) {
        int size = isConnected.length;
        boolean[] visited = new boolean[size];
        int count = 0;
        for (int i = 0; i < size; i++) {
            if (!visited[i]) {
                count++;
                dfs(visited, i, isConnected);
            }
        }

        return count;
    }

    private static void dfs(boolean visited[], int i, int[][] isConnected) {
        visited[i] = true;
        for (int j = 0; j < visited.length; j++) {
            if (!visited[j] && isConnected[i][j] == 1) {
                dfs(visited, j, isConnected);
            }
        }
    }
}