Weekly Contest 119

1. K Closest Points to Origin

type Point struct {
	x int
	y int
}

func kClosest(points [][]int, K int) [][]int {
	n := len(points)
	if n == 0 {
		return [][]int{}
	}

	var pts []Point
	for i := 0; i < n; i++ {
		pts = append(pts, Point{points[i][0], points[i][1]})
	}
	sort.Slice(pts, func(i, j int) bool {
		return pts[i].x*pts[i].x+pts[i].y*pts[i].y < pts[j].x*pts[j].x+pts[j].y*pts[j].y
	})

	var res [][]int
	for i := 0; i < K; i++ {
		res = append(res, []int{pts[i].x, pts[i].y})
	}
	return res
}

2. Largest Perimeter Triangle

func largestPerimeter(A []int) int {
	var res int
	sort.Ints(A)
	for i := len(A) - 3; i >= 0; i-- {
		if A[i]+A[i+1] > A[i+2] {
			res = A[i] + A[i+1] + A[i+2]
			break
		}
	}
	return res
}

3. Subarray Sums Divisible by K

func subarraysDivByK(A []int, K int) int {

	var (
		res int
		mod = map[int]int{}
	)

	for i := range A {
		A[i] = (A[i]%K + K) % K
	}

	sum := 0
	mod[0] = 1
	for i := range A {
		sum = (sum + A[i]) % K
		res += mod[sum]
		mod[sum]++
	}

	return res
}

func main() {
	fmt.Println(subarraysDivByK([]int{4, 5, 0, -2, -3, 1}, 5))
	fmt.Println(subarraysDivByK([]int{0, 0, 0, 0, 0}, 5))
	fmt.Println(subarraysDivByK([]int{5, 5, 5, 5, 5}, 5))
	// subarraysDivByK([]int{1, 2, 3}, 3)
}

4. Odd Even Jump

解题思路: 设 dp[i][0] 表示从位置 i 奇数步开始到终点位置的方案数，dp[i][1]表示从 i 偶数步开始到重点位置的方案数，状态转移方程为dp[i][0] = dp[j][1](j > i && A[j] >= A[i] 的最小值且最小索引) 和 dp[i][1] = dp[j][0] (j > i && A[j] <= A[i] 的最大值的最小索引)，易知我们要求解的结果是 SUM(dp[0][1], dp[1][1], ..., dp[n-1][1])。问题的关键是如果找到转态转义方程的下一步状态，此处给出两种解法。
（一）从后向前递推，用平衡树维护当前遍历过的元素且该元素对应的最小索引，由于 go 标准库没有针对平衡树实现相应的数据结构，故采用 C++ STL 中的 map 实现。示例代码如下所示：

#include <iostream>
#include <map>
using namespace std;

int main() {
	map<int, int> mp;
	map<int, int>::iterator it1;
	mp[1] = 1;
	mp[2] = 2;
	mp[5] = 5;
	mp[10] = 10;	
	it1 = mp.lower_bound(4);
	cout << it1->first << " " << it1->second << endl;
	it1--;
	cout << it1->first << " " << it1->second << endl;
	return 0;
}

（二）go 中实现平衡树的替代方案，因为我目前已经写不出来平衡树来了，只好搞了两种简易的代替方案。a. skiplist 维护 b. 树状数组 + 二分，代码实现中我采用了第二种，因为题目中给出的数据元素 0 <= A[i] < 100000。

package main

import "fmt"

const (
	maxn = 100010
)

var tree [maxn]int

func initTree(n int) {
	for i := 0; i <= n; i++ {
		tree[i] = 0
	}
}

func lowbit(x int) int {
	return x & (-x)
}

func addVal(idx, c, n int) {
	for i := idx; i <= n; i += lowbit(i) {
		tree[i] += c
	}
}

func getSum(idx int) int {

	if idx < 1 {
		return 0
	}

	sum := 0
	for i := idx; i > 0; i -= lowbit(i) {
		sum += tree[i]
	}

	return sum
}

func maxInt(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func minInt(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func findMinGreaterOrEqualIdx(x, maxV int) int {

	var (
		l   int
		r   int
		mid int
		ans int
	)

	l, r, ans = x+1, maxV, -1
	for l <= r {
		mid = l + (r-l)/2
		if getSum(mid)-getSum(x) > 0 {
			if ans == -1 {
				ans = mid
			} else {
				ans = minInt(ans, mid)
			}
			r = mid - 1
		} else {
			l = mid + 1
		}
	}
	return ans
}

func findMaxLessOrEqualIdx(x int) int {

	var (
		l   int
		r   int
		mid int
		ans int
	)

	l, r, ans = 1, x-1, -1
	for l <= r {
		mid = l + (r-l)/2
		if getSum(x-1)-getSum(mid-1) > 0 {
			if ans == -1 {
				ans = mid
			} else {
				ans = maxInt(ans, mid)
			}
			l = mid + 1
		} else {
			r = mid - 1
		}
	}
	return ans
}

func oddEvenJumps(A []int) int {

	n := len(A)
	if n < 2 {
		return n
	}

	var (
		maxVal int
		dp     [][2]int
		valIdx []int
		cnt    int
		idx    int
	)

	for i := 0; i < n; i++ {
		A[i]++
	}

	maxVal = A[0]
	for i := 1; i < n; i++ {
		maxVal = maxInt(maxVal, A[i])
	}

	valIdx = make([]int, maxVal+1)
	for i := 0; i <= maxVal; i++ {
		valIdx[i] = -1
	}

	dp = make([][2]int, n+1)
	dp[n-1][0], dp[n-1][1], cnt, valIdx[A[n-1]] = 1, 1, 1, n-1
	initTree(maxVal)
	addVal(A[n-1], 1, maxVal)
	for i := n - 2; i >= 0; i-- {

		// dp[i][0] 奇数步
		if valIdx[A[i]] != -1 {
			idx = valIdx[A[i]]
		} else {
			idx = findMinGreaterOrEqualIdx(A[i], maxVal)
			if idx != -1 {
				idx = valIdx[idx]
			}
		}

		/*
			if idx != -1 {
				fmt.Println("Test1: ", A[i], idx, A[idx])
			}
		*/

		if idx == -1 {
			dp[i][0] = 0
		} else {
			dp[i][0] = dp[idx][1]
		}

		// dp[i][1] 偶数步
		if valIdx[A[i]] != -1 {
			idx = valIdx[A[i]]
		} else {
			idx = findMaxLessOrEqualIdx(A[i])
			if idx != -1 {
				idx = valIdx[idx]
			}
		}

		/*
			if idx != -1 {
				fmt.Println("Test2: ", A[i], idx, A[idx])
			}
		*/

		if idx == -1 {
			dp[i][1] = 0
		} else {
			dp[i][1] = dp[idx][0]
		}

		// fmt.Println(dp[i][0], dp[i][1])

		cnt += dp[i][0]
		valIdx[A[i]] = i
		addVal(A[i], 1, maxVal)
	}
	return cnt
}

func main() {
	fmt.Println(oddEvenJumps([]int{10, 13, 12, 14, 15}))
	fmt.Println(oddEvenJumps([]int{2, 3, 1, 1, 4}))
	fmt.Println(oddEvenJumps([]int{5, 1, 3, 4, 2}))
	fmt.Println(oddEvenJumps([]int{82, 66, 0, 49}))
}