Codeforces Round #556 (Div. 2) - D. Three Religions（动态规划）

Problem  Codeforces Round #556 (Div. 2) - D. Three Religions

Time Limit: 3000 mSec

Problem Description

 

Input

 

Output

 

Sample Input

 6 8
abdabc
+ 1 a
+ 1 d
+ 2 b
+ 2 c
+ 3 a
+ 3 b
+ 1 c
- 2

Sample Output

YES
YES
YES
YES
YES
YES
NO
YES

 

题解：动态规划，意识到这个题是动态规划之后难点在于要优化什么东西，本题是让判断原串能否划分成题中不断更新的三个字符串，通常情况下dp数组不仅仅记录true/false这种信息，因为这种信息往往可以在不改变复杂度的情况下通过记录更具体的信息来直接导出，而这些更具体的信息会给状态的转移带来便利，本题就是这样的情况。

　　意识到本题的dp属于分段决策同样很重要，对于当前的三个字符串，判断是否合法的方式是逐个加入字符，逐个加入的过程就是天然的阶段，而每个阶段需要做出的决策是加入哪一个字符串的字符，在这个过程中维护的信息就是把第一个串的前 a 个字符，第二个串的前 b 个字符，第三个串的前 c 个字符放进去所需要原串的最小长度。

　　有了这样的状态定义转移方程自然很简单，比如考虑dp[a][b][c]，并且是从dp[a-1][b][c]转移过来的，那么dp[a][b][c]就是在dp[a-1][b][c]位置之后第一次出现第一个串第a个字符的位置，为了能够O(1)转移，预处理出对于原串的每个位置i，对每个小写英文字母x，i及i以后第一次出现x的位置，这很容易在O(26 * n)的复杂度内解决。这样每次状态转移只需要常数时间，正常情况下总的复杂度是O(q * 250^3)，这肯定会T，但是考虑到每次新加入一个字符需要重新计算的dp值只有250^2个，因此复杂度实际为O(q * 250^2)，可以接受。

 

#include <bits/stdc++.h>

using namespace std;

#define REP(i, n) for (int i = 1; i <= (n); i++)
#define sqr(x) ((x) * (x))

const int maxn = 100000 + 100;
const int maxm = 200000 + 100;
const int maxs = 256;

typedef long long LL;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;

const LL unit = 1LL;
const int INF = 0x3f3f3f3f;
const double eps = 1e-14;
const double inf = 1e15;
const double pi = acos(-1.0);
const int SIZE = 100 + 5;
const LL MOD = 1000000007;

int n, q;
int type;
int Next[maxn][26];
int dp[maxs][maxs][maxs];
string str, opt, word;
string ss[3];

void cal(int a, int b, int c)
{
    int &ans = dp[a][b][c];
    ans = n;
    if (a)
        ans = min(ans, Next[dp[a - 1][b][c] + 1][ss[0][a - 1] - 'a']);
    if (b)
        ans = min(ans, Next[dp[a][b - 1][c] + 1][ss[1][b - 1] - 'a']);
    if (c)
        ans = min(ans, Next[dp[a][b][c - 1] + 1][ss[2][c - 1] - 'a']);
}

void premanagement()
{
    for (int i = 0; i < 26; i++)
    {
        Next[n][i] = Next[n + 1][i] = n;
    }
    for (int i = n - 1; i >= 0; i--)
    {
        int tmp = str[i] - 'a';
        for (int j = 0; j < 26; j++)
        {
            if (j != tmp)
                Next[i][j] = Next[i + 1][j];
            else
                Next[i][j] = i;
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);

    cin >> n >> q;
    cin >> str;
    premanagement();
    dp[0][0][0] = -1;
    for (int i = 0; i < q; i++)
    {
        cin >> opt >> type;
        type--;
        if (opt[0] == '+')
        {
            cin >> word;
            ss[type] += word[0];
            int max0 = ss[0].size(), max1 = ss[1].size(), max2 = ss[2].size();
            int min0 = (type == 0 ? max0 : 0);
            int min1 = (type == 1 ? max1 : 0);
            int min2 = (type == 2 ? max2 : 0);
            for (int a = min0; a <= max0; a++)
            {
                for (int b = min1; b <= max1; b++)
                {
                    for (int c = min2; c <= max2; c++)
                    {
                        cal(a, b, c);
                    }
                }
            }
        }
        else
        {
            ss[type].pop_back();
        }

        if (dp[ss[0].size()][ss[1].size()][ss[2].size()] < n)
        {
            cout << "YES" << endl;
        }
        else
        {
            cout << "NO" << endl;
        }
    }
    return 0;
}