[NCH 1, 3]

Preview:

1. Implement strStr()

O(m*n):

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

注意：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,);
         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+);
             path.pop_back();
         }
     }
 };

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

:
:  ,
:  ,  ,
:  ,  ,  ,
:  ,  ,
:  ,
:  ,  ,
:  , 

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

3. Subsets II

 class Solution
 {
 public:
     vector<vector<int>> subsetsWithDup(vector<int> &nums)
     {
         sort(nums.begin(),nums.end());
         dfs(nums,);
         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-]) continue;
             path.push_back(nums[i]);
             dfs(nums,i+);
             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=;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>)
             {
                 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相关。