update

medium/213.house-robber-ii.go

@@ -0,0 +1,25 @@
+func rob(nums []int) int {
+	n := len(nums)
+	if n == 0 {
+		return 0
+	} else if n == 1 {
+		return nums[0]
+	}
+	dp := make([][]int, 2) // dp[0][i]: pick first element; dp[1][i]: do not pick.
+	for i := range dp {
+		dp[i] = make([]int, n)
+	}
+	dp[0][1] = nums[0]
+	for i := 2; i < n; i++ {
+		dp[0][i] = maxInt(dp[0][i-1], nums[i-1]+dp[0][i-2])
+		dp[1][i] = maxInt(dp[1][i-1], nums[i-1]+dp[1][i-2])
+	}
+	return maxInt(dp[0][n-1], maxInt(dp[1][n-2]+nums[n-1], dp[1][n-1]))
+}
+
+func maxInt(x, y int) int {
+	if x < y {
+		return y
+	}
+	return x
+}

medium/215.kth-largest-element-in-an-array.go

@@ -0,0 +1,64 @@
+func findKthLargest(nums []int, k int) int {
+	pq := NewFixedPQ(k)
+	for i := range nums {
+		pq.Enqueue(nums[i])
+	}
+	return pq.Peek()
+}
+
+type FixedPQ struct { // Small root heap XD
+	Size int
+	PQ   []int
+}
+
+func NewFixedPQ(size int) FixedPQ {
+	return FixedPQ{size, make([]int, 1)}
+}
+
+func (pq *FixedPQ) Enqueue(x int) {
+	if pq.Len() < pq.Size {
+		pq.PQ = append(pq.PQ, x)
+		pq.swim(pq.Len())
+	} else if pq.Peek() < x {
+		pq.PQ[1] = x
+		pq.sink(1)
+	}
+}
+
+func (pq *FixedPQ) Dequeue() int {
+	peek := pq.PQ[1]
+	pq.Swap(1, pq.Len())
+	pq.PQ = pq.PQ[:pq.Len()]
+	pq.sink(1)
+	return peek
+}
+
+func (pq FixedPQ) Len() int           { return len(pq.PQ) - 1 }
+func (pq FixedPQ) Less(i, j int) bool { return pq.PQ[i] < pq.PQ[j] }
+func (pq FixedPQ) Swap(i, j int)      { pq.PQ[i], pq.PQ[j] = pq.PQ[j], pq.PQ[i] }
+
+func (pq FixedPQ) Peek() int {
+	return pq.PQ[1]
+}
+
+func (pq FixedPQ) swim(i int) {
+	for 1 < i && pq.Less(i, i/2) {
+		pq.Swap(i, i/2)
+		i /= 2
+	}
+}
+
+func (pq FixedPQ) sink(i int) {
+	for 2*i <= pq.Size {
+		j := 2*i
+		if (j < pq.Size && pq.Less(j+1, j)) {
+			j++ // Compare with the smaller child
+		}
+		if !pq.Less(j, i) {
+			break // If ith <= jth, stop sinking
+		}
+		pq.Swap(i, j)
+		i = j
+	}
+}
+

medium/216.combination-sum-iii.go

@@ -0,0 +1,22 @@
+func combinationSum3(k int, n int) (ans [][]int) {
+	stack := make([]int, 0)
+	for i, sum, l := 1, 0, 0; ; l = len(stack) {
+		// If need to backtrack
+		if l == k || 10-i+l < k { // Cut the branches or MLE
+			if l == 0 { // No previous number to pop
+				break
+			} else if l == k && sum == n {
+				ans = append(ans, make([]int, k))
+				copy(ans[len(ans)-1], stack)
+			}
+			sum -= stack[l-1]
+			i = stack[l-1] + 1
+			stack = stack[:l-1]
+		} else {
+			stack = append(stack, i)
+			sum += i
+			i++
+		}
+	}
+	return ans
+}

medium/220.contains-duplicate-iii.go

@@ -0,0 +1,32 @@
+func containsNearbyAlmostDuplicate(nums []int, k int, t int) bool {
+	mq := NewMagicQueue(k + 1)
+	for i := range nums {
+		mq.Enqueue(nums[i])
+		if mq.MinGap() <= t {
+			return true
+		}
+	}
+	return false
+}
+
+type MagicQueue struct {
+	Size int
+	MQ []int
+}
+
+func NewMagicQueue(size int) MagicQueue {
+	return MagicQueue{size, make([]int, 0)}
+}
+
+func (mq MagicQueue) MinGap() int {
+	return 0
+}
+
+func (mq MagicQueue) Len() int {
+	return len(mq.MQ)
+}
+
+func (mq *MagicQueue) Enqueue(x int) {
+	
+}
+