Skip to content

Commit a847798

Browse files
javadevjavadev
committed
Updated tags
1 parent 3194d00 commit a847798

File tree

4 files changed

+108
-94
lines changed
  • src/main/kotlin/g3401_3500

4 files changed

+108
-94
lines changed

‎src/main/kotlin/g3401_3500/s3446_sort_matrix_by_diagonals/Solution.kt‎

Lines changed: 29 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1,31 +1,40 @@
11
package g3401_3500.s3446_sort_matrix_by_diagonals
22

3-
// #Medium #2025_02_09_Time_64_(100.00%)_Space_60.34_(100.00%)
3+
// #Medium #Array #Sorting #Matrix #2025_02_11_Time_12_ms_(93.75%)_Space_49.17_MB_(12.50%)
44

55
class Solution {
6-
fun sortMatrix(matrix: Array<IntArray>): Array<IntArray> {
7-
val diagonalMap = mutableMapOf<Int, MutableList<Int>>()
8-
val rows = matrix.size
9-
val cols = matrix[0].size
10-
for (i in 0 until rows) {
11-
for (j in 0 until cols) {
12-
val key = i - j
13-
diagonalMap.computeIfAbsent(key) { mutableListOf() }.add(matrix[i][j])
6+
fun sortMatrix(grid: Array<IntArray>): Array<IntArray> {
7+
val top = 0
8+
var left = 0
9+
var right = grid[0].size - 1
10+
while (top < right) {
11+
var x = grid[0].size - 1 - left
12+
val arr = IntArray(left + 1)
13+
for (i in top..left) {
14+
arr[i] = grid[i][x++]
1415
}
15-
}
16-
for ((key, values) in diagonalMap) {
17-
if (key < 0) {
18-
values.sort()
19-
} else {
20-
values.sortDescending()
16+
arr.sort()
17+
x = grid[0].size - 1 - left
18+
for (i in top..left) {
19+
grid[i][x++] = arr[i]
2120
}
21+
left++
22+
right--
2223
}
23-
for (i in 0 until rows) {
24-
for (j in 0 until cols) {
25-
val key = i - j
26-
matrix[i][j] = diagonalMap[key]!!.removeAt(0)
24+
var bottom = grid.size - 1
25+
var x = 0
26+
while (top <= bottom) {
27+
val arr = IntArray(bottom + 1)
28+
for (i in arr.indices) {
29+
arr[i] = grid[x + i][i]
30+
}
31+
arr.sort()
32+
for (i in arr.indices) {
33+
grid[x + i][i] = arr[arr.size - 1 - i]
2734
}
35+
bottom--
36+
x++
2837
}
29-
return matrix
38+
return grid
3039
}
3140
}

‎src/main/kotlin/g3401_3500/s3447_assign_elements_to_groups_with_constraints/Solution.kt‎

Lines changed: 27 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -1,36 +1,40 @@
11
package g3401_3500.s3447_assign_elements_to_groups_with_constraints
22

3-
// #Medium #2025_02_09_Time_464_(100.00%)_Space_73.32_(100.00%)
3+
// #Medium #Array #Hash_Table #2025_02_11_Time_24_ms_(100.00%)_Space_78.02_MB_(83.33%)
44

5-
import kotlin.math.min
5+
import kotlin.math.max
66

77
class Solution {
88
fun assignElements(groups: IntArray, elements: IntArray): IntArray {
9-
val elementIndexMap: MutableMap<Int, Int> = HashMap<Int, Int>()
10-
for (i in elements.indices) {
11-
elementIndexMap.putIfAbsent(elements[i], i)
12-
}
13-
val result = IntArray(groups.size)
14-
for (i in groups.indices) {
15-
result[i] = findSmallestIndex(groups[i], elementIndexMap)
9+
var j: Int
10+
var maxi = 0
11+
var i = 0
12+
while (i < groups.size) {
13+
maxi = max(maxi, groups[i])
14+
i++
1615
}
17-
return result
18-
}
19-
20-
private fun findSmallestIndex(groupSize: Int, elementIndexMap: MutableMap<Int, Int>): Int {
21-
var minIndex = Int.Companion.MAX_VALUE
22-
var i = 1
23-
while (i * i <= groupSize) {
24-
if (groupSize % i == 0) {
25-
if (elementIndexMap.containsKey(i)) {
26-
minIndex = min(minIndex, elementIndexMap[i]!!)
27-
}
28-
if (i != groupSize / i && elementIndexMap.containsKey(groupSize / i)) {
29-
minIndex = min(minIndex, elementIndexMap[groupSize / i]!!)
16+
val n = maxi + 1
17+
val arr = IntArray(n)
18+
val ans = IntArray(groups.size)
19+
arr.fill(-1)
20+
i = 0
21+
while (i < elements.size) {
22+
if (elements[i] < n && arr[elements[i]] == -1) {
23+
j = elements[i]
24+
while (j < n) {
25+
if (arr[j] == -1) {
26+
arr[j] = i
27+
}
28+
j += elements[i]
3029
}
3130
}
3231
i++
3332
}
34-
return if (minIndex == Int.Companion.MAX_VALUE) -1 else minIndex
33+
i = 0
34+
while (i < groups.size) {
35+
ans[i] = arr[groups[i]]
36+
i++
37+
}
38+
return ans
3539
}
3640
}

‎src/main/kotlin/g3401_3500/s3448_count_substrings_divisible_by_last_digit/Solution.kt‎

Lines changed: 16 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,7 @@
11
package g3401_3500.s3448_count_substrings_divisible_by_last_digit
22

3-
// #Hard #2025_02_09_Time_29_(100.00%)_Space_40.60_(100.00%)
3+
// #Hard #String #Dynamic_Programming #2025_02_11_Time_29_ms_(77.78%)_Space_41.05_MB_(77.78%)
44

5-
@Suppress("kotlin:S107")
65
class Solution {
76
fun countSubstrings(s: String): Long {
87
val n = s.length
@@ -12,17 +11,17 @@ class Solution {
1211
computeModArrays(s, p3, p7, p9)
1312
val freq3 = LongArray(3)
1413
val freq9 = LongArray(9)
15-
val freq7 = Array<LongArray>(6) { LongArray(7) }
14+
val freq7 = Array<LongArray?>(6) { LongArray(7) }
1615
val inv7 = intArrayOf(1, 5, 4, 6, 2, 3)
1716
return countValidSubstrings(s, p3, p7, p9, freq3, freq9, freq7, inv7)
1817
}
1918

2019
private fun computeModArrays(s: String, p3: IntArray, p7: IntArray, p9: IntArray) {
21-
p3[0] = (s[0].code - '0'.code) % 3
22-
p7[0] = (s[0].code - '0'.code) % 7
23-
p9[0] = (s[0].code - '0'.code) % 9
20+
p3[0] = (s.get(0).code - '0'.code) % 3
21+
p7[0] = (s.get(0).code - '0'.code) % 7
22+
p9[0] = (s.get(0).code - '0'.code) % 9
2423
for (i in 1..<s.length) {
25-
val dig = s[i].code - '0'.code
24+
val dig = s.get(i).code - '0'.code
2625
p3[i] = (p3[i - 1] * 10 + dig) % 3
2726
p7[i] = (p7[i - 1] * 10 + dig) % 7
2827
p9[i] = (p9[i - 1] * 10 + dig) % 9
@@ -36,17 +35,17 @@ class Solution {
3635
p9: IntArray,
3736
freq3: LongArray,
3837
freq9: LongArray,
39-
freq7: Array<LongArray>,
38+
freq7: Array<LongArray?>,
4039
inv7: IntArray,
4140
): Long {
4241
var ans: Long = 0
4342
for (j in 0..<s.length) {
44-
val d = s[j].code - '0'.code
43+
val d = s.get(j).code - '0'.code
4544
if (d != 0) {
4645
ans += countDivisibilityCases(s, j, d, p3, p7, p9, freq3, freq9, freq7, inv7)
4746
}
4847
freq3[p3[j]]++
49-
freq7[j % 6][p7[j]] = freq7[j % 6][p7[j]] + 1
48+
freq7[j % 6]!![p7[j]] = freq7[j % 6]!![p7[j]] + 1
5049
freq9[p9[j]]++
5150
}
5251
return ans
@@ -61,7 +60,7 @@ class Solution {
6160
p9: IntArray,
6261
freq3: LongArray,
6362
freq9: LongArray,
64-
freq7: Array<LongArray>,
63+
freq7: Array<LongArray?>,
6564
inv7: IntArray,
6665
): Long {
6766
var ans: Long = 0
@@ -85,7 +84,7 @@ class Solution {
8584
if (j == 0) {
8685
return 1
8786
}
88-
val num = (s[j - 1].code - '0'.code) * 10 + (s[j].code - '0'.code)
87+
val num = (s.get(j - 1).code - '0'.code) * 10 + (s.get(j).code - '0'.code)
8988
return (if (num % 4 == 0) j + 1 else 1).toLong()
9089
}
9190

@@ -94,20 +93,20 @@ class Solution {
9493
return 1
9594
}
9695
if (j == 1) {
97-
val num = (s[0].code - '0'.code) * 10 + 8
96+
val num = (s.get(0).code - '0'.code) * 10 + 8
9897
return (if (num % 8 == 0) 2 else 1).toLong()
9998
}
100-
val num3 = (s[j - 2].code - '0'.code) * 100 + (s[j - 1].code - '0'.code) * 10 + 8
101-
val num2 = (s[j - 1].code - '0'.code) * 10 + 8
99+
val num3 = (s.get(j - 2).code - '0'.code) * 100 + (s.get(j - 1).code - '0'.code) * 10 + 8
100+
val num2 = (s.get(j - 1).code - '0'.code) * 10 + 8
102101
return (if (num3 % 8 == 0) j - 1 else 0) + (if (num2 % 8 == 0) 1 else 0) + 1L
103102
}
104103

105-
private fun countDivisibilityBy7(j: Int, p7: IntArray, freq7: Array<LongArray>, inv7: IntArray): Long {
104+
private fun countDivisibilityBy7(j: Int, p7: IntArray, freq7: Array<LongArray?>, inv7: IntArray): Long {
106105
var ans = (if (p7[j] == 0) 1L else 0L)
107106
for (m in 0..5) {
108107
val idx = ((j % 6) - m + 6) % 6
109108
val req = (p7[j] * inv7[m]) % 7
110-
ans += freq7[idx][req]
109+
ans += freq7[idx]!![req]
111110
}
112111
return ans
113112
}

‎src/main/kotlin/g3401_3500/s3449_maximize_the_minimum_game_score/Solution.kt‎

Lines changed: 36 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -1,46 +1,48 @@
11
package g3401_3500.s3449_maximize_the_minimum_game_score
22

3-
// #Hard #2025_02_09_Time_214_(100.00%)_Space_61.96_(100.00%)
4-
5-
import kotlin.math.max
3+
// #Hard #Array #Greedy #Binary_Search #2025_02_11_Time_123_ms_(100.00%)_Space_62.76_MB_(100.00%)
64

75
class Solution {
8-
fun maxScore(points: IntArray, m: Int): Long {
6+
private fun judge(points: IntArray, m: Long, tgt: Long): Boolean {
7+
var m = m
8+
var cur: Long
9+
var nxt = 0L
910
val n = points.size
10-
if (m < n) {
11-
return 0
12-
}
13-
var lo: Long = 1
14-
var hi = 1e18.toLong()
15-
var ans: Long = 0
16-
while (lo <= hi) {
17-
val mid = lo + (hi - lo) / 2
18-
var tot: Long = 0
19-
var tr: Long = 0
20-
var skip: Long = 0
21-
var i = 0
22-
while (i < n && tot <= m) {
23-
val p = points[i]
24-
val need = (mid + p - 1L) / p
25-
if (tr >= need) {
26-
tr = 0
27-
skip++
28-
} else {
29-
val cur = tr * p
30-
val ops = (mid - cur + p - 1L) / p
31-
tot += 2 * ops - 1 + skip
32-
tr = max((ops - 1), 0)
33-
skip = 0
11+
for (i in 0..<n) {
12+
if (i == n - 1 && nxt >= tgt) {
13+
return true
14+
}
15+
m--
16+
cur = nxt + points[i]
17+
nxt = 0
18+
if (cur < tgt) {
19+
val req = (tgt - cur - 1) / points[i] + 1
20+
if (i < n - 1) {
21+
nxt = points[i + 1] * req
3422
}
35-
i++
23+
m -= req * 2
24+
}
25+
if (m < 0) {
26+
return false
3627
}
37-
if (tot <= m) {
38-
ans = mid
39-
lo = mid + 1
28+
}
29+
return true
30+
}
31+
32+
fun maxScore(points: IntArray, m: Int): Long {
33+
var x = 0L
34+
var y = 10000000L * m
35+
while (x < y - 1) {
36+
val mid = (x + y) / 2
37+
if (judge(points, m.toLong(), mid)) {
38+
x = mid
4039
} else {
41-
hi = mid - 1
40+
y = mid - 1
4241
}
4342
}
44-
return ans
43+
while (judge(points, m.toLong(), x + 1)) {
44+
x++
45+
}
46+
return x
4547
}
4648
}

0 commit comments

Comments
 (0)