Weekly Contest 118

1.Powerful Integers

解题思路：枚举即可

func powInt(x, y int) int {
	res := 1
	for y > 0 {
		if y&1 > 0 {
			res *= x
		}
		x = x * x
		y >>= 1
	}
	return res
}

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

func powerfulIntegers(x int, y int, bound int) []int {
	if bound < 2 {
		return nil
	}
	res := []int{}
	for i := 0; powInt(x, i) <= bound && i <= 100; i++ {
		for j := 0; powInt(y, j) <= bound && j <= 100; j++ {
			v := powInt(x, i) + powInt(y, j)
			if v <= bound {
				res = append(res, v)
			}
		}
	}
	sort.Ints(res)
	idx1, idx2 := 0, 1
	for idx2 < len(res) {
		if res[idx2] != res[idx1] {
			idx1++
			res[idx1] = res[idx2]
		}
		idx2++
	}
	return res[:idx1+1]
}

2. Pancake Sorting

解题思路：构造，从大到小依次归位元素。因为要让一个元素归位，最多需要经过两次反转操作即可完成，即先把该元素反转到头部，然后再反转到相应位置处即可。

func reverse(A []int) {
	for i, j := 0, len(A)-1; i < j; i, j = i+1, j-1 {
		A[i], A[j] = A[j], A[i]
	}
}

func pancakeSort(A []int) []int {

	if len(A) < 2 {
		return []int{}
	}

	var (
		i   int
		v   int
		res []int
	)

	v = len(A)
	for v > 0 {
		for i = 0; i < len(A); i++ {
			if A[i] == v {
				break
			}
		}
		if i == v-1 {
			v--
			continue
		}
		if i != 0 {
			res = append(res, i+1)
		}
		res = append(res, v)
		reverse(A[:i+1])
		reverse(A[:v])
		v--
	}
	return res
}

3. Flip Binary Tree To Match Preorder Traversal

解题思路：前序遍历的顺序为根节点、左子树、右子树，因此根节点的下一个元素便是左孩子节点（如果存在）。因此，只需要递归遍历二叉树，在二叉树遍历的过程中及时调整相应位置处的元素即可。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func flipMatchVoyage(root *TreeNode, voyage []int) []int {

	var (
		idx = -1
		res []int
	)

	var dfs func(r *TreeNode) bool
	dfs = func(r *TreeNode) bool {

		if r == nil {
			return true
		}

		idx++
		if r.Val != voyage[idx] {
			return false
		}

		if r.Left != nil && idx+1 < len(voyage) && r.Left.Val != voyage[idx+1] {
			res = append(res, r.Val)
			r.Left, r.Right = r.Right, r.Left
		}

		if r.Left != nil && !dfs(r.Left) {
			return false
		}
		if r.Right != nil && !dfs(r.Right) {
			return false
		}
		return true
	}

	ok := dfs(root)
	if !ok {
		return []int{-1}
	}
	/*
		if !ok || idx < len(voyage)-1 {
			return []int{-1}
		}
	*/
	return res
}

// TreeNode 树节点
type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

4. Equal Rational Numbers

解题思路：这题原本认为处理掉循环小数的对比即可，发现测试用例出了个 0.9999(9) = 1 的判断，瞬间感觉做不了，投降。。。后面，如果有必要做了，再回来补掉这题。