LeetCode 111-120题 尚未看题解

111. 二叉树的最小深度

难度简单365

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

示例:

给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回它的最小深度  2.

 int minDepth(TreeNode* root) {
        if(root==NULL) return 0;
        queue<TreeNode*> q;
        q.push(root);
        int step=1;
        while(!q.empty()){
            //注意，不是单个单个节点扩散。而是一排就扩散！！！
            int sz=q.size();
            for(int i=0;i<sz;i++){
                TreeNode* now=q.front();q.pop();
                if(now->left==NULL&&now->right==NULL) return step;
                if(now->left!=NULL) q.push(now->left);
                if(now->right!=NULL) q.push(now->right);
            }
            step++;
        }
        return step;
    }

class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) return 0;
        else if (root.left == null) return minDepth(root.right) + 1;
        else if (root.right == null) return minDepth(root.left) + 1;
        else return Math.min(minDepth(root.left), minDepth(root.right)) + 1;
    }
}

112. 路径总和

难度简单429

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

示例: 
给定如下二叉树，以及目标和 sum = 22，

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \      \
        7    2      1

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

我在梦里做过吗？？

为什么感觉做过啊

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        if(root==NULL) return false;
        queue<TreeNode*> q;
        queue<int> num;
        q.push(root);
        num.push(root->val);
        while(!q.empty()){
            TreeNode* now=q.front();q.pop();
            int number=num.front();num.pop();
            if(now->left==NULL&&now->right==NULL){
                if(number==sum) return true;
            }
            if(now->left!=NULL){
                q.push(now->left);num.push(number+now->left->val);
            }
            if(now->right!=NULL){
                q.push(now->right);num.push(number+now->right->val);
            }
        }
        return false;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool ans=false;
    void dfs(bool& ans,TreeNode* root,int num,int sum){
        if(ans==true) return;
        if(sum==num&&root->left==NULL&&root->right==NULL){
            ans=true;return;
        }
        if(root->left!=NULL) dfs(ans,root->left,num+root->left->val,sum);
        if(root->right!=NULL) dfs(ans,root->right,num+root->right->val,sum);
    }
    bool hasPathSum(TreeNode* root, int sum) {
        if(root==NULL) return false;
        dfs(ans,root,root->val,sum);
        return ans;
    }
};

113. 路径总和 II

难度中等318

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

说明: 叶子节点是指没有子节点的节点。

示例:
给定如下二叉树，以及目标和 sum = 22，

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \    / \
        7    2  5   1

返回:

[
   [5,4,11,2],
   [5,8,4,5]
]

class Solution {
public:
    void dfs(vector<int> tmp,vector<vector<int>>& ans,TreeNode* root,int num,int sum){
        if(sum==num&&root->left==NULL&&root->right==NULL){
            ans.push_back(tmp);
            return;
        }
        if(root->left!=NULL){
            tmp.push_back(root->left->val);
            dfs(tmp,ans,root->left,num+root->left->val,sum);
            tmp.pop_back();
        }
        if(root->right!=NULL){
            tmp.push_back(root->right->val);
            dfs(tmp,ans,root->right,num+root->right->val,sum);
            tmp.pop_back();
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<vector<int>> ans;
        if(root==NULL) return ans;
        vector<int> tmp;tmp.push_back(root->val);
        dfs(tmp,ans,root,root->val,sum);
        return ans;
    }
};

 

114. 二叉树展开为链表

难度中等552

给定一个二叉树，原地将它展开为一个单链表。

 

例如，给定二叉树

    1
   / \
  2   5
 / \   \
3   4   6

将其展开为：

1
 \
  2
   \
    3
     \
      4
       \
        5
         \
          6

话说这个答案是我抄的吗？

class Solution {
public:
    void flatten(TreeNode* root) {
        //先序遍历的顺序吗？
        //这，修改链表，不要慌，好好看看是怎么修改连接的。并且还是二叉树那就和可能是递归啊
        //结合遍历顺序作答。
        if(root==NULL) return;
        flatten(root->left);
        flatten(root->right);
        if(root->left!=NULL){
            TreeNode* last=root->left;
            //左子树最后一个节点
            while(last->right!=NULL) last=last->right;
            last->right=root->right;
            root->right=root->left;
            root->left=NULL;
        }

    }
};

 

115. 不同的子序列

难度困难257

给定一个字符串 S 和一个字符串 T，计算在 S 的子序列中 T 出现的个数。

一个字符串的一个子序列是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是）

题目数据保证答案符合 32 位带符号整数范围。

 

示例 1：

输入：S = "rabbbit", T = "rabbit"
输出：3
解释：

如下图所示, 有 3 种可以从 S 中得到 "rabbit" 的方案。
(上箭头符号 ^ 表示选取的字母)

rabbbit
^^^^ ^^
rabbbit
^^ ^^^^
rabbbit
^^^ ^^^

示例 2：

输入：S = "babgbag", T = "bag"
输出：5
解释：

如下图所示, 有 5 种可以从 S 中得到 "bag" 的方案。 
(上箭头符号 ^ 表示选取的字母)

babgbag
^^ ^
babgbag
^^    ^
babgbag
^    ^^
babgbag
  ^  ^^
babgbag
    ^^^

//超时递归....
class Solution {
public:
    int cnt=0;
    void dfs(string s,string t,int i,int j){
        if(j==t.size()){
            cnt++;return;
        }
        if(i>=s.size()) return;
        if(s[i]==t[j]){
            dfs(s,t,i+1,j+1);//选择
            //不选择
            dfs(s,t,i+1,j);
        }
        else{
            dfs(s,t,i+1,j);
        }
    }
    int numDistinct(string s, string t) {
        //递归？
        if(s.size()<t.size()) return 0;
        if(s.size()==t.size()) return s==t?1:0;
        //开始处理
        dfs(s,t,0,0);
        return cnt;
    }
};

116. 填充每个节点的下一个右侧节点指针

难度中等243

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

 

示例：

输入：{"$id":"1","left":{"$id":"2","left":{"$id":"3","left":null,"next":null,"right":null,"val":4},"next":null,"right":{"$id":"4","left":null,"next":null,"right":null,"val":5},"val":2},"next":null,"right":{"$id":"5","left":{"$id":"6","left":null,"next":null,"right":null,"val":6},"next":null,"right":{"$id":"7","left":null,"next":null,"right":null,"val":7},"val":3},"val":1}

输出：{"$id":"1","left":{"$id":"2","left":{"$id":"3","left":null,"next":{"$id":"4","left":null,"next":{"$id":"5","left":null,"next":{"$id":"6","left":null,"next":null,"right":null,"val":7},"right":null,"val":6},"right":null,"val":5},"right":null,"val":4},"next":{"$id":"7","left":{"$ref":"5"},"next":null,"right":{"$ref":"6"},"val":3},"right":{"$ref":"4"},"val":2},"next":null,"right":{"$ref":"7"},"val":1}

解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        //这看上去很简单，就层序遍历啊
        if(root==NULL) return root;
        // Node* tmp
        queue<Node*> q;
        q.push(root);
        while(!q.empty()){
            int size=q.size();
            Node* pre=q.front();q.pop();
            if(pre->left!=NULL) q.push(pre->left);
            if(pre->right!=NULL) q.push(pre->right);
            for(int i=1;i<size;i++){
                Node* cur=q.front();q.pop();
                pre->next=cur;
                pre=cur;
                if(cur->left!=NULL) q.push(cur->left);
                if(cur->right!=NULL) q.push(cur->right);
                
            }
            pre->next=NULL;
        }
        return root;
    }
};

117. 填充每个节点的下一个右侧节点指针 II

难度中等198

给定一个二叉树

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

 

进阶：

• 你只能使用常量级额外空间。
• 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

 

示例：

输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。

 

提示：

• 树中的节点数小于 6000
• -100 <= node.val <= 100

 

class Solution {
public:
    Node* connect(Node* root) {
         //这看上去很简单，就层序遍历啊
        if(root==NULL) return root;
        // Node* tmp
        queue<Node*> q;
        q.push(root);
        while(!q.empty()){
            int size=q.size();
            Node* pre=q.front();q.pop();
            if(pre->left!=NULL) q.push(pre->left);
            if(pre->right!=NULL) q.push(pre->right);
            for(int i=1;i<size;i++){
                Node* cur=q.front();q.pop();
                pre->next=cur;
                pre=cur;
                if(cur->left!=NULL) q.push(cur->left);
                if(cur->right!=NULL) q.push(cur->right);
                
            }
            pre->next=NULL;
        }
        return root;
    }
};

 

118. 杨辉三角

难度简单350

给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。

在杨辉三角中，每个数是它左上方和右上方的数的和。

示例:

输入: 5
输出:
[
     [1],
    [1,1],
   [1,2,1],
  [1,3,3,1],
 [1,4,6,4,1]
]

错一位再逐个相加


等~等~等~

120. 三角形最小路径和

难度中等593

给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。

相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。

 

例如，给定三角形：

[
     [2],
    [3,4],
   [6,5,7],
  [4,1,8,3]
]

自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

 

说明：

如果你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题，那么你的算法会很加分。