DP学习笔记

经典案例

动态规划经常用来求最优解。如何判断一个题目是否能用DP来解决，可以通过画递归树来确定是否存在重复子问题，如果存在，则可以通过存储子问题的解去优化算法，还有就是知道子问题解后，能否得到当前的解。DP最关键的是整理出重叠子问题，从而得到动态转移方程或动态转移表。

如何得到状态转移方程？可以在假设知道子问题解的情况下，看看如何得到当前的解。这是问题的关键。而前提是要定义清楚dp[i]=k的含义。

以下是一些典型案例。

0-1背包问题

题目：

背包总重量W，n个物品，每个物品重量不等，不能分割，期望选择几件物品，装载到背包中，不超过总重量的前提下，让包里面物品总重量最大

分析：

dp[i][w]=true/false 表示第i个物品选或者不选时，是否能达到w重量。算法复杂度为O(n*w)

动态转移方程

选第i个物品时：dp[i][w+item[i]]=dp[i-1][w]

不选第i个物品时：dp[i][w] = dp[i-1][w]

 代码

//n表示一共有n个物品，w表示最多承受的重量
func  knapsack(items []int, n, w int) int {
    //初始化状态转移表
    states := make([][]bool, n)
    for i := 0; i < n; i++ {
        states[i] = make([]bool, w+1)
    }

    //初始化第0行的状态
    states[0][0] = false
    if items[0] <= w {
        states[0][items[0]] = true
    }

    //开始状态转移，从第一行开始
    for i := 1; i < n; i++ {
        //不选第i个
        for j := 0; j <= w; j++ {
            states[i][j] = states[i-1][j]
        }
        //选第i个
        for j := 0; j <= w-items[i]; j++ {
            states[i][j+items[i]] = states[i-1][j]
        }
    }

    for i := w; i >= 0; i-- {
        if states[n-1][i] {
            return i
        }
    }
    fmt.Println(states)
    return 0
}

股票买卖时机（买卖一次求最大profit）

题目：

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。

分析：

首先将题目转化为每次交易的profit序列，有亏有赢，也就是对item[i]和item[i-1]做差，得到profit[i]序列，现在只需求连续求和运算，求出最大的和即可。

动态转移方程：

dp[i]=max(dp[i-1]+profit[i], profit[i])

代码：

if len(prices) <= 1 {
        return 0
    }

    diff := make([]int, len(prices)-1)
    for i:=1; i<len(prices); i++ {
        diff[i-1] = prices[i] - prices[i-1]
    }

    dp := make([]int, len(diff))
    dp[0] = diff[0]
    profit := diff[0]
    for i:=1; i<len(diff); i++ {
        dp[i] = Max(dp[i-1]+diff[i], diff[i])
        if profit < dp[i] {
            profit = dp[i]
        }
    }
    if profit < 0 {
        return 0
    }
    return profit

 

莱特斯坦距离（编辑距离）

 题目：

给定两个单词 word1 和 word2，计算出将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

插入一个字符
删除一个字符
替换一个字符

分析：

编辑距离：将一个字符串转化成另一个字符串，需要的最少编辑次数（增加一个字符，删除一个字符，替换一个字符）这类二维的题目（涉及到两个字符串的题目）可以用表格来帮助推到状态转移方程。

a,b表示两个字符串，dp[i][j]=k表示a/b的莱特斯坦距离。如果a[i]=b[j]，则dp[i][j]=dp[i-1][j-1]；如果a[i]!=b[j]，那么比较复杂，如果比如两个字符串为"a","c"，那么改任意一个即可，所以可以表示为dp[i][j]=min(dp[i-1][j],d[i][j-1])+1，如果是"ac"和"ag"，那么

if s1[i] == s2[j]:
    啥都别做（skip）
    i, j 同时向前移动
else:
三选一：
    插入（insert） dp[i][j]=dp[i][j-1]+1
    删除（delete）dp[i][j]=dp[i-1][j]+1
    替换（replace）dp[i][j]=dp[i-1][j-1]+1

注意，要考虑空串情况，比如a为""，b="abcf"这种情况。dp[i][j]=max{i,j}

状态转移方程

如果a[i]=b[j]：dp[i][j] = dp(i - 1, j - 1)

如果a[i]!=b[j]：dp[i][j] = min(dp(i, j - 1) + 1,  dp(i - 1, j) + 1, dp(i - 1, j - 1) + 1) 

代码：

func minDistance(a string, b string) int {
   lenA, lenB := len(a), len(b)
    if lenA == 0 || lenB == 0 {
        return int(math.Max(float64(lenA), float64(lenB)))
    }

    lev := make([][]int, lenA+1)
    for i := 0; i <= lenA; i++ {
        lev[i] = make([]int, lenB+1)
    }

    //初始化第一列
    for i := 0; i <= lenA; i++ {
        lev[i][0] = i
    }
    //初始化第一行
    for j := 0; j <= lenB; j++ {
        lev[0][j] = j
    }

    //计算
    for i := 1; i <= lenA; i++ {
        for j := 1; j <= lenB; j++ {
            if a[i-1] == b[j-1] {
                lev[i][j] = lev[i-1][j-1]
            } else {
                lev[i][j] = int(math.Min(math.Min(float64(lev[i-1][j]), float64(lev[i][j-1])), float64(lev[i-1][j-1]))) + 1
            }
        }
    }

    return lev[lenA][lenB]
}

最长公共子串

题目：

给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。

分析：

公共子串一定是连续的，所以dp[i][j]表示以a[i]和b[j]结尾的最长子串长度（如果不是以i,j结尾，那么dp[i+1][j+1]就不是子问题了）

动态转移方程：

情况一、a[i]=b[j]： dp[i][j] = dp[i-1][j-1]+1

情况二、a[i]不等于b[j]：dp [i][j]=0 （不等时得重新计算）

func longestCommonSubstring(a, b string) int {
    dp := make([][]int, len(a))
    for i, _ := range dp {
        dp[i] = make([]int, len(b))
    }

    //初始化第一列
    for i := 0; i < len(a); i++ {
        if a[i] == b[0] {
            dp[i][0] = 1
        } else {
            dp[i][0] = 0
        }
    }
    //初始化第一行
    for j := 0; j < len(b); j++ {
        if a[0] == b[j] {
            dp[0][j] = 1
        } else {
            dp[0][j] = 0
        }
    }

    longest := 0
    for i := 1; i < len(a); i++ {
        for j := 1; j < len(b); j++ {
            if a[i] == b[j] {
                dp[i][j] = dp[i-1][j-1] + 1
                longest = int(math.Max(float64(dp[i][j]), float64(longest)))
            } else {
                dp[i][j] = 0
            }
        }
    }

    return longest
}

 

最长公共子序列

题目：

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。

若这两个字符串没有公共子序列，则返回 0。

分析：

dp[i][j]=k表示长度为i的序列a和长度为j的序列b的最长公共子串的长度（子串不一定要以i和j结尾，这个很重要，和最长公共子串不一样）；当知道之前状态时，能否得到当前的状态，如果能，则可以用动态规划。

动态转移方程：

情况一、a[i]=b[j]： dp[i][j] = dp[i-1][j-1]+1

情况二、a[i]不等于b[j]：dp [i][j]=max{dp[i-1][j], dp[i][j-1]}

//最长公共子序列，可以不连续
func longestCommonSubsequence(a, b string) int {
    lenA, lenB := len(a), len(b)
    dp := make([][]int, lenA)
    for i, _ := range dp {
        dp[i] = make([]int, lenB)
    }

    //初始化dp第0列和第0行
    for j := 0; j < lenB; j++ {
        if a[0] == b[j] || (j >= 1 && dp[0][j-1] == 1) {
            dp[0][j] = 1
        } else {
            dp[0][j] = 0
        }
    }
    for i := 0; i < lenA; i++ {
        if a[i] == b[0] || (i >= 1 && dp[i-1][0] == 1) {
            dp[i][0] = 1
        } else {
            dp[i][0] = 0
        }
    }

    for i := 1; i < lenA; i++ {
        for j := 1; j < lenB; j++ {
            if a[i] == b[j] {
                dp[i][j] = dp[i-1][j-1] + 1
            } else {
                dp[i][j] = int(math.Max(float64(dp[i-1][j]), float64(dp[i][j-1])))
            }
        }
    }
    return dp[lenA-1][lenB-1]
}

最长单调递增子串

题目

给定一个字符串（或数组），求最长的连续单调自增子串。

分析

定位dp[i]=k表示以item[i]结尾的最长单调自增子串长度为k。那么如果item[i+1]比前一个大，dp[i+1]=dp[i]+1，如果小于等于前一个，那么dp[i+1]=1

动态转移方程

如果item[i]>item[i-1]，则dp[i]=dp[i-1]+1 

否则dp[i]=1

代码略。。。。

最长单调递增子序列

题目

给定一个无序的整数数组，找到其中最长上升子序列的长度。

分析

dp[i]=k表示以item[i]结尾的最长递增子序列的长度为k。当知道前i个dp的值后，怎么求第i+1个结尾的最长子序列长度呢：依此从后往前遍历，找到前i个中比item[i+1]小的item[j]，求出dp[i]=dp[j]+1，取最大值为dp[i]。算法复杂度为O(n*n)

状态转移方程

dp[i]=max{1, dp[j]+1} (item[i]>item[j], 0<=j<i)

代码

func lengthOfLIS(nums []int) int {
    if nums == nil || len(nums) == 0 {
        return 0
    }
    //初始化dp为1
    dp := make([]int, len(nums))
    longest := 1

    for i := 0; i < len(nums); i++ {
        dp[i] = 1
        for j := i - 1; j >= 0; j-- {
            if nums[i] > nums[j] {
                dp[i] = int(math.Max(float64(dp[i]), float64(dp[j]+1)))
                if longest < dp[i] {
                    longest = dp[i]
                }
            }
        }
    }
    return longest
}

乘积最大子序列

题目：

给定一个整数数组 nums ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）。

分析：

数字每乘一次，有五种情况，从正变成负（极大到极小）；从负变成正（极小变为极大）；变为0（重新开始算）；正数还是正数（变大）；负数还是负数（变小）；所以需要记录下最大值（正数），最小值（负数），如果是0，则重新开始算；所以需要两个dp数组用来记录以a[i]结束的最大值和最小值，防止乘后符号变化。

动态转移方程：

dpMax[i] = max{dp[i-1]*a[i], a[i], dpMin[i-1]*a[i]}

dpMin[i] = min{dp[i-1]*a[i], a[i], dpMin[i-1]*a[i]}

if len(nums) ==0 {
        return 0
    }
    dpMax := make([]int, len(nums))
    dpMin := make([]int, len(nums))
    dpMax[0] = nums[0]
    dpMin[0] = nums[0]
    max := nums[0]

    for i:=1; i<len(nums); i++ {
        dpMax[i] = getMax(dpMax[i-1]*nums[i], dpMin[i-1]*nums[i], nums[i])
        dpMin[i] = getMin(dpMax[i-1]*nums[i], dpMin[i-1]*nums[i], nums[i])
        if max < dpMax[i] {
            max = dpMax[i]
        }
    }

    return max

Coin Change （零钱兑换）

 题目：

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

你可以认为每种硬币的数量是无限的。

 分析：

dp[n]=k表示总金额为n时，最少需要k枚硬币。

动态转移方程：

n=0时，dp[n]=0

n<0时，dp[n]=-1

n>=1时，dp[n]=dp[n-coin]+1, coin为所有的coin[]中的一个，每一个都要试一试。因此算法复杂度为amount*len(coins)

代码

func coinChange(coins []int, amount int) int {
    if amount == 0 {
        return 0
    }
    if amount <= 0 {
        return -1
    }
    dp := make([]int, amount+1)
    dp[0] = 0
    for i := 1; i <= amount; i++ {
        dp[i] = math.MaxInt32
    }

    for i := 1; i <= amount; i++ {
        for _, coin := range coins {
            if i-coin < 0 || dp[i-coin] == -1 {
                continue
            }
            if dp[i] > dp[i-coin]+1 {
                dp[i] = dp[i-coin] + 1
            }
        }
        if dp[i] == math.MaxInt32 {
            dp[i] = -1
        }
    }
    return dp[amount]
}