diff --git a/README.md b/README.md
index fa1b603b..96f7bb9c 100644
--- a/README.md
+++ b/README.md
@@ -122,11 +122,6 @@
* [递归算法的时间与空间复杂度分析!](./problems/前序/递归算法的时间与空间复杂度分析.md)
* [刷了这么多题,你了解自己代码的内存消耗么?](./problems/前序/刷了这么多题,你了解自己代码的内存消耗么?.md)
-## 社群
-
-* [准备校招的录友们,组织在这里!](https://mp.weixin.qq.com/s/5vKadlE1g2HjDpo2-y2ZFw)
-* [准备社招的录友们,组织在这里!](https://mp.weixin.qq.com/s/mbQ3s17ZJ4LXFRb-VD58Ww)
-
## 知识星球精选
* [为什么都说客户端会消失](./problems/知识星球精选/客三消.md)
@@ -488,6 +483,7 @@
## 贪心
* [649.Dota2参议院](./problems/0649.Dota2参议院.md) 有难度
+* [1221.分割平衡字符](./problems/1221.分割平衡字符串.md) 简单贪心
## 动态规划
* [5.最长回文子串](./problems/0005.最长回文子串.md) 和[647.回文子串](https://mp.weixin.qq.com/s/2WetyP6IYQ6VotegepVpEw) 差不多是一样的
diff --git a/problems/0059.螺旋矩阵II.md b/problems/0059.螺旋矩阵II.md
index 3dbc2a50..fbac50ac 100644
--- a/problems/0059.螺旋矩阵II.md
+++ b/problems/0059.螺旋矩阵II.md
@@ -11,7 +11,8 @@
## 59.螺旋矩阵II
[力扣题目链接](https://leetcode-cn.com/problems/spiral-matrix-ii/)
-给定一个正整数 n,生成一个包含 1 到 n2 所有元素,且元素按顺时针顺序螺旋排列的正方形矩阵。
+
+给定一个正整数 n,生成一个包含 1 到 n^2 所有元素,且元素按顺时针顺序螺旋排列的正方形矩阵。
示例:
diff --git a/problems/0108.将有序数组转换为二叉搜索树.md b/problems/0108.将有序数组转换为二叉搜索树.md
index 5f99f98a..f7bff27d 100644
--- a/problems/0108.将有序数组转换为二叉搜索树.md
+++ b/problems/0108.将有序数组转换为二叉搜索树.md
@@ -9,7 +9,7 @@
> 构造二叉搜索树,一不小心就平衡了
-## 108.将有序数组转换为二叉搜索树
+# 108.将有序数组转换为二叉搜索树
[力扣题目链接](https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/)
@@ -21,7 +21,7 @@

-## 思路
+# 思路
做这道题目之前大家可以了解一下这几道:
@@ -192,7 +192,7 @@ public:
};
```
-## 总结
+# 总结
**在[二叉树:构造二叉树登场!](https://programmercarl.com/0106.从中序与后序遍历序列构造二叉树.html) 和 [二叉树:构造一棵最大的二叉树](https://programmercarl.com/0654.最大二叉树.html)之后,我们顺理成章的应该构造一下二叉搜索树了,一不小心还是一棵平衡二叉搜索树**。
@@ -205,10 +205,10 @@ public:
最后依然给出迭代的方法,其实就是模拟取中间元素,然后不断分割去构造二叉树的过程。
-## 其他语言版本
+# 其他语言版本
-Java:
+## Java
递归: 左闭右开 [left,right)
```Java
@@ -253,7 +253,8 @@ class Solution {
return root;
}
}
-```
+```
+
迭代: 左闭右闭 [left,right]
```java
class Solution {
@@ -303,15 +304,10 @@ class Solution {
}
```
-Python:
+## Python
+
+递归法:
```python3
-# Definition for a binary tree node.
-# class TreeNode:
-# def __init__(self, val=0, left=None, right=None):
-# self.val = val
-# self.left = left
-# self.right = right
-#递归法
class Solution:
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
def buildaTree(left,right):
@@ -326,21 +322,11 @@ class Solution:
return root
```
-Go:
+## Go
-
-> 递归(隐含回溯)
+递归(隐含回溯)
```go
-/**
- * Definition for a binary tree node.
- * type TreeNode struct {
- * Val int
- * Left *TreeNode
- * Right *TreeNode
- * }
- */
- //递归(隐含回溯)
func sortedArrayToBST(nums []int) *TreeNode {
if len(nums)==0{return nil}//终止条件,最后数组为空则可以返回
root:=&TreeNode{nums[len(nums)/2],nil,nil}//按照BSL的特点,从中间构造节点
@@ -350,21 +336,9 @@ func sortedArrayToBST(nums []int) *TreeNode {
}
```
-JavaScript版本
+## JavaScript
```javascript
-/**
- * Definition for a binary tree node.
- * function TreeNode(val, left, right) {
- * this.val = (val===undefined ? 0 : val)
- * this.left = (left===undefined ? null : left)
- * this.right = (right===undefined ? null : right)
- * }
- */
-/**
- * @param {number[]} nums
- * @return {TreeNode}
- */
var sortedArrayToBST = function (nums) {
const buildTree = (Arr, left, right) => {
if (left > right)
diff --git a/problems/0377.组合总和Ⅳ.md b/problems/0377.组合总和Ⅳ.md
index 47e81af6..01f48d45 100644
--- a/problems/0377.组合总和Ⅳ.md
+++ b/problems/0377.组合总和Ⅳ.md
@@ -5,6 +5,7 @@
欢迎大家参与本项目,贡献其他语言版本的代码,拥抱开源,让更多学习算法的小伙伴们收益!
+ # 动态规划:Carl称它为排列总和! ## 377. 组合总和 Ⅳ diff --git a/problems/0538.把二叉搜索树转换为累加树.md b/problems/0538.把二叉搜索树转换为累加树.md index df22511d..24fc7211 100644 --- a/problems/0538.把二叉搜索树转换为累加树.md +++ b/problems/0538.把二叉搜索树转换为累加树.md @@ -7,7 +7,7 @@欢迎大家参与本项目,贡献其他语言版本的代码,拥抱开源,让更多学习算法的小伙伴们收益!
-## 538.把二叉搜索树转换为累加树 +# 538.把二叉搜索树转换为累加树 [力扣题目链接](https://leetcode-cn.com/problems/convert-bst-to-greater-tree/) @@ -23,20 +23,20 @@  -输入:[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8] -输出:[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8] +* 输入:[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8] +* 输出:[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8] 示例 2: -输入:root = [0,null,1] -输出:[1,null,1] +* 输入:root = [0,null,1] +* 输出:[1,null,1] 示例 3: -输入:root = [1,0,2] -输出:[3,3,2] +* 输入:root = [1,0,2] +* 输出:[3,3,2] 示例 4: -输入:root = [3,2,4,1] -输出:[7,9,4,10] +* 输入:root = [3,2,4,1] +* 输出:[7,9,4,10] 提示: @@ -45,7 +45,7 @@ * 树中的所有值 互不相同 。 * 给定的树为二叉搜索树。 -## 思路 +# 思路 一看到累加树,相信很多小伙伴都会疑惑:如何累加?遇到一个节点,然后在遍历其他节点累加?怎么一想这么麻烦呢。 @@ -162,17 +162,17 @@ public: }; ``` -## 总结 +# 总结 经历了前面各种二叉树增删改查的洗礼之后,这道题目应该比较简单了。 **好了,二叉树已经接近尾声了,接下来就是要对二叉树来一个大总结了**。 -## 其他语言版本 +# 其他语言版本 -Java: +## Java ```Java class Solution { int sum; @@ -195,15 +195,10 @@ class Solution { } ``` -Python: -```python3 -# Definition for a binary tree node. -# class TreeNode: -# def __init__(self, val=0, left=None, right=None): -# self.val = val -# self.left = left -# self.right = right -#递归法 +## Python + +递归法 +```python class Solution: def convertBST(self, root: TreeNode) -> TreeNode: def buildalist(root): @@ -216,10 +211,10 @@ class Solution: buildalist(root) return root ``` -Go: +## Go -> 弄一个sum暂存其和值 +弄一个sum暂存其和值 ```go //右中左 @@ -239,23 +234,10 @@ func RightMLeft(root *TreeNode,sum *int) *TreeNode { } ``` -JavaScript版本 - -> 递归 +## JavaScript +递归 ```javascript -/** - * Definition for a binary tree node. - * function TreeNode(val, left, right) { - * this.val = (val===undefined ? 0 : val) - * this.left = (left===undefined ? null : left) - * this.right = (right===undefined ? null : right) - * } - */ -/** - * @param {TreeNode} root - * @return {TreeNode} - */ var convertBST = function(root) { let pre = 0; const ReverseInOrder = (cur) => { @@ -271,21 +253,8 @@ var convertBST = function(root) { }; ``` -> 迭代 - +迭代 ```javascript -/** - * Definition for a binary tree node. - * function TreeNode(val, left, right) { - * this.val = (val===undefined ? 0 : val) - * this.left = (left===undefined ? null : left) - * this.right = (right===undefined ? null : right) - * } - */ -/** - * @param {TreeNode} root - * @return {TreeNode} - */ var convertBST = function (root) { let pre = 0; let cur = root; diff --git a/problems/1221.分割平衡字符串.md b/problems/1221.分割平衡字符串.md new file mode 100644 index 00000000..c764e3ff --- /dev/null +++ b/problems/1221.分割平衡字符串.md @@ -0,0 +1,118 @@ + +欢迎大家参与本项目,贡献其他语言版本的代码,拥抱开源,让更多学习算法的小伙伴们收益!
+ +# 1221. 分割平衡字符串 + +[力扣题目链接](https://leetcode-cn.com/problems/split-a-string-in-balanced-strings/) + +在一个 平衡字符串 中,'L' 和 'R' 字符的数量是相同的。 + +给你一个平衡字符串 s,请你将它分割成尽可能多的平衡字符串。 + +注意:分割得到的每个字符串都必须是平衡字符串。 + +返回可以通过分割得到的平衡字符串的 最大数量 。 + + +示例 1: + +* 输入:s = "RLRRLLRLRL" +* 输出:4 +* 解释:s 可以分割为 "RL"、"RRLL"、"RL"、"RL" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。 + +示例 2: +* 输入:s = "RLLLLRRRLR" +* 输出:3 +* 解释:s 可以分割为 "RL"、"LLLRRR"、"LR" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。 + +示例 3: +* 输入:s = "LLLLRRRR" +* 输出:1 +* 解释:s 只能保持原样 "LLLLRRRR". + +示例 4: +* 输入:s = "RLRRRLLRLL" +* 输出:2 +* 解释:s 可以分割为 "RL"、"RRRLLRLL" ,每个子字符串中都包含相同数量的 'L' 和 'R' 。 + +# 思路 + +这道题目看起来好像很复杂,其实是非常简单的贪心,关于贪心,我在这里[关于贪心算法,你该了解这些!](https://programmercarl.com/贪心算法理论基础.html)有详细的讲解。 + +从前向后遍历,只要遇到平衡子串,计数就+1,遍历一遍即可。 + +局部最优:从前向后遍历,只要遇到平衡子串 就统计 + +全局最优:统计了最多的平衡子串。 + +局部最优可以推出全局最优,举不出反例,那么就试试贪心。 + + +例如,LRLR 这本身就是平衡子串 , 但要遇到LR就可以分割。 + +C++代码如下: + +```CPP +class Solution { +public: + int balancedStringSplit(string s) { + int result = 0; + int count = 0; + for (int i = 0; i < s.size(); i++) { + if (s[i] == 'R') count++; + else count--; + if (count == 0) result++; + } + return result; + } +}; +``` + +# 拓展 + +一些同学可能想,你这个推理不靠谱,都没有数学证明。怎么就能说是合理的呢,怎么就能说明 局部最优可以推出全局最优呢? + +一般数学证明有如下两种方法: + +* 数学归纳法 +* 反证法 + +如果真的去严格数学证明其实不是在我们刷题或者 面试的考察范围内了。 + +所以贪心题目的思考过程是: 如果发现局部最优好像可以推出全局最优,那么就 尝试一下举反例,如果举不出反例,那么就试试贪心。 + + + +# 其他语言版本 + +## Java + +```java +``` + +## Python + +```python +``` + +## Go + +```go +``` + +## JavaScript + +```js +``` + +----------------------- +* 作者微信:[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw) +* B站视频:[代码随想录](https://space.bilibili.com/525438321) +* 知识星球:[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ) + +欢迎大家参与本项目,贡献其他语言版本的代码,拥抱开源,让更多学习算法的小伙伴们收益!
+ + # 动态规划:关于多重背包,你该了解这些! 之前我们已经体统的讲解了01背包和完全背包,如果没有看过的录友,建议先把如下三篇文章仔细阅读一波。