test: 3602, 3603, 3604, 3605, 3606, 3607, 3608, 3609 solution

go

Author: QuBenhao

golang/problems_test.go

@@ -1,16 +1,24 @@
 package golang
 
 import (
-	"leetCode/problems/problems_3597"
-	"leetCode/problems/problems_3598"
-	"leetCode/problems/problems_3599"
-	"leetCode/problems/problems_3600"
+	"leetCode/problems/problems_3602"
+	"leetCode/problems/problems_3603"
+	"leetCode/problems/problems_3604"
+	"leetCode/problems/problems_3605"
+	"leetCode/problems/problems_3606"
+	"leetCode/problems/problems_3607"
+	"leetCode/problems/problems_3608"
+	"leetCode/problems/problems_3609"
 	"testing"
 )
 
 func TestSolutions(t *testing.T) {
-	TestEach(t, "3597", "problems", problem3597.Solve)
-	TestEach(t, "3598", "problems", problem3598.Solve)
-	TestEach(t, "3599", "problems", problem3599.Solve)
-	TestEach(t, "3600", "problems", problem3600.Solve)
+	TestEach(t, "3602", "problems", problem3602.Solve)
+	TestEach(t, "3603", "problems", problem3603.Solve)
+	TestEach(t, "3604", "problems", problem3604.Solve)
+	TestEach(t, "3605", "problems", problem3605.Solve)
+	TestEach(t, "3606", "problems", problem3606.Solve)
+	TestEach(t, "3607", "problems", problem3607.Solve)
+	TestEach(t, "3608", "problems", problem3608.Solve)
+	TestEach(t, "3609", "problems", problem3609.Solve)
 }

golang/solution_test.go

@@ -1,10 +1,10 @@
 package golang
 
 import (
-	problem "leetCode/problems/problems_3609"
+	problem "leetCode/problems/problems_1865"
 	"testing"
 )
 
 func TestSolution(t *testing.T) {
-	TestEach(t, "3609", "problems", problem.Solve)
+	TestEach(t, "1865", "problems", problem.Solve)
 }

problems/problems_3602/solution.go

@@ -1,13 +1,30 @@
 package problem3602
 
 import (
+	"bytes"
 	"encoding/json"
 	"log"
+	"slices"
 	"strings"
 )
 
+const hex36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
 func concatHex36(n int) string {
-    
+	x := n * n
+	y := x * n
+	var buf bytes.Buffer
+	for y > 0 {
+		buf.WriteByte(hex36[y%36])
+		y /= 36
+	}
+	for x > 0 {
+		buf.WriteByte(hex36[x%16])
+		x /= 16
+	}
+	// reverse the buffer to get the correct order
+	slices.Reverse(buf.Bytes())
+	return buf.String()
 }
 
 func Solve(inputJsonValues string) any {

problems/problems_3603/solution.go

@@ -3,11 +3,30 @@ package problem3603
 import (
 	"encoding/json"
 	"log"
+	"math"
 	"strings"
 )
 
 func minCost(m int, n int, waitCost [][]int) int64 {
-    
+	dp := make([][]int64, m)
+	for i := range dp {
+		dp[i] = make([]int64, n)
+		for j := range dp[i] {
+			dp[i][j] = math.MaxInt64
+		}
+	}
+	dp[0][0] = 1
+	for i := range m {
+		for j := range n {
+			if i < m-1 {
+				dp[i+1][j] = min(dp[i+1][j], dp[i][j]+int64(i+2)*int64(j+1)+int64(waitCost[i+1][j]))
+			}
+			if j < n-1 {
+				dp[i][j+1] = min(dp[i][j+1], dp[i][j]+int64(i+1)*int64(j+2)+int64(waitCost[i][j+1]))
+			}
+		}
+	}
+	return dp[m-1][n-1] - int64(waitCost[m-1][n-1])
 }
 
 func Solve(inputJsonValues string) any {

problems/problems_3604/solution.go

@@ -1,13 +1,65 @@
 package problem3604
 
 import (
+	"container/heap"
 	"encoding/json"
 	"log"
+	"math"
 	"strings"
 )
 
 func minTime(n int, edges [][]int) int {
-    
+	graph := make([][][]int, n)
+	for _, edge := range edges {
+		graph[edge[0]] = append(graph[edge[0]], []int{edge[1], edge[2], edge[3]})
+	}
+	h := &hp{[]int{0, 0}} // {time, node}
+	heap.Init(h)
+	dist := make([]int, n)
+	for i := range dist {
+		dist[i] = math.MaxInt32
+	}
+	dist[0] = 0
+	for h.Len() > 0 {
+		cur := heap.Pop(h).([]int)
+		time, node := cur[0], cur[1]
+		if node == n-1 {
+			return time
+		}
+		if time > dist[node] {
+			continue
+		}
+		for _, next := range graph[node] {
+			nextNode, start, end := next[0], next[1], next[2]
+			if time <= end {
+				nextTime := max(time, start) + 1
+				if nextTime < dist[nextNode] {
+					dist[nextNode] = nextTime
+					heap.Push(h, []int{nextTime, nextNode})
+				}
+			}
+		}
+	}
+	return -1
+}
+
+type hp [][]int
+
+func (h hp) Len() int           { return len(h) }
+func (h hp) Less(i, j int) bool { return h[i][0] < h[j][0] }
+func (h hp) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+func (h *hp) Push(x any) {
+	*h = append(*h, x.([]int))
+}
+func (h *hp) Pop() any {
+	if len(*h) == 0 {
+		return nil
+	}
+	old := *h
+	n := len(old)
+	x := old[n-1]
+	*h = old[0 : n-1]
+	return x
 }
 
 func Solve(inputJsonValues string) any {

problems/problems_3605/solution.go

@@ -7,7 +7,79 @@ import (
 )
 
 func minStable(nums []int, maxC int) int {
-    
+	n := len(nums)
+	gs := make([][][]int, n)
+	for i, num := range nums {
+		if i > 0 {
+			gs[i] = make([][]int, len(gs[i-1]))
+			for j := range gs[i-1] {
+				gs[i][j] = make([]int, len(gs[i-1][j]))
+				copy(gs[i][j], gs[i-1][j])
+			}
+		}
+		gs[i] = append(gs[i], []int{num, i})
+		j := 0
+		for _, p := range gs[i] {
+			p[0] = gcd(p[0], num)
+			if gs[i][j][0] != p[0] {
+				j++
+				gs[i][j] = p
+			}
+		}
+		gs[i] = gs[i][:j+1]
+	}
+
+	check := func(k int) bool {
+		count := 0
+		if k == 0 {
+			for _, num := range nums {
+				if num != 1 {
+					count++
+					if count > maxC {
+						return false
+					}
+				}
+			}
+		} else {
+			for i := n - 1; i >= 0; {
+				found := false
+				for j := len(gs[i]) - 1; j >= 0; j-- {
+					v, idx := gs[i][j][0], gs[i][j][1]
+					if v != 1 && i-idx+1 > k {
+						count++
+						if count > maxC {
+							return false
+						}
+						i = max(i-k, idx) - 1
+						found = true
+						break
+					}
+				}
+				if !found {
+					i--
+				}
+			}
+		}
+		return true
+	}
+
+	left, right := 0, n
+	for left < right {
+		mid := (left + right) / 2
+		if check(mid) {
+			right = mid
+		} else {
+			left = mid + 1
+		}
+	}
+	return left
+}
+
+func gcd(a, b int) int {
+	for a != 0 {
+		a, b = b%a, a
+	}
+	return b
 }
 
 func Solve(inputJsonValues string) any {

problems/problems_3606/solution.go

@@ -3,11 +3,52 @@ package problem3606
 import (
 	"encoding/json"
 	"log"
+	"sort"
 	"strings"
 )
 
-func validateCoupons(code []string, businessLine []string, isActive []bool) []string {
-    
+var BUSINESS = map[string]int{
+	"electronics": 0,
+	"grocery":     1,
+	"pharmacy":    2,
+	"restaurant":  3,
+}
+
+func validateCoupons(code []string, businessLine []string, isActive []bool) (result []string) {
+	var valids []int
+	for i, c := range code {
+		if !isActive[i] {
+			continue
+		}
+		if _, ok := BUSINESS[businessLine[i]]; !ok {
+			continue
+		}
+		if len(c) == 0 {
+			continue
+		}
+		valid := true
+		for _, char := range c {
+			// check is alnumeric
+			if !(('0' <= char && char <= '9') || ('A' <= char && char <= 'Z') || ('a' <= char && char <= 'z') || char == '_') {
+				valid = false
+				break
+			}
+		}
+		if valid {
+			valids = append(valids, i)
+		}
+	}
+	sort.Slice(valids, func(i, j int) bool {
+		b0, b1 := BUSINESS[businessLine[valids[i]]], BUSINESS[businessLine[valids[j]]]
+		if b0 != b1 {
+			return b0 < b1
+		}
+		return code[valids[i]] < code[valids[j]]
+	})
+	for _, idx := range valids {
+		result = append(result, code[idx])
+	}
+	return
 }
 
 func Solve(inputJsonValues string) any {