Attack on Titans ZOJ - 3747

题目传送门

题意：给n个士兵排队，每个士兵三种G、R、P可选，求至少有m个连续G士兵，最多有k个连续R士兵的排列的。

思路：这个题目至多的情况十分的好考虑，如果是至少的情况是可以转换为至多的情况：至多k个连续R,至多n个连续G情况 【减去】至多k个连续R，至多（m-1）个连续G情况。

当第i个为R时

如果i<=k 时 无论怎么放都不会超过u个连续的R这个限制条件 所以dp[i][1]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2];

如果i=k+1时，要排除前k个都放了R的情况，dp[i][1]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2]-1;

如果i>k+1时，要排除从i-1到i-k位置都放了R的情况，dp[i][1]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2]-dp[i-k-1][0]-dp[i-k-1][2];

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>

#define MAXN 1000010
#define MAXE 5
#define INF 1000000000
#define MOD 1000000007
#define LL long long
#define pi acos(-1.0)

using namespace std;

LL dp[MAXN][4];

int main() {
    std::ios::sync_with_stdio(false);
    int n, m, k;
    while (cin >> n >> m >> k) {
        dp[0][1] = 1;
        dp[0][2] = dp[0][3] = 0;
        for (int i = 1; i <= n; ++i) {
            dp[i][1] = dp[i][2] = dp[i][3] = 0;
            dp[i][1] = dp[i - 1][1] + dp[i - 1][2] + dp[i - 1][3];
            dp[i][1] %= MOD;
            dp[i][2] = dp[i - 1][1] + dp[i - 1][2] + dp[i - 1][3];
            dp[i][2] %= MOD;
            dp[i][3] = dp[i - 1][1] + dp[i - 1][2] + dp[i - 1][3];
            dp[i][3] %= MOD;
            if (i == k + 1) {
                dp[i][3] = (dp[i][3] - 1 + MOD) % MOD;
            } else if (i > k + 1) {
                dp[i][3] = (dp[i][3] - dp[i - k - 1][1] - dp[i - k - 1][2] + 2LL * MOD) % MOD;
            }
        }
        LL ans = dp[n][1] + dp[n][2] + dp[n][3];
        ans %= MOD;
        for (int i = 1; i <= n; ++i) {
            dp[i][1] = dp[i][2] = dp[i][3] = 0;
            dp[i][1] = dp[i - 1][1] + dp[i - 1][2] + dp[i - 1][3];
            dp[i][1] %= MOD;
            dp[i][2] = dp[i - 1][1] + dp[i - 1][2] + dp[i - 1][3];
            dp[i][2] %= MOD;
            dp[i][3] = dp[i - 1][1] + dp[i - 1][2] + dp[i - 1][3];
            dp[i][3] %= MOD;
            if (i == k + 1) {
                dp[i][3] = (dp[i][3] - 1 + MOD) % MOD;
            } else if (i > k + 1) {
                dp[i][3] = (dp[i][3] - dp[i - k - 1][1] - dp[i - k - 1][2] + 2LL * MOD) % MOD;
            }
            if (i == m) {
                dp[i][1] = (dp[i][1] - 1 + MOD) % MOD;
            } else if (i > m) {
                dp[i][1] = (dp[i][1] - dp[i - m][2] - dp[i - m][3] + 2LL * MOD) % MOD;
            }
        }
        ans = (ans - dp[n][1] - dp[n][2] - dp[n][3] + 3LL * MOD) % MOD;
        cout << ans << endl;
    }
    return 0;
}