算法题：动态规划之学生出勤记录II

题目

给定一个正整数 n，返回长度为 n 的所有可被视为可奖励的出勤记录的数量。答案可能非常大，你只需返回结果mod 109 + 7的值。

学生出勤记录是只包含以下三个字符的字符串：

‘A’ : Absent，缺勤
‘L’ : Late，迟到
‘P’ : Present，到场
如果记录不包含多于一个’A’（缺勤）或超过两个连续的’L’（迟到），则该记录被视为可奖励的。

示例 1:

输入: n = 2
输出: 8 
解释： 
有8个长度为2的记录将被视为可奖励：
"PP" , "AP", "PA", "LP", "PL", "AL", "LA", "LL"
只有"AA"不会被视为可奖励，因为缺勤次数超过一次。

注意：n 的值不会超过100000。

思路

根据题目的意思，其实可以理解为：在三个不同的字符中，有放回的抽取 n 个字符，求满足设定规则的可能性。（这么理解是方便举一反三，解决思路和这种理解关系不大）。按照动态规划的思想，可以设定三个数组 P、 A、 L ，分别存储以 P、A、L结尾的可能性，具体点：P[i] 就是当抽取序列长度为 i 时，以 P 结尾的序列的种数，A，L同理。因为这样做可以得到P、A、L的递推公式，就达到了动态规划的目的。

具体方法以及推导

P[i] = P[i-1] + A[i-1] + L[i-1]
L[i] = P[i-1] + A[i-1] + A[i-2] + P[i-2]
A[i] = A[i-1] + A[i-2] + A[i-3]

第一个P，因为P接在任何字符后边都符合规则，可以给奖励，所以就是 i -1 长度三种字符结尾的和

第二个L，首先，L接在A或者P后都可以，所以前两项相加，接在L后边时，需要保证这个L前边不是 L，也就是 i - 2 长度的序列不能以 L 结尾，也就是 A 和 P 结尾，所以再加上后两项。

第三个A 比较复杂，因为只能有一个A，所以 i 长度序列要以A结尾，需要保证 i - 1 长度的序列中没有 A

推导A：

先引入 naP 和 naL数组分别表示没有A，并且分别以P、L结尾的序列的可能次数。

具体来说，naP[i] 表示 i 长度序列以 P 结尾，并且不包含字符 A，naL同理。

所以： A[i] = naP[i - 1] + naL[i - 1]

接着来看 naP[i] 的递推 ，naP[i] = naP[i - 1] + naL[i -1] 。(因为是不含A的可能性和，所以只有 naP[i - 1] + naL[i - 1])

可以看到这个递推和 A[i] 的递推一毛一样，因为可能次数一样，可以等价 naP[ i -1] = A[i - 1]

所以 A[i] = naP[i - 1] + naL[i - 1] 可以写成 A[i] = A[i - 1] + naL[i - 1]

现在只剩下 naL[i] 的递推，naL[i] = naP[i - 1] + naP[ i - 2]
(因为不含A，所以没有A[i - 1]，又因为L不能连续，与上边 L[i] 的递推同理，所以后半部分只剩 naP[i - 2] 这一项)

继续：那么 naL[i - 1] = naP[i - 2] + naP[i - 3]，naP[i - 2] 和 naP[i - 3] 等价 A[i - 2] 和 A[i - 3]

最后： A[i] = A[i-1] + A[i-2] + A[i-3]

总结

采用三个数组的递推公式，得到所求长度的所有合法可能性，naP 和 naL只是中间用来推导，程序中不涉及。

因为数组从 0 开始，所以 A[0] 对应序列长度为 1 的可能性，最后结果就是序列长度为 n 的三种字符结尾的所有可能性之和，也就是 A[n - 1] + P [n - 1] + L[n -1]

最后

由于数据可能比较大，所以对 10^9 + 7 求模，中间值也比较大，所以在求每个数组值时就求模

代码

c++ 语言实现，思路理解后，语言无所谓。

#include<iostream>
#include<vector>

using namespace std;

// 学生出勤记录II，题目是dp的问题，在 3 个字符里有放回的抽 n 次，抽出来的序列满足一定规则的方式

// 思路：根据题目的限制规则 3 个字符分别建立三个数组，存储以他们结尾的可能数， P[i] 存储 长度 i 的序列以P结尾的可能数
// 因为这么设计可以构造出 dp 的形式，即递推的形式。
// P[i] = P[i-1] + A[i-1] + L[i-1]
// L[i] = P[i-1] + A[i-1] + A[i-2] + p[i-2]
// A[i] = A[i-1] + A[i-2] + A[i-3]
class Solution {
public:
	int checkRecord(int n) 
	{
		// 判断特殊与边界
		if (0 == n)
		{
			return 0;
		}
		if (1 == n)
		{
			return 3;
		}
		if (2 == n)
		{
			return 8;
		}
		long M = 1000000007;
		vector<int> P(n), A(n), L(n);
		// 这里 A[0] 表示 长度为 1 
		// 不可以推导求的先计算出来
		A[0] = 1; A[1] = 2; A[2] = 4;
		P[0] = 1;
		L[0] = 1;
		L[1] = 3;
		for (int i = 1; i < n; i++)
		{
			P[i] = (P[i - 1] % M + A[i - 1] % M + L[i - 1] % M)% M;
			if (i > 1)
			{
				L[i] = (P[i - 1] % M + A[i - 1] % M + P[i - 2] % M + A[i - 2] % M) % M;
			}
			if (i > 2)
			{
				A[i] = (A[i - 1] % M + A[i - 2] % M + A[i - 3] % M) % M;
			}
		}

		return (A[n - 1] % M + P[n - 1] % M + L[n - 1] % M) % M;
	}
};

最最后

上边这种解法属于O（n），时间复杂度其实挺高，但是思路比较好理解。还有几种更简单的方法附在参考链接。

还有一种解法非常简单，是leetcode上战胜100%的，20ms，代码如下。（还没理解，等理解了加思路）

class Solution {
public:
    int checkRecord(int n) {
        static const long long M = 1000000007;
        long long a0l0 = 1, a0l1 = 0, a0l2 = 0, a1l0 = 0, a1l1 = 0, a1l2 = 0;
        for (int i = 0; i <= n; ++i) {
            auto new_a0l0 = (a0l0 + a0l1 + a0l2) % M;
            a0l2 = a0l1;
            a0l1 = a0l0;
            a0l0 = new_a0l0;
            auto new_a1l0 = (a0l0 + a1l0 + a1l1 + a1l2) % M;
            a1l2 = a1l1;
            a1l1 = a1l0;
            a1l0 = new_a1l0;
        }
        return static_cast<int>(a1l0);
    }
};

参考链接

o（logn）：https://leetcode.com/problems/student-attendance-record-ii/discuss/101633/improving-the-runtime-from-on-to-olog-n
O （n）：https://leetcode.com/problems/student-attendance-record-ii/discuss/101638/simple-java-on-solution

有问题望指出