text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
char univ[100001];
const int MAX = 0x3f3f3f3f;
int dp[251][251][251];
int nextc[100001][26];
int main() {
int N, Q;
scanf("%d%d", &N, &Q);
scanf("%s", univ);
fill(nextc[N], nextc[N] + 26, MAX);
for (int i = N - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
nextc[i][j] = nextc[i + 1][j];
if (univ[i] == 'a' + j) {
nextc[i][j] = i;
}
}
}
string word[3];
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0] = -1;
for (int q = 0; q < Q; q++) {
char op[5], w[5];
int r;
scanf("%s%d", op, &r);
r--;
if (op[0] == '+') {
scanf("%s", w);
word[r].push_back(w[0]);
size_t s[3], d[3];
for (int i = 0; i < 3; i++) {
s[i] = (r == i) ? word[i].size() : 0;
}
for (d[0] = s[0]; d[0] <= word[0].size(); d[0]++) {
for (d[1] = s[1]; d[1] <= word[1].size(); d[1]++) {
for (d[2] = s[2]; d[2] <= word[2].size(); d[2]++) {
size_t &i = d[0], &j = d[1], &k = d[2];
dp[i][j][k] = MAX;
for (int rr = 0; rr < 3; rr++) {
if (d[rr] == 0) {
continue;
}
int pstate = dp[i - (rr == 0)][j - (rr == 1)][k - (rr == 2)];
if (pstate < MAX) {
int tans = nextc[pstate + 1][word[rr][d[rr] - 1] - 'a'];
dp[i][j][k] = min(dp[i][j][k], tans);
}
}
}
}
}
} else {
word[r].pop_back();
}
bool ans = dp[word[0].size()][word[1].size()][word[2].size()] < MAX;
printf("%s\n", ans ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
constexpr int MOD = 1e9 + 7;
constexpr int INF = INT_MAX;
constexpr ll LLINF = LLONG_MAX;
template <class T>
inline bool setmin(T &a, T b) {
if (a > b) return a = b, 1;
return 0;
}
template <class T>
inline bool setmax(T &a, T b) {
if (a < b) return a = b, 1;
return 0;
}
namespace fastio {
template <class T>
istream &operator>>(istream &os, vector<T> &container) {
for (auto &u : container) os >> u;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &container) {
for (auto &u : container) os << u << " ";
return os;
}
template <class T1, class T2>
inline istream &operator>>(istream &os, pair<T1, T2> &p) {
return os >> p.first >> p.second;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << p.first << " " << p.second;
}
template <typename... args>
void re(args &...tail) {
((cin >> tail), ...);
}
template <typename... args>
void pr(args... tail) {
((cout << tail << " "), ...);
}
template <typename... args>
void prln(args... tail) {
((cout << tail << " "), ...);
cout << "\n";
}
} // namespace fastio
using namespace fastio;
namespace debug {
template <typename _T>
inline void _debug(const char *s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _debug(const char *s, _T x, args... a) {
while (*s != ',') cerr << *s++;
cerr << " = " << x << ',';
_debug(s + 1, a...);
}
} // namespace debug
using namespace debug;
const int N = 1e5 + 7;
string s;
int n, q;
int nxt[N][26];
int dp[257][257][257];
string rel[3];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
re(n, q, s);
for (int i = (0); i <= (25); i++) nxt[n][i] = nxt[n + 1][i] = n;
for (int i = (n - 1); i >= (0); i--) {
for (int j = (0); j <= (25); j++) {
nxt[i][j] = (s[i] == 'a' + j ? i : nxt[i + 1][j]);
}
}
dp[0][0][0] = -1;
for (int _ = (1); _ <= (q); _++) {
char t;
int x;
re(t, x);
x--;
if (t == '+') {
char l;
re(l);
rel[x] += l;
int e0 = (int)(rel[0]).size(), e1 = (int)(rel[1]).size(),
e2 = (int)(rel[2]).size();
int b0 = (x == 0 ? e0 : 0);
int b1 = (x == 1 ? e1 : 0);
int b2 = (x == 2 ? e2 : 0);
for (int a = (b0); a <= (e0); a++) {
for (int b = (b1); b <= (e1); b++) {
for (int c = (b2); c <= (e2); c++) {
auto &v = dp[a][b][c];
v = n;
if (a) setmin(v, nxt[dp[a - 1][b][c] + 1][rel[0][a - 1] - 'a']);
if (b) setmin(v, nxt[dp[a][b - 1][c] + 1][rel[1][b - 1] - 'a']);
if (c) setmin(v, nxt[dp[a][b][c - 1] + 1][rel[2][c - 1] - 'a']);
}
}
}
} else {
rel[x].pop_back();
}
prln(dp[(int)(rel[0]).size()][(int)(rel[1]).size()][(int)(rel[2]).size()] <
n
? "YES"
: "NO");
}
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using pii = pair<int, int>;
constexpr int ALPHABET_SIZE = 'z' - 'a' + 1;
constexpr int MAX_SIZE = 256;
constexpr int INF = 1e8;
int n;
string s;
string as, bs, cs;
vector<int> next_pos[ALPHABET_SIZE];
int calced_pos[MAX_SIZE][MAX_SIZE][MAX_SIZE];
int calced_mark[MAX_SIZE][MAX_SIZE][MAX_SIZE];
int added_mark[MAX_SIZE][MAX_SIZE][MAX_SIZE];
int dda[(int)3e5];
int ddb[(int)3e5];
int ddc[(int)3e5];
void promote(int s_pos, int mark, int type) {
int dsize = 0;
int dptr = 0;
if (type == 1) {
for (int bb = 0; bb <= bs.size(); bb++) {
for (int cc = 0; cc <= cs.size(); cc++) {
dda[dsize] = s_pos;
ddb[dsize] = bb;
ddc[dsize] = cc;
dsize++;
calced_mark[s_pos][bb][cc] = mark;
added_mark[s_pos][bb][cc] = mark;
}
}
} else if (type == 2) {
for (int aa = 0; aa <= as.size(); aa++) {
for (int cc = 0; cc <= cs.size(); cc++) {
dda[dsize] = aa;
ddb[dsize] = s_pos;
ddc[dsize] = cc;
dsize++;
calced_mark[aa][s_pos][cc] = mark;
added_mark[aa][s_pos][cc] = mark;
}
}
} else {
for (int aa = 0; aa <= as.size(); aa++) {
for (int bb = 0; bb <= bs.size(); bb++) {
dda[dsize] = aa;
ddb[dsize] = bb;
ddc[dsize] = s_pos;
dsize++;
calced_mark[aa][bb][s_pos] = mark;
added_mark[aa][bb][s_pos] = mark;
}
}
}
while (dptr < dsize) {
int a = dda[dptr];
int b = ddb[dptr];
int c = ddc[dptr];
dptr++;
int &m = calced_mark[a][b][c];
m = mark;
added_mark[a][b][c] = mark;
int &pos = calced_pos[a][b][c];
if (a == 0 && b == 0 && c == 0) {
pos = 0;
}
if (a < as.size()) {
int &p = calced_pos[a + 1][b][c];
int &mm = calced_mark[a + 1][b][c];
int &am = added_mark[a + 1][b][c];
if (am != mark) {
if (mm != mark) {
p = INF;
mm = mark;
dda[dsize] = a + 1;
ddb[dsize] = b;
ddc[dsize] = c;
dsize++;
}
if (pos < n) p = min(p, next_pos[as[a] - 'a'][pos] + 1);
}
}
if (b < bs.size()) {
int &p = calced_pos[a][b + 1][c];
int &mm = calced_mark[a][b + 1][c];
int &am = added_mark[a][b + 1][c];
if (am != mark) {
if (mm != mark) {
p = INF;
mm = mark;
dda[dsize] = a;
ddb[dsize] = b + 1;
ddc[dsize] = c;
dsize++;
}
if (pos < n) p = min(p, next_pos[bs[b] - 'a'][pos] + 1);
}
}
if (c < cs.size()) {
int &p = calced_pos[a][b][c + 1];
int &mm = calced_mark[a][b][c + 1];
int &am = added_mark[a][b][c + 1];
if (am != mark) {
if (mm != mark) {
p = INF;
mm = mark;
dda[dsize] = a;
ddb[dsize] = b;
ddc[dsize] = c + 1;
dsize++;
}
if (pos < n) p = min(p, next_pos[cs[c] - 'a'][pos] + 1);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int q;
cin >> n >> q;
cin >> s;
memset(calced_mark, 0, sizeof(calced_mark));
memset(added_mark, 0, sizeof(added_mark));
for (int i = 0; i < ALPHABET_SIZE; i++) {
next_pos[i].resize(n, INF);
}
for (int i = n - 1; i >= 0; i--) {
if (i + 1 < n) {
for (int z = 0; z < ALPHABET_SIZE; z++) {
next_pos[z][i] = next_pos[z][i + 1];
}
}
int c = s[i] - 'a';
next_pos[c][i] = i;
}
int mark = 228;
char c, which;
int num;
while (q--) {
mark++;
cin >> c >> num;
if (c == '-') {
if (num == 1) {
as.pop_back();
} else if (num == 2) {
bs.pop_back();
} else if (num == 3) {
cs.pop_back();
}
} else {
cin >> which;
if (num == 1) {
as.push_back(which);
promote(as.size() - 1, mark, num);
} else if (num == 2) {
bs.push_back(which);
promote(bs.size() - 1, mark, num);
} else if (num == 3) {
cs.push_back(which);
promote(cs.size() - 1, mark, num);
}
}
cout << (calced_pos[as.size()][bs.size()][cs.size()] <= s.size() ? "YES"
: "NO")
<< endl;
}
}
|
#include <bits/stdc++.h>
const double eps = (1e-9);
using namespace std;
int dcmp(long double a, long double b) {
return fabsl(a - b) <= eps ? 0 : (a > b) ? 1 : -1;
}
int getBit(int num, int idx) { return ((num >> idx) & 1) == 1; }
int setBit1(int num, int idx) { return num | (1 << idx); }
long long setBit0(long long num, int idx) { return num & ~(1ll << idx); }
long long flipBit(int num, int idx) { return num ^ (1 << idx); }
void FS() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int n, q;
string st;
int dp[255][255][255], arr[100009][30], L[4], R[4], siz[4];
char ss[4][260];
void build() {
for (int j = 0; j < 26; j++) arr[n][j] = n, arr[n + 1][j] = n;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
arr[i][j] = arr[i + 1][j];
}
arr[i][st[i] - 'a'] = i;
}
}
void solve() {
for (int i = L[1]; i <= R[1]; i++) {
for (int j = L[2]; j <= R[2]; j++) {
for (int k = L[3]; k <= R[3]; k++) {
int &an = dp[i][j][k];
an = n + 1;
if (i) an = min(an, arr[dp[i - 1][j][k]][ss[1][i - 1] - 'a'] + 1);
if (j) an = min(an, arr[dp[i][j - 1][k]][ss[2][j - 1] - 'a'] + 1);
if (k) an = min(an, arr[dp[i][j][k - 1]][ss[3][k - 1] - 'a'] + 1);
}
}
}
}
int main() {
cin >> n >> q >> st;
build();
while (q--) {
char ch, c;
cin >> ch;
if (ch == '+') {
int id;
cin >> id >> c;
ss[id][siz[id]++] = c;
for (int i = 1; i <= 3; i++) {
if (i == id) {
L[id] = R[id] = siz[id];
} else {
L[i] = 0;
R[i] = siz[i];
}
}
solve();
} else {
int id;
cin >> id;
siz[id]--;
}
cout << (dp[siz[1]][siz[2]][siz[3]] <= n ? "YES\n" : "NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize(3)
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC target("sse3", "sse2", "sse")
#pragma GCC target("avx", "sse4", "sse4.1", "sse4.2", "ssse3")
#pragma GCC target("f16c")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", \
"no-stack-protector")
#pragma GCC push_options
#pragma GCC pop_options
#pragma GCC reset_options
#pragma GCC optimize("O3")
const double eps = 1e-9;
const int INFMEM = 63;
const int INF = 1061109567;
const long long LINF = 4557430888798830399LL;
const double DINF = numeric_limits<double>::infinity();
const long long MOD = 1000000007;
const int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
const double PI = 3.141592653589793;
inline void fastll(long long &input_number) {
input_number = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9') {
input_number = (input_number << 3) + (input_number << 1) + ch - '0';
ch = getchar_unlocked();
}
input_number *= sign;
}
inline void open(string a) {
freopen((a + ".in").c_str(), "r", stdin);
freopen((a + ".out").c_str(), "w", stdout);
}
inline void fasterios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
string s;
long long cnt[4];
long long kiri[4];
long long n, q, allsum;
long long cost[100005][30];
long long memo[255][255][255];
vector<char> religions[4];
int main() {
cin >> n >> q;
for (int i = 0; i <= n + 3; i++) {
for (int j = 0; j <= 27; j++) {
cost[i][j] = n + 1;
}
}
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
long long now = c - 'a';
cost[i][now] = i;
}
for (int j = 0; j <= 27; j++) {
for (int i = n + 2; i >= 0; i--) {
cost[i][j] = min(cost[i + 1][j], cost[i][j]);
}
}
memo[0][0][0] = 0;
while (q--) {
long long t;
char c;
cin >> c >> t;
if (c == '+') {
char tmp;
cin >> tmp;
religions[t].push_back(tmp - 'a');
cnt[t]++;
kiri[1] = kiri[2] = kiri[3] = 0;
kiri[t] = cnt[t];
for (int i = kiri[1]; i <= cnt[1]; i++) {
for (int j = kiri[2]; j <= cnt[2]; j++) {
for (int k = kiri[3]; k <= cnt[3]; k++) {
memo[i][j][k] = n + 1;
if (i > 0)
memo[i][j][k] =
min(memo[i][j][k],
cost[memo[i - 1][j][k] + 1][religions[1][i - 1]]);
if (j > 0)
memo[i][j][k] =
min(memo[i][j][k],
cost[memo[i][j - 1][k] + 1][religions[2][j - 1]]);
if (k > 0)
memo[i][j][k] =
min(memo[i][j][k],
cost[memo[i][j][k - 1] + 1][religions[3][k - 1]]);
}
}
}
} else {
religions[t].pop_back();
cnt[t]--;
}
if (memo[cnt[1]][cnt[2]][cnt[3]] == n + 1) {
cout << "NO" << '\n';
continue;
}
cout << "YES" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int nxt[100010][30];
string words[4];
long long int dp[255][255][255];
void process(long long int i, long long int j, long long int k) {
long long int val = LONG_MAX;
if (i >= 1 && dp[i - 1][j][k] != LONG_MAX)
val = min(val, nxt[dp[i - 1][j][k]][words[1][i - 1] - 'a']);
if (j >= 1 && dp[i][j - 1][k] != LONG_MAX)
val = min(val, nxt[dp[i][j - 1][k]][words[2][j - 1] - 'a']);
if (k >= 1 && dp[i][j][k - 1] != LONG_MAX)
val = min(val, nxt[dp[i][j][k - 1]][words[3][k - 1] - 'a']);
dp[i][j][k] = val;
}
int main() {
ios_base::sync_with_stdio(false);
long long int n, q;
char op;
char ch;
long long int arrNum;
cin >> n >> q;
string second;
cin >> second;
dp[0][0][0] = 0;
for (long long int i = 0; i <= n; i++)
for (long long int j = 0; j < 30; j++) nxt[i][j] = LONG_MAX;
for (long long int i = n - 1; i >= 0; i--) {
for (long long int j = 0; j < 30; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][second[i] - 'a'] = i + 1;
}
long long int min1, max1, min2, max2, min3, max3;
while (q--) {
cin >> op;
cin >> arrNum;
if (op == '+') {
cin >> ch;
words[arrNum] += ch;
max1 = words[1].size();
max2 = words[2].size();
max3 = words[3].size();
min1 = arrNum == 1 ? max1 : 0;
min2 = arrNum == 2 ? max2 : 0;
min3 = arrNum == 3 ? max3 : 0;
for (long long int i = min1; i <= max1; i++) {
for (long long int j = min2; j <= max2; j++) {
for (long long int k = min3; k <= max3; k++) {
process(i, j, k);
}
}
}
} else {
words[arrNum].pop_back();
}
cout << ((dp[words[1].size()][words[2].size()][words[3].size()] == LONG_MAX)
? "NO"
: "YES")
<< '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool smin(T &a, const T &b) {
return a > b ? a = b : a;
}
template <typename T>
inline bool smax(T &a, const T &b) {
return a < b ? a = b : a;
}
const int N = (int)1e5 + 5, mod = (int)0;
int best[255][255][255], nxt[N][26];
int a[3][N], sz[3];
int main() {
ios_base::sync_with_stdio(0);
int n, q;
cin >> n >> q;
string s;
cin >> s;
for (int j = 0; j < 26; ++j) nxt[n][j] = nxt[n + 1][j] = n + 1;
for (int j = n - 1; j >= 0; --j) {
for (int c = 0; c < 26; ++c) {
if (s[j] - 'a' == c) {
nxt[j][c] = j;
} else {
nxt[j][c] = nxt[j + 1][c];
}
}
}
for (int i = 0; i < 255; ++i)
for (int j = 0; j < 255; ++j)
for (int k = 0; k < 255; ++k) best[i][j][k] = n + 1;
best[0][0][0] = 0;
while (q--) {
char ch;
cin >> ch;
int rel;
cin >> rel;
--rel;
if (ch == '+') {
cin >> ch;
a[rel][sz[rel]++] = ch - 'a';
int stx = 0, edx = sz[0];
int sty = 0, edy = sz[1];
int stz = 0, edz = sz[2];
if (rel == 0) {
stx = sz[rel];
edx = sz[rel];
} else if (rel == 1) {
edy = sz[rel];
sty = sz[rel];
} else {
edz = sz[rel];
stz = sz[rel];
}
for (int first = stx; first <= edx; ++first)
for (int second = sty; second <= edy; ++second)
for (int z = stz; z <= edz; ++z) {
best[first][second][z] = n + 1;
if (first > 0) {
int pos = best[first - 1][second][z];
int c = a[0][first - 1];
int go = nxt[pos][c] + 1;
go = min(go, n + 1);
best[first][second][z] = min(best[first][second][z], go);
}
if (second > 0) {
int pos = best[first][second - 1][z];
int c = a[1][second - 1];
int go = nxt[pos][c] + 1;
go = min(go, n + 1);
best[first][second][z] = min(best[first][second][z], go);
}
if (z > 0) {
int pos = best[first][second][z - 1];
int c = a[2][z - 1];
int go = nxt[pos][c] + 1;
go = min(go, n + 1);
best[first][second][z] = min(best[first][second][z], go);
}
}
} else {
--sz[rel];
}
cout << (best[sz[0]][sz[1]][sz[2]] <= n ? "YES\n" : "NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
constexpr int maxm = 240000;
constexpr int maxn = 255;
char s[maxm], op[maxn], st[3][maxn];
int sz[3], f[maxn][maxn][maxn], nxt[26][maxm];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q >> (s + 1);
for (int i = n + 5; i >= 0; i -= 1)
if (i > n)
for (int j = 0; j < 26; j += 1) nxt[j][i] = n + 1;
else
for (int j = 0; j < 26; j += 1)
if (j == s[i] - 'a')
nxt[j][i] = i;
else
nxt[j][i] = nxt[j][i + 1];
for (int x; q; q -= 1) {
cin >> op >> x;
x -= 1;
if (*op == '+') {
cin >> op;
st[x][sz[x] += 1] = *op;
if (x == 0)
for (int i = 0; i <= sz[1]; i += 1)
for (int j = 0; j <= sz[2]; j += 1) {
f[sz[0]][i][j] = n + 1;
f[sz[0]][i][j] =
min(f[sz[0]][i][j],
nxt[st[0][sz[0]] - 'a'][f[sz[0] - 1][i][j] + 1]);
if (i)
f[sz[0]][i][j] = min(f[sz[0]][i][j],
nxt[st[1][i] - 'a'][f[sz[0]][i - 1][j] + 1]);
if (j)
f[sz[0]][i][j] = min(f[sz[0]][i][j],
nxt[st[2][j] - 'a'][f[sz[0]][i][j - 1] + 1]);
}
if (x == 1)
for (int i = 0; i <= sz[0]; i += 1)
for (int j = 0; j <= sz[2]; j += 1) {
f[i][sz[1]][j] = n + 1;
f[i][sz[1]][j] =
min(f[i][sz[1]][j],
nxt[st[1][sz[1]] - 'a'][f[i][sz[1] - 1][j] + 1]);
if (i)
f[i][sz[1]][j] = min(f[i][sz[1]][j],
nxt[st[0][i] - 'a'][f[i - 1][sz[1]][j] + 1]);
if (j)
f[i][sz[1]][j] = min(f[i][sz[1]][j],
nxt[st[2][j] - 'a'][f[i][sz[1]][j - 1] + 1]);
}
if (x == 2)
for (int i = 0; i <= sz[0]; i += 1)
for (int j = 0; j <= sz[1]; j += 1) {
f[i][j][sz[2]] = n + 1;
f[i][j][sz[2]] =
min(f[i][j][sz[2]],
nxt[st[2][sz[2]] - 'a'][f[i][j][sz[2] - 1] + 1]);
if (i)
f[i][j][sz[2]] = min(f[i][j][sz[2]],
nxt[st[0][i] - 'a'][f[i - 1][j][sz[2]] + 1]);
if (j)
f[i][j][sz[2]] = min(f[i][j][sz[2]],
nxt[st[1][j] - 'a'][f[i][j - 1][sz[2]] + 1]);
}
} else {
sz[x] -= 1;
}
cout << (f[sz[0]][sz[1]][sz[2]] == n + 1 ? "NO\n" : "YES\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T load() {
T r;
cin >> r;
return r;
}
template <typename T>
vector<T> loadMany(int n) {
vector<T> rs(n);
generate(rs.begin(), rs.end(), &load<T>);
return rs;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
auto n = load<int>();
auto q = load<int>();
auto maxReligion = 250;
auto text = load<string>();
auto nextocc = vector<array<int, 26>>(n);
for (auto i = n - 1; i >= 0; --i)
for (auto c = 'a'; c <= 'z'; ++c)
nextocc[i][c - 'a'] = text[i] == c ? i
: i != n - 1 ? nextocc[i + 1][c - 'a']
: n;
auto dyn = vector<vector<vector<int>>>(
maxReligion + 1,
vector<vector<int>>(maxReligion + 1, vector<int>(maxReligion + 1, -1)));
dyn[0][0][0] = 0;
auto pass = [&](int l1, int l2, int l3, int& target, char chr) {
if (dyn[l1][l2][l3] >= n) return;
target = min(target, nextocc[dyn[l1][l2][l3]][chr - 'a'] + 1);
};
auto ls = array<int, 3>{0, 0, 0};
auto religion = array<string, 3>{};
while (q-- > 0) {
auto kind = load<char>();
auto faith = load<int>() - 1;
if (kind == '+') {
auto chr = load<char>();
religion[faith].push_back(chr);
++ls[faith];
auto start = array<int, 3>{0, 0, 0};
auto finish = ls;
start[faith] = ls[faith];
finish[faith] = ls[faith];
for (auto l1 = start[0]; l1 <= finish[0]; ++l1) {
for (auto l2 = start[1]; l2 <= finish[1]; ++l2) {
for (auto l3 = start[2]; l3 <= finish[2]; ++l3) {
dyn[l1][l2][l3] = n + 1;
if (l1 > 0)
pass(l1 - 1, l2, l3, dyn[l1][l2][l3], religion[0][l1 - 1]);
if (l2 > 0)
pass(l1, l2 - 1, l3, dyn[l1][l2][l3], religion[1][l2 - 1]);
if (l3 > 0)
pass(l1, l2, l3 - 1, dyn[l1][l2][l3], religion[2][l3 - 1]);
}
}
}
} else {
religion[faith].pop_back();
--ls[faith];
}
cout << (dyn[ls[0]][ls[1]][ls[2]] <= n ? "YES\n" : "NO\n");
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long Mod = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double Pi = 3.141592653589793116L;
const long double EPS = 0.000000001L, Gold = ((1.0L + sqrt(5.0L)) / 2.0L);
long long keymod[] = {1000000007LL, 1000000009LL, 1000000021LL, 1000000033LL};
mt19937 rng32(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng64(chrono::steady_clock::now().time_since_epoch().count());
int OImode = 0;
int MultiTest = 0;
int Interactive = 0;
void ConfigMonitor();
char infile[] = "FILE.IN";
char outfile[] = "FILE.OUT";
int n, q;
string s;
int dp[251][251][251];
string rel[3];
void Input() {
for (int i = 0; i < 251; i++) {
for (int j = 0; j < 251; j++) {
for (int k = 0; k < 251; k++) {
dp[i][j][k] = INT_MAX;
}
}
}
dp[0][0][0] = 0;
cin >> n >> q >> s;
}
void Solve() {
vector<vector<int>> charID(26);
vector<vector<int>> Next(n, vector<int>(26, INT_MAX));
for (int i = 0; i < n; i++) charID[s[i] - 'a'].push_back(i);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 26; j++) {
if (lower_bound(charID[j].begin(), charID[j].end(), i) == charID[j].end())
continue;
Next[i][j] = *lower_bound(charID[j].begin(), charID[j].end(), i) + 1;
}
}
while (q--) {
char t;
int id;
cin >> t >> id;
id--;
if (t == '+') {
char c;
cin >> c;
rel[id].push_back(c);
if (id == 0) {
for (int j = 0; j <= rel[1].size(); j++) {
for (int k = 0; k <= rel[2].size(); k++) {
if (dp[rel[0].size() - 1][j][k] < n) {
dp[rel[0].size()][j][k] =
min(dp[rel[0].size()][j][k],
Next[dp[rel[0].size() - 1][j][k]][c - 'a']);
}
if (j > 0 && dp[rel[0].size()][j - 1][k] < n) {
dp[rel[0].size()][j][k] =
min(dp[rel[0].size()][j][k],
Next[dp[rel[0].size()][j - 1][k]][rel[1][j - 1] - 'a']);
}
if (k > 0 && dp[rel[0].size()][j][k - 1] < n) {
dp[rel[0].size()][j][k] =
min(dp[rel[0].size()][j][k],
Next[dp[rel[0].size()][j][k - 1]][rel[2][k - 1] - 'a']);
}
}
}
}
if (id == 1) {
for (int i = 0; i <= rel[0].size(); i++) {
for (int k = 0; k <= rel[2].size(); k++) {
if (dp[i][rel[1].size() - 1][k] < n) {
dp[i][rel[1].size()][k] =
min(dp[i][rel[1].size()][k],
Next[dp[i][rel[1].size() - 1][k]][c - 'a']);
}
if (i > 0 && dp[i - 1][rel[1].size()][k] < n) {
dp[i][rel[1].size()][k] =
min(dp[i][rel[1].size()][k],
Next[dp[i - 1][rel[1].size()][k]][rel[0][i - 1] - 'a']);
}
if (k > 0 && dp[i][rel[1].size()][k - 1] < n) {
dp[i][rel[1].size()][k] =
min(dp[i][rel[1].size()][k],
Next[dp[i][rel[1].size()][k - 1]][rel[2][k - 1] - 'a']);
}
}
}
}
if (id == 2) {
for (int i = 0; i <= rel[0].size(); i++) {
for (int j = 0; j <= rel[1].size(); j++) {
if (dp[i][j][rel[2].size() - 1] < n) {
dp[i][j][rel[2].size()] =
min(dp[i][j][rel[2].size()],
Next[dp[i][j][rel[2].size() - 1]][c - 'a']);
}
if (i > 0 && dp[i - 1][j][rel[2].size()] < n) {
dp[i][j][rel[2].size()] =
min(dp[i][j][rel[2].size()],
Next[dp[i - 1][j][rel[2].size()]][rel[0][i - 1] - 'a']);
}
if (j > 0 && dp[i][j - 1][rel[2].size()] < n) {
dp[i][j][rel[2].size()] =
min(dp[i][j][rel[2].size()],
Next[dp[i][j - 1][rel[2].size()]][rel[1][j - 1] - 'a']);
}
}
}
}
} else if (t == '-') {
if (id == 0) {
for (int j = 0; j <= rel[1].size(); j++) {
for (int k = 0; k <= rel[2].size(); k++) {
dp[rel[0].size()][j][k] = INT_MAX;
}
}
}
if (id == 1) {
for (int i = 0; i <= rel[0].size(); i++) {
for (int k = 0; k <= rel[2].size(); k++) {
dp[i][rel[1].size()][k] = INT_MAX;
}
}
}
if (id == 2) {
for (int i = 0; i <= rel[0].size(); i++) {
for (int j = 0; j <= rel[1].size(); j++) {
dp[i][j][rel[2].size()] = INT_MAX;
}
}
}
rel[id].pop_back();
}
if (dp[rel[0].size()][rel[1].size()][rel[2].size()] > n)
cout << "NO\n";
else
cout << "YES\n";
}
}
int main(int argc, char* argv[]) {
ConfigMonitor();
ios_base::sync_with_stdio(false);
if (!Interactive) cin.tie(NULL);
int T = 1;
if (MultiTest) cin >> T;
while (T--) {
Input();
Solve();
}
return 0;
}
void ConfigMonitor() {
if (OImode) {
freopen(infile, "r", stdin);
freopen(outfile, "w", stdout);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int M = 1e5 + 5;
const int N = 300;
char s[M];
int f[26][M];
int dp[N][N][N];
int ch[4][N];
int main() {
int n, m;
scanf("%d%d%s", &n, &m, s + 1);
for (int k = 25; k >= 0; k--) {
f[k][n + 1] = n + 1;
for (int i = n; i >= 0; i--) {
int c = s[i + 1] - 'a';
if (c != k)
f[k][i] = f[k][i + 1];
else
f[k][i] = i + 1;
}
}
int n1, n2, n3;
n1 = n2 = n3 = 0;
while (m--) {
char op[3];
int flag;
scanf("%s%d", op, &flag);
if (op[0] == '+') {
char t[3];
scanf("%s", t);
int c = t[0] - 'a';
if (flag == 1) {
ch[1][++n1] = c;
dp[n1][0][0] = f[c][dp[n1 - 1][0][0]];
for (int i = 1; i <= n2; i++)
dp[n1][i][0] =
min(f[c][dp[n1 - 1][i][0]], f[ch[2][i]][dp[n1][i - 1][0]]);
for (int j = 1; j <= n3; j++)
dp[n1][0][j] =
min(f[c][dp[n1 - 1][0][j]], f[ch[3][j]][dp[n1][0][j - 1]]);
for (int i = 1; i <= n2; i++)
for (int j = 1; j <= n3; j++) {
dp[n1][i][j] =
min(f[c][dp[n1 - 1][i][j]], min(f[ch[3][j]][dp[n1][i][j - 1]],
f[ch[2][i]][dp[n1][i - 1][j]]));
}
} else if (flag == 2) {
ch[2][++n2] = c;
dp[0][n2][0] = f[c][dp[0][n2 - 1][0]];
for (int i = 1; i <= n1; i++)
dp[i][n2][0] =
min(f[ch[1][i]][dp[i - 1][n2][0]], f[c][dp[i][n2 - 1][0]]);
for (int j = 1; j <= n3; j++)
dp[0][n2][j] =
min(f[c][dp[0][n2 - 1][j]], f[ch[3][j]][dp[0][n2][j - 1]]);
for (int i = 1; i <= n1; i++)
for (int j = 1; j <= n3; j++) {
dp[i][n2][j] =
min(f[c][dp[i][n2 - 1][j]], min(f[ch[3][j]][dp[i][n2][j - 1]],
f[ch[1][i]][dp[i - 1][n2][j]]));
}
} else {
ch[3][++n3] = c;
dp[0][0][n3] = f[c][dp[0][0][n3 - 1]];
for (int i = 1; i <= n1; i++)
dp[i][0][n3] =
min(f[c][dp[i][0][n3 - 1]], f[ch[1][i]][dp[i - 1][0][n3]]);
for (int j = 1; j <= n2; j++)
dp[0][j][n3] =
min(f[c][dp[0][j][n3 - 1]], f[ch[2][j]][dp[0][j - 1][n3]]);
for (int i = 1; i <= n1; i++)
for (int j = 1; j <= n2; j++)
dp[i][j][n3] =
min(f[c][dp[i][j][n3 - 1]], min(f[ch[2][j]][dp[i][j - 1][n3]],
f[ch[1][i]][dp[i - 1][j][n3]]));
}
} else {
if (flag == 1)
n1--;
else if (flag == 2)
n2--;
else
n3--;
}
if (dp[n1][n2][n3] != n + 1)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v1, v2, v3;
vector<int> pos[26];
int f[251][251][251];
bool used[251][251][251];
string st, op, ch;
int n, q, x;
inline void check(int x, int y, int z) {
if (x < 0 || y < 0 || z < 0) return;
if (used[x][y][z]) return;
f[x][y][z] = n + 1;
if (x > 0) {
check(x - 1, y, z);
if (f[x - 1][y][z] != n + 1) {
int num = v1[x - 1];
auto iter =
lower_bound(pos[num].begin(), pos[num].end(), f[x - 1][y][z] + 1);
if (iter != pos[num].end()) {
f[x][y][z] = min(f[x][y][z], *iter);
}
}
}
if (y > 0) {
check(x, y - 1, z);
if (f[x][y - 1][z] != n + 1) {
int num = v2[y - 1];
auto iter =
lower_bound(pos[num].begin(), pos[num].end(), f[x][y - 1][z] + 1);
if (iter != pos[num].end()) {
f[x][y][z] = min(f[x][y][z], *iter);
}
}
}
if (z > 0) {
check(x, y, z - 1);
if (f[x][y][z - 1] != n + 1) {
int num = v3[z - 1];
auto iter =
lower_bound(pos[num].begin(), pos[num].end(), f[x][y][z - 1] + 1);
if (iter != pos[num].end()) {
f[x][y][z] = min(f[x][y][z], *iter);
}
}
}
used[x][y][z] = true;
}
inline void work() {
cin >> n >> q;
cin >> st;
for (int i = 0; i < st.size(); ++i) {
pos[st[i] - 97].push_back(i);
}
used[0][0][0] = true;
f[0][0][0] = -1;
for (int i = 0; i < q; ++i) {
cin >> op >> x;
if (op[0] == '+') {
cin >> ch;
if (x == 1) {
v1.push_back(ch[0] - 97);
} else if (x == 2) {
v2.push_back(ch[0] - 97);
} else {
v3.push_back(ch[0] - 97);
}
check(v1.size(), v2.size(), v3.size());
} else {
if (x == 1) {
for (int j = 0; j <= v2.size(); ++j) {
for (int k = 0; k <= v3.size(); ++k) {
used[v1.size()][j][k] = false;
}
}
v1.pop_back();
} else if (x == 2) {
for (int j = 0; j <= v1.size(); ++j) {
for (int k = 0; k <= v3.size(); ++k) {
used[j][v2.size()][k] = false;
}
}
v2.pop_back();
} else {
for (int j = 0; j <= v1.size(); ++j) {
for (int k = 0; k <= v2.size(); ++k) {
used[j][k][v3.size()] = false;
}
}
v3.pop_back();
}
};
if (f[v1.size()][v2.size()][v3.size()] <= n) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
work();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, dp[270][270][270], go[220001][26];
char s[220001], t[5][301];
inline int getnext(int pos, char ch) {
return pos > n ? 0x3f3f3f3f : go[pos][ch - 'a'];
}
int main() {
scanf("%d%d%s", &n, &q, s + 1);
memset(go, 0x3f, sizeof go);
for (int i = n - 1; i >= 0; i--) {
memcpy(go[i], go[i + 1], sizeof go[i]);
go[i][s[i + 1] - 'a'] = i + 1;
}
memset(dp, 0x3f, sizeof dp);
dp[0][0][0] = 0;
int x = 0, y = 0, z = 0;
while (q--) {
char op[3], ch[3];
int id;
scanf("%s%d", op, &id);
if (op[0] == '+') {
scanf("%s", ch);
if (id == 1) {
t[1][++x] = ch[0];
for (int i = 0; i <= y; i++)
for (int j = 0; j <= z; j++)
dp[x][i][j] =
min(getnext(dp[x - 1][i][j], t[1][x]),
min(i ? getnext(dp[x][i - 1][j], t[2][i]) : 0x3f3f3f3f,
j ? getnext(dp[x][i][j - 1], t[3][j]) : 0x3f3f3f3f));
} else if (id == 2) {
t[2][++y] = ch[0];
for (int i = 0; i <= x; i++)
for (int j = 0; j <= z; j++)
dp[i][y][j] =
min(getnext(dp[i][y - 1][j], t[2][y]),
min(i ? getnext(dp[i - 1][y][j], t[1][i]) : 0x3f3f3f3f,
j ? getnext(dp[i][y][j - 1], t[3][j]) : 0x3f3f3f3f));
} else {
t[3][++z] = ch[0];
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++)
dp[i][j][z] =
min(getnext(dp[i][j][z - 1], t[3][z]),
min(i ? getnext(dp[i - 1][j][z], t[1][i]) : 0x3f3f3f3f,
j ? getnext(dp[i][j - 1][z], t[2][j]) : 0x3f3f3f3f));
}
} else if (id == 1)
x--;
else if (id == 2)
y--;
else
z--;
puts(dp[x][y][z] <= n ? "YES" : "NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
char ss[MAX];
int trie[MAX][28];
char s[4][MAX];
int top[4], up[4], down[4];
int dp[255][255][255];
int main() {
int n, q;
cin >> n >> q;
cin >> (ss + 1);
for (int i = 0; i <= 26; i++) trie[n + 1][i] = trie[n + 2][i] = n + 1;
ss[0] = 0;
for (int i = n; i >= 0; i--) {
int cur = ss[i] - 'a';
for (int j = 0; j < 26; j++) {
if (j == cur)
trie[i][j] = i;
else
trie[i][j] = trie[i + 1][j];
}
}
char op[5], tmp[5];
int id;
while (q--) {
scanf("%s", op);
if (op[0] == '+') {
scanf("%d", &id);
scanf("%s", tmp);
s[id][++top[id]] = tmp[0];
for (int i = 1; i <= 3; i++)
down[i] = (i == id ? top[i] : 0), up[i] = top[i];
for (int i = down[1]; i <= up[1]; i++) {
for (int j = down[2]; j <= up[2]; j++) {
for (int k = down[3]; k <= up[3]; k++) {
dp[i][j][k] = n + 1;
if (i)
dp[i][j][k] =
min(dp[i][j][k], trie[dp[i - 1][j][k] + 1][s[1][i] - 'a']);
if (j)
dp[i][j][k] =
min(dp[i][j][k], trie[dp[i][j - 1][k] + 1][s[2][j] - 'a']);
if (k)
dp[i][j][k] =
min(dp[i][j][k], trie[dp[i][j][k - 1] + 1][s[3][k] - 'a']);
}
}
}
} else {
scanf("%d", &id);
top[id]--;
}
if (dp[top[1]][top[2]][top[3]] > n)
puts("NO");
else
puts("YES");
}
return 0;
}
|
#include <bits/stdc++.h>
long long int pow(long long int a, long long int b, long long int m) {
a %= m;
long long int x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > m) x %= m;
}
y = (y * y);
if (y > m) y %= m;
b /= 2;
}
return x % m;
}
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long int gen(long long int start, long long int end) {
long long int diff = end - start;
long long int temp = rand() % start;
return temp + diff;
}
using namespace std;
string s;
int nxt[200002][27];
void build_nxt() {
int n = s.length();
for (int i = 0; i < 26; i++) {
if (i != (s.back() - 'a'))
nxt[n - 1][i] = n;
else
nxt[n - 1][i] = n - 1;
}
for (int i = n - 2; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
nxt[i][j] = nxt[i + 1][j];
}
nxt[i][s[i] - 'a'] = i;
}
}
int len[4];
string r[4];
int dp[252][252][252];
void solve(int i, int j, int k) {
dp[i][j][k] = s.length();
int n = s.length();
if (i - 1 >= 0) {
int pos = dp[i - 1][j][k];
if (pos <= n - 2)
dp[i][j][k] = min(dp[i][j][k], nxt[pos + 1][r[1][i - 1] - 'a']);
}
if (j - 1 >= 0) {
int pos = dp[i][j - 1][k];
if (pos <= n - 2)
dp[i][j][k] = min(dp[i][j][k], nxt[pos + 1][r[2][j - 1] - 'a']);
}
if (k - 1 >= 0) {
int pos = dp[i][j][k - 1];
if (pos <= n - 2)
dp[i][j][k] = min(dp[i][j][k], nxt[pos + 1][r[3][k - 1] - 'a']);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
cin >> s;
build_nxt();
dp[0][0][0] = -1;
while (q--) {
char tp;
cin >> tp;
if (tp == '+') {
int i;
char c;
cin >> i >> c;
++len[i];
r[i].push_back(c);
if (i == 1) {
for (int j = 0; j <= len[2]; j++) {
for (int k = 0; k <= len[3]; k++) {
solve(len[i], j, k);
}
}
}
if (i == 2) {
for (int j = 0; j <= len[1]; j++) {
for (int k = 0; k <= len[3]; k++) {
solve(j, len[i], k);
}
}
}
if (i == 3) {
for (int j = 0; j <= len[1]; j++) {
for (int k = 0; k <= len[2]; k++) {
solve(j, k, len[i]);
}
}
}
if (dp[len[1]][len[2]][len[3]] < (int)s.length()) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
} else {
int i;
cin >> i;
len[i]--;
r[i].pop_back();
if (dp[len[1]][len[2]][len[3]] < (int)s.length()) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int nax = 100 * 1000 + 1;
const int kax = 251;
const int INF = 1000 * 1000 * 1000;
int n, q;
int dp[kax][kax][kax], gdzie[nax][26], last[26];
string s;
vector<char> sl[3];
void get_state(int a, int b, int c) {
dp[a][b][c] = INF;
if (a > 0 && dp[a - 1][b][c] != INF) {
dp[a][b][c] =
min(gdzie[dp[a - 1][b][c] + 1][sl[0][a - 1] - 'a'], dp[a][b][c]);
}
if (b > 0 && dp[a][b - 1][c] != INF) {
dp[a][b][c] =
min(gdzie[dp[a][b - 1][c] + 1][sl[1][b - 1] - 'a'], dp[a][b][c]);
}
if (c > 0 && dp[a][b][c - 1] != INF) {
dp[a][b][c] =
min(gdzie[dp[a][b][c - 1] + 1][sl[2][c - 1] - 'a'], dp[a][b][c]);
}
}
int main() {
cin >> n >> q >> s;
for (int i = 0; i < 26; i++) {
last[i] = gdzie[n][i] = INF;
}
for (int i = n - 1; i >= 0; i--) {
last[s[i] - 'a'] = i;
for (int j = 0; j < 26; j++) {
gdzie[i][j] = last[j];
}
}
dp[0][0][0] = -1;
while (q--) {
char c, y;
int x;
cin >> c >> x;
if (c == '-') {
sl[--x].pop_back();
} else {
cin >> y;
sl[--x].push_back(y);
if (x == 0) {
for (int i = 0; i <= sl[1].size(); i++) {
for (int j = 0; j <= sl[2].size(); j++) {
get_state(sl[0].size(), i, j);
}
}
} else if (x == 1) {
for (int i = 0; i <= sl[0].size(); i++) {
for (int j = 0; j <= sl[2].size(); j++) {
get_state(i, sl[1].size(), j);
}
}
} else {
for (int i = 0; i <= sl[0].size(); i++) {
for (int j = 0; j <= sl[1].size(); j++) {
get_state(i, j, sl[2].size());
}
}
}
}
if (dp[sl[0].size()][sl[1].size()][sl[2].size()] < INF) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int l = 1 << 19;
char buf[l], *s, *t, c;
char gc() {
if (s == t) {
t = (s = buf) + fread(buf, 1, l, stdin);
return s == t ? EOF : *s++;
}
return *s++;
}
template <class I>
void gi(I &x) {
x = 0;
c = gc();
while (c < '0' || c > '9') c = gc();
while ('0' <= c && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ 48);
c = gc();
}
}
}; // namespace io
using io::gi;
const int N = 100005;
int n, q, s[N], dp[251][251][251];
int t1, t2, t3, s1[N], s2[N], s3[N];
char ss[N];
set<int> S[26];
void upd(int &a, int b) {
if (a == -1 || a > b) a = b;
}
int main() {
scanf("%d%d%s", &n, &q, ss + 1);
for (int i = 1; i <= n; i++) {
s[i] = ss[i] - 'a';
S[s[i]].insert(i);
}
memset(dp, -1, sizeof(dp));
dp[0][0][0] = 0;
while (q--) {
char A[3], C[3];
int b, c;
set<int>::iterator v;
scanf("%s%d", A, &b);
if (A[0] == '-') {
if (b == 1) --t1;
if (b == 2) --t2;
if (b == 3) --t3;
} else {
scanf("%s", C);
c = C[0] - 'a';
if (b == 1) {
s1[++t1] = c;
for (int i = t1; i <= t1; i++)
for (int j = 0; j <= t2; j++)
for (int k = 0; k <= t3; k++) {
dp[i][j][k] = -1;
if (i && dp[i - 1][j][k] != -1) {
v = S[s1[i]].upper_bound(dp[i - 1][j][k]);
if (v != S[s1[i]].end()) upd(dp[i][j][k], *v);
}
if (j && dp[i][j - 1][k] != -1) {
v = S[s2[j]].upper_bound(dp[i][j - 1][k]);
if (v != S[s2[j]].end()) upd(dp[i][j][k], *v);
}
if (k && dp[i][j][k - 1] != -1) {
v = S[s3[k]].upper_bound(dp[i][j][k - 1]);
if (v != S[s3[k]].end()) upd(dp[i][j][k], *v);
}
}
}
if (b == 2) {
s2[++t2] = c;
for (int i = 0; i <= t1; i++)
for (int j = t2; j <= t2; j++)
for (int k = 0; k <= t3; k++) {
dp[i][j][k] = -1;
if (i && dp[i - 1][j][k] != -1) {
v = S[s1[i]].upper_bound(dp[i - 1][j][k]);
if (v != S[s1[i]].end()) upd(dp[i][j][k], *v);
}
if (j && dp[i][j - 1][k] != -1) {
v = S[s2[j]].upper_bound(dp[i][j - 1][k]);
if (v != S[s2[j]].end()) upd(dp[i][j][k], *v);
}
if (k && dp[i][j][k - 1] != -1) {
v = S[s3[k]].upper_bound(dp[i][j][k - 1]);
if (v != S[s3[k]].end()) upd(dp[i][j][k], *v);
}
}
}
if (b == 3) {
s3[++t3] = c;
for (int i = 0; i <= t1; i++)
for (int j = 0; j <= t2; j++)
for (int k = t3; k <= t3; k++) {
dp[i][j][k] = -1;
if (i && dp[i - 1][j][k] != -1) {
v = S[s1[i]].upper_bound(dp[i - 1][j][k]);
if (v != S[s1[i]].end()) upd(dp[i][j][k], *v);
}
if (j && dp[i][j - 1][k] != -1) {
v = S[s2[j]].upper_bound(dp[i][j - 1][k]);
if (v != S[s2[j]].end()) upd(dp[i][j][k], *v);
}
if (k && dp[i][j][k - 1] != -1) {
v = S[s3[k]].upper_bound(dp[i][j][k - 1]);
if (v != S[s3[k]].end()) upd(dp[i][j][k], *v);
}
}
}
}
if (dp[t1][t2][t3] == -1)
puts("NO");
else
puts("YES");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
template <class T>
inline void umin(T &x, T y) {
x = x < y ? x : y;
}
template <class T>
inline void umax(T &x, T y) {
x = x > y ? x : y;
}
inline unsigned int R() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
const int N = 102000, inf = 0x3f3f3f3f;
int n, q;
char s[N];
int nxt[N][26], f[255][255][255];
int a[N], b[N], c[N];
int A, B, C;
inline void trans(int i, int j, int k) {
f[i][j][k] = inf;
if (i > 0) umin(f[i][j][k], nxt[f[i - 1][j][k]][a[i]]);
if (j > 0) umin(f[i][j][k], nxt[f[i][j - 1][k]][b[j]]);
if (k > 0) umin(f[i][j][k], nxt[f[i][j][k - 1]][c[k]]);
}
int main() {
read(n);
read(q);
scanf("%s", s + 1);
for (register int i = (0); i <= (25); i++) nxt[n][i] = nxt[n + 1][i] = n + 1;
for (register int i = (n); i >= (1); i--) {
memcpy(nxt[i - 1], nxt[i], 104);
nxt[i - 1][s[i] - 'a'] = i;
}
while (q--) {
char t[5];
scanf("%s", t);
if (t[0] == '+') {
int id;
read(id);
scanf("%s", t);
int ch = t[0] - 'a';
if (id == 1) {
a[++A] = ch;
for (register int i = (0); i <= (B); i++)
for (register int j = (0); j <= (C); j++) trans(A, i, j);
} else if (id == 2) {
b[++B] = ch;
for (register int i = (0); i <= (A); i++)
for (register int k = (0); k <= (C); k++) trans(i, B, k);
} else {
c[++C] = ch;
for (register int i = (0); i <= (A); i++)
for (register int j = (0); j <= (B); j++) trans(i, j, C);
}
} else {
int id;
read(id);
if (id == 1) A--;
if (id == 2) B--;
if (id == 3) C--;
}
printf("%s\n", f[A][B][C] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long int INFL = 1e18;
const int MAX_N = 1e5 + 10;
const int MAX_Q = 1e3;
const int MAX_L = 256;
int nxt[MAX_N][26];
int dp[MAX_L][MAX_L][MAX_L];
int len[3];
char chs[3][MAX_L];
char org[MAX_N];
int main(void) {
cin.sync_with_stdio(false), cin.tie(NULL);
int N, Q;
cin >> N >> Q;
for (int i = 1; i <= N; i++) cin >> org[i];
for (int i = 0; i < 26; i++) nxt[N + 1][i] = nxt[N + 2][i] = N + 2;
for (int i = N; i >= 0; i--) {
for (int j = 0; j < 26; j++) nxt[i][j] = nxt[i + 1][j];
if (i != 0) nxt[i][org[i] - 'a'] = i;
}
memset(dp, 0x3f, sizeof dp);
dp[0][0][0] = 0;
while (Q--) {
char ch;
int r;
cin >> ch >> r;
r--;
if (ch == '+') {
cin >> ch;
chs[r][len[r]] = ch - 'a';
len[r]++;
if (r == 0) {
int i = len[0];
for (int j = 0; j <= len[1]; j++) {
for (int k = 0; k <= len[2]; k++) {
dp[i][j][k] = N + 2;
if (i > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k]][chs[0][i - 1]]);
if (j > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k]][chs[1][j - 1]]);
if (k > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1]][chs[2][k - 1]]);
if (dp[i][j][k] != N + 2) dp[i][j][k]++;
}
}
} else if (r == 1) {
int j = len[1];
for (int i = 0; i <= len[0]; i++) {
for (int k = 0; k <= len[2]; k++) {
dp[i][j][k] = N + 2;
if (i > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k]][chs[0][i - 1]]);
if (j > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k]][chs[1][j - 1]]);
if (k > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1]][chs[2][k - 1]]);
if (dp[i][j][k] != N + 2) dp[i][j][k]++;
}
}
} else {
int k = len[2];
for (int i = 0; i <= len[0]; i++) {
for (int j = 0; j <= len[1]; j++) {
dp[i][j][k] = N + 2;
if (i > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k]][chs[0][i - 1]]);
if (j > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k]][chs[1][j - 1]]);
if (k > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1]][chs[2][k - 1]]);
if (dp[i][j][k] != N + 2) dp[i][j][k]++;
}
}
}
} else {
len[r]--;
}
if (dp[len[0]][len[1]][len[2]] <= N + 1)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[100010];
int dp[26][100010];
int maxP[260][260][260];
int len[3];
char desc[3][260];
int main(void) {
int N, Q;
cin >> N >> Q;
cin >> str;
for (int i = 0; i < 26; i++) dp[i][N] = 100010;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 26; j++) {
if (str[N - 1 - i] == 'a' + j)
dp[j][N - 1 - i] = N - i;
else
dp[j][N - 1 - i] = dp[j][N - i];
}
}
for (int q = 0; q < Q; q++) {
char o, c;
int i;
cin >> o >> i;
i--;
if (o == '+') {
cin >> c;
desc[i][len[i]++] = c;
if (i == 0) {
for (int j = 0; j < 260; j++) {
for (int k = 0; k < 260; k++) {
if (maxP[len[0] - 1][j][k] < 100010)
maxP[len[0]][j][k] = dp[c - 'a'][maxP[len[0] - 1][j][k]];
else
maxP[len[0]][j][k] = 100010;
if (j && maxP[len[0]][j - 1][k] < 100010)
maxP[len[0]][j][k] =
min(maxP[len[0]][j][k],
dp[desc[1][j - 1] - 'a'][maxP[len[0]][j - 1][k]]);
if (k && maxP[len[0]][j][k - 1] < 100010)
maxP[len[0]][j][k] =
min(maxP[len[0]][j][k],
dp[desc[2][k - 1] - 'a'][maxP[len[0]][j][k - 1]]);
}
}
}
if (i == 1) {
for (int j = 0; j < 260; j++) {
for (int k = 0; k < 260; k++) {
if (maxP[j][len[1] - 1][k] < 100010)
maxP[j][len[1]][k] = dp[c - 'a'][maxP[j][len[1] - 1][k]];
else
maxP[j][len[1]][k] = 100010;
if (j && maxP[j - 1][len[1]][k] < 100010)
maxP[j][len[1]][k] =
min(maxP[j][len[1]][k],
dp[desc[0][j - 1] - 'a'][maxP[j - 1][len[1]][k]]);
if (k && maxP[j][len[1]][k - 1] < 100010)
maxP[j][len[1]][k] =
min(maxP[j][len[1]][k],
dp[desc[2][k - 1] - 'a'][maxP[j][len[1]][k - 1]]);
}
}
}
if (i == 2) {
for (int j = 0; j < 260; j++) {
for (int k = 0; k < 260; k++) {
if (maxP[j][k][len[2] - 1] < 100010)
maxP[j][k][len[2]] = dp[c - 'a'][maxP[j][k][len[2] - 1]];
else
maxP[j][k][len[2]] = 100010;
if (j && maxP[j - 1][k][len[2]] < 100010)
maxP[j][k][len[2]] =
min(maxP[j][k][len[2]],
dp[desc[0][j - 1] - 'a'][maxP[j - 1][k][len[2]]]);
if (k && maxP[j][k - 1][len[2]] < 100010)
maxP[j][k][len[2]] =
min(maxP[j][k][len[2]],
dp[desc[1][k - 1] - 'a'][maxP[j][k - 1][len[2]]]);
}
}
}
} else
len[i]--;
cout << (maxP[len[0]][len[1]][len[2]] < 100010 ? "YES" : "NO") << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXN = 1e5 + 1;
const int MAXLEN = 251;
const int SIG = 26;
string s;
int longueur, nb_requetes;
int nxt[MAXN][SIG];
int dp[MAXLEN][MAXLEN][MAXLEN];
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> longueur >> nb_requetes;
cin >> s;
for (int i(longueur - 1); i >= 0; --i)
for (int c(0); c < SIG; ++c) {
if (c == s[i] - 'a')
nxt[i][c] = i;
else
nxt[i][c] = (i == longueur - 1 ? longueur : nxt[i + 1][c]);
}
for (int i(0); i < MAXLEN; ++i)
for (int j(0); j < MAXLEN; ++j)
for (int k(0); k < MAXLEN; ++k) dp[i][j][j] = longueur + 1;
dp[0][0][0] = 0;
array<vector<char>, 3> words;
for (int i(0); i < 3; ++i) words[i] = {};
while (nb_requetes--) {
char op;
int id;
cin >> op >> id;
--id;
if (op == '-') {
pair<int, int> ranges[3] = {{0, ((int)(words[0]).size())},
{0, ((int)(words[1]).size())},
{0, ((int)(words[2]).size())}};
ranges[id] = {((int)(words[id]).size()), ((int)(words[id]).size())};
for (int i(ranges[0].first); i <= ranges[0].second; ++i)
for (int j(ranges[1].first); j <= ranges[1].second; ++j)
for (int k(ranges[2].first); k <= ranges[2].second; ++k)
dp[i][j][k] = longueur + 1;
words[id].pop_back();
} else {
char c;
cin >> c;
c -= 'a';
pair<int, int> ranges[3] = {{0, ((int)(words[0]).size())},
{0, ((int)(words[1]).size())},
{0, ((int)(words[2]).size())}};
words[id].push_back(c);
ranges[id] = {((int)(words[id]).size()), ((int)(words[id]).size())};
for (int i(ranges[0].first); i <= ranges[0].second; ++i)
for (int j(ranges[1].first); j <= ranges[1].second; ++j)
for (int k(ranges[2].first); k <= ranges[2].second; ++k) {
dp[i][j][k] = longueur + 1;
if (i and dp[i - 1][j][k] < longueur)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k]][words[0][i - 1]] + 1);
if (j and dp[i][j - 1][k] < longueur)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k]][words[1][j - 1]] + 1);
if (k and dp[i][j][k - 1] < longueur)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1]][words[2][k - 1]] + 1);
}
}
if (dp[((int)(words[0]).size())][((int)(words[1]).size())]
[((int)(words[2]).size())] <= longueur)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007LL;
int n, q;
string s;
int dp[252][252][252];
vector<string> cs;
int nxt[100005][26];
void solve(int a, int b, int c) {
int s1 = cs[0].size();
int s2 = cs[1].size();
int s3 = cs[2].size();
for (int i = a; i <= s1; ++i) {
for (int j = b; j <= s2; ++j) {
for (int k = c; k <= s3; ++k) {
dp[i][j][k] = 1000000000;
}
}
}
for (int i = a; i <= s1; ++i) {
for (int j = b; j <= s2; ++j) {
for (int k = c; k <= s3; ++k) {
if (i == 0 && j == 0 && k == 0) dp[i][j][k] = -1;
if (i && dp[i - 1][j][k] < 1000000000) {
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k] + 1][cs[0][i - 1] - 'a']);
}
if (j && dp[i][j - 1][k] < 1000000000) {
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k] + 1][cs[1][j - 1] - 'a']);
}
if (k && dp[i][j][k - 1] < 1000000000) {
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1] + 1][cs[2][k - 1] - 'a']);
}
}
}
}
}
int main() {
scanf("%d%d", &n, &q);
cin >> s;
for (int i = n; i >= 0; --i) {
for (int j = 0; j < 26; ++j) {
nxt[i][j] = 1000000000;
if (i == n) continue;
if (s[i] == j + 'a')
nxt[i][j] = i;
else
nxt[i][j] = nxt[i + 1][j];
}
}
cs.clear();
for (int i = 0; i < 3; ++i) {
cs.push_back("");
}
solve(0, 0, 0);
for (int i = 0; i < q; ++i) {
string op;
int id;
string c;
cin >> op;
if (op == "+") {
cin >> id >> c;
cs[id - 1] += c;
if (id == 1)
solve(cs[id - 1].size(), 0, 0);
else if (id == 2)
solve(0, cs[id - 1].size(), 0);
else
solve(0, 0, cs[id - 1].size());
} else {
cin >> id;
cs[id - 1].pop_back();
}
if (dp[cs[0].size()][cs[1].size()][cs[2].size()] < 1000000000) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const int maxm = 256;
void chkmin(int &x, int y) { x = x > y ? y : x; }
int nxt[maxn][26], pos[26];
char S[maxn], op[1], ch[1];
int dp[maxm][maxm][maxm];
int len[3], sub[3][maxm], n, m;
void Build() {
for (int i = 0; i < 26; ++i) nxt[n + 1][i] = pos[i] = n + 1;
for (int i = n; ~i; --i) {
for (int j = 0; j < 26; ++j) nxt[i][j] = pos[j];
if (i) pos[S[i] - 'a'] = i;
}
}
void Update(int a, int b, int c) {
int &val = dp[a][b][c];
val = n + 1;
if (a) chkmin(val, nxt[dp[a - 1][b][c]][sub[0][a]]);
if (b) chkmin(val, nxt[dp[a][b - 1][c]][sub[1][b]]);
if (c) chkmin(val, nxt[dp[a][b][c - 1]][sub[2][c]]);
}
void Add(int id) {
scanf("%s", ch);
int val = ch[0] - 'a';
sub[id][++len[id]] = val;
int min0 = id == 0 ? len[0] : 0;
int min1 = id == 1 ? len[1] : 0;
int min2 = id == 2 ? len[2] : 0;
for (int a = min0; a <= len[0]; ++a)
for (int b = min1; b <= len[1]; ++b)
for (int c = min2; c <= len[2]; ++c) Update(a, b, c);
}
int main() {
scanf("%d%d", &n, &m);
scanf("%s", S + 1);
Build();
for (int i = 1, id; i <= m; ++i) {
scanf("%s%d", op, &id);
id--;
if (op[0] == '+') Add(id);
if (op[0] == '-') len[id]--;
puts(dp[len[0]][len[1]][len[2]] <= n ? "YES" : "NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[100011][26], dp2[251][251][251];
void init(const string& second) {
int n = second.length(), i, j;
for (i = 0; i <= 25; ++i) {
dp[n][i] = n;
dp[n + 1][i] = n;
}
for (i = n - 1; i >= 0; --i) {
for (j = 0; j < 26; ++j) dp[i][j] = dp[i + 1][j];
dp[i][(second[i] - 'a')] = i;
}
}
string ar[3], second;
int func(int x, int y, int z) {
if (dp2[x][y][z] != -2) return dp2[x][y][z];
if (x == 0 && y == 0 && z == 0) return dp2[x][y][z] = -1;
int ans = second.length() + 10, zz;
if (x > 0) {
zz = (ar[0][x - 1] - 'a');
ans = min(ans, dp[func(x - 1, y, z) + 1][zz]);
}
if (y > 0) {
zz = (ar[1][y - 1] - 'a');
ans = min(ans, dp[func(x, y - 1, z) + 1][zz]);
}
if (z > 0) {
zz = (ar[2][z - 1] - 'a');
ans = min(ans, dp[func(x, y, z - 1) + 1][zz]);
}
return dp2[x][y][z] = ans;
}
int main() {
std::ios::sync_with_stdio(false);
int T;
T = 1;
while (T--) {
int n, i, j, q, x, z, k;
string ch, ch2;
for (i = 0; i <= 250; ++i) {
for (j = 0; j <= 250; ++j) {
for (k = 0; k <= 250; ++k) dp2[i][j][k] = -2;
}
}
cin >> n >> q;
cin >> second;
init(second);
while (q--) {
cin >> ch;
cin >> x;
if (ch[0] == '+') {
cin >> ch2;
ar[x - 1] += ch2[0];
if (x == 1) {
for (j = 0; j <= ar[1].length(); ++j) {
for (k = 0; k <= ar[2].length(); ++k) {
func(ar[0].length(), j, k);
}
}
} else if (x == 2) {
for (j = 0; j <= ar[0].length(); ++j) {
for (k = 0; k <= ar[2].length(); ++k) {
func(j, ar[1].length(), k);
}
}
} else {
for (j = 0; j <= ar[0].length(); ++j) {
for (k = 0; k <= ar[1].length(); ++k) {
func(j, k, ar[2].length());
}
}
}
} else {
if (x == 1) {
for (j = 0; j <= ar[1].length(); ++j) {
for (k = 0; k <= ar[2].length(); ++k) {
dp2[ar[0].length()][j][k] = -2;
}
}
} else if (x == 2) {
for (j = 0; j <= ar[0].length(); ++j) {
for (k = 0; k <= ar[2].length(); ++k) {
dp2[j][ar[1].length()][k] = -2;
}
}
} else {
for (j = 0; j <= ar[0].length(); ++j) {
for (k = 0; k <= ar[1].length(); ++k) {
dp2[j][k][ar[2].length()] = -2;
}
}
}
ar[x - 1].pop_back();
}
if (dp2[ar[0].length()][ar[1].length()][ar[2].length()] < n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
static void redirect(int argc, const char **argv) {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (argc > 1) {
static filebuf f;
f.open(argv[1], ios::in);
cin.rdbuf(&f);
if (!cin) {
cerr << "Failed to open '" << argv[1] << "'" << endl;
exit(1);
}
}
if (argc > 2) {
static filebuf f;
f.open(argv[2], ios::out | ios::trunc);
cout.rdbuf(&f);
if (!cout) {
cerr << "Failed to open '" << argv[2] << "'" << endl;
}
}
}
static int dp[251][251][251];
int main(int argc, const char **argv) {
redirect(argc, argv);
int N, Q;
string W;
cin >> N >> Q >> W;
array<vector<int>, 26> pos;
for (int i = 0; i < N; i++) pos[W[i] - 'a'].push_back(i);
for (int i = 0; i < 26; i++) pos[i].push_back(N);
auto nextc = [&](int p, char c) {
if (p >= N) return N + 1;
return *lower_bound(begin(pos[c - 'a']), end(pos[c - 'a']), p) + 1;
};
array<string, 3> b;
dp[0][0][0] = 0;
for (int q = 0; q < Q; q++) {
char t;
int r;
char c;
cin >> t >> r;
r--;
if (t == '+') {
cin >> c;
b[r] += c;
array<int, 3> low, high;
for (int i = 0; i < 3; i++) {
low[i] = 0;
high[i] = ((long long)(b[i]).size());
}
low[r] = ((long long)(b[r]).size());
for (int i = low[0]; i <= high[0]; i++)
for (int j = low[1]; j <= high[1]; j++)
for (int k = low[2]; k <= high[2]; k++) {
int v = N + 1;
if (i > 0) v = min(v, nextc(dp[i - 1][j][k], b[0][i - 1]));
if (j > 0) v = min(v, nextc(dp[i][j - 1][k], b[1][j - 1]));
if (k > 0) v = min(v, nextc(dp[i][j][k - 1], b[2][k - 1]));
dp[i][j][k] = v;
}
} else
b[r].pop_back();
cout << (dp[((long long)(b[0]).size())][((long long)(b[1]).size())]
[((long long)(b[2]).size())] <= N
? "YES\n"
: "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int M;
int dp[255][255][255];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
M = 100005;
int n, i, j, k, q;
int sa[] = {0, 0, 0, 0};
vector<char> ca[4];
cin >> n >> q;
string w;
cin >> w;
int lca[n + 1][26];
for (i = 0; i < 26; i++) {
lca[n][i] = M;
}
for (i = n - 1; i >= 0; i--) {
for (j = 0; j < 26; j++) {
if (w[i] == ('a' + j))
lca[i][j] = i + 1;
else
lca[i][j] = lca[i + 1][j];
}
}
dp[0][0][0] = 0;
for (i = 0; i < q; i++) {
char a, ch;
int c;
cin >> a >> c;
if (a == '-') {
ca[c].pop_back();
sa[c]--;
} else {
cin >> ch;
sa[c]++;
ca[c].push_back(ch);
if (c == 1) {
for (j = 0; j <= sa[2]; j++) {
for (k = 0; k <= sa[3]; k++) {
dp[sa[1]][j][k] = M;
if (dp[sa[1] - 1][j][k] < M)
dp[sa[1]][j][k] = lca[dp[sa[1] - 1][j][k]][ch - 'a'];
if (j > 0 && dp[sa[1]][j - 1][k] < M)
dp[sa[1]][j][k] =
min(dp[sa[1]][j][k],
lca[dp[sa[1]][j - 1][k]][ca[2][j - 1] - 'a']);
if (k > 0 && dp[sa[1]][j][k - 1] < M)
dp[sa[1]][j][k] =
min(dp[sa[1]][j][k],
lca[dp[sa[1]][j][k - 1]][ca[3][k - 1] - 'a']);
}
}
} else if (c == 2) {
for (j = 0; j <= sa[1]; j++) {
for (k = 0; k <= sa[3]; k++) {
dp[j][sa[2]][k] = M;
if (dp[j][sa[2] - 1][k] < M)
dp[j][sa[2]][k] = lca[dp[j][sa[2] - 1][k]][ch - 'a'];
if (j > 0 && dp[j - 1][sa[2]][k] < M)
dp[j][sa[2]][k] =
min(dp[j][sa[2]][k],
lca[dp[j - 1][sa[2]][k]][ca[1][j - 1] - 'a']);
if (k > 0 && dp[j][sa[2]][k - 1] < M)
dp[j][sa[2]][k] =
min(dp[j][sa[2]][k],
lca[dp[j][sa[2]][k - 1]][ca[3][k - 1] - 'a']);
}
}
} else {
for (j = 0; j <= sa[1]; j++) {
for (k = 0; k <= sa[2]; k++) {
dp[j][k][sa[3]] = M;
if (dp[j][k][sa[3] - 1] < M)
dp[j][k][sa[3]] = lca[dp[j][k][sa[3] - 1]][ch - 'a'];
if (j > 0 && dp[j - 1][k][sa[3]] < M)
dp[j][k][sa[3]] =
min(dp[j][k][sa[3]],
lca[dp[j - 1][k][sa[3]]][ca[1][j - 1] - 'a']);
if (k > 0 && dp[j][k - 1][sa[3]] < M)
dp[j][k][sa[3]] =
min(dp[j][k][sa[3]],
lca[dp[j][k - 1][sa[3]]][ca[2][k - 1] - 'a']);
}
}
}
}
if (dp[sa[1]][sa[2]][sa[3]] < M)
cout << "YES";
else
cout << "NO";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void ECHO(string _s) {
cout << endl;
(void)_s;
}
template <typename T, typename... Args>
void ECHO(string _s, T x, Args... args) {
int _i;
string _s2 = "";
for (_i = 0; _i < (int)(_s).size(); ++_i) {
if (_s[_i] == ',') break;
if (_s[_i] != ' ') _s2 += _s[_i];
}
if (_i == (int)(_s).size()) {
--_i;
}
cout << " (" << _s2 << "):" << x;
ECHO(_s.substr(_i + 1, (int)(_s).size() - _i - 1), args...);
}
template <typename T0, typename T1>
inline ostream& operator<<(ostream& os, pair<T0, T1>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
inline ostream& operator<<(ostream& os, vector<T>& v) {
for (int i = 0; i < (int)(v).size(); ++i) {
if (i > 0) cout << "_";
cout << v[i];
}
cout << endl;
return os;
}
inline long long _gcd(long long a, long long b) {
while (b) b %= a ^= b ^= a ^= b;
return a;
}
mt19937 ran(time(0));
const long double PI = acos(-1);
const long double eps = 1e-9;
const int MAX_N = 1e5 + 5;
int nxt[26][MAX_N], n, na, nb, nc;
string s, a, b, c;
bool flag;
void Fill() {
int i, j;
for (j = 0; j < 26; ++j) nxt[j][n + 1] = nxt[j][n] = n;
for (i = n - 1; i >= 0; --i) {
for (j = 0; j < 26; ++j) {
if (s[i] - 'a' == j)
nxt[j][i] = i;
else
nxt[j][i] = nxt[j][i + 1];
}
}
}
int dp[255][255][255];
void recompute(int i, int j, int k) {
int& ans = dp[i][j][k];
ans = n;
if (i > 0) ans = min(ans, nxt[a[i - 1] - 'a'][dp[i - 1][j][k] + 1]);
if (j > 0) ans = min(ans, nxt[b[j - 1] - 'a'][dp[i][j - 1][k] + 1]);
if (k > 0) ans = min(ans, nxt[c[k - 1] - 'a'][dp[i][j][k - 1] + 1]);
}
int main() {
ios::sync_with_stdio(false);
int q, num, i, j, k, mini, minj, mink;
char sgn;
na = nb = nc = 0;
cin >> n >> q;
cin >> s;
Fill();
dp[0][0][0] = -1;
while (q--) {
cin >> sgn;
if (sgn == '-') {
cin >> num;
if (num == 1) {
a.pop_back();
--na;
} else if (num == 2) {
b.pop_back();
--nb;
} else {
c.pop_back();
--nc;
}
} else {
cin >> num >> sgn;
if (num == 1) {
a.push_back(sgn);
++na;
} else if (num == 2) {
b.push_back(sgn);
++nb;
} else {
c.push_back(sgn);
++nc;
}
mini = num == 1 ? na : 0;
minj = num == 2 ? nb : 0;
mink = num == 3 ? nc : 0;
for (i = mini; i <= na; ++i) {
for (j = minj; j <= nb; ++j) {
for (k = mink; k <= nc; ++k) {
if (i != 0 || j != 0 || k != 0) recompute(i, j, k);
}
}
}
}
if (dp[na][nb][nc] < n)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
string second;
string a[3];
int szs[3];
int dp[255][255][255];
int cur[26];
int nxt[200005][26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> q >> second;
for (int i = 0; i < (signed)(26); i++) cur[i] = nxt[n + 1][i] = n + 1;
for (int i = (n); i >= 1; i--) {
for (int j = 0; j < (signed)(26); j++) nxt[i][j] = cur[j];
cur[second[i - 1] - 'a'] = i;
}
for (int j = 0; j < (signed)(26); j++) nxt[0][j] = cur[j];
dp[0][0][0] = 0;
for (int _ = 0; _ < (signed)(q); _++) {
char c;
cin >> c;
if (c == '+') {
int ind;
char x;
cin >> ind >> x;
a[ind - 1].push_back(x);
++szs[ind - 1];
if (ind == 1) {
int loc = szs[0];
for (int i = (0); i <= (signed)(szs[1]); i++) {
for (int j = (0); j <= (signed)(szs[2]); j++) {
dp[loc][i][j] = nxt[dp[loc - 1][i][j]][x - 'a'];
if (i != 0) {
dp[loc][i][j] =
min(dp[loc][i][j], nxt[dp[loc][i - 1][j]][a[1][i - 1] - 'a']);
}
if (j != 0) {
dp[loc][i][j] =
min(dp[loc][i][j], nxt[dp[loc][i][j - 1]][a[2][j - 1] - 'a']);
}
}
}
} else if (ind == 2) {
int loc = szs[1];
for (int i = (0); i <= (signed)(szs[0]); i++) {
for (int j = (0); j <= (signed)(szs[2]); j++) {
dp[i][loc][j] = nxt[dp[i][loc - 1][j]][x - 'a'];
if (i != 0) {
dp[i][loc][j] =
min(dp[i][loc][j], nxt[dp[i - 1][loc][j]][a[0][i - 1] - 'a']);
}
if (j != 0) {
dp[i][loc][j] =
min(dp[i][loc][j], nxt[dp[i][loc][j - 1]][a[2][j - 1] - 'a']);
}
}
}
} else {
int loc = szs[2];
for (int i = (0); i <= (signed)(szs[0]); i++) {
for (int j = (0); j <= (signed)(szs[1]); j++) {
dp[i][j][loc] = nxt[dp[i][j][loc - 1]][x - 'a'];
if (i != 0) {
dp[i][j][loc] =
min(dp[i][j][loc], nxt[dp[i - 1][j][loc]][a[0][i - 1] - 'a']);
}
if (j != 0) {
dp[i][j][loc] =
min(dp[i][j][loc], nxt[dp[i][j - 1][loc]][a[1][j - 1] - 'a']);
}
}
}
}
} else {
int i;
cin >> i;
a[i - 1].pop_back();
--szs[i - 1];
}
if (dp[szs[0]][szs[1]][szs[2]] <= n) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 100;
const int maxm = 200000 + 100;
const int maxs = 256;
const long long 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 long long 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);
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;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 1e5 + 10;
char str[maxn], A[3][255];
int n, m, sz[3], nxt[26][maxn], dp[255][255][255];
inline int checkmin(int& x, int y) { return x < y ? x : x = y; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
scanf("%d %d %s", &n, &m, str + 1);
for (int j = 0; j < 26; j++) {
for (int i = n, pos = n + 1; ~i; i--) {
nxt[j][i] = pos;
if (str[i] == j + 'a') pos = i;
}
}
dp[0][0][0] = 0;
char op[3];
int x;
while (m--) {
scanf("%s %d", op, &x), x--;
if (*op == '+') {
scanf("%s", op);
A[x][++sz[x]] = *op;
int s0 = x == 0 ? sz[0] : 0;
int s1 = x == 1 ? sz[1] : 0;
int s2 = x == 2 ? sz[2] : 0;
for (int i = s0; i <= sz[0]; i++) {
for (int j = s1; j <= sz[1]; j++) {
for (int k = s2; k <= sz[2]; k++) {
dp[i][j][k] = n + 1;
if (i && dp[i - 1][j][k] <= n)
checkmin(dp[i][j][k], nxt[A[0][i] - 'a'][dp[i - 1][j][k]]);
if (j && dp[i][j - 1][k] <= n)
checkmin(dp[i][j][k], nxt[A[1][j] - 'a'][dp[i][j - 1][k]]);
if (k && dp[i][j][k - 1] <= n)
checkmin(dp[i][j][k], nxt[A[2][k] - 'a'][dp[i][j][k - 1]]);
}
}
}
} else {
sz[x]--;
}
cout << (dp[sz[0]][sz[1]][sz[2]] <= n ? "YES" : "NO") << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)998244353;
const int max_n = 251;
string words[3];
int dp[max_n][max_n][max_n];
int pre[100005][26];
int n;
void recompute(int a, int b, int c) {
int& val = dp[a][b][c];
val = n + 1;
if (a) val = min(val, pre[dp[a - 1][b][c] + 1][words[0][a - 1] - 'a']);
if (b) val = min(val, pre[dp[a][b - 1][c] + 1][words[1][b - 1] - 'a']);
if (c) val = min(val, pre[dp[a][b][c - 1] + 1][words[2][c - 1] - 'a']);
}
void solve() {
int q;
cin >> n >> q;
string s;
cin >> s;
for (int i = 0; i <= n + 3; i++)
for (int j = 0; j < 26; j++) pre[i][j] = n + 1;
for (int i = 0; i < n; i++) pre[i][s[i] - 'a'] = i;
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j < 26; j++) pre[i][j] = min(pre[i][j], pre[i + 1][j]);
dp[0][0][0] = -1;
while (q--) {
char type;
int id;
cin >> type >> id;
id--;
if (type == '+') {
char ch;
cin >> ch;
words[id].push_back(ch);
int mxa = (int)words[0].size(), mxb = (int)words[1].size(),
mxc = (int)words[2].size();
int mna = (id == 0 ? mxa : 0);
int mnb = (id == 1 ? mxb : 0);
int mnc = (id == 2 ? mxc : 0);
for (int a = mna; a <= mxa; a++) {
for (int b = mnb; b <= mxb; b++) {
for (int c = mnc; c <= mxc; c++) {
recompute(a, b, c);
}
}
}
} else {
words[id].pop_back();
}
int a = (int)words[0].size(), b = (int)words[1].size(),
c = (int)words[2].size();
if (dp[a][b][c] < n)
cout << "YES\n";
else
cout << "NO\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100005;
int nxt[nmax][30];
int dp[255][255][255];
string s;
char a[5][255];
int nr[5], l[5], r[5];
int n, q, i, j, k, wh;
char ch, tip;
void prp(int &a, int b) {
if (b < a) a = b;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> q;
cin >> s;
s = " " + s;
for (j = 0; j < 26; j++) nxt[n + 1][j] = n + 1;
for (i = n; i >= 0; i--) {
for (j = 0; j < 26; j++) nxt[i][j] = nxt[i + 1][j];
if (i + 1 <= n) nxt[i][s[i + 1] - 'a'] = i + 1;
}
for (i = 0; i <= 250; i++)
for (j = 0; j <= 250; j++) dp[0][i][j] = dp[i][0][j] = dp[i][j][0] = n + 1;
dp[0][0][0] = 0;
for (int cnt = 1; cnt <= q; cnt++) {
cin >> tip >> wh;
if (tip == '+') {
cin >> ch;
a[wh][++nr[wh]] = ch;
for (i = 1; i <= 3; i++) l[i] = 0, r[i] = nr[i];
l[wh] = nr[wh];
for (i = l[1]; i <= r[1]; i++)
for (j = l[2]; j <= r[2]; j++)
for (k = l[3]; k <= r[3]; k++) dp[i][j][k] = n + 1;
for (i = l[1]; i <= r[1]; i++)
for (j = l[2]; j <= r[2]; j++)
for (k = l[3]; k <= r[3]; k++) {
if (i) prp(dp[i][j][k], nxt[dp[i - 1][j][k]][a[1][i] - 'a']);
if (j) prp(dp[i][j][k], nxt[dp[i][j - 1][k]][a[2][j] - 'a']);
if (k) prp(dp[i][j][k], nxt[dp[i][j][k - 1]][a[3][k] - 'a']);
}
} else
nr[wh]--;
if (dp[nr[1]][nr[2]][nr[3]] <= n)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int R() {
int rt;
scanf("%d", &rt);
return rt;
}
const int MAXN = 1e5 + 7, MAXL = 257;
int dp[MAXL][MAXL][MAXL], len[5];
vector<char> w[5];
char s[MAXN];
int nxt[MAXN][27], lst[27];
int main() {
int n = R(), q = R();
scanf("%s", s + 1);
w[1].push_back(0), w[2].push_back(0), w[3].push_back(0);
for (int i = 0; i < 26; ++i) lst[i] = n + 1, nxt[n + 1][i] = n + 1;
for (int i = n; i >= 0; --i) {
for (int j = 0; j < 26; ++j) nxt[i][j] = lst[j];
if (i) lst[s[i] - 'a'] = i;
}
for (int i = 0; i <= 250; ++i)
for (int j = 0; j <= 250; ++j)
for (int k = 0; k <= 250; ++k) dp[i][j][k] = n + 1;
dp[0][0][0] = 0;
for (; q; --q) {
char ch = getchar();
while (ch != '+' && ch != '-') ch = getchar();
if (ch == '+') {
int x = R();
while (ch < 'a' || ch > 'z') ch = getchar();
++len[x], w[x].push_back(ch);
if (x == 1)
for (int i = 0; i <= len[2]; ++i)
for (int j = 0; j <= len[3]; ++j) {
if (len[x])
dp[len[x]][i][j] =
min(dp[len[x]][i][j],
nxt[dp[len[x] - 1][i][j]][w[x][len[x]] - 'a']);
if (i)
dp[len[x]][i][j] = min(dp[len[x]][i][j],
nxt[dp[len[x]][i - 1][j]][w[2][i] - 'a']);
if (j)
dp[len[x]][i][j] = min(dp[len[x]][i][j],
nxt[dp[len[x]][i][j - 1]][w[3][j] - 'a']);
}
if (x == 2)
for (int i = 0; i <= len[1]; ++i)
for (int j = 0; j <= len[3]; ++j) {
if (i)
dp[i][len[x]][j] = min(dp[i][len[x]][j],
nxt[dp[i - 1][len[x]][j]][w[1][i] - 'a']);
if (len[x])
dp[i][len[x]][j] =
min(dp[i][len[x]][j],
nxt[dp[i][len[x] - 1][j]][w[x][len[x]] - 'a']);
if (j)
dp[i][len[x]][j] = min(dp[i][len[x]][j],
nxt[dp[i][len[x]][j - 1]][w[3][j] - 'a']);
}
if (x == 3)
for (int i = 0; i <= len[1]; ++i)
for (int j = 0; j <= len[2]; ++j) {
if (i)
dp[i][j][len[x]] = min(dp[i][j][len[x]],
nxt[dp[i - 1][j][len[x]]][w[1][i] - 'a']);
if (j)
dp[i][j][len[x]] = min(dp[i][j][len[x]],
nxt[dp[i][j - 1][len[x]]][w[2][j] - 'a']);
if (len[x])
dp[i][j][len[x]] =
min(dp[i][j][len[x]],
nxt[dp[i][j][len[x] - 1]][w[x][len[x]] - 'a']);
}
} else {
int x = R();
if (x == 1)
for (int i = 0; i <= len[2]; ++i)
for (int j = 0; j <= len[3]; ++j) dp[len[x]][i][j] = n + 1;
if (x == 2)
for (int i = 0; i <= len[1]; ++i)
for (int j = 0; j <= len[3]; ++j) dp[i][len[x]][j] = n + 1;
if (x == 3)
for (int i = 0; i <= len[1]; ++i)
for (int j = 0; j <= len[2]; ++j) dp[i][j][len[x]] = n + 1;
--len[x], w[x].pop_back();
}
puts((dp[len[1]][len[2]][len[3]] == (n + 1)) ? "NO" : "YES");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T>
void ndarray(vector<T> &vec, int len) {
vec.resize(len);
}
template <typename T, typename... Args>
void ndarray(vector<T> &vec, int len, Args... args) {
vec.resize(len);
for (auto &v : vec) ndarray(v, args...);
}
template <typename T>
bool mmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T>
bool mmin(T &m, const T q) {
if (m > q) {
m = q;
return true;
} else
return false;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec) os << v << ",";
os << "]";
return os;
}
constexpr int M = 251;
constexpr int INF = 100000000;
int main() {
int N, Q;
string S;
cin >> N >> Q >> S;
vector<vector<vector<int>>> dp;
ndarray(dp, M, M, M);
for (int i = (0), i_end_ = (M); i < i_end_; i++)
for (int j = (0), j_end_ = (M); j < j_end_; j++)
for (int k = (0), k_end_ = (M); k < k_end_; k++) dp[i][j][k] = INF;
dp[0][0][0] = -1;
vector<vector<int>> search;
ndarray(search, 26, S.length());
for (int c = (0), c_end_ = (26); c < c_end_; c++) {
int now = INF;
for (int i = (S.length()) - 1, i_begin_ = (0); i >= i_begin_; i--) {
if (S[i] - 'a' == c) now = i;
search[c][i] = now;
}
}
vector<string> word(3);
for (int i = (0), i_end_ = (Q); i < i_end_; i++) {
char c;
int j;
cin >> c >> j;
j--;
if (c == '+') {
char v;
cin >> v;
word[j].push_back(v);
for (int s = (0), s_end_ = (M); s < s_end_; s++)
for (int t = (0), t_end_ = (M); t < t_end_; t++) {
int l, m, n;
if (j == 0)
l = word[j].length(), m = s, n = t;
else if (j == 1)
l = s, m = word[j].length(), n = t;
else
l = s, m = t, n = word[j].length();
if (l + m + n == 0) continue;
dp[l][m][n] = INF;
if (l > 0 and l - 1 < word[0].size() and dp[l - 1][m][n] + 1 < N)
mmin(dp[l][m][n],
search[word[0][l - 1] - 'a'][dp[l - 1][m][n] + 1]);
if (m > 0 and m - 1 < word[1].size() and dp[l][m - 1][n] + 1 < N)
mmin(dp[l][m][n],
search[word[1][m - 1] - 'a'][dp[l][m - 1][n] + 1]);
if (n > 0 and n - 1 < word[2].size() and dp[l][m][n - 1] + 1 < N)
mmin(dp[l][m][n],
search[word[2][n - 1] - 'a'][dp[l][m][n - 1] + 1]);
}
} else
word[j].pop_back();
if (dp[word[0].length()][word[1].length()][word[2].length()] < INF)
puts("YES");
else
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
string s[3];
int a[100010][26];
int dp[260][260][260];
void f(int l1, int l2, int l3) {
if (dp[l1][l2][l3] != -1) return;
int ans = INT_MAX;
dp[l1][l2][l3] = -1;
if (l1 > 0) {
f(l1 - 1, l2, l3);
if (dp[l1 - 1][l2][l3] != -1) {
int r1 = dp[l1 - 1][l2][l3];
if (r1 < n) {
int r2 = a[r1][s[0][l1 - 1] - 97];
if (r2 != -1) ans = min(ans, r2 + 1);
}
} else
return;
}
if (l2 > 0) {
f(l1, l2 - 1, l3);
if (dp[l1][l2 - 1][l3] != -1) {
int r1 = dp[l1][l2 - 1][l3];
if (r1 < n) {
int r2 = a[r1][s[1][l2 - 1] - 97];
if (r2 != -1) ans = min(ans, r2 + 1);
}
} else
return;
}
if (l3 > 0) {
f(l1, l2, l3 - 1);
if (dp[l1][l2][l3 - 1] != -1) {
int r1 = dp[l1][l2][l3 - 1];
if (r1 < n) {
int r2 = a[r1][s[2][l3 - 1] - 97];
if (r2 != -1) ans = min(ans, r2 + 1);
}
} else
return;
}
if (ans != INT_MAX) dp[l1][l2][l3] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string str;
cin >> n >> q >> str;
for (int i = 0; i < 26; i++) a[n - 1][i] = -1;
a[n - 1][str[n - 1] - 97] = n - 1;
for (int i = n - 2; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
a[i][j] = a[i + 1][j];
}
a[i][str[i + 1] - 97] = i + 1;
a[i][str[i] - 97] = i;
}
for (int i = 0; i < 3; i++) s[i] = "";
for (int i = 0; i < 251; i++) {
for (int j = 0; j < 251; j++) {
for (int k = 0; k < 251; k++) {
dp[i][j][k] = -1;
}
}
}
dp[0][0][0] = 0;
while (q--) {
char x;
cin >> x;
int t;
cin >> t;
if (x == '+') {
char p;
cin >> p;
s[t - 1] += p;
} else {
int l = s[0].size();
int r = s[1].size();
if (t == 1) {
l = s[1].size();
r = s[2].size();
}
if (t == 2) {
l = s[0].size();
r = s[2].size();
}
for (int i = 0; i <= l; i++) {
for (int j = 0; j <= r; j++) {
if (t == 1) dp[s[0].size()][i][j] = -1;
if (t == 2) dp[i][s[1].size()][j] = -1;
if (t == 3) dp[i][j][s[2].size()] = -1;
}
}
s[t - 1].erase(s[t - 1].begin() + s[t - 1].size() - 1);
dp[0][0][0] = 0;
}
int l1 = s[0].size();
int l2 = s[1].size();
int l3 = s[2].size();
f(l1, l2, l3);
if (dp[l1][l2][l3] == -1)
puts("NO");
else
puts("YES");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int inf = 0x3f3f3f3f;
int n, q, x, dp[255][255][255], nxt[maxn][30], len[5];
char str[maxn], s[5][255], ch[10];
void init() {
for (int i = 0; i < 26; i++) nxt[n][i] = nxt[n + 1][i] = n + 1;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
nxt[i][j] = nxt[i + 1][j];
}
nxt[i][str[i] - 'a'] = i + 1;
}
}
int main() {
scanf("%d%d%s", &n, &q, str);
init();
while (q--) {
scanf("%s%d", ch, &x);
if (ch[0] == '-')
len[x]--;
else {
len[x]++;
scanf("%s", ch);
s[x][len[x]] = ch[0];
for (int i = (x == 1 ? len[x] : 0); i <= len[1]; i++) {
for (int j = (x == 2 ? len[x] : 0); j <= len[2]; j++) {
for (int k = (x == 3 ? len[x] : 0); k <= len[3]; k++) {
dp[i][j][k] = n + 1;
if (i)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k]][s[1][i] - 'a']);
if (j)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k]][s[2][j] - 'a']);
if (k)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1]][s[3][k] - 'a']);
}
}
}
}
if (dp[len[1]][len[2]][len[3]] <= n)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, dp[255][255][255], sz[3], i, sig[100005][26];
string s, a[3];
char op, h;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q >> s;
memset(sig, -1, sizeof(sig));
for (char &c : s) c -= 'a';
for (int i = 0; i < 26; i++) sig[n][i] = n;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) sig[i][j] = sig[i + 1][j];
sig[i][s[i]] = i;
}
dp[0][0][0] = -1;
while (q--) {
cin >> op >> i;
i--;
if (op == '-') {
a[i].pop_back();
sz[i]--;
} else {
cin >> h;
a[i].push_back(h - 'a');
sz[i]++;
for (int x = (i == 0 ? sz[0] : 0); x <= sz[0]; x++)
for (int y = (i == 1 ? sz[1] : 0); y <= sz[1]; y++)
for (int z = (i == 2 ? sz[2] : 0); z <= sz[2]; z++) {
dp[x][y][z] = n;
if (x && dp[x - 1][y][z] < n)
dp[x][y][z] =
min(dp[x][y][z], sig[dp[x - 1][y][z] + 1][a[0][x - 1]]);
if (y && dp[x][y - 1][z] < n)
dp[x][y][z] =
min(dp[x][y][z], sig[dp[x][y - 1][z] + 1][a[1][y - 1]]);
if (z && dp[x][y][z - 1] < n)
dp[x][y][z] =
min(dp[x][y][z], sig[dp[x][y][z - 1] + 1][a[2][z - 1]]);
}
}
if (dp[sz[0]][sz[1]][sz[2]] < n)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
inline int readInt() {
int x;
scanf("%d", &x);
return x;
}
int dp[255][255][255];
int nex[26][100005];
char words[3][256];
int cnt[3];
int main() {
int n, q;
string s;
scanf("%d%d", &n, &q);
cin >> s;
vector<int> nt(26, n + 1);
for (int j = 0; j < (int)26; ++j) nex[j][n + 1] = n + 1;
for (int i = n; i >= 0; i--) {
for (int j = 0; j < (int)26; ++j) nex[j][i] = nt[j];
if (i > 0) nt[s[i - 1] - 'a'] = i;
}
for (int i = 0; i < (int)255; ++i)
for (int j = 0; j < (int)255; ++j)
for (int k = 0; k < (int)255; ++k) dp[i][j][k] = n + 1;
dp[0][0][0] = 0;
for (int i = 0; i < (int)q; ++i) {
char op[2], ch[2];
int idx;
scanf("%s%d", op, &idx);
idx--;
if (op[0] == '+') {
scanf("%s", ch);
words[idx][cnt[idx]] = ch[0];
cnt[idx]++;
for (int i = (idx == 0) ? cnt[0] : 0; i < (int)cnt[0] + 1; ++i) {
for (int j = (idx == 1) ? cnt[1] : 0; j < (int)cnt[1] + 1; ++j) {
for (int k = (idx == 2) ? cnt[2] : 0; k < (int)cnt[2] + 1; ++k) {
if (i > 0)
dp[i][j][k] =
min(dp[i][j][k], nex[words[0][i - 1] - 'a'][dp[i - 1][j][k]]);
if (j > 0)
dp[i][j][k] =
min(dp[i][j][k], nex[words[1][j - 1] - 'a'][dp[i][j - 1][k]]);
if (k > 0)
dp[i][j][k] =
min(dp[i][j][k], nex[words[2][k - 1] - 'a'][dp[i][j][k - 1]]);
}
}
}
} else {
for (int i = (idx == 0) ? cnt[0] : 0; i < (int)cnt[0] + 1; ++i) {
for (int j = (idx == 1) ? cnt[1] : 0; j < (int)cnt[1] + 1; ++j) {
for (int k = (idx == 2) ? cnt[2] : 0; k < (int)cnt[2] + 1; ++k) {
dp[i][j][k] = n + 1;
}
}
}
cnt[idx]--;
}
if (dp[cnt[0]][cnt[1]][cnt[2]] <= n) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LLMAX = 2e18;
const int MOD = 1e9 + 7;
const double eps = 1e-8;
const int MAXN = 1e6 + 10;
inline long long sqr(long long x) { return x * x; }
inline int sqr(int x) { return x * x; }
inline double sqr(double x) { return x * x; }
long long __gcd(long long a, long long b) {
return b == 0 ? a : __gcd(b, a % b);
}
long long qpow(long long a, long long n) {
long long sum = 1;
while (n) {
if (n & 1) sum = sum * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return sum;
}
inline int dcmp(double x) {
if (fabs(x) < eps) return 0;
return (x > 0 ? 1 : -1);
}
int __next[MAXN][26], len[4], seq[4][251], dp[251][251][251];
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q;
string s;
cin >> n >> q >> s;
dp[0][0][0] = -1;
memset(__next, 0x3f3f3f3f, sizeof(__next));
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j < 26; j++)
if (s[i] == 'a' + j)
__next[i][j] = i;
else
__next[i][j] = __next[i + 1][j];
while (q--) {
string in, y;
int x;
cin >> in;
if (in == "+") {
cin >> x >> y;
seq[x][++len[x]] = y[0] - 'a';
for (int i = (x == 1 ? len[1] : 0); i <= len[1]; i++)
for (int j = (x == 2 ? len[2] : 0); j <= len[2]; j++)
for (int k = (x == 3 ? len[3] : 0); k <= len[3]; k++) {
dp[i][j][k] = 0x3f3f3f3f;
if (i && dp[i - 1][j][k] != 0x3f3f3f3f)
dp[i][j][k] =
min(dp[i][j][k], __next[dp[i - 1][j][k] + 1][seq[1][i]]);
if (j && dp[i][j - 1][k] != 0x3f3f3f3f)
dp[i][j][k] =
min(dp[i][j][k], __next[dp[i][j - 1][k] + 1][seq[2][j]]);
if (k && dp[i][j][k - 1] != 0x3f3f3f3f)
dp[i][j][k] =
min(dp[i][j][k], __next[dp[i][j][k - 1] + 1][seq[3][k]]);
}
} else {
cin >> x;
len[x]--;
}
if (dp[len[1]][len[2]][len[3]] == 0x3f3f3f3f)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 1e5 + 10;
char str[maxn], A[3][255];
int n, m, sz[3], nxt[26][maxn], dp[255][255][255];
inline int checkmin(int &x, int y) { return x < y ? x : x = y; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
scanf("%d %d %s", &n, &m, str + 1);
for (int j = 0; j < 26; j++) {
for (int i = n, pos = n + 1; ~i; i--) {
nxt[j][i] = pos;
if (str[i] == j + 'a') pos = i;
}
}
dp[0][0][0] = 0;
char op[3];
int x;
while (m--) {
scanf("%s %d", op, &x), x--;
if (*op == '+') {
scanf("%s", op);
A[x][++sz[x]] = *op;
int s0 = x == 0 ? sz[0] : 0;
int s1 = x == 1 ? sz[1] : 0;
int s2 = x == 2 ? sz[2] : 0;
for (int i = s0; i <= sz[0]; i++) {
for (int j = s1; j <= sz[1]; j++) {
for (int k = s2; k <= sz[2]; k++) {
dp[i][j][k] = n + 1;
if (i && dp[i - 1][j][k] <= n)
checkmin(dp[i][j][k], nxt[A[0][i] - 'a'][dp[i - 1][j][k]]);
if (j && dp[i][j - 1][k] <= n)
checkmin(dp[i][j][k], nxt[A[1][j] - 'a'][dp[i][j - 1][k]]);
if (k && dp[i][j][k - 1] <= n)
checkmin(dp[i][j][k], nxt[A[2][k] - 'a'][dp[i][j][k - 1]]);
}
}
}
} else {
sz[x]--;
}
cout << (dp[sz[0]][sz[1]][sz[2]] <= n ? "YES" : "NO") << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 4;
const int n_alpha = 26;
int post[maxn][n_alpha];
int dp[254][254][254];
vector<int> r[3];
void update(int i, int j, int k) {
int ans = -1;
if (i > 0 && dp[i - 1][j][k] != -1) {
int ret = post[dp[i - 1][j][k]][r[0][i - 1]];
if (ret != -1 && (ans == -1 || ret < ans)) ans = ret;
}
if (j > 0 && dp[i][j - 1][k] != -1) {
int ret = post[dp[i][j - 1][k]][r[1][j - 1]];
if (ret != -1 && (ans == -1 || ret < ans)) ans = ret;
}
if (k > 0 && dp[i][j][k - 1] != -1) {
int ret = post[dp[i][j][k - 1]][r[2][k - 1]];
if (ret != -1 && (ans == -1 || ret < ans)) ans = ret;
}
dp[i][j][k] = ans;
}
int main(void) {
int n, q;
while (cin >> n >> q) {
memset(post, -1, sizeof(post));
r[0].clear();
r[1].clear();
r[2].clear();
string word;
cin >> word;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < n_alpha; j++) {
post[i][j] = post[i + 1][j];
}
post[i][word[i] - 'a'] = i + 1;
}
memset(dp, -1, sizeof(dp));
dp[0][0][0] = 0;
for (int o = 0; o < q; o++) {
string op;
int pos;
cin >> op >> pos;
pos--;
string letter;
int n1[3];
n1[0] = r[0].size();
n1[1] = r[1].size();
n1[2] = r[2].size();
if (op == "+") {
cin >> letter;
r[pos].push_back(letter[0] - 'a');
} else {
r[pos].pop_back();
}
int n2[3];
n2[0] = r[0].size();
n2[1] = r[1].size();
n2[2] = r[2].size();
if (op == "+") {
int v = letter[0] - 'a';
int p = n2[pos] - 1;
if (pos == 0) {
for (int j = 0; j <= n2[1]; j++) {
for (int k = 0; k <= n2[2]; k++) {
update(p + 1, j, k);
}
}
}
if (pos == 1) {
for (int i = 0; i <= n2[0]; i++) {
for (int k = 0; k <= n2[2]; k++) {
update(i, p + 1, k);
}
}
}
if (pos == 2) {
for (int i = 0; i <= n2[0]; i++) {
for (int j = 0; j <= n2[1]; j++) {
update(i, j, p + 1);
}
}
}
if (dp[n2[0]][n2[1]][n2[2]] == -1) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
} else {
if (dp[n2[0]][n2[1]][n2[2]] == -1) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int maxn = 110000;
string s;
int nxt[maxn][26];
const int maxl = 271;
int dp[maxl][maxl][maxl];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int n, q;
cin >> n >> q;
cin >> s;
s = '#' + s;
++n;
for (int j = 0; j < (int)(26); ++j) nxt[n - 1][j] = nxt[n][j] = n;
for (int i = (int)(n - 1) - 1; i >= 0; --i)
for (int j = 0; j < (int)(26); ++j)
nxt[i][j] = s[i + 1] == (char)('a' + j) ? i + 1 : nxt[i + 1][j];
vector<string> t(3);
for (int i = 0; i < (int)(q); ++i) {
char c;
cin >> c;
if (c == '+') {
int z;
char l;
cin >> z >> l;
--z;
if (z == 0) {
t[0] += l;
int i = t[0].size();
for (int j = 0; j < (int)(t[1].size() + 1); ++j)
for (int k = 0; k < (int)(t[2].size() + 1); ++k)
dp[i][j][k] = nxt[dp[i - 1][j][k]][l - 'a'];
for (int j = 0; j < (int)(t[1].size() + 1); ++j)
for (int k = 0; k < (int)(t[2].size() + 1); ++k) {
if (j < t[1].size())
uin(dp[i][j + 1][k], nxt[dp[i][j][k]][t[1][j] - 'a']);
if (k < t[2].size())
uin(dp[i][j][k + 1], nxt[dp[i][j][k]][t[2][k] - 'a']);
}
} else if (z == 1) {
t[1] += l;
int j = t[1].size();
for (int i = 0; i < (int)(t[0].size() + 1); ++i)
for (int k = 0; k < (int)(t[2].size() + 1); ++k)
dp[i][j][k] = nxt[dp[i][j - 1][k]][l - 'a'];
for (int i = 0; i < (int)(t[0].size() + 1); ++i)
for (int k = 0; k < (int)(t[2].size() + 1); ++k) {
if (i < t[0].size())
uin(dp[i + 1][j][k], nxt[dp[i][j][k]][t[0][i] - 'a']);
if (k < t[2].size())
uin(dp[i][j][k + 1], nxt[dp[i][j][k]][t[2][k] - 'a']);
}
} else {
t[2] += l;
int k = t[2].size();
for (int i = 0; i < (int)(t[0].size() + 1); ++i)
for (int j = 0; j < (int)(t[1].size() + 1); ++j)
dp[i][j][k] = nxt[dp[i][j][k - 1]][l - 'a'];
for (int i = 0; i < (int)(t[0].size() + 1); ++i)
for (int j = 0; j < (int)(t[1].size() + 1); ++j) {
if (i < t[0].size())
uin(dp[i + 1][j][k], nxt[dp[i][j][k]][t[0][i] - 'a']);
if (j < t[1].size())
uin(dp[i][j + 1][k], nxt[dp[i][j][k]][t[1][j] - 'a']);
}
}
} else {
int z;
cin >> z;
--z;
t[z].resize(t[z].size() - 1);
}
cout << (dp[t[0].size()][t[1].size()][t[2].size()] < n ? "YES" : "NO")
<< '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
const int maxn = (long long)1e5 + 5;
const int inf = 0x3f3f3f3f;
char a[4][255], s[maxn];
int len[4];
int nxt[maxn][27];
int last[maxn];
int dp[255][255][255];
inline void f(int x, int y, int z) {
dp[x][y][z] = inf;
if (x && dp[x - 1][y][z] != inf)
dp[x][y][z] = min(dp[x][y][z], nxt[dp[x - 1][y][z]][a[1][x] - 'a']);
if (y && dp[x][y - 1][z] != inf)
dp[x][y][z] = min(dp[x][y][z], nxt[dp[x][y - 1][z]][a[2][y] - 'a']);
if (z && dp[x][y][z - 1] != inf)
dp[x][y][z] = min(dp[x][y][z], nxt[dp[x][y][z - 1]][a[3][z] - 'a']);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, q;
cin >> n >> q;
cin >> (s + 1);
memset(last, inf, sizeof(last));
for (int i = n; ~i; --i) {
for (int j = 0; j < 26; ++j) nxt[i][j] = last[j];
if (i) last[s[i] - 'a'] = i;
}
while (q--) {
string opt;
cin >> opt;
if (opt == "+") {
int t;
cin >> t >> opt;
a[t][++len[t]] = opt[0];
if (t == 1)
for (int i = 0; i <= len[2]; ++i)
for (int j = 0; j <= len[3]; ++j) f(len[1], i, j);
if (t == 2)
for (int i = 0; i <= len[1]; ++i)
for (int j = 0; j <= len[3]; ++j) f(i, len[2], j);
if (t == 3)
for (int i = 0; i <= len[1]; ++i)
for (int j = 0; j <= len[2]; ++j) f(i, j, len[3]);
} else {
int t;
cin >> t;
--len[t];
}
cout << (dp[len[1]][len[2]][len[3]] <= n ? "YES" : "NO") << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[100010];
int dp[26][100010];
int maxP[260][260][260];
int len[3];
int idx[3];
char desc[3][260];
int get(int rel) {
int m = maxP[idx[0] - (rel == 0)][idx[1] - (rel == 1)][idx[2] - (rel == 2)];
if (m == 100010) return 100010;
return dp[desc[rel][idx[rel] - 1] - 'a'][m];
}
int main(void) {
setbuf(stdout, 0);
int N, Q;
cin >> N >> Q;
cin >> str;
for (int i = 0; i < 26; i++) dp[i][N] = 100010;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 26; j++) {
if (str[N - 1 - i] == 'a' + j)
dp[j][N - 1 - i] = N - i;
else
dp[j][N - 1 - i] = dp[j][N - i];
}
}
for (int q = 0; q < Q; q++) {
char o, c;
int i;
cin >> o >> i;
i--;
if (o == '+') {
cin >> c;
desc[i][len[i]++] = c;
idx[i] = len[i];
if (i == 0) {
for (int j = 0; j <= len[1]; j++) {
idx[1] = j;
for (int k = 0; k <= len[2]; k++) {
idx[2] = k;
maxP[len[0]][j][k] = get(i);
if (j) maxP[len[0]][j][k] = min(maxP[len[0]][j][k], get(1));
if (k) maxP[len[0]][j][k] = min(maxP[len[0]][j][k], get(2));
}
}
}
if (i == 1) {
for (int j = 0; j <= len[0]; j++) {
idx[0] = j;
for (int k = 0; k <= len[2]; k++) {
idx[2] = k;
maxP[j][len[1]][k] = get(i);
if (j) maxP[j][len[1]][k] = min(maxP[j][len[1]][k], get(0));
if (k) maxP[j][len[1]][k] = min(maxP[j][len[1]][k], get(2));
}
}
}
if (i == 2) {
for (int j = 0; j <= len[0]; j++) {
idx[0] = j;
for (int k = 0; k <= len[1]; k++) {
idx[1] = k;
maxP[j][k][len[2]] = get(i);
if (j) maxP[j][k][len[2]] = min(maxP[j][k][len[2]], get(0));
if (k) maxP[j][k][len[2]] = min(maxP[j][k][len[2]], get(1));
}
}
}
} else
len[i]--;
cout << (maxP[len[0]][len[1]][len[2]] < 100010 ? "YES\n" : "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
char X[100010];
int dp[252][252][252];
int nxt[100010][30];
int main() {
scanf("%d%d%s", &n, &q, X + 1);
for (int i = 0; i < 30; i++) nxt[n + 1][i] = n + 1;
for (int i = n; i; i--) {
for (int j = 0; j < 26; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][X[i] - 'a'] = i;
}
auto get_nxt = [&](int x, char c) {
int cc = c - 'a';
return x == n + 1 ? n + 1 : nxt[x + 1][cc];
};
auto upd = [&](int &x, int y) {
if (x > y) x = y;
};
int la = 0, lb = 0, lc = 0;
string sa, sb, sc;
for (int i = 1; i <= q; i++) {
char ch[2];
scanf("%s", ch);
if (ch[0] == '+') {
int x;
char c;
scanf("%d %c", &x, &c);
--x;
if (x == 0) {
for (int i = 0; i <= lb; i++)
for (int j = 0; j <= lc; j++) {
dp[la + 1][i][j] = get_nxt(dp[la][i][j], c);
if (i)
upd(dp[la + 1][i][j], get_nxt(dp[la + 1][i - 1][j], sb[i - 1]));
if (j)
upd(dp[la + 1][i][j], get_nxt(dp[la + 1][i][j - 1], sc[j - 1]));
}
++la;
sa.push_back(c);
} else if (x == 1) {
for (int i = 0; i <= la; i++)
for (int j = 0; j <= lc; j++) {
dp[i][lb + 1][j] = get_nxt(dp[i][lb][j], c);
if (i)
upd(dp[i][lb + 1][j], get_nxt(dp[i - 1][lb + 1][j], sa[i - 1]));
if (j)
upd(dp[i][lb + 1][j], get_nxt(dp[i][lb + 1][j - 1], sc[j - 1]));
}
++lb;
sb.push_back(c);
} else {
for (int i = 0; i <= la; i++)
for (int j = 0; j <= lb; j++) {
dp[i][j][lc + 1] = get_nxt(dp[i][j][lc], c);
if (i)
upd(dp[i][j][lc + 1], get_nxt(dp[i - 1][j][lc + 1], sa[i - 1]));
if (j)
upd(dp[i][j][lc + 1], get_nxt(dp[i][j - 1][lc + 1], sb[j - 1]));
}
++lc;
sc.push_back(c);
}
} else {
int x;
scanf("%d", &x);
--x;
if (x == 0)
--la, sa.pop_back();
else if (x == 1)
--lb, sb.pop_back();
else
--lc, sc.pop_back();
}
if (dp[la][lb][lc] <= n)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vs = vector<string>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
const int INF = INT_MAX;
int N, Q;
cin >> N >> Q;
string univ;
cin >> univ;
vector<array<int, 26>> jump(N + 1);
for (int& inx : jump.back()) {
inx = INF;
}
for (int i = N - 1; i >= 0; i--) {
jump[i] = jump[i + 1];
jump[i][univ[i] - 'a'] = i + 1;
}
const int MLEN = 251;
vector<vvi> dp(MLEN, vvi(MLEN, vi(MLEN, INF)));
dp[0][0][0] = 0;
vector<vector<char>> relig(3);
array<int, 3> size = {0, 0, 0};
for (int q = 0; q < Q; q++) {
char op, elt;
int which;
cin >> op >> which;
which--;
if (op == '+') {
cin >> elt;
relig[which].push_back(elt);
}
for (int a = (which == 0 ? size[0] : 0); a <= relig[0].size(); a++) {
for (int b = (which == 1 ? size[1] : 0); b <= relig[1].size(); b++) {
for (int c = (which == 2 ? size[2] : 0); c <= relig[2].size(); c++) {
if (op == '-') {
dp[a][b][c] = INF;
} else {
if (dp[a][b][c] >= N) continue;
if (a < relig[0].size()) {
dp[a + 1][b][c] =
min(dp[a + 1][b][c], jump[dp[a][b][c]][relig[0][a] - 'a']);
}
if (b < relig[1].size()) {
dp[a][b + 1][c] =
min(dp[a][b + 1][c], jump[dp[a][b][c]][relig[1][b] - 'a']);
}
if (c < relig[2].size()) {
dp[a][b][c + 1] =
min(dp[a][b][c + 1], jump[dp[a][b][c]][relig[2][c] - 'a']);
}
}
}
}
}
if (op == '+') {
size[which]++;
}
if (op == '-') {
relig[which].pop_back();
size[which]--;
}
if (dp[size[0]][size[1]][size[2]] != INF) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 2139063143;
const int N = 101000, M = 255;
const int P = 1000000007;
const double eps = 1e-7;
template <typename T>
inline void sc(T &x) {
x = 0;
static int p;
p = 1;
static char c;
c = getchar();
while (!isdigit(c)) {
if (c == '-') p = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c - 48);
c = getchar();
}
x *= p;
}
template <typename T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void pr(T x) {
print(x), putchar('\n');
}
template <typename T1, typename T2>
void chkmax(T1 &A, T2 B) {
A = A >= B ? A : B;
}
template <typename T1, typename T2>
void chkmin(T1 &A, T2 B) {
A = A <= B ? A : B;
}
int f[M][M][M], h[N][27], a[4][M];
char s[N];
int main() {
int n, m;
sc(n), sc(m);
scanf("%s", s + 1);
for (int i = 1; i <= 26; i++) h[n][i] = h[n + 1][i] = n + 1;
for (int i = n; i >= 1; i--)
memcpy(h[i - 1], h[i], sizeof(h[i])), h[i - 1][s[i] - 'a' + 1] = i;
int p[4] = {0};
while (m--) {
char op[2];
scanf("%s", op);
int id;
sc(id);
if (op[0] == '+') {
scanf("%s", op);
a[id][++p[id]] = op[0] - 'a' + 1;
int w[4] = {0};
w[id] = p[id];
for (int i = w[1]; i <= p[1]; i++)
for (int j = w[2]; j <= p[2]; j++)
for (int k = w[3]; k <= p[3]; k++) f[i][j][k] = n + 1;
f[0][0][0] = 0;
if (id == 1 && op[0] == 'd') {
++n;
--n;
}
--w[id];
for (int i = w[1]; i <= p[1]; i++)
for (int j = w[2]; j <= p[2]; j++)
for (int k = w[3]; k <= p[3]; k++) {
if (i < p[1]) chkmin(f[i + 1][j][k], h[f[i][j][k]][a[1][i + 1]]);
if (j < p[2]) chkmin(f[i][j + 1][k], h[f[i][j][k]][a[2][j + 1]]);
if (k < p[3]) chkmin(f[i][j][k + 1], h[f[i][j][k]][a[3][k + 1]]);
}
} else
--p[id];
puts(f[p[1]][p[2]][p[3]] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using std::abs;
using std::cerr;
using std::cin;
using std::cout;
using std::function;
using std::lower_bound;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::reverse;
using std::set;
using std::sort;
using std::stoi;
using std::string;
using std::to_string;
using std::vector;
using ll = long long;
using PI = pair<int, int>;
template <class T>
using V = vector<T>;
using VI = V<int>;
int MOD = (int)1e9 + 7;
template <class T>
inline void debug(T &A) {}
template <class T>
inline void debug_dim2(T &A) {}
template <typename... Args>
inline void debug(const char *format, Args const &...args) {}
template <typename... Args>
string format(const std::string &fmt, Args... args) {
size_t len = std::snprintf(nullptr, 0, fmt.c_str(), args...);
std::vector<char> buf(len + 1);
std::snprintf(&buf[0], len + 1, fmt.c_str(), args...);
return std::string(&buf[0], &buf[0] + len);
}
template <class T>
T min(V<T> &A) {
return *std::min_element(A.begin(), A.end());
}
int dp[251][251][251];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, Q;
string W;
cin >> N >> Q >> W;
int INF = (int)1e9;
V<VI> trie(1, VI(26, INF));
VI last(26, 0);
for (int i = 0; i < N; ++i) {
int p = i + 1;
int j = last[W[i] - 'a'];
debug("c:%c j:%d p:%d", W[i], j, p);
for (int k = j; k < p; ++k) {
trie[k][W[i] - 'a'] = p;
}
trie.emplace_back(26, INF);
last[W[i] - 'a'] = p;
}
debug_dim2(trie);
VI ptr(3, 0);
V<VI> d(3, VI(250));
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 0;
auto transit = [&](int p, int c) { return p != INF ? trie[p][c] : INF; };
auto recalcDP = [&](int type) {
for (int i = type == 0 ? ptr[0] : 0; i <= ptr[0]; ++i) {
for (int j = type == 1 ? ptr[1] : 0; j <= ptr[1]; ++j) {
for (int k = type == 2 ? ptr[2] : 0; k <= ptr[2]; ++k) {
int v = INF;
if (i > 0) v = min(v, transit(dp[i - 1][j][k], d[0][i - 1]));
if (j > 0) v = min(v, transit(dp[i][j - 1][k], d[1][j - 1]));
if (k > 0) v = min(v, transit(dp[i][j][k - 1], d[2][k - 1]));
dp[i][j][k] = v;
}
}
}
};
for (int q = 0; q < Q; ++q) {
char tpe;
cin >> tpe;
if (tpe == '+') {
int i;
char c;
cin >> i >> c;
i--;
d[i][ptr[i]++] = c - 'a';
recalcDP(i);
} else {
int i;
cin >> i;
i--;
ptr[i]--;
}
if (dp[ptr[0]][ptr[1]][ptr[2]] != INF) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void JIZZ(string output = "") {
cout << output;
exit(0);
}
const long double PI = 3.14159265358979323846264338327950288;
const long double eps = 1e-10;
const long long mod = 1e9 + 7;
int nxt[100005][26];
int dp[255][255][255];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
string s;
cin >> s;
for (int i = 0; i < 26; ++i) nxt[n][i] = nxt[n + 1][i] = n + 1;
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < 26; ++j) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i] - 'a'] = i + 1;
}
string str[5];
str[1] = str[2] = str[3] = " ";
int len[5] = {0};
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0] = 0;
while (q--) {
char c;
cin >> c;
if (c == '+') {
int i;
cin >> i >> c;
++len[i];
str[i] += c;
auto update = [&](int i, int j, int k) {
if (i) {
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i - 1][j][k]][str[1][i] - 'a']);
}
if (j) {
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j - 1][k]][str[2][j] - 'a']);
}
if (k) {
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j][k - 1]][str[3][k] - 'a']);
}
};
if (i == 1) {
for (int i = 0; i <= len[2]; ++i) {
for (int j = 0; j <= len[3]; ++j) {
dp[len[1]][i][j] = 0x3f3f3f3f;
update(len[1], i, j);
}
}
} else if (i == 2) {
for (int i = 0; i <= len[1]; ++i) {
for (int j = 0; j <= len[3]; ++j) {
dp[i][len[2]][j] = 0x3f3f3f3f;
update(i, len[2], j);
}
}
} else {
for (int i = 0; i <= len[1]; ++i) {
for (int j = 0; j <= len[2]; ++j) {
dp[i][j][len[3]] = 0x3f3f3f3f;
update(i, j, len[3]);
}
}
}
} else {
int i;
cin >> i;
--len[i];
str[i].pop_back();
};
;
if (dp[len[1]][len[2]][len[3]] <= n)
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 100001, mxM = 256, C = 26;
inline void ckmin(int &a, int b) {
if (a > b) a = b;
}
inline void ckmax(int &a, int b) {
if (a < b) a = b;
}
int nxt[mxN][C], pos[C];
char s[mxN], op[1], c[1];
int dp[mxM][mxM][mxM];
int len[3], sub[3][mxM], n, m;
inline void build() {
int i, j;
for (i = 0; i < 26; ++i) nxt[n + 1][i] = pos[i] = n + 1;
for (i = n; ~i; --i) {
for (j = 0; j < 26; ++j) nxt[i][j] = pos[j];
if (i) pos[s[i] - 'a'] = i;
}
}
inline void upd(int a, int b, int c) {
int &t = dp[a][b][c];
t = n + 1;
if (a) ckmin(t, nxt[dp[a - 1][b][c]][sub[0][a]]);
if (b) ckmin(t, nxt[dp[a][b - 1][c]][sub[1][b]]);
if (c) ckmin(t, nxt[dp[a][b][c - 1]][sub[2][c]]);
}
inline void add(int id) {
scanf("%s", c);
int val = c[0] - 'a', a, b, c;
sub[id][++len[id]] = val;
int mn0 = id == 0 ? len[0] : 0;
int mn1 = id == 1 ? len[1] : 0;
int mn2 = id == 2 ? len[2] : 0;
for (a = mn0; a <= len[0]; ++a)
for (b = mn1; b <= len[1]; ++b)
for (c = mn2; c <= len[2]; ++c) upd(a, b, c);
}
inline void del(int id) { --len[id]; }
int main() {
int i, j, id;
scanf("%d%d", &n, &m);
scanf("%s", s + 1);
build();
for (i = 1; i <= m; ++i) {
scanf("%s%d", op, &j);
--j;
if (op[0] == '+')
add(j);
else
del(j);
puts(dp[len[0]][len[1]][len[2]] <= n ? "YES" : "NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void setmin(T& a, T b) {
if (a > b) a = b;
}
int n;
string s;
int nxt[100100][26];
int ans[251][251][251];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int q;
cin >> n >> q;
cin >> s;
const int msz = 250;
char arr[3][msz];
memset(arr, 0, sizeof arr);
for (int i = 0; i <= msz; i++) {
for (int j = 0; j <= msz; j++) {
for (int k = 0; k <= msz; k++) {
ans[i][j][k] = n;
}
}
}
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j < 26; j++) {
nxt[i][j] = n;
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
nxt[i][j] = nxt[i + 1][j];
}
nxt[i][s[i] - 'a'] = i;
}
int sz1 = 0;
int sz2 = 0;
int sz3 = 0;
ans[0][0][0] = -1;
vector<int> sz(3, 0);
while (q--) {
char t;
cin >> t;
int ind;
cin >> ind;
ind--;
if (t == '-') {
sz[ind]--;
} else {
vector<int> l = {0, 0, 0};
sz[ind]++;
l[ind] = sz[ind];
char c;
cin >> c;
c -= 'a';
arr[ind][sz[ind]] = c;
for (int i = l[0]; i <= sz[0]; i++) {
for (int j = l[1]; j <= sz[1]; j++) {
for (int k = l[2]; k <= sz[2]; k++) {
ans[i][j][k] = n;
if (i) setmin(ans[i][j][k], nxt[ans[i - 1][j][k] + 1][arr[0][i]]);
if (j) setmin(ans[i][j][k], nxt[ans[i][j - 1][k] + 1][arr[1][j]]);
if (k) setmin(ans[i][j][k], nxt[ans[i][j][k - 1] + 1][arr[2][k]]);
}
}
}
}
cout << (ans[sz[0]][sz[1]][sz[2]] < n ? "YES\n" : "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 1;
const int MAXN = 1e5;
const int MX = 250;
int n, q, nxt[MAXN + 1][26], d[MX + 1][MX + 1][MX + 1];
char s[MAXN + 1];
int len[3], &il = len[0], &jl = len[1], &kl = len[2];
char rel[3][MX + 1], (&ir)[MX + 1] = rel[0], (&jr)[MX + 1] = rel[1],
(&kr)[MX + 1] = rel[2];
void update(int i, int j, int k) {
if (i || j || k) {
d[i][j][k] = INF;
if (i && d[i - 1][j][k] <= n)
d[i][j][k] = min(d[i][j][k], nxt[d[i - 1][j][k]][ir[i] - 'a']);
if (j && d[i][j - 1][k] <= n)
d[i][j][k] = min(d[i][j][k], nxt[d[i][j - 1][k]][jr[j] - 'a']);
if (k && d[i][j][k - 1] <= n)
d[i][j][k] = min(d[i][j][k], nxt[d[i][j][k - 1]][kr[k] - 'a']);
}
}
int main() {
scanf("%d%d%s", &n, &q, s);
for (int i = 0; i < 26; ++i) nxt[n][i] = INF;
for (int i = n - 1; i >= 0; --i)
for (int j = 0; j < 26; ++j)
nxt[i][j] = (s[i] == 'a' + j ? i + 1 : nxt[i + 1][j]);
while (q--) {
char type, which;
scanf(" %c %c", &type, &which);
if (type == '+') {
scanf(" %c", &rel[which - '1'][++len[which - '1']]);
switch (which) {
case '1':
for (int j = 0; j <= jl; ++j)
for (int k = 0; k <= kl; ++k) update(il, j, k);
break;
case '2':
for (int i = 0; i <= il; ++i)
for (int k = 0; k <= kl; ++k) update(i, jl, k);
break;
case '3':
for (int i = 0; i <= il; ++i)
for (int j = 0; j <= jl; ++j) update(i, j, kl);
break;
}
} else
--len[which - '1'];
puts(d[il][jl][kl] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char C[120000 + 5];
int DP[260][260][260];
int NEXT[120000 + 5][35];
int n1 = 0;
int n2 = 0;
int n3 = 0;
int n;
int letter_to_add;
vector<int> C1;
vector<int> C2;
vector<int> C3;
void CALC1() {
C1.push_back(letter_to_add);
for (int i = 0; i <= n2; i++)
for (int j = 0; j <= n3; j++) {
DP[n1][i][j] = min(n + 1, NEXT[DP[n1 - 1][i][j] + 1][letter_to_add]);
if (i > 0)
DP[n1][i][j] = min(DP[n1][i][j], NEXT[DP[n1][i - 1][j] + 1][C2[i]]);
if (j > 0)
DP[n1][i][j] = min(DP[n1][i][j], NEXT[DP[n1][i][j - 1] + 1][C3[j]]);
}
}
void CALC2() {
C2.push_back(letter_to_add);
for (int i = 0; i <= n1; i++)
for (int j = 0; j <= n3; j++) {
DP[i][n2][j] = min(n + 1, NEXT[DP[i][n2 - 1][j] + 1][letter_to_add]);
if (i > 0)
DP[i][n2][j] = min(DP[i][n2][j], NEXT[DP[i - 1][n2][j] + 1][C1[i]]);
if (j > 0)
DP[i][n2][j] = min(DP[i][n2][j], NEXT[DP[i][n2][j - 1] + 1][C3[j]]);
}
}
void CALC3() {
C3.push_back(letter_to_add);
for (int i = 0; i <= n1; i++)
for (int j = 0; j <= n2; j++) {
DP[i][j][n3] = min(n + 1, NEXT[DP[i][j][n3 - 1] + 1][letter_to_add]);
if (i > 0)
DP[i][j][n3] = min(DP[i][j][n3], NEXT[DP[i - 1][j][n3] + 1][C1[i]]);
if (j > 0)
DP[i][j][n3] = min(DP[i][j][n3], NEXT[DP[i][j - 1][n3] + 1][C2[j]]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> C[i];
for (int i = 1; i <= 251; i++)
for (int j = 1; j <= 251; j++)
for (int k = 1; k <= 251; k++) DP[i][j][k] = n + 1;
for (int k = 0; k <= 26; k++) {
NEXT[n + 1][k] = n + 1;
NEXT[n + 2][k] = n + 1;
NEXT[n + 3][k] = n + 1;
}
for (int i = n; i >= 1; i--) {
for (int k = 0; k <= 26; k++) NEXT[i][k] = NEXT[i + 1][k];
NEXT[i][int(C[i]) - 97] = i;
}
DP[0][0][0] = 0;
char x;
int where;
char lett;
C1.push_back(-1);
C2.push_back(-1);
C3.push_back(-1);
for (int t = 1; t <= q; t++) {
cin >> x;
if (x == '-') {
cin >> where;
if (where == 1) {
n1--;
C1.pop_back();
}
if (where == 2) {
n2--;
C2.pop_back();
}
if (where == 3) {
n3--;
C3.pop_back();
}
if (DP[n1][n2][n3] <= n)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
} else {
cin >> where;
cin >> lett;
letter_to_add = int(lett) - 97;
if (where == 1) {
n1++;
CALC1();
}
if (where == 2) {
n2++;
CALC2();
}
if (where == 3) {
n3++;
CALC3();
}
if (DP[n1][n2][n3] <= n)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[251][251][251];
int nx[123456][27];
inline void update1(int i, int j, int k, string& s) {
if (i)
dp[i][j][k] = min(dp[i][j][k], nx[dp[i - 1][j][k] + 1][s[i - 1] - 'a']);
}
inline void update2(int i, int j, int k, string& s) {
if (j)
dp[i][j][k] = min(dp[i][j][k], nx[dp[i][j - 1][k] + 1][s[j - 1] - 'a']);
}
inline void update3(int i, int j, int k, string& s) {
if (k)
dp[i][j][k] = min(dp[i][j][k], nx[dp[i][j][k - 1] + 1][s[k - 1] - 'a']);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
string s;
cin >> s;
for (int j = 0; j < 26; ++j) nx[s.size()][j] = s.size() + 1;
for (int i = max(size_t(100005), s.size() - 1); i >= 0; --i) {
for (int j = 0; j < 26; ++j) {
if (i >= s.size())
nx[i][j] = s.size() + 1;
else if (s[i] == 'a' + j)
nx[i][j] = i;
else
nx[i][j] = nx[i + 1][j];
}
}
string a1, a2, a3;
a1.reserve(256);
a2.reserve(256);
a3.reserve(256);
dp[0][0][0] = -1;
while (q--) {
int w;
char z, l;
cin >> z >> w;
if (z == '+') cin >> l;
auto a = (w == 1 ? a1.size() + (z == '+' ? 1 : -1) : 0);
auto b = (w == 2 ? a2.size() + (z == '+' ? 1 : -1) : 0);
auto c = (w == 3 ? a3.size() + (z == '+' ? 1 : -1) : 0);
if (z == '+') {
if (a)
a1.push_back(l);
else if (b)
a2.push_back(l);
else
a3.push_back(l);
for (auto i = a; i <= a1.size(); ++i) {
for (auto j = b; j <= a2.size(); ++j) {
for (auto k = c; k <= a3.size(); ++k) {
dp[i][j][k] = n + 1;
update1(i, j, k, a1);
update2(i, j, k, a2);
update3(i, j, k, a3);
}
}
}
} else {
if (w == 1)
a1.pop_back();
else if (w == 2)
a2.pop_back();
else
a3.pop_back();
}
cout << (dp[a1.size()][a2.size()][a3.size()] <= n ? "YES" : "NO") << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, M = 255, S = 26;
int n, q, a, b, c;
char ch[N], sa[M], sb[M], sc[M];
int nxt[N][S];
int f[M][M][M];
int main() {
scanf("%d%d", &n, &q);
scanf("%s", ch + 1);
for (int i = 0; i < S; ++i) {
nxt[n + 1][i] = n + 1;
nxt[n + 2][i] = n + 1;
}
for (int i = n; i; --i) {
for (int j = 0; j < S; ++j) nxt[i][j] = nxt[i + 1][j];
nxt[i][ch[i] - 97] = i;
}
a = b = c = 0;
while (q--) {
char s[2];
scanf("%s", s);
int x;
scanf("%d", &x);
if (s[0] == '+') {
scanf("%s", s);
if (x == 1) {
sa[++a] = s[0];
for (int i = 0; i <= b; ++i)
for (int j = 0; j <= c; ++j) {
f[a][i][j] = n + 1;
if (i)
f[a][i][j] = min(f[a][i][j], nxt[f[a][i - 1][j] + 1][sb[i] - 97]);
if (j)
f[a][i][j] = min(f[a][i][j], nxt[f[a][i][j - 1] + 1][sc[j] - 97]);
f[a][i][j] = min(f[a][i][j], nxt[f[a - 1][i][j] + 1][sa[a] - 97]);
}
} else if (x == 2) {
sb[++b] = s[0];
for (int i = 0; i <= a; ++i)
for (int j = 0; j <= c; ++j) {
f[i][b][j] = n + 1;
if (i)
f[i][b][j] = min(f[i][b][j], nxt[f[i - 1][b][j] + 1][sa[i] - 97]);
if (j)
f[i][b][j] = min(f[i][b][j], nxt[f[i][b][j - 1] + 1][sc[j] - 97]);
f[i][b][j] = min(f[i][b][j], nxt[f[i][b - 1][j] + 1][sb[b] - 97]);
}
} else if (x == 3) {
sc[++c] = s[0];
for (int i = 0; i <= a; ++i)
for (int j = 0; j <= b; ++j) {
f[i][j][c] = n + 1;
if (i)
f[i][j][c] = min(f[i][j][c], nxt[f[i - 1][j][c] + 1][sa[i] - 97]);
if (j)
f[i][j][c] = min(f[i][j][c], nxt[f[i][j - 1][c] + 1][sb[j] - 97]);
f[i][j][c] = min(f[i][j][c], nxt[f[i][j][c - 1] + 1][sc[c] - 97]);
}
}
} else {
if (x == 1)
--a;
else if (x == 2)
--b;
else if (x == 3)
--c;
}
puts(f[a][b][c] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100633;
const long long MOD = 998244353LL;
const int fx[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int p[6][3] = {
{0, 1, 2}, {0, 2, 1}, {1, 0, 2}, {1, 2, 0}, {2, 0, 1}, {2, 1, 0},
};
long long addmod(long long x, long long y) {
x += y;
if (x >= MOD) x -= MOD;
return x;
}
int n, m;
int a[3][N];
char s[N];
int d[N][26];
int f[251][251][251];
void calc(int x, int y, int z) {
if (x < 0) return;
if (y < 0) return;
if (z < 0) return;
if (x == 0 && y == 0 && z == 0) return;
f[x][y][z] = -1;
if (x) {
int u = f[x - 1][y][z];
if (u != -1 && d[u][a[0][x]] != -1) {
if (f[x][y][z] == -1)
f[x][y][z] = d[u][a[0][x]];
else
f[x][y][z] = min(f[x][y][z], d[u][a[0][x]]);
}
}
if (y) {
int u = f[x][y - 1][z];
if (u != -1 && d[u][a[1][y]] != -1) {
if (f[x][y][z] == -1)
f[x][y][z] = d[u][a[1][y]];
else
f[x][y][z] = min(f[x][y][z], d[u][a[1][y]]);
}
}
if (z) {
int u = f[x][y][z - 1];
if (u != -1 && d[u][a[2][z]] != -1) {
if (f[x][y][z] == -1)
f[x][y][z] = d[u][a[2][z]];
else
f[x][y][z] = min(f[x][y][z], d[u][a[2][z]]);
}
}
}
int main() {
int cases = 1;
for (int iii = 1; iii <= cases; ++iii) {
scanf("%d%d", &n, &m);
scanf("%s", s);
memset(d, -1, sizeof(d));
memset(f, -1, sizeof(f));
for (int i = 0; i < n; ++i) {
d[i][s[i] - 'a'] = i + 1;
}
f[0][0][0] = 0;
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < 26; ++j)
if (d[i][j] == -1) d[i][j] = d[i + 1][j];
}
for (int mm = 0; mm < m; ++mm) {
scanf("%s", s);
if (s[0] == '-') {
int x;
scanf("%d", &x);
--a[x - 1][0];
} else {
int xx;
scanf("%d", &xx);
scanf("%s", s);
++a[xx - 1][0];
a[xx - 1][a[xx - 1][0]] = s[0] - 'a';
int x = a[0][0];
int y = a[1][0];
int z = a[2][0];
if (xx == 1) {
for (int i = 0; i <= y; ++i)
for (int j = 0; j <= z; ++j) calc(x, i, j);
}
if (xx == 2) {
for (int i = 0; i <= x; ++i)
for (int j = 0; j <= z; ++j) calc(i, y, j);
}
if (xx == 3) {
for (int i = 0; i <= x; ++i)
for (int j = 0; j <= y; ++j) calc(i, j, z);
}
}
if (f[a[0][0]][a[1][0]][a[2][0]] != -1)
puts("YES");
else
puts("NO");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class U>
inline void smin(U &a, const U &b) {
if (a > b) a = b;
}
const int inf = 0x3f3f3f3f;
const int NN = 1e5 + 10;
char s[NN];
char a[4][255];
int b[4];
int nxt[NN][26];
int pos[256][256][256];
int main() {
int n, id, test;
scanf("%d %d", &n, &test);
scanf("%s", s + 1);
for (int i = 'a'; i <= 'z'; i++) {
int ed = inf;
for (int j = n; j >= 0; j--) {
nxt[j][i - 'a'] = ed;
if (s[j] == i) ed = j;
}
}
char c;
while (test--) {
scanf(" %c %d", &c, &id);
id--;
if (c == '-')
b[id]--;
else {
scanf(" %c", &c);
c -= 'a';
a[id][++b[id]] = c;
if (id == 0) {
for (int i = 0; i <= b[1]; i++)
for (int j = 0; j <= b[2]; j++) pos[b[0]][i][j] = inf;
for (int i = 0; i <= b[1]; i++)
for (int j = 0; j <= b[2]; j++) {
if (pos[b[0] - 1][i][j] <= n)
smin(pos[b[0]][i][j], nxt[pos[b[0] - 1][i][j]][c]);
if (i && pos[b[0]][i - 1][j] <= n)
smin(pos[b[0]][i][j], nxt[pos[b[0]][i - 1][j]][a[1][i]]);
if (j && pos[b[0]][i][j - 1] <= n)
smin(pos[b[0]][i][j], nxt[pos[b[0]][i][j - 1]][a[2][j]]);
}
} else if (id == 1) {
for (int i = 0; i <= b[0]; i++)
for (int j = 0; j <= b[2]; j++) pos[i][b[1]][j] = inf;
for (int i = 0; i <= b[0]; i++)
for (int j = 0; j <= b[2]; j++) {
if (pos[i][b[1] - 1][j] <= n)
smin(pos[i][b[1]][j], nxt[pos[i][b[1] - 1][j]][c]);
if (i && pos[i - 1][b[1]][j] <= n)
smin(pos[i][b[1]][j], nxt[pos[i - 1][b[1]][j]][a[0][i]]);
if (j && pos[i][b[1]][j - 1] <= n)
smin(pos[i][b[1]][j], nxt[pos[i][b[1]][j - 1]][a[2][j]]);
}
} else {
for (int i = 0; i <= b[0]; i++)
for (int j = 0; j <= b[1]; j++) pos[i][j][b[2]] = inf;
for (int i = 0; i <= b[0]; i++)
for (int j = 0; j <= b[1]; j++) {
if (pos[i][j][b[2] - 1] <= n)
smin(pos[i][j][b[2]], nxt[pos[i][j][b[2] - 1]][c]);
if (i && pos[i - 1][j][b[2]] <= n)
smin(pos[i][j][b[2]], nxt[pos[i - 1][j][b[2]]][a[0][i]]);
if (j && pos[i][j - 1][b[2]] <= n)
smin(pos[i][j][b[2]], nxt[pos[i][j - 1][b[2]]][a[1][j]]);
}
}
}
if (pos[b[0]][b[1]][b[2]] <= n)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, ne[100010][28], dp[252][252][252], si[100010], a[252][4], x;
string s;
char ch1, ch2;
int main() {
std::ios::sync_with_stdio(false);
cin >> n >> m;
cin >> s;
for (int i = 0; i < 26; i++) ne[n][i] = ne[n + 1][i] = n + 1;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) ne[i][j] = ne[i + 1][j];
ne[i][s[i] - 'a'] = i + 1;
}
for (int i = 0; i <= 250; i++)
for (int j = 0; j <= 250; j++)
for (int k = 0; k <= 250; k++) dp[i][j][k] = n + 1;
dp[0][0][0] = 0;
while (m--) {
cin >> ch1 >> x;
if (ch1 == '+') {
cin >> ch2;
if (x == 1) {
si[1]++;
a[si[1]][1] = ch2 - 'a';
for (int i = si[1] - 1; i < si[1]; i++)
for (int j = 0; j <= si[2]; j++)
for (int k = 0; k <= si[3]; k++)
dp[i + 1][j][k] =
min(dp[i + 1][j][k], ne[dp[i][j][k]][a[i + 1][1]]);
for (int i = si[1]; i <= si[1]; i++) {
for (int j = 0; j <= si[2]; j++) {
for (int k = 0; k <= si[3]; k++) {
if (j != si[2])
dp[i][j + 1][k] =
min(dp[i][j + 1][k], ne[dp[i][j][k]][a[j + 1][2]]);
if (k != si[3])
dp[i][j][k + 1] =
min(dp[i][j][k + 1], ne[dp[i][j][k]][a[k + 1][3]]);
}
}
}
}
if (x == 2) {
si[2]++;
a[si[2]][2] = ch2 - 'a';
for (int i = 0; i <= si[1]; i++)
for (int j = si[2] - 1; j < si[2]; j++)
for (int k = 0; k <= si[3]; k++)
dp[i][j + 1][k] =
min(dp[i][j + 1][k], ne[dp[i][j][k]][a[j + 1][2]]);
for (int i = 0; i <= si[1]; i++) {
for (int j = si[2]; j <= si[2]; j++) {
for (int k = 0; k <= si[3]; k++) {
if (i != si[1])
dp[i + 1][j][k] =
min(dp[i + 1][j][k], ne[dp[i][j][k]][a[i + 1][1]]);
if (k != si[3])
dp[i][j][k + 1] =
min(dp[i][j][k + 1], ne[dp[i][j][k]][a[k + 1][3]]);
}
}
}
}
if (x == 3) {
si[3]++;
a[si[3]][3] = ch2 - 'a';
for (int i = 0; i <= si[1]; i++)
for (int j = 0; j <= si[2]; j++)
for (int k = si[3] - 1; k < si[3]; k++)
dp[i][j][k + 1] =
min(dp[i][j][k + 1], ne[dp[i][j][k]][a[k + 1][3]]);
for (int i = 0; i <= si[1]; i++) {
for (int j = 0; j <= si[2]; j++) {
for (int k = si[3]; k <= si[3]; k++) {
if (i != si[1])
dp[i + 1][j][k] =
min(dp[i + 1][j][k], ne[dp[i][j][k]][a[i + 1][1]]);
if (j != si[2])
dp[i][j + 1][k] =
min(dp[i][j + 1][k], ne[dp[i][j][k]][a[j + 1][2]]);
}
}
}
}
} else {
int l1 = 0, r1 = si[1], l2 = 0, r2 = si[2], l3 = 0, r3 = si[3];
if (x == 1) {
l1 = si[1];
si[1]--;
}
if (x == 2) {
l2 = si[2];
si[2]--;
}
if (x == 3) {
l3 = si[3];
si[3]--;
}
for (int i = l1; i <= r1; i++)
for (int j = l2; j <= r2; j++)
for (int k = l3; k <= r3; k++) dp[i][j][k] = n + 1;
}
if (dp[si[1]][si[2]][si[3]] == n + 1)
puts("NO");
else
puts("YES");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[300][300][300];
int SIZE[4];
int ctoi(char moji) { return (int)(moji - 'a'); }
string religion[4];
int n, q;
string S;
int NEXT[100005][27];
void initialize() {
int LAST[27];
for (int i = 0; i <= 25; i++) LAST[i] = (1e9);
for (int i = n; i >= 0; i--) {
for (int index = 0; index <= 25; index++) {
NEXT[i][index] = LAST[index];
}
LAST[ctoi(S[i])] = i;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> q >> S;
S = "#" + S;
initialize();
for (int i = 0; i <= 250; i++) {
for (int j = 0; j <= 250; j++) {
for (int k = 0; k <= 250; k++) dp[i][j][k] = (1e9);
}
}
for (int i = 1; i <= 3; i++) religion[i] = "#";
dp[0][0][0] = 0;
while (q--) {
char sign;
cin >> sign;
int index;
cin >> index;
if (sign == '-') {
religion[index].pop_back();
SIZE[index]--;
if (dp[SIZE[1]][SIZE[2]][SIZE[3]] <= n) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
continue;
}
char dust;
cin >> dust;
religion[index].push_back(dust);
int now = ctoi(dust);
SIZE[index]++;
int index_S[4];
for (index_S[1] = 0; index_S[1] <= SIZE[1]; index_S[1]++) {
if (index == 1) index_S[1] = SIZE[1];
for (index_S[2] = 0; index_S[2] <= SIZE[2]; index_S[2]++) {
if (index == 2) index_S[2] = SIZE[2];
for (index_S[3] = 0; index_S[3] <= SIZE[3]; index_S[3]++) {
if (index == 3) index_S[3] = SIZE[3];
dp[index_S[1]][index_S[2]][index_S[3]] = (1e9);
if (index_S[1] > 0 &&
dp[index_S[1] - 1][index_S[2]][index_S[3]] <= n) {
dp[index_S[1]][index_S[2]][index_S[3]] =
min(dp[index_S[1]][index_S[2]][index_S[3]],
NEXT[dp[index_S[1] - 1][index_S[2]][index_S[3]]]
[ctoi(religion[1][index_S[1]])]);
}
if (index_S[2] > 0 &&
dp[index_S[1]][index_S[2] - 1][index_S[3]] <= n) {
dp[index_S[1]][index_S[2]][index_S[3]] =
min(dp[index_S[1]][index_S[2]][index_S[3]],
NEXT[dp[index_S[1]][index_S[2] - 1][index_S[3]]]
[ctoi(religion[2][index_S[2]])]);
}
if (index_S[3] > 0 &&
dp[index_S[1]][index_S[2]][index_S[3] - 1] <= n) {
dp[index_S[1]][index_S[2]][index_S[3]] =
min(dp[index_S[1]][index_S[2]][index_S[3]],
NEXT[dp[index_S[1]][index_S[2]][index_S[3] - 1]]
[ctoi(religion[3][index_S[3]])]);
}
}
}
}
cerr << q << " " << dp[SIZE[1]][SIZE[2]][SIZE[3]] << endl;
if (dp[SIZE[1]][SIZE[2]][SIZE[3]] <= n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long ln, n[3], aa[100069], pr[26][100069], a[3][269], dp[269][269][269];
int main() {
long long t, rr, i, j, ii, k, l, tg[3];
string s;
char ch;
scanf("%lld%lld", &ln, &t);
cin >> s;
for (i = 1; i <= ln; i++) {
aa[i] = s[i - 1] - 'a';
}
for (i = 0; i < 26; i++) {
pr[i][ln + 1] = ln + 1;
for (j = ln; j + 1; j--) {
pr[i][j] = pr[i][j + 1];
if (aa[j + 1] == i) {
pr[i][j] = j + 1;
}
}
}
for (rr = 0; rr < t; rr++) {
scanf(" %c%lld", &ch, &k);
k--;
if (ch == '+') {
scanf(" %c", &ch);
l = ch - 'a';
n[k]++;
a[k][n[k]] = l;
for (i = 0; i <= n[(k + 1) % 3]; i++) {
for (j = 0; j <= n[(k + 2) % 3]; j++) {
tg[0] = n[k];
tg[1] = i;
tg[2] = j;
for (ii = 0; ii < k; ii++) {
swap(tg[0], tg[1]);
swap(tg[0], tg[2]);
}
dp[tg[0]][tg[1]][tg[2]] = 1e18;
for (ii = 0; ii < 3; ii++) {
if (tg[ii]) {
dp[tg[0]][tg[1]][tg[2]] = min(
dp[tg[0]][tg[1]][tg[2]],
pr[a[ii][tg[ii]]]
[dp[tg[0] - !ii][tg[1] - (ii == 1)][tg[2] - (ii == 2)]]);
}
}
}
}
} else if (ch == '-') {
n[k]--;
}
if (dp[n[0]][n[1]][n[2]] <= ln) {
printf("YES\n");
} else {
printf("NO\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[100002];
int n;
int q;
string s;
char ty[3];
string cur[3];
int dp[253][253][253];
int res[100002][26];
int main() {
cin >> n >> q;
scanf("%s", buf);
s = buf;
memset(dp, -1, sizeof(dp));
dp[0][0][0] = 0;
memset(res, -1, sizeof(res));
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
res[i][j] = res[i + 1][j];
}
res[i][buf[i] - 'a'] = i;
}
while (q--) {
scanf("%s", ty);
if (ty[0] == '+') {
int num;
scanf("%d", &num);
scanf("%s", ty);
char cc = ty[0];
num--;
cur[num].push_back(cc);
int a = cur[0].size();
int b = cur[1].size();
int c = cur[2].size();
if (num == 0) {
for (int i = a; i <= a; i++) {
for (int j = 0; j <= b; j++) {
for (int k = 0; k <= c; k++) {
dp[i][j][k] = -1;
}
}
}
for (int i = a - 1; i <= a; i++) {
for (int j = 0; j <= b; j++) {
for (int k = 0; k <= c; k++) {
if (dp[i][j][k] == -1) continue;
if (i < a && res[dp[i][j][k]][cur[0][i] - 'a'] != -1) {
int pos = res[dp[i][j][k]][cur[0][i] - 'a'];
if (pos != -1 && dp[i + 1][j][k] == -1 ||
dp[i + 1][j][k] > pos) {
dp[i + 1][j][k] = pos + 1;
}
}
if (j < b && res[dp[i][j][k]][cur[1][j] - 'a'] != -1) {
int pos = res[dp[i][j][k]][cur[1][j] - 'a'];
if (pos != -1 && dp[i][j + 1][k] == -1 ||
dp[i][j + 1][k] > pos) {
dp[i][j + 1][k] = pos + 1;
}
}
if (k < c && res[dp[i][j][k]][cur[2][k] - 'a'] != -1) {
int pos = res[dp[i][j][k]][cur[2][k] - 'a'];
if (pos != -1 && dp[i][j][k + 1] == -1 ||
dp[i][j][k + 1] > pos) {
dp[i][j][k + 1] = pos + 1;
}
}
}
}
}
}
if (num == 1) {
for (int i = 0; i <= a; i++) {
for (int j = b; j <= b; j++) {
for (int k = 0; k <= c; k++) {
dp[i][j][k] = -1;
}
}
}
for (int i = 0; i <= a; i++) {
for (int j = b - 1; j <= b; j++) {
for (int k = 0; k <= c; k++) {
if (dp[i][j][k] == -1) continue;
if (i < a && res[dp[i][j][k]][cur[0][i] - 'a'] != -1) {
int pos = res[dp[i][j][k]][cur[0][i] - 'a'];
if (pos != -1 && dp[i + 1][j][k] == -1 ||
dp[i + 1][j][k] > pos) {
dp[i + 1][j][k] = pos + 1;
}
}
if (j < b && res[dp[i][j][k]][cur[1][j] - 'a'] != -1) {
int pos = res[dp[i][j][k]][cur[1][j] - 'a'];
if (pos != -1 && dp[i][j + 1][k] == -1 ||
dp[i][j + 1][k] > pos) {
dp[i][j + 1][k] = pos + 1;
}
}
if (k < c && res[dp[i][j][k]][cur[2][k] - 'a'] != -1) {
int pos = res[dp[i][j][k]][cur[2][k] - 'a'];
if (pos != -1 && dp[i][j][k + 1] == -1 ||
dp[i][j][k + 1] > pos) {
dp[i][j][k + 1] = pos + 1;
}
}
}
}
}
}
if (num == 2) {
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= b; j++) {
for (int k = c; k <= c; k++) {
dp[i][j][k] = -1;
}
}
}
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= b; j++) {
for (int k = c - 1; k <= c; k++) {
if (dp[i][j][k] == -1) continue;
if (i < a && res[dp[i][j][k]][cur[0][i] - 'a'] != -1) {
int pos = res[dp[i][j][k]][cur[0][i] - 'a'];
if (pos != -1 && dp[i + 1][j][k] == -1 ||
dp[i + 1][j][k] > pos) {
dp[i + 1][j][k] = pos + 1;
}
}
if (j < b && res[dp[i][j][k]][cur[1][j] - 'a'] != -1) {
int pos = res[dp[i][j][k]][cur[1][j] - 'a'];
if (pos != -1 && dp[i][j + 1][k] == -1 ||
dp[i][j + 1][k] > pos) {
dp[i][j + 1][k] = pos + 1;
}
}
if (k < c && res[dp[i][j][k]][cur[2][k] - 'a'] != -1) {
int pos = res[dp[i][j][k]][cur[2][k] - 'a'];
if (pos != -1 && dp[i][j][k + 1] == -1 ||
dp[i][j][k + 1] > pos) {
dp[i][j][k + 1] = pos + 1;
}
}
}
}
}
}
if (dp[cur[0].size()][cur[1].size()][cur[2].size()] != -1) {
puts("YES");
continue;
} else {
puts("NO");
}
} else {
int num;
scanf("%d", &num);
num--;
cur[num].pop_back();
if (dp[cur[0].size()][cur[1].size()][cur[2].size()] != -1) {
puts("YES");
continue;
} else {
puts("NO");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) { return (!y ? x : gcd(y, x % y)); }
const int maxn = 252;
const int N = 1e5 + 10;
const int inf = 1e9;
const int W = 27;
int dp[maxn][maxn][maxn];
int fir[W][N];
int sz[3];
int n, q;
inline int gg(int last, char w) {
if (last >= n) return inf;
return fir[w - 'a'][last];
}
string st[3];
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> q;
string s;
cin >> s;
memset(fir, 63, sizeof fir);
for (int i = n - 1; i >= 0; i--) {
int x = s[i] - 'a';
for (int j = 0; j < 26; j++) fir[j][i] = fir[j][i + 1];
fir[x][i] = i;
}
memset(dp, 63, sizeof dp);
dp[0][0][0] = -1;
for (int it = 0; it < q; it++) {
char tp;
cin >> tp;
if (tp == '-') {
int x;
cin >> x;
x--;
sz[x]--;
st[x].pop_back();
} else {
int x;
char c;
cin >> x >> c;
int w = c - 'a';
x--;
int m = sz[x] + 1;
if (x == 0) {
for (int i = 0; i <= sz[1]; i++) {
for (int j = 0; j <= sz[2]; j++) {
dp[m][i][j] = inf;
if (m) dp[m][i][j] = min(dp[m][i][j], gg(dp[m - 1][i][j] + 1, c));
if (i)
dp[m][i][j] =
min(dp[m][i][j], gg(dp[m][i - 1][j] + 1, st[1][i - 1]));
if (j)
dp[m][i][j] =
min(dp[m][i][j], gg(dp[m][i][j - 1] + 1, st[2][j - 1]));
}
}
} else if (x == 1) {
for (int i = 0; i <= sz[0]; i++) {
for (int j = 0; j <= sz[2]; j++) {
dp[i][m][j] = inf;
if (m) dp[i][m][j] = min(dp[i][m][j], gg(dp[i][m - 1][j] + 1, c));
if (i)
dp[i][m][j] =
min(dp[i][m][j], gg(dp[i - 1][m][j] + 1, st[0][i - 1]));
if (j)
dp[i][m][j] =
min(dp[i][m][j], gg(dp[i][m][j - 1] + 1, st[2][j - 1]));
}
}
} else {
for (int i = 0; i <= sz[0]; i++) {
for (int j = 0; j <= sz[1]; j++) {
dp[i][j][m] = inf;
if (m) dp[i][j][m] = min(dp[i][j][m], gg(dp[i][j][m - 1] + 1, c));
if (i)
dp[i][j][m] =
min(dp[i][j][m], gg(dp[i - 1][j][m] + 1, st[0][i - 1]));
if (j)
dp[i][j][m] =
min(dp[i][j][m], gg(dp[i][j - 1][m] + 1, st[1][j - 1]));
}
}
}
sz[x] = m;
st[x] += c;
}
if (dp[sz[0]][sz[1]][sz[2]] < n) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int A = 'z' - 'a' + 1;
const int N = 1e5;
const int N2 = 25e1;
int n, q;
string s, t[3];
int a[N + 1][A], dp[N2 + 1][N2 + 1][N2 + 1];
void process() {
cin >> n >> q >> s;
int j[A];
for (int i = 0; i < A; ++i) j[i] = N;
for (int i = n; i >= 0; --i) {
if (i < n) j[s[i] - 'a'] = i;
for (int i2 = 0; i2 < A; ++i2) a[i][i2] = j[i2];
}
dp[0][0][0] = 0;
int i2;
char c, c2;
for (int i = 0; i < q; ++i) {
cin >> c;
if (c == '+') {
cin >> i2 >> c2;
t[--i2].push_back(c2);
int a2[3] = {0, 0, 0};
a2[i2] = t[i2].size();
for (int i3 = a2[0]; i3 <= t[0].size(); ++i3)
for (int i4 = a2[1]; i4 <= t[1].size(); ++i4)
for (int i5 = a2[2]; i5 <= t[2].size(); ++i5) {
int &dp2 = dp[i3][i4][i5];
dp2 = N + 1;
if (i3 > 0 && dp[i3 - 1][i4][i5] <= n)
dp2 = min(dp2, a[dp[i3 - 1][i4][i5]][t[0][i3 - 1] - 'a'] + 1);
if (i4 > 0 && dp[i3][i4 - 1][i5] <= n)
dp2 = min(dp2, a[dp[i3][i4 - 1][i5]][t[1][i4 - 1] - 'a'] + 1);
if (i5 > 0 && dp[i3][i4][i5 - 1] <= n)
dp2 = min(dp2, a[dp[i3][i4][i5 - 1]][t[2][i5 - 1] - 'a'] + 1);
}
} else {
cin >> i2;
t[--i2].pop_back();
}
bool ans;
ans = (dp[t[0].size()][t[1].size()][t[2].size()] <= n);
cout << (ans ? "YES\n" : "NO\n");
}
}
int main() { process(); }
|
#include <bits/stdc++.h>
using namespace std;
int dp[300][300][300];
int nxt[100111][30], nas[30];
char str[100111];
int n, q;
vector<int> v[3];
int fun(int a, int b, int c) {
if (a == 0 && b == 0 && c == 0) return 0;
int &ret = dp[a][b][c];
if (ret != -1) return ret;
ret = (1 << 20);
if (a > 0) {
int pos = fun(a - 1, b, c);
if (pos < n) {
int cur = nxt[pos][v[0][a - 1]] + 1;
ret = min(ret, cur);
}
}
if (b > 0) {
int pos = fun(a, b - 1, c);
if (pos < n) {
int cur = nxt[pos][v[1][b - 1]] + 1;
ret = min(ret, cur);
}
}
if (c > 0) {
int pos = fun(a, b, c - 1);
if (pos < n) {
int cur = nxt[pos][v[2][c - 1]] + 1;
ret = min(ret, cur);
}
}
return ret;
}
int main() {
scanf("%d%d", &n, &q);
scanf("%s", str);
for (int i = 0; i < 30; i++) nas[i] = (1 << 20);
for (int i = n - 1; i >= 0; i--) {
nas[str[i] - 'a'] = i;
for (int j = 0; j < 30; j++) nxt[i][j] = nas[j];
}
memset(dp, -1, sizeof(dp));
dp[0][0][0] = 0;
while (q--) {
char s[2], c[2];
int x;
scanf("%s %d", s, &x);
x--;
if (s[0] == '+') {
scanf("%s", c);
v[x].push_back(c[0] - 'a');
}
if (s[0] == '-') {
int k = v[x].size();
for (int i = 0; i < 300; i++) {
for (int j = 0; j < 300; j++) {
if (x == 0) dp[k][i][j] = -1;
if (x == 1) dp[i][k][j] = -1;
if (x == 2) dp[i][j][k] = -1;
}
}
v[x].pop_back();
}
int ans = fun(v[0].size(), v[1].size(), v[2].size());
if (ans <= n)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
const double pi = acos(-1.0);
int read() {
int x = 0, f = 1;
char ch = getchar();
while ((ch < '0') || (ch > '9')) {
if (ch == '-') f = -1;
ch = getchar();
}
while ((ch >= '0') && (ch <= '9')) {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * f;
}
char str[100100];
int nxt[100100][31], sum[300][300][300], n, q, len[4], head[50];
char s[4][250], op[4], st[100100], add[20];
int main() {
n = read();
q = read();
scanf("%s", st + 1);
for (register int i = 0; i <= 26; i++) head[i] = 1000000007;
for (register int i = n; i >= 0; i--) {
for (register int j = 0; j <= 26; j++) nxt[i][j] = head[j];
if (i) head[st[i] - 'a'] = i;
}
while (q--) {
scanf("%s", op + 1);
int pos = read();
if (op[1] == '+') {
scanf("%s", add + 1);
char ch = add[1];
s[pos][++len[pos]] = add[1];
int l = len[pos];
if (pos == 1) {
for (register int i = 0; i <= len[2]; i++) {
for (register int j = 0; j <= len[3]; j++) {
int &v = sum[len[pos]][i][j];
v = 1000000007;
if (sum[len[pos] - 1][i][j] <= n)
v = nxt[sum[len[pos] - 1][i][j]][ch - 'a'];
if (i != 0) {
int tmppos = sum[len[pos]][i - 1][j];
if (tmppos <= n) v = min(v, nxt[tmppos][s[2][i] - 'a']);
}
if (j != 0) {
int tmppos = sum[len[pos]][i][j - 1];
if (tmppos <= n) v = min(v, nxt[tmppos][s[3][j] - 'a']);
}
}
}
}
if (pos == 2) {
for (register int i = 0; i <= len[1]; i++) {
for (register int j = 0; j <= len[3]; j++) {
int &v = sum[i][l][j];
v = 1000000007;
if (sum[i][l - 1][j] <= n) v = nxt[sum[i][l - 1][j]][ch - 'a'];
if (i) {
int tmppos = sum[i - 1][len[pos]][j];
if (tmppos <= n) v = min(v, nxt[tmppos][s[1][i] - 'a']);
}
if (j) {
int tmppos = sum[i][l][j - 1];
if (tmppos <= n) v = min(v, nxt[tmppos][s[3][j] - 'a']);
}
}
}
}
if (pos == 3) {
for (register int i = 0; i <= len[1]; i++) {
for (register int j = 0; j <= len[2]; j++) {
int &v = sum[i][j][l];
v = 1000000007;
if (sum[i][j][l - 1] <= n) v = nxt[sum[i][j][l - 1]][ch - 'a'];
if (i) {
int tmppos = sum[i - 1][j][l];
if (tmppos <= n) v = min(v, nxt[tmppos][s[1][i] - 'a']);
}
if (j) {
int tmppos = sum[i][j - 1][l];
if (tmppos <= n) v = min(v, nxt[tmppos][s[2][j] - 'a']);
}
}
}
}
} else {
len[pos]--;
}
if (sum[len[1]][len[2]][len[3]] <= n)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const int AlphaSize = 26;
const int MaxN = 1e5 + 100;
const int MaxM = 256;
int next_occur[MaxN][AlphaSize];
int dp[MaxM][MaxM][MaxM];
string pattern;
string words[3];
int N, Q;
void CreateLinks() {
for (int i = 0; i < AlphaSize; ++i) {
next_occur[N][i] = next_occur[N + 1][i] = N;
}
for (int pos = N - 1; pos >= 0; --pos) {
for (int i = 0; i < AlphaSize; ++i) {
next_occur[pos][i] =
(pattern[pos] == 'a' + i ? pos : next_occur[pos + 1][i]);
}
}
}
void RecomputeDp(int a, int b, int c) {
int& val = dp[a][b][c];
val = N;
if (a) {
val = min(val, next_occur[dp[a - 1][b][c] + 1][words[0][a - 1] - 'a']);
}
if (b) {
val = min(val, next_occur[dp[a][b - 1][c] + 1][words[1][b - 1] - 'a']);
}
if (c) {
val = min(val, next_occur[dp[a][b][c - 1] + 1][words[2][c - 1] - 'a']);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> Q >> pattern;
CreateLinks();
dp[0][0][0] = -1;
for (int i = 0; i < Q; ++i) {
char type;
int word_id;
cin >> type >> word_id;
--word_id;
if (type == '+') {
char ch;
cin >> ch;
words[word_id] += ch;
int max0 = words[0].size(), max1 = words[1].size(),
max2 = words[2].size();
int min0 = word_id == 0 ? max0 : 0;
int min1 = word_id == 1 ? max1 : 0;
int min2 = word_id == 2 ? max2 : 0;
for (int a = min0; a <= max0; ++a) {
for (int b = min1; b <= max1; ++b) {
for (int c = min2; c <= max2; ++c) {
RecomputeDp(a, b, c);
}
}
}
} else {
words[word_id].pop_back();
}
bool answer = dp[words[0].size()][words[1].size()][words[2].size()] < N;
cout << (answer ? "YES\n" : "NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Q = 1 << 17;
int nxt[26][Q];
char s[Q];
int f[255][255][255];
char op[3][Q];
int tl[3] = {0};
const int inf = 998244353;
int main() {
f[0][0][0] = 0;
int n, q;
scanf("%d%d", &n, &q);
scanf("%s", s + 1);
for (int i = 0; i < 26; i++) nxt[i][n + 1] = nxt[i][n] = n + 1;
char ty;
int id;
char New;
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < 26; j++) nxt[j][i] = nxt[j][i + 1];
nxt[s[i + 1] - 'a'][i] = i + 1;
}
while (q--) {
cin >> ty >> id;
--id;
if (ty == '-')
--tl[id];
else {
++tl[id];
cin >> op[id][tl[id]];
if (id == 0) {
for (int i = tl[0]; i <= tl[0]; i++)
for (int j = 0; j <= tl[1]; j++)
for (int k = 0; k <= tl[2]; k++) {
f[i][j][k] =
min(k > 0 ? nxt[op[2][k] - 'a'][f[i][j][k - 1]] : inf,
min(j > 0 ? nxt[op[1][j] - 'a'][f[i][j - 1][k]] : inf,
i > 0 ? nxt[op[0][i] - 'a'][f[i - 1][j][k]] : inf));
}
}
if (id == 1) {
for (int i = 0; i <= tl[0]; i++)
for (int j = tl[1]; j <= tl[1]; j++)
for (int k = 0; k <= tl[2]; k++) {
f[i][j][k] =
min(k > 0 ? nxt[op[2][k] - 'a'][f[i][j][k - 1]] : inf,
min(j > 0 ? nxt[op[1][j] - 'a'][f[i][j - 1][k]] : inf,
i > 0 ? nxt[op[0][i] - 'a'][f[i - 1][j][k]] : inf));
}
}
if (id == 2) {
for (int i = 0; i <= tl[0]; i++)
for (int j = 0; j <= tl[1]; j++)
for (int k = tl[2]; k <= tl[2]; k++) {
f[i][j][k] =
min(k > 0 ? nxt[op[2][k] - 'a'][f[i][j][k - 1]] : inf,
min(j > 0 ? nxt[op[1][j] - 'a'][f[i][j - 1][k]] : inf,
i > 0 ? nxt[op[0][i] - 'a'][f[i - 1][j][k]] : inf));
}
}
}
puts(f[tl[0]][tl[1]][tl[2]] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
;
const long long INF64 = 0X3F3F3F3F3F3F3F3F;
const int INF32 = 0x3F3F3F3F;
const int mod = 1e6 + 3;
const int mod2 = 1e9 + 9;
const int N = 1e5 + 4;
int ti = 0;
int n, q;
int dp[255][255][255], id[26][N], len[3];
char reli[3][300];
char s[N];
void upd(int t, char op) {
++len[t];
reli[t][len[t]] = op;
for (int i = t == 0 ? len[0] : 0; i <= len[0]; ++i) {
for (int j = t == 1 ? len[1] : 0; j <= len[1]; ++j) {
for (int k = t == 2 ? len[2] : 0; k <= len[2]; ++k) {
if (i || j || k) dp[i][j][k] = n + 1;
if (i)
dp[i][j][k] = min(dp[i][j][k], id[reli[0][i] - 'a'][dp[i - 1][j][k]]);
if (j)
dp[i][j][k] = min(dp[i][j][k], id[reli[1][j] - 'a'][dp[i][j - 1][k]]);
if (k)
dp[i][j][k] = min(dp[i][j][k], id[reli[2][k] - 'a'][dp[i][j][k - 1]]);
++ti;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
scanf("%d%d", &n, &q);
scanf("%s", s + 1);
for (int i = 0; i < 26; ++i) {
id[i][n + 1] = id[i][n] = n + 1;
}
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < 26; ++j) id[j][i] = id[j][i + 1];
id[s[i + 1] - 'a'][i] = i + 1;
}
int t;
char op[2];
while (q--) {
scanf("%s", op);
scanf("%d", &t);
--t;
if (op[0] == '+') {
scanf("%s", op);
upd(t, op[0]);
} else {
--len[t];
}
if (dp[len[0]][len[1]][len[2]] != n + 1)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int kInf = int(1E9 + 10);
int dp[260][260][260];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, q, a = 0, b = 0, c = 0, k, nxt;
vector<int> v[26];
string s, qs, sa, sb, sc;
cin >> n >> q >> s;
sa.resize(1000);
sb.resize(1000);
sc.resize(1000);
dp[0][0][0] = 0;
for (int i = 0; i < n; i++) v[s[i] - 'a'].push_back(i);
for (int i = 0; i < 26; i++) v[i].push_back(n);
while (q--) {
cin >> qs;
if (qs[0] == '+') {
cin >> k >> qs;
qs[0] -= 'a';
if (k == 1) {
sa[a++] = qs[0];
for (int i = 0; i <= b; i++)
for (int j = 0; j <= c; j++) {
nxt = kInf;
if (dp[a - 1][i][j] < n)
nxt = min(nxt, *lower_bound(v[qs[0]].begin(), v[qs[0]].end(),
dp[a - 1][i][j]));
if (i > 0 && dp[a][i - 1][j] < n)
nxt = min(nxt, *lower_bound(v[sb[i - 1]].begin(),
v[sb[i - 1]].end(), dp[a][i - 1][j]));
if (j > 0 && dp[a][i][j - 1] < n)
nxt = min(nxt, *lower_bound(v[sc[j - 1]].begin(),
v[sc[j - 1]].end(), dp[a][i][j - 1]));
if (nxt < n)
dp[a][i][j] = nxt + 1;
else
dp[a][i][j] = kInf;
}
} else if (k == 2) {
sb[b++] = qs[0];
for (int i = 0; i <= a; i++)
for (int j = 0; j <= c; j++) {
nxt = kInf;
if (dp[i][b - 1][j] < n)
nxt = min(nxt, *lower_bound(v[qs[0]].begin(), v[qs[0]].end(),
dp[i][b - 1][j]));
if (i > 0 && dp[i - 1][b][j] < n)
nxt = min(nxt, *lower_bound(v[sa[i - 1]].begin(),
v[sa[i - 1]].end(), dp[i - 1][b][j]));
if (j > 0 && dp[i][b][j - 1] < n)
nxt = min(nxt, *lower_bound(v[sc[j - 1]].begin(),
v[sc[j - 1]].end(), dp[i][b][j - 1]));
if (nxt < n)
dp[i][b][j] = nxt + 1;
else
dp[i][b][j] = kInf;
}
} else {
sc[c++] = qs[0];
for (int i = 0; i <= a; i++)
for (int j = 0; j <= b; j++) {
nxt = kInf;
if (dp[i][j][c - 1] < n)
nxt = min(nxt, *lower_bound(v[qs[0]].begin(), v[qs[0]].end(),
dp[i][j][c - 1]));
if (i > 0 && dp[i - 1][j][c] < n)
nxt = min(nxt, *lower_bound(v[sa[i - 1]].begin(),
v[sa[i - 1]].end(), dp[i - 1][j][c]));
if (j > 0 && dp[i][j - 1][c] < n)
nxt = min(nxt, *lower_bound(v[sb[j - 1]].begin(),
v[sb[j - 1]].end(), dp[i][j - 1][c]));
if (nxt < n)
dp[i][j][c] = nxt + 1;
else
dp[i][j][c] = kInf;
}
}
} else {
cin >> k;
if (k == 1)
a--;
else if (k == 2)
b--;
else
c--;
}
if (dp[a][b][c] < kInf)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
double get_time() { return 1.0 * clock() / CLOCKS_PER_SEC; }
int main() {
fast();
int n, q;
string s;
cin >> n >> q >> s;
vector<vector<int>> nxt(26, vector<int>(n + 2, n + 1));
for (int i = n - 1; i >= 0; i--) {
nxt[s[i] - 'a'][i] = i;
}
for (int i = 0; i < 26; i++) {
for (int j = n - 1; j >= 0; j--) nxt[i][j] = min(nxt[i][j], nxt[i][j + 1]);
}
vector<vector<vector<int>>> dp(
256, vector<vector<int>>(256, vector<int>(256, n + 1)));
dp[0][0][0] = 0;
vector<int> l(3);
string t[3];
while (q--) {
char ch, c;
int idx;
cin >> ch >> idx;
idx--;
if (ch == '+') {
cin >> c;
l[idx]++;
t[idx] += c;
}
42;
int lim0 = (idx == 0 ? l[0] : 0);
int lim1 = (idx == 1 ? l[1] : 0);
int lim2 = (idx == 2 ? l[2] : 0);
for (int i = lim0; i <= l[0]; i++) {
for (int j = lim1; j <= l[1]; j++) {
for (int k = lim2; k <= l[2]; k++) {
int &val = dp[i][j][k];
val = n + 1;
if (ch == '+') {
if (i > 0)
val = min(val, nxt[t[0][i - 1] - 'a'][dp[i - 1][j][k]] + 1);
if (j > 0)
val = min(val, nxt[t[1][j - 1] - 'a'][dp[i][j - 1][k]] + 1);
if (k > 0)
val = min(val, nxt[t[2][k - 1] - 'a'][dp[i][j][k - 1]] + 1);
}
}
}
}
if (ch == '-') {
l[idx]--;
t[idx] = t[idx].substr(0, (int)t[idx].size() - 1);
}
if (dp[l[0]][l[1]][l[2]] < n + 1)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const long long linf = 4000000000000000000LL;
const long long inf = 1000000007;
const long double pi = 3.1415926535;
void pv(vector<int> a) {
for (auto& x : a) cout << x << " ";
cout << endl;
}
void pv(vector<long long> a) {
for (auto& x : a) cout << x << " ";
cout << endl;
}
void pv(vector<vector<int>> a) {
for (int i = (0); i < (int(a.size())); ++i) {
cout << i << endl;
pv(a[i]);
cout << endl;
}
}
void pv(vector<vector<long long>> a) {
for (int i = (0); i < (int(a.size())); ++i) {
cout << i << endl;
pv(a[i]);
}
cout << endl;
}
void pv(vector<string> a) {
for (auto& x : a) cout << x << endl;
cout << endl;
}
void setIO(string second) {
ios_base::sync_with_stdio(0);
cin.tie(0);
if (int(second.size())) {
freopen((second + ".in").c_str(), "r", stdin);
if (second != "test1") freopen((second + ".out").c_str(), "w", stdout);
}
}
int n, q;
string a;
string x = "", y = "", z = "";
vector<vector<int>> next_;
vector<vector<vector<int>>> dp;
const int MAX = 251;
bool solve() {
dp[0][0][0] = 0;
for (int i = (0); i < (int(x.size()) + 1); ++i) {
for (int j = (0); j < (int(y.size()) + 1); ++j) {
for (int k = (0); k < (int(z.size()) + 1); ++k) {
if (dp[i][j][k] == inf) continue;
int index = dp[i][j][k];
if (index == n) continue;
if (i != int(x.size()) && next_[index][x[i] - 'a'] != n) {
dp[i + 1][j][k] = min(dp[i + 1][j][k], next_[index][x[i] - 'a'] + 1);
}
if (j != int(y.size()) && next_[index][y[j] - 'a'] != n) {
dp[i][j + 1][k] = min(dp[i][j + 1][k], next_[index][y[j] - 'a'] + 1);
}
if (k != int(z.size()) && next_[index][z[k] - 'a'] != n) {
dp[i][j][k + 1] = min(dp[i][j][k + 1], next_[index][z[k] - 'a'] + 1);
}
}
}
}
return dp[int(x.size())][int(y.size())][int(z.size())] <= n;
}
const int SZ = 26;
int main() {
setIO("");
cin >> n >> q >> a;
next_.resize(n, vector<int>(SZ, n));
for (int i = (n)-1; i >= (0); --i) {
if (i != n - 1) {
next_[i] = next_[i + 1];
}
next_[i][a[i] - 'a'] = i;
}
dp.resize(MAX, vector<vector<int>>(MAX, vector<int>(MAX)));
for (int i = (0); i < (q); ++i) {
char t;
cin >> t;
if (t == '+') {
int temp;
char add;
cin >> temp >> add;
if (temp == 1) {
x.push_back(add);
for (int i = (0); i < (int(y.size()) + 1); ++i)
for (int j = (0); j < (int(z.size()) + 1); ++j)
dp[int(x.size())][i][j] = inf;
for (int i = (int(x.size()) - 1); i < (int(x.size()) + 1); ++i) {
for (int j = (0); j < (int(y.size()) + 1); ++j) {
for (int k = (0); k < (int(z.size()) + 1); ++k) {
if (dp[i][j][k] == inf) continue;
int index = dp[i][j][k];
if (index == n) continue;
if (i != int(x.size()) && next_[index][x[i] - 'a'] != n) {
dp[i + 1][j][k] =
min(dp[i + 1][j][k], next_[index][x[i] - 'a'] + 1);
}
if (j != int(y.size()) && next_[index][y[j] - 'a'] != n) {
dp[i][j + 1][k] =
min(dp[i][j + 1][k], next_[index][y[j] - 'a'] + 1);
}
if (k != int(z.size()) && next_[index][z[k] - 'a'] != n) {
dp[i][j][k + 1] =
min(dp[i][j][k + 1], next_[index][z[k] - 'a'] + 1);
}
}
}
}
} else if (temp == 2) {
y.push_back(add);
for (int i = (0); i < (int(x.size()) + 1); ++i)
for (int j = (0); j < (int(z.size()) + 1); ++j)
dp[i][int(y.size())][j] = inf;
for (int i = (0); i < (int(x.size()) + 1); ++i) {
for (int j = (int(y.size()) - 1); j < (int(y.size()) + 1); ++j) {
for (int k = (0); k < (int(z.size()) + 1); ++k) {
if (dp[i][j][k] == inf) continue;
int index = dp[i][j][k];
if (index == n) continue;
if (i != int(x.size()) && next_[index][x[i] - 'a'] != n) {
dp[i + 1][j][k] =
min(dp[i + 1][j][k], next_[index][x[i] - 'a'] + 1);
}
if (j != int(y.size()) && next_[index][y[j] - 'a'] != n) {
dp[i][j + 1][k] =
min(dp[i][j + 1][k], next_[index][y[j] - 'a'] + 1);
}
if (k != int(z.size()) && next_[index][z[k] - 'a'] != n) {
dp[i][j][k + 1] =
min(dp[i][j][k + 1], next_[index][z[k] - 'a'] + 1);
}
}
}
}
} else {
z.push_back(add);
for (int i = (0); i < (int(x.size()) + 1); ++i)
for (int j = (0); j < (int(y.size()) + 1); ++j)
dp[i][j][int(z.size())] = inf;
for (int i = (0); i < (int(x.size()) + 1); ++i) {
for (int j = (0); j < (int(y.size()) + 1); ++j) {
for (int k = (int(z.size()) - 1); k < (int(z.size()) + 1); ++k) {
if (dp[i][j][k] == inf) continue;
int index = dp[i][j][k];
if (index == n) continue;
if (i != int(x.size()) && next_[index][x[i] - 'a'] != n) {
dp[i + 1][j][k] =
min(dp[i + 1][j][k], next_[index][x[i] - 'a'] + 1);
}
if (j != int(y.size()) && next_[index][y[j] - 'a'] != n) {
dp[i][j + 1][k] =
min(dp[i][j + 1][k], next_[index][y[j] - 'a'] + 1);
}
if (k != int(z.size()) && next_[index][z[k] - 'a'] != n) {
dp[i][j][k + 1] =
min(dp[i][j][k + 1], next_[index][z[k] - 'a'] + 1);
}
}
}
}
}
} else {
int temp;
cin >> temp;
if (temp == 1) {
x.pop_back();
} else if (temp == 2) {
y.pop_back();
} else {
z.pop_back();
}
}
cout << (dp[int(x.size())][int(y.size())][int(z.size())] <= n ? "YES"
: "NO")
<< endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class T2>
inline int chkmax(T &x, const T2 &y) {
return x < y ? x = y, 1 : 0;
}
template <class T, class T2>
inline int chkmin(T &x, const T2 &y) {
return x > y ? x = y, 1 : 0;
}
const int MAXN = (1 << 17);
const int MAXM = 256;
int n, q;
string s;
void read() {
cin >> n >> q;
cin >> s;
}
int l1, l2, l3;
int nxt[MAXN][26];
int dp[MAXM][MAXM][MAXM];
int a[MAXM], b[MAXM], d[MAXM];
void solve() {
for (int x = 0; x < 26; x++) nxt[n][x] = n;
for (int i = n - 1; i >= 0; i--) {
for (int x = 0; x < 26; x++) nxt[i][x] = nxt[i + 1][x];
nxt[i][s[i] - 'a'] = i;
}
dp[0][0][0] = -1;
l1 = l2 = l3 = 0;
while (q--) {
char type;
cin >> type;
int id;
cin >> id;
if (type == '-') {
if (id == 1) l1--;
if (id == 2) l2--;
if (id == 3) l3--;
} else {
char c;
cin >> c;
int v = c - 'a';
if (id == 1) {
a[l1++] = v;
for (int i = 0; i <= l2; i++)
for (int j = 0; j <= l3; j++) {
int &memo = dp[l1][i][j];
memo = n;
if (dp[l1 - 1][i][j] != n)
chkmin(memo, nxt[dp[l1 - 1][i][j] + 1][a[l1 - 1]]);
if (i && dp[l1][i - 1][j] != n)
chkmin(memo, nxt[dp[l1][i - 1][j] + 1][b[i - 1]]);
if (j && dp[l1][i][j - 1] != n)
chkmin(memo, nxt[dp[l1][i][j - 1] + 1][d[j - 1]]);
}
}
if (id == 2) {
b[l2++] = v;
for (int i = 0; i <= l1; i++)
for (int j = 0; j <= l3; j++) {
int &memo = dp[i][l2][j];
memo = n;
if (dp[i][l2 - 1][j] != n)
chkmin(memo, nxt[dp[i][l2 - 1][j] + 1][b[l2 - 1]]);
if (i && dp[i - 1][l2][j] != n)
chkmin(memo, nxt[dp[i - 1][l2][j] + 1][a[i - 1]]);
if (j && dp[i][l2][j - 1] != n)
chkmin(memo, nxt[dp[i][l2][j - 1] + 1][d[j - 1]]);
}
}
if (id == 3) {
d[l3++] = v;
for (int i = 0; i <= l1; i++)
for (int j = 0; j <= l2; j++) {
int &memo = dp[i][j][l3];
memo = n;
if (dp[i][j][l3 - 1] != n)
chkmin(memo, nxt[dp[i][j][l3 - 1] + 1][d[l3 - 1]]);
if (i && dp[i - 1][j][l3] != n)
chkmin(memo, nxt[dp[i - 1][j][l3] + 1][a[i - 1]]);
if (j && dp[i][j - 1][l3] != n)
chkmin(memo, nxt[dp[i][j - 1][l3] + 1][b[j - 1]]);
}
}
}
if (dp[l1][l2][l3] == n)
cout << "NO" << '\n';
else
cout << "YES" << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100015];
long long g[100015][33], f[255][255][255], len[10];
char a[10][300];
long long n, q;
void qmin(long long &x, long long y) {
if (y < x) x = y;
}
signed main() {
cin >> n >> q;
scanf("%s", s + 1);
for (long long i = 0; i < 26; i++) {
g[n + 1][i] = 0x3f3f3f3f;
for (long long j = n; j >= 0; j--) {
g[j][i] = g[j + 1][i];
if (s[j] == 'a' + i) g[j][i] = j + 1;
}
}
while (q--) {
string op;
cin >> op;
if (op == "+") {
long long x;
cin >> x;
string chch;
cin >> chch;
char ch = chch[0];
len[x]++;
a[x][len[x]] = ch;
if (x == 1) {
long long i = len[1] - 1;
for (long long j = 0; j <= len[2]; j++)
for (long long u = 0; u <= len[3]; u++) f[i + 1][j][u] = 0x3f3f3f3f;
for (i = len[1] - 1; i <= len[1]; i++)
for (long long u = 0; u <= len[3]; u++)
for (long long j = 0; j <= len[2]; j++) {
long long ff = f[i][j][u];
if (ff == 0x3f3f3f3f) continue;
if (i != len[1]) qmin(f[i + 1][j][u], g[ff][a[1][i + 1] - 'a']);
if (j != len[2]) qmin(f[i][j + 1][u], g[ff][a[2][j + 1] - 'a']);
if (u != len[3]) qmin(f[i][j][u + 1], g[ff][a[3][u + 1] - 'a']);
}
}
if (x == 2) {
long long j = len[2] - 1;
for (long long i = 0; i <= len[1]; i++)
for (long long u = 0; u <= len[3]; u++) f[i][j + 1][u] = 0x3f3f3f3f;
for (long long i = 0; i <= len[1]; i++)
for (j = len[2] - 1; j <= len[2]; j++)
for (long long u = 0; u <= len[3]; u++) {
long long ff = f[i][j][u];
if (ff == 0x3f3f3f3f) continue;
if (i != len[1]) qmin(f[i + 1][j][u], g[ff][a[1][i + 1] - 'a']);
if (j != len[2]) qmin(f[i][j + 1][u], g[ff][a[2][j + 1] - 'a']);
if (u != len[3]) qmin(f[i][j][u + 1], g[ff][a[3][u + 1] - 'a']);
}
}
if (x == 3) {
long long u = len[3] - 1;
for (long long i = 0; i <= len[1]; i++)
for (long long j = 0; j <= len[2]; j++) f[i][j][u + 1] = 0x3f3f3f3f;
for (long long i = 0; i <= len[1]; i++)
for (long long j = 0; j <= len[2]; j++)
for (u = len[3] - 1; u <= len[3]; u++) {
long long QAQ = f[i][j][u];
if (QAQ == 0x3f3f3f3f) continue;
if (i != len[1]) qmin(f[i + 1][j][u], g[QAQ][a[1][i + 1] - 'a']);
if (j != len[2]) qmin(f[i][j + 1][u], g[QAQ][a[2][j + 1] - 'a']);
if (u != len[3]) qmin(f[i][j][u + 1], g[QAQ][a[3][u + 1] - 'a']);
}
}
if (x == 4) {
long long u = len[3] - 1;
for (long long i = 0; i <= len[1]; i++)
for (long long j = 0; j <= len[2]; j++) f[i][j][u + 1] = 0x3f3f3f3f;
for (long long i = 0; i <= len[1]; i++)
for (long long j = 0; j <= len[2]; j++)
;
long long orzsooke = 2333;
}
} else {
long long x;
cin >> x;
len[x]--;
}
if (f[len[1]][len[2]][len[3]] != 0x3f3f3f3f)
printf("YES\n");
else
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class C>
void mini(C &a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C &a4, C b4) {
a4 = max(a4, b4);
}
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const long long MAX = 260;
const long long MAXn = 100100;
const long long ALFA = 'z' - 'a' + 1;
long long n, q;
long long dp[MAX][MAX][MAX];
long long gd[MAXn][ALFA];
vector<long long> s[3];
long long dl[3];
void licz(long long a, long long b, long long c) {
long long &res = dp[a][b][c];
res = n + 1;
if (a != 0) {
mini(res, gd[dp[a - 1][b][c]][s[0][a - 1]] + 1);
}
if (b != 0) {
mini(res, gd[dp[a][b - 1][c]][s[1][b - 1]] + 1);
}
if (c != 0) {
mini(res, gd[dp[a][b][c - 1]][s[2][c - 1]] + 1);
}
};
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
if (0) cout << fixed << setprecision(6);
{
string z;
cin >> n >> q >> z;
for (long long i = (0); i <= ((long long)(ALFA)-1); i++)
gd[n + 1][i] = gd[n][i] = n + 1;
for (long long i = n - 1; i >= 0; i--) {
for (long long j = (0); j <= ((long long)(ALFA)-1); j++) {
gd[i][j] = gd[i + 1][j];
}
gd[i][(long long)z[i] - 'a'] = i;
}
for (long long i = (0); i <= ((long long)(n)-1); i++) {
for (long long j = (0); j <= ((long long)(ALFA)-1); j++)
if (0) cout << gd[i][j] << " ";
if (0) cout << "\n";
}
}
dp[0][0][0] = 0;
for (long long _ = (0); _ <= ((long long)(q)-1); _++) {
char z;
long long kt;
cin >> z >> kt;
kt--;
if (z == '+') {
dl[kt]++;
char x;
cin >> x;
s[kt].push_back(x - 'a');
if (kt == 0) {
for (long long i = (0); i <= ((long long)(dl[1] + 1) - 1); i++)
for (long long j = (0); j <= ((long long)(dl[2] + 1) - 1); j++) {
licz(dl[0], i, j);
}
} else if (kt == 1) {
for (long long i = (0); i <= ((long long)(dl[0] + 1) - 1); i++)
for (long long j = (0); j <= ((long long)(dl[2] + 1) - 1); j++) {
licz(i, dl[1], j);
}
} else {
for (long long i = (0); i <= ((long long)(dl[0] + 1) - 1); i++)
for (long long j = (0); j <= ((long long)(dl[1] + 1) - 1); j++) {
licz(i, j, dl[2]);
}
}
} else {
s[kt].pop_back();
dl[kt]--;
}
(dp[dl[0]][dl[1]][dl[2]]);
if (dp[dl[0]][dl[1]][dl[2]] <= n) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
|
#include <bits/stdc++.h>
const int N = 100005;
using namespace std;
char s[N];
int nxt[N][26];
char w[3][255];
int len[3], f[255][255][255];
int main() {
int n, q, i, j, k;
scanf("%d%d", &n, &q);
scanf("%s", s);
for (i = 0; i < 26; i++) nxt[n][i] = nxt[n + 1][i] = n;
for (i = n - 1; i >= 0; i--) {
for (j = 0; j < 26; j++)
if (s[i] - 'a' == j)
nxt[i][j] = i;
else
nxt[i][j] = nxt[i + 1][j];
}
char op, ch;
int r;
f[0][0][0] = -1;
while (q--) {
scanf("%*c%c%d", &op, &r);
if (op == '+') {
scanf("%*c%c", &ch);
r--;
w[r][len[r]++] = ch;
int p, q;
if (r == 0) {
p = 1;
q = 2;
} else if (r == 1) {
p = 0;
q = 2;
} else {
p = 0;
q = 1;
}
for (i = 0; i <= len[p]; i++)
for (j = 0; j <= len[q]; j++) {
if (r == 0) {
f[len[r]][i][j] = nxt[f[len[r] - 1][i][j] + 1][ch - 'a'];
if (i > 0)
f[len[r]][i][j] =
min(f[len[r]][i][j],
nxt[f[len[r]][i - 1][j] + 1][w[1][i - 1] - 'a']);
if (j > 0)
f[len[r]][i][j] =
min(f[len[r]][i][j],
nxt[f[len[r]][i][j - 1] + 1][w[2][j - 1] - 'a']);
} else if (r == 1) {
f[i][len[r]][j] = nxt[f[i][len[r] - 1][j] + 1][ch - 'a'];
if (i > 0)
f[i][len[r]][j] =
min(f[i][len[r]][j],
nxt[f[i - 1][len[r]][j] + 1][w[0][i - 1] - 'a']);
if (j > 0)
f[i][len[r]][j] =
min(f[i][len[r]][j],
nxt[f[i][len[r]][j - 1] + 1][w[2][j - 1] - 'a']);
} else {
f[i][j][len[r]] = nxt[f[i][j][len[r] - 1] + 1][ch - 'a'];
if (i > 0)
f[i][j][len[r]] =
min(f[i][j][len[r]],
nxt[f[i - 1][j][len[r]] + 1][w[0][i - 1] - 'a']);
if (j > 0)
f[i][j][len[r]] =
min(f[i][j][len[r]],
nxt[f[i][j - 1][len[r]] + 1][w[1][j - 1] - 'a']);
}
}
} else {
r--;
len[r]--;
}
if (f[len[0]][len[1]][len[2]] < n)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
const int MAXN = 255;
const int MAXM = 100100;
const int ALPH = 26;
int dp[MAXN][MAXN][MAXN];
vector<int> rg;
int to[MAXM][ALPH];
string t[3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
string s;
cin >> s;
rg.resize(3);
vector<int> prv(ALPH, n);
for (int i = n; i >= 0; --i) {
if (i < n) {
prv[s[i] - 'a'] = i;
}
for (int j = 0; j < 26; ++j) {
to[i][j] = prv[j];
}
}
for (int qw = 0; qw < q; ++qw) {
char c;
int pos;
cin >> c >> pos;
--pos;
if (c == '-') {
--rg[pos];
t[pos].pop_back();
} else {
char ch;
cin >> ch;
t[pos] += ch;
vector<int> lf(3);
++rg[pos];
lf[pos] = rg[pos];
for (int i = lf[0]; i <= rg[0]; ++i) {
for (int j = lf[1]; j <= rg[1]; ++j) {
for (int k = lf[2]; k <= rg[2]; ++k) {
dp[i][j][k] = n + 1;
if (i > 0) {
int p = dp[i - 1][j][k];
if (p < n) {
int c = t[0][i - 1] - 'a';
dp[i][j][k] = min(to[p][c] + 1, dp[i][j][k]);
}
}
if (j > 0) {
int p = dp[i][j - 1][k];
if (p < n) {
int c = t[1][j - 1] - 'a';
dp[i][j][k] = min(to[p][c] + 1, dp[i][j][k]);
}
}
if (k > 0) {
int p = dp[i][j][k - 1];
if (p < n) {
int c = t[2][k - 1] - 'a';
dp[i][j][k] = min(to[p][c] + 1, dp[i][j][k]);
}
}
}
}
}
}
if (dp[rg[0]][rg[1]][rg[2]] <= n) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long INF = mod * mod;
const double eps = 1e-8;
const double pi = acos(-1.0);
string s;
int n;
int nex[100002][26];
string a[3];
int lensum;
int dp[251][251][251];
vector<int> loc[26];
void solve() {
int q;
cin >> n >> q;
cin >> s;
for (int i = 0; i < n; i++) {
loc[s[i] - 'a'].push_back(i);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 26; j++) {
int id = lower_bound(loc[j].begin(), loc[j].end(), i) - loc[j].begin();
if (id == loc[j].size())
nex[i][j] = n + 1;
else
nex[i][j] = loc[j][id];
}
}
for (int j = 0; j < 26; j++) nex[n][j] = nex[n + 1][j] = n + 1;
for (int i = 0; i < 251; i++) {
for (int j = 0; j < 251; j++) {
for (int k = 0; k < 251; k++) dp[i][j][k] = n + 1;
}
}
dp[0][0][0] = 0;
bool yes = true;
for (int aa = 0; aa < q; aa++) {
char t;
cin >> t;
if (t == '+') {
int id;
char al;
cin >> id >> al;
id--;
int len = a[id].length();
a[id].push_back(al);
if (id == 2) {
int l1 = a[0].length(), l2 = a[1].length();
for (int i = 0; i < l1 + 1; i++) {
for (int j = 0; j < l2 + 1; j++) {
dp[i][j][len + 1] =
min(dp[i][j][len + 1], nex[dp[i][j][len]][al - 'a'] + 1);
}
}
for (int i = 0; i < l1 + 1; i++) {
for (int j = 0; j < l2 + 1; j++) {
if (i < l1) {
dp[i + 1][j][len + 1] =
min(dp[i + 1][j][len + 1],
nex[dp[i][j][len + 1]][a[0][i] - 'a'] + 1);
}
if (j < l2) {
dp[i][j + 1][len + 1] =
min(dp[i][j + 1][len + 1],
nex[dp[i][j][len + 1]][a[1][j] - 'a'] + 1);
}
}
}
yes = (dp[l1][l2][len + 1] <= n);
} else if (id == 1) {
int l1 = a[0].length(), l2 = a[2].length();
for (int i = 0; i < l1 + 1; i++) {
for (int j = 0; j < l2 + 1; j++) {
dp[i][len + 1][j] =
min(dp[i][len + 1][j], nex[dp[i][len][j]][al - 'a'] + 1);
}
}
for (int i = 0; i < l1 + 1; i++) {
for (int j = 0; j < l2 + 1; j++) {
if (i < l1) {
dp[i + 1][len + 1][j] =
min(dp[i + 1][len + 1][j],
nex[dp[i][len + 1][j]][a[0][i] - 'a'] + 1);
}
if (j < l2) {
dp[i][len + 1][j + 1] =
min(dp[i][len + 1][j + 1],
nex[dp[i][len + 1][j]][a[2][j] - 'a'] + 1);
}
}
}
yes = (dp[l1][len + 1][l2] <= n);
} else {
int l1 = a[1].length(), l2 = a[2].length();
for (int i = 0; i < l1 + 1; i++) {
for (int j = 0; j < l2 + 1; j++) {
dp[len + 1][i][j] =
min(dp[len + 1][i][j], nex[dp[len][i][j]][al - 'a'] + 1);
}
}
for (int i = 0; i < l1 + 1; i++) {
for (int j = 0; j < l2 + 1; j++) {
if (i < l1) {
dp[len + 1][i + 1][j] =
min(dp[len + 1][i + 1][j],
nex[dp[len + 1][i][j]][a[1][i] - 'a'] + 1);
}
if (j < l2) {
dp[len + 1][i][j + 1] =
min(dp[len + 1][i][j + 1],
nex[dp[len + 1][i][j]][a[2][j] - 'a'] + 1);
}
}
}
yes = (dp[len + 1][l1][l2] <= n);
}
} else {
lensum--;
int id;
cin >> id;
id--;
a[id].pop_back();
int len = a[id].size();
len++;
if (id == 0) {
int l1 = a[1].length(), l2 = a[2].length();
for (int i = 0; i < l1 + 1; i++) {
for (int j = 0; j < l2 + 1; j++) {
dp[len][i][j] = n + 1;
}
}
}
if (id == 1) {
int l1 = a[0].length(), l2 = a[2].length();
for (int i = 0; i < l1 + 1; i++) {
for (int j = 0; j < l2 + 1; j++) {
dp[i][len][j] = n + 1;
}
}
}
if (id == 2) {
int l1 = a[0].length(), l2 = a[1].length();
for (int i = 0; i < l1 + 1; i++) {
for (int j = 0; j < l2 + 1; j++) {
dp[i][j][len] = n + 1;
}
}
}
yes = (dp[a[0].length()][a[1].length()][a[2].length()] <= n);
}
if (yes) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
using namespace std;
const int MAXN = 1e5 + 5;
char str[MAXN];
int mark[MAXN];
int nxt[MAXN][26];
int pre[26];
int mp[256];
int dp[255][255][255];
int n, q;
int tot = 1;
int main() {
memset(dp, INF, sizeof(dp));
for (int i = 'a'; i <= 'z'; i++) {
mp[i] = i - 'a';
}
scanf("%d%d", &n, &q);
scanf("%s", str + 1);
for (int i = 1; i <= n; i++) {
int id = mp[str[i]];
for (int j = pre[id]; j < i; j++) {
nxt[j][id] = i;
}
pre[id] = i;
}
dp[0][0][0] = 0;
int pos[3] = {};
vector<char> strs[3];
while (q--) {
char op[2], ch[2];
int num;
scanf("%s%d", op, &num);
num--;
if (op[0] == '+') {
scanf("%s", ch);
strs[num].push_back(ch[0]);
for (int i = 0; i <= strs[0].size() + strs[1].size() + strs[2].size() -
strs[num].size();
i++) {
for (int j = 0; j <= i; j++) {
int indexs[3] = {};
indexs[num] = strs[num].size();
if (num == 2) {
indexs[0] = j;
indexs[1] = i - j;
} else if (num == 1) {
indexs[0] = j;
indexs[2] = i - j;
} else {
indexs[2] = i - j;
indexs[1] = j;
}
bool out = false;
for (int k = 0; k < 3; k++) {
if (indexs[k] > strs[k].size()) {
out = true;
break;
}
}
if (out) {
continue;
}
dp[indexs[0]][indexs[1]][indexs[2]] = INF;
for (int k = 0; k < 3; k++) {
int loc;
if (indexs[k] == 0) {
continue;
}
if (k == 0) {
loc = dp[indexs[0] - 1][indexs[1]][indexs[2]];
} else if (k == 1) {
loc = dp[indexs[0]][indexs[1] - 1][indexs[2]];
} else {
loc = dp[indexs[0]][indexs[1]][indexs[2] - 1];
}
if (loc == INF) {
continue;
}
if (nxt[loc][mp[strs[k][indexs[k] - 1]]] == 0) {
continue;
}
dp[indexs[0]][indexs[1]][indexs[2]] =
min(dp[indexs[0]][indexs[1]][indexs[2]],
nxt[loc][mp[strs[k][indexs[k] - 1]]]);
}
}
}
} else {
strs[num].pop_back();
}
if (dp[strs[0].size()][strs[1].size()][strs[2].size()] != INF) {
puts("YES");
} else {
puts("NO");
}
}
return 0;
}
|
#include <bits/stdc++.h>
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
using namespace ::std;
const int maxn = 260;
const int maxm = 2e5 + 500;
int dp[maxn][maxn][maxn];
string a[3];
string s;
int findNxt[maxm][26];
int lastT[26];
int n;
inline void update(int i, int j, int k) {
if (i == 0 && j == 0 && k == 0) {
dp[i][j][k] = 0;
}
dp[i][j][k] = n + 1;
if (i != 0) {
dp[i][j][k] = min(dp[i][j][k], findNxt[dp[i - 1][j][k]][a[0][i - 1]] + 1);
}
if (j != 0) {
dp[i][j][k] = min(dp[i][j][k], findNxt[dp[i][j - 1][k]][a[1][j - 1]] + 1);
}
if (k != 0) {
dp[i][j][k] = min(dp[i][j][k], findNxt[dp[i][j][k - 1]][a[2][k - 1]] + 1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> n >> q >> s;
for (int i = 0; i < n; i++) {
s[i] -= 'a';
}
fill(lastT, lastT + 26, n);
for (int j = 0; j < 26; j++) {
findNxt[n][j] = n + 1;
}
for (int j = 0; j < 26; j++) {
findNxt[n + 1][j] = n + 1;
}
for (int i = n - 1; i >= 0; i--) {
lastT[s[i]] = i;
for (int j = 0; j < 26; j++) {
findNxt[i][j] = lastT[j];
}
}
while (q--) {
char c, d;
cin >> c;
if (c == '+') {
int v;
cin >> v >> d;
d -= 'a';
v--;
a[v].push_back(d);
if (v == 0) {
int i = a[0].size();
for (int j = 0; j <= a[1].size(); j++) {
for (int k = 0; k <= a[2].size(); k++) {
update(i, j, k);
}
}
}
if (v == 1) {
int j = a[1].size();
for (int i = 0; i <= a[0].size(); i++) {
for (int k = 0; k <= a[2].size(); k++) {
update(i, j, k);
}
}
}
if (v == 2) {
int k = a[2].size();
for (int i = 0; i <= a[0].size(); i++) {
for (int j = 0; j <= a[1].size(); j++) {
update(i, j, k);
}
}
}
} else {
int v;
cin >> v;
v--;
a[v].pop_back();
}
int res = dp[a[0].size()][a[1].size()][a[2].size()];
if (res > n) {
cout << "NO\n";
} else {
cout << "YES\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
const int M = 251;
const int INF = 1e9;
int a[N], dp[M][M][M], c[5], b[5][M];
char str[N];
set<int> s[26];
int find(int k, int x) {
auto it = s[x].upper_bound(k);
return it == s[x].end() ? N : *it;
}
void update(int i, int j, int k) {
if (i != 0) dp[i][j][k] = min(dp[i][j][k], find(dp[i - 1][j][k], b[1][i]));
if (j != 0) dp[i][j][k] = min(dp[i][j][k], find(dp[i][j - 1][k], b[2][j]));
if (k != 0) dp[i][j][k] = min(dp[i][j][k], find(dp[i][j][k - 1], b[3][k]));
}
int main() {
int n, q;
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0] = 0;
for (int i = 0; i < 26; i++) s[i].insert(N);
scanf("%d %d %s", &n, &q, str + 1);
for (int i = 1; i <= n; i++) {
a[i] = str[i] - 'a';
s[a[i]].insert(i);
}
while (q--) {
int k;
char ch = getchar();
while (ch != '+' && ch != '-') ch = getchar();
scanf("%d", &k);
if (ch == '+') {
char ch = getchar();
while (ch < 'a' || ch > 'z') ch = getchar();
b[k][++c[k]] = ch - 'a';
if (k == 1)
for (int i = 0; i <= c[2]; i++)
for (int j = 0; j <= c[3]; j++) update(c[k], i, j);
else if (k == 2)
for (int i = 0; i <= c[1]; i++)
for (int j = 0; j <= c[3]; j++) update(i, c[k], j);
else if (k == 3)
for (int i = 0; i <= c[1]; i++)
for (int j = 0; j <= c[2]; j++) update(i, j, c[k]);
puts(dp[c[1]][c[2]][c[3]] <= n ? "YES" : "NO");
} else {
if (k == 1)
for (int i = 0; i <= c[2]; i++)
for (int j = 0; j <= c[3]; j++) dp[c[k]][i][j] = INF;
else if (k == 2)
for (int i = 0; i <= c[1]; i++)
for (int j = 0; j <= c[3]; j++) dp[i][c[k]][j] = INF;
else if (k == 3)
for (int i = 0; i <= c[1]; i++)
for (int j = 0; j <= c[2]; j++) dp[i][j][c[k]] = INF;
c[k]--;
puts(dp[c[1]][c[2]][c[3]] <= n ? "YES" : "NO");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int maxn = 1e5 + 5, maxq = 1005, maxl = 255;
ll n, q;
string s;
ll nxt[maxn][26];
string des[5];
ll d[maxl][maxl][maxl];
ll &inf = d[maxl - 1][maxl - 1][maxl - 1];
inline int ctoi(char c) { return c - 'a'; }
void yes() { cout << "YES\n"; }
void no() { cout << "NO\n"; }
int main(int argc, const char *argv[]) {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cin >> n >> q;
char *buf = new char[n + 5];
cin >> &buf[1];
s = buf + 1;
d[0][0][0] = -1;
for (int j = 'a'; j <= 'z'; ++j) {
auto last = n;
nxt[n][ctoi(j)] = nxt[n + 1][ctoi(j)] = n;
for (int i = n - 1; i >= 0; --i) {
if (s[i] == j) {
last = i;
}
nxt[i][ctoi(j)] = last;
}
}
while (q--) {
char op;
int i;
cin >> op >> i;
if (op == '-') {
des[i].pop_back();
} else {
char c;
cin >> c;
des[i] += c;
int start[5] = {1, 0, 0, 0};
start[i] = des[i].size();
for (int i = start[1], i2 = des[1].size(), j2 = des[2].size(),
k2 = des[3].size();
i <= i2; ++i) {
for (int j = start[2]; j <= j2; ++j) {
for (int k = start[3]; k <= k2; ++k) {
auto &val = d[i][j][k] = n;
if (i) {
val = min(val, nxt[d[i - 1][j][k] + 1][ctoi(des[1][i - 1])]);
}
if (j) {
val = min(val, nxt[d[i][j - 1][k] + 1][ctoi(des[2][j - 1])]);
}
if (k) {
val = min(val, nxt[d[i][j][k - 1] + 1][ctoi(des[3][k - 1])]);
}
}
}
}
}
cout << (d[des[1].size()][des[2].size()][des[3].size()] < n ? "YES\n"
: "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template <class T = int>
using V = vector<T>;
template <class T = int>
using VV = V<V<T> >;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, q;
cin >> n >> q;
string s;
cin >> s;
VV<> nxt(n, V<>(26, n));
for (int i = n - 1; i >= 0; --i) {
if (i + 1 < n) nxt[i] = nxt[i + 1];
nxt[i][s[i] - 'a'] = i;
}
auto fn = [&](int l, char ch) -> int {
if (l >= n) return n + 1;
return nxt[l][ch - 'a'] + 1;
};
static int dp[251][251][251];
string x, y, z;
while (q--) {
char op;
cin >> op;
if (op == '+') {
int i;
cin >> i, --i;
char ch;
cin >> ch;
if (i == 0) {
x += ch;
int m = x.size();
for (int b = 0; b <= (int)y.size(); ++b)
for (int c = 0; c <= (int)z.size(); ++c) {
dp[m][b][c] = fn(dp[m - 1][b][c], ch);
if (b)
dp[m][b][c] = min(dp[m][b][c], fn(dp[m][b - 1][c], y[b - 1]));
if (c)
dp[m][b][c] = min(dp[m][b][c], fn(dp[m][b][c - 1], z[c - 1]));
}
}
if (i == 1) {
y += ch;
int m = y.size();
for (int a = 0; a <= (int)x.size(); ++a)
for (int c = 0; c <= (int)z.size(); ++c) {
dp[a][m][c] = fn(dp[a][m - 1][c], ch);
if (a)
dp[a][m][c] = min(dp[a][m][c], fn(dp[a - 1][m][c], x[a - 1]));
if (c)
dp[a][m][c] = min(dp[a][m][c], fn(dp[a][m][c - 1], z[c - 1]));
}
}
if (i == 2) {
z += ch;
int m = z.size();
for (int a = 0; a <= (int)x.size(); ++a)
for (int b = 0; b <= (int)y.size(); ++b) {
dp[a][b][m] = fn(dp[a][b][m - 1], ch);
if (a)
dp[a][b][m] = min(dp[a][b][m], fn(dp[a - 1][b][m], x[a - 1]));
if (b)
dp[a][b][m] = min(dp[a][b][m], fn(dp[a][b - 1][m], y[b - 1]));
}
}
} else {
int i;
cin >> i, --i;
if (i == 0) x.pop_back();
if (i == 1) y.pop_back();
if (i == 2) z.pop_back();
}
cout << (dp[x.size()][y.size()][z.size()] <= n ? "YES" : "NO") << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300, maxs = 1e5 + 10;
char readchar() {
char ch;
while ((ch = getchar()) != '+' && ch != '-')
;
return ch;
}
int f[maxn][maxn][maxn];
int l[4];
char s[maxs];
int a[4][maxn];
int nxt[maxs][26];
int n, q;
int main() {
scanf("%d%d", &n, &q);
scanf("%s", s + 1);
for (int i = 0; i < 26; i++) nxt[n + 1][i] = nxt[n][i] = n + 1;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i + 1] - 'a'] = i + 1;
}
while (q--) {
char ch;
int o, x;
ch = readchar();
if (ch == '+') {
scanf("%d %c", &o, &ch);
x = ch - 'a';
a[o][++l[o]] = x;
if (o == 1) {
for (int i = 0; i <= l[2]; i++)
for (int j = 0; j <= l[3]; j++) {
f[l[1]][i][j] = n + 1;
if (i)
f[l[1]][i][j] =
min(f[l[1]][i][j], nxt[f[l[1]][i - 1][j]][a[2][i]]);
if (j)
f[l[1]][i][j] =
min(f[l[1]][i][j], nxt[f[l[1]][i][j - 1]][a[3][j]]);
f[l[1]][i][j] = min(f[l[1]][i][j], nxt[f[l[1] - 1][i][j]][x]);
}
}
if (o == 2) {
for (int i = 0; i <= l[1]; i++)
for (int j = 0; j <= l[3]; j++) {
f[i][l[2]][j] = n + 1;
if (i)
f[i][l[2]][j] =
min(f[i][l[2]][j], nxt[f[i - 1][l[2]][j]][a[1][i]]);
if (j)
f[i][l[2]][j] =
min(f[i][l[2]][j], nxt[f[i][l[2]][j - 1]][a[3][j]]);
f[i][l[2]][j] = min(f[i][l[2]][j], nxt[f[i][l[2] - 1][j]][x]);
}
}
if (o == 3) {
for (int i = 0; i <= l[1]; i++)
for (int j = 0; j <= l[2]; j++) {
f[i][j][l[3]] = n + 1;
if (i)
f[i][j][l[3]] =
min(f[i][j][l[3]], nxt[f[i - 1][j][l[3]]][a[1][i]]);
if (j)
f[i][j][l[3]] =
min(f[i][j][l[3]], nxt[f[i][j - 1][l[3]]][a[2][j]]);
f[i][j][l[3]] = min(f[i][j][l[3]], nxt[f[i][j][l[3] - 1]][x]);
}
}
} else {
scanf("%d", &o);
l[o]--;
}
if (f[l[1]][l[2]][l[3]] <= n)
printf("YES\n");
else
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int AlphaSize = 26;
const int MaxN = 1e5 + 100;
const int MaxM = 256;
int next_occur[MaxN][AlphaSize];
int dp[MaxM][MaxM][MaxM];
string pattern;
string words[3];
int N, Q;
void CreateLinks() {
for (int i = 0; i < AlphaSize; ++i) {
next_occur[N][i] = next_occur[N + 1][i] = N;
}
for (int pos = N - 1; pos >= 0; --pos) {
for (int i = 0; i < AlphaSize; ++i) {
next_occur[pos][i] =
(pattern[pos] == 'a' + i ? pos : next_occur[pos + 1][i]);
}
}
}
void RecomputeDp(int a, int b, int c) {
int &val = dp[a][b][c];
val = N;
if (a) {
val = min(val, next_occur[dp[a - 1][b][c] + 1][words[0][a - 1] - 'a']);
}
if (b) {
val = min(val, next_occur[dp[a][b - 1][c] + 1][words[1][b - 1] - 'a']);
}
if (c) {
val = min(val, next_occur[dp[a][b][c - 1] + 1][words[2][c - 1] - 'a']);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> Q >> pattern;
CreateLinks();
dp[0][0][0] = -1;
for (int i = 0; i < Q; ++i) {
char type;
int word_id;
cin >> type >> word_id;
--word_id;
if (type == '+') {
char ch;
cin >> ch;
words[word_id] += ch;
int max0 = words[0].size(), max1 = words[1].size(),
max2 = words[2].size();
int min0 = word_id == 0 ? max0 : 0;
int min1 = word_id == 1 ? max1 : 0;
int min2 = word_id == 2 ? max2 : 0;
for (int a = min0; a <= max0; ++a) {
for (int b = min1; b <= max1; ++b) {
for (int c = min2; c <= max2; ++c) {
RecomputeDp(a, b, c);
}
}
}
} else {
words[word_id].pop_back();
}
bool answer = dp[words[0].size()][words[1].size()][words[2].size()] < N;
cout << (answer ? "YES\n" : "NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline long long getnum() {
long long r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline char getreal() {
char c = _buff.get();
while (c <= 32) c = _buff.get();
return c;
}
long long qpow(long long x, long long k) {
return k == 0 ? 1
: 1ll * qpow(1ll * x * x % mod, k >> 1) * (k & 1 ? x : 1) % mod;
}
char s[100111];
int go[100111][26];
int n;
int dp[255][255][255];
int nA, nB, nC;
char sA[255], sB[255], sC[255];
void addA(char c) {
sA[++nA] = c;
for (int i = nA; i <= nA; i++) {
for (int j = 0; j <= nB; j++) {
for (int k = 0; k <= nC; k++) {
int &cur = dp[i][j][k];
cur = n + 2;
if (i > 0) cur = min(cur, go[dp[i - 1][j][k]][sA[i] - 'a']);
if (j > 0) cur = min(cur, go[dp[i][j - 1][k]][sB[j] - 'a']);
if (k > 0) cur = min(cur, go[dp[i][j][k - 1]][sC[k] - 'a']);
}
}
}
}
void addB(char c) {
sB[++nB] = c;
for (int i = 0; i <= nA; i++) {
for (int j = nB; j <= nB; j++) {
for (int k = 0; k <= nC; k++) {
int &cur = dp[i][j][k];
cur = n + 2;
if (i > 0) cur = min(cur, go[dp[i - 1][j][k]][sA[i] - 'a']);
if (j > 0) cur = min(cur, go[dp[i][j - 1][k]][sB[j] - 'a']);
if (k > 0) cur = min(cur, go[dp[i][j][k - 1]][sC[k] - 'a']);
}
}
}
}
void addC(char c) {
sC[++nC] = c;
for (int i = 0; i <= nA; i++) {
for (int j = 0; j <= nB; j++) {
for (int k = nC; k <= nC; k++) {
int &cur = dp[i][j][k];
cur = n + 2;
if (i > 0) cur = min(cur, go[dp[i - 1][j][k]][sA[i] - 'a']);
if (j > 0) cur = min(cur, go[dp[i][j - 1][k]][sB[j] - 'a']);
if (k > 0) cur = min(cur, go[dp[i][j][k - 1]][sC[k] - 'a']);
}
}
}
}
int main() {
int q;
scanf("%d%d", &n, &q);
scanf("%s", s + 1);
for (int i = 0; i < 26; i++) go[n + 2][i] = go[n + 1][i] = n + 2;
for (int i = n; i >= 1; i--) {
for (int j = 0; j < 26; j++) go[i][j] = go[i + 1][j];
go[i][s[i] - 'a'] = i + 1;
}
dp[0][0][0] = 1;
for (int i = 1; i <= q; i++) {
char cmd[10], s[10];
int id;
scanf("%s %d", cmd, &id);
if (cmd[0] == '+') {
scanf("%s", s);
if (id == 1) addA(s[0]);
if (id == 2) addB(s[0]);
if (id == 3) addC(s[0]);
} else {
if (id == 1) nA--;
if (id == 2) nB--;
if (id == 3) nC--;
}
if (dp[nA][nB][nC] <= n + 1)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1e5 + 3, maxm = 252, maxq = 1e3 + 3;
int n, q, l[3], nearest[maxn][26];
char s[maxn], c[3][maxm];
int minn[maxm * maxm * maxm];
int &mn(int i, int j, int k) { return minn[i * maxm * maxm + j * maxm + k]; }
void recalc(int i, int j, int k) {
int &ans = mn(i, j, k);
if (!i && !j && !k) {
ans = 0;
return;
}
ans = 0x3f3f3f3f;
if (i) {
int v = mn(i - 1, j, k);
if (v < n) {
int u = nearest[v][c[0][i - 1] - 'a'] + 1;
if (u < ans) ans = u;
}
}
if (j) {
int v = mn(i, j - 1, k);
if (v < n) {
int u = nearest[v][c[1][j - 1] - 'a'] + 1;
if (u < ans) ans = u;
}
}
if (k) {
int v = mn(i, j, k - 1);
if (v < n) {
int u = nearest[v][c[2][k - 1] - 'a'] + 1;
if (u < ans) ans = u;
}
}
}
void update(int cur) {
int low[3] = {0, 0, 0}, up[3] = {l[0], l[1], l[2]};
low[cur] = l[cur];
for (int i = low[0]; i <= up[0]; ++i)
for (int j = low[1]; j <= up[1]; ++j)
for (int k = low[2]; k <= up[2]; ++k) recalc(i, j, k);
}
int main() {
scanf("%d%d%s", &n, &q, s);
memset(nearest[n], 0x3f, sizeof(nearest[n]));
for (int i = n - 1; i >= 0; --i) {
memcpy(nearest[i], nearest[i + 1], sizeof(nearest[i]));
nearest[i][s[i] - 'a'] = i;
}
for (int i = 0; i < q; ++i) {
char bufA[4], bufB[4];
int u;
scanf("%s%d", bufA, &u);
--u;
if (bufA[0] == '+') {
scanf("%s", bufB);
c[u][l[u]++] = bufB[0];
} else if (bufA[0] == '-') {
c[u][--l[u]] = 0;
}
update(u);
puts(mn(l[0], l[1], l[2]) <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
const int N = 100005;
int n, q;
char s[N];
vector<char> need[5];
int sz[5];
vector<int> pos[30];
int dp[255][255][255];
int f(int at[]) {
if (at[1] == 0 && at[2] == 0 && at[3] == 0) return 0;
int &ans = dp[at[1]][at[2]][at[3]];
if (ans != -1) return ans;
ans = n + 1;
for (int i = 1; i <= 3; i++) {
if (at[i]) {
at[i]--;
auto it = lower_bound(pos[need[i][at[i]] - 'a'].begin(),
pos[need[i][at[i]] - 'a'].end(), f(at));
if (it != pos[need[i][at[i]] - 'a'].end()) {
ans = min(ans, *it + 1);
}
at[i]++;
}
}
return ans;
}
int main() {
scanf("%d %d", &n, &q);
scanf("%s", s);
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; i++) {
pos[s[i] - 'a'].push_back(i);
}
while (q--) {
char op;
scanf(" %c", &op);
if (op == '+') {
int id;
char c;
scanf("%d %c", &id, &c);
sz[id]++;
need[id].push_back(c);
} else {
int id;
scanf("%d", &id);
need[id].pop_back();
if (id == 1) {
for (int i = 0; i <= sz[2]; i++) {
for (int j = 0; j <= sz[3]; j++) {
dp[sz[1]][i][j] = -1;
}
}
}
if (id == 2) {
for (int i = 0; i <= sz[1]; i++) {
for (int j = 0; j <= sz[3]; j++) {
dp[i][sz[2]][j] = -1;
}
}
}
if (id == 3) {
for (int i = 0; i <= sz[2]; i++) {
for (int j = 0; j <= sz[1]; j++) {
dp[j][i][sz[3]] = -1;
}
}
}
sz[id]--;
}
if (f(sz) <= n) {
printf("YES\n");
} else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
const int M = 26;
const int K = 250 + 1;
int nextC[N][M];
int minWorld[K][K][K];
int a0 = 0, a1 = 0, a2 = 0;
char r0[K];
char r1[K];
char r2[K];
void setMin(int b0, int b1, int b2) {
assert(b0 > 0 or b1 > 0 or b2 > 0);
minWorld[b0][b1][b2] = N;
if (b0 > 0) {
int l = minWorld[b0 - 1][b1][b2];
if (l != N) {
int k = nextC[l][r0[b0 - 1] - 'a'];
minWorld[b0][b1][b2] = min(minWorld[b0][b1][b2], k);
}
}
if (b1 > 0) {
int l = minWorld[b0][b1 - 1][b2];
if (l != N) {
int k = nextC[l][r1[b1 - 1] - 'a'];
minWorld[b0][b1][b2] = min(minWorld[b0][b1][b2], k);
}
}
if (b2 > 0) {
int l = minWorld[b0][b1][b2 - 1];
if (l != N) {
int k = nextC[l][r2[b2 - 1] - 'a'];
minWorld[b0][b1][b2] = min(minWorld[b0][b1][b2], k);
}
}
}
void remove(int i) {
if (i == 0)
a0--;
else if (i == 1)
a1--;
else if (i == 2)
a2--;
else
assert(false);
}
void insert(int i, char c) {
if (i == 0) {
r0[a0++] = c;
for (int b1 = 0; b1 <= a1; b1++)
for (int b2 = 0; b2 <= a2; b2++) setMin(a0, b1, b2);
} else if (i == 1) {
r1[a1++] = c;
for (int b0 = 0; b0 <= a0; b0++)
for (int b2 = 0; b2 <= a2; b2++) setMin(b0, a1, b2);
} else if (i == 2) {
r2[a2++] = c;
for (int b0 = 0; b0 <= a0; b0++)
for (int b1 = 0; b1 <= a1; b1++) setMin(b0, b1, a2);
}
}
signed main() {
iostream::sync_with_stdio(false);
int n, q;
cin >> n >> q;
string world;
cin >> world;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) nextC[i][j] = N;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < M; j++) nextC[i][j] = nextC[i + 1][j];
nextC[i][world[i] - 'a'] = i + 1;
}
minWorld[0][0][0] = 0;
for (int i = 0; i < q; i++) {
char x;
cin >> x;
if (x == '+') {
int i;
char c;
cin >> i >> c;
insert(i - 1, c);
} else if (x == '-') {
int i;
cin >> i;
remove(i - 1);
} else
assert(false);
cout << (minWorld[a0][a1][a2] == N ? "NO" : "YES") << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, nx[26][100010], x, len[4], f[260][260][260], a[4][260];
char c[100010], d[3], e[3];
void update(int x) {
for (int i = x == 1 ? len[1] : 0; i <= len[1]; i++)
for (int j = x == 2 ? len[2] : 0; j <= len[2]; j++)
for (int k = x == 3 ? len[3] : 0; k <= len[3]; k++) {
f[i][j][k] = 2147483647;
if (i && f[i - 1][j][k] != 2147483647)
f[i][j][k] = min(f[i][j][k], nx[a[1][i]][f[i - 1][j][k] + 1]);
if (j && f[i][j - 1][k] != 2147483647)
f[i][j][k] = min(f[i][j][k], nx[a[2][j]][f[i][j - 1][k] + 1]);
if (k && f[i][j][k - 1] != 2147483647)
f[i][j][k] = min(f[i][j][k], nx[a[3][k]][f[i][j][k - 1] + 1]);
}
}
int main() {
scanf("%d%d%s", &n, &q, c + 1);
for (int i = 0; i < 26; i++) {
nx[i][n + 1] = 2147483647;
for (int j = n; j; j--) nx[i][j] = c[j] == i + 'a' ? j : nx[i][j + 1];
}
while (q--) {
scanf("%s%d", d, &x);
if (d[0] == '+') {
scanf("%s", e);
a[x][++len[x]] = e[0] - 'a';
update(x);
} else
len[x]--;
puts(f[len[1]][len[2]][len[3]] == 2147483647 ? "NO" : "YES");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[256][256][256];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n, q;
string s;
cin >> n >> q >> s;
vector<vector<int>> nex(n + 1, vector<int>(26, n + 1));
for (int i = n - 1; i >= 0; i--) {
nex[i] = nex[i + 1];
nex[i][s[i] - 'a'] = i;
}
vector<string> ss(3);
for (int i = 0; i <= 250; i++) {
for (int j = 0; j <= 250; j++) {
for (int k = 0; k <= 250; k++) {
dp[i][j][k] = n + 1;
}
}
}
dp[0][0][0] = 0;
while (q--) {
vector<vector<int>> pos(3, {0});
char com;
int col;
cin >> com >> col;
--col;
if (com == '+') {
char c;
cin >> c;
ss[col].push_back(c);
if (col == 0) {
for (int i = ss[0].size(); i <= (int)ss[0].size(); i++) {
for (int j = 0; j <= (int)ss[1].size(); j++) {
for (int k = 0; k <= (int)ss[2].size(); k++) {
dp[i][j][k] = n + 1;
}
}
}
for (int i = ss[0].size() - 1; i <= (int)ss[0].size(); i++) {
for (int j = 0; j <= (int)ss[1].size(); j++) {
for (int k = 0; k <= (int)ss[2].size(); k++)
if (dp[i][j][k] < n) {
if (i < (int)ss[0].size())
dp[i + 1][j][k] = min(dp[i + 1][j][k],
nex[dp[i][j][k]][ss[0][i] - 'a'] + 1);
if (j < (int)ss[1].size())
dp[i][j + 1][k] = min(dp[i][j + 1][k],
nex[dp[i][j][k]][ss[1][j] - 'a'] + 1);
if (k < (int)ss[2].size())
dp[i][j][k + 1] = min(dp[i][j][k + 1],
nex[dp[i][j][k]][ss[2][k] - 'a'] + 1);
}
}
}
} else if (col == 1) {
for (int i = 0; i <= (int)ss[0].size(); i++) {
for (int j = ss[1].size(); j <= (int)ss[1].size(); j++) {
for (int k = 0; k <= (int)ss[2].size(); k++) {
dp[i][j][k] = n + 1;
}
}
}
for (int i = 0; i <= (int)ss[0].size(); i++) {
for (int j = ss[1].size() - 1; j <= (int)ss[1].size(); j++) {
for (int k = 0; k <= (int)ss[2].size(); k++)
if (dp[i][j][k] < n) {
if (i < (int)ss[0].size())
dp[i + 1][j][k] = min(dp[i + 1][j][k],
nex[dp[i][j][k]][ss[0][i] - 'a'] + 1);
if (j < (int)ss[1].size())
dp[i][j + 1][k] = min(dp[i][j + 1][k],
nex[dp[i][j][k]][ss[1][j] - 'a'] + 1);
if (k < (int)ss[2].size())
dp[i][j][k + 1] = min(dp[i][j][k + 1],
nex[dp[i][j][k]][ss[2][k] - 'a'] + 1);
}
}
}
} else {
for (int i = 0; i <= (int)ss[0].size(); i++) {
for (int j = 0; j <= (int)ss[1].size(); j++) {
for (int k = ss[2].size(); k <= (int)ss[2].size(); k++) {
dp[i][j][k] = n + 1;
}
}
}
for (int i = 0; i <= (int)ss[0].size(); i++) {
for (int j = 0; j <= (int)ss[1].size(); j++) {
for (int k = ss[2].size() - 1; k <= (int)ss[2].size(); k++)
if (dp[i][j][k] < n) {
if (i < (int)ss[0].size())
dp[i + 1][j][k] = min(dp[i + 1][j][k],
nex[dp[i][j][k]][ss[0][i] - 'a'] + 1);
if (j < (int)ss[1].size())
dp[i][j + 1][k] = min(dp[i][j + 1][k],
nex[dp[i][j][k]][ss[1][j] - 'a'] + 1);
if (k < (int)ss[2].size())
dp[i][j][k + 1] = min(dp[i][j][k + 1],
nex[dp[i][j][k]][ss[2][k] - 'a'] + 1);
}
}
}
}
} else {
ss[col].pop_back();
}
puts(dp[ss[0].size()][ss[1].size()][ss[2].size()] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
char str[maxn], A[3][255];
int n, m, sz[3], nxt[26][maxn], dp[255][255][255];
inline int chkmin(int& x, int y) { return x < y ? x : x = y; }
int main() {
scanf("%d %d %s", &n, &m, str + 1);
for (int j = 0; j < 26; j++) {
for (int i = n, pos = n + 1; ~i; i--) {
nxt[j][i] = pos;
if (str[i] == j + 'a') pos = i;
}
}
dp[0][0][0] = 0;
char op[3];
int x;
while (m--) {
scanf("%s %d", op, &x), x--;
if (*op == '+') {
scanf("%s", op);
A[x][++sz[x]] = *op;
int s0 = x == 0 ? sz[0] : 0;
int s1 = x == 1 ? sz[1] : 0;
int s2 = x == 2 ? sz[2] : 0;
for (int i = s0; i <= sz[0]; i++) {
for (int j = s1; j <= sz[1]; j++) {
for (int k = s2; k <= sz[2]; k++) {
dp[i][j][k] = n + 1;
if (i && dp[i - 1][j][k] <= n)
chkmin(dp[i][j][k], nxt[A[0][i] - 'a'][dp[i - 1][j][k]]);
if (j && dp[i][j - 1][k] <= n)
chkmin(dp[i][j][k], nxt[A[1][j] - 'a'][dp[i][j - 1][k]]);
if (k && dp[i][j][k - 1] <= n)
chkmin(dp[i][j][k], nxt[A[2][k] - 'a'][dp[i][j][k - 1]]);
}
}
}
} else {
sz[x]--;
}
puts(dp[sz[0]][sz[1]][sz[2]] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const int N = 1e5 + 1, D = 251, A = 26, INF = 1e9;
int dp[D][D][D], f[N][A], sz[3];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
string a, d[3];
int n, q;
cin >> n >> q >> a;
for (int i = 0; i < int(A); i++) f[n][i] = -1;
for (int i = int(n - 1); i >= 0; i--)
for (int j = 0; j < int(A); j++)
f[i][j] = a[i] == char('a' + j) ? i : f[i + 1][j];
while (q--) {
char t;
int r;
cin >> t >> r, r--;
if (t == '+') {
char v;
cin >> v;
d[r] += v;
vector<int> st(3);
st[r] = ++sz[r];
for (int i = int(st[0]); i < int(sz[0] + 1); i++)
for (int j = int(st[1]); j < int(sz[1] + 1); j++)
for (int k = int(st[2]); k < int(sz[2] + 1); k++) dp[i][j][k] = INF;
st[r]--;
for (int i = int(st[0]); i < int(sz[0] + 1); i++) {
for (int j = int(st[1]); j < int(sz[1] + 1); j++) {
for (int k = int(st[2]); k < int(sz[2] + 1); k++) {
int c = dp[i][j][k];
if (c < n) {
if (i < sz[0]) {
int nx = f[c][int(d[0][i] - 'a')] + 1;
int &x = dp[i + 1][j][k];
if (nx) x = min(x, nx);
}
if (j < sz[1]) {
int nx = f[c][int(d[1][j] - 'a')] + 1;
int &x = dp[i][j + 1][k];
if (nx) x = min(x, nx);
}
if (k < sz[2]) {
int nx = f[c][int(d[2][k] - 'a')] + 1;
int &x = dp[i][j][k + 1];
if (nx) x = min(x, nx);
}
}
}
}
}
} else
d[r].pop_back(), sz[r]--;
cout << (dp[sz[0]][sz[1]][sz[2]] != INF ? "YES" : "NO") << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1e5 + 5;
const int LMAX = 255;
int lookup[30][NMAX], dp[LMAX][LMAX][LMAX];
char s[3][LMAX];
char univ[NMAX];
char line[105];
int I[3];
int main() {
int N, Q, i, k, j;
cin >> N >> Q;
cin >> (univ + 1);
for (i = 0; i < 26; ++i)
for (j = 0; j <= N; ++j) lookup[i][j] = -1;
for (i = 0; i < 26; ++i) {
for (j = N - 1; j >= 0; --j) {
if (univ[j + 1] == ('a' + i))
lookup[i][j] = j + 1;
else
lookup[i][j] = lookup[i][j + 1];
}
}
for (i = 0; i <= 250; ++i)
for (j = 0; j <= 250; ++j)
for (k = 0; k <= 250; ++k) dp[i][j][k] = -1;
dp[0][0][0] = 0;
cin.getline(line, 20);
while (Q--) {
cin.getline(line, 100);
int ind = line[2] - '1';
int next[2] = {(ind + 1) % 3, (ind + 2) % 3};
int newind[3];
int smallind[3];
if (line[0] == '-') {
for (i = 0; i <= I[next[0]]; ++i) {
for (j = 0; j <= I[next[1]]; ++j) {
smallind[next[0]] = i;
smallind[next[1]] = j;
smallind[ind] = I[ind];
dp[smallind[0]][smallind[1]][smallind[2]] = -1;
}
}
I[ind]--;
} else {
s[ind][++I[ind]] = line[4];
smallind[ind] = I[ind];
int w;
for (w = 0; w <= I[next[0]] + I[next[1]]; ++w) {
for (i = 0; i <= I[next[0]]; ++i) {
j = w - i;
if (j >= 0 && j <= I[next[1]]) {
smallind[next[0]] = i;
smallind[next[1]] = j;
newind[next[0]] = i;
newind[next[1]] = j;
newind[ind] = I[ind];
for (k = 0; k < 3; ++k) {
newind[k]--;
char ch = s[k][smallind[k]];
if (dp[newind[0]][newind[1]][newind[2]] >= 0 && newind[k] >= 0 &&
lookup[s[k][smallind[k]] - 'a']
[dp[newind[0]][newind[1]][newind[2]]] != -1) {
if (dp[smallind[0]][smallind[1]][smallind[2]] == -1)
dp[smallind[0]][smallind[1]][smallind[2]] =
lookup[s[k][smallind[k]] - 'a']
[dp[newind[0]][newind[1]][newind[2]]];
else
dp[smallind[0]][smallind[1]][smallind[2]] =
min(dp[smallind[0]][smallind[1]][smallind[2]],
lookup[s[k][smallind[k]] - 'a']
[dp[newind[0]][newind[1]][newind[2]]]);
}
newind[k]++;
}
}
}
}
}
if (dp[I[0]][I[1]][I[2]] != -1)
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)255, INF = (int)1e9, L = (int)1e5 + 50;
const int Q = (int)1005;
struct edge {
int to, c;
};
int n, q;
string str;
vector<vector<vector<int> > > dp;
int loc[Q][3];
int nxt[L][26];
int pos[26];
struct Trie {
vector<edge> G[Q];
int nxt[Q][26];
int par[Q];
int sz = 1;
int cur = 0;
void set() {
par[0] = -1;
memset(nxt, -1, sizeof(nxt));
}
int add(int x) {
if (nxt[cur][x] == -1) {
nxt[cur][x] = sz;
par[sz] = cur;
sz++;
}
cur = nxt[cur][x];
return cur;
}
int del() {
cur = par[cur];
return cur;
}
void get_adj() {
for (int i = 0; i < sz; i++) {
for (int j = 0; j < 26; j++) {
if (nxt[i][j] != -1) G[i].push_back({nxt[i][j], j});
}
}
}
void print() {
cout << "trie: " << endl;
for (int i = 0; i < sz; i++) {
cout << i << ": ";
for (auto e : G[i]) printf("(%d, %d), ", e.to, e.c);
cout << endl;
}
cout << "cur : " << cur << endl;
}
} trie[3];
void umin(int &to, int x) { to = min(to, x); }
int main() {
cin >> n >> q;
cin >> str;
fill(pos, pos + 26, -1);
for (int i = n - 1; i >= 0; i--) {
pos[str[i] - 'a'] = i;
for (int j = 0; j < 26; j++) nxt[i][j] = pos[j];
}
int x[3] = {0, 0, 0};
for (int i = 0; i < 3; i++) trie[i].set();
for (int i = 0; i < q; i++) {
char op, c;
int k;
cin >> op >> k;
k--;
if (op == '+') {
cin >> c;
x[k] = trie[k].add(c - 'a');
} else {
x[k] = trie[k].del();
}
for (int j = 0; j < 3; j++) loc[i][j] = x[j];
}
for (int i = 0; i < 3; i++) trie[i].get_adj();
dp.resize(trie[0].sz);
for (int i = 0; i < trie[0].sz; i++) {
dp[i].resize(trie[1].sz);
for (int j = 0; j < trie[1].sz; j++) {
dp[i][j].resize(trie[2].sz);
for (int k = 0; k < trie[2].sz; k++) dp[i][j][k] = INF;
}
}
dp[0][0][0] = 0;
for (int i = 0; i < trie[0].sz; i++) {
for (int j = 0; j < trie[1].sz; j++) {
for (int k = 0; k < trie[2].sz; k++) {
if (dp[i][j][k] >= n) continue;
int curloc = dp[i][j][k];
for (auto e : trie[0].G[i]) {
int nx = nxt[curloc][e.c];
if (nx != -1) umin(dp[e.to][j][k], nx + 1);
}
for (auto e : trie[1].G[j]) {
int nx = nxt[curloc][e.c];
if (nx != -1) umin(dp[i][e.to][k], nx + 1);
}
for (auto e : trie[2].G[k]) {
int nx = nxt[curloc][e.c];
if (nx != -1) umin(dp[i][j][e.to], nx + 1);
}
}
}
}
for (int i = 0; i < q; i++) {
int ci = loc[i][0], cj = loc[i][1], ck = loc[i][2];
if (dp[ci][cj][ck] < INF) {
cout << "YES"
<< "\n";
} else
cout << "NO"
<< "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = 1e9;
const int N = 1e5 + 5;
const int M = 255;
int n, q;
string s;
int dp[M][M][M];
int f[N][26];
int len[4];
char sa[4][M];
void get_num() {
for (int id = 0; id < 26; ++id) {
int pos = Inf;
f[n + 1][id] = pos;
for (int i = n; i; --i) {
if (s[i - 1] - 'a' == id) pos = i;
f[i][id] = pos;
}
}
}
bool flag = 0;
inline int cmin(int& a, int b) {
a = min(a, b);
return a;
}
void prif() {
if (len[1] + len[2] + len[3] <= 2)
for (int i = 0; i <= len[1]; ++i) {
cout << "i= " << i << ' ';
for (int j = 0; j <= len[2]; ++j) {
cout << "j=" << j << ' ';
for (int k = 0; k <= len[3]; ++k) {
if (dp[i][j][k] == Inf) break;
cout << k << ' ' << dp[i][j][k] << ';';
}
cout << endl;
}
cout << endl;
}
cout << endl;
}
void update(int id, char c) {
for (int i = (id == 1 ? len[id] : 0); i <= len[1]; ++i) {
for (int j = (id == 2 ? len[id] : 0); j <= len[2]; ++j) {
for (int k = (id == 3 ? len[id] : 0); k <= len[3]; ++k) {
dp[i][j][k] = Inf;
if (i && dp[i - 1][j][k] != Inf)
cmin(dp[i][j][k], f[dp[i - 1][j][k] + 1][sa[1][i] - 'a']);
if (j && dp[i][j - 1][k] != Inf)
cmin(dp[i][j][k], f[dp[i][j - 1][k] + 1][sa[2][j] - 'a']);
if (k && dp[i][j][k - 1] != Inf)
cmin(dp[i][j][k], f[dp[i][j][k - 1] + 1][sa[3][k] - 'a']);
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> q;
cin >> s;
get_num();
char op, c;
int id;
memset(len, 0, sizeof(len));
while (q--) {
cin >> op;
if (op == '+') {
cin >> id >> c;
sa[id][++len[id]] = c;
update(id, c);
} else {
cin >> id;
--len[id];
}
if (dp[len[1]][len[2]][len[3]] == Inf)
cout << "NO\n";
else
cout << "YES\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[260][260][260];
int n, q;
char c[200010];
int nxt[200010][30], lst[30];
int len1, len2, len3;
char op, co;
int x;
char s1[260], s2[260], s3[260];
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> c[i];
c[i] -= 'a';
}
for (int i = 0; i <= 25; i++) lst[i] = 2000000;
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= 25; j++) nxt[i][j] = lst[j];
lst[c[i]] = i;
}
for (int i = 0; i <= 25; i++) nxt[0][i] = lst[i];
for (int i = 0; i <= 256; i++)
for (int j = 0; j <= 256; j++)
for (int k = 0; k <= 256; k++) f[i][j][k] = 2000000;
f[0][0][0] = 0;
while (q--) {
cin >> op >> x;
if (op == '+') {
cin >> co;
if (x == 1) {
s1[++len1] = co - 'a';
for (int i = len1 - 1; i <= len1; i++) {
for (int j = 0; j <= len2; j++)
for (int k = 0; k <= len3; k++)
if (f[i][j][k] <= n) {
if (i != len1)
f[i + 1][j][k] =
min(nxt[f[i][j][k]][s1[i + 1]], f[i + 1][j][k]);
if (j != len2)
f[i][j + 1][k] =
min(nxt[f[i][j][k]][s2[j + 1]], f[i][j + 1][k]);
if (k != len3)
f[i][j][k + 1] =
min(nxt[f[i][j][k]][s3[k + 1]], f[i][j][k + 1]);
}
}
}
if (x == 2) {
s2[++len2] = co - 'a';
for (int i = 0; i <= len1; i++) {
for (int j = len2 - 1; j <= len2; j++)
for (int k = 0; k <= len3; k++)
if (f[i][j][k] <= n) {
if (i != len1)
f[i + 1][j][k] =
min(nxt[f[i][j][k]][s1[i + 1]], f[i + 1][j][k]);
if (j != len2)
f[i][j + 1][k] =
min(nxt[f[i][j][k]][s2[j + 1]], f[i][j + 1][k]);
if (k != len3)
f[i][j][k + 1] =
min(nxt[f[i][j][k]][s3[k + 1]], f[i][j][k + 1]);
}
}
}
if (x == 3) {
s3[++len3] = co - 'a';
for (int i = 0; i <= len1; i++) {
for (int j = 0; j <= len2; j++)
for (int k = len3 - 1; k <= len3; k++)
if (f[i][j][k] <= n) {
if (i != len1)
f[i + 1][j][k] =
min(nxt[f[i][j][k]][s1[i + 1]], f[i + 1][j][k]);
if (j != len2)
f[i][j + 1][k] =
min(nxt[f[i][j][k]][s2[j + 1]], f[i][j + 1][k]);
if (k != len3)
f[i][j][k + 1] =
min(nxt[f[i][j][k]][s3[k + 1]], f[i][j][k + 1]);
}
}
}
} else {
if (x == 1) {
for (int i = len1; i <= len1; i++)
for (int j = 0; j <= 256; j++)
for (int k = 0; k <= 256; k++) f[i][j][k] = 10000000;
len1--;
}
if (x == 2) {
for (int i = 0; i <= 256; i++)
for (int j = len2; j <= len2; j++)
for (int k = 0; k <= 256; k++) f[i][j][k] = 10000000;
len2--;
}
if (x == 3) {
for (int i = 0; i <= 256; i++)
for (int j = 0; j <= 256; j++)
for (int k = len3; k <= len3; k++) f[i][j][k] = 10000000;
len3--;
}
}
if (f[len1][len2][len3] <= n)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 251;
const long long mod = 998244353;
char s[100010], a[3][N];
int back[100010][27];
int tot[3], n, q;
int dp[N][N][N];
void init() {
int len = strlen(s);
for (int j = (0); j <= (25); j++) {
back[len][j] = n + 1;
}
for (int i = (len - 1); i >= (0); i--) {
for (int j = (0); j <= (25); j++) {
back[i][j] = back[i + 1][j];
if (s[i] - 'a' == j) {
back[i][j] = i;
}
}
}
}
void update(int i, int j, int k, int pos, char now) {
if (pos == n + 1) return;
int to = back[pos][now - 'a'] + 1;
dp[i][j][k] = min(dp[i][j][k], to);
}
void solve(int ib, int jb, int kb) {
for (int i = (ib); i <= (tot[0]); i++) {
for (int j = (jb); j <= (tot[1]); j++) {
for (int k = (kb); k <= (tot[2]); k++) {
if (i != 0 || j != 0 || k != 0) dp[i][j][k] = n + 1;
if (i - 1 >= 0) {
update(i, j, k, dp[i - 1][j][k], a[0][i]);
}
if (j - 1 >= 0) {
update(i, j, k, dp[i][j - 1][k], a[1][j]);
}
if (k - 1 >= 0) {
update(i, j, k, dp[i][j][k - 1], a[2][k]);
}
}
}
}
}
int main() {
scanf("%d%d", &n, &q);
scanf("%s", s);
memset(tot, 0, sizeof(tot));
dp[0][0][0] = 0;
init();
while (q-- > 0) {
char type[2], tmp[2];
int pos;
scanf("%s%d", type, &pos);
if (type[0] == '+') {
scanf("%s", tmp);
a[pos - 1][++tot[pos - 1]] = tmp[0];
solve(pos - 1 == 0 ? tot[pos - 1] : 0, pos - 1 == 1 ? tot[pos - 1] : 0,
pos - 1 == 2 ? tot[pos - 1] : 0);
} else {
tot[pos - 1]--;
}
if (dp[tot[0]][tot[1]][tot[2]] != n + 1) {
puts("YES");
} else {
puts("NO");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 255, K = 26, MX = 1e5 + 7;
int dp[N][N][N];
string a, b, c;
string s;
int n, q;
int nxt[MX][K];
void adda(char ch) {
a += ch;
int x = a.size() - 1;
int y = b.size() - 1;
int z = c.size() - 1;
for (int i = 0; i <= y; i++)
for (int j = 0; j <= z; j++) {
dp[x][i][j] = nxt[dp[x - 1][i][j]][a[x] - 'a'];
if (i > 0)
dp[x][i][j] = min(dp[x][i][j], nxt[dp[x][i - 1][j]][b[i] - 'a']);
if (j > 0)
dp[x][i][j] = min(dp[x][i][j], nxt[dp[x][i][j - 1]][c[j] - 'a']);
}
}
void addb(char ch) {
b += ch;
int x = a.size() - 1;
int y = b.size() - 1;
int z = c.size() - 1;
for (int i = 0; i <= x; i++)
for (int j = 0; j <= z; j++) {
dp[i][y][j] = nxt[dp[i][y - 1][j]][b[y] - 'a'];
if (i > 0)
dp[i][y][j] = min(dp[i][y][j], nxt[dp[i - 1][y][j]][a[i] - 'a']);
if (j > 0)
dp[i][y][j] = min(dp[i][y][j], nxt[dp[i][y][j - 1]][c[j] - 'a']);
}
}
void addc(char ch) {
c += ch;
int x = a.size() - 1;
int y = b.size() - 1;
int z = c.size() - 1;
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++) {
dp[i][j][z] = nxt[dp[i][j][z - 1]][c[z] - 'a'];
if (i > 0)
dp[i][j][z] = min(dp[i][j][z], nxt[dp[i - 1][j][z]][a[i] - 'a']);
if (j > 0)
dp[i][j][z] = min(dp[i][j][z], nxt[dp[i][j - 1][z]][b[j] - 'a']);
}
}
int main() {
cin >> n >> q;
cin >> s;
s = ' ' + s;
a = b = c = ":";
for (int i = 0; i < 26; i++) nxt[n][i] = nxt[n + 1][i] = n + 1;
for (int i = 0; i < 26; i++)
for (int j = n - 1; j >= 0; j--) {
if (s[j + 1] == 'a' + i)
nxt[j][i] = j + 1;
else
nxt[j][i] = nxt[j + 1][i];
}
while (q--) {
char op, no, ch;
cin >> ws >> op >> no;
if (op == '+') {
cin >> ch;
if (no == '1') adda(ch);
if (no == '2') addb(ch);
if (no == '3') addc(ch);
} else {
if (no == '1') a.pop_back();
if (no == '2') b.pop_back();
if (no == '3') c.pop_back();
}
cout << (dp[a.size() - 1][b.size() - 1][c.size() - 1] <= n ? "YES" : "NO")
<< endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
string pattern;
string words[3];
int dp[255][255][255];
int next_char[100005][26];
void helper() {
for (int i = 0; i < 26; i++) next_char[n][i] = next_char[n + 1][i] = n;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
next_char[i][j] = pattern[i] == 'a' + j ? i : next_char[i + 1][j];
}
}
}
void compute(int a, int b, int c) {
int &val = dp[a][b][c];
val = n;
if (a) val = min(val, next_char[dp[a - 1][b][c] + 1][words[0][a - 1] - 'a']);
if (b) val = min(val, next_char[dp[a][b - 1][c] + 1][words[1][b - 1] - 'a']);
if (c) val = min(val, next_char[dp[a][b][c - 1] + 1][words[2][c - 1] - 'a']);
}
int main() {
cin >> n >> q >> pattern;
helper();
dp[0][0][0] = -1;
for (int k = 0; k < q; k++) {
char type, c;
int i;
cin >> type >> i;
i--;
if (type == '+') {
cin >> c;
words[i] += c;
int max0 = words[0].size(), max1 = words[1].size(),
max2 = words[2].size();
int min0 = i == 0 ? max0 : 0;
int min1 = i == 1 ? max1 : 0;
int min2 = i == 2 ? max2 : 0;
for (int A = min0; A <= max0; A++) {
for (int B = min1; B <= max1; B++) {
for (int C = min2; C <= max2; C++) {
compute(A, B, C);
}
}
}
} else {
words[i].pop_back();
}
bool answer = dp[words[0].size()][words[1].size()][words[2].size()] < n;
cout << (answer ? "YES\n" : "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
char str[100010];
int des[4][256];
int len[4];
int nxt[100010][26];
int dp[255][255][255];
void update(int &a, int b) {
if (a == -1)
a = b;
else if (b > -1)
a = min(a, b);
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n >> q;
scanf("%s", str + 1);
for (int i = n; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
if (i == n) {
nxt[i][j] = -1;
} else {
if (str[i + 1] == j + 'a') {
nxt[i][j] = i + 1;
} else {
nxt[i][j] = nxt[i + 1][j];
}
}
}
}
dp[0][0][0] = 0;
while (q--) {
char op[2];
scanf("%s", op);
int who;
char ch[2];
if (op[0] == '+') {
scanf("%d %s", &who, ch);
des[who][len[who]++] = ch[0] - 'a';
} else {
scanf("%d", &who);
len[who]--;
}
int is = 0, js = 0, ks = 0;
if (who == 1) is = len[1];
if (who == 2) js = len[2];
if (who == 3) ks = len[3];
int ie = len[1], je = len[2], ke = len[3];
for (int i = is; i <= ie; i++) {
for (int j = js; j <= je; j++) {
for (int k = ks; k <= ke; k++) {
if (i + j + k > 0) dp[i][j][k] = -1;
if (i > 0 && dp[i - 1][j][k] >= 0) {
update(dp[i][j][k], nxt[dp[i - 1][j][k]][des[1][i - 1]]);
}
if (j > 0 && dp[i][j - 1][k] >= 0) {
update(dp[i][j][k], nxt[dp[i][j - 1][k]][des[2][j - 1]]);
}
if (k > 0 && dp[i][j][k - 1] >= 0) {
update(dp[i][j][k], nxt[dp[i][j][k - 1]][des[3][k - 1]]);
}
}
}
}
if (dp[len[1]][len[2]][len[3]] >= 0) {
puts("YES");
} else {
puts("NO");
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.