动态规划算法

动态规划

动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。

算法分为：
自底向上:动态规划(划分小问题)

自顶向下:记忆化搜索(递归基础上记忆已计算的结果)

1.1 最长回文字符串

1.动态规划算法

func longestPalindrome(s string) string {
    n := len(s)
    if n <= 1 {
        return s
    }
    max := 0
    end := 0
    dp := make([][]bool, n)
    for i := range dp {
        dp[i] = make([]bool, n)
        for j := 0; j < n; j++ {
            if i - j > 1 {
                dp[i][j] = s[i] == s[j] && dp[i-1][j+1]
            } else {
                dp[i][j] = s[i] == s[j]
            }
            if dp[i][j] {
                if i-j+1 > max {
                    max = i-j+1
                    end = i
                }
            }
        }
    }
    return s[end-max+1:end+1]
}

1.2 零钱兑换

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

示例 1:

输入: coins = [1, 2, 5], amount = 11
输出: 3 
解释: 11 = 5 + 5 + 1

示例 2:

输入: coins = [2], amount = 3
输出: -1

动态规划–自底向上

func coinChange(coins []int, amount int) int {
    if amount == 0 {
        return 0
    }
    if len(coins) == 0 {
        return -1
    }
    dp := make([]int, amount+1)
    for m := 0; m <= amount; m++ {
        dp[m] = amount+1
    }
    dp[0] = 0
    for i := 0; i <= amount; i++ {
        for _, coin := range coins {
            if i < coin {continue}
            dp[i] = min(dp[i], 1+dp[i-coin])
        }
    }
    if dp[amount] == amount+1 {
        return -1
    }
    return dp[amount]
}