leetcode(96-100)

96. 不同的二叉搜索树

给定一个整数 n，求以 1 ... n 为节点组成的二叉搜索树有多少种？

示例:

输入: 3
输出: 5
解释:
给定 n = 3, 一共有 5 种不同结构的二叉搜索树:

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

class Solution {
public:
    int numTrees(int n) {
        if (n == 0) return 0;
        vector<int> res{1,1};
        for (int i = 2; i <= n; ++i){
            int tmp = 0;
            for (int j = 0; j < i; ++j){
                tmp += res[j] * res[i - j-1];
            }
            res.push_back(tmp);
        }
        return res[n];
    }
};

97. 交错字符串

给定三个字符串 s1, s2, s3, 验证 s3 是否是由 s1 和 s2 交错组成的。

示例 1:

输入: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
输出: true

示例 2:

输入: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
输出: false

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int len1=s1.size(),len2=s2.size(),len3=s3.size();
        if(len1+len2!=len3) return false;
        if(len3==0) return true;
        vector<vector<int>> dp(len1+1,vector<int>(len2+1,0));
        for(int i=0; i<=len1 && s1[i-1]==s3[i-1]; i++){
            dp[i][0]=1;
        }
        for(int i=0; i<=len2 && s2[i-1]==s3[i-1]; i++){
            dp[0][i]=1;
        }
        for(int i=1; i<=len1; i++){
            for(int j=1; j<=len2; j++){
                int k=i+j-1;
                if(s1[i-1]==s3[k] && dp[i-1][j]==1)       dp[i][j]=1;
                if(s2[j-1]==s3[k] && dp[i][j-1]==1)       dp[i][j]=1;
            }
        }
        return dp[len1][len2];
    }
};

98. 验证二叉搜索树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

• 节点的左子树只包含小于当前节点的数。
• 节点的右子树只包含大于当前节点的数。
• 所有左子树和右子树自身必须也是二叉搜索树。

示例 1:

输入:
    2
   / \
  1   3
输出: true

示例 2:

输入:
    5
   / \
  1   4
     / \
    3   6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
     根节点的值为 5 ，但是其右子节点值为 4 。

/**
 * 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 isValidBST(TreeNode* root) {
        if(root==NULL) return true;
        vector<int> res;
        inorder(root, res);
        for(int i=0; i<res.size()-1; i++){
            if(res[i] >= res[i+1]) return false;
        }
        return true;
    }
    void inorder(TreeNode* root, vector<int>& res){
        if(root==NULL) return;
        inorder(root->left, res);
        res.push_back(root->val);
        inorder(root->right, res);
    }
};

99. 恢复二叉搜索树

二叉搜索树中的两个节点被错误地交换。

请在不改变其结构的情况下，恢复这棵树。

示例 1:

输入: [1,3,null,null,2]

   1
  /
 3
  \
   2

输出: [3,1,null,null,2]

   3
  /
 1
  \
   2

示例 2:

输入: [3,1,4,null,null,2]

  3
 / \
1   4
   /
  2

输出: [2,1,4,null,null,3]

  2
 / \
1   4
   /
  3

进阶:

• 使用 O(n) 空间复杂度的解法很容易实现。
• 你能想出一个只使用常数空间的解决方案吗？

/**
 * 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:
    void recoverTree(TreeNode* root) {
        TreeNode* pre=NULL;
        TreeNode* left=NULL;
        TreeNode* right=NULL;
        TreeNode* pnode=root;
        int count=0;
        stack<TreeNode*> q;
        while(!q.empty() || pnode){
            while(pnode){
                q.push(pnode);
                pnode=pnode->left;
            }
            TreeNode* cur=q.top();
            if(pre!=NULL && pre->val>cur->val){
                if(!left) left=pre;
                right=cur;
                count++;
                if(count==2) break;
            }
            pre=cur;
            pnode=cur->right;
            q.pop();
        }
        swap(left->val,right->val);
        return;
    }
};

100. 相同的树

给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:

输入:       1         1
          / \       / \
         2   3     2   3

        [1,2,3],   [1,2,3]

输出: true

示例 2:

输入:      1          1
          /           \
         2             2

        [1,2],     [1,null,2]

输出: false

示例 3:

输入:       1         1
          / \       / \
         2   1     1   2

        [1,2,1],   [1,1,2]

输出: 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 isSameTree(TreeNode* p, TreeNode* q) {
        if (p == NULL && q == NULL) return true;
        if (p && q) return p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
        return false;         
    }
};

(以上题目均摘自leetcode)