Add LeetCode Weekly Contest 270

Author: EndlessCheng

leetcode/weekly/270/a/a.go

@@ -0,0 +1,23 @@
+package main
+
+// 枚举所有三位数偶数
+
+// github.com/EndlessCheng/codeforces-go
+func findEvenNumbers(digits []int) (ans []int) {
+	cnt := [10]int{}
+	for _, d := range digits {
+		cnt[d]++
+	}
+next:
+	for i := 100; i < 1000; i += 2 { // 枚举所有三位数偶数 i
+		c := [10]int{}
+		for x := i; x > 0; x /= 10 { // 枚举 i 的每一位 d
+			d := x % 10
+			if c[d]++; c[d] > cnt[d] { // 如果 d 出现次数比 digits 中的 d 的次数还多，那么 i 肯定不能由 digits 中的数字组成
+				continue next // 枚举下一个偶数
+			}
+		}
+		ans = append(ans, i)
+	}
+	return
+}

leetcode/weekly/270/a/a_test.go

@@ -0,0 +1,25 @@
+package main
+
+import . "github.com/EndlessCheng/codeforces-go/leetcode/testutil"
+
+/* 快慢指针
+
+这题其实就是把 [876. 链表的中间结点](https://leetcode-cn.com/problems/middle-of-the-linked-list/) 和删除链表结点结合起来
+
+我们只需要在 876 题的基础上，额外记录 $\textit{slow}$ 结点的上一个结点即可。
+
+*/
+
+// github.com/EndlessCheng/codeforces-go
+func deleteMiddle(head *ListNode) *ListNode {
+	dummyHead := &ListNode{Next: head}
+	pre, slow, fast := dummyHead, head, head
+	for fast != nil && fast.Next != nil {
+		pre = slow // pre 记录了 slow 的上一个结点
+		slow = slow.Next
+		fast = fast.Next.Next
+	}
+	// 循环结束后，slow 为待删除结点
+	pre.Next = slow.Next // 删除 slow
+	return dummyHead.Next
+}

leetcode/weekly/270/b/b.go

@@ -0,0 +1,118 @@
+package main
+
+import (
+	. "github.com/EndlessCheng/codeforces-go/leetcode/testutil"
+	"strings"
+)
+
+/* 一题双解：BFS / 最近公共祖先
+
+#### 解法一：DFS + BFS
+
+我们可以从起点出发，通过 BFS 找到终点，同时记录每个点的来源节点和方向，在找到终点后，顺着来源节点往回走，同时记录答案。
+
+由于要往父节点方向走，我们需要先通过一次 DFS 记录每个节点的父节点，这样就可以在 BFS 中往父节点和左右节点三个方向前进了。
+
+DFS 的过程中也可以顺带找到起点。
+
+#### 解法二：最近公共祖先
+
+按照 [236. 二叉树的最近公共祖先](https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/) 给出的方法，我们可以从起点出发，找到到起点和终点的路径，然后去掉前缀相同的部分。剩下即为从起点和终点的最近公共祖先出发，到起点和终点的路径，分别记作 $\textit{pathToStart}$ 和 $\textit{pathToDest}$。
+
+我们要找的最短路径即为：起点 => 起点和终点的最近公共祖先 => 终点。
+
+对于起点到最近公共祖先这一段，可以看成长度为 $\textit{pathToStart}$ 的向父节点走的路径；对于最近公共祖先到终点这一段就是 $\textit{pathToDest}$。将这两段路径拼起来即为答案。
+
+*/
+
+// github.com/EndlessCheng/codeforces-go
+func getDirections(root *TreeNode, startValue, destValue int) string {
+	var path []byte
+	var dfs func(*TreeNode, int) bool
+	dfs = func(node *TreeNode, target int) bool {
+		if node == nil {
+			return false
+		}
+		if node.Val == target {
+			return true
+		}
+		path = append(path, 'L')
+		if dfs(node.Left, target) {
+			return true
+		}
+		path[len(path)-1] = 'R'
+		if dfs(node.Right, target) {
+			return true
+		}
+		path = path[:len(path)-1]
+		return false
+	}
+	dfs(root, startValue)
+	pathToStart := path
+
+	path = nil
+	dfs(root, destValue)
+	pathToDest := path
+
+	for len(pathToStart) > 0 && len(pathToDest) > 0 && pathToStart[0] == pathToDest[0] {
+		pathToStart = pathToStart[1:]
+		pathToDest = pathToDest[1:]
+	}
+
+	return strings.Repeat("U", len(pathToStart)) + string(pathToDest)
+}
+
+func getDirections2(root *TreeNode, startValue, destValue int) string {
+	q := []*TreeNode{nil}
+	parents := map[*TreeNode]*TreeNode{}
+	var dfs func(node, pa *TreeNode)
+	dfs = func(node, pa *TreeNode) {
+		if node == nil {
+			return
+		}
+		parents[node] = pa
+		if node.Val == startValue {
+			q[0] = node // 只有一个起点
+		}
+		dfs(node.Left, node)
+		dfs(node.Right, node)
+	}
+	dfs(root, nil)
+
+	ans := []byte{}
+	vis := map[*TreeNode]bool{nil: true, q[0]: true}
+	type pair struct {
+		from *TreeNode
+		dir  byte
+	}
+	from := map[*TreeNode]pair{}
+	for len(q) > 0 {
+		node := q[0]
+		q = q[1:]
+		if node.Val == destValue {
+			for ; from[node].from != nil; node = from[node].from {
+				ans = append(ans, from[node].dir)
+			}
+			break
+		}
+		if !vis[node.Left] {
+			vis[node.Left] = true
+			from[node.Left] = pair{node, 'L'}
+			q = append(q, node.Left)
+		}
+		if !vis[node.Right] {
+			vis[node.Right] = true
+			from[node.Right] = pair{node, 'R'}
+			q = append(q, node.Right)
+		}
+		if !vis[parents[node]] {
+			vis[parents[node]] = true
+			from[parents[node]] = pair{node, 'U'}
+			q = append(q, parents[node])
+		}
+	}
+	for i, n := 0, len(ans); i < n/2; i++ {
+		ans[i], ans[n-1-i] = ans[n-1-i], ans[i]
+	}
+	return string(ans)
+}

leetcode/weekly/270/b/b_test.go

@@ -0,0 +1,51 @@
+package main
+
+/* 有向图欧拉路径
+
+本题与 [332. 重新安排行程](https://leetcode-cn.com/problems/reconstruct-itinerary/) 一样，都可以抽象成如下问题：
+
+> 给你一张有向图，在这张有向图中找到一条欧拉路径。
+
+对于此题，由于题目保证有解，所以有向图肯定是欧拉图或半欧拉图。
+
+我们需要找到一个起点，如果是欧拉图，那么随便找一个点都行，如果是半欧拉图，那么找到一个出度比入度大 1 的点，把它当成起点，然后按照 332 给出的算法来求解。
+
+*/
+
+// github.com/EndlessCheng/codeforces-go
+func validArrangement(pairs [][]int) [][]int {
+	type edge struct{ to, idx int }
+	g := map[int][]edge{}
+	inDeg := map[int]int{}
+	for i, p := range pairs {
+		v, w := p[0], p[1]
+		g[v] = append(g[v], edge{w, i}) // 建图（有向图）
+		inDeg[w]++ // 统计入度
+	}
+
+	start := 0
+	for i, es := range g {
+		if len(es) == inDeg[i]+1 { // 如果存在出度比入度大 1 的点，那就把它当成起点
+			start = i
+			break
+		}
+		start = i // 或者随便找一个点当起点
+	}
+
+	m := len(pairs)
+	ans := make([][]int, 0, m)
+	var dfs func(int)
+	dfs = func(v int) {
+		for len(g[v]) > 0 {
+			e := g[v][0]
+			g[v] = g[v][1:]
+			dfs(e.to)
+			ans = append(ans, pairs[e.idx]) // 保存所有边
+		}
+	}
+	dfs(start)
+	for i := 0; i < m/2; i++ {
+		ans[i], ans[m-1-i] = ans[m-1-i], ans[i]
+	}
+	return ans
+}