mirror of
https://github.com/youngyangyang04/leetcode-master.git
synced 2025-07-11 13:00:22 +08:00
Merge branch 'master' of https://github.com/youngyangyang04/leetcode
This commit is contained in:
youngyangyang04
@ -321,6 +321,59 @@ class Solution:
|
||||
backtrack(board)
|
||||
```
|
||||
|
||||
Python3:
|
||||
|
||||
```python3
|
||||
class Solution:
|
||||
def __init__(self) -> None:
|
||||
self.board = []
|
||||
|
||||
def isValid(self, row: int, col: int, target: int) -> bool:
|
||||
for idx in range(len(self.board)):
|
||||
# 同列是否重复
|
||||
if self.board[idx][col] == str(target):
|
||||
return False
|
||||
# 同行是否重复
|
||||
if self.board[row][idx] == str(target):
|
||||
return False
|
||||
# 9宫格里是否重复
|
||||
box_row, box_col = (row // 3) * 3 + idx // 3, (col // 3) * 3 + idx % 3
|
||||
if self.board[box_row][box_col] == str(target):
|
||||
return False
|
||||
return True
|
||||
|
||||
def getPlace(self) -> List[int]:
|
||||
for row in range(len(self.board)):
|
||||
for col in range(len(self.board)):
|
||||
if self.board[row][col] == ".":
|
||||
return [row, col]
|
||||
return [-1, -1]
|
||||
|
||||
def isSolved(self) -> bool:
|
||||
row, col = self.getPlace() # 找个空位置
|
||||
|
||||
if row == -1 and col == -1: # 没有空位置，棋盘被填满的
|
||||
return True
|
||||
|
||||
for i in range(1, 10):
|
||||
if self.isValid(row, col, i): # 检查这个空位置放i，是否合适
|
||||
self.board[row][col] = str(i) # 放i
|
||||
if self.isSolved(): # 合适，立刻返回, 填下一个空位置。
|
||||
return True
|
||||
self.board[row][col] = "." # 不合适，回溯
|
||||
|
||||
return False # 空位置没法解决
|
||||
|
||||
def solveSudoku(self, board: List[List[str]]) -> None:
|
||||
"""
|
||||
Do not return anything, modify board in-place instead.
|
||||
"""
|
||||
if board is None or len(board) == 0:
|
||||
return
|
||||
self.board = board
|
||||
self.isSolved()
|
||||
```
|
||||
|
||||
Go：
|
||||
|
||||
Javascript:
|
||||
|
||||
@ -338,6 +338,46 @@ class Solution(object):
|
||||
return ans```
|
||||
```
|
||||
|
||||
```python3
|
||||
class Solution:
|
||||
def __init__(self) -> None:
|
||||
self.s = ""
|
||||
self.res = []
|
||||
|
||||
def isVaild(self, s: str) -> bool:
|
||||
if len(s) > 1 and s[0] == "0":
|
||||
return False
|
||||
|
||||
if 0 <= int(s) <= 255:
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
def backTrack(self, path: List[str], start: int) -> None:
|
||||
if start == len(self.s) and len(path) == 4:
|
||||
self.res.append(".".join(path))
|
||||
return
|
||||
|
||||
for end in range(start + 1, len(self.s) + 1):
|
||||
# 剪枝
|
||||
# 保证切割完，s没有剩余的字符。
|
||||
if len(self.s) - end > 3 * (4 - len(path) - 1):
|
||||
continue
|
||||
if self.isVaild(self.s[start:end]):
|
||||
# 在参数处，更新状态，实则创建一个新的变量
|
||||
# 不会影响当前的状态，当前的path变量没有改变
|
||||
# 因此递归完不用path.pop()
|
||||
self.backTrack(path + [self.s[start:end]], end)
|
||||
|
||||
def restoreIpAddresses(self, s: str) -> List[str]:
|
||||
# prune
|
||||
if len(s) > 3 * 4:
|
||||
return []
|
||||
self.s = s
|
||||
self.backTrack([], 0)
|
||||
return self.res
|
||||
```
|
||||
|
||||
JavaScript：
|
||||
|
||||
```js
|
||||
|
||||
@ -775,6 +775,20 @@ var buildTree = function(inorder, postorder) {
|
||||
};
|
||||
```
|
||||
|
||||
从前序与中序遍历序列构造二叉树
|
||||
|
||||
```javascript
|
||||
var buildTree = function(preorder, inorder) {
|
||||
if(!preorder.length)
|
||||
return null;
|
||||
let root = new TreeNode(preorder[0]);
|
||||
let mid = inorder.findIndex((number) => number === root.val);
|
||||
root.left = buildTree(preorder.slice(1, mid + 1), inorder.slice(0, mid));
|
||||
root.right = buildTree(preorder.slice(mid + 1, preorder.length), inorder.slice(mid + 1, inorder.length));
|
||||
return root;
|
||||
};
|
||||
```
|
||||
|
||||
-----------------------
|
||||
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
|
||||
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
|
||||
|
||||
@ -240,6 +240,25 @@ class Solution:
|
||||
```
|
||||
|
||||
Go：
|
||||
```go
|
||||
func canCompleteCircuit(gas []int, cost []int) int {
|
||||
curSum := 0
|
||||
totalSum := 0
|
||||
start := 0
|
||||
for i := 0; i < len(gas); i++ {
|
||||
curSum += gas[i] - cost[i]
|
||||
totalSum += gas[i] - cost[i]
|
||||
if curSum < 0 {
|
||||
start = i+1
|
||||
curSum = 0
|
||||
}
|
||||
}
|
||||
if totalSum < 0 {
|
||||
return -1
|
||||
}
|
||||
return start
|
||||
}
|
||||
```
|
||||
|
||||
Javascript:
|
||||
```Javascript
|
||||
|
||||
@ -301,6 +301,57 @@ class Solution {
|
||||
```
|
||||
|
||||
|
||||
```Python3
|
||||
class Solution:
|
||||
#1.去除多余的空格
|
||||
def trim_spaces(self,s):
|
||||
n=len(s)
|
||||
left=0
|
||||
right=n-1
|
||||
|
||||
while left<=right and s[left]==' ': #去除开头的空格
|
||||
left+=1
|
||||
while left<=right and s[right]==' ': #去除结尾的空格
|
||||
right=right-1
|
||||
tmp=[]
|
||||
while left<=right: #去除单词中间多余的空格
|
||||
if s[left]!=' ':
|
||||
tmp.append(s[left])
|
||||
elif tmp[-1]!=' ': #当前位置是空格，但是相邻的上一个位置不是空格，则该空格是合理的
|
||||
tmp.append(s[left])
|
||||
left+=1
|
||||
return tmp
|
||||
#2.翻转字符数组
|
||||
def reverse_string(self,nums,left,right):
|
||||
while left<right:
|
||||
nums[left], nums[right]=nums[right],nums[left]
|
||||
left+=1
|
||||
right-=1
|
||||
return None
|
||||
#3.翻转每个单词
|
||||
def reverse_each_word(self, nums):
|
||||
start=0
|
||||
end=0
|
||||
n=len(nums)
|
||||
while start<n:
|
||||
while end<n and nums[end]!=' ':
|
||||
end+=1
|
||||
self.reverse_string(nums,start,end-1)
|
||||
start=end+1
|
||||
end+=1
|
||||
return None
|
||||
|
||||
#4.翻转字符串里的单词
|
||||
def reverseWords(self, s): #测试用例："the sky is blue"
|
||||
l = self.trim_spaces(s) #输出：['t', 'h', 'e', ' ', 's', 'k', 'y', ' ', 'i', 's', ' ', 'b', 'l', 'u', 'e'
|
||||
self.reverse_string( l, 0, len(l) - 1) #输出：['e', 'u', 'l', 'b', ' ', 's', 'i', ' ', 'y', 'k', 's', ' ', 'e', 'h', 't']
|
||||
self.reverse_each_word(l) #输出：['b', 'l', 'u', 'e', ' ', 'i', 's', ' ', 's', 'k', 'y', ' ', 't', 'h', 'e']
|
||||
return ''.join(l) #输出：blue is sky the
|
||||
|
||||
|
||||
'''
|
||||
|
||||
|
||||
Go：
|
||||
|
||||
```go
|
||||
|
||||
@ -109,7 +109,7 @@ public:
|
||||
};
|
||||
```
|
||||
|
||||
时间复杂度：$O(n)$
|
||||
时间复杂度：$O(n)$
|
||||
空间复杂度：$O(1)$
|
||||
|
||||
**一些录友会疑惑为什么时间复杂度是O(n)**。
|
||||
@ -118,8 +118,8 @@ public:
|
||||
|
||||
## 相关题目推荐
|
||||
|
||||
* 904.水果成篮
|
||||
* 76.最小覆盖子串
|
||||
* [904.水果成篮](https://leetcode-cn.com/problems/fruit-into-baskets/)
|
||||
* [76.最小覆盖子串](https://leetcode-cn.com/problems/minimum-window-substring/)
|
||||
|
||||
|
||||
|
||||
|
||||
@ -265,6 +265,54 @@ class Solution:
|
||||
else: return root
|
||||
```
|
||||
Go：
|
||||
> BSL法
|
||||
|
||||
```go
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* type TreeNode struct {
|
||||
* Val int
|
||||
* Left *TreeNode
|
||||
* Right *TreeNode
|
||||
* }
|
||||
*/
|
||||
//利用BSL的性质（前序遍历有序）
|
||||
func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
|
||||
if root==nil{return nil}
|
||||
if root.Val>p.Val&&root.Val>q.Val{//当前节点的值大于给定的值，则说明满足条件的在左边
|
||||
return lowestCommonAncestor(root.Left,p,q)
|
||||
}else if root.Val<p.Val&&root.Val<q.Val{//当前节点的值小于各点的值，则说明满足条件的在右边
|
||||
return lowestCommonAncestor(root.Right,p,q)
|
||||
}else {return root}//当前节点的值在给定值的中间（或者等于），即为最深的祖先
|
||||
}
|
||||
```
|
||||
|
||||
> 普通法
|
||||
|
||||
```go
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* type TreeNode struct {
|
||||
* Val int
|
||||
* Left *TreeNode
|
||||
* Right *TreeNode
|
||||
* }
|
||||
*/
|
||||
//递归会将值层层返回
|
||||
func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
|
||||
//终止条件
|
||||
if root==nil||root.Val==p.Val||root.Val==q.Val{return root}//最后为空或者找到一个值时，就返回这个值
|
||||
//后序遍历
|
||||
findLeft:=lowestCommonAncestor(root.Left,p,q)
|
||||
findRight:=lowestCommonAncestor(root.Right,p,q)
|
||||
//处理单层逻辑
|
||||
if findLeft!=nil&&findRight!=nil{return root}//说明在root节点的两边
|
||||
if findLeft==nil{//左边没找到，就说明在右边找到了
|
||||
return findRight
|
||||
}else {return findLeft}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -228,7 +228,27 @@ class Solution:
|
||||
|
||||
Go：
|
||||
|
||||
Javascript:
|
||||
```Javascript
|
||||
var eraseOverlapIntervals = function(intervals) {
|
||||
intervals.sort((a, b) => {
|
||||
return a[1] - b[1]
|
||||
})
|
||||
|
||||
let count = 1
|
||||
let end = intervals[0][1]
|
||||
|
||||
for(let i = 1; i < intervals.length; i++) {
|
||||
let interval = intervals[i]
|
||||
if(interval[0] >= right) {
|
||||
end = interval[1]
|
||||
count += 1
|
||||
}
|
||||
}
|
||||
|
||||
return intervals.length - count
|
||||
};
|
||||
```
|
||||
|
||||
|
||||
-----------------------
|
||||
|
||||
@ -428,7 +428,100 @@ class Solution:
|
||||
return self.res
|
||||
```
|
||||
Go：
|
||||
暴力法（非BSL）
|
||||
|
||||
```go
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* type TreeNode struct {
|
||||
* Val int
|
||||
* Left *TreeNode
|
||||
* Right *TreeNode
|
||||
* }
|
||||
*/
|
||||
func findMode(root *TreeNode) []int {
|
||||
var history map[int]int
|
||||
var maxValue int
|
||||
var maxIndex int
|
||||
var result []int
|
||||
history=make(map[int]int)
|
||||
traversal(root,history)
|
||||
for k,value:=range history{
|
||||
if value>maxValue{
|
||||
maxValue=value
|
||||
maxIndex=k
|
||||
}
|
||||
}
|
||||
for k,value:=range history{
|
||||
if value==history[maxIndex]{
|
||||
result=append(result,k)
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
func traversal(root *TreeNode,history map[int]int){
|
||||
if root.Left!=nil{
|
||||
traversal(root.Left,history)
|
||||
}
|
||||
if value,ok:=history[root.Val];ok{
|
||||
history[root.Val]=value+1
|
||||
}else{
|
||||
history[root.Val]=1
|
||||
}
|
||||
if root.Right!=nil{
|
||||
traversal(root.Right,history)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
计数法BSL（此代码在执行代码里能执行，但提交后报错，不知为何，思路是对的）
|
||||
|
||||
```go
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* type TreeNode struct {
|
||||
* Val int
|
||||
* Left *TreeNode
|
||||
* Right *TreeNode
|
||||
* }
|
||||
*/
|
||||
var count,maxCount int //统计计数
|
||||
func findMode(root *TreeNode) []int {
|
||||
var result []int
|
||||
var pre *TreeNode //前指针
|
||||
if root.Left==nil&&root.Right==nil{
|
||||
result=append(result,root.Val)
|
||||
return result
|
||||
}
|
||||
traversal(root,&result,pre)
|
||||
return result
|
||||
}
|
||||
func traversal(root *TreeNode,result *[]int,pre *TreeNode){//遍历统计
|
||||
//如果BSL中序遍历相邻的两个节点值相同，则统计频率；如果不相同，依据BSL中序遍历排好序的性质，重新计数
|
||||
if pre==nil{
|
||||
count=1
|
||||
}else if pre.Val==root.Val{
|
||||
count++
|
||||
}else {
|
||||
count=1
|
||||
}
|
||||
//如果统计的频率等于最大频率，则加入结果集；如果统计的频率大于最大频率，更新最大频率且重新将结果加入新的结果集中
|
||||
if count==maxCount{
|
||||
*result=append(*result,root.Val)
|
||||
}else if count>maxCount{
|
||||
maxCount=count//重新赋值maxCount
|
||||
*result=[]int{}//清空result中的内容
|
||||
*result=append(*result,root.Val)
|
||||
}
|
||||
pre=root//保存上一个的节点
|
||||
if root.Left!=nil{
|
||||
traversal(root.Left,result,pre)
|
||||
}
|
||||
if root.Right!=nil{
|
||||
traversal(root.Right,result,pre)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
@ -103,6 +103,7 @@ public:
|
||||
|
||||
Java：
|
||||
```Java
|
||||
//解法一
|
||||
class Solution {
|
||||
public String reverseStr(String s, int k) {
|
||||
StringBuffer res = new StringBuffer();
|
||||
@ -128,6 +129,28 @@ class Solution {
|
||||
return res.toString();
|
||||
}
|
||||
}
|
||||
|
||||
//解法二（似乎更容易理解点）
|
||||
//题目的意思其实概括为 每隔2k个反转前k个，尾数不够k个时候全部反转
|
||||
class Solution {
|
||||
public String reverseStr(String s, int k) {
|
||||
char[] ch = s.toCharArray();
|
||||
for(int i = 0; i < ch.length; i += 2 * k){
|
||||
int start = i;
|
||||
//这里是判断尾数够不够k个来取决end指针的位置
|
||||
int end = Math.min(ch.length - 1, start + k - 1);
|
||||
//用异或运算反转
|
||||
while(start < end){
|
||||
ch[start] ^= ch[end];
|
||||
ch[end] ^= ch[start];
|
||||
ch[start] ^= ch[end];
|
||||
start++;
|
||||
end--;
|
||||
}
|
||||
}
|
||||
return new String(ch);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Python：
|
||||
|
||||
@ -311,6 +311,42 @@ func findMax(nums []int) (index int){
|
||||
}
|
||||
```
|
||||
|
||||
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 constructMaximumBinaryTree = function (nums) {
|
||||
const BuildTree = (arr, left, right) => {
|
||||
if (left > right)
|
||||
return null;
|
||||
let maxValue = -1;
|
||||
let maxIndex = -1;
|
||||
for (let i = left; i <= right; ++i) {
|
||||
if (arr[i] > maxValue) {
|
||||
maxValue = arr[i];
|
||||
maxIndex = i;
|
||||
}
|
||||
}
|
||||
let root = new TreeNode(maxValue);
|
||||
root.left = BuildTree(arr, left, maxIndex - 1);
|
||||
root.right = BuildTree(arr, maxIndex + 1, right);
|
||||
return root;
|
||||
}
|
||||
let root = BuildTree(nums, 0, nums.length - 1);
|
||||
return root;
|
||||
};
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
@ -128,7 +128,26 @@ class Solution:
|
||||
|
||||
Go：
|
||||
|
||||
|
||||
Javascript:
|
||||
```Javascript
|
||||
var partitionLabels = function(s) {
|
||||
let hash = {}
|
||||
for(let i = 0; i < s.length; i++) {
|
||||
hash[s[i]] = i
|
||||
}
|
||||
let result = []
|
||||
let left = 0
|
||||
let right = 0
|
||||
for(let i = 0; i < s.length; i++) {
|
||||
right = Math.max(right, hash[s[i]])
|
||||
if(right === i) {
|
||||
result.push(right - left + 1)
|
||||
left = i + 1
|
||||
}
|
||||
}
|
||||
return result
|
||||
};
|
||||
```
|
||||
|
||||
|
||||
-----------------------
|
||||
|
||||
@ -138,6 +138,30 @@ class Solution:
|
||||
```
|
||||
|
||||
Go：
|
||||
```Go
|
||||
func largestSumAfterKNegations(nums []int, K int) int {
|
||||
sort.Slice(nums, func(i, j int) bool {
|
||||
return math.Abs(float64(nums[i])) > math.Abs(float64(nums[j]))
|
||||
})
|
||||
|
||||
for i := 0; i < len(nums); i++ {
|
||||
if K > 0 && nums[i] < 0 {
|
||||
nums[i] = -nums[i]
|
||||
K--
|
||||
}
|
||||
}
|
||||
|
||||
if K%2 == 1 {
|
||||
nums[len(nums)-1] = -nums[len(nums)-1]
|
||||
}
|
||||
|
||||
result := 0
|
||||
for i := 0; i < len(nums); i++ {
|
||||
result += nums[i]
|
||||
}
|
||||
return result
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
Javascript:
|
||||
|
||||
@ -221,12 +221,12 @@ class Solution:
|
||||
Go：
|
||||
|
||||
前序遍历:
|
||||
```
|
||||
```go
|
||||
func PreorderTraversal(root *TreeNode) (res []int) {
|
||||
var traversal func(node *TreeNode)
|
||||
traversal = func(node *TreeNode) {
|
||||
if node == nil {
|
||||
return
|
||||
return
|
||||
}
|
||||
res = append(res,node.Val)
|
||||
traversal(node.Left)
|
||||
@ -239,12 +239,12 @@ func PreorderTraversal(root *TreeNode) (res []int) {
|
||||
```
|
||||
中序遍历:
|
||||
|
||||
```
|
||||
```go
|
||||
func InorderTraversal(root *TreeNode) (res []int) {
|
||||
var traversal func(node *TreeNode)
|
||||
traversal = func(node *TreeNode) {
|
||||
if node == nil {
|
||||
return
|
||||
return
|
||||
}
|
||||
traversal(node.Left)
|
||||
res = append(res,node.Val)
|
||||
@ -256,12 +256,12 @@ func InorderTraversal(root *TreeNode) (res []int) {
|
||||
```
|
||||
后序遍历:
|
||||
|
||||
```
|
||||
```go
|
||||
func PostorderTraversal(root *TreeNode) (res []int) {
|
||||
var traversal func(node *TreeNode)
|
||||
traversal = func(node *TreeNode) {
|
||||
if node == nil {
|
||||
return
|
||||
return
|
||||
}
|
||||
traversal(node.Left)
|
||||
traversal(node.Right)
|
||||
|
||||
@ -5,6 +5,7 @@
|
||||
<a href="https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ"><img src="https://img.shields.io/badge/知识星球-代码随想录-blue" alt=""></a>
|
||||
</p>
|
||||
<p align="center"><strong>欢迎大家<a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
|
||||
|
||||
# 动态规划：关于01背包问题，你该了解这些！（滚动数组）
|
||||
|
||||
昨天[动态规划：关于01背包问题，你该了解这些！](https://mp.weixin.qq.com/s/FwIiPPmR18_AJO5eiidT6w)中是用二维dp数组来讲解01背包。
|
||||
@ -35,7 +36,7 @@
|
||||
|
||||
**其实可以发现如果把dp[i - 1]那一层拷贝到dp[i]上，表达式完全可以是：dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);**
|
||||
|
||||
**于其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了**，只用dp[j]（一维数组，也可以理解是一个滚动数组）。
|
||||
**与其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了**，只用dp[j]（一维数组，也可以理解是一个滚动数组）。
|
||||
|
||||
这就是滚动数组的由来，需要满足的条件是上一层可以重复利用，直接拷贝到当前层。
|
||||
|
||||
@ -214,7 +215,7 @@ int main() {
|
||||
Java：
|
||||
|
||||
```java
|
||||
public static void main(String[] args) {
|
||||
public static void main(String[] args) {
|
||||
int[] weight = {1, 3, 4};
|
||||
int[] value = {15, 20, 30};
|
||||
int bagWight = 4;
|
||||
@ -242,7 +243,24 @@ Java：
|
||||
|
||||
|
||||
Python：
|
||||
```python
|
||||
def test_1_wei_bag_problem():
|
||||
weight = [1, 3, 4]
|
||||
value = [15, 20, 30]
|
||||
bag_weight = 4
|
||||
# 初始化: 全为0
|
||||
dp = [0] * (bag_weight + 1)
|
||||
|
||||
# 先遍历物品, 再遍历背包容量
|
||||
for i in range(len(weight)):
|
||||
for j in range(bag_weight, weight[i] - 1, -1):
|
||||
# 递归公式
|
||||
dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
|
||||
|
||||
print(dp)
|
||||
|
||||
test_1_wei_bag_problem()
|
||||
```
|
||||
|
||||
Go：
|
||||
```go
|
||||
|
||||
Reference in New Issue
Block a user