Skip to content

Commit 1f20821

Browse files
javadevjavadev
committed
Improved tasks
1 parent 6eac515 commit 1f20821

File tree

4 files changed

+79
-97
lines changed

4 files changed

+79
-97
lines changed

‎src/main/java/g3401_3500/s3417_zigzag_grid_traversal_with_skip/Solution.java

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
package g3401_3500.s3417_zigzag_grid_traversal_with_skip;
22

3-
// #Easy #2025_01_12_Time_1_(100.00%)_Space_45.64_(_%)
3+
// #Easy #2025_01_14_Time_1_(100.00%)_Space_45.81_(35.36%)
44

55
import java.util.ArrayList;
66
import java.util.List;

‎src/main/java/g3401_3500/s3418_maximum_amount_of_money_robot_can_earn/Solution.java

Lines changed: 43 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -1,54 +1,56 @@
11
package g3401_3500.s3418_maximum_amount_of_money_robot_can_earn;
22

3-
// #Medium #2025_01_12_Time_156_(_%)_Space_79.73_(_%)
4-
5-
import java.util.Arrays;
3+
// #Medium #2025_01_14_Time_12_(99.87%)_Space_71.91_(98.93%)
64

75
public class Solution {
8-
private int solve(int[][] coins, int r, int c, int i, int j, int skip, int[][][] dp) {
9-
if (i == r - 1 && j == c - 1) {
10-
if (coins[i][j] < 0 && skip > 0) {
11-
return 0;
12-
}
13-
return coins[i][j];
14-
} else if (dp[i][j][skip] != Integer.MIN_VALUE) {
15-
return dp[i][j][skip];
16-
}
17-
int val1 = Integer.MIN_VALUE;
18-
int val2 = Integer.MIN_VALUE;
19-
if (i < r - 1) {
20-
if (coins[i][j] < 0 && skip > 0) {
21-
val1 =
22-
Math.max(
23-
solve(coins, r, c, i + 1, j, skip - 1, dp),
24-
coins[i][j] + solve(coins, r, c, i + 1, j, skip, dp));
25-
} else {
26-
val1 = coins[i][j] + solve(coins, r, c, i + 1, j, skip, dp);
6+
public int maximumAmount(int[][] coins) {
7+
int m = coins.length;
8+
int n = coins[0].length;
9+
int[][] dp = new int[m][n];
10+
int[][] dp1 = new int[m][n];
11+
int[][] dp2 = new int[m][n];
12+
dp[0][0] = coins[0][0];
13+
for (int j = 1; j < n; j++) {
14+
dp[0][j] = dp[0][j - 1] + coins[0][j];
15+
}
16+
for (int i = 1; i < m; i++) {
17+
dp[i][0] = dp[i - 1][0] + coins[i][0];
18+
}
19+
for (int i = 1; i < m; i++) {
20+
for (int j = 1; j < n; j++) {
21+
dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]) + coins[i][j];
2722
}
2823
}
29-
if (j < c - 1) {
30-
if (coins[i][j] < 0 && skip > 0) {
31-
val2 =
24+
dp1[0][0] = Math.max(coins[0][0], 0);
25+
for (int j = 1; j < n; j++) {
26+
dp1[0][j] = Math.max(dp[0][j - 1], dp1[0][j - 1] + coins[0][j]);
27+
}
28+
for (int i = 1; i < m; i++) {
29+
dp1[i][0] = Math.max(dp[i - 1][0], dp1[i - 1][0] + coins[i][0]);
30+
}
31+
for (int i = 1; i < m; i++) {
32+
for (int j = 1; j < n; j++) {
33+
dp1[i][j] =
3234
Math.max(
33-
solve(coins, r, c, i, j + 1, skip - 1, dp),
34-
coins[i][j] + solve(coins, r, c, i, j + 1, skip, dp));
35-
} else {
36-
val2 = coins[i][j] + solve(coins, r, c, i, j + 1, skip, dp);
35+
Math.max(dp[i][j - 1], dp[i - 1][j]),
36+
Math.max(dp1[i][j - 1], dp1[i - 1][j]) + coins[i][j]);
3737
}
3838
}
39-
40-
return dp[i][j][skip] = Math.max(val1, val2);
41-
}
42-
43-
public int maximumAmount(int[][] coins) {
44-
int r = coins.length;
45-
int c = coins[0].length;
46-
int[][][] dp = new int[r][c][3];
47-
for (int[][] arr1 : dp) {
48-
for (int[] arr2 : arr1) {
49-
Arrays.fill(arr2, Integer.MIN_VALUE);
39+
dp2[0][0] = Math.max(coins[0][0], 0);
40+
for (int j = 1; j < n; j++) {
41+
dp2[0][j] = Math.max(dp1[0][j - 1], dp2[0][j - 1] + coins[0][j]);
42+
}
43+
for (int i = 1; i < m; i++) {
44+
dp2[i][0] = Math.max(dp1[i - 1][0], dp2[i - 1][0] + coins[i][0]);
45+
}
46+
for (int i = 1; i < m; i++) {
47+
for (int j = 1; j < n; j++) {
48+
dp2[i][j] =
49+
Math.max(
50+
Math.max(dp1[i][j - 1], dp1[i - 1][j]),
51+
Math.max(dp2[i][j - 1], dp2[i - 1][j]) + coins[i][j]);
5052
}
5153
}
52-
return solve(coins, r, c, 0, 0, 2, dp);
54+
return dp2[m - 1][n - 1];
5355
}
5456
}

‎src/main/java/g3401_3500/s3419_minimize_the_maximum_edge_weight_of_graph/Solution.java

Lines changed: 34 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -1,74 +1,54 @@
11
package g3401_3500.s3419_minimize_the_maximum_edge_weight_of_graph;
22

3-
// #Medium #2025_01_12_Time_1014_(100.00%)_Space_114.21_(100.00%)
3+
// #Medium #2025_01_14_Time_51_(99.43%)_Space_119.08_(34.00%)
44

5+
import java.util.Arrays;
56
import java.util.ArrayList;
67
import java.util.LinkedList;
78
import java.util.List;
89
import java.util.Queue;
910

10-
@SuppressWarnings({"unused", "java:S1172"})
11+
@SuppressWarnings("unchecked")
1112
public class Solution {
1213
public int minMaxWeight(int n, int[][] edges, int threshold) {
13-
int minW = Integer.MAX_VALUE;
14-
int maxW = 0;
15-
for (int[] e : edges) {
16-
minW = Math.min(minW, e[2]);
17-
maxW = Math.max(maxW, e[2]);
18-
}
19-
int ans = -1;
20-
int l = minW;
21-
int h = maxW;
22-
while (l <= h) {
23-
int mid = (l + h) >> 1;
24-
if (find(n, edges, mid)) {
25-
ans = mid;
26-
h = mid - 1;
27-
} else {
28-
l = mid + 1;
29-
}
30-
}
31-
return ans;
32-
}
33-
34-
private boolean find(int n, int[][] edges, int maxi) {
35-
List<List<Integer>> adj = new ArrayList<>();
14+
List<int[]>[] graph = new ArrayList[n];
15+
List<int[]>[] reversedG = new ArrayList[n];
3616
for (int i = 0; i < n; i++) {
37-
adj.add(new ArrayList<>());
17+
reversedG[i] = new ArrayList<>();
3818
}
39-
for (int[] e : edges) {
40-
if (e[2] <= maxi) {
41-
adj.get(e[0]).add(e[1]);
42-
}
19+
for (int[] i : edges) {
20+
int a = i[0];
21+
int b = i[1];
22+
int w = i[2];
23+
reversedG[b].add(new int[] {a, w});
4324
}
44-
return zero(n, adj);
45-
}
46-
47-
public boolean zero(int n, List<List<Integer>> adj) {
48-
List<List<Integer>> rev = new ArrayList<>();
49-
for (int i = 0; i < n; i++) {
50-
rev.add(new ArrayList<>());
25+
int[] distance = new int[n];
26+
Arrays.fill(distance, Integer.MAX_VALUE);
27+
distance[0] = 0;
28+
if (reversedG[0].size() == 0) {
29+
return -1;
5130
}
52-
for (int i = 0; i < n; i++) {
53-
for (int nb : adj.get(i)) {
54-
rev.get(nb).add(i);
31+
Queue<Integer> que = new LinkedList<>();
32+
que.add(0);
33+
while (!que.isEmpty()) {
34+
int cur = que.poll();
35+
for (int[] next : reversedG[cur]) {
36+
int node = next[0];
37+
int w = next[1];
38+
int nextdis = Math.max(w, distance[cur]);
39+
if (nextdis < distance[node]) {
40+
distance[node] = nextdis;
41+
que.add(node);
42+
}
5543
}
5644
}
57-
boolean[] vis = new boolean[n];
58-
Queue<Integer> q = new LinkedList<>();
59-
q.add(0);
60-
int cnt = 1;
61-
vis[0] = true;
62-
while (!q.isEmpty()) {
63-
int curr = q.poll();
64-
for (int nb : rev.get(curr)) {
65-
if (!vis[nb]) {
66-
vis[nb] = true;
67-
q.add(nb);
68-
cnt++;
69-
}
45+
int ans = 0;
46+
for (int i = 0; i < n; i++) {
47+
if (distance[i] == Integer.MAX_VALUE) {
48+
return -1;
7049
}
50+
ans = Math.max(ans, distance[i]);
7151
}
72-
return cnt == n;
52+
return ans;
7353
}
7454
}

‎src/main/java/g3401_3500/s3420_count_non_decreasing_subarrays_after_k_operations/Solution.java

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
package g3401_3500.s3420_count_non_decreasing_subarrays_after_k_operations;
22

3-
// #Hard #2025_01_12_Time_31_(100.00%)_Space_62.21_(100.00%)
3+
// #Hard #2025_01_14_Time_29_(92.59%)_Space_62.14_(57.41%)
44

55
import java.util.ArrayDeque;
66
import java.util.Deque;

0 commit comments

Comments
 (0)