极小化极大和动态规划之间的故事 2

今天我们继续上次没有讲完的故事。

1 我能赢吗

Leetcode 464：

    在 "100 game" 这个游戏中，两名玩家轮流选择从 1 到 10 的任意整数，累计
整数和，先使得累计整数和达到 100 的玩家，即为胜者。
    如果我们将游戏规则改为 “玩家不能重复使用整数” 呢？
    例如，两个玩家可以轮流从公共整数池中抽取从 1 到 15 的整数（不放回），直
到累计整数和 >= 100。
    给定一个整数 maxChoosableInteger （整数池中可选择的最大数）和另一个整数
 desiredTotal（累计和），判断先出手的玩家是否能稳赢（假设两位玩家游戏时都表
 现最佳）？
    你可以假设 maxChoosableInteger 不会大于 20， desiredTotal 不会大于 
300。

示例：
输入：
maxChoosableInteger = 10
desiredTotal = 11
输出：
false

解释：
    无论第一个玩家选择哪个整数，他都会失败。
    第一个玩家可以选择从 1 到 10 的整数。
    如果第一个玩家选择 1，那么第二个玩家只能选择从 2 到 10 的整数。
    第二个玩家可以通过选择整数 10（那么累积和为 11 >= desiredTotal），从而
取得胜利.
    同样地，第一个玩家选择任意其他整数，第二个玩家都会赢。

很显然，这又是一个极小化极大的问题。之前已经提到过，极小化极大往往会重复计算很多次，就比如这道题，先手拿走1后手拿走2，和先手拿走2后手拿走1，是完全等价的。因此，为了避免重复计算，我们需要把“1和2已经被拿走”这个状态以及它的答案（先手能否稳赢）记录下来。 但这就有一个问题，题目条件是整数池的大小 maxChoosableInteger 不大于20，也就是说整个动态规划空间最高会达到20维，这显然是不可接受的。因为这个，之前还犯了一个错误，就是我误以为只需要记录整数池内所有剩下数的和就可以了，如果是这样可行的话，那么动态规划空间就是一维的，但后来发现这是不可行的，因为整数池内还剩下1和2，和还剩下3的状态显然是不能等价的，但是它们的和都是3，因此不能只记录整数池内剩下整数的和。

既然动态空间的维度过高，现在就要想办法对状态进行压缩了。 对于一个数字来说，它只有两种状态：在整数池内，或不在。因此只需要一个比特，而非一个int型，就可以表示一个数的所有状态。而整数池最多有20个数，int型是32位，因此只需要一个int型，就可以表示所有数的所有状态。

对状态进行压缩以后，就可以写代码了。值得注意的是，当整数池内的所有数之和比目标数还要小的时候，两个玩家都无法获胜，这种情况也属于先手无法获胜，因此也要返回false。 这道题实现的代码如下：

class Solution 
{
public:
    bool canIWin(int maxChoosableInteger, int desiredTotal) 
    {
        int state = 0;
        map<int, int> hash;
        return minMax(maxChoosableInteger, desiredTotal, state, hash);
    }
    bool minMax(int maxChoosableInteger, int desiredTotal, int state, 
        map<int, int>& hash)
    {
        if (hash[state] == 1) { return true; }
        if (hash[state] == -1) { return false; }
        if (stateToSum(state, maxChoosableInteger) < desiredTotal) 
        { 
        	return false; 
        }

        int new_state;
        for (int i = 0; i < maxChoosableInteger; ++i)
        {
            if (!(state & (1 << i))) 
            {
                if (i + 1 >= desiredTotal) 
                { 
                	return hash[state] = true; 
                }
                new_state = state + (1 << i);
                hash[new_state] = minMax(maxChoosableInteger, 
                    desiredTotal - (i + 1), new_state, hash);
                if (!hash[new_state]) 
                { 
                	return hash[state] = true;
                }
            }
        }
        return hash[state] = false;
    }
    int stateToSum(int state, int maxChoosableInteger)
    {
        int ans = 0;
        for (int i = 0; i < maxChoosableInteger; ++i)
        {
            if (!(state & (1 << i))) 
            { 
            	ans += i + 1; 
            }
        }
        return ans;
    }
};

2 预测赢家

Leetcode 486：

    给定一个表示分数的非负整数数组。 玩家1从数组任意一端拿取一个分数，随后玩
家2继续从剩余数组任意一端拿取分数，然后玩家1拿，……。每次一个玩家只能拿取一个
分数，分数被拿取之后不再可取。直到没有剩余分数可取时游戏结束。最终获得分数总
和最多的玩家获胜。
    给定一个表示分数的数组，预测玩家1是否会成为赢家。你可以假设每个玩家的玩法
都会使他的分数最大化。

示例 1:
输入: [1, 5, 2]
输出: False
解释: 一开始，玩家1可以从1和2中进行选择。
如果他选择2（或者1），那么玩家2可以从1（或者2）和5中进行选择。如果玩家2选择
了5，那么玩家1则只剩下1（或者2）可选。
所以，玩家1的最终分数为 1 + 2 = 3，而玩家2为 5。
因此，玩家1永远不会成为赢家，返回 False。

示例 2:
输入: [1, 5, 233, 7]
输出: True
解释: 玩家1一开始选择1。然后玩家2必须从5和7中进行选择。无论玩家2选择了哪个，
玩家1都可以选择233。
最终，玩家1（234分）比玩家2（12分）获得更多的分数，所以返回 True，表示玩家1
可以成为赢家。

注意:
1 <= 给定的数组长度 <= 20.
数组里所有分数都为非负数且不会大于10000000。
如果最终两个玩家的分数相等，那么玩家1仍为赢家。

其实如果做过另一道题 leetcode 877：石子游戏 的话，就可以看出这个题是那道题的更一般情况，因此这里不再赘述，请参阅另一篇博客https://blog.csdn.net/weixin_43590611/article/details/104009097

实现代码如下：

class Solution 
{
public:
    bool PredictTheWinner(vector<int>& nums) 
    {
        int n = nums.size();
        vector<int> dp(nums);
        for (int len = 1; len < n; ++len)
        {
            for (int i = 0; i + len < n; ++i)
            {
                dp[i] = max(nums[i] + sum(i + 1, i + len, nums) - dp[i + 1],
                    nums[i + len] + sum(i, i + len - 1, nums) - dp[i]);
            }
        }
        return dp[0] * 2 >= accumulate(nums.begin(), nums.end(), 0);
    }
    int sum(int i, int j, vector<int>& nums)
    {
        return accumulate(nums.begin() + i, nums.begin() + j + 1, 0);
    }
};

3 猜数字大小2

Leetcode 375：

    我们正在玩一个猜数游戏，游戏规则如下：
    我从 1 到 n 之间选择一个数字，你来猜我选了哪个数字。
    每次你猜错了，我都会告诉你，我选的数字比你的大了或者小了。
    然而，当你猜了数字 x 并且猜错了的时候，你需要支付金额为 x 的现金。直到你
猜到我选的数字，你才算赢得了这个游戏。

示例:
n = 10, 我选择了8.
第一轮: 你猜我选择的数字是5，我会告诉你，我的数字更大一些，然后你需要支付5块。
第二轮: 你猜是7，我告诉你，我的数字更大一些，你支付7块。
第三轮: 你猜是9，我告诉你，我的数字更小一些，你支付9块。
游戏结束。8 就是我选的数字。
你最终要支付 5 + 7 + 9 = 21 块钱。

给定 n ≥ 1，计算你至少需要拥有多少现金才能确保你能赢得这个游戏。

这个题和典型的二分查找有点类似，不过不同之处在于这次我们要使得花的钱最少，而非查找次数最少。因此我们不能简单地每次都猜某个范围的中位数。至于具体猜哪个，最后花的钱最少，这是无法事先计算的，只能把这个范围内猜数的所有情况的花费都算出来，再进行比较，取最小值，才能得到最佳策略。值得注意的是，猜一个数，有可能出现目标与它相等，目标比它大，目标比它小三种情况，而猜某个数的的花费，应该是猜这个数之后可能出现的三种情况中，花费最大的那个。 实现的代码如下：

class Solution 
{
public:
    int getMoneyAmount(int n) 
    {   
        vector<vector<int> > dp(n + 1, vector<int> (n + 1, -1));
        dynamicPro(1, n, dp);
        return dp[1][n];
    }
    int dynamicPro(int left, int right, vector<vector<int> >& dp)
    {
        if (left > right) { return 0; }
        if (dp[left][right] != -1) { return dp[left][right]; }
        if (left == right) { return dp[left][right] = 0; }
        int res = INT_MAX;
        for (int i = left; i <= right; ++i)
        {
            res = min(res, 
                i + max(dynamicPro(left, i - 1, dp), 
                    dynamicPro(i + 1, right, dp)));
        }
        return dp[left][right] = res;
    }
};

更多精彩内容，敬请期待。