增加新题目

动态规划/打家劫舍/main.go

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+
+}
+func rob(nums []int) int {
+
+	return 0
+}

动态规划/杨辉三角/main.go

@@ -0,0 +1,29 @@
+package main
+
+func main() {
+
+}
+func generate(numRows int) [][]int {
+	reslist := make([][]int, 0)
+	for i := 0; i < numRows; i++ {
+		tmpnumlist := make([]int, 0)
+		if i == 0 {
+			tmpnumlist = append(tmpnumlist, 1)
+			reslist = append(reslist, tmpnumlist)
+			continue
+		}
+		for j := 0; j < i+1; j++ {
+			if j-1 < 0 {
+				tmpnumlist = append(tmpnumlist, reslist[i-1][0])
+				continue
+
+			} else if j == len(reslist[i-1]) {
+				tmpnumlist = append(tmpnumlist, reslist[i-1][j-1])
+				continue
+			}
+			tmpnumlist = append(tmpnumlist, reslist[i-1][j]+reslist[i-1][j-1])
+		}
+		reslist = append(reslist, tmpnumlist)
+	}
+	return reslist
+}

动态规划/爬楼梯/main.go

@@ -0,0 +1,21 @@
+package main
+
+func main() {
+
+}
+
+func climbStairs(n int) int {
+	if n == 1 {
+		return 1
+	}
+	if n == 2 {
+		return 2
+	}
+	stepn1 := 1
+	stepn2 := 2
+	for i := 3; i <= n; i++ {
+		current := stepn1 + stepn2
+		stepn1, stepn2 = stepn2, current
+	}
+	return stepn2
+}

贪心算法/买卖股票的最佳时机/main.go

@@ -0,0 +1,26 @@
+package main
+
+func main() {
+
+}
+func maxProfit(prices []int) int {
+	minnum := 0
+	res := 0
+
+	for i := 0; i < len(prices); i++ {
+		if i == 0 {
+			minnum = prices[i]
+			res = 0
+			continue
+		}
+		if prices[i] < minnum {
+			minnum = prices[i]
+		}
+		tmpnum := prices[i] - minnum
+
+		if tmpnum > res {
+			res = tmpnum
+		}
+	}
+	return res
+}

贪心算法/跳跃游戏/main.go

@@ -0,0 +1,25 @@
+package main
+
+func main() {
+
+}
+
+func canJump(nums []int) bool {
+	maxstep := 0
+	for i := 0; i < len(nums); i++ {
+		if maxstep == 0 {
+			maxstep = nums[i] + (i + 1)
+			continue
+		}
+		if (i + 1) <= maxstep {
+			tmp := nums[i] + (i + 1)
+			if tmp > maxstep {
+				maxstep = tmp
+			}
+		} else {
+			return false
+		}
+	}
+
+	return true
+}

贪心算法/跳跃游戏II/main.go

@@ -0,0 +1,67 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println(jump([]int{2, 3, 1, 1, 4}))
+}
+
+func jump(nums []int) int {
+	res := 0
+	right := 2
+	maxstep := 0
+
+	for i := 0; i < len(nums); i++ {
+		if (i+1)+nums[i] > right {
+			maxstep = (i + 1) + nums[i]
+		}
+		if (i + 1) == right {
+			res++
+			right = maxstep
+		}
+		if maxstep >= len(nums) {
+			break
+		}
+
+	}
+	return res
+}
+
+//func jump(nums []int) int {
+//	step := make([]int, len(nums))
+//	res := 0
+//	for i := 0; i < len(nums); i++ {
+//		maxstep := 0
+//		maxi := 0
+//		for j := i + 1; j < i+nums[i]; j++ {
+//			if j >= len(nums) {
+//				break
+//			}
+//			if j == i+1 {
+//				maxstep = nums[j]
+//				maxi = j
+//				continue
+//			}
+//			if nums[j] >= maxstep {
+//				maxstep = nums[j]
+//				maxi = j
+//			}
+//		}
+//		step[i] = maxi
+//	}
+//	tmp := make([]int, len(nums))
+//	copy(tmp, step)
+//	for len(tmp) > 1 {
+//		res++
+//		num := tmp[0]
+//		i := 0
+//		for i < num {
+//			tmp = tmp[1:]
+//			i++
+//		}
+//		//fmt.Println("---", tmp)
+//	}
+//	//fmt.Println(step)
+//	//fmt.Println(res)
+//	return res
+//}

链表/LRU缓存/main.go

@@ -5,10 +5,17 @@ type ListNode struct {
 	Next *ListNode
 }
 
+type LRUCache struct {
+}
+
+func Constructor(capacity int) LRUCache {
+	return LRUCache{}
+}
+
+func (this *LRUCache) Get(key int) int {
+	return 0
+}
+
 func main() {
 
 }
-func reverseKGroup(head *ListNode, k int) *ListNode {
-
-	return nil
-}