Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit a3a3f43

Browse files
Update
2 parents ff8b3e9 + 029e771 commit a3a3f43

File tree

52 files changed

+1376
-92
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

52 files changed

+1376
-92
lines changed

‎problems/0020.有效的括号.md

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -402,6 +402,38 @@ bool isValid(char * s){
402402
```
403403
404404
405+
C#:
406+
```csharp
407+
public class Solution {
408+
public bool IsValid(string s) {
409+
var len = s.Length;
410+
if(len % 2 == 1) return false; // 字符串长度为单数,直接返回 false
411+
// 初始化栈
412+
var stack = new Stack<char>();
413+
// 遍历字符串
414+
for(int i = 0; i < len; i++){
415+
// 当字符串为左括号时,进栈对应的右括号
416+
if(s[i] == '('){
417+
stack.Push(')');
418+
}else if(s[i] == '['){
419+
stack.Push(']');
420+
}else if(s[i] == '{'){
421+
stack.Push('}');
422+
}
423+
// 当字符串为右括号时,当栈为空(无左括号) 或者 出栈字符不是当前的字符
424+
else if(stack.Count == 0 || stack.Pop() != s[i])
425+
return false;
426+
}
427+
// 如果栈不为空,例如"((()",右括号少于左括号,返回false
428+
if (stack.Count > 0)
429+
return false;
430+
// 上面的校验都满足,则返回true
431+
else
432+
return true;
433+
}
434+
}
435+
```
436+
405437
PHP:
406438
```php
407439
// https://www.php.net/manual/zh/class.splstack.php

‎problems/0031.下一个排列.md

Lines changed: 44 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -116,6 +116,48 @@ class Solution {
116116
}
117117
}
118118
```
119+
> 优化时间复杂度为O(N),空间复杂度为O(1)
120+
```Java
121+
class Solution {
122+
public void nextPermutation(int[] nums) {
123+
// 1.从后向前获取逆序区域的前一位
124+
int index = findIndex(nums);
125+
// 判断数组是否处于最小组合状态
126+
if(index != 0){
127+
// 2.交换逆序区域刚好大于它的最小数字
128+
exchange(nums,index);
129+
}
130+
// 3.把原来的逆序区转为顺序
131+
reverse(nums,index);
132+
}
133+
134+
public static int findIndex(int [] nums){
135+
for(int i = nums.length-1;i>0;i--){
136+
if(nums[i]>nums[i-1]){
137+
return i;
138+
}
139+
}
140+
return 0;
141+
}
142+
public static void exchange(int [] nums, int index){
143+
int head = nums[index-1];
144+
for(int i = nums.length-1;i>0;i--){
145+
if(head < nums[i]){
146+
nums[index-1] = nums[i];
147+
nums[i] = head;
148+
break;
149+
}
150+
}
151+
}
152+
public static void reverse(int [] nums, int index){
153+
for(int i = index,j = nums.length-1;i<j;i++,j--){
154+
int temp = nums[i];
155+
nums[i] = nums[j];
156+
nums[j] = temp;
157+
}
158+
}
159+
}
160+
```
119161
120162
## Python
121163
>直接使用sorted()不符合题意
@@ -164,7 +206,7 @@ class Solution:
164206
high -= 1
165207
```
166208
>上一版本简化版
167-
'''python
209+
```python
168210
class Solution(object):
169211
def nextPermutation(self, nums: List[int]) -> None:
170212
n = len(nums)
@@ -185,7 +227,7 @@ class Solution(object):
185227
end -= 1
186228
187229
return nums
188-
'''
230+
```
189231

190232
## Go
191233

‎problems/0035.搜索插入位置.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -142,7 +142,7 @@ public:
142142
```
143143

144144
* 时间复杂度:O(log n)
145-
* 时间复杂度:O(1)
145+
* 空间复杂度:O(1)
146146

147147
效率如下:
148148
![35_搜索插入位置2](https://img-blog.csdnimg.cn/2020121623272877.png)

‎problems/0039.组合总和.md

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -417,6 +417,35 @@ function combinationSum(candidates: number[], target: number): number[][] {
417417
};
418418
```
419419

420+
## Rust
421+
422+
```Rust
423+
impl Solution {
424+
pub fn backtracking(result: &mut Vec<Vec<i32>>, path: &mut Vec<i32>, candidates: &Vec<i32>, target: i32, mut sum: i32, start_index: usize) {
425+
if sum == target {
426+
result.push(path.to_vec());
427+
return;
428+
}
429+
for i in start_index..candidates.len() {
430+
if sum + candidates[i] <= target {
431+
sum += candidates[i];
432+
path.push(candidates[i]);
433+
Self::backtracking(result, path, candidates, target, sum, i);
434+
sum -= candidates[i];
435+
path.pop();
436+
}
437+
}
438+
}
439+
440+
pub fn combination_sum(candidates: Vec<i32>, target: i32) -> Vec<Vec<i32>> {
441+
let mut result: Vec<Vec<i32>> = Vec::new();
442+
let mut path: Vec<i32> = Vec::new();
443+
Self::backtracking(&mut result, &mut path, &candidates, target, 0, 0);
444+
result
445+
}
446+
}
447+
```
448+
420449
## C
421450

422451
```c

‎problems/0040.组合总和II.md

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -599,6 +599,41 @@ function combinationSum2(candidates: number[], target: number): number[][] {
599599
};
600600
```
601601

602+
## Rust
603+
604+
```Rust
605+
impl Solution {
606+
pub fn backtracking(result: &mut Vec<Vec<i32>>, path: &mut Vec<i32>, candidates: &Vec<i32>, target: i32, mut sum: i32, start_index: usize, used: &mut Vec<bool>) {
607+
if sum == target {
608+
result.push(path.to_vec());
609+
return;
610+
}
611+
for i in start_index..candidates.len() {
612+
if sum + candidates[i] <= target {
613+
if i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false { continue; }
614+
sum += candidates[i];
615+
path.push(candidates[i]);
616+
used[i] = true;
617+
Self::backtracking(result, path, candidates, target, sum, i + 1, used);
618+
used[i] = false;
619+
sum -= candidates[i];
620+
path.pop();
621+
}
622+
}
623+
}
624+
625+
pub fn combination_sum2(candidates: Vec<i32>, target: i32) -> Vec<Vec<i32>> {
626+
let mut result: Vec<Vec<i32>> = Vec::new();
627+
let mut path: Vec<i32> = Vec::new();
628+
let mut used: Vec<bool> = vec![false; candidates.len()];
629+
let mut candidates = candidates;
630+
candidates.sort();
631+
Self::backtracking(&mut result, &mut path, &candidates, target, 0, 0, &mut used);
632+
result
633+
}
634+
}
635+
```
636+
602637
## C
603638

604639
```c

‎problems/0056.合并区间.md

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -297,7 +297,37 @@ function merge(intervals: number[][]): number[][] {
297297
};
298298
```
299299

300+
### Scala
300301

302+
```scala
303+
object Solution {
304+
import scala.collection.mutable
305+
def merge(intervals: Array[Array[Int]]): Array[Array[Int]] = {
306+
var res = mutable.ArrayBuffer[Array[Int]]()
307+
308+
// 排序
309+
var interval = intervals.sortWith((a, b) => {
310+
a(0) < b(0)
311+
})
312+
313+
var left = interval(0)(0)
314+
var right = interval(0)(1)
315+
316+
for (i <- 1 until interval.length) {
317+
if (interval(i)(0) <= right) {
318+
left = math.min(left, interval(i)(0))
319+
right = math.max(right, interval(i)(1))
320+
} else {
321+
res.append(Array[Int](left, right))
322+
left = interval(i)(0)
323+
right = interval(i)(1)
324+
}
325+
}
326+
res.append(Array[Int](left, right))
327+
res.toArray // 返回res的Array形式
328+
}
329+
}
330+
```
301331

302332
-----------------------
303333
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

‎problems/0059.螺旋矩阵II.md

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -598,5 +598,30 @@ object Solution {
598598
}
599599
}
600600
```
601+
C#:
602+
```csharp
603+
public class Solution {
604+
public int[][] GenerateMatrix(int n) {
605+
int[][] answer = new int[n][];
606+
for(int i = 0; i < n; i++)
607+
answer[i] = new int[n];
608+
int start = 0;
609+
int end = n - 1;
610+
int tmp = 1;
611+
while(tmp < n * n)
612+
{
613+
for(int i = start; i < end; i++) answer[start][i] = tmp++;
614+
for(int i = start; i < end; i++) answer[i][end] = tmp++;
615+
for(int i = end; i > start; i--) answer[end][i] = tmp++;
616+
for(int i = end; i > start; i--) answer[i][start] = tmp++;
617+
start++;
618+
end--;
619+
}
620+
if(n % 2 == 1) answer[n / 2][n / 2] = tmp;
621+
return answer;
622+
}
623+
}
624+
```
625+
601626
-----------------------
602627
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

‎problems/0062.不同路径.md

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -436,5 +436,21 @@ int uniquePaths(int m, int n){
436436
}
437437
```
438438
439+
### Scala
440+
441+
```scala
442+
object Solution {
443+
def uniquePaths(m: Int, n: Int): Int = {
444+
var dp = Array.ofDim[Int](m, n)
445+
for (i <- 0 until m) dp(i)(0) = 1
446+
for (j <- 1 until n) dp(0)(j) = 1
447+
for (i <- 1 until m; j <- 1 until n) {
448+
dp(i)(j) = dp(i - 1)(j) + dp(i)(j - 1)
449+
}
450+
dp(m - 1)(n - 1)
451+
}
452+
}
453+
```
454+
439455
-----------------------
440456
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

‎problems/0063.不同路径II.md

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -476,5 +476,37 @@ int uniquePathsWithObstacles(int** obstacleGrid, int obstacleGridSize, int* obst
476476
}
477477
```
478478
479+
### Scala
480+
481+
```scala
482+
object Solution {
483+
import scala.util.control.Breaks._
484+
def uniquePathsWithObstacles(obstacleGrid: Array[Array[Int]]): Int = {
485+
var (m, n) = (obstacleGrid.length, obstacleGrid(0).length)
486+
var dp = Array.ofDim[Int](m, n)
487+
488+
// 比如break、continue这些流程控制需要使用breakable
489+
breakable(
490+
for (i <- 0 until m) {
491+
if (obstacleGrid(i)(0) != 1) dp(i)(0) = 1
492+
else break()
493+
}
494+
)
495+
breakable(
496+
for (j <- 0 until n) {
497+
if (obstacleGrid(0)(j) != 1) dp(0)(j) = 1
498+
else break()
499+
}
500+
)
501+
502+
for (i <- 1 until m; j <- 1 until n; if obstacleGrid(i)(j) != 1) {
503+
dp(i)(j) = dp(i - 1)(j) + dp(i)(j - 1)
504+
}
505+
506+
dp(m - 1)(n - 1)
507+
}
508+
}
509+
```
510+
479511
-----------------------
480512
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

‎problems/0070.爬楼梯.md

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -401,6 +401,38 @@ int climbStairs(int n){
401401
}
402402
```
403403

404+
### Scala
405+
406+
```scala
407+
object Solution {
408+
def climbStairs(n: Int): Int = {
409+
if (n <= 2) return n
410+
var dp = new Array[Int](n + 1)
411+
dp(1) = 1
412+
dp(2) = 2
413+
for (i <- 3 to n) {
414+
dp(i) = dp(i - 1) + dp(i - 2)
415+
}
416+
dp(n)
417+
}
418+
}
419+
```
420+
421+
优化空间复杂度:
422+
```scala
423+
object Solution {
424+
def climbStairs(n: Int): Int = {
425+
if (n <= 2) return n
426+
var (a, b) = (1, 2)
427+
for (i <- 3 to n) {
428+
var tmp = a + b
429+
a = b
430+
b = tmp
431+
}
432+
b // 最终返回b
433+
}
434+
}
435+
```
404436

405437
-----------------------
406438
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /