leetocde464. 我能赢吗 dfs+状态压缩

  • https://leetcode.cn/problems/can-i-win

  • 给定两个整数 maxChoosableInteger (整数池中可选择的最大数)和 desiredTotal(累计和),若先出手的玩家能稳赢则返回 true ,否则返回 false 。假设两位玩家游戏时都表现 最佳 。

  • 在 “100 game” 这个游戏中,两名玩家轮流选择从 1 到 10 的任意整数,累计整数和,先使得累计整数和 达到或超过 100 的玩家,即为胜者。

  • 如果我们将游戏规则改为 “玩家不能 重复使用整数” 呢?

  • 例如,两个玩家可以轮流从公共整数池中抽取从 1 到 15 的整数(不放回),直到累计整数和 >= 100。

示例 1:

输入:maxChoosableInteger = 10, desiredTotal = 11
输出:false
解释:
无论第一个玩家选择哪个整数,他都会失败。
第一个玩家可以选择从 110 的整数。
如果第一个玩家选择 1,那么第二个玩家只能选择从 210 的整数。
第二个玩家可以通过选择整数 10(那么累积和为 11 >= desiredTotal),从而取得胜利.
同样地,第一个玩家选择任意其他整数,第二个玩家都会赢。
示例 2:

输入:maxChoosableInteger = 10, desiredTotal = 0
输出:true
示例 3:

输入:maxChoosableInteger = 10, desiredTotal = 1
输出:true
 

提示:

1 <= maxChoosableInteger <= 20
0 <= desiredTotal <= 300

题解

  • 最先想到的就是dfs穷举所有的可行的方案,先手全能赢,则返回true。并且这道题可以用记忆化搜索减少一些计算。题目有要求"玩家不能重复使用整数"所以可以状态压缩。

错解

  • 没有状态压缩可以使用set记录,并使用unordered_set choosable_copy = choosable;保存节点状态。
  • 这个错解是因为,像4 ,6这种,因为先手没有进行理智的选择,先手出于理智的考虑,需要再选定第一个值之后,去判断对手是否一定输,否则先手不能选这个值。
    leetocde464. 我能赢吗 dfs+状态压缩_第1张图片
class Solution {
public:
    int play_times = 0;//记录完了几次了
    bool flag = true;
    bool canIWin(int maxChoosableInteger, int desiredTotal) {
        // 预先判断
        // 5 50这种例子,1到5加到一起也到不了50,先手赢不了
        if (maxChoosableInteger * (maxChoosableInteger + 1) / 2 < desiredTotal)
            return false;
        // 20 1这种例子,先手直接赢
        if (maxChoosableInteger >= desiredTotal)
            return true;



        // 候选集,「公共整数池」
        unordered_set<int> choosable;
        for (int i = 1; i <= maxChoosableInteger; ++i) {
            choosable.insert(i);
        }
        // 判断当前做选择的玩家(先手),是否一定赢
        return dfs(choosable, 0, maxChoosableInteger, desiredTotal);
    }
    
    // 当前做选择的玩家是否一定赢
    bool dfs(unordered_set<int>& choosable, int sum, int maxChoosableInteger, int desiredTotal) {
       if(!flag){
           return false;
       }

        // 遍历可选择的公共整数
        for (int x : choosable) {
            // 如果选择了 x 以后,大于等于了 desiredTotal,结束游戏
            if (sum + x >= desiredTotal) {
                if(play_times %2 == 0){

                }    
                else{
                    flag = false;
                    return false;
                }
            }
            //否则继续游戏
            unordered_set<int> choosable_copy = choosable;//保存状态
            choosable_copy.erase(x);
             play_times++;
            if (!dfs(choosable_copy, sum + x, maxChoosableInteger, desiredTotal)) {
                return false;
            }else{
                
            }
            play_times--;
        }
        
        return true;
    }
    
};

base

  • 这个解法直接判断当前是否能赢
class Solution {
public:
    bool canIWin(int maxChoosableInteger, int desiredTotal) {
        // 预先判断
        // 5 50这种例子,1到5加到一起也到不了50,先手赢不了
        if (maxChoosableInteger * (maxChoosableInteger + 1) / 2 < desiredTotal)
            return false;
        // 20 1这种例子,先手直接赢
        if (maxChoosableInteger >= desiredTotal)
            return true;

        // 候选集,「公共整数池」
        unordered_set<int> choosable;
        for (int i = 1; i <= maxChoosableInteger; ++i) {
            choosable.insert(i);
        }
        // 判断当前做选择的玩家(先手),是否一定赢
        return dfs(choosable, 0, maxChoosableInteger, desiredTotal);
    }
    
    // 当前做选择的玩家是否一定赢
    bool dfs(unordered_set<int>& choosable, int sum, int maxChoosableInteger, int desiredTotal) {
        // 遍历可选择的公共整数
        for (int x : choosable) {
            // 如果选择了 x 以后,大于等于了 desiredTotal,当前玩家赢
            if (sum + x >= desiredTotal) {
                return true;
            }
            // 改变「公共整数池」
            // 为了避免影响当前的 choosable,因此复制了一份并擦出掉 x,传给对手
            unordered_set<int> choosable_copy = choosable;
            choosable_copy.erase(x);
            // 当前玩家选择了 x 以后,判断对方玩家一定输吗?
            if (!dfs(choosable_copy, sum + x, maxChoosableInteger, desiredTotal)) {
                return true;
            }
        }
        return false;
    }
    
};

状态压缩

  • 使用int整数(二进制32位)的每一位表示是否选择,一个整数就能表示一个set
class Solution {
public:
    bool canIWin(int maxChoosableInteger, int desiredTotal) {
        // 判断当前做选择的玩家(先手),是否一定赢
        // 开始时,state = 0,表示「公共整数集」中的所有数字都未被使用过
        return dfs(0, 0, maxChoosableInteger, desiredTotal);
    }
    
    // 当前做选择的玩家是否一定赢
    bool dfs(int state, int sum, int maxChoosableInteger, int desiredTotal) {
        // 遍历可选择的公共整数
        for (int x = 1; x <= maxChoosableInteger; ++x) {
            // 如果 x 已经被使用过了,则不能选择
            if ((1 << x) & state) continue;
            // 如果选择了 x 以后,大于等于了 desiredTotal,当前玩家赢
            if (sum + x >= desiredTotal) {
                return true;
            }
            // 当前玩家选择了 x 以后,判断对方玩家一定输吗?
            if (!dfs((1 << x) | state, sum + x, maxChoosableInteger, desiredTotal)) {
                return true;
            }
        }
        return false;
    }
    
};

记忆化

class Solution {
private:
    // visited[i] == 0,说明没有计算过
    // visited[i] == 1,说明计算过,结果为 true
    // visited[i] == 2,说明计算过,结果为 false
    int visited[1 << 21];
public:
    bool canIWin(int maxChoosableInteger, int desiredTotal) {
        // 预先判断
        // 5 50这种例子,1到5加到一起也到不了50,先手赢不了
        if (maxChoosableInteger * (maxChoosableInteger + 1) / 2 < desiredTotal)
            return false;
        // 20 1这种例子,先手直接赢
        if (maxChoosableInteger >= desiredTotal)
            return true;

        // 判断当前做选择的玩家(先手),是否一定赢
        // 开始时,state = 0,表示「公共整数集」中的所有数字都未被使用过
        return dfs(0, 0, maxChoosableInteger, desiredTotal);
    }
    
    // 当前做选择的玩家是否一定赢
    bool dfs(int state, int sum, int maxChoosableInteger, int desiredTotal) {
        if (visited[state] == 1) return true;
        if (visited[state] == 2) return false;
        // 遍历可选择的公共整数
        for (int x = 1; x <= maxChoosableInteger; ++x) {
            // 如果 x 已经被使用过了,则不能选择
            if ((1 << x) & state) continue;
            // 如果选择了 x 以后,大于等于了 desiredTotal,当前玩家赢
            if (sum + x >= desiredTotal) {
                visited[state] = 1;
                return true;
            }
            // 当前玩家选择了 x 以后,判断对方玩家一定输吗?
            if (!dfs((1 << x) | state, sum + x, maxChoosableInteger, desiredTotal)) {
                visited[state] = 1;
                return true;
            }
        }
        visited[state] = 2;
        return false;
    }
    
};

//参考:https://leetcode.cn/problems/can-i-win/solution/by-fuxuemingzhu-g16c/

你可能感兴趣的:(笔记,深度优先,算法)