375猜数字大小 II（动态规划，区间动态规划，矩阵链乘法——总结）

1、题目描述

我们正在玩一个猜数游戏，游戏规则如下：

我从 1 到 n 之间选择一个数字，你来猜我选了哪个数字。

每次你猜错了，我都会告诉你，我选的数字比你的大了或者小了。

然而，当你猜了数字 x 并且猜错了的时候，你需要支付金额为 x 的现金。直到你猜到我选的数字，你才算赢得了这个游戏。

2、示例

n = 10, 我选择了8.

第一轮: 你猜我选择的数字是5，我会告诉你，我的数字更大一些，然后你需要支付5块。
第二轮: 你猜是7，我告诉你，我的数字更大一些，你支付7块。
第三轮: 你猜是9，我告诉你，我的数字更小一些，你支付9块。

游戏结束。8 就是我选的数字。

你最终要支付 5 + 7 + 9 = 21 块钱。
给定 n ≥ 1，计算你至少需要拥有多少现金才能确保你能赢得这个游戏。

3、题解

动态规划题型总共分为五类：

• 矩阵链乘法：这类题型是经典的区间动态规划，如312戳气球和375猜数字大小 II，dp[i][j]表示区间[i,j]内的最优值，一般是三重循环，起始点i从n慢慢到0，终止点j从i慢慢到n，k从起始点i到终止点j，模板如下：

for(int i=n;i>=1;i--)
{
	for(int j=i;j<=n;j++)
	{
		for(int k=i+1;k<=j-1;k++)
			dp[i][j]=min(dp[i][j],k+max(dp[i][k-1],dp[k+1][j]));
	}
}

for(int i=nums.size()-2;i>=0;i--)
{
	for(int j=i+2;j<nums.size();j++)
	{
		for(int k=i+1;k<j;k++)
			dp[i][j]=max(dp[i][j],dp[i][k]+dp[k][j]+nums[i]*nums[k]*nums[j]);
	}
}

• 单序列问题：这类题型是经典的一维动态规划问题，如70爬楼梯，这种类型只有一重循环遍历，得到动态规划方程即可，模板如下：

for (int i = 2; i < n; i++)
{
	dp[i] = dp[i - 1] + dp[i - 2];
}

• 完全背包问题：这类题型是经典的一维动态规划问题，和01背包问题类似，只不过完全背包可以无限次的存取物品，01背包要么0要么1，如322零钱兑换和279完全平方数，dp[i]表示填充的容量为i时的最优值，有个具体的最大容量w，从nums数组中无限次挑选num装满w使得获得最大收益，一般是第一重循环遍历从1到w，第二重循环遍历nums中的元素进行优化看是否能得到更优值，模板如下：

for(int i=1;i<=n;i++)
{
	int minval=INT_MAX;
	for(int j=1;j*j<=i;j++)
	{
		minval=min(minval,dp[i-j*j]);
	}
	dp[i]=1+minval;
}

for(int i=1;i<=amount;i++)
{
	for(int j=0;j<coins.size();j++)
	{
		if(i-coins[j]>=0&&dp[i-coins[j]]!=-1)
			dp[i]=dp[i]==-1?dp[i-coins[j]]+1:min(dp[i],dp[i-coins[j]]+1);
	}
}

• 01背包问题：这类题型是经典的一维动态规划问题，如416分割等和子集和494目标和，dp[i]表示填充容量为i的最优值，有个具体的最大容量w，从nums数组中挑选num装满w使得获得最大收益，一般是遍历nums中所有元素，对每个元素num从容量w到num进行优化看是否能得到更优值，模板如下：

//dp[i]表示填充容量为i的方法个数
dp[0]=1;
for(auto num:nums)
{
    for(int j=w;j>=num;j--)
    {
        dp[j]+=dp[j-num];
    }
}
//dp[i]表示是否能填充容量为i
dp[0]=true;
for(auto num:nums)
{
    for(int j=w;j>=num;j--)
    {
        dp[j]=dp[j]||dp[j-num];
    }
}

• 最长公共子序列：这类题型是经典的二维动态规划问题，如72编辑距离和1143最长公共子序列，dp[i][j]表示text1前i个字符与text2前j个字符时最长公共子序列的大小，这种题目一般有两个对象每个对象对应dp的一个维度，双重循环分别遍历数组1和数组2里面的值，模板如下：

for(int i=0;i<text1.size();i++)
{
	for(int j=0;j<text2.size();j++)
	{
		if(text1[i]==text2[j])
			dp[i+1][j+1]=dp[i][j]+1;
		else
			dp[i+1][j+1]=max(dp[i][j],max(dp[i][j+1],dp[i+1][j]));
	}
}

基本思想：动态规划，区间动态规划，矩阵链乘法，和312戳气球题目类似

• dp[i][j]表示从[i,j]中猜出正确数字所需要的最少花费金额
• 当i==j时，只有一个数字，不用猜，花费金额为0
• 当i+1==j时，两个数字，只要猜小的那个数字，剩下的就是大的数字，花费金额为i
• 当其他情况，dp[i][j]=min(dp[i][j],k+max(dp[i][k-1],dp[k+1][j]))

#include<vector>
#include<iostream>
#include<algorithm>
#include<deque>
using namespace std;
class Solution {
public:
    int getMoneyAmount(int n) {
        //基本思想：动态规划，区间动态规划，矩阵链乘法，和312戳气球题目类似
        //dp[i][j]表示从[i,j]中猜出正确数字所需要的最少花费金额
        //当i==j时，只有一个数字，不用猜，花费金额为0
        //当i+1==j时，两个数字，只要猜小的那个数字，剩下的就是大的数字，花费金额为i
        //当其他情况，dp[i][j]=min(dp[i][j],k+max(dp[i][k-1],dp[k+1][j]))
        vector<vector<int>> dp(n+1,vector<int>(n+1,1e9));
        for(int i=n;i>=1;i--)
        {
            for(int j=i;j<=n;j++)
            {
                if(i==j)
                    dp[i][j]=0;
                else if(i+1==j)
                    dp[i][j]=i;
                else
                {
                    for(int k=i+1;k<=j-1;k++)
                        dp[i][j]=min(dp[i][j],k+max(dp[i][k-1],dp[k+1][j]));
                }
            }
        }
        return dp[1][n];
    }
};
int main()
{
    Solution solute;
    int n=15;
    cout<<solute.getMoneyAmount(n)<<endl;
    return 0;
}