leetcode题解日练--2016.7.10

日练三题，冰冻三尺非一日之寒。

今日题目：1、在一个旋转的数组中找最小数；❤2、数的组合（k元素子集）；3、不同的加括号方式；4、数的排列。

今日摘录：最初我们来到这个世界，是因为不得不来；最终我们离开这个世界，是因为不得不走。做人不能忘记四条，话不要说错，床不要睡错，门槛不要踏错，口袋不要摸错。 —《活着》

153. Find Minimum in Rotated Sorted Array | Difficulty: Medium

Suppose a sorted array is rotated at some pivot unknown to you beforehand.

(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).

Find the minimum element.

You may assume no duplicate exists in the array.

题意：一个已经经过移位的数组，找出其中最小的元素，假设没有重复元素的存在。
思路：
1、一个时间复杂度为O(N)的方法，遍历数组的元素，如果如果后一个元素比前一个小，那么那个就是我们要找的。

class Solution {
public:
    int findMin(vector<int>& nums) {
        for(int i=0;i<nums.size()-1;i++)
        {
            if(nums[i]>nums[i+1])   return nums[i+1];
        }
        return nums[0];
    }
};

结果：4ms
2、直接用二分查找的思想，mid=left+(right-left)/2;如果nums[mid]>nums[right]，就说明待查找元素在mid位置元素的右边，left=mid+1，如果nums[mid]

class Solution {
public:
    int findMin(vector<int>& nums) {
        int left = 0,right=nums.size()-1;
        while(left<right)
        {
            //if(nums[left]<nums[right])  return nums[left];
            int mid = left+(right-left)/2;
            if(nums[mid]>nums[right])   left = mid+1;
            else    right = mid;
        }
        return nums[left];
    }
};

结果：4ms

77. Combinations | Difficulty: Medium

Given two integers n and k, return all possible combinations of k numbers out of 1 … n.

For example,
If n = 4 and k = 2, a solution is:

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

题意：给定n和k，写出所有n个数中选k个数的组合。

思路：
1、直接回溯就可以搞定

class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        vector<vector<int>> res;
        vector<int> tmp;
        combineSub(res,tmp,n,k);
        return res;
    }

    void combineSub(vector<vector<int>> &res,vector<int>tmp,int n,int k )
    {
        if(k==0)
        {
            res.push_back(tmp);
            return;
        }
        if(k>0)
        {
        for(int i=tmp.empty()?1:tmp.back()+1;i<=n;i++)
        {
            tmp.push_back(i);
            combineSub(res,tmp,n,k-1);
            tmp.pop_back();
        }
        }

    }
};

结果：580ms
居然这么慢，应该是有什么地方没写对
稍微改进下

class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        vector<vector<int>> res;
        vector<int> tmp(k,0);
        combineSub(res,tmp,1,n,k);
        return res;
    }

    void combineSub(vector<vector<int>> &res,vector<int>tmp,int start,int n,int k )
    {
        if(k==0)
        {
            res.push_back(tmp);
            return;
        }

        for(int i=start;i<=n-k+1;i++)
        {
            tmp[tmp.size()-k]=i;
            combineSub(res,tmp,i+1,n,k-1);
            tmp[tmp.size()-1] = 0;
        }

    }
};

结果：92ms

2、再做一点改进

class Solution {
public:
    vector<vector<int> > combine(int n, int k) {
        // dfs method
        if(k == 0 || n == 0 || n<k)
            return result;
        v.resize(k);
        combinecore(1, n, k);
        return result;
    }
    void combinecore(int start, int n, int k) {
        int i = start;
        while(i<=(n-k+1)) {
            v[v.size()-k] = i;
            i++;
            if(k>1)
                combinecore(i, n, k-1);
            else
                result.push_back(v);
        }
    }
private:
    vector<int> v;
    vector<vector<int> > result;
};

结果：84ms

3、利用k元素子集的方法去做
换个角度来看，从1-n中选择k个数字进行组合。n=4,k=2是不是某种程度上等价于
XXXX这样一个四位二进制数，其中只能某两位取1，有多少种组合相比不难得出，就是C4取2种，那么如何获得这些可能性呢？
分四步来解决：
1、求出最低位的1开始的连续的1的区间(00010111->00000111)；
2、将这一区间全部变为0，并将区间左侧的那个0变为1(00010111->00011000)；
3、将第1步里取出的区间右移，直到剩下的1个数减少1个(00000111->00000011)；
4、将第2步和第3步的结果按位取或(00011000|00000011-> 00011011)。
伪代码如下：

    int comb=(1<<k)-1; //最小的k元素子集
    while(comb < 1<<n)
    {
        //处理每一个子集
        ……
        int x=comb & -comb; //x表示最低位1的位置
        int y=comb + x; //y表示4步中的第2步
        comb= (((comb&~y)/x )>>1)|y;
    }

class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        vector<vector<int>> result;
        int comb=(1<<k)-1;
        while(comb< 1<<n)
        {
            vector<int> r;
            for(int j=0;j<n;j++)
            {
                if(comb>>j&1)
                    r.push_back(j+1);
            }
            result.push_back(r);
            int x=comb&-comb;
            int y=comb+x;
            comb = (((comb&~y)/x)>>1)|y;
        }
        return result;
    }
};

结果：100ms

241. Different Ways to Add Parentheses | Difficulty: Medium

Given a string of numbers and operators, return all possible results from computing all the different possible ways to group numbers and operators. The valid operators are +, - and *.

Example 1
Input: “2-1-1”.

((2-1)-1) = 0
(2-(1-1)) = 2
Output: [0, 2]

Example 2
Input: “2*3-4*5”

(2*(3-(4*5))) = -34
((2*3)-(4*5)) = -14
((2*(3-4))*5) = -10
(2*((3-4)*5)) = -10
(((2*3)-4)*5) = 10
Output: [-34, -14, -10, -10, 10]

题意：寻找不同的加括号方式，将可能得到的计算值返回。
思路：
1、首先思考一个问题，先不考虑如何计算具体加括号之后的数值，先想下有多少种加括号的方法？经过试验:有1个运算符只有一个划分方式，有2个运算符有2种划分方式，有3个运算符有5种划分方式。是不是对这个式子很熟悉，没错，加括号的方法数就是一个卡特兰数，当算式中有n个运算符的时候，一共就有f(n)=(2n!)/(n!)(n+1)!种的加括号方法，那么如何做才能做到不重复不遗漏的将每种情况都考虑进来呢？
首先，问题整体来看有些复杂，这个时候可以尝试去找下问题的子问题，从一个简单栗子来看：
2*5-3，这个式子只有2个运算符，我想一个小学毕业生应该都能知道划分方式有((2*5)-3)=7和(2*(5-3))=4这两种，两个运算符是很好看出来的，我们首先考虑第一个号，我们将号左边的结果记为res1，*号右边的结果记为res2，那么我们只需要先后计算出res1和res2，然后最后再两者相乘就是最终结果，而计算res1和res2中结果的时候，也是一样的思想，对res1中的每个算式遍历一次，对每次选中的运算符又分成两个子问题，这样递归的执行下去直到平凡情况也就是res1和res2都是一个数值，这个时候直接对两个数进行四则运算就可以了。
基于以上思路写出如下代码：

class Solution {
public:
    vector<int> diffWaysToCompute(string input) {
        vector<int> res;
        for(int i=0;i<input.length();i++)
        {
            if(input[i]=='+'||input[i]=='-'||input[i]=='*')
            {
                string inputLeft = input.substr(0,i);
                string inputRight = input.substr(i+1,input.length()-i-1);
                vector<int> resLeft = diffWaysToCompute(inputLeft);
                vector<int> resRight = diffWaysToCompute(inputRight);
                for(auto res1:resLeft)
                    for(auto res2:resRight)
                    {
                         switch (input[i]) {
                             case '+':
                                res.push_back(res1+res2);
                                break;
                             case '-':
                                res.push_back(res1-res2);
                                break;
                             default:
                                res.push_back(res1*res2);
                         }
                    }
            }
        }
        if (res.empty())
        {
            res.push_back(stoi(input));
        }
        return res;
    }
};

结果：8ms

2、详见https://discuss.leetcode.com/topic/19906/c-4ms-recursive-dp-solution-with-brief-explanation
DP的思路，开创额外的空间用来保存子式的中间计算的结果，栗如：3*3*3，在以第一个分割的时候，会保存dp[“3”]=3,dp[“3*3”]=9,然后在以第二个分割的时候，左边的3*3和右边的3都在dp中有所保存，直接调用无需再去递归求。

class Solution {
public:
    vector<int> diffWaysToCompute(string input) {
        unordered_map<string, vector<int>> dp;
        return computeWithDP(input, dp);
    }
        vector<int> computeWithDP(string input, unordered_map<string, vector<int>> &dp)
        {
        vector<int> res;
        for(int i=0;i<input.length();i++)
        {
            if(input[i]=='+'||input[i]=='-'||input[i]=='*')
            {
                vector<int> resultLeft,resultRight;
                string inputLeft = input.substr(0,i);
                if(dp.find(inputLeft)!=dp.end())    resultLeft = dp[inputLeft];
                else    resultLeft = computeWithDP(inputLeft,dp);
                string inputRight = input.substr(i+1,input.length()-i-1);
                if(dp.find(inputRight)!=dp.end())    resultRight = dp[inputRight];
                else    resultRight = computeWithDP(inputRight,dp);
                for(auto res1:resultLeft)
                    for(auto res2:resultRight)
                    {
                         switch (input[i]) {
                             case '+':
                                res.push_back(res1+res2);
                                break;
                             case '-':
                                res.push_back(res1-res2);
                                break;
                             default:
                                res.push_back(res1*res2);
                         }
                    }
            }
        }
        if (res.empty())
        {
            res.push_back(stoi(input));
        }
        dp[input] = res;
        return dp[input];
    }
};

结果：4ms

46. Permutations | Difficulty: Medium

Given a collection of distinct numbers, return all possible permutations.

For example,
[1,2,3] have the following permutations:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

题意：写出一个列表中元素所有排列可能性
1、python有直接现成的库可以调用

class Solution(object):
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        import itertools
        permute = list(itertools.permutations(nums))
        permute = [list(i) for i in permute]
        return permute

结果：86ms

2、但是做题不能总是import，so考虑用下迭代器

class Solution(object):
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        def gen(nums):
            if not nums:
                yield []
            for i, n in enumerate(nums):
                for p in gen(nums[:i] + nums[i+1:]):
                    yield [n] + p
        return list(gen(nums))

结果：92ms

3、可以用DFS来做

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        dfs(nums,0,res);
        return res;
    }
    void dfs(vector<int>& nums,int start,vector<vector<int>>& res)
    {
        if(start>=nums.size())
        {
            res.push_back(nums);
            return ;
        }
        for(int i=start;i<nums.size();i++)
        {
            swap(nums[i],nums[start]);
            dfs(nums,start+1,res);
            swap(nums[i],nums[start]);
        }
    }
};

结果：12ms