• 思路：

  

  我们就根据上图这个例子来分析一下：

  1. 气球1和气球2是重叠的，需要一个箭，然后我们分析气球3
  2. 当气球1和气球2重叠的时候可以看到，气球1和气球2的空间应该合并成[2,6]然后再和气球3作比较
  3. 从上面特点可以看出，我们只需要关注气球的最右边界，找到右边界值最小的，成为新的右边界，然后再和气球3比
  4. 所以每次右边界改变就行

  以上就是这套题的全部思路，一般这种题第一肯定是先排序再说其他。

• 代码

  static bool compare(vector<int>& v1, vector<int>& v2){return v1[0] < v2[0] || (v1[0] == v2[0] && v1[1] > v2[1]);}int findMinArrowShots(vector<vector<int>>& points) {int n = points.size();sort(points.begin(), points.end(), compare);for(int i = 0; i < n; i++){cout<<points[i][0]<<","<<points[i][1]<<" "<<endl;}int count = 1;for(int i = 0; i < n - 1 ; i++){if(points[i][1] < points[i + 1][0]){count++;}else{points[i + 1][1] = min(points[i][1], points[i+1][1]);}}return count;}
  

• 思路

  很简单，计算能连续的区间有多少个，取差就行

  注意是移除最小区间数量，也就意味着我们尽可能少的移动区间，所以可以想一下，当你的intervals[i][1]约小，你能减少的区间就越小，当你的intervals[i][1]越大，表明你要移除更多的区间才行。

• 代码

  bool static cmp(vector<int>& v1, vector<int>& v2){//return v1[0] < v2[0] || (v1[0] == v2[0] && v1[1] < v2[1]);return v1[1] < v2[1];}int eraseOverlapIntervals(vector<vector<int>>& intervals) {int n = intervals.size();//sort(intervals.begin(), intervals.end(), cmp);sort(intervals.begin(), intervals.end(), cmp);int end = INT_MIN;int count = 0;for(int i = 0; i < n ; i++){cout<<intervals[i][0]<<" "<<intervals[i][1]<<endl;}for(int i = 0; i < n ; i++){if(end <= intervals[i][0]){end = intervals[i][1];cout<<"end:"<<end<<endl;count++;}}cout<<"count:"<<count<<endl;return n - count;}
  

• 思路

  

  在遍历的过程中相当于是要找每一个字母的边界，如果找到之前遍历过的所有字母的最远边界，说明这个边界就是分割点了。此时前面出现过所有字母，最远也就到这个边界了。

• 代码

  vector<int> partitionLabels(string S) {int len = S.size();vector<int> distance(26);/*求每个字母*/for(int i = 0; i < len; i++){distance[S[i] - 'a'] = i;}int start = 0;int end = 0;vector<int> res;for(int i = 0; i < len; i++){end = max(end,  distance[S[i] - 'a']);if(i == end){int tmp = end - start + 1;start = end + 1;res.push_back(tmp);}}return res;}
  

• 思路

  这个题比之前那个射气球好点在于重叠不用考虑几个区间都重叠部分，只要有重叠就可以合并

  要特别注意这个用例：[[2,3],[4,5],[6,7],[8,9],[1,10]]

• 代码

  static bool cmp(vector<int>& v1, vector<int>& v2){return v1[0] < v2[0] || (v1[0] == v2[0]) && (v1[1] < v2[1]);}vector<vector<int>> merge(vector<vector<int>>& intervals) {int len = intervals.size();if(len <= 1){return intervals;}vector<vector<int>> tmp1;sort(intervals.begin(), intervals.end(), cmp);int i = 0;/*每个元素是长度为2的int数组*/vector<int> tmp2(2);/*首先初始化里面的数组，让其为第一个索引的数组值*/tmp2[0] = intervals[0][0];tmp2[1] = intervals[0][1];/*用for也行*/while(i < len - 1){/*在这里的判断条件不是intervals[i][1] >= intervals[i+1][0]*//*因为这种类型都要保存右边最大的那个索引，参考射气球的那一道题*//*因此我认为记录最大索引值，是这种题的精髓*/if(tmp2[1] >= intervals[i+1][0]){tmp2[1] = max(intervals[i+1][1], tmp2[1]); }else{tmp1.push_back(tmp2);tmp2[0] = intervals[i+1][0];tmp2[1] = max(intervals[i+1][1],tmp2[1]);}i++;}tmp1.push_back(tmp2);return tmp1;}
  

• 思路

  这道题之所以困扰我这么久并不是因为状态状态转移方程，这个其实很好理解

  而是max即返回连续最大和 与 dp之间的关系

  我之前一直以为要返回dp数组某个值，导致动态规划出现问题，但是其实这道题的max和dp是平行的，max是一个独立的变量，

  比如-2 1 -3这个例子，当i=3时dp的值行该是max(dp[i-1]+nums[i-1], nums[i-1])注意这个求得可不是某个区间的最大值，而某个区间的最大值在max中存储，因此还需要一步max=max(dp[i], max),这道题最关键的就是这一步。

• 代码

  int maxSubArray(vector<int>& nums) {int n = nums.size();if(n <= 1){return nums[0];}vector<int> dp(n+1, -10000);int max_num = nums[0];dp[1] = nums[0];for(int i = 2; i < n+1; i++){dp[i] = max(dp[i-1] + nums[i-1], nums[i-1]);max_num = max(max_num, dp[i]);}return max_num;}
  

• 这题第一反应肯定是每个索引作为一个起点走一遍，这种方法也不能说出，但可能面试官不认，所以你得弄点新活儿。

  思路：①一定能跑完全程，表明总加油数大于等于油耗数。②计算每个站的为起始点的剩余油量，会发现一个规律就是从站i开始到站j邮箱里面的油就是站i到站j的剩余油量相加，即cost[i]+…+cost[j]。③如果前面邮箱是负的，那么后面肯定是正的，因为要跑完全程啊，就得那么多，肯定要大于等于0才行。

  因此，如果区间i-j的剩余油量和为负数，那么就从j+1开始算起。

• 代码

  int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {int n = gas.size();int rest_sum = 0;int rest_total = 0;int start = 0;for(int i = 0; i < n; i++){rest_sum += gas[i]-cost[i];//这个rest_total就是说计算所有剩余邮箱的和是否小于0的，放在里面不用再循环一下了，一次循环就解决了rest_total += gas[i] - cost[i];if(rest_sum < 0){rest_sum = 0;start = i + 1;}}//只有剩余邮箱和小于0才会饶不了一圈if(rest_total < 0){return -1;}return start;}
  

	vector<vector<int>> res;vector<int> temp;vector<vector<int>> permute(vector<int>& nums) {vector<bool> use_check(nums.size(), false);back_tracing(nums, use_check);return res;}void back_tracing(vector<int>& nums, vector<bool>& use_check){if(temp.size() == nums.size()){res.push_back(temp);return;}for(int i = 0; i < nums.size(); i++ ){//列表中的这个元素用过了，直接跳过if(use_check[i] == true){continue;}//列表中的这个元素还没有用use_check[i] = true;temp.push_back(nums[i]);back_tracing(nums, use_check);temp.pop_back();use_check[i] = false;}}

• 主要的问题

  • 对于vector来说我们不需要new，因为vectorr的空间是自动增长的,它自己管理的,也是自己释放,不需要new

  • 这道题对节点问题的处理主要在于判断是否是用过的节点。针对这中情况我们设一个vector，长度和给的列表长度一样长，里面初始化为false。如果某个元素用过了我们就用true表示。

    当递归到决策树的最后一个节点后，会回溯，撤销处理结果，因此这个时候我们需要重新吧所有的全部初始化为false，重新使用。放入路径中的元素也全部拿出来，这里用的是vector c++11 的pop_back()方法。

  • 不用去想具体实现步骤，就是只关注那个功能区写具体代码就行。

这道题和前面那道题的区别是这道题不能重复，因为给的序列可能会重复

vector<vector<int>> res;vector<int> temp;vector<vector<int>> permuteUnique(vector<int>& nums) {vector<bool> user_check_vec(nums.size(), false);sort(nums.begin(), nums.end());back_tracing(nums, user_check_vec);return res;}void back_tracing(vector<int>& nums, vector<bool> vec){if(temp.size() == nums.size()){res.push_back(temp);return;}for(int i = 0; i < nums.size(); i++){if(i > 0 && nums[i-1] == nums[i] && vec[i -1] == false){continue;}if(vec[i] == true){continue;}vec[i] = true;temp.push_back(nums[i]);back_tracing(nums,vec);//回溯temp.pop_back();vec[i] = false;}}

• 注意的问题

  最开始我是这样想的，为了让第一个加入进去的元素不重复，我用一个map保存不重复的元素，用一个我设置为true。反正这样子不行，不去想了，有点难。

  然后就是作者的思路：

  if(i > 0 && nums[i-1] == nums[i] && vec[i-1] == false){continue;
  }
  

  这句话保证了不重复，是不是非常精妙！

  nums[i-1] == nums[i]这句话保证了这次选的元素和上次选的一样，但是可能是同一层也有可能是同一个枝。我们要吧同一层的去掉，因此还要加上vec[i-1] == false。这句话保证了在递归算法中，与当前元素相同的前一个元素是没有用过的！！！

  切记，递归函数上面的代码不要想着回溯
  !

  当然做这道题之前一定要先排序，先排序！！！

下面这幅图就是本题的思路

vector<vector<int>> res;
vector<int> temp;
vector<vector<int>> combine(int n, int k) {back_tracing(n ,k, 1);return res;
}void back_tracing(int n, int k, int start){if(temp.size() == k){res.push_back(temp);return;}for(int i = start; i <= n; i++){temp.push_back(i);back_tracing(n, k, i+1);temp.pop_back();}
}

重点，第二次写还是遇到了相同的问题

这是一道基本的组合问题，最最基本。这道题出问题的点在于不能出现像[2,2]或者[3,2]这样的组合

对于[2,2]这样的，我们必须要保证同一个树枝下，上一个要小下一个才行，

对于[3,2]这样的，我们必须保证同一层，前一个要小于后一个才行

不然的话写这道题的时候最开始会出现[[1,1],[1,2],[1,3],[1,4],[2,2],[2,3],[2,4],[3,2],[3,3],[3,4],[4,2],[4,3],[4,4]]这样的答案，苦死很久没发现为什么

其实问题出在for循环中 back_tracing(n, k, i+1);这段代码

对于同一树枝下的递归来说，我们考虑for时候，主要放在循环变量i上，而不是start上，因为start是控制层的递进。而i是控制递归的递进！！

第二次写补充： for 选择 in 选择列表 其实由于是组合问题，所以每次选择列表都要少一个数，因为不能重复！所以选择列表必须要i+1

在组合问题中，需要设置一个start变量。因为在递归层中，start决定从哪个索引开始遍历

每次从集合中选取元素，可选择的范围都在进行收缩，调整可选择的范围靠的就是start