[NCH 1, 3]

Preview:

1. Implement strStr()

O(m*n):

class Solution
{
public:
    int strStr(string haystack,string needle)
    {
        for(int i=0;i<=int(haystack.size()-needle.size());i++)
        {
            int j;
            for(j=0;j<needle.size();j++)
            {
                if(haystack[i+j]!=needle[j])
                    break;
            }
            if(j==needle.size())
                return i;
        }
        return -1;
    }
};

注意：size()函数返回值是size_t类型，是unsigned的，所以假如有可能为负数的话就会出问题。haystack.size()是有可能小于needle.size()的，有可能为负，因此要加个int强制转换。

或者，如果不想强制转换的话，可以把外层for循环的判断改为 i + needle.size() <= haystack.size(); 这样就不会涉及到负数了。

O(m+n):

ref: soul

2.  Subsets

class Solution
{
public:
    vector<vector<int>> subsets(vector<int> &nums)
    {
        sort(nums.begin(),nums.end());
        dfs(nums,0);
        return result;
    }
    vector<vector<int>> result;    
    vector<int> path;
    void dfs(vector<int> &nums,int start)
    {
        result.push_back(path);    
        for(int i=start;i<nums.size();i++)
        {
            path.push_back(nums[i]);
            dfs(nums,i+1);
            path.pop_back();
        }
    }
};

对于排序后为{0,1,4}的序列，result输出是这样的：

1: 
2: 0 , 
3: 0 , 1 , 
4: 0 , 1 , 4 , 
5: 0 , 4 , 
6: 1 , 
7: 1 , 4 , 
8: 4 , 

仔细思考一下顺序为什么是这样的。

3. Subsets II

class Solution
{
public:
    vector<vector<int>> subsetsWithDup(vector<int> &nums)
    {
        sort(nums.begin(),nums.end());
        dfs(nums,0);
        return result;
    }
    vector<vector<int>> result;
    vector<int> path;
    void dfs(vector<int> &nums, int start)
    {
        result.push_back(path);
        for(int i=start;i<nums.size();i++)
        {
            if(i>start && nums[i]==nums[i-1]) continue;
            path.push_back(nums[i]);
            dfs(nums,i+1);
            path.pop_back();
        }
    }
};

参考自己当时的分析。对于一个特定的for循环，它所循环到的每个元素都是针对当前同一个位置的不同元素的替换（它们之前的前缀都是一样的）。

注意判重是基于i>start的基础上，start之前那是前缀的事，不用管，只要保证从start之后在同一个位置不会出现重复元素就行。

比如nums是[1,2,2,2,2,2,2,3],前缀是[1,2,2],那么只要保证之后不会出现重复的[1,2,2,2]之类的就行了。

4. Permutations

class Solution
{
public:
    vector<vector<int>> permute(vector<int> &nums)    
    {
        dfs(nums);
        return result;
    }
    vector<vector<int>> result;
    vector<int> path;
    void dfs(vector<int> &nums)
    {    
        if(path.size()==nums.size())
        {
            result.push_back(path);    
            return;
        }
        for(int i=0;i<nums.size();i++)
        {
            if(find(path.begin(),path.end(),nums[i])==path.end())
            {
                path.push_back(nums[i]);
                dfs(nums);
                path.pop_back();
            }
        }
    }
};

5. Permutations II

class Solution
{
public:
    vector<vector<int>> permuteUnique(vector<int> &nums)
    {
        for(auto x:nums)
            umap[x]++;
        dfs(nums);
        return result;
    }
    vector<vector<int>> result;
    vector<int> path;
    unordered_map<int,int> umap;
    void dfs(vector<int> &nums)
    {
        if(path.size()==nums.size())
        {
            result.push_back(path);
            return;
        }
        for(auto p=umap.begin();p!=umap.end();p++)
        {    
            if(p->second>0)
            {
                path.push_back(p->first);
                umap[p->first]--;
                dfs(nums);
                umap[p->first]++;
                path.pop_back();
            }
        }
    }
};

如果nums里之前是已经排好序的元素，那么如果把result输出来其实可以看到，所有的permutation是按照从小到大的顺序。

其实把元素放进unordered_map中就隐含着把元素按照相同元素在一起的顺序放了，隐含着排了个序。对排序的元素来处理可以避免重复取值。ref

[NCH03]

递归如何求复杂度?

全排列如何求时间复杂度？首先看总共有多少种情况，是n！个。然后在递归的时候递归内部的处理的复杂度是O（n）。所以全排列的时间复杂度是n * n!

二叉树如何求时间复杂度？大部分是O(n)，n为点的个数。

二叉树的空间复杂度？空间复杂度主要耗费栈空间。栈空间主要和h相关。