Skip to content

Commit 478dc6c

Browse files
javadevjavadev
authored
Improved tasks 1659, 3435
1 parent 4157c3e commit 478dc6c

File tree

3 files changed

+163
-137
lines changed
  • src

3 files changed

+163
-137
lines changed

‎src/main/java/g1601_1700/s1659_maximize_grid_happiness/Solution.java‎

Lines changed: 81 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -1,74 +1,96 @@
11
package g1601_1700.s1659_maximize_grid_happiness;
22

33
// #Hard #Dynamic_Programming #Bit_Manipulation #Bitmask #Memoization
4-
// #2022_04_23_Time_95_ms_(75.00%)_Space_53.1_MB_(58.33%)
4+
// #2025_04_04_Time_39_ms_(86.36%)_Space_54.76_MB_(72.73%)
55

6+
@SuppressWarnings("java:S107")
67
public class Solution {
7-
private int m;
8-
private int n;
9-
private int[][][][][] dp;
10-
private int notPlace = 0;
11-
private int intro = 1;
12-
private int extro = 2;
13-
private int mod;
8+
private static final int NONE = 0;
9+
private static final int INTROVERT = 1;
10+
private static final int EXTROVERT = 2;
1411

15-
public int getMaxGridHappiness(int m, int n, int introvertsCount, int extrovertsCount) {
16-
this.m = m;
17-
this.n = n;
18-
int numOfState = (int) Math.pow(3, n);
19-
this.dp = new int[m][n][introvertsCount + 1][extrovertsCount + 1][numOfState];
20-
this.mod = numOfState / 3;
21-
return dfs(0, 0, introvertsCount, extrovertsCount, 0);
22-
}
23-
24-
private int dfs(int x, int y, int ic, int ec, int state) {
25-
if (x == m) {
12+
private int maxHappiness(
13+
int index,
14+
int m,
15+
int n,
16+
int introverts,
17+
int extroverts,
18+
int board,
19+
int[][][][] dp,
20+
int tmask) {
21+
if (index >= m * n) {
2622
return 0;
27-
} else if (y == n) {
28-
return dfs(x + 1, 0, ic, ec, state);
2923
}
30-
if (dp[x][y][ic][ec][state] != 0) {
31-
return dp[x][y][ic][ec][state];
24+
if (dp[index][introverts][extroverts][board] != 0) {
25+
return dp[index][introverts][extroverts][board];
3226
}
33-
// 1 - not place
34-
int max = dfs(x, y + 1, ic, ec, (state % mod) * 3);
35-
int up = state / mod;
36-
int left = state % 3;
37-
// 2 - place intro
38-
if (ic > 0) {
39-
int temp = 120;
40-
if (x > 0 && up != notPlace) {
41-
temp -= 30;
42-
temp += up == intro ? -30 : 20;
43-
}
44-
if (y > 0 && left != notPlace) {
45-
temp -= 30;
46-
temp += left == intro ? -30 : 20;
47-
}
48-
int nextState = state;
49-
nextState %= mod;
50-
nextState *= 3;
51-
nextState += intro;
52-
max = Math.max(max, temp + dfs(x, y + 1, ic - 1, ec, nextState));
27+
int introScore = -1;
28+
int extroScore = -1;
29+
if (introverts > 0) {
30+
int newBoard = ((board << 2) | INTROVERT) & tmask;
31+
introScore =
32+
120
33+
+ adjust(board, INTROVERT, n, index)
34+
+ maxHappiness(
35+
index + 1,
36+
m,
37+
n,
38+
introverts - 1,
39+
extroverts,
40+
newBoard,
41+
dp,
42+
tmask);
43+
}
44+
if (extroverts > 0) {
45+
int newBoard = ((board << 2) | EXTROVERT) & tmask;
46+
extroScore =
47+
40
48+
+ adjust(board, EXTROVERT, n, index)
49+
+ maxHappiness(
50+
index + 1,
51+
m,
52+
n,
53+
introverts,
54+
extroverts - 1,
55+
newBoard,
56+
dp,
57+
tmask);
5358
}
54-
// 3 - place extro
55-
if (ec > 0) {
56-
int temp = 40;
57-
if (x > 0 && up != notPlace) {
58-
temp += 20;
59-
temp += up == intro ? -30 : 20;
59+
int newBoard = ((board << 2) | NONE) & tmask;
60+
int skip = maxHappiness(index + 1, m, n, introverts, extroverts, newBoard, dp, tmask);
61+
dp[index][introverts][extroverts][board] = Math.max(skip, Math.max(introScore, extroScore));
62+
return dp[index][introverts][extroverts][board];
63+
}
64+
65+
private int adjust(int board, int thisIs, int col, int index) {
66+
int shiftBy = 2 * (col - 1);
67+
int left = board & 0x03;
68+
if (index % col == 0) {
69+
left = NONE;
70+
}
71+
int up = (board >> shiftBy) & 0x03;
72+
int[] combination = new int[] {left, up};
73+
int adjustment = 0;
74+
for (int neighbor : combination) {
75+
if (neighbor == NONE) {
76+
continue;
6077
}
61-
if (y > 0 && left != notPlace) {
62-
temp += 20;
63-
temp += left == intro ? -30 : 20;
78+
if (neighbor == INTROVERT && thisIs == INTROVERT) {
79+
adjustment -= 60;
80+
} else if (neighbor == INTROVERT && thisIs == EXTROVERT) {
81+
adjustment -= 10;
82+
} else if (neighbor == EXTROVERT && thisIs == INTROVERT) {
83+
adjustment -= 10;
84+
} else if (neighbor == EXTROVERT && thisIs == EXTROVERT) {
85+
adjustment += 40;
6486
}
65-
int nextState = state;
66-
nextState %= mod;
67-
nextState *= 3;
68-
nextState += extro;
69-
max = Math.max(max, temp + dfs(x, y + 1, ic, ec - 1, nextState));
7087
}
71-
dp[x][y][ic][ec][state] = max;
72-
return max;
88+
return adjustment;
89+
}
90+
91+
public int getMaxGridHappiness(int m, int n, int introvertsCount, int extrovertsCount) {
92+
int[][][][] dp = new int[m * n][introvertsCount + 1][extrovertsCount + 1][(1 << (2 * n))];
93+
int tmask = (1 << (2 * n)) - 1;
94+
return maxHappiness(0, m, n, introvertsCount, extrovertsCount, 0, dp, tmask);
7395
}
7496
}

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

Lines changed: 80 additions & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -1,109 +1,113 @@
11
package g3401_3500.s3435_frequencies_of_shortest_supersequences;
22

33
// #Hard #Array #String #Bit_Manipulation #Graph #Enumeration #Topological_Sort
4-
// #2025_01_29_Time_16_ms_(95.35%)_Space_45.52_MB_(93.02%)
4+
// #2025_04_04_Time_20_ms_(97.26%)_Space_45.52_MB_(83.56%)
55

66
import java.util.ArrayList;
7-
import java.util.Arrays;
8-
import java.util.HashSet;
97
import java.util.List;
10-
import java.util.Set;
118

9+
@SuppressWarnings("unchecked")
1210
public class Solution {
13-
private int m;
14-
private int forcedMask;
15-
private int[] adj;
16-
private char[] idxToChar = new char[26];
17-
private int[] charToIdx = new int[26];
18-
private boolean[] used = new boolean[26];
11+
private int min = Integer.MAX_VALUE;
12+
private List<int[]> lists = new ArrayList<>();
1913

2014
public List<List<Integer>> supersequences(String[] words) {
21-
Arrays.fill(charToIdx, -1);
22-
for (String w : words) {
23-
used[w.charAt(0) - 'a'] = true;
24-
used[w.charAt(1) - 'a'] = true;
15+
boolean[][] pairs = new boolean[26][26];
16+
int[] counts = new int[26];
17+
for (String word : words) {
18+
int a = word.charAt(0) - 'a';
19+
int b = word.charAt(1) - 'a';
20+
if (!pairs[a][b]) {
21+
pairs[a][b] = true;
22+
counts[a]++;
23+
counts[b]++;
24+
}
25+
}
26+
List<Integer>[] links = new ArrayList[26];
27+
for (int i = 0; i < 26; i++) {
28+
links[i] = new ArrayList<>();
2529
}
26-
// Map each used letter to an index [0..m-1]
27-
for (int c = 0; c < 26; c++) {
28-
if (used[c]) {
29-
idxToChar[m] = (char) (c + 'a');
30-
charToIdx[c] = m++;
30+
int[] counts1 = new int[26];
31+
int[] sides = new int[26];
32+
for (int i = 0; i < 26; i++) {
33+
for (int j = 0; j < 26; j++) {
34+
if (pairs[i][j]) {
35+
links[i].add(j);
36+
counts1[j]++;
37+
sides[i] |= 1;
38+
sides[j] |= 2;
39+
}
3140
}
3241
}
33-
adj = new int[m];
34-
// Build graph and record forced duplicates
35-
for (String w : words) {
36-
int u = charToIdx[w.charAt(0) - 'a'];
37-
int v = charToIdx[w.charAt(1) - 'a'];
38-
if (u == v) {
39-
forcedMask |= (1 << u);
42+
int[] arr = new int[26];
43+
for (int i = 0; i < 26; i++) {
44+
if (counts[i] <= 1) {
45+
arr[i] = counts[i];
46+
} else if (counts1[i] == 0 || sides[i] != 3) {
47+
arr[i] = 1;
48+
} else if (pairs[i][i]) {
49+
arr[i] = 2;
4050
} else {
41-
adj[u] |= (1 << v);
51+
arr[i] = -1;
4252
}
4353
}
44-
// Try all supersets of forcedMask; keep those that kill all cycles
45-
int best = 9999;
46-
List<Integer> goodSets = new ArrayList<>();
47-
for (int s = 0; s < (1 << m); s++) {
48-
if ((s & forcedMask) != forcedMask) {
49-
continue;
50-
}
51-
int size = Integer.bitCount(s);
52-
if (size <= best && !hasCycle(s)) {
53-
if (size < best) {
54-
best = size;
55-
goodSets.clear();
56-
}
57-
goodSets.add(s);
54+
dfs(links, 0, arr, new int[26], 0);
55+
List<List<Integer>> res = new ArrayList<>();
56+
for (int[] arr1 : lists) {
57+
List<Integer> list = new ArrayList<>();
58+
for (int n : arr1) {
59+
list.add(n);
5860
}
61+
res.add(list);
62+
}
63+
return res;
64+
}
65+
66+
private void dfs(List<Integer>[] links, int i, int[] arr1, int[] arr, int n) {
67+
if (n > min) {
68+
return;
5969
}
60-
// Build distinct freq arrays from these sets
61-
Set<String> seen = new HashSet<>();
62-
List<List<Integer>> ans = new ArrayList<>();
63-
for (int s : goodSets) {
64-
int[] freq = new int[26];
65-
for (int i = 0; i < m; i++) {
66-
freq[idxToChar[i] - 'a'] = ((s & (1 << i)) != 0) ? 2 : 1;
70+
if (i == 26) {
71+
if (!chk(links, arr)) {
72+
return;
6773
}
68-
String key = Arrays.toString(freq);
69-
if (seen.add(key)) {
70-
List<Integer> tmp = new ArrayList<>();
71-
for (int f : freq) {
72-
tmp.add(f);
73-
}
74-
ans.add(tmp);
74+
if (n < min) {
75+
min = n;
76+
lists = new ArrayList<>();
77+
lists.add(arr.clone());
78+
} else if (n == min) {
79+
lists.add(arr.clone());
7580
}
81+
return;
82+
}
83+
if (arr1[i] >= 0) {
84+
arr[i] = arr1[i];
85+
dfs(links, i + 1, arr1, arr, n + arr1[i]);
86+
} else {
87+
arr[i] = 1;
88+
dfs(links, i + 1, arr1, arr, n + 1);
89+
arr[i] = 2;
90+
dfs(links, i + 1, arr1, arr, n + 2);
7691
}
77-
return ans;
7892
}
7993

80-
private boolean hasCycle(int mask) {
81-
int[] color = new int[m];
82-
for (int i = 0; i < m; i++) {
83-
if (((mask >> i) & 1) == 0 && color[i] == 0 && dfs(i, color, mask)) {
84-
return true;
94+
private boolean chk(List<Integer>[] links, int[] arr) {
95+
for (int i = 0; i < 26; i++) {
96+
if (arr[i] == 1 && dfs1(links, arr, new boolean[26], i)) {
97+
return false;
8598
}
8699
}
87-
return false;
100+
return true;
88101
}
89102

90-
private boolean dfs(int u, int[] color, int mask) {
91-
color[u] = 1;
92-
int nxt = adj[u];
93-
while (nxt != 0) {
94-
int v = Integer.numberOfTrailingZeros(nxt);
95-
nxt &= (nxt - 1);
96-
if (((mask >> v) & 1) == 1) {
97-
continue;
98-
}
99-
if (color[v] == 1) {
100-
return true;
101-
}
102-
if (color[v] == 0 && dfs(v, color, mask)) {
103+
private boolean dfs1(List<Integer>[] links, int[] arr, boolean[] seens, int i) {
104+
seens[i] = true;
105+
for (int next : links[i]) {
106+
if (arr[next] == 1 && (seens[next] || dfs1(links, arr, seens, next))) {
103107
return true;
104108
}
105109
}
106-
color[u] = 2;
110+
seens[i] = false;
107111
return false;
108112
}
109113
}

‎src/test/java/g3401_3500/s3435_frequencies_of_shortest_supersequences/SolutionTest.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -14,10 +14,10 @@ void supersequences() {
1414
equalTo(
1515
List.of(
1616
List.of(
17-
2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
17+
1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1818
0, 0, 0, 0, 0, 0),
1919
List.of(
20-
1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
20+
2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2121
0, 0, 0, 0, 0, 0))));
2222
}
2323

0 commit comments

Comments
 (0)