每日一题

Sitrone · Sitrone · commit f6d7879bcb35 · 2020-10-05T14:21:39.000+08:00
diff --git a/algs/leetcode/1402_maxSatisfaction.go b/algs/leetcode/1402_maxSatisfaction.go
@@ -0,0 +1,47 @@
+package leetcode
+
+import "sort"
+
+// 动态规划, dp[i][j]表示前i个物体中，选中j个菜，可以达到的最大值 FIXME 该题解法有问题
+// dp[0][1] = arr[0]
+// dp[i][j] = max(dp[i-1][j-1], dp[i-1][j] + arr[i]*j)
+func maxSatisfaction(satisfaction []int) int {
+	var (
+		dp      = make([][]int, len(satisfaction))
+		maxFunc func(x, y int) int
+	)
+
+	sort.Ints(satisfaction)
+	maxFunc = func(x, y int) int {
+		if x > y {
+			return x
+		}
+		return y
+	}
+
+	for i := 0; i < len(satisfaction); i++ {
+		dp[i] = make([]int, len(satisfaction))
+	}
+
+	dp[0][0] = 0
+	dp[0][1] = satisfaction[0]
+	for i := 1; i < len(satisfaction); i++ {
+		for j := 0; j < i; j++ {
+			if j == 0 {
+				dp[i][j] = 0
+			} else {
+				if i == j {
+					dp[i][j] = dp[i-1][j-1] + satisfaction[i-1]*j
+				} else {
+					dp[i][j] = maxFunc(dp[i-1][j], dp[i-1][j-1]+satisfaction[i-1]*j)
+				}
+			}
+		}
+	}
+
+	var ans = 0
+	for i := 0; i <= len(satisfaction); i++ {
+		ans = maxFunc(ans, dp[len(satisfaction)][i])
+	}
+	return ans
+}
diff --git a/algs/leetcode/1436_destCity.go b/algs/leetcode/1436_destCity.go
@@ -0,0 +1,17 @@
+package leetcode
+
+// 哈希表
+func destCity(paths [][]string) string {
+	startMap := make(map[string]struct{}, len(paths))
+	for _, path := range paths {
+		startMap[path[0]] = struct{}{}
+	}
+
+	for _, path := range paths {
+		if _, ok := startMap[path[1]]; !ok {
+			return path[1]
+		}
+	}
+
+	return ""
+}
diff --git a/algs/leetcode/1460_canBeEqual.go b/algs/leetcode/1460_canBeEqual.go
@@ -0,0 +1,26 @@
+package leetcode
+
+func canBeEqual(target []int, arr []int) bool {
+	if len(target) != len(arr) {
+		return false
+	}
+
+	if len(target) == 0 {
+		return true
+	}
+
+	targetM := make(map[int]int, len(target))
+	for i := 0; i < len(target); i++ {
+		targetM[target[i]]++
+	}
+
+	for i := 0; i < len(arr); i++ {
+		if val, ok := targetM[arr[i]]; !ok || val <= 0 {
+			return false
+		} else {
+			targetM[arr[i]] = val - 1
+		}
+	}
+
+	return true
+}
diff --git a/algs/leetcode/1464_maxProduct.go b/algs/leetcode/1464_maxProduct.go
@@ -0,0 +1,54 @@
+package leetcode
+
+import "math"
+
+// 找到最大的两个值
+func maxProduct1(nums []int) int {
+	var (
+		max    int
+		max2nd int
+	)
+
+	if nums[0] > nums[1] {
+		max = nums[0]
+		max2nd = nums[1]
+	} else {
+		max = nums[1]
+		max2nd = nums[0]
+	}
+	for i := 2; i < len(nums); i++ {
+		if nums[i] > max {
+			max2nd, max = max, nums[i]
+		} else if nums[i] > max2nd {
+			max2nd = nums[i]
+		}
+	}
+
+	return (max - 1) * (max2nd - 1)
+}
+
+// 暴力法
+func maxProduct2(nums []int) int {
+	var (
+		max     = math.MinInt32
+		calFunc func(x, y int) int
+		maxFunc func(x, y int) int
+	)
+
+	calFunc = func(x, y int) int {
+		return (x - 1) * (y - 1)
+	}
+	maxFunc = func(x, y int) int {
+		if x > y {
+			return x
+		}
+		return y
+	}
+	for i := 0; i < len(nums); i++ {
+		for j := i + 1; j < len(nums); j++ {
+			max = maxFunc(max, calFunc(nums[i], nums[j]))
+		}
+	}
+
+	return max
+}
diff --git a/algs/leetcode/146_LRUCache_test.go b/algs/leetcode/146_LRUCache_test.go
@@ -1,19 +1,18 @@
 package leetcode
 
 import (
-	"fmt"
 	"testing"
 )
 
 func TestLRUCache_Get(t *testing.T) {
-	lruCache := Constructor(2)
-	fmt.Println(lruCache.Get(2))
-	lruCache.Put(2, 6)
-	fmt.Println(lruCache.Get(1))
-	lruCache.Put(1, 5)
-	lruCache.Put(1, 2)
-	fmt.Println(lruCache.Get(1))
-	fmt.Println(lruCache.Get(2))
-
-	fmt.Println(10 / 4)
+	//lruCache := Constructor(2)
+	//fmt.Println(lruCache.Get(2))
+	//lruCache.Put(2, 6)
+	//fmt.Println(lruCache.Get(1))
+	//lruCache.Put(1, 5)
+	//lruCache.Put(1, 2)
+	//fmt.Println(lruCache.Get(1))
+	//fmt.Println(lruCache.Get(2))
+	//
+	//fmt.Println(10 / 4)
 }
diff --git a/algs/leetcode/17_calculate.go b/algs/leetcode/17_calculate.go
@@ -0,0 +1,30 @@
+package leetcode
+
+func calculate(s string) int {
+	var (
+		x, y  = 1, 0
+		aFunc func(x, y int) int
+		bFunc func(x, y int) int
+	)
+	aFunc = func(x, y int) int {
+		return 2*x + y
+	}
+
+	bFunc = func(x, y int) int {
+		return x + 2*y
+	}
+
+	for _, b := range s {
+		if b == 'A' {
+			x = aFunc(x, y)
+		} else if b == 'B' {
+			y = bFunc(x, y)
+		}
+	}
+
+	return x + y
+}
+
+func calculate1(s string) int {
+	return len(s) * 2
+}
diff --git a/algs/leetcode/284_iterator.go b/algs/leetcode/284_iterator.go
@@ -0,0 +1,56 @@
+package leetcode
+
+//Below is the interface for Iterator, which is already defined for you.
+
+type Iterator struct {
+}
+
+func (this *Iterator) hasNext() bool {
+	// Returns true if the iteration has more elements.
+	return false
+}
+
+func (this *Iterator) next() int {
+	// Returns the next element in the iteration.
+	return 0
+}
+
+type PeekingIterator struct {
+	head int
+	iter *Iterator
+}
+
+func Constructor(iter *Iterator) *PeekingIterator {
+	return &PeekingIterator{
+		head: 0,
+		iter: iter,
+	}
+}
+
+func (this *PeekingIterator) hasNext() bool {
+	if this.head > 0 {
+		return true
+	} else {
+		return this.iter.hasNext()
+	}
+}
+
+func (this *PeekingIterator) next() int {
+	if this.head > 0 {
+		next := this.head
+		this.head = 0
+		return next
+	} else {
+		return this.iter.next()
+	}
+}
+
+func (this *PeekingIterator) peek() int {
+	if this.head > 0 {
+		return this.head
+	} else {
+		peek := this.iter.next()
+		this.head = peek
+		return peek
+	}
+}
diff --git a/algs/leetcode/590_postorder.go b/algs/leetcode/590_postorder.go
@@ -0,0 +1,54 @@
+package leetcode
+
+import "zitrone.github.com/go-snippet/algs"
+
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Children []*Node
+ * }
+ */
+
+// 给定一个 N 叉树，返回其节点值的后序遍历。
+// 递归
+func postorder(root *Node) []int {
+	if root == nil {
+		return nil
+	}
+	var ret = make([]int, 0, 10)
+	for i := 0; i < len(root.Children); i++ {
+		ret = append(ret, postorder(root.Children[i])...)
+	}
+
+	ret = append(ret, root.Val)
+	return ret
+}
+
+// 非递归 stack
+func postorder1(root *Node) []int {
+	if root == nil {
+		return nil
+	}
+	var (
+		stack = &algs.Stack{}
+		ret   = make([]int, 0, 10)
+	)
+	stack.Push(root.Val)
+	for !stack.IsEmpty() {
+		rootI, _ := stack.Pop()
+		root := rootI.(*Node)
+		if root != nil {
+			ret = append(ret, root.Val)
+			for i := 0; i < len(root.Children); i++ {
+				stack.Push(root.Children[i])
+			}
+		}
+	}
+
+	for i, j := 0, len(ret)-1; i < len(ret)/2; i++ {
+		ret[i], ret[j] = ret[j], ret[i]
+		j--
+	}
+	return ret
+}
diff --git a/algs/leetcode/tree_node.go b/algs/leetcode/tree_node.go
@@ -6,3 +6,9 @@ type TreeNode struct {
 	Left  *TreeNode
 	Right *TreeNode
 }
+
+//Definition for a Node.
+type Node struct {
+	Val      int
+	Children []*Node
+}
