[LeetCode] 547. Friend Circles Java

题目：

There are N students in a class. Some of them are friends, while some are not. Their friendship is transitive in nature. For example, if A is a direct friend of B, and B is a direct friend of C, then A is an indirect friend of C. And we defined a friend circle is a group of students who are direct or indirect friends.

Given a N*N matrix M representing the friend relationship between students in the class. If M[i][j] = 1, then the ith and jth students are direct friends with each other, otherwise not. And you have to output the total number of friend circles among all the students.

Example 1:

Input: 
[[1,1,0],
 [1,1,0],
 [0,0,1]]
Output: 2
Explanation:The 0th and 1st students are direct friends, so they are in a friend circle. 
The 2nd student himself is in a friend circle. So return 2.

Example 2:

Input: 
[[1,1,0],
 [1,1,1],
 [0,1,1]]
Output: 1
Explanation:The 0th and 1st students are direct friends, the 1st and 2nd students are direct friends, 
so the 0th and 2nd students are indirect friends. All of them are in the same friend circle, so return 1.

Note:

1. N is in range [1,200].
2. M[i][i] = 1 for all students.
3. If M[i][j] = 1, then M[j][i] = 1.

题意及分析：求朋友圈个数，若M[i][j]==1，则i,j为朋友，朋友有传递性，直接朋友或者间接朋友组成一个朋友圈。按照图论的方式来讲给出一个图的邻接矩阵，求不相邻的子图个数。我第一次用了宽度遍历，对于其中一个点M[i][j]，若该点未被遍历过，则把该点标记为已遍历，然后遍历第i,j行和i,j列（即宽度遍历），找到为1的且未被遍历过的点，重复操作。但是此方法时间复杂度较高，排名基本上在最后面了。。。 另一种是声明一个visited，用于记录遍历过的结点。每次dfs找到一个原矩阵为1的位置（除了对角线），就把这个位置的列数变成行数再dfs，如果是在同一个圈里，最终会绕回已经遍历过的行，visited为true，return 0；如果不是同一个圈，则增加1。（mat[i][j]==1这个判断相当于i的邻接点，深度优先遍历）
代码：

public class Solution {
    public int findCircleNum(int[][] M) {
        int res = 0;
        int row= M.length;
        if(row==0) return 0;
        for(int i=0;i<row;i++){         //只遍历矩阵下半部分
            for(int j=0;j<=i;j++){
                if(M[i][j]==1){     //未被遍历过的值为1的点
                    res++;
                    boolean[] rowVisited = new boolean[row];        //记录已经遍历过的行
                    boolean[] colVisited = new boolean[row];        //记录已经遍历过的列
                    Integer[] index = {i,j};
                    Queue<Integer[]> queue = new LinkedList<>();
                    queue.add(index);  //查找该个点组成的朋友圈,能和该点组成朋友圈的点满足在i,j行或者i,j列
                    while(!queue.isEmpty()){

                        Integer[] val = queue.poll();
                        int x =val[0],y=val[1];
                        if(M[x][y]==1){     //防止重复
                            M[x][y] = 2;        //将遍历过的点置为2
                            if(!rowVisited[x]){
                                for(int m=0;m<=x;m++){      //x行
                                    Integer[]  addIndex = {x,m};
                                    if(M[x][m]==1 && !queue.contains(addIndex)) queue.add(addIndex);
                                }
                                rowVisited[x]=true;
                            }
                            if(!rowVisited[y]){
                                for(int n=0;n<=y;n++){         //第y行
                                    Integer[]  addIndex = {y,n};
                                    if(M[y][n]==1) queue.add(addIndex);
                                }
                                rowVisited[y]=true;
                            }

                            if(!colVisited[x]){
                                for(int m=x;m<row;m++){     //第x列
                                    Integer[]  addIndex = {m,x};
                                    if(M[m][x]==1&& !queue.contains(addIndex)) queue.add(addIndex);
                                }
                                colVisited[x]=true;
                            }

                            if(!colVisited[y]){
                                for(int m=y;m<row;m++){     //第y列
                                    Integer[]  addIndex = {m,y};
                                    if(M[m][y]==1&& !queue.contains(addIndex)) queue.add(addIndex);
                                }
                                colVisited[y]=true;
                            }
                        }

                    }
                }
            }
        }
        return res;
    }
}

 代码：

public class Solution {
    
    public int findCircleNum(int[][] M) {
        if (M == null && M.length == 0)
            return 0;
        int n = M.length;
        boolean[] visited = new boolean[n];
        int count = 0;
        //如果dfs大于0，说明有未遍历的结点
        //只需要遍历所有结点
        for (int i = 0; i < n; i++)
            if (dfs(M, i, visited) > 0)
                count++;
        return count;
    }

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