Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

feat: add solutions to lc problem: No.1909 #3969

Merged
merged 1 commit into from
Jan 18, 2025
Merged

feat: add solutions to lc problem: No.1909 #3969

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
191 changes: 114 additions & 77 deletions ...00-1999/1909.Remove One Element to Make the Array Strictly Increasing/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -73,7 +73,11 @@ tags:

<!-- solution:start -->

### 方法一
### 方法一：遍历

我们可以遍历数组，找到第一个不满足 $\textit{nums}[i] < \textit{nums}[i+1]$ 的位置 $i$，然后检查删除 $i$ 或者 $i+1$ 后的数组是否严格递增，如果是则返回 $\textit{true}$，否则返回 $\textit{false}$。

时间复杂度 $O(n)$，其中 $n$ 是数组 $\textit{nums}$ 的长度。空间复杂度 $O(1)$。

<!-- tabs:start -->

Expand All @@ -82,43 +86,44 @@ tags:
```python
class Solution:
def canBeIncreasing(self, nums: List[int]) -> bool:
def check(nums, i):
prev = -inf
for j, num in enumerate(nums):
if i == j:
def check(k: int) -> bool:
pre = -inf
for i, x in enumerate(nums):
if i == k:
continue
if prev >= nums[j]:
if pre >= x:
return False
prev = nums[j]
pre = x
return True

i, n = 1, len(nums)
while i < n and nums[i - 1] < nums[i]:
i = 0
while i + 1 < len(nums) and nums[i] < nums[i + 1]:
i += 1
return check(nums, i - 1) or check(nums, i)
return check(i) or check(i + 1)
```

#### Java

```java
class Solution {
public boolean canBeIncreasing(int[] nums) {
int i = 1, n = nums.length;
for (; i < n && nums[i - 1] < nums[i]; ++i)
;
return check(nums, i - 1) || check(nums, i);
int i = 0;
while (i + 1 < nums.length && nums[i] < nums[i + 1]) {
++i;
}
return check(nums, i) || check(nums, i + 1);
}

private boolean check(int[] nums, int i) {
int prev = Integer.MIN_VALUE;
for (int j = 0; j < nums.length; ++j) {
if (i == j) {
private boolean check(int[] nums, int k) {
int pre = 0;
for (int i = 0; i < nums.length; ++i) {
if (i == k) {
continue;
}
if (prev >= nums[j]) {
if (pre >= nums[i]) {
return false;
}
prev = nums[j];
pre = nums[i];
}
return true;
}
Expand All @@ -131,20 +136,25 @@ class Solution {
class Solution {
public:
bool canBeIncreasing(vector<int>& nums) {
int i = 1, n = nums.size();
for (; i < n && nums[i - 1] < nums[i]; ++i)
;
return check(nums, i - 1) || check(nums, i);
}

bool check(vector<int>& nums, int i) {
int prev = 0;
for (int j = 0; j < nums.size(); ++j) {
if (i == j) continue;
if (prev >= nums[j]) return false;
prev = nums[j];
int n = nums.size();
auto check = [&](int k) -> bool {
int pre = 0;
for (int i = 0; i < n; ++i) {
if (i == k) {
continue;
}
if (pre >= nums[i]) {
return false;
}
pre = nums[i];
}
return true;
};
int i = 0;
while (i + 1 < n && nums[i] < nums[i + 1]) {
++i;
}
return true;
return check(i) || check(i + 1);
}
};
```
Expand All @@ -153,50 +163,50 @@ public:

```go
func canBeIncreasing(nums []int) bool {
i, n := 1, len(nums)
for ; i < n && nums[i-1] < nums[i]; i++ {

}
return check(nums, i-1) || check(nums, i)
}

func check(nums []int, i int) bool {
prev := 0
for j := 0; j < len(nums); j++ {
if i == j {
continue
}
if prev >= nums[j] {
return false
check := func(k int) bool {
pre := 0
for i, x := range nums {
if i == k {
continue
}
if pre >= x {
return false
}
pre = x
}
prev = nums[j]
return true
}
return true
i := 0
for i+1 < len(nums) && nums[i] < nums[i+1] {
i++
}
return check(i) || check(i+1)
}
```

#### TypeScript

```ts
function canBeIncreasing(nums: number[]): boolean {
const check = (p: number) => {
let prev = undefined;
for (let j = 0; j < nums.length; j++) {
if (p != j) {
if (prev !== undefined && prev >= nums[j]) {
return false;
}
prev = nums[j];
const n = nums.length;
const check = (k: number): boolean => {
let pre = 0;
for (let i = 0; i < n; ++i) {
if (i === k) {
continue;
}
if (pre >= nums[i]) {
return false;
}
pre = nums[i];
}
return true;
};
for (let i = 0; i < nums.length; i++) {
if (nums[i - 1] >= nums[i]) {
return check(i - 1) || check(i);
}
let i = 0;
while (i + 1 < n && nums[i] < nums[i + 1]) {
++i;
}
return true;
return check(i) || check(i + 1);
}
```

Expand All @@ -205,26 +215,53 @@ function canBeIncreasing(nums: number[]): boolean {
```rust
impl Solution {
pub fn can_be_increasing(nums: Vec<i32>) -> bool {
let check = |p: usize| -> bool {
let mut prev = None;
for j in 0..nums.len() {
if p != j {
if let Some(value) = prev {
if value >= nums[j] {
return false;
}
}
prev = Some(nums[j]);
let check = |k: usize| -> bool {
let mut pre = 0;
for (i, &x) in nums.iter().enumerate() {
if i == k {
continue;
}
if pre >= x {
return false;
}
pre = x;
}
true
};
for i in 1..nums.len() {
if nums[i - 1] >= nums[i] {
return check(i - 1) || check(i);

let mut i = 0;
while i + 1 < nums.len() && nums[i] < nums[i + 1] {
i += 1;
}
check(i) || check(i + 1)
}
}
```

#### C#

```cs
public class Solution {
public bool CanBeIncreasing(int[] nums) {
int n = nums.Length;
bool check(int k) {
int pre = 0;
for (int i = 0; i < n; ++i) {
if (i == k) {
continue;
}
if (pre >= nums[i]) {
return false;
}
pre = nums[i];
}
return true;
}
int i = 0;
while (i + 1 < n && nums[i] < nums[i + 1]) {
++i;
}
true
return check(i) || check(i + 1);
}
}
```
Expand Down
Loading
Loading