leetcode 375. Guess Number Higher or Lower II 猜数游戏+动态规划DP+最大最小化问题

We are playing the Guess Game. The game is as follows:

I pick a number from 1 to n. You have to guess which number I picked.

Every time you guess wrong, I’ll tell you whether the number I picked is higher or lower.

However, when you guess a particular number x, and you guess wrong, you pay $x. You win the game when you guess the number I picked.

Example:

n = 10, I pick 8.

First round: You guess 5, I tell you that it’s higher. You pay 5.
Second round: You guess 7, I tell you that it’s higher. You pay 7.
Third round: You guess 9, I tell you that it’s lower. You pay 9.

Game over. 8 is the number I picked.

You end up paying 5 + 7 + 9 = 21.
Given a particular n ≥ 1, find out how much money you need to have to guarantee a win.

在1-n个数里面,我们任意猜一个数(设为i),保证获胜所花的钱应该为 i + max(w(1 ,i-1), w(i+1 ,n)),这里w(x,y))表示猜范围在(x,y)的数保证能赢应花的钱,则我们依次遍历 1-n作为猜的数,求出其中的最小值即为答案,即最小的最大值问题

建议和这道题leetcode 374. Guess Number Higher or Lower 猜数游戏一起学习

代码如下:


/* 
 * 这个事第二次遇到这样的DP动态规划问题
 * 我们需要按照一定的顺序计算dp的值,由于计算dp[i][j]时我们需要计算dp[i][j-1],dp[i+1][j],
 * 所以我们按照j-i递增的顺序计算,即l区间长度len由短到长的顺序计算。
 * */
class Solution 
{
    public int getMoneyAmount(int n) 
    {
        int [][]dp=new int[n+1][n+1];
        for(int len=1;len<n;len++)
        {
            for(int i=0;i+len<=n;i++)
            {
                int j=i+len;
                int one=Integer.MAX_VALUE;
                for(int k=i;k<=j;k++)
                {
                    int tmp=k+ Math.max(k-1>=i?dp[i][k - 1]:0,k+1<=j?dp[k + 1][j]:0);
                    one=Math.min(one, tmp);
                }
                dp[i][j]=one;
            }
        }

        return dp[1][n];
        //return cost(dp,1,n);
    }

    /*
     * ,在1-n个数里面,我们任意猜一个数(设为i),保证获胜所花的钱应该为 i + max(w(1 ,i-1), w(i+1 ,n)),
     * 这里w(x,y))表示猜范围在(x,y)的数保证能赢应花的钱,则我们依次遍历 1-n作为猜的数,
     * 求出其中的最小值即为答案,即最小的最大值问题
     * */
    public int cost(int[][] dp, int beg, int end) 
    {
        if(beg>=end)
            return 0;
        else if(dp[beg][end]!=0)
            return dp[beg][end];
        else 
        {
            int one=Integer.MAX_VALUE;
            for(int i=beg;i<=end;i++)
            {
                int tmp=i+Math.max(cost(dp, beg, i-1), cost(dp, i+1, end));
                one=Math.min(one, tmp);
            }
            dp[beg][end]=one;
            return one;
        }
    }
}

下面是C++的做法,很不错,就是按照length去做DP动态规划

DFS的做法很不错,和这一道题leetcode 329. Longest Increasing Path in a Matrix 矩阵中寻找最长递增序列 + 一个典型的深度优先遍历DFS的做法 的做法很相似,建议一起学习

代码如下:

#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <queue>
#include <stack>
#include <string>
#include <climits>
#include <algorithm>
#include <sstream>
#include <functional>
#include <bitset>
#include <numeric>
#include <cmath>
#include <regex>

using namespace std;


class Solution 
{
public:
    int getMoneyAmount(int n)
    {
        vector<vector<int>> dp(n + 1, vector<int>(n + 1, 0));
        return dfs(dp, 1, n);
    }

    int dfs(vector<vector<int>>& dp, int beg, int end)
    {
        if (beg >= end)
            return 0;
        else if (dp[beg][end] != 0)
            return dp[beg][end];
        else
        {
            int one = INT_MAX;
            for (int i = beg; i <= end; i++)
            {
                int a = i - 1 >= beg ? dfs(dp,beg,i-1) : 0;
                int b = i + 1 <= end ? dfs(dp,i+1,end) : 0;
                int tmp = i + max(a, b);
                one = min(one, tmp);
            }
            dp[beg][end] = one;
            return dp[beg][end];
        }
    }

    int getMoneyAmountByDP(int n) 
    {
        vector<vector<int>> dp(n + 1, vector<int>(n + 1, 0));
        for (int len = 1; len <= n; len++)
        {
            for (int i = 0; i + len <= n; i++)
            {
                int j = i + len, one = INT_MAX;
                for (int k = i; k <= j; k++)
                {
                    int a = k - 1 >= i ? dp[i][k - 1] : 0;
                    int b = k + 1 <= j ? dp[k + 1][j] : 0;
                    int tmp = k + max(a,b);
                    one = min(one, tmp);
                }
                dp[i][j] = one;
            }
        }
        return dp[1][n];
    }
};
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值