Merge pull request gzc426#15 from gzc426/master

heyheyheyi · web-flow · commit 618a0f12de65 · 2018-12-25T10:51:02.000+08:00
12.25
diff --git a/2018.12.19-leetcode452/李碧涵.md b/2018.12.19-leetcode452/李碧涵.md
@@ -0,0 +1,59 @@
+#### [452. Minimum Number of Arrows to Burst Balloons](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/)
+**题目描述**
+> 在二维空间有许多球形气球。对每个气球，输入是**水平方向**上气球直径的**开始和结束坐标**（开始坐标总是小于结束坐标）。
+
+> 记一个气球直径的开始和结束坐标为 xstart，xend。在坐标x处射出一支箭，若 xstart ≤ x ≤ xend，则该气球会被引爆。
+可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。
+求所需弓箭的最小数量，使所有气球都被引爆。
+
+**例子**
+> Input:  [[10,16], [2,8], [1,6], [7,12]]
+Output:  2
+**Explanation:**
+One way is to shoot one arrow for example at x = 6 (bursting the balloons [2,8] and [1,6]) and another arrow at x = 11 (bursting the other two balloons).
+
+**思想**
+和重叠区间有关~
+首先区间按start排序；依次遍历区间，若两区间重叠，记录重叠区域；然后判断下一个区间是否和该重叠区域重合。若重合，继续记录重叠区域；否则弓箭数+1。
+（改进）
+按end排序
+
+**解法**
+```python
+class Solution(object):
+    def findMinArrowShots(self, points):
+        """
+        :type points: List[List[int]]
+        :rtype: int
+        """
+        if not points:
+            return 0
+        
+        cnt = 1
+        points = sorted(points, key = lambda x:x[0])
+        end = points[0][1]
+        for point in points[1:]:
+            if end >= point[0]:    # overlap
+                end = min(end, point[1])
+            else:
+                end = point[1]
+                cnt += 1
+        return cnt
+```
+改进：按end排序
+```python
+class Solution(object):
+    def findMinArrowShots(self, points):
+        """
+        :type points: List[List[int]]
+        :rtype: int
+        """
+        points = sorted(points, key = lambda x:x[1])
+        cnt = 0
+        end = float('-inf')
+        for point in points:
+            if point[0] > end:    # non-overlap
+                cnt += 1
+                end = point[1]
+        return cnt
+```
diff --git a/2018.12.20-leetcode406/Be a fresh man.md b/2018.12.20-leetcode406/Be a fresh man.md
@@ -0,0 +1,90 @@
+## 406_(根据身高重建队列)Queue Reconstruction by Height
+## 1 问题描述、输入输出与样例
+### 1.1 问题描述
+假设有打乱顺序的一群人站成一个队列。 每个人由一个整数对(h, k)表示，其中h是这个人的身高，k是排在这个人前面且身高大于或等于h的人数。 编写一个算法来重建这个队列。
+
+__注意__：
+总人数少于1100人。
+### 1.2 输入与输出
+输入：
+* vector<pair<int, int>>& people: 长度可变的结构体数组的引用 people
+
+输出：
+* vector<pair<int, int>>: 重建之后的长度可变结构体数组
+### 1.3 样例
+#### 1.3.1 样例1
+输入:[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]<br>
+输出:[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]
+
+## 2 思路描述与代码	
+### 2.1 思路描述（排序重建法）
+1. 按身高 h 从大到小排列，身高相等按 k 从小到大排序
+2. 按照规则（当前(h, k)插入的位置为第 k 个元素）重建队列
+
+
+比如输入:people = [[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
+1. 排序后people = [[7,0], [7,1], [6,1], [5,0], [5,2], [4,4]]
+2. 按照规则（当前(h, k)插入的位置为第 k 个元素）重建队列
+* [7,0]插入第 0 个位置，有 ans = [[7,0]];
+* [7,1]插入第 1 个位置，有 ans = [[7,0], [7,1]];
+* [6,1]插入第 1 个位置，有 ans = [[7,0], [6,1], [7,1]];
+* [5,0]插入第 0 个位置，有 ans = [[5,0], [7,0], [6,1], [7,1]];
+* [5,2]插入第 2 个位置，有 ans = [[5,0], [7,0], [5,2], [6,1], [7,1]];
+* [4,4]插入第 4 个位置，有 ans = [[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]];
+
+### 2.2 代码
+```cpp
+//函数中涉及到的c++知识
+//pair<int, int> 可以理解为包含两个元素的结构体
+//vector<pair<int, int>> 是个长度可变的结构体数组，c++里面称为容器
+//ret_func_type func(vector<pair<int, int>>& name) 中的name是vector<pair<int, int>>容器的引用，可以理解为传入一个指针
+//sort(g.begin(), g.end(), cmp) 对容器g的结构体按照cmp的排序规则排序，容器的起始数据的指针是 g.begin(),容器的末尾数据的指针是g.end()
+
+//1. 按身高 h 从大到小排列，身高相等按 k 从小到大排序
+//2. 重建队列
+vector<pair<int, int>> reconstructQueue(vector<pair<int, int>>& people) {
+    int len = people.size();
+    vector<pair<int, int>> ans;
+    //1. 按身高 h 从大到小排列，身高相等按 k 从小到大排序
+    sort(people.begin(), people.end(), cmp);
+    //2. 重建队列
+    for( int i = 0; i < len; i++ ){
+        ans.insert(ans.begin() + people[i].second, people[i]);
+    }
+    return ans;
+}
+//按身高 h 从大到小排列，身高相等按 k 从小到大排序
+static bool cmp(const pair<int, int>& data1, const pair<int, int>& data2){
+    return data1.first != data2.first ? data1.first > data2.first : data1.second < data2.second;
+}
+```
+## 3 思考与拓展
+### 3.1 思考
+本题按照排序规则排序后，很容易找到重排后应插入的位置。
+#### 3.1.1 其他方法
+#### 3.1.1.1 排序+BIT(二分索引树)
+1. 按照以 h 从小到达， h 相同以 k 从小到达排序
+2. 遍历排序后的结构体数组，借助BIT(二分索引树)可以在O(logn)时间内找到未用的第 k 个位置。
+
+比如输入:people = [[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
+1. 排序后people = [[4,4], [5,0], [5,2], [6,1], [7,0], [7,1]]
+2. 按照规则（当前(h, k)插入的位置为第 k 个可用元素）重建队列
+* pos = [1,1,1,1,1,1], [4,4]插入第 4 + 1 个可用位置，有pos = [1,1,1,1,0,1], ans = [[-1,-1],[-1,-1],[-1,-1],[-1,-1],[4,4],[-1,-1]];
+* pos = [1,1,1,1,0,1], [5,0]插入第 0 + 1 个可用位置，有pos = [0,1,1,1,0,1], ans = [[5,0],[-1,-1],[-1,-1],[-1,-1],[4,4],[-1,-1]];
+* pos = [0,1,1,1,0,1], [5,2]插入第 2 - 1 + 1 个可用位置（相同元素需要减掉），有pos = [0,1,0,1,0,1], ans = [[5,0],[-1,-1],[5,2],[-1,-1],[4,4],[-1,-1]];
+* pos = [0,1,0,1,0,1], [6,1]插入第 1 + 1 个可用位置，有pos = [0,0,1,0,0,1], ans = [[5,0],[-1,-1],[5,2],[6,1],[4,4],[-1,-1]];
+* pos = [0,0,1,0,0,1], [7,0]插入第 0 + 1 个可用位置，有pos = [0,0,0,0,0,1], ans = [[5,0],[7,0],[5,2],[6,1],[4,4],[-1,-1]];
+* pos = [0,0,0,0,0,1], [7,1]插入第 0 + 1 个可用位置，有pos = [0,0,0,0,0,0], ans = [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]
+
+
+#### 3.1.2 复杂度分析
+方法|空间复杂度|时间复杂度
+--- | --- | ---
+排序重建法|O(1)|平均O(nlogn)，最差O(n^2)
+排序+BIT(二分索引树)|O(n)|O(nlogn)
+#### 3.1.3 难点分析
+1. 找到合理的排序规则；
+2. 根据合理的规则对排序后的结构体数组重建
+
+### 3.2 拓展
+如果让你实现BIT(二分索引树)呢？
diff --git a/2018.12.20-leetcode406/李碧涵.md b/2018.12.20-leetcode406/李碧涵.md
@@ -0,0 +1,29 @@
+#### [406. Queue Reconstruction by Height](https://leetcode.com/problems/queue-reconstruction-by-height/)
+**题目描述**
+> 假设有打乱顺序的一群人站成一个队列。 
+每人用一个整数对(h, k)表示，其中h是这个人的身高，k是排在这个人前面即身高≥h的人数。 
+编写一个算法来重建这个队列。
+
+**例子**
+> Input:    [[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
+Output:    [[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]
+
+**思想**
+**要点**是排序方式。
+1）按照h降序，k升序的方式排列。例子为[[7,0], [7,1], [6,1], [5,0],  [5,2], [4,4]]
+2）首先[7,0], [7,1]正确；对于[6,1]要求前面有一个比它高的，所以在idx=1插入[6,1]；对于[5,0]，要求前面有没有比它高的，所以在idx=0插入[5,0]...
+
+**解法**
+```python
+class Solution(object):
+    def reconstructQueue(self, people):
+        """
+        :type people: List[List[int]]
+        :rtype: List[List[int]]
+        """
+        res = []
+        people = sorted(people, key = lambda(h, k):(-h, k))
+        for p in people:
+            res.insert(p[1], p)
+        return res
+```
diff --git a/2018.12.23-leetcode392/Be a fresh man.md b/2018.12.23-leetcode392/Be a fresh man.md
@@ -0,0 +1,77 @@
+## 392_(判断子序列)Is Subsequence
+## 1 问题描述、输入输出与样例
+### 1.1 问题描述
+给定字符串 s 和 t ，判断 s 是否为 t 的子序列。<br>
+你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长（长度 ~= 500,000），而 s 是个短字符串（长度 <=100）。<br>
+字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
+
+__后续挑战__ :<br>
+如果有大量输入的 S，称作S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？
+
+### 1.2 输入与输出
+输入：
+* string s:给定的字符串 s
+* string t:给定的字符串 t
+
+输出：
+* bool:判断 s 是否为 t 的子序列
+### 1.3 样例
+#### 1.3.1 样例1
+输入: s = "abc", t = "ahbgdc"<br>
+输出: true
+#### 1.3.2 样例2
+输入: s = "axc", t = "ahbgdc"<br>
+输出: false
+## 2 思路描述与代码	
+### 2.1 思路描述（双下标法）
+i为字符 s 的遍历下标， j 表示字符 t 的遍历下标
+```cpp
+for( j = 0; j < len_t; j++ ){
+    if(s[i] == t[j]){
+        if(i == len_s - 1) return true;
+        else i++;
+    }
+}
+```
+比如输入: s = "abc", t = "ahbgdc"；<br>
+j = 0, i = 0, s[0] == t[0], i = 1; <br>
+j = 1, i = 1, s[1] != t[1]; <br>
+j = 2, i = 1, s[1] == t[2], i = 2; <br>
+j = 3, i = 2, s[1] != t[3]; <br>
+j = 4, i = 2, s[2] != t[4]; <br>
+j = 5, i = 2, s[2] == t[5], 返回true;
+### 2.2 代码
+```cpp
+bool isSubsequence(string s, string t) {
+    int len_s = s.size();
+    int len_t = t.size();
+    //边界情况
+    if(len_s > len_t) return false;
+    else if(len_s == 0) return true;
+    
+    //遍历t
+    int i = 0, j = 0;
+    for( j = 0; j < len_t; j++ ){
+        //如果当前字符相等，查找 s 的下一个字符是否在 t 中
+        if(s[i] == t[j]){
+            if(i == len_s - 1) return true;
+            else i++;
+        }
+    }
+    return false;
+}
+```
+## 3 思考与拓展
+### 3.1 思考
+本题按照子序列的定义并利用双下标法可以很容易解决。
+#### 3.1.1 其他方法
+无。
+#### 3.1.2 复杂度分析
+方法|空间复杂度|时间复杂度
+--- | --- | ---
+双下标法|O(1)|O(s_len+t_len)
+#### 3.1.3 难点分析
+1. i下标的更新。
+
+### 3.2 拓展
+如果给你的是数组数据呢？
diff --git a/2018.12.23-leetcode392/Ostrichcrab.md b/2018.12.23-leetcode392/Ostrichcrab.md
@@ -0,0 +1,20 @@
+```
+class Solution {
+public:
+    bool isSubsequence(string s, string t) {
+        int ls = s.length();
+        int lt = t.length();
+        int i =0; int j = 0;
+        for(; i!=ls&&j!=lt;){
+            if(s[i]==t[j]){
+                i++;
+                j++;
+            }else{
+                j++;
+            }
+        }
+        if(i==ls) return true;
+        else return false;
+    }
+};
+```
diff --git a/2018.12.23-leetcode392/WYJ.md b/2018.12.23-leetcode392/WYJ.md
@@ -0,0 +1,20 @@
+```java
+class Solution {
+    public boolean isSubsequence(String s, String t) {
+        if(s.length() == 0){
+            return true;
+        }
+        int indexS = 0, indexT = 0;
+        while(indexT < t.length()){
+            if(t.charAt(indexT) == s.charAt(indexS)){
+                indexS++;
+            }
+            indexT++;
+            if(indexS == s.length()){
+                return true;
+            }
+        }
+        return false;
+    }
+}
+```
diff --git a/2018.12.24-leetcode665/Be a fresh man.md b/2018.12.24-leetcode665/Be a fresh man.md
@@ -0,0 +1,62 @@
+## 665_(非递减数列)Non-decreasing Array
+## 1 问题描述、输入输出与样例
+### 1.1 问题描述
+给定一个长度为 n 的整数数组，你的任务是判断在最多改变 1 个元素的情况下，该数组能否变成一个非递减数列。<br>
+我们是这样定义一个非递减数列的： 对于数组中所有的 i (1 <= i < n)，满足 array[i] <= array[i + 1]。<br>
+__说明__:  <br>
+n 的范围为 [1, 10,000]。
+### 1.2 输入与输出
+输入：
+* vector<int>& nums:输入的整数数组
+
+输出：
+* bool:在最多改变 1 个元素的情况下，该数组能否变成一个非递减数列
+### 1.3 样例
+#### 1.3.1 样例1
+输入: [4,2,3]<br>
+输出: True<br>
+解释: 你可以通过把第一个4变成1来使得它成为一个非递减数列。
+#### 1.3.2 样例2
+输入: [4,2,1]<br>
+输出: False<br>
+解释: 你不能在只改变一个元素的情况下将其变为非递减数列。
+## 2 思路描述与代码	
+### 2.1 思路描述（比较计数法）
+cnt统计当前数比前一个数小的个数;
+遍历数组中所有的值 
+* 如果当前值比前一个值小
+    * 如果cnt == 1，则判断是否存在纠正的方式，无则返回false
+    * 否则cnt >= 2，则不存在纠正方式，返回false   
+### 2.2 代码
+```cpp
+bool checkPossibility(vector<int>& nums) {
+    int n = nums.size();
+    int cnt = 0;
+    for (int i = 1; i < n; i++) {
+        if (nums[i - 1] > nums[i]) {
+            cnt++;
+            //cnt = 1时，需要注意有两种情况可以补救：
+            //1. 比如[-1 4 2 3], 4 < 2, 2 > -1, 通过修改 4  为 -1~2 间的数都可以补救
+            //2. 比如[1 2 -1 3],-1 < 2, 2 < 3,  通过修改 -1 为  2~3 间的数都可以补救
+
+            //cnt >= 2则怎样都不行了，因为只能修改一次
+            if((cnt == 1 && i >= 2 && i < n - 1 && nums[i] < nums[i - 2] && nums[i + 1] < nums[i - 1]) || cnt >= 2) return false;
+        }
+    }
+    return true;
+}
+```
+## 3 思考与拓展
+### 3.1 思考
+本题中需要考虑多种情况的可能性，否则容易犯错。
+#### 3.1.1 其他方法
+无。
+#### 3.1.2 复杂度分析
+方法|空间复杂度|时间复杂度
+--- | --- | ---
+比较计数法|O(1)|O(n)
+#### 3.1.3 难点分析
+1. 当前值比前一个值小只出现一次时需要考虑[-1 4 2 3]、[1 2 -1 3]、[1,2,3,2]、[4,1,2,3]之类可纠正的情况
+
+### 3.2 拓展
+如果给你的是链表数据呢？
diff --git a/2018.12.24-leetcode665/WYJ.md b/2018.12.24-leetcode665/WYJ.md
diff --git a/2018.12.24-leetcode665/sourcema.md b/2018.12.24-leetcode665/sourcema.md
