蓝桥杯定向刷题：DFS篇

1.二叉树的所有叶子节点

给定一个二叉树，返回所有从根节点到叶子节点的路径。
说明: 叶子节点是指没有子节点的节点。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        if(root == null){
            ArrayList<String> list = new ArrayList<String>();
            return list;
        }else if(root.right == null && root.left == null){
            ArrayList<String> list = new ArrayList<String>();
            list.add(Integer.toString(root.val));
            return list;
        }else{
            ArrayList<String> list = new ArrayList<String>();
            String tempstr = Integer.toString(root.val).concat("->");
            if(root.left != null){
                ArrayList<String> temp = (ArrayList<String>)binaryTreePaths(root.left);
                for(int i = 0; i < temp.size(); i++){
                    list.add(tempstr.concat(temp.get(i)));
                }
            }
            if(root.right != null){
                ArrayList<String> temp = (ArrayList<String>)binaryTreePaths(root.right);
                for(int i = 0; i < temp.size(); i++){
                    list.add(tempstr.concat(temp.get(i)));
                }
            }
            return list;
        }
    }
}

经验：
（1）递归DFS中间使用函数返回值需要强制类型转换，不然抽象类List无法使用。
（2）水题一遍过

2.N叉树的最大深度

给定一个 N 叉树，找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

/*
// Definition for a Node.
class Node {
    public int val;
    public List children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public int maxDepth(Node root) {
        if(root == null)
            return 0;
        else if(root.children.size() == 0)
            return 1;
        else{
            int max = 0;
            for(int i = 0; i < root.children.size(); i++){
                int temp = maxDepth(root.children.get(i));
                if(max < temp)
                    max = temp;
            }
            return max  + 1;
        }       
    }
}

经验：
水题一遍过

3.员工的重要性

给定一个保存员工信息的数据结构，它包含了员工 唯一的 id ，重要度 和 直系下属的 id 。
比如，员工 1 是员工 2 的领导，员工 2 是员工 3 的领导。他们相应的重要度为 15 , 10 , 5 。那么员工 1 的数据结构是 [1, 15, [2]] ，员工 2的 数据结构是 [2, 10, [3]] ，员工 3 的数据结构是 [3, 5, []] 。注意虽然员工 3 也是员工 1 的一个下属，但是由于 并不是直系 下属，因此没有体现在员工 1 的数据结构中。
现在输入一个公司的所有员工信息，以及单个员工 id ，返回这个员工和他所有下属的重要度之和。

/*
// Definition for Employee.
class Employee {
    public int id;
    public int importance;
    public List subordinates;
};
*/

class Solution {
    
    public int getImportance(List<Employee> employees, int id) {
        int flag = 0;
        for(int i = 0; i < employees.size(); i++){
            if(employees.get(i).id == id){
                flag = 1;
                ArrayList<Integer> temp = (ArrayList<Integer>)employees.get(i).subordinates;
                if(temp.size() == 0)
                    return employees.get(i).importance;
                else{
                    int sum = 0;
                    for(int j = 0; j < temp.size(); j++){
                        sum += getImportance(employees, temp.get(j));
                    }
                    return sum + employees.get(i).importance;
                }
            }
        }
        if(flag == 0)
            return 0;
        else
            return 0;
    }
}

经验：
DFS的小变种，远离还是相同的。

4.图像渲染

有一幅以二维整数数组表示的图画，每一个整数表示该图画的像素值大小，数值在 0 到 65535 之间。
给你一个坐标 (sr, sc) 表示图像渲染开始的像素值（行 ，列）和一个新的颜色值 newColor，让你重新上色这幅图像。
为了完成上色工作，从初始坐标开始，记录初始坐标的上下左右四个方向上像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应四个方向上像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为新的颜色值。
最后返回经过上色渲染后的图像。

class Solution {
    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
        dfs(image, sr, sc, newColor, image[sr][sc]);
        return image;
    }

    public void dfs(int[][] image, int sr, int sc, int newColor, int oldColor){
        if(!(sr < 0 || sr >= image.length || sc < 0 || sc >= image[0].length)){
            if(image[sr][sc] == oldColor && image[sr][sc] != newColor){
                image[sr][sc] = newColor;
                dfs(image, sr - 1, sc, newColor, oldColor);
                dfs(image, sr + 1, sc, newColor, oldColor);
                dfs(image, sr, sc - 1, newColor, oldColor);
                dfs(image, sr, sc + 1, newColor, oldColor);
            }
        }
    }
}

经验：
此题的题干描述并不是很清楚，基本靠示例猜题目。
需要剪去newColor和oldColor一样的情况，不然会发生栈溢出（StackOverFlowError）。

5.叶子相似的树

请考虑一棵二叉树上所有的叶子，这些叶子的值按从左到右的顺序排列形成一个 叶值序列 。
举个例子，如上图所示，给定一棵叶值序列为 (6, 7, 4, 9, 8) 的树。
如果有两棵二叉树的叶值序列是相同，那么我们就认为它们是 叶相似 的。
如果给定的两个头结点分别为 root1 和 root2 的树是叶相似的，则返回 true；否则返回 false 。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    ArrayList<Integer> list1 = new ArrayList<Integer>();
    ArrayList<Integer> list2 = new ArrayList<Integer>();
    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
        dfs(root1, 1);
        dfs(root2, 2);
        if(list1.size() != list2.size())
            return false;
        else{
            int flag = 0;
            for(int i = 0; i < list2.size(); i++){
                if(list1.get(i) != list2.get(i)){
                    flag = 1;
                    return false;
                }
            }
            if(flag == 0)
                return true;
            else
                return false;
        }
    }

    public void dfs(TreeNode root, int flag){
        if(root == null)
            return;
        else if(root.left == null && root.right == null){
            if(flag == 1){
                list1.add(root.val);
                return;
            }else{
                list2.add(root.val);
                return;
            }
        }else{
            dfs(root.left, flag);
            dfs(root.right, flag);
        }
    }
}

经验：
水题。