7月算法训练------第十五天（深度优先算法）解题报告

7月算法训练------第十五天（深度优先算法）解题报告

题目类型：深度优先算法
题目难度：中等

第一题、2331. 计算布尔二叉树的值

1. 题目链接：2331. 计算布尔二叉树的值
2. 思路分析：
   本题很简单，运用递归，代码也很简单；当节点值为0或1时，表示这个节点是叶子节点，就把节点所带表的值直接返回。
   当节点代表或时，就将 “左节点的值||右节点的值” 返回。
   当节点代表与时，就将 “左节点的值&&右节点的值” 返回。
3. 代码：

/**
 * 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 boolean evaluateTree(TreeNode root) {
        if(root.val == 1){
            return true;
        }
        if(root.val == 0){
            return false;
        }
        if(root.val == 2){
            return evaluateTree(root.left) || evaluateTree(root.right);
        }
        if(root.val == 3){
            return evaluateTree(root.left) && evaluateTree(root.right);
        }
        return true;
    }
}

第二题、951. 翻转等价二叉树

1. 题目链接：951. 翻转等价二叉树
2. 思路分析：
   运用递归：
   如果root1和root2为空，则返回true；
   如果root1为空且root2不为空，或者root1不为空且root2为空，则返回false；
   当两个节点值相等时，进行判断：
   如果两个节点的左节点相等，且右节点相等时，就返回true；
   如果root1的左和root2的右相等，且root1的右和root2的左相等，则返回true；
   否则返回false；
3. 代码：

/**
 * 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 boolean flipEquiv(TreeNode root1, TreeNode root2) {
        if(root1 == null && root2 == null){
            return true;
        } else if((root1 == null && root2 != null) || (root1 != null && root2 == null)){
            return false;
        }
        
        if(root1.val == root2.val){
            if(flipEquiv(root1.left, root2.left) && flipEquiv(root1.right, root2.right)){
                return true;
            }
            if(flipEquiv(root1.left, root2.right) && flipEquiv(root1.right, root2.left)){
                return true;
            }  
        }else{
            return false;
        }
        return false;
    }
}

第三题、1992. 找到所有的农场组

1. 题目链接：1992. 找到所有的农场组
2. 思路分析：
   对整个图进深度优先算法，记录每次的最大值。
3. 代码：

class Solution {
    private int row;
    private int col;

    public int[][] findFarmland(int[][] land) {
        row = land.length;
        col = land[0].length;

        List<int[]> list = new ArrayList<>();
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                if(land[i][j]==1){
                    int[] landpos = new int[4];
                    landpos[0] = i;
                    landpos[1] = j;
                    dfs(land,i,j,landpos);
                    list.add(landpos);
                }
            }
        }
        int size = list.size();
        int[][] ans = new int[size][4];
        for(int i=0;i<size;i++){
            ans[i] = list.get(i);
        }
        return ans;
    }

    private void dfs(int[][] land,int x,int y,int[] res){
         if(x>=row || y>=col || land[x][y]!=1){
             return;
         }
         land[x][y] = 2;
         dfs(land,x+1,y,res);
         dfs(land,x,y+1,res);
         if(res[2]==0 && res[3]==0){
             res[2] = x;
             res[3] = y;
         }
    }
}

第四题、652. 寻找重复的子树

1. 题目链接：652. 寻找重复的子树
2. 思路分析：
   将以root为根节点的树序列化，一棵树徐立华的结果唯一，我们用一个map集合存放这个序列化结果，如果map里面已经有这个序列化结果，就将该节点存入List中。递归求解。
3. 代码：

/**
 * 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 {
    List<TreeNode> count;
    Map<String, Integer> ma;
    public List<TreeNode> findDuplicateSubtrees(TreeNode root) {
        count = new ArrayList();
        ma = new HashMap();
        child(root);
        return count;
    }
    public String child(TreeNode root){
        if(root == null){
            return "#";
        }
        String str = root.val + " " + child(root.left) + " " + child(root.right);
        ma.put(str, ma.getOrDefault(str, 0) + 1);
        if(ma.get(str) == 2){
            count.add(root);
        }
        return str;
    }
}