509. 斐波那契數
已解答
簡單
相關標籤
相關企業
斐波那契數 （通常用 F(n) 表示）形成的序列稱為 斐波那契數列 。該數列由 0 和 1 開始，後面的每一項數字都是前面兩項數字的和。也就是：
F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1給定 n ，請計算 F(n) 。
示例 1：
輸入：n = 2
輸出：1
解釋：F(2) = F(1) + F(0) = 1 + 0 = 1示例 2：
輸入：n = 3
輸出：2
解釋：F(3) = F(2) + F(1) = 1 + 1 = 2示例 3：
輸入：n = 4
輸出：3
解釋：F(4) = F(3) + F(2) = 2 + 1 = 3
func fib(n int) int {
if n < 2 {
return n
}
//1。 確定dp資料下標，以及含意
// dp[i] //第i個數的斐波那契數
//2. 遞推公式
// dp[i] = dp[i-1]+dp[i-2]
//3. 初始化
// dp[0] = 1, dp[1] = 1
//4. 確定遍歷順序
// 從前向右，
// 5.列印遞迴陣列
vardp []int
dp = make([]int, n)
dp[0] = 1
dp[1] = 1
fori := 2; i < n; i++ {
dp[i] = dp[i-1] + dp[i-2]
}
return dp[n-1]
}
70. 爬樓梯
已解答
簡單
相關標籤
相關企業
提示
假設你正在爬樓梯。需要 n 階你才能到達樓頂。
每次你可以爬 1 或 2 個臺階。你有多少種不同的方法可以爬到樓頂呢？
示例 1：
輸入：n = 2
輸出：2
解釋：有兩種方法可以爬到樓頂。
1. 1 階 + 1 階
2. 2 階示例 2：
輸入：n = 3
輸出：3
解釋：有三種方法可以爬到樓頂。
1. 1 階 + 1 階 + 1 階
2. 1 階 + 2 階
3. 2 階 + 1 階
提示：
1 <= n <= 45
func climbStairs(n int) int {
// 1. 確定dp下標與含義，dp[i] = 到i臺階的不同方法數
// 2. 遞推公式， d[i] = dp[i-1]+dp[i-2]
// 3. dp初始化 d[0] = 0 dp[1] = 1
// 4. 遍歷順序， 從前向後
// 5。 列印dp
dp := make([]int, n+1)
dp[0] = 1
dp[1] = 1
for i := 2; i < n+1; i++ {
dp[i] = dp[i-1] + dp[i-2]
}
return dp[n]
}
746. 使用最小花費爬樓梯
已解答
簡單
相關標籤
相關企業
提示
給你一個整數陣列 cost ，其中 cost[i] 是從樓梯第 i 個臺階向上爬需要支付的費用。一旦你支付此費用，即可選擇向上爬一個或者兩個臺階。
你可以選擇從下標為 0 或下標為 1 的臺階開始爬樓梯。
請你計算並返回達到樓梯頂部的最低花費。
示例 1：
輸入：cost = [10,15,20]
輸出：15
解釋：你將從下標為 1 的臺階開始。
- 支付 15 ，向上爬兩個臺階，到達樓梯頂部。
總花費為 15 。示例 2：
輸入：cost = [1,100,1,1,1,100,1,1,100,1]
輸出：6
解釋：你將從下標為 0 的臺階開始。
- 支付 1 ，向上爬兩個臺階，到達下標為 2 的臺階。
- 支付 1 ，向上爬兩個臺階，到達下標為 4 的臺階。
- 支付 1 ，向上爬兩個臺階，到達下標為 6 的臺階。
- 支付 1 ，向上爬一個臺階，到達下標為 7 的臺階。
- 支付 1 ，向上爬兩個臺階，到達下標為 9 的臺階。
- 支付 1 ，向上爬一個臺階，到達樓梯頂部。
總花費為 6 。
提示：
2 <= cost.length <= 10000 <= cost[i] <= 999
func minCostClimbingStairs(cost []int) int {
// dp[i] 含義， 到i臺階的最小花費
// 遞推公式 dp[i] = min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2])
// 初始化 dp[1] = cost[0] dp[1] = 0, dp[0] = 0
// 從前向後遍歷
//列印dp
dp := make([]int, len(cost)+1)
fori := 2; i <= len(cost); i++ {
dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2])
}
return dp[len(cost)]
}
func min(a, b int) int {
if a > b {
return b
}
return a
}