From 3f7beb8c8f3d9e06f9932a157ffce92dd7d2aade Mon Sep 17 00:00:00 2001 From: fw_qaq <82551626+Jack-Zhang-1314@users.noreply.github.com> Date: Sun, 4 Dec 2022 17:59:09 +0800 Subject: [PATCH 01/44] =?UTF-8?q?Update=200235.=E4=BA=8C=E5=8F=89=E6=90=9C?= =?UTF-8?q?=E7=B4=A2=E6=A0=91=E7=9A=84=E6=9C=80=E8=BF=91=E5=85=AC=E5=85=B1?= =?UTF-8?q?=E7=A5=96=E5=85=88.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...35.二叉搜索树的最近公共祖先.md | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/problems/0235.二叉搜索树的最近公共祖先.md b/problems/0235.二叉搜索树的最近公共祖先.md index c90b3d8c..97f85437 100644 --- a/problems/0235.二叉搜索树的最近公共祖先.md +++ b/problems/0235.二叉搜索树的最近公共祖先.md @@ -418,6 +418,39 @@ object Solution { } ``` +## rust + +```rust +impl Solution { + pub fn lowest_common_ancestor( + root: Option>>, + p: Option>>, + q: Option>>, + ) -> Option>> { + let q_val = q.as_ref().unwrap().borrow().val; + let p_val = p.as_ref().unwrap().borrow().val; + let root_val = root.as_ref().unwrap().borrow().val; + + if root_val > q_val && root_val > p_val { + return Self::lowest_common_ancestor( + root.as_ref().unwrap().borrow().left.clone(), + p, + q, + ); + }; + + if root_val < q_val && root_val < p_val { + return Self::lowest_common_ancestor( + root.as_ref().unwrap().borrow().right.clone(), + p, + q, + ); + } + root + } +} +``` +

From 6866f2b9ace6a92d38d9b28f3e91365a38878c35 Mon Sep 17 00:00:00 2001 From: fw_qaq <82551626+Jack-Zhang-1314@users.noreply.github.com> Date: Sun, 4 Dec 2022 19:35:20 +0800 Subject: [PATCH 02/44] =?UTF-8?q?Update=200235.=E4=BA=8C=E5=8F=89=E6=90=9C?= =?UTF-8?q?=E7=B4=A2=E6=A0=91=E7=9A=84=E6=9C=80=E8=BF=91=E5=85=AC=E5=85=B1?= =?UTF-8?q?=E7=A5=96=E5=85=88.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...35.二叉搜索树的最近公共祖先.md | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/problems/0235.二叉搜索树的最近公共祖先.md b/problems/0235.二叉搜索树的最近公共祖先.md index 97f85437..aa06e86c 100644 --- a/problems/0235.二叉搜索树的最近公共祖先.md +++ b/problems/0235.二叉搜索树的最近公共祖先.md @@ -420,6 +420,8 @@ object Solution { ## rust +递归： + ```rust impl Solution { pub fn lowest_common_ancestor( @@ -451,6 +453,32 @@ impl Solution { } ``` +迭代： + +```rust +impl Solution { + pub fn lowest_common_ancestor( + mut root: Option>>, + p: Option>>, + q: Option>>, + ) -> Option>> { + let p_val = p.unwrap().borrow().val; + let q_val = q.unwrap().borrow().val; + while let Some(node) = root.clone() { + let root_val = node.borrow().val; + if root_val > q_val && root_val > p_val { + root = node.borrow().left.clone(); + } else if root_val < q_val && root_val < p_val { + root = node.borrow().right.clone(); + } else { + return root; + } + } + None + } +} +``` +

From 880c36c76a5f6f3adc973063cd10120ce0e0c857 Mon Sep 17 00:00:00 2001 From: Xi Wen <16098574d@connect.polyu.hk> Date: Sun, 4 Dec 2022 17:06:13 -0800 Subject: [PATCH 03/44] =?UTF-8?q?Update=200102.=E4=BA=8C=E5=8F=89=E6=A0=91?= =?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit typo --- problems/0102.二叉树的层序遍历.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md index 9985971f..29203a0e 100644 --- a/problems/0102.二叉树的层序遍历.md +++ b/problems/0102.二叉树的层序遍历.md @@ -2955,7 +2955,7 @@ impl Solution { * 107.二叉树的层次遍历II * 199.二叉树的右视图 * 637.二叉树的层平均值 -* 429.N叉树的前序遍历 +* 429.N叉树的层序遍历 * 515.在每个树行中找最大值 * 116.填充每个节点的下一个右侧节点指针 * 117.填充每个节点的下一个右侧节点指针II From 40db2893574c453acfeba8399410667be68cc1bb Mon Sep 17 00:00:00 2001 From: fw_qaq <82551626+fwqaaq@users.noreply.github.com> Date: Mon, 5 Dec 2022 22:26:55 +0800 Subject: [PATCH 04/44] =?UTF-8?q?Update=200701.=E4=BA=8C=E5=8F=89=E6=90=9C?= =?UTF-8?q?=E7=B4=A2=E6=A0=91=E4=B8=AD=E7=9A=84=E6=8F=92=E5=85=A5=E6=93=8D?= =?UTF-8?q?=E4=BD=9C.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../0701.二叉搜索树中的插入操作.md | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/problems/0701.二叉搜索树中的插入操作.md b/problems/0701.二叉搜索树中的插入操作.md index 2e899e22..b8d53b04 100644 --- a/problems/0701.二叉搜索树中的插入操作.md +++ b/problems/0701.二叉搜索树中的插入操作.md @@ -641,6 +641,42 @@ object Solution { } ``` +### rust + +迭代： + +```rust +impl Solution { + pub fn insert_into_bst( + root: Option>>, + val: i32, + ) -> Option>> { + if root.is_none() { + return Some(Rc::new(RefCell::new(TreeNode::new(val)))); + } + let mut cur = root.clone(); + let mut pre = None; + while let Some(node) = cur.clone() { + pre = cur; + if node.borrow().val > val { + cur = node.borrow().left.clone(); + } else { + cur = node.borrow().right.clone(); + }; + } + let r = Some(Rc::new(RefCell::new(TreeNode::new(val)))); + let mut p = pre.as_ref().unwrap().borrow_mut(); + if val < p.val { + p.left = r; + } else { + p.right = r; + } + + root + } +} +``` +

From eb76f57a19e813e77490931d97787a4d8b4a0552 Mon Sep 17 00:00:00 2001 From: fw_qaq <82551626+fwqaaq@users.noreply.github.com> Date: Mon, 5 Dec 2022 22:55:08 +0800 Subject: [PATCH 05/44] =?UTF-8?q?Update=200701.=E4=BA=8C=E5=8F=89=E6=90=9C?= =?UTF-8?q?=E7=B4=A2=E6=A0=91=E4=B8=AD=E7=9A=84=E6=8F=92=E5=85=A5=E6=93=8D?= =?UTF-8?q?=E4=BD=9C.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../0701.二叉搜索树中的插入操作.md | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/problems/0701.二叉搜索树中的插入操作.md b/problems/0701.二叉搜索树中的插入操作.md index b8d53b04..559c3900 100644 --- a/problems/0701.二叉搜索树中的插入操作.md +++ b/problems/0701.二叉搜索树中的插入操作.md @@ -677,6 +677,30 @@ impl Solution { } ``` +递归： + +```rust +impl Solution { + pub fn insert_into_bst( + root: Option>>, + val: i32, + ) -> Option>> { + if let Some(node) = &root { + if node.borrow().val > val { + let left = Self::insert_into_bst(node.borrow_mut().left.take(), val); + node.borrow_mut().left = left; + } else { + let right = Self::insert_into_bst(node.borrow_mut().right.take(), val); + node.borrow_mut().right = right; + } + root + } else { + Some(Rc::new(RefCell::new(TreeNode::new(val)))) + } + } +} +``` +

From dab64d0d6a9170d22391f1960d552ab89b56d190 Mon Sep 17 00:00:00 2001 From: ZerenZhang2022 <118794589+ZerenZhang2022@users.noreply.github.com> Date: Mon, 5 Dec 2022 23:03:35 -0500 Subject: [PATCH 06/44] =?UTF-8?q?Update=200102.=E4=BA=8C=E5=8F=89=E6=A0=91?= =?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # LeetCode 429. N-ary Tree Level Order Traversal python, 递归法 --- problems/0102.二叉树的层序遍历.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md index 9985971f..cb5ba6bf 100644 --- a/problems/0102.二叉树的层序遍历.md +++ b/problems/0102.二叉树的层序遍历.md @@ -1346,6 +1346,22 @@ class Solution: return results ``` +```python +# LeetCode 429. N-ary Tree Level Order Traversal +# 递归法 +class Solution: + def levelOrder(self, root: 'Node') -> List[List[int]]: + if not root: return [] + result=[] + def traversal(root,depth): + if len(result)==depth:result.append([]) + result[depth].append(root.val) + if root.children: + for i in range(len(root.children)):traversal(root.children[i],depth+1) + + traversal(root,0) + return result +``` java: ```java From 0131465339d570fb8c47ddea3eb8f9a7d6cbf577 Mon Sep 17 00:00:00 2001 From: 5Reason Date: Tue, 6 Dec 2022 12:03:55 +0800 Subject: [PATCH 07/44] =?UTF-8?q?=E6=9B=B4=E6=96=B0=20131.=E5=88=86?= =?UTF-8?q?=E5=89=B2=E5=9B=9E=E6=96=87=20=E4=B8=B2=20js=E4=BB=A3=E7=A0=81?= =?UTF-8?q?=E7=9A=84=E5=8F=98=E9=87=8F=E5=90=8D,=E5=92=8C=E6=95=99?= =?UTF-8?q?=E7=A8=8B=E4=BF=9D=E6=8C=81=E4=B8=80=E8=87=B4=E9=81=BF=E5=85=8D?= =?UTF-8?q?=E6=B7=B7=E6=B7=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0131.分割回文串.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/problems/0131.分割回文串.md b/problems/0131.分割回文串.md index 3a3c2d73..8e180ec8 100644 --- a/problems/0131.分割回文串.md +++ b/problems/0131.分割回文串.md @@ -494,15 +494,15 @@ var partition = function(s) { const res = [], path = [], len = s.length; backtracking(0); return res; - function backtracking(i) { - if(i >= len) { + function backtracking(startIndex) { + if(startIndex >= len) { res.push(Array.from(path)); return; } - for(let j = i; j < len; j++) { - if(!isPalindrome(s, i, j)) continue; - path.push(s.slice(i, j + 1)); - backtracking(j + 1); + for(let i = startIndex; i < len; i++) { + if(!isPalindrome(s, startIndex, i)) continue; + path.push(s.slice(startIndex, i + 1)); + backtracking(i + 1); path.pop(); } } From 8364dcd0f181e6152f00b6f6bf415f296b451e0b Mon Sep 17 00:00:00 2001 From: jwcen Date: Wed, 7 Dec 2022 19:43:34 +0800 Subject: [PATCH 08/44] =?UTF-8?q?=E4=BA=8C=E5=8F=89=E6=A0=91=E7=9A=84?= =?UTF-8?q?=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86=EF=BC=9A=E4=BD=BF=E7=94=A8?= =?UTF-8?q?=E5=88=87=E7=89=87=E6=A8=A1=E6=8B=9F=E9=98=9F=E5=88=97=EF=BC=8C?= =?UTF-8?q?=E6=98=93=E7=90=86=E8=A7=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0102.二叉树的层序遍历.md | 30 +++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md index 9985971f..bc78cb36 100644 --- a/problems/0102.二叉树的层序遍历.md +++ b/problems/0102.二叉树的层序遍历.md @@ -271,6 +271,36 @@ func levelOrder(root *TreeNode) [][]int { return res } + +/** +102. 二叉树的层序遍历：使用切片模拟队列，易理解 + */ +func levelOrder(root *TreeNode) (res [][]int) { + if root == nil { + return + } + + curLevel := []*TreeNode{root} // 存放当前层节点 + for len(curLevel) > 0 { + nextLevel := []*TreeNode{} // 准备通过当前层生成下一层 + vals := []int{} + + for _, node := range curLevel { + vals = append(vals, node.Val) // 收集当前层的值 + // 收集下一层的节点 + if node.Left != nil { + nextLevel = append(nextLevel, node.Left) + } + if node.Right != nil { + nextLevel = append(nextLevel, node.Right) + } + } + res = append(res, vals) + curLevel = nextLevel // 将下一层变成当前层 + } + + return +} ``` javascript代码： From 50632bc383163e690ee274867481b64070e7ca51 Mon Sep 17 00:00:00 2001 From: huhaonan <812559558@qq.com> Date: Thu, 8 Dec 2022 09:58:53 +0800 Subject: [PATCH 09/44] =?UTF-8?q?Java=E7=89=88=E6=9C=AC=E6=8C=89=E7=85=A7?= =?UTF-8?q?=E8=A7=86=E9=A2=91=E7=9A=84=E6=80=9D=E8=B7=AF=E5=AE=9E=E7=8E=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../0024.两两交换链表中的节点.md | 34 +++++++++---------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/problems/0024.两两交换链表中的节点.md b/problems/0024.两两交换链表中的节点.md index 50775cdd..de389448 100644 --- a/problems/0024.两两交换链表中的节点.md +++ b/problems/0024.两两交换链表中的节点.md @@ -154,24 +154,23 @@ class Solution { ``` ```java -// 虚拟头结点 class Solution { - public ListNode swapPairs(ListNode head) { - - ListNode dummyNode = new ListNode(0); - dummyNode.next = head; - ListNode prev = dummyNode; - - while (prev.next != null && prev.next.next != null) { - ListNode temp = head.next.next; // 缓存 next - prev.next = head.next; // 将 prev 的 next 改为 head 的 next - head.next.next = head; // 将 head.next(prev.next) 的next，指向 head - head.next = temp; // 将head 的 next 接上缓存的temp - prev = head; // 步进1位 - head = head.next; // 步进1位 - } - return dummyNode.next; - } + ListNode dumyhead = new ListNode(-1); + dumyhead.next = head; // 设置一个虚拟头结点 + ListNode cur1 = dumyhead; // 将虚拟头结点指向head，这样方面后面做删除操作 + ListNode temp; // 临时节点，保存两个节点后面的节点 + ListNode firstnode; // 临时节点，保存两个节点之中的第一个节点 + ListNode secondnode; // 临时节点，保存两个节点之中的第二个节点 + while (cur1.next != null && cur1.next.next != null) { + temp = cur1.next.next.next; + firstnode = cur1.next; + secondnode = cur1.next.next; + cur1.next = secondnode; // 步骤一 + secondnode.next = firstnode; // 步骤二 + firstnode.next = temp; // 步骤三 + cur1 = firstnode; // cur移动，准备下一轮交换 + } + return dumyhead.next; } ``` @@ -430,3 +429,4 @@ impl Solution { + From 10cccc211edf7c96bb7d5c0fe580b0469ff8ed55 Mon Sep 17 00:00:00 2001 From: huhaonan <812559558@qq.com> Date: Thu, 8 Dec 2022 10:16:04 +0800 Subject: [PATCH 10/44] =?UTF-8?q?0024Java=E7=89=88=E6=8C=89=E8=A7=86?= =?UTF-8?q?=E9=A2=91=E6=80=9D=E8=B7=AF=E5=AE=9E=E7=8E=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../0024.两两交换链表中的节点.md | 23 ++++++++++--------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/problems/0024.两两交换链表中的节点.md b/problems/0024.两两交换链表中的节点.md index de389448..4dc051aa 100644 --- a/problems/0024.两两交换链表中的节点.md +++ b/problems/0024.两两交换链表中的节点.md @@ -155,22 +155,24 @@ class Solution { ```java class Solution { - ListNode dumyhead = new ListNode(-1); - dumyhead.next = head; // 设置一个虚拟头结点 - ListNode cur1 = dumyhead; // 将虚拟头结点指向head，这样方面后面做删除操作 + public ListNode swapPairs(ListNode head) { + ListNode dumyhead = new ListNode(-1); // 设置一个虚拟头结点 + dumyhead.next = head; // 将虚拟头结点指向head，这样方面后面做删除操作 + ListNode cur = dumyhead; ListNode temp; // 临时节点，保存两个节点后面的节点 ListNode firstnode; // 临时节点，保存两个节点之中的第一个节点 ListNode secondnode; // 临时节点，保存两个节点之中的第二个节点 - while (cur1.next != null && cur1.next.next != null) { - temp = cur1.next.next.next; - firstnode = cur1.next; - secondnode = cur1.next.next; - cur1.next = secondnode; // 步骤一 + while (cur.next != null && cur.next.next != null) { + temp = cur.next.next.next; + firstnode = cur.next; + secondnode = cur.next.next; + cur.next = secondnode; // 步骤一 secondnode.next = firstnode; // 步骤二 firstnode.next = temp; // 步骤三 - cur1 = firstnode; // cur移动，准备下一轮交换 + cur = firstnode; // cur移动，准备下一轮交换 } - return dumyhead.next; + return dumyhead.next; + } } ``` @@ -429,4 +431,3 @@ impl Solution { - From f01233e23ba0c296e8df959dc5a6b8f23ec2727d Mon Sep 17 00:00:00 2001 From: wang2jun <91008685+wang2jun@users.noreply.github.com> Date: Thu, 8 Dec 2022 13:52:50 +0800 Subject: [PATCH 11/44] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20127=E5=8D=95?= =?UTF-8?q?=E8=AF=8D=E6=8E=A5=E9=BE=99=20TypeScript=20=E7=89=88=E6=9C=AC?= =?UTF-8?q?=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 添加 127单词接龙 TypeScript 版本代码 --- problems/0127.单词接龙.md | 49 +++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/problems/0127.单词接龙.md b/problems/0127.单词接龙.md index 2e30123d..bc21d0ad 100644 --- a/problems/0127.单词接龙.md +++ b/problems/0127.单词接龙.md @@ -247,6 +247,55 @@ var ladderLength = function(beginWord, endWord, wordList) { }; ``` +## TypeScript +```typescript +function ladderLength( + beginWord: string, + endWord: string, + wordList: string[] +): number { + const words = new Set(wordList); + if (!words.has(endWord)) return 0; + if (beginWord.length === 1) return 2; + let current = new Set([beginWord]); + let rightcurrent = new Set([endWord]); + words.delete(endWord); + let step = 1; + while (current.size) { + if (current.size > rightcurrent.size) { + [current, rightcurrent] = [rightcurrent, current]; + } + const temp: Set = new Set(); + for (const word of current) { + for (const right of rightcurrent) { + if (diffonechar(word, right)) { + return step + 1; + } + } + for (const other of words) { + if (diffonechar(other, word)) { + temp.add(other); + + words.delete(other); + } + } + } + if (temp.size === 0) return 0; + current = temp; + step = step + 1; + } + return 0; +} + +function diffonechar(word1: string, word2: string): boolean { + let changes = 0; + for (let i = 0; i < word1.length; i++) { + if (word1[i] != word2[i]) changes += 1; + } + return changes === 1; +} +``` +

From 97367686282a330d87790a72c8d04e57c0354a38 Mon Sep 17 00:00:00 2001 From: fw_qaq <82551626+fwqaaq@users.noreply.github.com> Date: Fri, 9 Dec 2022 00:20:13 +0800 Subject: [PATCH 12/44] =?UTF-8?q?Update=200669.=E4=BF=AE=E5=89=AA=E4=BA=8C?= =?UTF-8?q?=E5=8F=89=E6=90=9C=E7=B4=A2=E6=A0=91.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0669.修剪二叉搜索树.md | 27 ++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/problems/0669.修剪二叉搜索树.md b/problems/0669.修剪二叉搜索树.md index c2d7b79b..1cc958c8 100644 --- a/problems/0669.修剪二叉搜索树.md +++ b/problems/0669.修剪二叉搜索树.md @@ -469,6 +469,33 @@ object Solution { } ``` +## rust + +// 递归 +```rust +impl Solution { + pub fn trim_bst( + root: Option>>, + low: i32, + high: i32, + ) -> Option>> { + root.as_ref()?; + let mut node = root.as_ref().unwrap().borrow_mut(); + if node.val < low { + return Self::trim_bst(node.right.clone(), low, high); + } + if node.val > high { + return Self::trim_bst(node.left.clone(), low, high); + } + + node.left = Self::trim_bst(node.left.clone(), low, high); + node.right = Self::trim_bst(node.right.clone(), low, high); + drop(node); + root + } +} +``` +

From 50aba633cc9be0b85a5786142020875a77cc4bbe Mon Sep 17 00:00:00 2001 From: 5Reason Date: Fri, 9 Dec 2022 14:54:53 +0800 Subject: [PATCH 13/44] =?UTF-8?q?=E6=9B=B4=E6=96=B0=20491.=E9=80=92?= =?UTF-8?q?=E5=A2=9E=E5=AD=90=E5=BA=8F=E5=88=97=20=E4=BF=AE=E6=AD=A3?= =?UTF-8?q?=E5=AD=90=E6=A0=87=E9=A2=98md=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0491.递增子序列.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/problems/0491.递增子序列.md b/problems/0491.递增子序列.md index e33a049d..c30d23f7 100644 --- a/problems/0491.递增子序列.md +++ b/problems/0491.递增子序列.md @@ -396,7 +396,7 @@ var findSubsequences = function(nums) { ``` -## TypeScript +### TypeScript ```typescript function findSubsequences(nums: number[]): number[][] { @@ -542,7 +542,7 @@ int** findSubsequences(int* nums, int numsSize, int* returnSize, int** returnCol } ``` -## Swift +### Swift ```swift func findSubsequences(_ nums: [Int]) -> [[Int]] { @@ -573,7 +573,7 @@ func findSubsequences(_ nums: [Int]) -> [[Int]] { ``` -## Scala +### Scala ```scala object Solution { From 334c9a8b0097bce9eeb7dfe5797ea1e89f60cb52 Mon Sep 17 00:00:00 2001 From: fw_qaq <82551626+fwqaaq@users.noreply.github.com> Date: Fri, 9 Dec 2022 19:29:56 +0800 Subject: [PATCH 14/44] =?UTF-8?q?Update=200108.=E5=B0=86=E6=9C=89=E5=BA=8F?= =?UTF-8?q?=E6=95=B0=E7=BB=84=E8=BD=AC=E6=8D=A2=E4=B8=BA=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=90=9C=E7=B4=A2=E6=A0=91.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...将有序数组转换为二叉搜索树.md | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/problems/0108.将有序数组转换为二叉搜索树.md b/problems/0108.将有序数组转换为二叉搜索树.md index ffb60b38..0a053df5 100644 --- a/problems/0108.将有序数组转换为二叉搜索树.md +++ b/problems/0108.将有序数组转换为二叉搜索树.md @@ -482,6 +482,26 @@ object Solution { } ``` +## rust + +递归： + +```rust +impl Solution { + pub fn sorted_array_to_bst(nums: Vec) -> Option>> { + if nums.is_empty() { + return None; + } + let index = nums.len() / 2; + let mut root = TreeNode::new(nums[index]); + + root.left = Self::sorted_array_to_bst(nums[..index].to_vec()); + root.right = Self::sorted_array_to_bst(nums[index + 1..].to_vec()); + Some(Rc::new(RefCell::new(root))) + } +} +``` +

From 4341179d9381c7d1a927ba17bcb2c7dce2371af5 Mon Sep 17 00:00:00 2001 From: fw_qaq <82551626+fwqaaq@users.noreply.github.com> Date: Fri, 9 Dec 2022 20:02:58 +0800 Subject: [PATCH 15/44] =?UTF-8?q?Update=200538.=E6=8A=8A=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=90=9C=E7=B4=A2=E6=A0=91=E8=BD=AC=E6=8D=A2=E4=B8=BA=E7=B4=AF?= =?UTF-8?q?=E5=8A=A0=E6=A0=91.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...38.把二叉搜索树转换为累加树.md | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/problems/0538.把二叉搜索树转换为累加树.md b/problems/0538.把二叉搜索树转换为累加树.md index 9940e604..36dbfa70 100644 --- a/problems/0538.把二叉搜索树转换为累加树.md +++ b/problems/0538.把二叉搜索树转换为累加树.md @@ -371,6 +371,31 @@ object Solution { } ``` +## rust + +递归： + +```rust +impl Solution { + pub fn convert_bst(root: Option>>) -> Option>> { + let mut pre = 0; + Self::traversal(&root, &mut pre); + root + } + + pub fn traversal(cur: &Option>>, pre: &mut i32) { + if cur.is_none() { + return; + } + let mut node = cur.as_ref().unwrap().borrow_mut(); + Self::traversal(&node.right, pre); + *pre += node.val; + node.val = *pre; + Self::traversal(&node.left, pre); + } +} +``` +

From 26f01c3ef9db64c890ae077c16a50544b990701f Mon Sep 17 00:00:00 2001 From: fw_qaq <82551626+fwqaaq@users.noreply.github.com> Date: Fri, 9 Dec 2022 20:15:28 +0800 Subject: [PATCH 16/44] =?UTF-8?q?Update=200538.=E6=8A=8A=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=90=9C=E7=B4=A2=E6=A0=91=E8=BD=AC=E6=8D=A2=E4=B8=BA=E7=B4=AF?= =?UTF-8?q?=E5=8A=A0=E6=A0=91.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...38.把二叉搜索树转换为累加树.md | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/problems/0538.把二叉搜索树转换为累加树.md b/problems/0538.把二叉搜索树转换为累加树.md index 36dbfa70..2f759d39 100644 --- a/problems/0538.把二叉搜索树转换为累加树.md +++ b/problems/0538.把二叉搜索树转换为累加树.md @@ -396,6 +396,30 @@ impl Solution { } ``` +迭代： + +```rust +impl Solution { + pub fn convert_bst(root: Option>>) -> Option>> { + let mut cur = root.clone(); + let mut stack = vec![]; + let mut pre = 0; + while !stack.is_empty() || cur.is_some() { + while let Some(node) = cur { + cur = node.borrow().right.clone(); + stack.push(node); + } + if let Some(node) = stack.pop() { + pre += node.borrow().val; + node.borrow_mut().val = pre; + cur = node.borrow().left.clone(); + } + } + root + } +} +``` +

From 83d2865c21cc2ed84364c4c6a531fd7fb728832d Mon Sep 17 00:00:00 2001 From: hbingzhi Date: Fri, 16 Dec 2022 15:45:25 +0800 Subject: [PATCH 17/44] =?UTF-8?q?=E5=88=A0=E9=99=A4=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=A0=91=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86637Java=E8=A7=A3?= =?UTF-8?q?=E6=B3=95=E4=B8=AD=E6=B2=A1=E6=9C=89=E5=BF=85=E8=A6=81=E7=9A=84?= =?UTF-8?q?=E8=AF=AD=E5=8F=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0102.二叉树的层序遍历.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md index 9985971f..8de91e40 100644 --- a/problems/0102.二叉树的层序遍历.md +++ b/problems/0102.二叉树的层序遍历.md @@ -1072,7 +1072,6 @@ public class N0637 { que.offerLast(root); while (!que.isEmpty()) { - TreeNode peek = que.peekFirst(); int levelSize = que.size(); double levelSum = 0.0; @@ -2970,3 +2969,4 @@ impl Solution { + From 2c72abc02b9a44b9adc790dd038b085fddca001c Mon Sep 17 00:00:00 2001 From: MIracleyin Date: Fri, 16 Dec 2022 16:16:10 +0800 Subject: [PATCH 18/44] rust 968 min camera cover --- problems/0968.监控二叉树.md | 49 ++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/problems/0968.监控二叉树.md b/problems/0968.监控二叉树.md index e4a0512a..4a8f9868 100644 --- a/problems/0968.监控二叉树.md +++ b/problems/0968.监控二叉树.md @@ -579,6 +579,55 @@ object Solution { } ``` +```Rust +/// 版本一 +impl Solution { + pub fn min_camera_cover(root: Option>>) -> i32 { + let mut res = 0; + if Self::traversal(&root, &mut res) == 0 { + res += 1; + } + res + } + + pub fn traversal(cur: &Option>>, ans: &mut i32) -> i32 { + // 0 未覆盖 1 节点已设置摄像头 2 节点已覆盖 + if let Some(node) = cur { + let node = node.borrow(); + + let left = Self::traversal(&node.left, ans); + let right = Self::traversal(&node.right, ans); + + // 左右节点都被覆盖 + if left == 2 && right == 2 { + return 0; // 无覆盖 + } + + // left == 0 right == 0 左右无覆盖 + // left == 0 right == 1 左节点无覆盖 右节点有摄像头 + // left == 1 right == 0 左节点有摄像头 左节点无覆盖 + // left == 0 right == 2 左节点无覆盖 右节点有覆盖 + // left == 2 right == 0 左节点有覆盖 右节点无覆盖 + if left == 0 || right == 0 { + *ans += 1; + return 1; + } + + // left == 1 right == 1 左节点有摄像头 右节点有摄像头 + // left == 1 right == 2 左节点有摄像头 右节点覆盖 + // left == 2 right == 1 左节点覆盖 右节点有摄像头 + if left == 1 || right == 1 { + return 2; // 已覆盖 + } + } else { + return 2; + } + -1 + } +} + +``` +

From dca56f0953dde88762cc707d83f7e65ae81f2cee Mon Sep 17 00:00:00 2001 From: MIracleyin Date: Fri, 16 Dec 2022 16:19:06 +0800 Subject: [PATCH 19/44] fix title rust 968 --- problems/0968.监控二叉树.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/problems/0968.监控二叉树.md b/problems/0968.监控二叉树.md index 4a8f9868..179102f5 100644 --- a/problems/0968.监控二叉树.md +++ b/problems/0968.监控二叉树.md @@ -578,7 +578,7 @@ object Solution { } } ``` - +### Rust ```Rust /// 版本一 impl Solution { From ac18aa205aaf4278a8c037a4beb67108f905371c Mon Sep 17 00:00:00 2001 From: MIracleyin Date: Fri, 16 Dec 2022 16:57:44 +0800 Subject: [PATCH 20/44] rust 968 min camera cover version 2 --- problems/0968.监控二叉树.md | 36 ++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/problems/0968.监控二叉树.md b/problems/0968.监控二叉树.md index 179102f5..d897755b 100644 --- a/problems/0968.监控二叉树.md +++ b/problems/0968.监控二叉树.md @@ -626,6 +626,42 @@ impl Solution { } } +/// 版本二 +enum NodeState { + NoCover = 0, + Camera = 1, + Covered = 2, +} + +impl Solution { + pub fn min_camera_cover(root: Option>>) -> i32 { + let mut res = 0; + let state = Self::traversal(&root, &mut res); + match state { + NodeState::NoCover => res + 1, + _ => res, + } + } + + pub fn traversal(cur: &Option>>, ans: &mut i32) -> NodeState { + if let Some(node) = cur { + let node = node.borrow(); + let left_state = Self::traversal(&node.left, ans); + let right_state = Self::traversal(&node.right, ans); + match (left_state, right_state) { + (NodeState::NoCover, _) | (_, NodeState::NoCover) => { + *ans += 1; + NodeState::Camera + } + (NodeState::Camera, _) | (_, NodeState::Camera) => NodeState::Covered, + (_, _) => NodeState::NoCover, + } + } else { + NodeState::Covered + } + } +} + ```

From e1d0a28bddf573b83f88ab65fd47cf9d912de921 Mon Sep 17 00:00:00 2001 From: fw_qaq <82551626+fwqaaq@users.noreply.github.com> Date: Sat, 17 Dec 2022 23:04:18 +0800 Subject: [PATCH 21/44] =?UTF-8?q?update=200077.=E7=BB=84=E5=90=88=E4=BC=98?= =?UTF-8?q?=E5=8C=96.md=20=E5=85=B3=E4=BA=8E=20rust=20=E7=9A=84=E4=B8=80?= =?UTF-8?q?=E4=BA=9B=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0077.组合优化.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/problems/0077.组合优化.md b/problems/0077.组合优化.md index 34318d16..066e1b33 100644 --- a/problems/0077.组合优化.md +++ b/problems/0077.组合优化.md @@ -267,22 +267,22 @@ Rust: ```Rust impl Solution { - fn backtracking(result: &mut Vec>, path: &mut Vec, n: i32, k: i32, startIndex: i32) { + fn backtracking(result: &mut Vec>, path: &mut Vec, n: i32, k: i32, start_index: i32) { let len= path.len() as i32; if len == k{ result.push(path.to_vec()); return; } // 此处剪枝 - for i in startIndex..= n - (k - len) + 1 { + for i in start_index..= n - (k - len) + 1 { path.push(i); Self::backtracking(result, path, n, k, i+1); path.pop(); } } pub fn combine(n: i32, k: i32) -> Vec> { - let mut result: Vec> = Vec::new(); - let mut path: Vec = Vec::new(); + let mut result = vec![]; + let mut path = vec![]; Self::backtracking(&mut result, &mut path, n, k, 1); result } From 9b9980020914453b19ffad8494c6ac8fb92566ca Mon Sep 17 00:00:00 2001 From: fw_qaq <82551626+fwqaaq@users.noreply.github.com> Date: Sat, 17 Dec 2022 23:55:38 +0800 Subject: [PATCH 22/44] =?UTF-8?q?Update=200216.=E7=BB=84=E5=90=88=E6=80=BB?= =?UTF-8?q?=E5=92=8CIII.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0216.组合总和III.md | 32 ++++++++++++++++++++------------ 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/problems/0216.组合总和III.md b/problems/0216.组合总和III.md index 19fe1eb9..3b396b31 100644 --- a/problems/0216.组合总和III.md +++ b/problems/0216.组合总和III.md @@ -475,28 +475,36 @@ function combinationSum3(k: number, n: number): number[][] { ```Rust impl Solution { - fn backtracking(result: &mut Vec>, path:&mut Vec, targetSum:i32, k: i32, mut sum: i32, startIndex: i32) { + pub fn combination_sum3(k: i32, n: i32) -> Vec> { + let mut result = vec![]; + let mut path = vec![]; + Self::backtrace(&mut result, &mut path, n, k, 0, 1); + result + } + pub fn backtrace( + result: &mut Vec>, + path: &mut Vec, + target_sum: i32, + k: i32, + sum: i32, + start_index: i32, + ) { + if sum > target_sum { + return; + } let len = path.len() as i32; if len == k { - if sum == targetSum { + if sum == target_sum { result.push(path.to_vec()); } return; } - for i in startIndex..=9 { - sum += i; + for i in start_index..=9 - (k - len) + 1 { path.push(i); - Self::backtracking(result, path, targetSum, k, sum, i+1); - sum -= i; + Self::backtrace(result, path, target_sum, k, sum + i, i + 1); path.pop(); } } - pub fn combination_sum3(k: i32, n: i32) -> Vec> { - let mut result: Vec> = Vec::new(); - let mut path: Vec = Vec::new(); - Self::backtracking(&mut result, &mut path, n, k, 0, 1); - result - } } ``` From 6df0981377bece752ccba09c208751cd9ad87414 Mon Sep 17 00:00:00 2001 From: fw_qaq <82551626+fwqaaq@users.noreply.github.com> Date: Sun, 18 Dec 2022 23:31:36 +0800 Subject: [PATCH 23/44] =?UTF-8?q?update=200017.=E7=94=B5=E8=AF=9D=E5=8F=B7?= =?UTF-8?q?=E7=A0=81=E7=9A=84=E5=AD=97=E6=AF=8D=E7=BB=84=E5=90=88.md=20abo?= =?UTF-8?q?ut=20rust=20=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0017.电话号码的字母组合.md | 35 +++++++------------- 1 file changed, 12 insertions(+), 23 deletions(-) diff --git a/problems/0017.电话号码的字母组合.md b/problems/0017.电话号码的字母组合.md index 12a45a61..a3ab112f 100644 --- a/problems/0017.电话号码的字母组合.md +++ b/problems/0017.电话号码的字母组合.md @@ -450,42 +450,31 @@ function letterCombinations(digits: string): string[] { ## Rust ```Rust +const map: [&str; 10] = [ + "", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz", +]; impl Solution { - fn backtracking(result: &mut Vec, s: &mut String, map: &[&str; 10], digits: &String, index: usize) { + fn back_trace(result: &mut Vec, s: &mut String, digits: &String, index: usize) { let len = digits.len(); if len == index { result.push(s.to_string()); return; } - // 在保证不会越界的情况下使用unwrap()将Some()中的值提取出来 - let digit= digits.chars().nth(index).unwrap().to_digit(10).unwrap() as usize; - let letters = map[digit]; - for i in letters.chars() { + let digit = (digits.as_bytes()[index] - b'0') as usize; + for i in map[digit].chars() { s.push(i); - Self::backtracking(result, s, &map, &digits, index+1); + Self::back_trace(result, s, digits, index + 1); s.pop(); } } pub fn letter_combinations(digits: String) -> Vec { - if digits.len() == 0 { + if digits.is_empty() { return vec![]; } - const MAP: [&str; 10] = [ - "", - "", - "abc", - "def", - "ghi", - "jkl", - "mno", - "pqrs", - "tuv", - "wxyz" - ]; - let mut result: Vec = Vec::new(); - let mut s: String = String::new(); - Self::backtracking(&mut result, &mut s, &MAP, &digits, 0); - result + let mut res = vec![]; + let mut s = String::new(); + Self::back_trace(&mut res, &mut s, &digits, 0); + res } } ``` From 83af7646e0e91bf195d22a15f453cbc37ab0bb59 Mon Sep 17 00:00:00 2001 From: ZerenZhang2022 <118794589+ZerenZhang2022@users.noreply.github.com> Date: Mon, 19 Dec 2022 15:32:28 -0500 Subject: [PATCH 24/44] =?UTF-8?q?Update=200226.=E7=BF=BB=E8=BD=AC=E4=BA=8C?= =?UTF-8?q?=E5=8F=89=E6=A0=91.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit python层序遍历方法，和之前层序遍历一节的写法一致 --- problems/0226.翻转二叉树.md | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/problems/0226.翻转二叉树.md b/problems/0226.翻转二叉树.md index ad2a7de2..e55e1240 100644 --- a/problems/0226.翻转二叉树.md +++ b/problems/0226.翻转二叉树.md @@ -359,7 +359,22 @@ class Solution: queue.append(node.right) return root ``` - +迭代法：广度优先遍历（层序遍历），和之前的层序遍历写法一致： +```python +class Solution: + def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]: + if not root: return root + from collections import deque + que=deque([root]) + while que: + size=len(que) + for i in range(size): + cur=que.popleft() + cur.left, cur.right = cur.right, cur.left + if cur.left: que.append(cur.left) + if cur.right: que.append(cur.right) + return root +``` ### Go 递归版本的前序遍历 From d178871e8329d89fc98e7661a92bf928d6ee10af Mon Sep 17 00:00:00 2001 From: Yuhao Ju Date: Fri, 23 Dec 2022 01:16:10 +0800 Subject: [PATCH 25/44] =?UTF-8?q?update=200139.=E5=8D=95=E8=AF=8D=E6=8B=86?= =?UTF-8?q?=E5=88=86=EF=BC=9A=E4=BC=98=E5=8C=96=E6=96=87=E6=9C=AC=20?= =?UTF-8?q?=E5=92=8C=20go=20=E4=BB=A3=E7=A0=81=E9=A3=8E=E6=A0=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0139.单词拆分.md | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/problems/0139.单词拆分.md b/problems/0139.单词拆分.md index f06bd40c..f76d8075 100644 --- a/problems/0139.单词拆分.md +++ b/problems/0139.单词拆分.md @@ -138,7 +138,7 @@ public: 3. dp数组如何初始化 -从递归公式中可以看出，dp[i] 的状态依靠 dp[j]是否为true，那么dp[0]就是递归的根基，dp[0]一定要为true，否则递归下去后面都都是false了。 +从递推公式中可以看出，dp[i] 的状态依靠 dp[j]是否为true，那么dp[0]就是递推的根基，dp[0]一定要为true，否则递推下去后面都都是false了。 那么dp[0]有没有意义呢？ @@ -152,13 +152,13 @@ dp[0]表示如果字符串为空的话，说明出现在字典里。 题目中说是拆分为一个或多个在字典中出现的单词，所以这是完全背包。 -还要讨论两层for循环的前后循序。 +还要讨论两层for循环的前后顺序。 **如果求组合数就是外层for循环遍历物品，内层for遍历背包**。 **如果求排列数就是外层for遍历背包，内层for循环遍历物品**。 -我在这里做一个一个总结： +我在这里做一个总结： 求组合数：[动态规划：518.零钱兑换II](https://programmercarl.com/0518.零钱兑换II.html) 求排列数：[动态规划：377. 组合总和 Ⅳ](https://programmercarl.com/0377.组合总和.html)、[动态规划：70. 爬楼梯进阶版（完全背包）](https://programmercarl.com/0070.爬楼梯完全背包版本.html) @@ -170,7 +170,7 @@ dp[0]表示如果字符串为空的话，说明出现在字典里。 "apple" + "apple" + "pen" 或者 "pen" + "apple" + "apple" 是不可以的，那么我们就是强调物品之间顺序。 -所以说，本题一定是 先遍历 背包，在遍历物品。 +所以说，本题一定是 先遍历 背包，再遍历物品。 5. 举例推导dp[i] @@ -209,7 +209,7 @@ public: 关于遍历顺序，再给大家讲一下为什么 先遍历物品再遍历背包不行。 -这里可以给出先遍历物品在遍历背包的代码： +这里可以给出先遍历物品再遍历背包的代码： ```CPP class Solution { @@ -241,7 +241,7 @@ public: 最后dp[s.size()] = 0 即 dp[13] = 0 ，而不是1，因为先用 "apple" 去遍历的时候，dp[8]并没有被赋值为1 （还没用"pen"），所以 dp[13]也不能变成1。 -除非是先用 "apple" 遍历一遍，在用 "pen" 遍历，此时 dp[8]已经是1，最后再用 "apple" 去遍历，dp[13]才能是1。 +除非是先用 "apple" 遍历一遍，再用 "pen" 遍历，此时 dp[8]已经是1，最后再用 "apple" 去遍历，dp[13]才能是1。 如果大家对这里不理解，建议可以把我上面给的代码，拿去力扣上跑一跑，把dp数组打印出来，对着递推公式一步一步去看，思路就清晰了。 @@ -352,16 +352,16 @@ class Solution: Go： ```Go func wordBreak(s string,wordDict []string) bool { - wordDictSet:=make(map[string]bool) - for _,w:=range wordDict{ - wordDictSet[w]=true + wordDictSet := make(map[string]bool) + for _, w := range wordDict { + wordDictSet[w] = true } - dp:=make([]bool,len(s)+1) - dp[0]=true - for i:=1;i<=len(s);i++{ - for j:=0;j Date: Sat, 24 Dec 2022 17:37:56 +0800 Subject: [PATCH 26/44] =?UTF-8?q?update=200198.=E6=89=93=E5=AE=B6=E5=8A=AB?= =?UTF-8?q?=E8=88=8D:=20=E6=9B=B4=E6=96=B0=20go=20=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0198.打家劫舍.md | 33 ++++++++++++--------------------- 1 file changed, 12 insertions(+), 21 deletions(-) diff --git a/problems/0198.打家劫舍.md b/problems/0198.打家劫舍.md index 1e48f007..6002cd3a 100644 --- a/problems/0198.打家劫舍.md +++ b/problems/0198.打家劫舍.md @@ -52,7 +52,7 @@ 如果偷第i房间，那么dp[i] = dp[i - 2] + nums[i] ，即：第i-1房一定是不考虑的，找出 下标i-2（包括i-2）以内的房屋，最多可以偷窃的金额为dp[i-2] 加上第i房间偷到的钱。 -如果不偷第i房间，那么dp[i] = dp[i - 1]，即考虑i-1房，（**注意这里是考虑，并不是一定要偷i-1房，这是很多同学容易混淆的点**） +如果不偷第i房间，那么dp[i] = dp[i - 1]，即考 虑i-1房，（**注意这里是考虑，并不是一定要偷i-1房，这是很多同学容易混淆的点**） 然后dp[i]取最大值，即dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]); @@ -154,29 +154,20 @@ class Solution: Go： ```Go func rob(nums []int) int { - if len(nums)<1{ - return 0 - } - if len(nums)==1{ - return nums[0] - } - if len(nums)==2{ - return max(nums[0],nums[1]) - } - dp :=make([]int,len(nums)) - dp[0]=nums[0] - dp[1]=max(nums[0],nums[1]) - for i:=2;ib{ - return a - } - return b + if a > b { + return a + } + return b } ``` From e39209e3d7a55cd36812e8b6042f802e1e03bdde Mon Sep 17 00:00:00 2001 From: Yuhao Ju Date: Sat, 24 Dec 2022 17:41:56 +0800 Subject: [PATCH 27/44] =?UTF-8?q?update=200213.=E6=89=93=E5=AE=B6=E5=8A=AB?= =?UTF-8?q?=E8=88=8DII:=20=E8=B0=83=E6=8D=A2=E5=85=B6=E4=BB=96=E8=AF=AD?= =?UTF-8?q?=E8=A8=80=E4=B8=AD=20go=20=E4=BB=A3=E7=A0=81=E7=9A=84=E9=A1=BA?= =?UTF-8?q?=E5=BA=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0213.打家劫舍II.md | 76 ++++++++++++++++----------------- 1 file changed, 38 insertions(+), 38 deletions(-) diff --git a/problems/0213.打家劫舍II.md b/problems/0213.打家劫舍II.md index 8e1ca126..dd109f83 100644 --- a/problems/0213.打家劫舍II.md +++ b/problems/0213.打家劫舍II.md @@ -143,6 +143,44 @@ class Solution: return dp[-1] ``` +Go： + +```go +// 打家劫舍Ⅱ 动态规划 +// 时间复杂度O(n) 空间复杂度O(n) +func rob(nums []int) int { + if len(nums) == 1 { + return nums[0] + } + if len(nums) == 2 { + return max(nums[0], nums[1]) + } + + result1 := robRange(nums, 0) + result2 := robRange(nums, 1) + return max(result1, result2) +} + +// 偷盗指定的范围 +func robRange(nums []int, start int) int { + dp := make([]int, len(nums)) + dp[1] = nums[start] + + for i := 2; i < len(nums); i++ { + dp[i] = max(dp[i - 2] + nums[i - 1 + start], dp[i - 1]) + } + + return dp[len(nums) - 1] +} + +func max(a, b int) int { + if a > b { + return a + } + return b +} +``` + javascipt: ```javascript var rob = function(nums) { @@ -187,44 +225,6 @@ function robRange(nums: number[], start: number, end: number): number { } ``` -Go： - -```go -// 打家劫舍Ⅱ 动态规划 -// 时间复杂度O(n) 空间复杂度O(n) -func rob(nums []int) int { - if len(nums) == 1 { - return nums[0] - } - if len(nums) == 2 { - return max(nums[0], nums[1]) - } - - result1 := robRange(nums, 0) - result2 := robRange(nums, 1) - return max(result1, result2) -} - -// 偷盗指定的范围 -func robRange(nums []int, start int) int { - dp := make([]int, len(nums)) - dp[1] = nums[start] - - for i := 2; i < len(nums); i++ { - dp[i] = max(dp[i - 2] + nums[i - 1 + start], dp[i - 1]) - } - - return dp[len(nums) - 1] -} - -func max(a, b int) int { - if a > b { - return a - } - return b -} -``` -

From a9034c491081324e49edd160184e3c99ef91dd54 Mon Sep 17 00:00:00 2001 From: Yuhao Ju Date: Sat, 24 Dec 2022 17:54:59 +0800 Subject: [PATCH 28/44] =?UTF-8?q?update=200337.=E6=89=93=E5=AE=B6=E5=8A=AB?= =?UTF-8?q?=E8=88=8DIII=EF=BC=9A=E5=88=A0=E9=99=A4=E5=86=97=E4=BD=99?= =?UTF-8?q?=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0337.打家劫舍III.md | 35 ++------------------------------ 1 file changed, 2 insertions(+), 33 deletions(-) diff --git a/problems/0337.打家劫舍III.md b/problems/0337.打家劫舍III.md index c69279fd..ba9a2e59 100644 --- a/problems/0337.打家劫舍III.md +++ b/problems/0337.打家劫舍III.md @@ -129,7 +129,7 @@ if (cur == NULL) return vector{0, 0}; 3. 确定遍历顺序 -首先明确的是使用后序遍历。 因为通过递归函数的返回值来做下一步计算。 +首先明确的是使用后序遍历。 因为要通过递归函数的返回值来做下一步计算。 通过递归左节点，得到左节点偷与不偷的金钱。 @@ -147,7 +147,7 @@ vector right = robTree(cur->right); // 右 4. 确定单层递归的逻辑 -如果是偷当前节点，那么左右孩子就不能偷，val1 = cur->val + left[0] + right[0]; （**如果对下标含义不理解就在回顾一下dp数组的含义**） +如果是偷当前节点，那么左右孩子就不能偷，val1 = cur->val + left[0] + right[0]; （**如果对下标含义不理解就再回顾一下dp数组的含义**） 如果不偷当前节点，那么左右孩子就可以偷，至于到底偷不偷一定是选一个最大的，所以：val2 = max(left[0], left[1]) + max(right[0], right[1]); @@ -483,37 +483,6 @@ function robNode(node: TreeNode | null): MaxValueArr { } ``` -### Go - -```go -// 打家劫舍Ⅲ 动态规划 -// 时间复杂度O(n) 空间复杂度O(logn) -func rob(root *TreeNode) int { - dp := traversal(root) - return max(dp[0], dp[1]) -} - -func traversal(cur *TreeNode) []int { - if cur == nil { - return []int{0, 0} - } - - dpL := traversal(cur.Left) - dpR := traversal(cur.Right) - - val1 := cur.Val + dpL[0] + dpR[0] // 偷盗当前节点 - val2 := max(dpL[0], dpL[1]) + max(dpR[0], dpR[1]) // 不偷盗当前节点 - return []int{val2, val1} -} - -func max(a, b int) int { - if a > b { - return a - } - return b -} -``` -

From c94a8a951a5dbddce848b8517d362c2eb041bd19 Mon Sep 17 00:00:00 2001 From: Yuhao Ju Date: Sat, 24 Dec 2022 20:04:07 +0800 Subject: [PATCH 29/44] =?UTF-8?q?update=200121.=E4=B9=B0=E5=8D=96=E8=82=A1?= =?UTF-8?q?=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6=E6=9C=BA=EF=BC=9A?= =?UTF-8?q?=E4=BC=98=E5=8C=96=E4=BB=A3=E7=A0=81=E9=A3=8E=E6=A0=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0121.买卖股票的最佳时机.md | 67 ++++++++------------ 1 file changed, 27 insertions(+), 40 deletions(-) diff --git a/problems/0121.买卖股票的最佳时机.md b/problems/0121.买卖股票的最佳时机.md index 915b178a..8736c9f3 100644 --- a/problems/0121.买卖股票的最佳时机.md +++ b/problems/0121.买卖股票的最佳时机.md @@ -89,7 +89,7 @@ dp[i][1] 表示第i天不持有股票所得最多现金 **注意这里说的是“持有”，“持有”不代表就是当天“买入”！也有可能是昨天就买入了，今天保持持有的状态** -很多同学把“持有”和“买入”没分区分清楚。 +很多同学把“持有”和“买入”没区分清楚。 在下面递推公式分析中，我会进一步讲解。 @@ -103,11 +103,11 @@ dp[i][1] 表示第i天不持有股票所得最多现金 如果第i天不持有股票即dp[i][1]， 也可以由两个状态推出来 * 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1] -* 第i天卖出股票，所得现金就是按照今天股票佳价格卖出后所得现金即：prices[i] + dp[i - 1][0] +* 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金即：prices[i] + dp[i - 1][0] 同样dp[i][1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]); -这样递归公式我们就分析完了 +这样递推公式我们就分析完了 3. dp数组如何初始化 @@ -121,7 +121,7 @@ dp[0][1]表示第0天不持有股票，不持有股票那么现金就是0，所 4. 确定遍历顺序 -从递推公式可以看出dp[i]都是有dp[i - 1]推导出来的，那么一定是从前向后遍历。 +从递推公式可以看出dp[i]都是由dp[i - 1]推导出来的，那么一定是从前向后遍历。 5. 举例推导dp数组 @@ -326,53 +326,40 @@ Go: > 贪心法： ```Go func maxProfit(prices []int) int { - low := math.MaxInt32 - rlt := 0 - for i := range prices{ - low = min(low, prices[i]) - rlt = max(rlt, prices[i]-low) + min := prices[0] + res := 0 + for i := 1; i < len(prices); i++ { + if prices[i] - min > res { + res = prices[i]-min + } + if min > prices[i] { + min = prices[i] + } } - - return rlt -} -func min(a, b int) int { - if a < b{ - return a - } - - return b -} - -func max(a, b int) int { - if a > b{ - return a - } - - return b + return res } ``` > 动态规划：版本一 ```Go func maxProfit(prices []int) int { - length:=len(prices) - if length==0{return 0} - dp:=make([][]int,length) - for i:=0;ib{ +func max(a, b int) int { + if a > b { return a } return b @@ -385,7 +372,7 @@ func maxProfit(prices []int) int { dp := [2][2]int{} dp[0][0] = -prices[0] dp[0][1] = 0 - for i := 1; i < len(prices); i++{ + for i := 1; i < len(prices); i++ { dp[i%2][0] = max(dp[(i-1)%2][0], -prices[i]) dp[i%2][1] = max(dp[(i-1)%2][1], dp[(i-1)%2][0]+prices[i]) } From 18e062c3e6b8cc8b1f068ca74b61a9ba42432392 Mon Sep 17 00:00:00 2001 From: Yuhao Ju Date: Sat, 24 Dec 2022 20:19:05 +0800 Subject: [PATCH 30/44] =?UTF-8?q?update=200122.=E4=B9=B0=E5=8D=96=E8=82=A1?= =?UTF-8?q?=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6=E6=9C=BAII?= =?UTF-8?q?=EF=BC=88=E5=8A=A8=E6=80=81=E8=A7=84=E5=88=92=EF=BC=89=EF=BC=9A?= =?UTF-8?q?=E4=BF=AE=E6=94=B9=E9=94=99=E5=AD=97=E5=92=8C=E5=88=A0=E9=99=A4?= =?UTF-8?q?=E5=86=97=E4=BD=99=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...票的最佳时机II（动态规划）.md | 31 +++---------------- 1 file changed, 4 insertions(+), 27 deletions(-) diff --git a/problems/0122.买卖股票的最佳时机II（动态规划）.md b/problems/0122.买卖股票的最佳时机II（动态规划）.md index f2aec68b..2779083d 100644 --- a/problems/0122.买卖股票的最佳时机II（动态规划）.md +++ b/problems/0122.买卖股票的最佳时机II（动态规划）.md @@ -39,7 +39,7 @@ 本题我们在讲解贪心专题的时候就已经讲解过了[贪心算法：买卖股票的最佳时机II](https://programmercarl.com/0122.买卖股票的最佳时机II.html)，只不过没有深入讲解动态规划的解法，那么这次我们再好好分析一下动规的解法。 -本题和[121. 买卖股票的最佳时机](https://programmercarl.com/0121.买卖股票的最佳时机.html)的唯一区别本题股票可以买卖多次了（注意只有一只股票，所以再次购买前要出售掉之前的股票） +本题和[121. 买卖股票的最佳时机](https://programmercarl.com/0121.买卖股票的最佳时机.html)的唯一区别是本题股票可以买卖多次了（注意只有一只股票，所以再次购买前要出售掉之前的股票） **在动规五部曲中，这个区别主要是体现在递推公式上，其他都和[121. 买卖股票的最佳时机](https://programmercarl.com/0121.买卖股票的最佳时机.html)一样一样的**。 @@ -63,9 +63,9 @@ 那么第i天持有股票即dp[i][0]，如果是第i天买入股票，所得现金就是昨天不持有股票的所得现金 减去 今天的股票价格 即：dp[i - 1][1] - prices[i]。 -在来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来 +再来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来 * 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1] -* 第i天卖出股票，所得现金就是按照今天股票佳价格卖出后所得现金即：prices[i] + dp[i - 1][0] +* 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金即：prices[i] + dp[i - 1][0] **注意这里和[121. 买卖股票的最佳时机](https://programmercarl.com/0121.买卖股票的最佳时机.html)就是一样的逻辑，卖出股票收获利润（可能是负值）天经地义！** @@ -99,7 +99,7 @@ dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]); **这正是因为本题的股票可以买卖多次！** 所以买入股票的时候，可能会有之前买卖的利润即：dp[i - 1][1]，所以dp[i - 1][1] - prices[i]。 -想到到这一点，对这两道题理解的比较深刻了。 +想到到这一点，对这两道题理解的就比较深刻了。 这里我依然给出滚动数组的版本，C++代码如下： @@ -228,29 +228,6 @@ func max(a, b int) int { } ``` -```go -func maxProfit(prices []int) int { - //创建数组 - dp:=make([][]int,len(prices)) - for i:=0;i Date: Sat, 24 Dec 2022 21:15:31 +0800 Subject: [PATCH 31/44] =?UTF-8?q?update=200123.=E4=B9=B0=E5=8D=96=E8=82=A1?= =?UTF-8?q?=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6=E6=9C=BAIII?= =?UTF-8?q?=EF=BC=9A=E5=88=A0=E9=99=A4=E5=86=97=E4=BD=99=20go=20=E4=BB=A3?= =?UTF-8?q?=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../0123.买卖股票的最佳时机III.md | 71 +++++-------------- 1 file changed, 19 insertions(+), 52 deletions(-) diff --git a/problems/0123.买卖股票的最佳时机III.md b/problems/0123.买卖股票的最佳时机III.md index 611bd2ce..d480da83 100644 --- a/problems/0123.买卖股票的最佳时机III.md +++ b/problems/0123.买卖股票的最佳时机III.md @@ -62,7 +62,7 @@ dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天 需要注意：dp[i][1]，**表示的是第i天，买入股票的状态，并不是说一定要第i天买入股票，这是很多同学容易陷入的误区**。 -例如 dp[i][1] ，并不是说 第i点一定买入股票，有可能 第 i-1天 就买入了，那么 dp[i][1] 延续买入股票的这个状态。 +例如 dp[i][1] ，并不是说 第i天一定买入股票，有可能 第 i-1天 就买入了，那么 dp[i][1] 延续买入股票的这个状态。 2. 确定递推公式 @@ -102,7 +102,7 @@ dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]); 第0天第二次买入操作，初始值应该是多少呢？应该不少同学疑惑，第一次还没买入呢，怎么初始化第二次买入呢？ -第二次买入依赖于第一次卖出的状态，其实相当于第0天第一次买入了，第一次卖出了，然后在买入一次（第二次买入），那么现在手头上没有现金，只要买入，现金就做相应的减少。 +第二次买入依赖于第一次卖出的状态，其实相当于第0天第一次买入了，第一次卖出了，然后再买入一次（第二次买入），那么现在手头上没有现金，只要买入，现金就做相应的减少。 所以第二次买入操作，初始化为：dp[0][3] = -prices[0]; @@ -181,7 +181,7 @@ public: dp[1] = max(dp[1], dp[0] - prices[i]); 如果dp[1]取dp[1]，即保持买入股票的状态，那么 dp[2] = max(dp[2], dp[1] + prices[i]);中dp[1] + prices[i] 就是今天卖出。 -如果dp[1]取dp[0] - prices[i]，今天买入股票，那么dp[2] = max(dp[2], dp[1] + prices[i]);中的dp[1] + prices[i]相当于是尽在再卖出股票，一买一卖收益为0，对所得现金没有影响。相当于今天买入股票又卖出股票，等于没有操作，保持昨天卖出股票的状态了。 +如果dp[1]取dp[0] - prices[i]，今天买入股票，那么dp[2] = max(dp[2], dp[1] + prices[i]);中的dp[1] + prices[i]相当于是今天再卖出股票，一买一卖收益为0，对所得现金没有影响。相当于今天买入股票又卖出股票，等于没有操作，保持昨天卖出股票的状态了。 **这种写法看上去简单，其实思路很绕，不建议大家这么写，这么思考，很容易把自己绕进去！** @@ -312,26 +312,26 @@ Go: ```go func maxProfit(prices []int) int { - dp:=make([][]int,len(prices)) - for i:=0;ib{ +func max(a, b int) int { + if a > b { return a } return b @@ -407,39 +407,6 @@ function maxProfit(prices: number[]): number { }; ``` -Go: - -> 版本一： -```go -// 买卖股票的最佳时机III 动态规划 -// 时间复杂度O(n) 空间复杂度O(n) -func maxProfit(prices []int) int { - dp := make([][]int, len(prices)) - status := make([]int, len(prices) * 4) - for i := range dp { - dp[i] = status[:4] - status = status[4:] - } - dp[0][0], dp[0][2] = -prices[0], -prices[0] - - for i := 1; i < len(prices); i++ { - dp[i][0] = max(dp[i - 1][0], -prices[i]) - dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]) - dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] - prices[i]) - dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] + prices[i]) - } - - return dp[len(prices) - 1][3] -} - -func max(a, b int) int { - if a > b { - return a - } - return b -} -``` - From 78909ff5aac5594a8e8023c45fab1c53c61d6536 Mon Sep 17 00:00:00 2001 From: Re1own <0xzhzus@gmail.com> Date: Mon, 26 Dec 2022 00:29:02 -0500 Subject: [PATCH 32/44] =?UTF-8?q?Update=200707.=E8=AE=BE=E8=AE=A1=E9=93=BE?= =?UTF-8?q?=E8=A1=A8.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 结构体语法有错，中间有个free少了分号 --- problems/0707.设计链表.md | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/problems/0707.设计链表.md b/problems/0707.设计链表.md index 614bb36e..dd305d39 100644 --- a/problems/0707.设计链表.md +++ b/problems/0707.设计链表.md @@ -157,7 +157,7 @@ private: ## 其他语言版本 C: ```C -typedef struct { +typedef struct MyLinkedList { int val; struct MyLinkedList* next; }MyLinkedList; @@ -233,7 +233,7 @@ void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) { MyLinkedList *tmp = obj->next; if (tmp != NULL){ obj->next = tmp->next; - free(tmp) + free(tmp); } return; } @@ -263,20 +263,21 @@ void myLinkedListFree(MyLinkedList* obj) { } /** + * Your MyLinkedList struct will be instantiated and called as such: * MyLinkedList* obj = myLinkedListCreate(); * int param_1 = myLinkedListGet(obj, index); - + * myLinkedListAddAtHead(obj, val); - + * myLinkedListAddAtTail(obj, val); - + * myLinkedListAddAtIndex(obj, index, val); - + * myLinkedListDeleteAtIndex(obj, index); - + * myLinkedListFree(obj); -*/ + */ ``` Java： From 44fcb894c58abaf842537bca65a384e6c4048ec0 Mon Sep 17 00:00:00 2001 From: Re1own <0xzhzus@gmail.com> Date: Mon, 26 Dec 2022 01:03:12 -0500 Subject: [PATCH 33/44] =?UTF-8?q?707=5FC=E4=BB=A3=E7=A0=81=E8=AF=AD?= =?UTF-8?q?=E6=B3=95=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 创建结构体语法有问题，中间有一个free没有分号 --- problems/0707.设计链表.md | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/problems/0707.设计链表.md b/problems/0707.设计链表.md index dd305d39..b82a645e 100644 --- a/problems/0707.设计链表.md +++ b/problems/0707.设计链表.md @@ -233,7 +233,7 @@ void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) { MyLinkedList *tmp = obj->next; if (tmp != NULL){ obj->next = tmp->next; - free(tmp); + free(tmp); } return; } @@ -263,21 +263,20 @@ void myLinkedListFree(MyLinkedList* obj) { } /** - * Your MyLinkedList struct will be instantiated and called as such: * MyLinkedList* obj = myLinkedListCreate(); * int param_1 = myLinkedListGet(obj, index); - + * myLinkedListAddAtHead(obj, val); - + * myLinkedListAddAtTail(obj, val); - + * myLinkedListAddAtIndex(obj, index, val); - + * myLinkedListDeleteAtIndex(obj, index); - + * myLinkedListFree(obj); - */ +*/ ``` Java： From 4e28ab5b7d70900c7fb6860a9473eaaca25abe62 Mon Sep 17 00:00:00 2001 From: Haitao Lu Date: Mon, 26 Dec 2022 19:26:45 +0800 Subject: [PATCH 34/44] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E9=94=99=E5=88=AB?= =?UTF-8?q?=E5=AD=97.=20=E2=80=9C=E5=B7=A6=E9=97=AD=E5=8F=88=E9=97=AD?= =?UTF-8?q?=E2=80=9D=E5=BA=94=E8=AF=A5=E6=98=AF=E2=80=9C=E5=B7=A6=E9=97=AD?= =?UTF-8?q?=E5=8F=B3=E9=97=AD=E2=80=9D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0151.翻转字符串里的单词.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/problems/0151.翻转字符串里的单词.md b/problems/0151.翻转字符串里的单词.md index b82204fa..a12d8f76 100644 --- a/problems/0151.翻转字符串里的单词.md +++ b/problems/0151.翻转字符串里的单词.md @@ -150,7 +150,7 @@ void removeExtraSpaces(string& s) {//去除所有空格并在相邻单词之间 代码如下： ```CPP -// 反转字符串s中左闭又闭的区间[start, end] +// 反转字符串s中左闭右闭的区间[start, end] void reverse(string& s, int start, int end) { for (int i = start, j = end; i < j; i++, j--) { swap(s[i], s[j]); @@ -163,7 +163,7 @@ void reverse(string& s, int start, int end) { ```CPP class Solution { public: - void reverse(string& s, int start, int end){ //翻转，区间写法：左闭又闭 [] + void reverse(string& s, int start, int end){ //翻转，区间写法：左闭右闭 [] for (int i = start, j = end; i < j; i++, j--) { swap(s[i], s[j]); } From b825b5a7c82023ee2ac1b2adc68cf75abc2ecd13 Mon Sep 17 00:00:00 2001 From: ZerenZhang2022 <118794589+ZerenZhang2022@users.noreply.github.com> Date: Tue, 27 Dec 2022 00:30:43 -0500 Subject: [PATCH 35/44] =?UTF-8?q?Update=200098.=E9=AA=8C=E8=AF=81=E4=BA=8C?= =?UTF-8?q?=E5=8F=89=E6=90=9C=E7=B4=A2=E6=A0=91.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 补充：**递归** - 避免初始化最小值做法 --- problems/0098.验证二叉搜索树.md | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/problems/0098.验证二叉搜索树.md b/problems/0098.验证二叉搜索树.md index 95ae783f..93c2272c 100644 --- a/problems/0098.验证二叉搜索树.md +++ b/problems/0098.验证二叉搜索树.md @@ -392,7 +392,26 @@ class Solution: return is_left_valid and is_right_valid return __isValidBST(root) ``` - +**递归** - 避免初始化最小值做法： +```python +class Solution: + def isValidBST(self, root: TreeNode) -> bool: + # 规律: BST的中序遍历节点数值是从小到大. + pre = None + def __isValidBST(root: TreeNode) -> bool: + nonlocal pre + + if not root: + return True + + is_left_valid = __isValidBST(root.left) + if pre and pre.val>=root.val: return False + pre = root + is_right_valid = __isValidBST(root.right) + + return is_left_valid and is_right_valid + return __isValidBST(root) +``` ```python 迭代-中序遍历 class Solution: From b6807a66dc048c7098243a7c00c823eb3dceb3f1 Mon Sep 17 00:00:00 2001 From: Logen <47022821+Logenleedev@users.noreply.github.com> Date: Wed, 28 Dec 2022 09:45:31 -0600 Subject: [PATCH 36/44] =?UTF-8?q?=E6=B7=BB=E5=8A=A0leetcode=20226=E7=BF=BB?= =?UTF-8?q?=E8=BD=AC=E4=BA=8C=E5=8F=89=E6=A0=91python=E5=90=8E=E5=BA=8F?= =?UTF-8?q?=E9=80=92=E5=BD=92=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0226.翻转二叉树.md | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/problems/0226.翻转二叉树.md b/problems/0226.翻转二叉树.md index ad2a7de2..84c0c589 100644 --- a/problems/0226.翻转二叉树.md +++ b/problems/0226.翻转二叉树.md @@ -322,6 +322,18 @@ class Solution: return root ``` +递归法：后序遍历： +```python +class Solution: + def invertTree(self, root: TreeNode) -> TreeNode: + if root is None: + return None + self.invertTree(root.left) + self.invertTree(root.right) + root.left, root.right = root.right, root.left + return root +``` + 迭代法：深度优先遍历（前序遍历）： ```python class Solution: From 8cb8f7f56a370cc8f52be5ecddadb063a7401ccb Mon Sep 17 00:00:00 2001 From: Yuhao Ju Date: Thu, 29 Dec 2022 17:08:14 +0800 Subject: [PATCH 37/44] =?UTF-8?q?update=200188.=E4=B9=B0=E5=8D=96=E8=82=A1?= =?UTF-8?q?=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6=E6=9C=BAIV:=20?= =?UTF-8?q?=E5=88=A0=E9=99=A4=E5=86=97=E4=BD=99=20go=20=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../0188.买卖股票的最佳时机IV.md | 34 ------------------- 1 file changed, 34 deletions(-) diff --git a/problems/0188.买卖股票的最佳时机IV.md b/problems/0188.买卖股票的最佳时机IV.md index 23a8f54a..695fac35 100644 --- a/problems/0188.买卖股票的最佳时机IV.md +++ b/problems/0188.买卖股票的最佳时机IV.md @@ -323,40 +323,6 @@ func max(a, b int) int { } ``` -```go -func maxProfit(k int, prices []int) int { - if len(prices)==0{ - return 0 - } - dp:=make([][]int,len(prices)) - for i:=0;ib{ - return a - } - return b -} -``` - Javascript: ```javascript From aa0078469327a4eecf6dc872ab0cfbc4ad380b4d Mon Sep 17 00:00:00 2001 From: Yuhao Ju Date: Thu, 29 Dec 2022 22:12:32 +0800 Subject: [PATCH 38/44] =?UTF-8?q?update=200300.=E6=9C=80=E9=95=BF=E4=B8=8A?= =?UTF-8?q?=E5=8D=87=E5=AD=90=E5=BA=8F=E5=88=97:=20=E4=BF=AE=E6=94=B9?= =?UTF-8?q?=E6=96=87=E6=9C=AC=E9=94=99=E5=AD=97=EF=BC=8C=E8=B0=83=E6=95=B4?= =?UTF-8?q?=E5=85=B6=E4=BB=96=E8=AF=AD=E8=A8=80=E4=BB=A3=E7=A0=81=E4=BD=8D?= =?UTF-8?q?=E7=BD=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0300.最长上升子序列.md | 85 +++++++++++++------------- 1 file changed, 42 insertions(+), 43 deletions(-) diff --git a/problems/0300.最长上升子序列.md b/problems/0300.最长上升子序列.md index 42efe31d..f4fe1c31 100644 --- a/problems/0300.最长上升子序列.md +++ b/problems/0300.最长上升子序列.md @@ -36,9 +36,9 @@ 首先通过本题大家要明确什么是子序列，“子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序”。 本题也是代码随想录中子序列问题的第一题，如果没接触过这种题目的话，本题还是很难的，甚至想暴力去搜索也不知道怎么搜。 -子序列问题是动态规划解决的经典问题，当前下标i的递增子序列长度，其实和i之前的下表j的子序列长度有关系，那那又是什么样的关系呢。 +子序列问题是动态规划解决的经典问题，当前下标i的递增子序列长度，其实和i之前的下表j的子序列长度有关系，那又是什么样的关系呢。 -接下来，我们依然用动规五部曲来分析详细一波： +接下来，我们依然用动规五部曲来详细分析一波： 1. dp[i]的定义 @@ -46,7 +46,7 @@ **dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度** -为什么一定表示 “以nums[i]结尾的最长递增子序” ，因为我们在 做 递增比较的时候，如果比较 nums[j] 和 nums[i] 的大小，那么两个递增子序列一定分别以nums[j]为结尾 和 nums[i]为结尾， 要不然这个比较就没有意义了，不是尾部元素的比较那么 如果算递增呢。 +为什么一定表示 “以nums[i]结尾的最长递增子序” ，因为我们在 做 递增比较的时候，如果比较 nums[j] 和 nums[i] 的大小，那么两个递增子序列一定分别以nums[j]为结尾 和 nums[i]为结尾， 要不然这个比较就没有意义了，不是尾部元素的比较那么 如何算递增呢。 2. 状态转移方程 @@ -155,31 +155,6 @@ class Solution: ``` Go： -```go -func lengthOfLIS(nums []int ) int { - dp := []int{} - for _, num := range nums { - if len(dp) ==0 || dp[len(dp) - 1] < num { - dp = append(dp, num) - } else { - l, r := 0, len(dp) - 1 - pos := r - for l <= r { - mid := (l + r) >> 1 - if dp[mid] >= num { - pos = mid; - r = mid - 1 - } else { - l = mid + 1 - } - } - dp[pos] = num - }//二分查找 - } - return len(dp) -} -``` - ```go // 动态规划求解 func lengthOfLIS(nums []int) int { @@ -212,21 +187,29 @@ func max(x, y int) int { return y } ``` - -Rust: -```rust -pub fn length_of_lis(nums: Vec) -> i32 { - let mut dp = vec![1; nums.len() + 1]; - let mut result = 1; - for i in 1..nums.len() { - for j in 0..i { - if nums[j] < nums[i] { - dp[i] = dp[i].max(dp[j] + 1); - } - result = result.max(dp[i]); - } - } - result +贪心+二分 优化 +```go +func lengthOfLIS(nums []int ) int { + dp := []int{} + for _, num := range nums { + if len(dp) == 0 || dp[len(dp) - 1] < num { + dp = append(dp, num) + } else { + l, r := 0, len(dp) - 1 + pos := r + for l <= r { + mid := (l + r) >> 1 + if dp[mid] >= num { + pos = mid; + r = mid - 1 + } else { + l = mid + 1 + } + } + dp[pos] = num + }//二分查找 + } + return len(dp) } ``` @@ -270,6 +253,22 @@ function lengthOfLIS(nums: number[]): number { }; ``` +Rust: +```rust +pub fn length_of_lis(nums: Vec) -> i32 { + let mut dp = vec![1; nums.len() + 1]; + let mut result = 1; + for i in 1..nums.len() { + for j in 0..i { + if nums[j] < nums[i] { + dp[i] = dp[i].max(dp[j] + 1); + } + result = result.max(dp[i]); + } + } + result +} +``` From 2afe2709a7d3ae8048321182083bd1fa84cdd7d2 Mon Sep 17 00:00:00 2001 From: Yuhao Ju Date: Thu, 29 Dec 2022 22:40:18 +0800 Subject: [PATCH 39/44] =?UTF-8?q?update=200718.=E6=9C=80=E9=95=BF=E9=87=8D?= =?UTF-8?q?=E5=A4=8D=E5=AD=90=E6=95=B0=E7=BB=84=EF=BC=9A=E4=BC=98=E5=8C=96?= =?UTF-8?q?=E6=96=87=E6=9C=AC=E9=94=99=E5=AD=97=EF=BC=8C=E5=A2=9E=E5=8A=A0?= =?UTF-8?q?=20go=20=E7=9A=84=E6=BB=9A=E5=8A=A8=E6=95=B0=E7=BB=84=E4=BB=A3?= =?UTF-8?q?=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0718.最长重复子数组.md | 27 ++++++++++++++++++++++++-- 1 file changed, 25 insertions(+), 2 deletions(-) diff --git a/problems/0718.最长重复子数组.md b/problems/0718.最长重复子数组.md index 37f6cbfe..0658f9c8 100644 --- a/problems/0718.最长重复子数组.md +++ b/problems/0718.最长重复子数组.md @@ -28,7 +28,7 @@ 注意题目中说的子数组，其实就是连续子序列。 -要求两个数组中最长重复子数组，如果是暴力的解法 只要需要先两层for循环确定两个数组起始位置，然后在来一个循环可以是for或者while，来从两个起始位置开始比较，取得重复子数组的长度。 +要求两个数组中最长重复子数组，如果是暴力的解法 只需要先两层for循环确定两个数组起始位置，然后再来一个循环可以是for或者while，来从两个起始位置开始比较，取得重复子数组的长度。 本题其实是动规解决的经典题目，我们只要想到 用二维数组可以记录两个字符串的所有比较情况，这样就比较好推 递推公式了。 动规五部曲分析如下： @@ -163,7 +163,7 @@ public: 当然可以，就是实现起来麻烦一些。 -如果定义 dp[i][j]为 以下标i为结尾的A，和以下标j 为结尾的B，那么 第一行和第一列毕竟要经行初始化，如果nums1[i] 与 nums2[0] 相同的话，对应的 dp[i][0]就要初始为1， 因为此时最长重复子数组为1。 nums2[j] 与 nums1[0]相同的话，同理。 +如果定义 dp[i][j]为 以下标i为结尾的A，和以下标j 为结尾的B，那么 第一行和第一列毕竟要进行初始化，如果nums1[i] 与 nums2[0] 相同的话，对应的 dp[i][0]就要初始为1， 因为此时最长重复子数组为1。 nums2[j] 与 nums1[0]相同的话，同理。 所以代码如下： @@ -298,6 +298,29 @@ func findLength(A []int, B []int) int { } return res } + +// 滚动数组 +func findLength(nums1 []int, nums2 []int) int { + n, m, res := len(nums1), len(nums2), 0 + dp := make([]int, m+1) + for i := 1; i <= n; i++ { + for j := m; j >= 1; j-- { + if nums1[i-1] == nums2[j-1] { + dp[j] = dp[j-1] + 1 + } else { + dp[j] = 0 // 注意这里不相等要赋值为0，供下一层使用 + } + res = max(res, dp[j]) + } + } + return res +} +func max(a, b int) int { + if a > b { + return a + } + return b +} ``` JavaScript： From af67d52f09b8327c96f386248246300ee4df859c Mon Sep 17 00:00:00 2001 From: Logen <47022821+Logenleedev@users.noreply.github.com> Date: Thu, 29 Dec 2022 13:26:24 -0600 Subject: [PATCH 40/44] change depth to height --- problems/0104.二叉树的最大深度.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/problems/0104.二叉树的最大深度.md b/problems/0104.二叉树的最大深度.md index 03322c9a..e54221db 100644 --- a/problems/0104.二叉树的最大深度.md +++ b/problems/0104.二叉树的最大深度.md @@ -402,10 +402,10 @@ class solution: def getdepth(self, node): if not node: return 0 - leftdepth = self.getdepth(node.left) #左 - rightdepth = self.getdepth(node.right) #右 - depth = 1 + max(leftdepth, rightdepth) #中 - return depth + leftheight = self.getdepth(node.left) #左 + rightheight = self.getdepth(node.right) #右 + height = 1 + max(leftheight, rightheight) #中 + return height ``` 递归法：精简代码 From 0fed2a54a319160b17fe5cea69dd4fedd1e7e053 Mon Sep 17 00:00:00 2001 From: Yuhao Ju Date: Fri, 30 Dec 2022 15:24:06 +0800 Subject: [PATCH 41/44] =?UTF-8?q?update=201143.=E6=9C=80=E9=95=BF=E5=85=AC?= =?UTF-8?q?=E5=85=B1=E5=AD=90=E5=BA=8F=E5=88=97=EF=BC=9A=E4=BC=98=E5=8C=96?= =?UTF-8?q?=E6=96=87=E6=9C=AC=E9=94=99=E5=AD=97=EF=BC=8C=E8=B0=83=E6=95=B4?= =?UTF-8?q?=20rust=20=E4=BB=A3=E7=A0=81=E4=BD=8D=E7=BD=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/1143.最长公共子序列.md | 43 +++++++++++++------------- 1 file changed, 21 insertions(+), 22 deletions(-) diff --git a/problems/1143.最长公共子序列.md b/problems/1143.最长公共子序列.md index b655b5cd..f2e6e7e2 100644 --- a/problems/1143.最长公共子序列.md +++ b/problems/1143.最长公共子序列.md @@ -49,7 +49,7 @@ dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符 有同学会问：为什么要定义长度为[0, i - 1]的字符串text1，定义为长度为[0, i]的字符串text1不香么？ -这样定义是为了后面代码实现方便，如果非要定义为为长度为[0, i]的字符串text1也可以，我在 [动态规划：718. 最长重复子数组](https://programmercarl.com/0718.最长重复子数组.html) 中的「拓展」里 详细讲解了区别所在，其实就是简化了dp数组第一行和第一列的初始化逻辑。 +这样定义是为了后面代码实现方便，如果非要定义为长度为[0, i]的字符串text1也可以，我在 [动态规划：718. 最长重复子数组](https://programmercarl.com/0718.最长重复子数组.html) 中的「拓展」里 详细讲解了区别所在，其实就是简化了dp数组第一行和第一列的初始化逻辑。 2. 确定递推公式 @@ -240,27 +240,6 @@ func max(a,b int)int { ``` -Rust: -```rust -pub fn longest_common_subsequence(text1: String, text2: String) -> i32 { - let (n, m) = (text1.len(), text2.len()); - let (s1, s2) = (text1.as_bytes(), text2.as_bytes()); - let mut dp = vec![0; m + 1]; - let mut last = vec![0; m + 1]; - for i in 1..=n { - dp.swap_with_slice(&mut last); - for j in 1..=m { - dp[j] = if s1[i - 1] == s2[j - 1] { - last[j - 1] + 1 - } else { - last[j].max(dp[j - 1]) - }; - } - } - dp[m] -} -``` - Javascript： ```javascript const longestCommonSubsequence = (text1, text2) => { @@ -304,6 +283,26 @@ function longestCommonSubsequence(text1: string, text2: string): number { }; ``` +Rust: +```rust +pub fn longest_common_subsequence(text1: String, text2: String) -> i32 { + let (n, m) = (text1.len(), text2.len()); + let (s1, s2) = (text1.as_bytes(), text2.as_bytes()); + let mut dp = vec![0; m + 1]; + let mut last = vec![0; m + 1]; + for i in 1..=n { + dp.swap_with_slice(&mut last); + for j in 1..=m { + dp[j] = if s1[i - 1] == s2[j - 1] { + last[j - 1] + 1 + } else { + last[j].max(dp[j - 1]) + }; + } + } + dp[m] +} +``` From d3bd157bb4f2a9f2174281e4d0bd0bcdaa211129 Mon Sep 17 00:00:00 2001 From: Logen <47022821+Logenleedev@users.noreply.github.com> Date: Sun, 1 Jan 2023 16:49:52 -0600 Subject: [PATCH 42/44] fix typo --- problems/0239.滑动窗口最大值.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/problems/0239.滑动窗口最大值.md b/problems/0239.滑动窗口最大值.md index 9f2e96a6..540ab5d7 100644 --- a/problems/0239.滑动窗口最大值.md +++ b/problems/0239.滑动窗口最大值.md @@ -74,7 +74,7 @@ public: 大家此时应该陷入深思..... -**其实队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队里的元素数值是由大到小的。** +**其实队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。** 那么这个维护元素单调递减的队列就叫做**单调队列，即单调递减或单调递增的队列。C++中没有直接支持单调队列，需要我们自己来实现一个单调队列** From a5fd36e64cee1d02c1b7ce7c6fbc61e2254f085b Mon Sep 17 00:00:00 2001 From: Allen <2439506288@qq.com> Date: Mon, 2 Jan 2023 09:58:06 +0800 Subject: [PATCH 43/44] =?UTF-8?q?Update=200491.=E9=80=92=E5=A2=9E=E5=AD=90?= =?UTF-8?q?=E5=BA=8F=E5=88=97.md=20=E4=BF=AE=E6=94=B9=E8=BF=87=E6=97=B6?= =?UTF-8?q?=E9=A2=98=E7=9B=AE=E9=93=BE=E6=8E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0491.递增子序列.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/problems/0491.递增子序列.md b/problems/0491.递增子序列.md index c764a1c3..82b3604e 100644 --- a/problems/0491.递增子序列.md +++ b/problems/0491.递增子序列.md @@ -9,7 +9,7 @@ # 491.递增子序列 -[力扣题目链接](https://leetcode.cn/problems/increasing-subsequences/) +[力扣题目链接](https://leetcode.cn/problems/non-decreasing-subsequences/) 给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。 @@ -614,3 +614,4 @@ object Solution { + From c54ca3f210d2e881cac888f83af2ef6796091daf Mon Sep 17 00:00:00 2001 From: Yuhao Ju Date: Mon, 2 Jan 2023 22:40:46 +0800 Subject: [PATCH 44/44] =?UTF-8?q?update=200213.=E6=89=93=E5=AE=B6=E5=8A=AB?= =?UTF-8?q?=E8=88=8DII:=20=E4=BF=AE=E6=94=B9=E5=87=BD=E6=95=B0=20python=20?= =?UTF-8?q?=E4=BB=A3=E7=A0=81=E5=87=BD=E6=95=B0=E5=90=8D=E7=A7=B0=E9=94=99?= =?UTF-8?q?=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- problems/0213.打家劫舍II.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/problems/0213.打家劫舍II.md b/problems/0213.打家劫舍II.md index dd109f83..e595d2fd 100644 --- a/problems/0213.打家劫舍II.md +++ b/problems/0213.打家劫舍II.md @@ -131,7 +131,7 @@ class Solution: val2=self.roblist(nums[:-1])#不偷最后一间房 return max(val1,val2) - def robRange(self,nums): + def roblist(self,nums): l=len(nums) dp=[0]*l dp[0]=nums[0]