[1130]ADD:LC-5

Author: Coder-AndyLee

Diff for: readme.md

@@ -42,13 +42,16 @@
  [[20201111]474. 一和零-Medium](动态规划/背包问题/474.%20一和零-Medium.md)  
  [[20201116]1641. 统计字典序元音字符串的数目-Medium](动态规划/1641.%20统计字典序元音字符串的数目-Medium.md)  
  [[20201117]剑指 Offer 47. 礼物的最大价值](动态规划/剑指%20Offer%2047.%20礼物的最大价值.md)  
- [[20201118]134. 加油站-Medium](贪心/134.%20加油站-Medium.md)  
+[[20201118]134. 加油站-Medium](贪心/134.%20加油站-Medium.md)  
 [[20201119]338. 比特位计数-Medium](动态规划/338.%20比特位计数-Medium.md)  
 [[20201121]21. 合并两个有序链表-Easy](链表/21.%20合并两个有序链表-Easy.md)  
 [[20201123]148. 排序链表-Medium](链表/148.%20排序链表-Medium.md)   
 [[20201124]1402. 做菜顺序-Hard](贪心/1402.%20做菜顺序-Hard.md)  
 [[20201125]1314. 矩阵区域和-Medium](动态规划/前缀和/1314.%20矩阵区域和-Medium)   
 [[20201126]1292. 元素和小于等于阈值的正方形的最大边长-Medium](动态规划/前缀和/1292.%20元素和小于等于阈值的正方形的最大边长-Medium.md)  
+[[20201127]1277. 统计全为 1 的正方形子矩阵-Medium](动态规划/前缀和/1277.%20统计全为%201%20的正方形子矩阵-Medium.md)
+[[20201129]976. 三角形的最大周长-Easy](贪心/976.%20三角形的最大周长-Easy.md)  
+[[20201130]5. 最长回文子串-Medium](动态规划/5.%20最长回文子串-Medium.md)  
 
 # 按类别归类
 ## 树
@@ -104,10 +107,11 @@
 - [474. 一和零-Medium](动态规划/背包问题/474.%20一和零-Medium.md)  
 ### 4. 前缀和问题
 - [560. 和为K的子数组-Medium](数组/560.%20和为K的子数组-Medium.md)   
+- [1277. 统计全为 1 的正方形子矩阵-Medium](动态规划/前缀和/1277.%20统计全为%201%20的正方形子矩阵-Medium.md)  
 - [1292. 元素和小于等于阈值的正方形的最大边长-Medium](动态规划/前缀和/1292.%20元素和小于等于阈值的正方形的最大边长-Medium.md)  
 - [1314. 矩阵区域和-Medium](动态规划/前缀和/1314.%20矩阵区域和-Medium)  
 
-
+[5. 最长回文子串-Medium](动态规划/5.%20最长回文子串-Medium.md)  
 [53. 最大子序和-Easy](动态规划/53.%20最大子序和-Easy.md)  
 [338. 比特位计数-Medium](动态规划/338.%20比特位计数-Medium.md)  
 [1641. 统计字典序元音字符串的数目-Medium](动态规划/1641.%20统计字典序元音字符串的数目-Medium.md)  
@@ -117,4 +121,5 @@
 ## 贪心
 [134. 加油站-Medium](贪心/134.%20加油站-Medium.md)  
 [763. 划分字母区间-Medium](贪心/763.%20划分字母区间-Medium.md)  
+[976. 三角形的最大周长-Easy](贪心/976.%20三角形的最大周长-Easy.md)  
 [1402. 做菜顺序-Hard](贪心/1402.%20做菜顺序-Hard.md)   

Diff for: 动态规划/5. 最长回文子串-Medium.md

@@ -0,0 +1,89 @@
+# [Description](https://leetcode-cn.com/problems/longest-palindromic-substring)
+给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
+
+示例 1：
+```python
+输入: "babad"
+输出: "bab"
+注意: "aba" 也是一个有效答案。
+```
+示例 2：
+```python
+输入: "cbbd"
+输出: "bb"
+```
+
+
+# Solution
+### 解法一：动态规划
+- 抓住主要状态转移方程
+	```python
+	if s[i] == s[j] and dp[i+1][j-1] == 1:
+		dp[i][j] = 1
+	```
+- 本题遍历dp的思路与常规套路不太一样，因为状态转移是从短子串向长子串转移的，所以遍历应按**子串长度**进行。
+- 初始条件：长度为1，以及长度为2且两字符相等的子串为回文子串
+	```python
+	for i in range(len(s)):
+		dp[i][i] = 1
+		if i+1 < len(s) and s[i] == s[i+1]:
+			dp[i][i+1] = 1
+	```
+- 注意考虑边界条件：**字符串为空**或为**长度为1**
+- 时间复杂度：$O(n^2)$
+- 空间复杂度：$O(n^2)$
+```python
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        if s == '':
+            return ''
+        elif len(s) == 1:
+            return s
+        
+        dp = [[0]*len(s) for _ in range(len(s))]
+        start = 0
+        max_len = 1
+        
+        for i in range(len(s)):
+            dp[i][i] = 1
+            if i+1 < len(s) and s[i] == s[i+1]:
+                dp[i][i+1] = 1
+                start = i
+                max_len = 2
+                
+        for length in range(3, len(s)+1):
+            for i in range(len(s) - length + 1):
+                j = i + length - 1
+                if s[i] == s[j] and dp[i+1][j-1] == 1:
+                    dp[i][j] = 1
+                    start = i
+                    max_len = length
+        # print(start, start+max_len+1)
+        return s[start : start+max_len]
+```
+
+### 解法二：中心扩散
+- 遍历字符串，找 以i为中点 / 或以i,i+1为中点 的最长回文子串长度，并更新记录值。
+- 时间复杂度：$O(n^2)$
+- 空间复杂度：$O(1)$
+```python
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        def spread(s, left, right):
+            while left >= 0 and right <= len(s)-1 and s[left] == s[right]:
+                left -= 1
+                right += 1
+            return left+1, right-1
+
+        start, end = 0, 0
+
+        for i in range(len(s)):
+            l1, r1 = spread(s, i, i)
+            l2, r2 = spread(s, i, i+1)
+            if r1 - l1 > end - start:
+                start, end = l1, r1
+            if r2 - l2 > end - start:
+                start, end = l2, r2
+            
+        return s[start: end+1]
+```

Diff for: 动态规划/前缀和/1277. 统计全为 1 的正方形子矩阵-Medium.md

@@ -0,0 +1,63 @@
+# [Description](https://leetcode-cn.com/problems/count-square-submatrices-with-all-ones)
+给你一个 m * n 的矩阵，矩阵中的元素不是 0 就是 1，请你统计并返回其中完全由 1 组成的 正方形 子矩阵的个数。
+
+ 
+
+示例 1：
+```python
+输入：matrix =
+[
+  [0,1,1,1],
+  [1,1,1,1],
+  [0,1,1,1]
+]
+输出：15
+解释： 
+边长为 1 的正方形有 10 个。
+边长为 2 的正方形有 4 个。
+边长为 3 的正方形有 1 个。
+正方形的总数 = 10 + 4 + 1 = 15.
+```
+示例 2：
+```python
+输入：matrix = 
+[
+  [1,0,1],
+  [1,1,0],
+  [1,1,0]
+]
+输出：7
+解释：
+边长为 1 的正方形有 6 个。 
+边长为 2 的正方形有 1 个。
+正方形的总数 = 6 + 1 = 7.
+```
+
+提示：
+
+- 1 <= arr.length <= 300
+- 1 <= arr[0].length <= 300
+- 0 <= arr[i][j] <= 1
+
+
+# Solution
+- 参考题解，状态转移方程的制定比较巧妙。https://leetcode-cn.com/problems/count-square-submatrices-with-all-ones/solution/tong-ji-quan-wei-1-de-zheng-fang-xing-zi-ju-zhen-2/
+
+
+```python
+class Solution:
+    def countSquares(self, matrix: List[List[int]]) -> int:
+        m, n = len(matrix), len(matrix[0])
+        f = [[0] * n for _ in range(m)]
+        ans = 0
+        for i in range(m):
+            for j in range(n):
+                if i == 0 or j == 0:
+                    f[i][j] = matrix[i][j]
+                elif matrix[i][j] == 0:
+                    f[i][j] = 0
+                else:
+                    f[i][j] = min(f[i][j - 1], f[i - 1][j], f[i - 1][j - 1]) + 1
+                ans += f[i][j]
+        return ans
+```

Diff for: 动态规划/前缀和/1314. 矩阵区域和-Medium.md

@@ -27,6 +27,7 @@ i - K <= r <= i + K, j - K <= c <= j + K 
 - 本题是可用前缀和的思路来解（画图比较清晰）。先计算一个dp数组，其意义为：$dp[i][j]=sum\_mat[0...i][0...j]$。（实际使用时基本会在第一行和第一列各添加一排0以便于后续计算）之后可用如图所示的矩阵交并补的方法求解
 - ![Pasted image 20201125223235.png](pic/Pasted%20image%2020201125223235.png)
 - ![Pasted image 20201125223309.png](pic/Pasted%20image%2020201125223309.png)
+- 注意：前缀和问题往往可以考虑**二分**来在计算时优化
 ```python
 class Solution:
     def matrixBlockSum(self, mat: List[List[int]], K: int) -> List[List[int]]:

Diff for: 贪心/976. 三角形的最大周长-Easy.md

@@ -0,0 +1,45 @@
+# [Description](https://leetcode-cn.com/problems/largest-perimeter-triangle)
+
+给定由一些正数（代表长度）组成的数组 A，返回由其中三个长度组成的、面积不为零的三角形的最大周长。
+
+如果不能形成任何面积不为零的三角形，返回 0。
+
+
+示例 1：
+```python
+输入：[2,1,2]
+输出：5
+```
+示例 2：
+```python
+输入：[1,2,1]
+输出：0
+```
+示例 3：
+```python
+输入：[3,2,3,4]
+输出：10
+```
+示例 4：
+```python
+输入：[3,6,2,3]
+输出：8
+```
+
+提示：
+
+- 3 <= A.length <= 10000
+- 1 <= A[i] <= 10^6
+
+
+# Solution
+- 本题使用贪心解即可，核心思路为判断是否可构成三角形：两短边之和大于第三条长边。因此，可以先对数组排序，再对长边遍历；由于需要周长最大，两短边的index需与长边相邻
+```python
+class Solution:
+    def largestPerimeter(self, A: List[int]) -> int:
+        A.sort()
+        for i in range(len(A)-1, 1, -1):
+            if A[i-2] + A[i-1] > A[i]:
+                return A[i-2] + A[i-1] + A[i]
+        return 0
+```

Diff for: 链表/148. 排序链表-Medium.md

@@ -33,6 +33,9 @@
 # Solution
 - 考虑O(n log n) 时间复杂度和O(1)空间复杂度，因此可使用的排序方法为快速排序、堆排序和合并排序；其中合并排序最适合链表。其次，由于递归会开辟额外的栈空间，所以只能使用迭代。
 - 采用自底向上的策略，先将链表分成split=1长度的子链表，并两两进行归并排序；在此基础上逐渐增大split(split *= 2)，直至split>=length(链表长度)
+- 注意：
+	- 归并时，对于用于归并的两段子链表，若第二段没有，则表明已到链表末尾，可以跳出循环
+	- 归并时，第一次遍历用于找这次用于归并的两段子链表，可用split控制遍历长度；第二次遍历用于合并两个有序链表，需要计算两段子链表的长度（因为在末尾时，第二段子链表长度不等于split），用这个长度控制遍历长度。
 ```python
 class Solution:
     def sortList(self, head: ListNode) -> ListNode: