Java&C++题解与拓展——leetcode464.我能赢吗【不太懂的记忆化搜索与状态压缩】

AnjaVon

已于 2022-05-22 15:15:12 修改

阅读量198

点赞数 1

分类专栏： leetcode 文章标签： java c++ leetcode

于 2022-05-22 14:52:19 首次发布

本文链接：https://blog.csdn.net/sinat_41135487/article/details/124907764

版权

leetcode 专栏收录该内容

96 篇文章 1 订阅

订阅专栏

每日一题做题记录，参考官方和三叶的题解

题目要求

在这里插入图片描述

思路一：博弈论DP（超时）

用记忆化搜索记录状态，判断当前回合能否赢；
定义一个二进制数 $s t a t e$ 表示可选择的数；
定义递归函数DFS(state, tot, k)，参数分别为当前状态、当前累加和、当前轮数：
- $k$ 从 $0$ 开始，所以偶数表示先手；
- 计算当前轮是否能达到最终状态，先手赢后手输，也就是偶数轮返回 $1$ ，奇数轮返回 $- 1$ 。
判定最终结果，是否稳赢，即DFS(0, 0, 0)是否为 $1$ 。

Java

class Solution {
    int mci, dt;
    int[][] f = new int[1 << 20][2];
    public boolean canIWin(int maxChoosableInteger, int desiredTotal) {
        this.mci = maxChoosableInteger;
        this.dt = desiredTotal;
        if(dt == 0)
            return true;
        return DFS(0, 0, 0) == 1;
    }
    // 1赢、-1输
    int DFS(int state, int tot, int k) {
        if(state == ((1 << mci) - 1) && tot < dt) // 全用过还不到
            return -1;
        if(f[state][k % 2] != 0)
            return f[state][k % 2];
        int res = k % 2 == 0 ? 1 : -1; // 偶数轮（先手）赢，奇数轮输
        for(int i = 0; i < mci; i++) {
            if(((state >> i) & 1) == 1) // 已用过
                continue;
            if(tot + i + 1 >= dt) // 当前轮数赢
                return f[state][k % 2] = res;
            if(DFS(state | (1 << i), tot + i + 1, k + 1) == res)
                return f[state][k % 2] = res;
        }
        return f[state][k % 2] = -res;
    }
}

时间复杂度： $O(2^{n +1}\times n)$ ，其中 $n$ 为最大可选数字（maxChoosableInteger）
空间复杂度： $O(2^{n +1})$

C++

class Solution {
    int mci, dt;
    int f[1 << 20][2];
public:
    bool canIWin(int maxChoosableInteger, int desiredTotal) {
        this->mci = maxChoosableInteger;
        this->dt = desiredTotal;
        if(dt == 0)
            return true;
        if(mci * (mci + 1) / 2 < dt)
            return false;
        return DFS(0, 0, 0) == 1;
    }
    // 1赢、-1输
    int DFS(int state, int tot, int k) {
        if(f[state][k % 2] != 0)
            return f[state][k % 2];
        int res = k % 2 == 0 ? 1 : -1; // 偶数轮（先手）赢，奇数轮输
        for(int i = 0; i < mci; i++) {
            if(((state >> i) & 1) == 1) // 已用过
                continue;
            if(tot + i + 1 >= dt) // 当前轮数赢
                return f[state][k % 2] = res;
            if(DFS(state | (1 << i), tot + i + 1, k + 1) == res)
                return f[state][k % 2] = res;
        }
        return f[state][k % 2] = -res;
    }
};

时间复杂度： $O(2^{n +1}\times n)$ ，其中 $n$ 为最大可选数字（maxChoosableInteger）
空间复杂度： $O(2^{n +1})$

思路二：状态压缩

不记录轮数维度，极短当前状态能否获胜
调整重点

将记录『原始回合的先后手发起与原始回合的先后手获胜情况』调整为『当前回合发起和当前回合获胜情况』。

Java

class Solution {
    int mci, dt;
    int[] f = new int[1 << 20];
    public boolean canIWin(int maxChoosableInteger, int desiredTotal) {
        this.mci = maxChoosableInteger;
        this.dt = desiredTotal;
        if(mci * (mci + 1) / 2 < dt)
            return false;
        if(dt == 0)
            return true;
        return DFS(0, 0) == 1;
    }
    // 1赢、-1输
    int DFS(int state, int tot) {
        if(f[state] != 0)
            return f[state];
        for(int i = 0; i < mci; i++) {
            if(((state >> i) & 1) == 1) // 已用过
                continue;
            if(tot + i + 1 >= dt) // 当前轮数赢
                return f[state] = 1;
            if(DFS(state | (1 << i), tot + i + 1) == -1) // 对方输
                return f[state] = 1;
        }
        return f[state] = -1;
    }
}

时间复杂度： $O(2^n\times n)$ ，其中 $n$ 为最大可选数字（maxChoosableInteger）
空间复杂度： $O(2^n)$

C++

class Solution {
    int mci, dt;
    int f[1 << 20];
public:
    bool canIWin(int maxChoosableInteger, int desiredTotal) {
        this->mci = maxChoosableInteger;
        this->dt = desiredTotal;
        if(dt == 0)
            return true;
        if(mci * (mci + 1) / 2 < dt)
            return false;
        return DFS(0, 0) == 1;
    }
    // 1赢、-1输
    int DFS(int state, int tot) {
        if(f[state] != 0)
            return f[state];
        for(int i = 0; i < mci; i++) {
            if(((state >> i) & 1) == 1) // 已用过
                continue;
            if(tot + i + 1 >= dt) // 当前轮数赢
                return f[state] = 1;
            if(DFS(state | (1 << i), tot + i + 1) == -1) // 对方输
                return f[state] = 1;
        }
        return f[state] = -1;
    }
};