Leetcode_552_学生出勤记录Ⅱ_数位dp

一道典型的数位dp，先划分一下状态

按照相邻有连续的0，1，2，3+个L以及存在0，1，2+个A来进行划分，求笛卡尔积，将同类的状态进行合并

---

0：相邻的前1位是P，且没有A
1：相邻的前2位是PL，且没有A
2：相邻的前2位是LL，且没有A

---

3：相邻的前1位是P/A，且有1个A
4：相邻的前2位是PL/AL，且有1个A
5：相邻的前2位是LL，且有1个A

---

6：已经有连续的三个L或者出现过2个A

---

我们可以用dp[i][j]表示前i位状态位j的个数的人数
我们所求的就是${\sum }_0^{5}dp[n][j]$

很容易观察到，其实每个dp[i]的状态都是由前一个dp[i-1]转移得到，那么我们用一个数组存7种状态的值就可以了

class Solution {
    public int checkRecord(int n) {
        int ans = 0;
        final int mod = 1000000007;
        int[] sta = {1,1,0,1,0,0,0};
        int[] temp = new int[7];
        for (int i = 2; i <= n; i++) {
            // 当前位是A
            temp[3] = sta[0] + sta[1] + sta[2];
            temp[6] = sta[3] + sta[4] + sta[5] + sta[6];
            // 当前位是L
            temp[1] = sta[0];
            temp[2] = sta[1];
            temp[4] = sta[3];
            temp[5] = sta[4];
            temp[6] += sta[2] + sta[6];
            // 当前位是P
            temp[0] = sta[0] + sta[1] + sta[2];
            temp[3] += sta[3] + sta[4] + sta[5];
            temp[6] += sta[6];

            for (int j = 0; j < 7; j++) {
                sta[i] = temp[i] % mod;
            }
        }
        for (int i = 0; i <= 5; i++) {
            ans = (ans + sta[i]) % mod;
        }
        return ans;
    }

    public static void main(String[] args) {
        System.out.println(new Solution().checkRecord(2));
    }
}

这边状态更新可以再合并一下，最后那个sta[6]用不到，也可以扔掉；前面每一次加法都得取模

class Solution {
    public int checkRecord(int n) {
        int ans = 0;
        final int mod = 1000000007;
        int[] sta = {1, 1, 0, 1, 0, 0};
        int[] temp = new int[6];
        for (int i = 2; i <= n; i++) {
            temp[0] = ((sta[0] + sta[1]) % mod + sta[2]) % mod;
            temp[1] = sta[0];
            temp[2] = sta[1];
            temp[3] = (((temp[0] + sta[3]) % mod + sta[4]) % mod + sta[5]) % mod;
            temp[4] = sta[3];
            temp[5] = sta[4];

            for (int j = 0; j < 6; j++) {
                sta[j] = temp[j] % mod;
            }
        }
        for (int i = 0; i < 6; i++) {
            ans = (ans + sta[i]) % mod;
        }
        return ans;
    }

    public static void main(String[] args) {
        System.out.println(new Solution().checkRecord(10101));
    }
}

再进一步优化，可以使用矩阵快速幂去加速中间的状态转移，时间复杂度可以进一步降低到logn
$\left[\begin{array}{cccccc}1& 1& 1& 0& 0& 0\\ 1& 0& 0& 0& 0& 0\\ 0& 1& 0& 0& 0& 0\\ 1& 1& 1& 1& 1& 1\\ 0& 0& 0& 1& 0& 0\\ 0& 0& 0& 0& 1& 0\end{array}\right]$