Merge pull request apachecn#57 from apachecn/master

1

Author: xshahq

docs/Leetcode_Solutions/Python/312._Burst_Balloons.md

@@ -0,0 +1,109 @@
+# 312. Burst Balloons
+
+**<font color=red>难度: Hard</font>**
+
+## 刷题内容
+
+> 原题连接
+
+* https://leetcode.com/problems/burst-balloons/
+
+> 内容描述
+
+```
+Given n balloons, indexed from 0 to n-1. Each balloon is painted with a number on it represented by array nums. You are asked to burst all the balloons. If the you burst balloon i you will get nums[left] * nums[i] * nums[right] coins. Here left and right are adjacent indices of i. After the burst, the left and right then becomes adjacent.
+
+Find the maximum coins you can collect by bursting the balloons wisely.
+
+Note:
+
+You may imagine nums[-1] = nums[n] = 1. They are not real therefore you can not burst them.
+0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100
+Example:
+
+Input: [3,1,5,8]
+Output: 167 
+Explanation: nums = [3,1,5,8] --> [3,5,8] -->   [3,8]   -->  [8]  --> []
+             coins =  3*1*5      +  3*5*8    +  1*3*8      + 1*8*1   = 167
+```
+
+## 解题方案
+
+> 思路 1
+******- 时间复杂度: O(N^3)******- 空间复杂度: O(N^2)******
+
+典型dp, dp[left][right]代表爆掉left到right中间(not inclusive)所有的balloons, 所能得到的最大coins
+
+状态方程为：
+```dp[left][right] = max[(nums[i-1] * nums[i] * nums[i+1] + dp[left][i] + dp[i][right]) for i in range(left+1, right)]```
+其中i为最后一个被爆掉的气球
+
+这里的思考为：如果我们从第一个被爆掉的气球开始考虑，后面的情况我们不知道当前被爆掉的气球左右两边都是谁，也就写不出状态方程了
+
+但是如果从最后一个被爆掉的气球开始考虑的话，那它的左右两边肯定都是1，即nums[-1]和nums[n]；
+并且根据它分成的左右两边d[left][i]和dp[i][right]也可以通过同样的方法一步步算到最后
+
+
+这里还有一个trick，就是对于nums[i] = 0的气球最开始就可以直接删掉了，因为对于我们的最终结果没有任何影响
+
+beats 59.76%
+
+```python
+class Solution(object):
+    def maxCoins(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        nums = [1] + [i for i in nums if i > 0] + [1]
+        dp = [[0] * len(nums) for _ in range(len(nums))]
+
+        for gap in range(2, len(nums)):
+            for left in range(len(nums) - gap):
+                right = left + gap
+                for i in range(left + 1, right):
+                    dp[left][right] = max(dp[left][right],
+                           nums[left] * nums[i] * nums[right] + dp[left][i] + dp[i][right]) # i为最后一个被爆掉的气球
+        return dp[0][-1]
+```
+
+
+另外看到一个很有意思的[post](https://leetcode.com/problems/burst-balloons/discuss/76241/Another-way-to-think-of-this-problem-(Matrix-chain-multiplication))
+
+```
+If you think of bursting a balloon as multiplying two adjacent matrices, then this problem is exactly the classical DP problem
+Matrix-chain multiplication found in section 15.2 in the book Introduction to Algorithms (2nd edition).
+
+For example, given [3,5,8] and bursting 5, the number of coins you get is the number of scalar multiplications you need to do
+to multiply two matrices A[3*5] and B[5*8]. So in this example, the original problem is actually the same as given a matrix 
+chain A[1*3]*B[3*5]*C[5*8]*D[8*1], fully parenthesize it so that the total number of scalar multiplications is maximized, 
+although the orignal matrix-chain multiplication problem in the book asks to minimize it. Then you can see it clearly as a 
+classical DP problem.
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

docs/Leetcode_Solutions/Python/395._Longest_Substring_with_At_Least_K_Repeating_Characters.md

@@ -0,0 +1,146 @@
+# 395. Longest Substring with At Least K Repeating Characters
+
+**<font color=red>难度: Medium</font>**
+
+## 刷题内容
+
+> 原题连接
+
+* https://leetcode.com/problems/longest-substring-with-at-least-k-repeating-characters/
+
+> 内容描述
+
+```
+Find the length of the longest substring T of a given string (consists of lowercase letters only) such that every character in T appears no less than k times.
+
+Example 1:
+
+Input:
+s = "aaabb", k = 3
+
+Output:
+3
+
+The longest substring is "aaa", as 'a' is repeated 3 times.
+Example 2:
+
+Input:
+s = "ababbc", k = 2
+
+Output:
+5
+
+The longest substring is "ababb", as 'a' is repeated 2 times and 'b' is repeated 3 times.
+```
+
+## 解题方案
+
+> 思路 1
+******- 时间复杂度: O(N)******- 空间复杂度: O(N)******
+
+
+因为一共就只有26种不同的英文字母字符，所以我们只要做26次遍历即可。
+- 第1次找到一个最长的substring，它里面只有1种不同的字符，并且这1种字符出现至少k次
+- 第2次找到一个最长的substring，它里面只有2种不同的字符，并且这2种字符都出现至少k次
+- 第3次找到一个最长的substring，它里面只有2种不同的字符，并且这2种字符都出现至少k次
+- 第4次找到一个最长的substring，它里面只有2种不同的字符，并且这2种字符都出现至少k次
+- .........................................................................
+- .........................................................................
+- .........................................................................
+- 第26次找到一个最长的substring，它里面只有26种不同的字符，并且这26种字符都出现至少k次
+
+然后我们最终取最长的那个长度就可以了，大体就是slide window的思想，beats 15.57%
+
+```python
+class Solution(object):
+    def longestSubstring(self, s, k):
+        """
+        :type s: str
+        :type k: int
+        :rtype: int
+        """
+        if k == 0 or len(s) == 0:
+            return len(s)
+        res = 0
+        for ucc in range(1, 27):
+            res = max(res, self.longestSubstringWithUcc(s, k, ucc))
+        return res
+    
+    def longestSubstringWithUcc(self, s, k, ucc): # ucc: unique_chr_cnt
+        count = collections.defaultdict(int)
+        unique, no_less_than_k, start, res = 0, 0, 0, 0
+        for i, c in enumerate(s):
+            count[c] += 1
+            if count[c] == 1:
+                unique += 1
+            if count[c] == k:
+                no_less_than_k += 1
+            while start <= i and unique > ucc:
+                if count[s[start]] == 1:
+                    unique -= 1
+                if count[s[start]] == k:
+                    no_less_than_k -= 1
+                count[s[start]] -= 1
+                start += 1
+            if unique == ucc and no_less_than_k == ucc:
+                res = max(res, i - start + 1)
+        return res
+```
+
+
+
+
+> 思路 2
+******- 时间复杂度: O(N)******- 空间复杂度: O(N)******
+
+还有一个更好的方法，就是我们可以先计算出s中每种字符的个数，然后如果有一个字符的出现次数少于k次，那么说明任何包含这个字符的substring都不满足要求
+
+因此我们可以用这个字符来split整个字符串s，然后对split出来的各个substring继续递归调用longestSubstring函数即可，返回其中的最大值。
+
+如果所有的字符出现次数都不小于k次，那么说明整个字符串s都满足，我们直接返回len(s)
+
+beats 32.51%
+
+```python
+class Solution(object):
+    def longestSubstring(self, s, k):
+        """
+        :type s: str
+        :type k: int
+        :rtype: int
+        """
+        lookup = collections.Counter(s)
+        for c in lookup:
+            if lookup[c] < k:
+                return max(self.longestSubstring(t, k) for t in s.split(c))
+        return len(s)
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

docs/Leetcode_Solutions/Python/482._License_Key_Formatting.md

@@ -0,0 +1,58 @@
+# 482. License Key Formatting
+
+**<font color=red>难度: Easy</font>**
+
+## 刷题内容
+
+> 原题连接
+
+* https://leetcode.com/problems/license-key-formatting/
+
+> 内容描述
+
+```
+You are given a license key represented as a string S which consists only alphanumeric character and dashes. The string is separated into N+1 groups by N dashes.
+
+Given a number K, we would want to reformat the strings such that each group contains exactly K characters, except for the first group which could be shorter than K, but still must contain at least one character. Furthermore, there must be a dash inserted between two groups and all lowercase letters should be converted to uppercase.
+
+Given a non-empty string S and a number K, format the string according to the rules described above.
+
+Example 1:
+Input: S = "5F3Z-2e-9-w", K = 4
+
+Output: "5F3Z-2E9W"
+
+Explanation: The string S has been split into two parts, each part has 4 characters.
+Note that the two extra dashes are not needed and can be removed.
+Example 2:
+Input: S = "2-5g-3-J", K = 2
+
+Output: "2-5G-3J"
+
+Explanation: The string S has been split into three parts, each part has 2 characters except the first part as it could be shorter as mentioned above.
+Note:
+The length of string S will not exceed 12,000, and K is a positive integer.
+String S consists only of alphanumerical characters (a-z and/or A-Z and/or 0-9) and dashes(-).
+String S is non-empty.
+```
+
+## 解题方案
+
+> 思路 1
+******- 时间复杂度: O(N)******- 空间复杂度: O(1)******
+
+sb题没什么好说的
+
+beats 79.41%
+
+```python
+class Solution(object):
+    def licenseKeyFormatting(self, S, K):
+        """
+        :type S: str
+        :type K: int
+        :rtype: str
+        """
+        S = S.replace('-', '').upper()[::-1]
+        return '-'.join(S[i:i+K] for i in range(0, len(S), K))[::-1]
+```