刷题记录之LeetCode401-600Java版（详细注释）

目录

547. 朋友圈

---

547. 朋友圈

班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。

给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。

示例 1:
输入: 
[[1,1,0],
 [1,1,0],
 [0,0,1]]
输出: 2 
说明：已知学生0和学生1互为朋友，他们在一个朋友圈。
第2个学生自己在一个朋友圈。所以返回2。

示例 2:
输入: 
[[1,1,0],
 [1,1,1],
 [0,1,1]]
输出: 1
说明：已知学生0和学生1互为朋友，学生1和学生2互为朋友，所以学生0和学生2也是朋友，所以他们三个在一个朋友圈，返回1。

注意：
N 在[1,200]的范围内。
对于所有学生，有M[i][i] = 1。
如果有M[i][j] = 1，则有M[j][i] = 1。

class Solution {
    private void dfs(int[][] a, boolean[] visited, int i) {
        //对 i 遍历所有的 a[i][j]，
        //递归出口是全部 j 都不满足if条件 
        for(int j = 0; j < a.length; j++) {
            if(a[i][j] == 1 && !visited[j]) {
                //标记
                visited[j] = true;
                //递归接力
                dfs(a, visited, j);
            }
        }
    }
    public int findCircleNum(int[][] M) {
        //记录访问过的元素
        boolean[] visited = new boolean[M.length];
        int res = 0;
        for(int i = 0; i < M.length; i++) {
            if(!visited[i]) {
                //一个dfs生成一个朋友圈，计数一次
                dfs(M, visited, i);
                res++;
            }
        }
        return res;
    }
}

662. 二叉树最大宽度

给定一个二叉树，编写一个函数来获取这个树的最大宽度。树的宽度是所有层中的最大宽度。这个二叉树与满二叉树（full binary tree）结构相同，但一些节点为空。

每一层的宽度被定义为两个端点（该层最左和最右的非空节点，两端点间的null节点也计入长度）之间的长度。

示例 1:
输入: 

           1
         /   \
        3     2
       / \     \  
      5   3     9 

输出: 4
解释: 最大值出现在树的第 3 层，宽度为 4 (5,3,null,9)。

示例 2:
输入: 

          1
         /  
        3    
       / \       
      5   3     

输出: 2
解释: 最大值出现在树的第 3 层，宽度为 2 (5,3)。

示例 3:
输入: 

          1
         / \
        3   2 
       /        
      5      

输出: 2
解释: 最大值出现在树的第 2 层，宽度为 2 (3,2)。

示例 4:
输入: 

          1
         / \
        3   2
       /     \  
      5       9 
     /         \
    6           7
输出: 8
解释: 最大值出现在树的第 4 层，宽度为 8 (6,null,null,null,null,null,null,7)。
注意: 答案在32位有符号整数的表示范围内。

class Solution {
    //想到带下标的层次遍历
    public int widthOfBinaryTree(TreeNode root) {
        if(root == null) {
            return 0;
        }
        //节点序号，左子节点2 * num - 1，右子节点2 * num
        int num = 1;
        int depth = 1;
        //保存每一层的最左序号和最右序号
        ArrayList<Integer> left = new ArrayList<Integer>();
        left.add(1);
        ArrayList<Integer> right = new ArrayList<Integer>();
        right.add(1);

        preOrder(root, num, depth, left, right);

        //求每层的左右最大差值即可
        int maxWidth = 1;
        for(int i = 0; i < left.size(); i++) {
            maxWidth = Math.max(maxWidth, right.get(i) - left.get(i) + 1);
        }
        return maxWidth;
    }
    //这题应该用先序才对，这样可以先把list长度扩到树深度，不会丢失节点
    public void preOrder(TreeNode root, int num, int depth, 
                        ArrayList<Integer> left, ArrayList<Integer> right) {
        if(root == null) {
            return;
        }
        //list还没扩到当前树深度，就先add新节点
        if(left.size() < depth) {
            left.add(num);
            right.add(num);
        }
        //否则比较更新即可
        else {
            if(num < left.get(depth - 1)) {
                left.set(depth - 1, num);
            }
            if(num > right.get(depth - 1)) {
                right.set(depth - 1, num);
            }
        }
        preOrder(root.left, 2 * num - 1, depth + 1, left, right);
        preOrder(root.right, 2 * num, depth + 1, left, right);
    }
}