583，Offer12, Offer26

#583，Offer12, Offer26

538. 把二叉搜索树转换为累加树

难度简单378收藏分享切换为英文关注反馈

给定一个二叉搜索树（Binary Search Tree），把它转换成为累加树（Greater Tree)，使得每个节点的值是原来的节点值加上所有大于它的节点值之和。

例如：

输入: 原始二叉搜索树:
              5
            /   
           2     13

输出: 转换为累加树:
             18
            /   
          20     13

思路：将所有节点拆分排序，从大到小累加

package LeetCode;

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Stack;

/**
 * @ClassName Q538
 * @Description TODO
 * @Author m
 * @Version 1.0
 */
public class Q538 {
    public TreeNode convertBST(TreeNode root) {

        if(root == null){
            return root;
        }

        PriorityQueue<TreeNode> p = new PriorityQueue<>(new Comparator<TreeNode>() {
            @Override
            public int compare(TreeNode o1, TreeNode o2) {
                return o1.val < o2.val ? 1 : -1 ;
            }
        });

        Stack<TreeNode> s = new Stack<> ();

        s.add(root);

        while (!s.isEmpty()) {
            TreeNode now = s.pop();
            if(now.left != null){
                s.add(now.left);
            }
            if(now.right != null) {
                s.add(now.right);
            }
            p.offer(now);
        }

        int sum = 0;

        while (!p.isEmpty()) {
            TreeNode now = p.poll();
            now.val += sum;
            sum = now.val;
        }

        return root;
    }

}

剑指 Offer 12. 矩阵中的路径

难度中等169收藏分享切换为英文关注反馈

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。

[[“a”,“b”,“c”,“e”],
[“s”,“f”,“c”,“s”],
[“a”,“d”,“e”,“e”]]

但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。

示例 1：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true

示例 2：

输入：board = [["a","b"],["c","d"]], word = "abcd"
输出：false

提示：

• 1 <= board.length <= 200
• 1 <= board[i].length <= 200

思路 ： 经典的搜索问题，注意边界判断和走过的路径标记

package LeetCode;

/**
 * @ClassName Offer12
 * @Description TODO
 * @Author m
 * @Version 1.0
 */
public class Offer12 {

    String word;
    char[][] board;
    boolean[][] vis;
    int[][] dir = new int[][] {
            {0,1}, {0,-1}, {1,0}, {-1,0}
    };

    public boolean exist(char[][] board, String word) {
        this.word = word;
        this.board = board;

        vis = new boolean[board.length][board[0].length];

        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
                if(board[i][j] == word.charAt(0)) {
                    vis[i][j] = true;
                    if(dfs(0, i, j)){
                        return true;
                    }
                    vis[i][j] = false;

                }
            }
        }

        return false;
    }

    private boolean check(int i , int j) {
        return i < board.length && i >= 0 && j < board[i].length && j >= 0;
    }

    private boolean dfs(int index, int i , int j) {
        char now = board[i][j];
        boolean res = false;

        if(now == word.charAt(index)) {
            index++;
            if(index == word.length()) {
                return true;
            }

            for (int k = 0; k < 4; k++) {
                int ii = i+dir[k][0];
                int jj = j+dir[k][1];
                if(check(ii, jj) && !vis[ii][jj]) {
                    vis[ii][jj] = true;
                    res |= dfs(index, ii, jj);
                    vis[ii][jj] = false;
                }

                if(res) {
                    break;
                }
            }

        }

        return res;
    }
}

剑指 Offer 26. 树的子结构

难度中等118收藏分享切换为英文关注反馈

输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)

B是A的子结构， 即 A中有出现和B相同的结构和节点值。

例如:
给定的树 A:

3 / 4 5 / 1 2
给定的树 B：

4 / 1
返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。

示例 1：

输入：A = [1,2,3], B = [3,1]
输出：false

示例 2：

输入：A = [3,4,5,1,2], B = [4,1]
输出：true

限制：

0 <= 节点个数 <= 10000

思路：对A的每一个节点为起点和B比较

package LeetCode;

/**
 * @ClassName Offer26
 * @Description TODO
 * @Author m
 * @Version 1.0
 */
public class Offer26 {
    public boolean isSubStructure(TreeNode A, TreeNode B) {

        return (A!= null && B != null) && (check(A, B) | isSubStructure(A.left, B) | isSubStructure(A.right, B));

    }
    private boolean check(TreeNode A , TreeNode B) {
        if(null == B) return true;
        if(A == null || A.val != B.val) return false;
        return check(A.left , B.left)&check(A.right, B.right);
    }
}