auto commit

Author: CyC2018

docs/notes/Leetcode 题解 - 贪心思想.md

@@ -1,21 +1,21 @@
 <!-- GFM-TOC -->
-* [分配饼干](#分配饼干)
-* [不重叠的区间个数](#不重叠的区间个数)
-* [投飞镖刺破气球](#投飞镖刺破气球)
-* [根据身高和序号重组队列](#根据身高和序号重组队列)
-* [分隔字符串使同种字符出现在一起](#分隔字符串使同种字符出现在一起)
-* [种植花朵](#种植花朵)
-* [判断是否为子序列](#判断是否为子序列)
-* [修改一个数成为非递减数组](#修改一个数成为非递减数组)
-* [股票的最大收益](#股票的最大收益)
-* [子数组最大的和](#子数组最大的和)
-* [买入和售出股票最大的收益](#买入和售出股票最大的收益)
+* [1. 分配饼干](#1-分配饼干)
+* [2. 不重叠的区间个数](#2-不重叠的区间个数)
+* [3. 投飞镖刺破气球](#3-投飞镖刺破气球)
+* [3. 根据身高和序号重组队列](#3-根据身高和序号重组队列)
+* [4. 买卖股票最大的收益](#4-买卖股票最大的收益)
+* [5. 买卖股票的最大收益 II](#5-买卖股票的最大收益-ii)
+* [6. 种植花朵](#6-种植花朵)
+* [7. 判断是否为子序列](#7-判断是否为子序列)
+* [8. 修改一个数成为非递减数组](#8-修改一个数成为非递减数组)
+* [9. 子数组最大的和](#9-子数组最大的和)
+* [10. 分隔字符串使同种字符出现在一起](#10-分隔字符串使同种字符出现在一起)
 <!-- GFM-TOC -->
 
 
 保证每次操作都是局部最优的，并且最后得到的结果是全局最优的。
 
-# 分配饼干
+# 1. 分配饼干
 
 [455. Assign Cookies (Easy)](https://leetcode.com/problems/assign-cookies/description/)
 
@@ -49,7 +49,7 @@ public int findContentChildren(int[] g, int[] s) {
 }
 ```
 
-# 不重叠的区间个数
+# 2. 不重叠的区间个数
 
 [435. Non-overlapping Intervals (Medium)](https://leetcode.com/problems/non-overlapping-intervals/description/)
 
@@ -107,7 +107,7 @@ Arrays.sort(intervals, new Comparator<Interval>() {
 });
 ```
 
-# 投飞镖刺破气球
+# 3. 投飞镖刺破气球
 
 [452. Minimum Number of Arrows to Burst Balloons (Medium)](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
 
@@ -119,7 +119,7 @@ Output:
 2
 ```
 
-题目描述：气球在一个水平数轴上摆放，可以重叠，飞镖垂直投向坐标轴，使得路径上的气球都会刺破。求解最小的投飞镖次数使所有气球都被刺破。
+题目描述：气球在一个水平数轴上摆放，可以重叠，飞镖垂直投向坐标轴，使得路径上的气球都被刺破。求解最小的投飞镖次数使所有气球都被刺破。
 
 也是计算不重叠的区间个数，不过和 Non-overlapping Intervals 的区别在于，[1, 2] 和 [2, 3] 在本题中算是重叠区间。
 
@@ -141,7 +141,7 @@ public int findMinArrowShots(int[][] points) {
 }
 ```
 
-# 根据身高和序号重组队列
+# 3. 根据身高和序号重组队列
 
 [406. Queue Reconstruction by Height(Medium)](https://leetcode.com/problems/queue-reconstruction-by-height/description/)
 
@@ -157,7 +157,7 @@ Output:
 
 为了使插入操作不影响后续的操作，身高较高的学生应该先做插入操作，否则身高较小的学生原先正确插入的第 k 个位置可能会变成第 k+1 个位置。
 
-身高降序、k 值升序，然后按排好序的顺序插入队列的第 k 个位置中。
+身高 h 降序、个数 k 值升序，然后将某个学生插入队列的第 k 个位置中。
 
 ```java
 public int[][] reconstructQueue(int[][] people) {
@@ -173,48 +173,51 @@ public int[][] reconstructQueue(int[][] people) {
 }
 ```
 
-# 分隔字符串使同种字符出现在一起
+# 4. 买卖股票最大的收益
 
-[763. Partition Labels (Medium)](https://leetcode.com/problems/partition-labels/description/)
+[121. Best Time to Buy and Sell Stock (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
 
-```html
-Input: S = "ababcbacadefegdehijhklij"
-Output: [9,7,8]
-Explanation:
-The partition is "ababcbaca", "defegde", "hijhklij".
-This is a partition so that each letter appears in at most one part.
-A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.
-```
+题目描述：一次股票交易包含买入和卖出，只进行一次交易，求最大收益。
+
+只要记录前面的最小价格，将这个最小价格作为买入价格，然后将当前的价格作为售出价格，查看当前收益是不是最大收益。
 
 ```java
-public List<Integer> partitionLabels(String S) {
-    int[] lastIndexsOfChar = new int[26];
-    for (int i = 0; i < S.length(); i++) {
-        lastIndexsOfChar[char2Index(S.charAt(i))] = i;
-    }
-    List<Integer> partitions = new ArrayList<>();
-    int firstIndex = 0;
-    while (firstIndex < S.length()) {
-        int lastIndex = firstIndex;
-        for (int i = firstIndex; i < S.length() && i <= lastIndex; i++) {
-            int index = lastIndexsOfChar[char2Index(S.charAt(i))];
-            if (index > lastIndex) {
-                lastIndex = index;
-            }
-        }
-        partitions.add(lastIndex - firstIndex + 1);
-        firstIndex = lastIndex + 1;
+public int maxProfit(int[] prices) {
+    int n = prices.length;
+    if (n == 0) return 0;
+    int soFarMin = prices[0];
+    int max = 0;
+    for (int i = 1; i < n; i++) {
+        if (soFarMin > prices[i]) soFarMin = prices[i];
+        else max = Math.max(max, prices[i] - soFarMin);
     }
-    return partitions;
+    return max;
 }
+```
 
-private int char2Index(char c) {
-    return c - 'a';
+
+# 5. 买卖股票的最大收益 II
+
+[122. Best Time to Buy and Sell Stock II (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
+
+题目描述：可以进行多次交易，多次交易之间不能交叉进行，可以进行多次交易。
+
+对于 [a, b, c, d]，如果有 a <= b <= c <= d ，那么最大收益为 d - a。而 d - a = (d - c) + (c - b) + (b - a) ，因此当访问到一个 prices[i] 且 prices[i] - prices[i-1] > 0，那么就把 prices[i] - prices[i-1] 添加到收益中。
+
+```java
+public int maxProfit(int[] prices) {
+    int profit = 0;
+    for (int i = 1; i < prices.length; i++) {
+        if (prices[i] > prices[i - 1]) {
+            profit += (prices[i] - prices[i - 1]);
+        }
+    }
+    return profit;
 }
 ```
 
 
-# 种植花朵
+# 6. 种植花朵
 
 [605. Can Place Flowers (Easy)](https://leetcode.com/problems/can-place-flowers/description/)
 
@@ -223,7 +226,7 @@ Input: flowerbed = [1,0,0,0,1], n = 1
 Output: True
 ```
 
-题目描述：花朵之间至少需要一个单位的间隔，求解是否能种下 n 朵花。
+题目描述：flowerbed 数组中 1 表示已经种下了花朵。花朵之间至少需要一个单位的间隔，求解是否能种下 n 朵花。
 
 ```java
 public boolean canPlaceFlowers(int[] flowerbed, int n) {
@@ -244,7 +247,7 @@ public boolean canPlaceFlowers(int[] flowerbed, int n) {
 }
 ```
 
-# 判断是否为子序列
+# 7. 判断是否为子序列
 
 [392. Is Subsequence (Medium)](https://leetcode.com/problems/is-subsequence/description/)
 
@@ -266,7 +269,7 @@ public boolean isSubsequence(String s, String t) {
 }
 ```
 
-# 修改一个数成为非递减数组
+# 8. 修改一个数成为非递减数组
 
 [665. Non-decreasing Array (Easy)](https://leetcode.com/problems/non-decreasing-array/description/)
 
@@ -276,9 +279,9 @@ Output: True
 Explanation: You could modify the first 4 to 1 to get a non-decreasing array.
 ```
 
-题目描述：判断一个数组能不能只修改一个数就成为非递减数组。
+题目描述：判断一个数组是否能只修改一个数就成为非递减数组。
 
-在出现 nums[i] < nums[i - 1] 时，需要考虑的是应该修改数组的哪个数，使得本次修改能使 i 之前的数组成为非递减数组，并且  **不影响后续的操作** 。优先考虑令 nums[i - 1] = nums[i]，因为如果修改 nums[i] = nums[i - 1] 的话，那么 nums[i] 这个数会变大，就有可能比 nums[i + 1] 大，从而影响了后续操作。还有一个比较特别的情况就是 nums[i] < nums[i - 2]，只修改 nums[i - 1] = nums[i] 不能使数组成为非递减数组，只能修改 nums[i] = nums[i - 1]。
+在出现 nums[i] < nums[i - 1] 时，需要考虑的是应该修改数组的哪个数，使得本次修改能使 i 之前的数组成为非递减数组，并且  **不影响后续的操作** 。优先考虑令 nums[i - 1] = nums[i]，因为如果修改 nums[i] = nums[i - 1] 的话，那么 nums[i] 这个数会变大，就有可能比 nums[i + 1] 大，从而影响了后续操作。还有一个比较特别的情况就是 nums[i] < nums[i - 2]，修改 nums[i - 1] = nums[i] 不能使数组成为非递减数组，只能修改 nums[i] = nums[i - 1]。
 
 ```java
 public boolean checkPossibility(int[] nums) {
@@ -298,27 +301,9 @@ public boolean checkPossibility(int[] nums) {
 }
 ```
 
-# 股票的最大收益
-
-[122. Best Time to Buy and Sell Stock II (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
 
-题目描述：一次股票交易包含买入和卖出，多个交易之间不能交叉进行。
 
-对于 [a, b, c, d]，如果有 a <= b <= c <= d ，那么最大收益为 d - a。而 d - a = (d - c) + (c - b) + (b - a) ，因此当访问到一个 prices[i] 且 prices[i] - prices[i-1] > 0，那么就把 prices[i] - prices[i-1] 添加到收益中，从而在局部最优的情况下也保证全局最优。
-
-```java
-public int maxProfit(int[] prices) {
-    int profit = 0;
-    for (int i = 1; i < prices.length; i++) {
-        if (prices[i] > prices[i - 1]) {
-            profit += (prices[i] - prices[i - 1]);
-        }
-    }
-    return profit;
-}
-```
-
-# 子数组最大的和
+# 9. 子数组最大的和
 
 [53. Maximum Subarray (Easy)](https://leetcode.com/problems/maximum-subarray/description/)
 
@@ -342,28 +327,45 @@ public int maxSubArray(int[] nums) {
 }
 ```
 
-# 买入和售出股票最大的收益
+# 10. 分隔字符串使同种字符出现在一起
 
-[121. Best Time to Buy and Sell Stock (Easy)](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
-
-题目描述：只进行一次交易。
+[763. Partition Labels (Medium)](https://leetcode.com/problems/partition-labels/description/)
 
-只要记录前面的最小价格，将这个最小价格作为买入价格，然后将当前的价格作为售出价格，查看当前收益是不是最大收益。
+```html
+Input: S = "ababcbacadefegdehijhklij"
+Output: [9,7,8]
+Explanation:
+The partition is "ababcbaca", "defegde", "hijhklij".
+This is a partition so that each letter appears in at most one part.
+A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.
+```
 
 ```java
-public int maxProfit(int[] prices) {
-    int n = prices.length;
-    if (n == 0) return 0;
-    int soFarMin = prices[0];
-    int max = 0;
-    for (int i = 1; i < n; i++) {
-        if (soFarMin > prices[i]) soFarMin = prices[i];
-        else max = Math.max(max, prices[i] - soFarMin);
+public List<Integer> partitionLabels(String S) {
+    int[] lastIndexsOfChar = new int[26];
+    for (int i = 0; i < S.length(); i++) {
+        lastIndexsOfChar[char2Index(S.charAt(i))] = i;
     }
-    return max;
+    List<Integer> partitions = new ArrayList<>();
+    int firstIndex = 0;
+    while (firstIndex < S.length()) {
+        int lastIndex = firstIndex;
+        for (int i = firstIndex; i < S.length() && i <= lastIndex; i++) {
+            int index = lastIndexsOfChar[char2Index(S.charAt(i))];
+            if (index > lastIndex) {
+                lastIndex = index;
+            }
+        }
+        partitions.add(lastIndex - firstIndex + 1);
+        firstIndex = lastIndex + 1;
+    }
+    return partitions;
 }
-```
 
+private int char2Index(char c) {
+    return c - 'a';
+}
+```