Merge pull request apachecn#15 from apachecn/master

1

Author: xshahq

docs/Leetcode_Solutions/Python/376._Wiggle_Subsequence.md

@@ -0,0 +1,67 @@
+# 376. Wiggle Subsequence
+
+**<font color=red>难度: Medium</font>**
+
+## 刷题内容
+
+> 原题连接
+
+* https://leetcode.com/problems/wiggle-subsequence/description/
+
+> 内容描述
+
+```
+A sequence of numbers is called a wiggle sequence if the differences between successive numbers strictly alternate between positive and negative. The first difference (if one exists) may be either positive or negative. A sequence with fewer than two elements is trivially a wiggle sequence.
+
+For example, [1,7,4,9,2,5] is a wiggle sequence because the differences (6,-3,5,-7,3) are alternately positive and negative. In contrast, [1,4,7,2,5] and [1,7,4,5,5] are not wiggle sequences, the first because its first two differences are positive and the second because its last difference is zero.
+
+Given a sequence of integers, return the length of the longest subsequence that is a wiggle sequence. A subsequence is obtained by deleting some number of elements (eventually, also zero) from the original sequence, leaving the remaining elements in their original order.
+
+Example 1:
+
+Input: [1,7,4,9,2,5]
+Output: 6
+Explanation: The entire sequence is a wiggle sequence.
+Example 2:
+
+Input: [1,17,5,10,13,15,10,5,16,8]
+Output: 7
+Explanation: There are several subsequences that achieve this length. One is [1,17,10,13,10,16,8].
+Example 3:
+
+Input: [1,2,3,4,5,6,7,8,9]
+Output: 2
+Follow up:
+Can you do it in O(n) time?
+```
+
+## 解题方案
+
+> 思路 1
+******- 时间复杂度: O(N)******- 空间复杂度: O(1)******
+
+
+
+很简单的思想，从index为1的num开始看
+- 如果比之前一个数字大的话，那么此时就可以看作之前最后一下是negative的序列的后续num
+- 如果比之前一个数字小的话，那么此时就可以看作之前最后一下是positive的序列的后续num
+- 如果与之前一个数字相等的话，那么当前这个数字可以直接删除不要
+
+
+```python
+class Solution(object):
+    def wiggleMaxLength(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        if not nums or len(nums) == 0:
+            return 0
+        positive, negative = 1, 1
+        for i in range(1, len(nums)):
+            if nums[i] > nums[i-1]:
+                positive = negative + 1
+            elif nums[i] < nums[i-1]:
+                negative = positive + 1
+        return max(positive, negative)
+```

docs/Leetcode_Solutions/Python/924._Minimize_Malware_Spread.md

@@ -49,7 +49,7 @@ graph[i][i] = 1
 ## 解题方案
 
 > 思路 1
-******- 时间复杂度: O(N^2)******- 空间复杂度: O(N)******
+******- 时间复杂度: O(len(graph)^2)******- 空间复杂度: O(len(graph))******
 
 
 
@@ -59,11 +59,11 @@ graph[i][i] = 1
 
 思路就是看看initial里面哪个index最小的点所在的联通分量size最大
 
-其中要注意每个initial中元素ini所在的联通分量我们还要去除它里面含有的本身就在initial中的其他元素，因为对于这些元素，事实上即使我们删除了ini，也minimize不了它们。所以要算一下每个initial里面的元素所在的联通分量里面包含的其他的initial元素的个数，代码中带dup表示
+其中要注意每个initial中元素ini所在的联通分量我们还要去除它里面含有的本身就在initial中的其他元素，因为对于这些元素，事实上即使我们删除了ini，也minimize不了它们。所以要算一下每个initial里面的元素所在的联通分量里面包含的其他的initial元素的个数，代码中用dup表示
 
 graph长度为N，
 
-find()时间复杂度为O(N), union为O(1)，所以最终时间复杂度为O(N^2)
+find()时间复杂度为O(N), union为O(1)，所以最终时间复杂度为O(len(graph)^2)
 
 空间为O(N)
 
@@ -88,9 +88,10 @@ class Solution(object):
 
         uf = [i for i in range(len(graph))]
         for i in range(len(graph)):
-            for j in range(len(graph[0])):
+            for j in range(i+1, len(graph)):
                 if graph[i][j]:
                     union(i, j)
+                    
         lookup, dup = {}, {}
         for i in range(len(graph)):
             root = find(i)
@@ -102,10 +103,10 @@ class Solution(object):
         max_component_size = max(component_sizes_of_initial)
 
         res = []
-        for i in range(len(component_sizes_of_initial)):
+        for i in range(len(initial)):
             if component_sizes_of_initial[i] == max_component_size:
                 res.append(initial[i])
-        return min(res) 
+        return min(res)          
 ```
 
 

docs/Leetcode_Solutions/Python/925._Long_Pressed_Name.md

@@ -0,0 +1,110 @@
+# 925. Long Pressed Name
+
+**<font color=red>难度: Easy</font>**
+
+## 刷题内容
+
+> 原题连接
+
+* https://leetcode.com/problems/long-pressed-name/description/
+
+> 内容描述
+
+```
+Your friend is typing his name into a keyboard.  Sometimes, when typing a character c, the key might get long pressed, and the character will be typed 1 or more times.
+
+You examine the typed characters of the keyboard.  Return True if it is possible that it was your friends name, with some characters (possibly none) being long pressed.
+
+ 
+
+Example 1:
+
+Input: name = "alex", typed = "aaleex"
+Output: true
+Explanation: 'a' and 'e' in 'alex' were long pressed.
+Example 2:
+
+Input: name = "saeed", typed = "ssaaedd"
+Output: false
+Explanation: 'e' must have been pressed twice, but it wasn't in the typed output.
+Example 3:
+
+Input: name = "leelee", typed = "lleeelee"
+Output: true
+Example 4:
+
+Input: name = "laiden", typed = "laiden"
+Output: true
+Explanation: It's not necessary to long press any character.
+ 
+
+Note:
+
+name.length <= 1000
+typed.length <= 1000
+The characters of name and typed are lowercase letters.
+```
+
+## 解题方案
+
+> 思路 1
+******- 时间复杂度: O(max(len(name),len(typed)))******- 空间复杂度: O(1)******
+
+
+两个字符串从index为0开始比较
+
+- 如果该字符相同就同时往后挪, i += 1, j += 1
+- 如果该字符不相同，那么
+    - 如果typed的字符和name的前一个字符相等，那么j += 1
+    - 如果typed的字符和name的前一个字符不相等，肯定不行，直接返回False
+- while循环完了，如果 i < len(name)，那么说明name没有被比较晚，肯定不行，直接返回False
+- 如果typed还没有完，即j < len(typed)，那么如果typed剩下的所有字符不是都与name的最后一个字符相等的话，就说明不行，直接返回False，否则返回True
+
+
+```python
+class Solution(object):
+    def isLongPressedName(self, name, typed):
+        """
+        :type name: str
+        :type typed: str
+        :rtype: bool
+        """
+        i, j = 0, 0
+        prev = None
+        
+        while i < len(name) and j < len(typed):
+            if name[i] == typed[j]:
+                prev = name[i]
+                i += 1
+                j += 1
+            else:
+                if typed[j] == prev:
+                    j += 1
+                else:
+                    return False
+        if i < len(name):
+            return False
+        
+        while j < len(typed):
+            if typed[j] != prev:
+                return False
+            else:
+                j += 1
+                
+        return True
+```
+    
+    
+    
+    
+    
+    
+    
+    
+    
+
+
+
+
+
+

docs/Leetcode_Solutions/Python/926._Flip_String_to_Monotone_Increasing.md

@@ -0,0 +1,151 @@
+# 926. Flip String to Monotone Increasing
+
+**<font color=red>难度: Medium</font>**
+
+## 刷题内容
+
+> 原题连接
+
+* https://leetcode.com/problems/flip-string-to-monotone-increasing/description/
+
+> 内容描述
+
+```
+A string of '0's and '1's is monotone increasing if it consists of some number of '0's (possibly 0), followed by some number of '1's (also possibly 0.)
+
+We are given a string S of '0's and '1's, and we may flip any '0' to a '1' or a '1' to a '0'.
+
+Return the minimum number of flips to make S monotone increasing.
+
+ 
+
+Example 1:
+
+Input: "00110"
+Output: 1
+Explanation: We flip the last digit to get 00111.
+Example 2:
+
+Input: "010110"
+Output: 2
+Explanation: We flip to get 011111, or alternatively 000111.
+Example 3:
+
+Input: "00011000"
+Output: 2
+Explanation: We flip to get 00000000.
+ 
+
+Note:
+
+1 <= S.length <= 20000
+S only consists of '0' and '1' characters.
+```
+
+## 解题方案
+
+> 思路 1
+******- 时间复杂度: O(N)******- 空间复杂度: O(N)******
+
+
+
+
+
+
+
+我们就这样想吧，要想最后满足要求，我们的字符串S肯定是'000000001111111'的形式，可以全为0还可以全为1
+
+因此我们每种情况都考虑一下，取其中改变次数最小的那个次数，
+
+即让前i个字符都变成0，后面len(S)-i个字符都变成1所需要的次数
+
+
+
+```python
+class Solution(object):
+    def minFlipsMonoIncr(self, S):
+        """
+        :type S: str
+        :rtype: int
+        """
+        if not S or len(S) <= 1:
+            return 0
+        count_0, count_1 = [0] * (len(S)+1), [0] * (len(S)+1)
+        for i, v in enumerate(S):
+            if v == '0':
+                count_0[i+1] = count_0[i] + 1
+                count_1[i+1] = count_1[i]
+            else:
+                count_0[i+1] = count_0[i]
+                count_1[i+1] = count_1[i] + 1
+        res = sys.maxsize
+        for i in range(len(S)+1): # 代表S前面i个字符全都是'0'
+            res = min(res, count_1[i] + count_0[-1] - count_0[i])
+        return res
+```
+
+
+
+> 思路 2
+******- 时间复杂度: O(N)******- 空间复杂度: O(1)******
+
+跟刚才的思想一样，我们只要把左边的1全部变成0， 右边的0全部变成1，然后取最小的那次就行了
+
+
+```python
+class Solution(object):
+    def minFlipsMonoIncr(self, S):
+        """
+        :type S: str
+        :rtype: int
+        """
+        r0, r1, l0, l1 = 0, 0, 0, 0
+        for i, c in enumerate(S):
+            if c == '0':
+                r0 += 1 # 从idx为0开始，右边有多少个0
+            else:
+                r1 += 1 # 从idx为0开始，右边有多少个1
+        res = r0
+        for i, c in enumerate(S):
+            if c == '0': 
+                r0 -= 1
+                l0 += 1
+            else:
+                r1 -= 1
+                l1 += 1
+            res = min(l1 + r0, res) # 此时我们要将左边的1全部变成0，右边的0全部变成1
+        return res
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+