leetcode[每日一题]552. 学生出勤记录 II

题目描述
可以用字符串表示一个学生的出勤记录，其中的每个字符用来标记当天的出勤情况（缺勤、迟到、到场）。记录中只含下面三种字符：
‘A’：Absent，缺勤
‘L’：Late，迟到
‘P’：Present，到场
如果学生能够 同时 满足下面两个条件，则可以获得出勤奖励：

按总出勤 计，学生缺勤（‘A’）严格少于两天。
学生 不会 存在 连续 3 天或 连续 3 天以上的迟到（‘L’）记录。
给你一个整数 n ，表示出勤记录的长度（次数）。请你返回记录长度为 n 时，可能获得出勤奖励的记录情况 数量 。答案可能很大，所以返回对 109 + 7 取余 的结果。
示例1：
输入：n = 2
输出：8
解释：
有 8 种长度为 2 的记录将被视为可奖励：
“PP” , “AP”, “PA”, “LP”, “PL”, “AL”, “LA”, “LL”
只有"AA"不会被视为可奖励，因为缺勤次数为 2 次（需要少于 2 次）。
示例2：
输入：n = 1
输出：3
示例3：
输入：n = 10101
输出：183236316

题解：从dfs遍历到记忆数组再到dp
参考题解
part1 dfs
本质上来说是遍历所有情况

class Solution {
public:
    int mod = 1000000007;
    int dfs(int day, int n, int absent, int late){
        if(day >= n){
            return 1;
        }
        int ans = 0;
        //present 随意插入 只需要day+1
        ans = (ans + dfs(day+1, n, absent, 0)) % mod;
        //absent最多只能有一个不然无奖励
        if(absent < 1){
            ans = (ans + dfs(day+1, n, 1, 0)) % mod;
        }
        //late 最多有连续的两个
        if(late < 2){
            ans = (ans +dfs(day + 1, n, absent, late+1)) %mod;
        }
        return ans;
    }
    int checkRecord(int n) {
        return dfs(0, n, 0, 0);
    }
};

part加一个memo数组 记录所有的状态
本质上就是剪枝

class Solution {
public:
    int mod = 1000000007;
    int dfs(int day, int n, int absent, int late, int memo[][2][3]){
        if(day >= n){
            return 1;
        }
        //如果当前状态已存在直接获取
        if (memo[day][absent][late]!=0)
            return memo[day][absent][late];
        int ans = 0;
        ans = (ans + dfs(day+1, n, absent, 0, memo)) % mod;
        if(absent < 1){
            ans = (ans + dfs(day+1, n, 1, 0, memo)) % mod;
        }
        if(late < 2){
            ans = (ans +dfs(day + 1, n, absent, late+1, memo)) %mod;
        }
        memo[day][absent][late] = ans;
        return ans;
    }
    int checkRecord(int n) {
        int memo[n][2][3];
        memset(memo, 0, sizeof(memo));
        return dfs(0, n, 0, 0, memo);
    }
};

part3 dp动态规划
难点 ：考虑所有的情况不能漏

class Solution {
public:
    int checkRecord(int n) {
        int mod = 1000000007;
        long dp[n][2][3];
        memset(dp, 0, sizeof(dp));
        dp[0][0][0] = 1;
        dp[0][1][0] = 1;
        dp[0][0][1] = 1;
        for (int i=1;i<n;i++){
           // 本次填入P，分成前一天累计了0个A和1个A两种情况
            dp[i][0][0] = (dp[i - 1][0][0] + dp[i - 1][0][1] + dp[i - 1][0][2]) % mod;
            dp[i][1][0] = (dp[i - 1][1][0] + dp[i - 1][1][1] + dp[i - 1][1][2]) % mod;
            // 本次填入A，前一天没有累计A都能转移过来
            // 这行可以与上面一行合并计算，为了方便理解，我们分开，下面会合并
            dp[i][1][0] = (dp[i][1][0] + dp[i - 1][0][0] + dp[i - 1][0][1] + dp[i - 1][0][2]) % mod;
            // 本次填入L，前一天最多只有一个连续的L，分成四种情况
            dp[i][0][1] = dp[i - 1][0][0];
            dp[i][0][2] = dp[i - 1][0][1];
            dp[i][1][1] = dp[i - 1][1][0];
            dp[i][1][2] = dp[i - 1][1][1];
        }
        long ans = 0;
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                ans = (ans + dp[n - 1][i][j]) % mod;
            }
        }
        return (int) ans;
    }
};

part4 动态规划 + 降维I

class Solution {
    int MOD = 1000000007;
    public:
        int checkRecord(int n) {
        long dp[2][3];
        memset(dp, 0, sizeof(dp));
        // 初始值
        dp[0][0] = 1;
        dp[1][0] = 1;
        dp[0][1] = 1;
        for (int i = 1; i < n; i++) {
            long newDp[2][3];
            memset(newDp, 0, sizeof(newDp));
            newDp[0][0] = (dp[0][0] + dp[0][1] + dp[0][2]) % MOD;
            // 把方法三中间两个一样的状态合并为一行
            newDp[1][0] = (dp[1][0] + dp[1][1] + dp[1][2] + dp[0][0] + dp[0][1] + dp[0][2]) % MOD;
            newDp[0][1] = dp[0][0];
            newDp[0][2] = dp[0][1];
            newDp[1][1] = dp[1][0];
            newDp[1][2] = dp[1][1];
            memcpy(dp,newDp,sizeof(newDp));
        }
        long ans = 0;
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                ans = (ans + dp[i][j]) % MOD;
            }
        }
        return (int) ans;
    }
};