Leetcode题解（29）

93. Restore IP Addresses

题目

分析：多重循环，判断小数点合适的位置

代码如下（copy网上）

class Solution {
public:
    vector<string> restoreIpAddresses(string s) {
        vector<string> ret;
        if(s.size() > 12)
            return ret;
        for(int i = 0; i < s.size(); i ++)
        {// [0, i]
            for(int j = i+1; j < s.size(); j ++)
            {// [i+1, j]
                for(int k = j+1; k < s.size()-1; k ++)
                {// [j+1, k], [k+1, s.size()-1]
                    string ip1 = s.substr(0, i+1);
                    string ip2 = s.substr(i+1, j-i);
                    string ip3 = s.substr(j+1, k-j);
                    string ip4 = s.substr(k+1);
                    if(check(ip1) && check(ip2) && check(ip3) && check(ip4))
                    {
                        string ip = ip1 + "." + ip2 + "." + ip3 + "." + ip4;
                        ret.push_back(ip);
                    }
                }
            }
        }
        return ret;
    }
    bool check(string ip)
    {
        int value = stoi(ip);
        if(ip[0] == '0')
        {
            return (ip.size() == 1);
        }
        else
        {
            if(value <= 255)
                return true;
            else
                return false;
        }
    }
};

 ----------------------------------------------------------------------分割线--------------------------------------------------------------------------

94. Binary Tree Inorder Traversal

题目

分析：二叉树的中序遍历，题目要求不能使用递归，因此为了实现中序遍历，需要使用一个stack，只是在存储节点的 时候，中间节点利用两个NULL包裹起来存放。详细请看代码中的注释，代码如下：

/**
 * 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:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == NULL)
            return res;
        stack<TreeNode*> myStack;
        TreeNode *temp;
        myStack.push(root);
        while(!myStack.empty())
        {
            temp = myStack.top();
            myStack.pop();
            
            if(NULL == temp)//表示访问到中间节点了，需要读取val
            {
                temp = myStack.top();
                myStack.pop();
                res.push_back(temp->val);
                temp = myStack.top();
                myStack.pop();
                continue;                
            }
            //右节点push
            if(temp->right != NULL)
                myStack.push(temp->right);
            
            //利用两个NULL把中间节点包裹起来
            myStack.push(NULL);
            myStack.push(temp);
            myStack.push(NULL);
            
            //左节点push
            if(temp->left != NULL)
            {                
                myStack.push(temp->left);
            }
        }
        return res;
        
    }
};

 -------------------------------------------------------------------------------分割线-------------------------------------------------------------------

95. Unique Binary Search Trees II

题目

分析：递归求解，代码如下（copy网上代码）

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<TreeNode *> generateTrees(int n) {
        vector<TreeNode *> res;
        if(n==0)
        return res;
        return Helper(1, n);
    }
    vector<TreeNode *> Helper(int begin, int end)
    {
        vector<TreeNode *> ret;
        if(begin > end)
            ret.push_back(NULL);
        else if(begin == end)
        {
            TreeNode* node = new TreeNode(begin);
            ret.push_back(node);
        }
        else
        {
            for(int i = begin; i <= end; i ++)
            {//root
                vector<TreeNode *> left = Helper(begin, i-1);
                vector<TreeNode *> right = Helper(i+1, end);
                for(int l = 0; l < left.size(); l ++)
                {
                    for(int r = 0; r < right.size(); r ++)
                    {
                        //new tree
                        TreeNode* root = new TreeNode(i);
                        root->left = left[l];
                        root->right = right[r];
                        ret.push_back(root);
                    }
                }
            }
        }
        return ret;
    }
};

 ----------------------------------------------------------------------------分割线---------------------------------------------------------------------

96. Unique Binary Search Trees

题目

分析：这题和95题是一样的，代码如下（copy网上代码）：

class Solution {
public:
    int numTrees(int n) {
        int f[n+1];
        memset (f , 0 , sizeof(int)*(n+1));
        f[0]=1;
        for(int i=1; i<=n; i++)
            for(int j=0; j<i; j++)
                f[i] += f[j] * f[i-j-1];
        
        return f[n];
    }
};