第四周作业#010

Week_04/id_10/Leecode-123-10.go

@@ -0,0 +1,36 @@
+package leecode
+
+func maxProfit(prices []int) int {
+	if len(prices) == 0 {
+		return 0
+	}
+	// dp[i][k][t]  i 代表第几天  k 代表买入股票k次  t 是否持有股票 0 否 1 是
+	dp := make([][][]int, len(prices))
+	n := len(prices)
+	for i := 0; i < len(dp); i++ {
+		dp[i] = [][]int{[]int{0, 0}, []int{0, 0}, []int{0, 0}}
+	}
+	const INT_MIN = 0 - (1e9 + 7)
+	dp[0][1][1] = 0 - prices[0]
+	dp[0][1][0] = INT_MIN
+	dp[0][2][0] = INT_MIN
+	dp[0][2][1] = INT_MIN
+	for i := 1; i < len(prices); i++ {
+		dp[i][1][0] = max(dp[i-1][1][1]+prices[i], dp[i-1][1][0])
+		dp[i][1][1] = max(0-prices[i], dp[i-1][1][1])
+		dp[i][2][0] = max(dp[i-1][2][1]+prices[i], dp[i-1][2][0])
+		dp[i][2][1] = max(dp[i-1][1][0]-prices[i], dp[i-1][2][1])
+	}
+	return max(0, dp[n-1][1][0], dp[n-1][2][0])
+
+}
+
+func max(arr ...int) int {
+	maxNum := arr[0]
+	for i := 1; i < len(arr); i++ {
+		if maxNum < arr[i] {
+			maxNum = arr[i]
+		}
+	}
+	return maxNum
+}

Week_04/id_10/Leecode-169-10.go

@@ -0,0 +1,62 @@
+package leecode
+
+func majorityElement(nums []int) int {
+	//分治法
+	return helper(nums, 0, len(nums)-1)
+}
+
+func helper(nums []int, low, high int) int {
+	if low == high {
+		return nums[low]
+	}
+	mid := (low + high) / 2
+	left := helper(nums, low, mid)
+	right := helper(nums, mid+1, high)
+	if left == right {
+		return left
+	}
+	leftCount := 0
+	rightCount := 0
+	for i := low; i <= high; i++ {
+		if nums[i] == left {
+			leftCount++
+		} else if nums[i] == right {
+			rightCount++
+		}
+	}
+	if leftCount >= rightCount {
+		return left
+	}
+	return right
+}
+
+func majorityElement3(nums []int) int {
+	// 题解  Boyer-Moore 投票算法
+	count := 1
+	num := nums[0]
+	for i := 1; i < len(nums); i++ {
+		if count == 0 {
+			num = nums[i]
+			count = 1
+		} else if num == nums[i] {
+			count++
+		} else {
+			count--
+		}
+	}
+	return num
+}
+
+func majorityElement2(nums []int) int {
+	//使用 map 记录个数
+	numMap := make(map[int]int)
+	numLen := len(nums)
+	for i := 0; i < numLen; i++ {
+		num := nums[i]
+		numMap[num]++
+		if numMap[num] > numLen/2 {
+			return num
+		}
+	}
+	return -1
+}

Week_04/id_10/Leecode-208-10.go

@@ -0,0 +1,62 @@
+package leecode
+
+type Trie struct {
+	words  []*Trie
+	val    byte
+	is_end bool
+}
+
+/** Initialize your data structure here. */
+func Constructor() Trie {
+	root := Trie{words: make([]*Trie, 26), is_end: false}
+	return root
+}
+
+/** Inserts a word into the trie. */
+func (this *Trie) Insert(word string) {
+	root := this
+	for i := 0; i < len(word); i++ {
+		c := word[i] - 'a'
+		if root.words[c] == nil {
+			root.words[c] = &Trie{words: make([]*Trie, 26), val: word[i], is_end: false}
+		}
+		root = root.words[c]
+	}
+	root.is_end = true
+}
+
+/** Returns if the word is in the trie. */
+func (this *Trie) Search(word string) bool {
+	root := this
+	for i := 0; i < len(word); i++ {
+		c := word[i] - 'a'
+		if root.words[c] != nil {
+			root = root.words[c]
+		} else {
+			return false
+		}
+	}
+	return root.is_end
+}
+
+/** Returns if there is any word in the trie that starts with the given prefix. */
+func (this *Trie) StartsWith(prefix string) bool {
+	root := this
+	for i := 0; i < len(prefix); i++ {
+		c := prefix[i] - 'a'
+		if root.words[c] != nil {
+			root = root.words[c]
+		} else {
+			return false
+		}
+	}
+	return true
+}
+
+/**
+ * Your Trie object will be instantiated and called as such:
+ * obj := Constructor();
+ * obj.Insert(word);
+ * param_2 := obj.Search(word);
+ * param_3 := obj.StartsWith(prefix);
+ */

Week_04/id_10/Leecode-240-10.go

@@ -0,0 +1,136 @@
+package leecode
+
+func searchMatrix(matrix [][]int, target int) bool {
+	//题解
+	m := len(matrix)
+	if m == 0 {
+		return false
+	}
+	n := len(matrix[0])
+	if n == 0 {
+		return false
+	}
+	i := 0
+	j := n - 1
+	for i < m && j >= 0 {
+		if matrix[i][j] == target {
+			return true
+		} else if matrix[i][j] < target {
+			i++
+		} else {
+			j--
+		}
+	}
+	return false
+}
+
+func searchMatrix2(matrix [][]int, target int) bool {
+	//分治法
+	m := len(matrix)
+	if m == 0 {
+		return false
+	}
+	n := len(matrix[0])
+	if n == 0 {
+		return false
+	}
+	pos1 := []int{0, 0}
+	pos2 := []int{m - 1, n - 1}
+	return helper(matrix, pos1, pos2, target)
+}
+
+func binary_search_hen(matrix [][]int, target int, x, y1, y2 int) bool {
+	// 横向二分查找
+	if x >= len(matrix) {
+		return false
+	}
+	l := y1
+	r := y2
+	for l <= r {
+		mid := (l + r) / 2
+		if matrix[x][mid] == target {
+			return true
+		} else if matrix[x][mid] < target {
+			l = mid + 1
+		} else {
+			r = mid - 1
+		}
+	}
+	return false
+}
+
+func binary_search_shu(matrix [][]int, target int, y, x1, x2 int) bool {
+	// 竖向二分查找
+	if y >= len(matrix[0]) {
+		return false
+	}
+	l := x1
+	r := x2
+	for l <= r {
+		mid := (l + r) / 2
+		if matrix[mid][y] == target {
+			return true
+		} else if matrix[mid][y] < target {
+			l = mid + 1
+		} else {
+			r = mid - 1
+		}
+	}
+	return false
+}
+
+func helper(matrix [][]int, pos1, pos2 []int, target int) bool {
+	if pos1[0] < 0 || pos1[1] < 0 || pos2[0] < pos1[0] || pos2[1] < pos1[1] {
+		return false
+	}
+	if pos1[0] == pos2[0] && pos1[1] == pos2[1] {
+		return matrix[pos1[0]][pos1[1]] == target
+	}
+	if pos1[0] == pos2[0] {
+		return binary_search_hen(matrix, target, pos1[0], pos1[1], pos2[1])
+	}
+	if pos1[1] == pos2[1] {
+		return binary_search_shu(matrix, target, pos1[1], pos1[0], pos2[0])
+	}
+	midx := (pos1[0] + pos2[0]) / 2
+	midy := (pos1[1] + pos2[1]) / 2
+	if matrix[midx][midy] == target {
+		return true
+	}
+	if matrix[midx][midy] < target {
+		ret := binary_search_hen(matrix, target, midx, midy+1, pos2[1])
+		if ret {
+			return true
+		}
+		ret = binary_search_shu(matrix, target, midy, midx+1, pos2[0])
+		if ret {
+			return true
+		}
+		ret = helper(matrix, []int{midx + 1, midy + 1}, pos2, target)
+		if ret {
+			return true
+		}
+	} else {
+		ret := binary_search_hen(matrix, target, midx, pos1[1], midy-1)
+		if ret {
+			return true
+		}
+		ret = binary_search_shu(matrix, target, midy, pos1[0], midx-1)
+		if ret {
+			return true
+		}
+		ret = helper(matrix, pos1, []int{midx - 1, midy - 1}, target)
+		if ret {
+			return true
+		}
+	}
+	ret := helper(matrix, []int{midx + 1, pos1[1]}, []int{pos2[0], midy - 1}, target)
+	if ret {
+		return true
+	}
+	ret = helper(matrix, []int{pos1[0], midy + 1}, []int{midx - 1, pos2[1]}, target)
+	if ret {
+		return true
+	}
+	return false
+}

Week_04/id_10/Leecode-455-10.go

@@ -0,0 +1,20 @@
+package leecode
+
+import "sort"
+
+func findContentChildren(g []int, s []int) int {
+	//贪心算法  饼干最大 配胃口最大的孩子
+	sort.Ints(g)
+	sort.Ints(s)
+	gi := len(g) - 1
+	si := len(s) - 1
+	count := 0
+	for gi >= 0 && si >= 0 {
+		if g[gi] <= s[si] {
+			si--
+			count++
+		}
+		gi--
+	}
+	return count
+}

Week_04/id_10/Leecode-51-10.go

@@ -0,0 +1,37 @@
+package leecode
+
+import "bytes"
+
+func solveNQueens(n int) [][]string {
+	// 回溯法
+	result := make([][]string, 0)
+	pie := make([]bool, n*2)
+	na := make([]bool, n*2)
+	vlines := make([]bool, n)
+	qpos := make([]string, n)
+	var helper func(level int, qpos []string)
+	helper = func(level int, qpos []string) {
+		if level == n {
+			copystrs := make([]string, len(qpos))
+			copy(copystrs, qpos)
+			result = append(result, copystrs)
+			return
+		}
+		for i := 0; i < n; i++ {
+			if !vlines[i] && !na[i-level+n] && !pie[i+level] {
+				vlines[i] = true
+				na[i-level+n] = true
+				pie[i+level] = true
+				s := bytes.Repeat([]byte("."), n)
+				s[i] = 'Q'
+				qpos[level] = string(s)
+				helper(level+1, qpos)
+				vlines[i] = false
+				na[i-level+n] = false
+				pie[i+level] = false
+			}
+		}
+	}
+	helper(0, qpos)
+	return result
+}

Week_04/id_10/Leecode-62-10.go

@@ -0,0 +1,22 @@
+package leecode
+
+func uniquePaths(m int, n int) int {
+	if m == 0 || n == 0 {
+		return 0
+	}
+	dp := make([][]int, n)
+	for i := 0; i < n; i++ {
+		dp[i] = make([]int, m)
+		dp[i][0] = 1
+	}
+	for i := 0; i < m; i++ {
+		dp[0][i] = 1
+	}
+	for i := 1; i < n; i++ {
+		for j := 1; j < m; j++ {
+			dp[i][j] = dp[i-1][j] + dp[i][j-1]
+		}
+	}
+	return dp[n-1][m-1]
+
+}