add new solutions

solutions/14/q1448/solution.go

@@ -0,0 +1,28 @@
+package q1448
+
+import "math"
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func gn(node *TreeNode, curMax int) int {
+	if node == nil {
+		return 0
+	}
+	self := 0
+	if node.Val >= curMax {
+		self = 1
+	}
+
+	curMax = max(curMax, node.Val)
+	return self + gn(node.Left, curMax) + gn(node.Right, curMax)
+}
+
+func goodNodes(root *TreeNode) int {
+	return gn(root, math.MinInt)
+}
+
+var _ = goodNodes

solutions/14/q1456/solution.go

@@ -0,0 +1,27 @@
+package q1456
+
+func isVowel(b byte) bool {
+	switch b {
+	case 'a', 'e', 'i', 'o', 'u':
+		return true
+	}
+	return false
+}
+
+func maxVowels(s string, k int) int {
+	maxV := 0
+	curr := 0
+	for i := range len(s) {
+		if isVowel(s[i]) {
+			curr++
+		}
+		if i >= k && isVowel(s[i-k]) {
+			curr--
+		}
+
+		maxV = max(curr, maxV)
+	}
+	return maxV
+}
+
+var _ = maxVowels

solutions/14/q1466/solution.go

@@ -0,0 +1,67 @@
+package q1466
+
+import "math"
+
+func walk(connections [][2][]int, minFlips []int32, node int) {
+	mf := minFlips[node]
+
+	// Walk no-flip-needed
+	for _, n := range connections[node][1] {
+		if mf < minFlips[n] {
+			minFlips[n] = mf
+			walk(connections, minFlips, n)
+		}
+	}
+
+	// Walk flip-needed
+	for _, n := range connections[node][0] {
+		if mf+1 < minFlips[n] {
+			minFlips[n] = mf + 1
+			walk(connections, minFlips, n)
+		}
+	}
+}
+
+func collect(connections [][2][]int, minFlips []int32, node int, visited []bool) int32 {
+	mf := minFlips[node]
+	var sum int32
+
+	for _, n := range connections[node][1] {
+		if !visited[n] && mf == minFlips[n] {
+			visited[n] = true
+			sum += collect(connections, minFlips, n, visited) - mf
+		}
+	}
+
+	for _, n := range connections[node][0] {
+		if !visited[n] && mf+1 == minFlips[n] {
+			visited[n] = true
+			sum += collect(connections, minFlips, n, visited) - mf
+		}
+	}
+
+	return sum + mf
+}
+
+func minReorder(n int, connections [][]int) int {
+	conns := make([][2][]int, n)
+	for i := range connections {
+		from, to := connections[i][0], connections[i][1]
+		conns[from][0] = append(conns[from][0], to)
+		conns[to][1] = append(conns[to][1], from)
+	}
+
+	minFlips := make([]int32, n) // minimum flips to reach node n
+	minFlips[0] = math.MaxInt32
+	for i := 1; i < len(minFlips); i *= 2 {
+		copy(minFlips[i:], minFlips[:i])
+	}
+	minFlips[0] = 0
+
+	walk(conns, minFlips, 0)
+
+	visited := make([]bool, n)
+	return int(collect(conns, minFlips, 0, visited))
+}
+
+var _ = minReorder

solutions/14/q1493/solution.go

@@ -0,0 +1,24 @@
+package q1493
+
+func longestSubarray(nums []int) int {
+	prev, cur := 0, 0
+	longest := 0
+	has0 := false
+	for _, a := range nums {
+		if a == 1 {
+			cur++
+		}
+		longest = max(longest, prev+cur)
+		if a == 0 {
+			prev, cur = cur, 0
+			has0 = true
+		}
+	}
+
+	if !has0 {
+		longest--
+	}
+	return longest
+}
+
+var _ = longestSubarray