text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
vector<int> v1, v2, v3;
vector<int> pos[26];
int f[251][251][251];
string st, op, ch;
int n, q, x;
inline void update(int x, int y, int z) {
f[x][y][z] = n + 1;
if (x > 0 && 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 && 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 && 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);
}
}
}
inline void work() {
cin >> n >> q;
cin >> st;
for (int i = 0; i < st.size(); ++i) {
pos[st[i] - 97].push_back(i);
}
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);
for (int i = 0; i <= v2.size(); ++i) {
for (int j = 0; j <= v3.size(); ++j) {
update((int)v1.size(), i, j);
}
}
} else if (x == 2) {
v2.push_back(ch[0] - 97);
for (int i = 0; i <= v1.size(); ++i) {
for (int j = 0; j <= v3.size(); ++j) {
update(i, (int)v2.size(), j);
}
}
} else {
v3.push_back(ch[0] - 97);
for (int i = 0; i <= v1.size(); ++i) {
for (int j = 0; j <= v2.size(); ++j) {
update(i, j, (int)v3.size());
}
}
}
} else {
if (x == 1) {
v1.pop_back();
} else if (x == 2) {
v2.pop_back();
} else {
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>
#pragma optimize("unroll-loops,no-stack-protector")
using namespace std;
namespace io {
struct eof {
eof() {}
};
const int L = (1 << 21) | 5;
char ibuf[L], *iS, *iT, obuf[L], *oS = obuf, *oT = obuf + L - 1, c, qu[55];
int f, qr;
inline void flush() { fwrite(obuf, 1, oS - obuf, stdout), oS = obuf; }
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <class I>
inline void gi(I &x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
(c < '0' || c > '9') && (c != EOF);
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
if (c == EOF) throw eof();
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) putc(qu[qr--]);
}
inline void ps(const char *s) {
int l = strlen(s), x;
for (x = 0; x < l; x++) putc(s[x]);
}
struct IOC {
~IOC() { flush(); }
} ioc;
inline double readld() {
double x = 0, y = 1;
for (c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') y = -1;
assert(c != '.');
for (; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= y;
assert(c != 'e');
if (c == '.')
for (c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
y *= 0.1, x += y * (c & 15);
return x;
}
inline void printld(double x, int y) {
if (x < 0) putc('-'), x = -x;
x += .5 * pow(.1, y);
print((unsigned long long)x), putc('.');
for (x -= (unsigned long long)x; y; --y)
x *= 10, putc((int)x + '0'), x -= (int)x;
}
} // namespace io
using io::gi;
using io::print;
using io::putc;
template <class T>
int ctz(T a) {
return sizeof(T) > 4 ? __builtin_ctzll(a) : __builtin_ctz(a);
}
template <class T>
inline T gcd(T a, T b) {
int shift = ctz(a | b);
for (b >>= ctz(b), a >>= ctz(a); a; a -= b, a >>= ctz(a))
if (a < b) swap(a, b);
return b << shift;
}
template <class T>
void exgcd(T a, T b, T &x, T &y) {
if (!b) return (void)(x = 1, y = 0);
exgcd(b, a % b, y, x), y -= a / b * x;
}
template <class T>
T Inv(T a, T p) {
T x, y;
exgcd(a, p, x, y);
return (x % p + p) % p;
}
inline int fpow(int a, int t, int p) {
static int r;
for (r = 1; t; a = (long long)a * a % p, t >>= 1)
if (t & 1) r = (long long)r * a % p;
return r;
}
string to_string(string s) { return '"' + s + '"'; };
string to_string(const char *s) { return to_string(string(s)); }
string to_string(bool f) { return f ? "true" : "false"; }
template <class A, class B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <class T>
string to_string(T v) {
string s = "{", e = "";
for (auto &x : v) s += e + to_string(x), e = ", ";
s += "}";
return s;
}
void debug_out() { cerr << endl; }
template <class A, class... B>
void debug_out(A x, B... y) {
cerr << " " << to_string(x), debug_out(y...);
}
void scan() {}
template <class A, class... B>
void scan(A &a, B &...b) {
gi(a), scan(b...);
}
template <class T>
void read(T first, T last) {
for (; first != last; ++first) gi(*first);
}
template <class T>
void write(T first, T last) {
for (; first != last; putc(++first == last ? '\n' : ' ')) print(*first);
}
template <class T>
void show(T x) {
print(x), putc('\n');
}
template <class A, class... B>
void show(A a, B... b) {
print(a), putc(' '), show(b...);
}
template <class T>
inline T abs(T x) {
return x < 0 ? -x : x;
}
const int N = 255, M = 1e5 + 5;
template <class T>
bool chkmin(T &x, T y) {
return y < x ? x = y, true : false;
}
template <class T>
bool chkmax(T &x, T y) {
return x < y ? x = y, true : false;
}
int f[N][N][N], n, q, l[3];
char s[M], ch[3][N];
int go[M][26];
int main() {
scanf("%d%d", &n, &q);
scanf("%s", s + 1);
for (int i = 0; i < 26; ++i) go[n + 1][i] = go[n + 2][i] = n + 1;
for (int i = n; i >= 1; --i) {
memcpy(go[i], go[i + 1], sizeof(go[i + 1]));
go[i][s[i] - 'a'] = i;
}
f[0][0][0] = 0;
while (q--) {
char op[5];
int x;
scanf("%s", op);
if (*op == '+') {
scanf("%d", &x);
--x;
scanf("%s", op);
ch[x][++l[x]] = *op;
int i, j, k;
for (i = x == 0 ? l[0] : 0; i <= l[0]; ++i)
for (j = x == 1 ? l[1] : 0; j <= l[1]; ++j)
for (k = x == 2 ? l[2] : 0; k <= l[2]; ++k) {
f[i][j][k] = n + 1;
if (i) chkmin(f[i][j][k], go[f[i - 1][j][k] + 1][ch[0][i] - 'a']);
if (j) chkmin(f[i][j][k], go[f[i][j - 1][k] + 1][ch[1][j] - 'a']);
if (k) chkmin(f[i][j][k], go[f[i][j][k - 1] + 1][ch[2][k] - 'a']);
}
} else {
scanf("%d", &x);
--x;
--l[x];
}
if (f[l[0]][l[1]][l[2]] <= n)
puts("YES");
else
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
inline int read();
const int M = 100016, MOD = 1000000007;
int n;
int pxx[M][128];
char str[M];
char s[4][256];
int l[4];
int dp[256][256][256];
void update(int i, int j, int k) {
dp[i][j][k] = MOD;
if (i && dp[i - 1][j][k] < n)
dp[i][j][k] = min(dp[i][j][k], pxx[dp[i - 1][j][k] + 1][(int)s[1][i - 1]]);
if (j && dp[i][j - 1][k] < n)
dp[i][j][k] = min(dp[i][j][k], pxx[dp[i][j - 1][k] + 1][(int)s[2][j - 1]]);
if (k && dp[i][j][k - 1] < n)
dp[i][j][k] = min(dp[i][j][k], pxx[dp[i][j][k - 1] + 1][(int)s[3][k - 1]]);
}
int main(void) {
n = read();
int q = read();
scanf("%s", str);
getchar();
memset(pxx, 0x3f, sizeof(pxx));
for (int i = n - 1; i >= 0; --i) {
for (int c = 'a'; c <= 'z'; ++c) pxx[i][c] = pxx[i + 1][c];
pxx[i][(int)str[i]] = i;
}
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0] = -1;
while (q--) {
char op = getchar();
int p = read();
if (op == '+') {
s[p][l[p]++] = getchar();
getchar();
if (p == 1) {
int i = l[1];
for (int j = 0; j <= l[2]; ++j)
for (int k = 0; k <= l[3]; ++k) update(i, j, k);
}
if (p == 2) {
int j = l[2];
for (int i = 0; i <= l[1]; ++i)
for (int k = 0; k <= l[3]; ++k) update(i, j, k);
}
if (p == 3) {
int k = l[3];
for (int i = 0; i <= l[1]; ++i)
for (int j = 0; j <= l[2]; ++j) update(i, j, k);
}
} else {
--l[p];
}
printf("%s\n", dp[l[1]][l[2]][l[3]] < n ? "YES" : "NO");
}
return 0;
}
inline 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;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int infi = 1147483600;
const long long infl = 4e18 + 5;
const char ENDL = '\n';
const long long MOD = 998244353;
int n, q;
vector<vector<int>> t(3);
int dp[255][255][255];
int nex[26][100005];
vector<multiset<int>> idx(26);
void update(int i, int j, int k) {
dp[i][j][k] = n;
if (i > 0) {
int c = t[0][i];
dp[i][j][k] = min(dp[i][j][k], nex[c][dp[i - 1][j][k] + 1]);
}
if (j > 0) {
int c = t[1][j];
dp[i][j][k] = min(dp[i][j][k], nex[c][dp[i][j - 1][k] + 1]);
}
if (k > 0) {
int c = t[2][k];
dp[i][j][k] = min(dp[i][j][k], nex[c][dp[i][j][k - 1] + 1]);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> q;
string s;
cin >> s;
for (int i = 0; i < (int)n; i++) idx[s[i] - 'a'].insert(i);
for (int i = 0; i < (int)26; i++) idx[i].insert(n);
for (int i = 0; i < (int)26; i++) {
auto itr = idx[i].begin();
for (int j = 0; j < (int)n; j++) {
if (*itr < j) itr++;
nex[i][j] = *itr;
}
for (int j = (int)n; j < (int)n + 4; j++) nex[i][j] = n;
}
dp[0][0][0] = -1;
for (int i = 0; i < (int)3; i++) t[i].emplace_back(-1);
for (int xx = 0; xx < (int)q; xx++) {
char x;
cin >> x;
if (x == '+') {
int d;
cin >> d;
d--;
char c;
cin >> c;
t[d].emplace_back(c - 'a');
if (d == 0) {
int i = t[0].size() - 1;
for (int j = 0; j < (int)t[1].size(); j++)
for (int k = 0; k < (int)t[2].size(); k++) update(i, j, k);
} else if (d == 1) {
int j = t[1].size() - 1;
for (int i = 0; i < (int)t[0].size(); i++)
for (int k = 0; k < (int)t[2].size(); k++) update(i, j, k);
} else {
int k = t[2].size() - 1;
for (int i = 0; i < (int)t[0].size(); i++)
for (int j = 0; j < (int)t[1].size(); j++) update(i, j, k);
}
if (dp[t[0].size() - 1][t[1].size() - 1][t[2].size() - 1] < n) {
cout << "YES" << ENDL;
} else {
cout << "NO" << ENDL;
}
} else {
int d;
cin >> d;
d--;
t[d].pop_back();
if (dp[t[0].size() - 1][t[1].size() - 1][t[2].size() - 1] < n) {
cout << "YES" << ENDL;
} else {
cout << "NO" << ENDL;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr char nl = '\n';
template <class array, class B>
array&& mini(array&& a, B&& b) {
if (b < a) a = b;
return a;
}
template <class array, class B>
array&& maxi(array&& a, B&& b) {
if (b > a) a = b;
return a;
}
int first_bit(int x) { return x == 0 ? 0 : sizeof(x) * 8 - __builtin_clz(x); }
int ceil2(int x) { return x < 2 ? x : 1 << first_bit(x - 1); }
constexpr int inf = 0x3f3f3f3f;
constexpr long long inf_l = 0x3f3f3f3f3f3f3f3f;
struct Debug;
template <class T>
auto _is_debug_func(T&& x)
-> decltype(x(declval<add_lvalue_reference<Debug>::type>()), true_type{});
false_type _is_debug_func(...);
template <class T>
struct is_debug_func : decltype(_is_debug_func(declval<T>())) {};
;
template <class T>
auto _is_func(T&& x) -> decltype(x(), true_type{});
false_type _is_func(...);
template <class T>
struct is_func : decltype(_is_func(declval<T>())) {};
template <class T>
auto _is_string(T&& x) -> decltype(string(x), true_type{});
false_type _is_string(...);
template <class T>
struct is_string : decltype(_is_string(declval<T>())) {};
template <class T>
auto _is_ptr(T&& x)
-> decltype(*x, typename enable_if<is_string<T>() == false, int>::type(),
true_type{});
false_type _is_ptr(...);
template <class T>
struct is_ptr : decltype(_is_ptr(declval<T>())) {};
;
template <class T>
auto _is_container(T&& x)
-> decltype(x.begin(),
typename enable_if<is_string<T>() == false, int>::type(),
true_type{});
false_type _is_container(...);
template <class T>
struct is_container : decltype(_is_container(declval<T>())) {};
template <class Iter>
struct Off {
Iter _a, _b;
};
template <class T>
auto O(T&& x)
-> decltype(typename enable_if<is_container<T>() == true, int>::type(),
Off<decltype(x.begin())>()) {
return {x.begin(), x.end()};
}
template <class T>
auto O(T&& x)
-> decltype(typename enable_if<is_container<T>() == false, int>::type(),
x) {
return x;
}
struct Debug {
Debug() { cerr << boolalpha << fixed << setprecision(0); }
~Debug() { cerr << nl; }
Debug& operator()(int x = 1) {
for (auto _ = (0), ___ = ((x)-1); _ <= ___; ++_) *this << " ";
return *this;
}
template <class T>
auto operator<<(T&& x)
-> decltype(cerr << x,
typename enable_if<
is_func<T>() == false && is_ptr<T>() == false &&
is_integral<typename remove_reference<T>::type>() ==
true,
int>::type(),
*this) {
using L = long long;
if (abs(int(x)) == inf || abs(L(x)) == inf_l)
cerr << ((int(x) == inf || L(x) == inf_l) ? "+∞"
: (int(x) == -inf || L(x) == -inf_l) ? "-∞"
: "?");
else
cerr << x;
return *this;
}
template <class T>
auto operator<<(T&& x)
-> decltype(cerr << x,
typename enable_if<
is_func<T>() == false && is_ptr<T>() == false &&
is_integral<typename remove_reference<T>::type>() ==
false,
int>::type(),
*this) {
cerr << x;
return *this;
}
template <class T>
auto operator<<(T&& x) -> decltype(x.first, *this) {
return *this << "(" << O(x.first) << ", " << O(x.second) << ")";
}
template <class T>
auto operator<<(T&& x)
-> decltype(typename enable_if<is_container<T>() == true, int>::type(),
*this) {
*this << "{\n";
for (auto a = x.begin(); a != x.end(); ++a)
*this << " " << distance(x.begin(), a) << ": " << O(*a) << '\n';
return *this << "}";
}
template <class T>
auto operator<<(T&& x) -> decltype(x._a, *this) {
*this << "{";
for (auto a = x._a, b = x._b; a != b; ++a)
*this << O(*a) << (next(a) == b ? "" : ", ");
return *this << "}";
}
template <class T>
auto operator<<(T&& x)
-> decltype(typename enable_if<is_func<T>() == true, int>::type(),
*this) {
x();
return *this;
}
template <class T>
auto operator<<(T&& x)
-> decltype(typename enable_if<is_debug_func<T>() == true, int>::type(),
*this) {
x(*this);
return *this;
}
template <class T>
auto operator<<(T&& x)
-> decltype(typename enable_if<is_ptr<T>() == true &&
is_func<T>() == false &&
is_debug_func<T>() == false,
int>::type(),
*this) {
return *this << *x;
}
};
struct DebugOff {
template <class T>
DebugOff& operator<<(T&&) {
return *this;
}
DebugOff& operator()(int = 0) { return *this; }
};
using VI = vector<int>;
using VVI = vector<VI>;
using L = long long;
using VL = vector<L>;
using VB = vector<bool>;
using II = pair<int, int>;
using VII = vector<II>;
using VVII = vector<VII>;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
string s;
cin >> s;
int alfa = 26;
vector<vector<int>> nxt(n + 1, vector<int>(alfa, n + 1));
vector<int> last(alfa, n + 1);
for (auto i = ((n)-1), i__ = (0); i >= i__; --i) {
nxt[i + 1] = last;
last[int(s[i] - 'a')] = i + 1;
}
nxt[0] = last;
DebugOff() << "nxt"
": "
<< nxt << " ";
auto znak = [&](char c) { return int(c - 'a'); };
int mxSize = 253;
vector<string> in(3);
vector<vector<vector<int>>> dp(
mxSize, vector<vector<int>>(mxSize, vector<int>(mxSize, n + 1)));
dp[0][0][0] = 0;
auto calcDP = [&](int i, int j, int k) {
if (i == 0 && j == 0 && k == 0) {
dp[i][j][k] = 0;
return;
}
dp[i][j][k] = n + 1;
if (i != 0 && dp[i - 1][j][k] != n + 1)
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i - 1][j][k]][znak(in[0][i - 1])]);
if (j != 0 && dp[i][j - 1][k] != n + 1)
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j - 1][k]][znak(in[1][j - 1])]);
if (k != 0 && dp[i][j][k - 1] != n + 1)
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j][k - 1]][znak(in[2][k - 1])]);
};
while (q-- > 0) {
char c;
int id;
cin >> c >> id;
--id;
if (c == '+') {
char xx;
cin >> xx;
in[id] += xx;
int x = ((int)in[0].size()), y = ((int)in[1].size()),
z = ((int)in[2].size());
if (id == 0)
for (auto j = (0), j__ = (y); j <= j__; ++j)
for (auto k = (0), k__ = (z); k <= k__; ++k) calcDP(x, j, k);
else if (id == 1)
for (auto i = (0), i__ = (x); i <= i__; ++i)
for (auto k = (0), k__ = (z); k <= k__; ++k) calcDP(i, y, k);
else if (id == 2)
for (auto i = (0), i__ = (x); i <= i__; ++i)
for (auto j = (0), j__ = (y); j <= j__; ++j) calcDP(i, j, z);
DebugOff() << "dp"
": "
<< dp << " ";
cout << (dp[x][y][z] == n + 1 ? "NO" : "YES") << '\n';
} else {
in[id].pop_back();
int x = ((int)in[0].size()), y = ((int)in[1].size()),
z = ((int)in[2].size());
cout << (dp[x][y][z] == n + 1 ? "NO" : "YES") << '\n';
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int MAX_N = 255;
const int MAGIC_CONST = 1e9 + 20;
const long long mod = 1e9 + 7;
int n, q;
string s;
vector<vector<int>> letters;
vector<vector<vector<int>>> dp(
MAX_N, vector<vector<int>>(MAX_N, vector<int>(MAX_N, MAGIC_CONST)));
int curx = 0, cury = 0, curz = 0;
vector<deque<char>> d;
bool add_letter(char c, int idx) {
d[idx - 1].push_back(c);
if (idx == 1) {
curx++;
for (int yt = 0; yt <= cury; yt++) {
for (int zt = 0; zt <= curz; zt++) {
dp[curx][yt][zt] = MAGIC_CONST;
}
}
for (int yt = 0; yt <= cury; yt++) {
for (int zt = 0; zt <= curz; zt++) {
auto lb = upper_bound(letters[c].begin(), letters[c].end(),
dp[curx - 1][yt][zt]);
if (lb != letters[c].end()) dp[curx][yt][zt] = *lb;
if (yt != 0) {
char l = d[1][yt - 1];
lb = upper_bound(letters[l].begin(), letters[l].end(),
dp[curx][yt - 1][zt]);
if (lb != letters[l].end())
dp[curx][yt][zt] = min(dp[curx][yt][zt], *lb);
}
if (zt != 0) {
char l = d[2][zt - 1];
lb = upper_bound(letters[l].begin(), letters[l].end(),
dp[curx][yt][zt - 1]);
if (lb != letters[l].end())
dp[curx][yt][zt] = min(dp[curx][yt][zt], *lb);
}
}
}
}
if (idx == 2) {
cury++;
for (int xt = 0; xt <= curx; xt++) {
for (int zt = 0; zt <= curz; zt++) {
dp[xt][cury][zt] = MAGIC_CONST;
}
}
for (int xt = 0; xt <= curx; xt++) {
for (int zt = 0; zt <= curz; zt++) {
auto lb = upper_bound(letters[c].begin(), letters[c].end(),
dp[xt][cury - 1][zt]);
if (lb != letters[c].end()) dp[xt][cury][zt] = *lb;
if (xt != 0) {
char l = d[0][xt - 1];
lb = upper_bound(letters[l].begin(), letters[l].end(),
dp[xt - 1][cury][zt]);
if (lb != letters[l].end())
dp[xt][cury][zt] = min(dp[xt][cury][zt], *lb);
}
if (zt != 0) {
char l = d[2][zt - 1];
lb = upper_bound(letters[l].begin(), letters[l].end(),
dp[xt][cury][zt - 1]);
if (lb != letters[l].end())
dp[xt][cury][zt] = min(dp[xt][cury][zt], *lb);
}
}
}
}
if (idx == 3) {
curz++;
for (int xt = 0; xt <= curx; xt++) {
for (int yt = 0; yt <= cury; yt++) {
dp[xt][yt][curz] = MAGIC_CONST;
}
}
for (int xt = 0; xt <= curx; xt++) {
for (int yt = 0; yt <= cury; yt++) {
auto lb = upper_bound(letters[c].begin(), letters[c].end(),
dp[xt][yt][curz - 1]);
if (lb != letters[c].end()) dp[xt][yt][curz] = *lb;
if (xt != 0) {
char l = d[0][xt - 1];
lb = upper_bound(letters[l].begin(), letters[l].end(),
dp[xt - 1][yt][curz]);
if (lb != letters[l].end())
dp[xt][yt][curz] = min(dp[xt][yt][curz], *lb);
}
if (yt != 0) {
char l = d[1][yt - 1];
lb = upper_bound(letters[l].begin(), letters[l].end(),
dp[xt][yt - 1][curz]);
if (lb != letters[l].end())
dp[xt][yt][curz] = min(dp[xt][yt][curz], *lb);
}
}
}
}
return dp[curx][cury][curz] != MAGIC_CONST;
}
bool delete_letter(int idx) {
if (idx == 1) curx--;
if (idx == 2) cury--;
if (idx == 3) curz--;
d[idx - 1].pop_back();
return dp[curx][cury][curz] != MAGIC_CONST;
}
void solve() {
cin >> n >> q;
letters.resize('z' - 'a' + 1);
cin >> s;
dp[0][0][0] = -1;
d.resize(3);
for (int i = 0; i < n; i++) {
letters[s[i] - 'a'].push_back(i);
}
for (int i = 0; i < q; i++) {
char c1;
int idx;
cin >> c1 >> idx;
if (c1 == '-') {
if (delete_letter(idx)) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
} else {
char c2;
cin >> c2;
if (add_letter(c2 - 'a', idx)) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
srand(58164);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int nxt[100010][26];
int len[4];
int dp[260][260][260];
char s[100010];
int t[4][260];
int n, q;
void update(int id) {
for (int i = id == 1 ? len[1] : 0; i <= len[1]; i++) {
for (int j = id == 2 ? len[2] : 0; j <= len[2]; j++) {
for (int k = id == 3 ? len[3] : 0; k <= len[3]; k++) {
dp[i][j][k] = 1e9;
if (i && dp[i - 1][j][k] != 1e9)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k] + 1][t[1][i] - 'a']);
if (j && dp[i][j - 1][k] != 1e9)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k] + 1][t[2][j] - 'a']);
if (k && dp[i][j][k - 1] != 1e9)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1] + 1][t[3][k] - 'a']);
}
}
}
}
int main() {
cin >> n >> q;
scanf("%s", s + 1);
for (int i = 0; i < 26; i++) {
for (int j = n + 1; j >= 1; j--) {
if (j == n + 1)
nxt[j][i] = 1e9;
else {
if (s[j] != 'a' + i)
nxt[j][i] = nxt[j + 1][i];
else
nxt[j][i] = j;
}
}
}
char sign, c;
int id;
for (int i = 0; i < q; i++) {
cin >> sign;
if (sign == '+') {
cin >> id >> c;
len[id]++;
t[id][len[id]] = c;
update(id);
} else {
cin >> id;
len[id]--;
}
if (dp[len[1]][len[2]][len[3]] != 1e9) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int infty = 1e9;
vector<vector<int> > let(26);
vector<string> w(3, "");
vector<vector<vector<int> > > dp(260,
vector<vector<int> >(260,
vector<int>(260, -10)));
int pos(int x, int y, int z) {
if (dp[x][y][z] == -10) {
dp[x][y][z] = infty;
if (x > 0) {
int xr = w[0][x - 1] - 'a';
auto it = upper_bound(let[xr].begin(), let[xr].end(), pos(x - 1, y, z));
if (it != let[xr].end()) dp[x][y][z] = min(dp[x][y][z], *it);
}
if (y > 0) {
int xr = w[1][y - 1] - 'a';
auto it = upper_bound(let[xr].begin(), let[xr].end(), pos(x, y - 1, z));
if (it != let[xr].end()) dp[x][y][z] = min(dp[x][y][z], *it);
}
if (z > 0) {
int xr = w[2][z - 1] - 'a';
auto it = upper_bound(let[xr].begin(), let[xr].end(), pos(x, y, z - 1));
if (it != let[xr].end()) dp[x][y][z] = min(dp[x][y][z], *it);
}
}
return dp[x][y][z];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, q;
cin >> n >> q;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
let[s[i] - 'a'].push_back(i);
}
dp[0][0][0] = -1;
while (q--) {
char t;
cin >> t;
if (t == '+') {
int a;
char l;
cin >> a >> l;
a--;
w[a] += l;
} else {
int a;
cin >> a;
a--;
int x = w[a].size();
w[a].pop_back();
if (a == 0) {
for (int i = 0; i <= w[1].size(); i++)
for (int j = 0; j <= w[2].size(); j++) dp[x][i][j] = -10;
} else if (a == 1) {
for (int i = 0; i <= w[0].size(); i++)
for (int j = 0; j <= w[2].size(); j++) dp[i][x][j] = -10;
} else if (a == 2) {
for (int i = 0; i <= w[0].size(); i++)
for (int j = 0; j <= w[1].size(); j++) dp[i][j][x] = -10;
}
}
if (pos(w[0].size(), w[1].size(), w[2].size()) == infty)
cout << "NO\n";
else
cout << "YES\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long inf64 = 1e18;
const int N = 260;
const int L = 1e5 + 50;
const int ALPH = 26;
int n, q;
string a, b, c;
int la, lb, lc;
int dp[N][N][N];
string word;
int nxt[L][ALPH];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
cin >> word;
fill((int*)nxt, (int*)nxt + L * ALPH, n + 2);
for (int i = (int)word.size() - 1; i >= 0; i--) {
for (int j = 0; j < ALPH; j++) {
nxt[i][j] = nxt[i + 1][j];
}
nxt[i][word[i] - 'a'] = i;
}
la = lb = lc = 0;
fill((int*)dp, (int*)dp + N * N * N, n + 2);
dp[0][0][0] = 0;
for (int iter = 0; iter < q; iter++) {
char op;
int id;
char cc;
cin >> op >> id;
if (op == '+') {
cin >> cc;
if (id == 1) {
a.push_back(cc);
la++;
for (int i = la; i <= la; i++) {
for (int j = 0; j <= lb; j++) {
for (int k = 0; k <= lc; k++) {
if (i) {
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k]][a[i - 1] - 'a'] + 1);
}
if (j) {
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k]][b[j - 1] - 'a'] + 1);
}
if (k) {
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1]][c[k - 1] - 'a'] + 1);
}
}
}
}
} else if (id == 2) {
b.push_back(cc);
lb++;
for (int i = 0; i <= la; i++) {
for (int j = lb; j <= lb; j++) {
for (int k = 0; k <= lc; k++) {
if (i) {
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k]][a[i - 1] - 'a'] + 1);
}
if (j) {
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k]][b[j - 1] - 'a'] + 1);
}
if (k) {
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1]][c[k - 1] - 'a'] + 1);
}
}
}
}
} else {
c.push_back(cc);
lc++;
for (int i = 0; i <= la; i++) {
for (int j = 0; j <= lb; j++) {
for (int k = lc; k <= lc; k++) {
if (i) {
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k]][a[i - 1] - 'a'] + 1);
}
if (j) {
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k]][b[j - 1] - 'a'] + 1);
}
if (k) {
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1]][c[k - 1] - 'a'] + 1);
}
}
}
}
}
} else {
if (id == 1) {
for (int i = la; i <= la; i++) {
for (int j = 0; j <= lb; j++) {
for (int k = 0; k <= lc; k++) {
dp[i][j][k] = n + 2;
}
}
}
a.pop_back();
la--;
} else if (id == 2) {
for (int i = 0; i <= la; i++) {
for (int j = lb; j <= lb; j++) {
for (int k = 0; k <= lc; k++) {
dp[i][j][k] = n + 2;
}
}
}
b.pop_back();
lb--;
} else {
for (int i = 0; i <= la; i++) {
for (int j = 0; j <= lb; j++) {
for (int k = lc; k <= lc; k++) {
dp[i][j][k] = n + 2;
}
}
}
c.pop_back();
lc--;
}
}
cout << (dp[la][lb][lc] <= n ? "YES" : "NO") << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0LL) return b;
if (b == 0LL) return a;
return gcd(b, a % b);
}
const int N = 251;
const int N1 = 100005;
const int M = 26;
int dp[N][N][N];
int len[3];
int nxt[M][N1], n;
vector<char> r[3];
int solve1(int i0, int i1, int i2) {
if (i0 < 0 || i1 < 0 || i2 < 0) return n + 1;
if (dp[i0][i1][i2] != -1) return dp[i0][i1][i2];
int ans = n + 1;
int temp;
temp = solve1(i0 - 1, i1, i2);
if (temp != n + 1) ans = min(ans, nxt[r[0][i0 - 1] - 'a'][temp]);
temp = solve1(i0, i1 - 1, i2);
if (temp != n + 1) ans = min(ans, nxt[r[1][i1 - 1] - 'a'][temp]);
temp = solve1(i0, i1, i2 - 1);
if (temp != n + 1) ans = min(ans, nxt[r[2][i2 - 1] - 'a'][temp]);
dp[i0][i1][i2] = ans;
return ans;
}
void solve() {
int q;
cin >> n >> q;
string s;
cin >> s;
for (int i = 0; i < 26; i++) nxt[i][n] = n + 1;
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] - 'a'][i] = i + 1;
}
dp[0][0][0] = 0;
for (int i = 0; i < 3; i++) {
len[i] = 0;
r[i].clear();
}
char op, c;
int ind, l1, l2;
while (q--) {
cin >> op >> ind;
ind--;
if (op == '+') {
cin >> c;
r[ind].push_back(c);
len[ind]++;
if (ind == 0) {
l1 = len[1];
l2 = len[2];
} else if (ind == 1) {
l1 = len[0];
l2 = len[2];
} else {
l1 = len[0];
l2 = len[1];
}
for (int i = 0; i <= l1; i++)
for (int j = 0; j <= l2; j++) {
if (ind == 0)
dp[len[ind]][i][j] = -1;
else if (ind == 1)
dp[i][len[ind]][j] = -1;
else
dp[i][j][len[ind]] = -1;
}
solve1(len[0], len[1], len[2]);
} else {
r[ind].pop_back();
len[ind]--;
}
if (dp[len[0]][len[1]][len[2]] <= n && dp[len[0]][len[1]][len[2]] >= 0)
cout << "YES\n";
else
cout << "NO\n";
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
clock_t clk = clock();
int t = 1;
for (int tests = 1; tests <= t; tests++) {
solve();
}
clk = clock() - clk;
cerr << "Time Elapsed: " << fixed << setprecision(10)
<< ((long double)clk) / CLOCKS_PER_SEC << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100011;
const int maxm = 253;
const int AlphaSize = 26;
char s[maxn];
int d[maxm][maxm][maxm];
int main() {
int n, q;
scanf("%d%d%s", &n, &q, s);
assert(n == strlen(s));
vector<vector<int>> Next(n + 2, vector<int>(AlphaSize));
for (int i = 0; i < AlphaSize; ++i) Next[n][i] = Next[n + 1][i] = n;
for (int i = n - 1; i >= 0; --i)
for (int j = 0; j < AlphaSize; ++j)
Next[i][j] = (s[i] - 'a' == j) ? i : Next[i + 1][j];
vector<vector<char>> ss(3);
d[0][0][0] = -1;
while (q--) {
char op, c;
int id;
scanf(" %c%d", &op, &id);
--id;
if (op == '+') {
scanf(" %c", &c);
ss[id].push_back(c);
int min0 = (id == 0) ? ss[0].size() : 0, max0 = ss[0].size();
int min1 = (id == 1) ? ss[1].size() : 0, max1 = ss[1].size();
int min2 = (id == 2) ? ss[2].size() : 0, max2 = ss[2].size();
for (int i = min0; i <= max0; ++i) {
for (int j = min1; j <= max1; ++j) {
for (int k = min2; k <= max2; ++k) {
if (i || j || k) d[i][j][k] = n;
if (i)
d[i][j][k] =
min(d[i][j][k], Next[d[i - 1][j][k] + 1][ss[0][i - 1] - 'a']);
if (j)
d[i][j][k] =
min(d[i][j][k], Next[d[i][j - 1][k] + 1][ss[1][j - 1] - 'a']);
if (k)
d[i][j][k] =
min(d[i][j][k], Next[d[i][j][k - 1] + 1][ss[2][k - 1] - 'a']);
}
}
}
} else {
ss[id].pop_back();
}
puts(d[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 + 100;
const int MAXLEN = 251;
const int oo = MAXN - 1;
int N[MAXN][26];
int s[MAXN], t[3][MAXLEN], len[3];
int d[MAXLEN][MAXLEN][MAXLEN];
int n, q;
inline void minimize(int &a, int &b) { a = min(a, b); }
void solve() {
cin >> n >> q;
for (int i = 1; i <= n; ++i) {
char a;
cin >> a;
s[i] = a - 'a';
}
for (int i = 0; i < 26; ++i) {
int last = oo;
for (int j = n; j >= 0; --j) {
N[j][i] = last;
if (j > 0 && s[j] == i) last = j;
}
N[oo][i] = oo;
}
d[0][0][0] = 0;
len[0] = len[1] = len[2] = 0;
for (int i = 0; i < q; ++i) {
char type, ch;
int num;
cin >> type >> num;
--num;
int ans = oo;
if (type == '+') {
cin >> ch;
++len[num];
t[num][len[num]] = ch - 'a';
int n1 = num, n2 = num;
for (int j = 0; j < 3; ++j)
if (j != num) n1 = j;
for (int j = 0; j < 3; ++j)
if (j != num && j != n1) n2 = j;
if (n1 > n2) swap(n1, n2);
for (int j = 0; j <= len[n1]; ++j) {
for (int k = 0; k <= len[n2]; ++k) {
if (num == 0) {
d[len[num]][j][k] = N[d[len[num] - 1][j][k]][t[num][len[num]]];
if (k > 0)
minimize(d[len[num]][j][k], N[d[len[num]][j][k - 1]][t[n2][k]]);
if (j > 0)
minimize(d[len[num]][j][k], N[d[len[num]][j - 1][k]][t[n1][j]]);
} else if (num == 1) {
d[j][len[num]][k] = N[d[j][len[num] - 1][k]][t[num][len[num]]];
if (j > 0)
minimize(d[j][len[num]][k], N[d[j - 1][len[num]][k]][t[n1][j]]);
if (k > 0)
minimize(d[j][len[num]][k], N[d[j][len[num]][k - 1]][t[n2][k]]);
} else {
d[j][k][len[num]] = N[d[j][k][len[num] - 1]][t[num][len[num]]];
if (j > 0)
minimize(d[j][k][len[num]], N[d[j - 1][k][len[num]]][t[n1][j]]);
if (k > 0)
minimize(d[j][k][len[num]], N[d[j][k - 1][len[num]]][t[n2][k]]);
}
}
}
ans = d[len[0]][len[1]][len[2]];
} else {
--len[num];
ans = d[len[0]][len[1]][len[2]];
}
if (ans <= n) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 260;
int n, q, f[N][N][N], t[3], a[3][N];
string s;
vector<int> sv[N];
int v(int i, int x) {
int c = upper_bound(sv[i].begin(), sv[i].end(), x) - sv[i].begin();
if (c == sv[i].size()) return n + 1;
return sv[i][c];
}
int F(int i, int j, int k) {
if (!i && !j && !k) return 0;
if (f[i][j][k] != -1) return f[i][j][k];
int ret = n + 1;
if (i) ret = min(ret, v(a[0][i], F(i - 1, j, k)));
if (j) ret = min(ret, v(a[1][j], F(i, j - 1, k)));
if (k) ret = min(ret, v(a[2][k], F(i, j, k - 1)));
return f[i][j][k] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
memset(f, -1, sizeof(f));
cin >> n >> q >> s;
s = ' ' + s;
for (int i = 1; i <= n; ++i) sv[s[i] - 'a'].push_back(i);
while (q--) {
char o;
cin >> o;
if (o == '+') {
int i;
char c;
cin >> i >> c;
--i;
a[i][++t[i]] = c - 'a';
} else {
int i;
cin >> i;
--i;
for (int j = 0; j <= t[(i + 1) % 3]; ++j)
for (int k = 0; k <= t[(i + 2) % 3]; ++k) {
if (!i) f[t[i]][j][k] = -1;
if (i == 1) f[k][t[i]][j] = -1;
if (i == 2) f[j][k][t[i]] = -1;
}
--t[i];
}
if (F(t[0], t[1], t[2]) <= n)
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN(100003);
string S1, S2, S3;
int F[253][253][253], n, q;
char s[MaxN], op[3], cr[3];
int to[MaxN][26];
int check(int i, int d, int j) {
if (d == 1) return to[i][S1[j] - 'a'] ? to[i][S1[j] - 'a'] : n + 1;
if (d == 2) return to[i][S2[j] - 'a'] ? to[i][S2[j] - 'a'] : n + 1;
if (d == 3) return to[i][S3[j] - 'a'] ? to[i][S3[j] - 'a'] : n + 1;
}
int main() {
scanf("%d%d%s", &n, &q, s + 1);
for (int i = n; i; i--) {
for (int j = 0; j < 26; j++) to[i][j] = to[i + 1][j];
to[i][s[i] - 'a'] = i;
}
F[0][0][0] = 1;
for (int x; q--;) {
scanf("%s%d", op, &x);
if (*op == '+') {
scanf("%s", cr);
if (x == 1) {
S1.push_back(*cr);
int k = S1.size() - 1;
for (int i = 0; i <= S2.size(); i++)
for (int j = 0; j <= S3.size(); j++) {
if (!F[k][i][j]) continue;
int t = check(F[k][i][j], 1, k);
if (t > n)
F[k + 1][i][j] = 0;
else
F[k + 1][i][j] = t + 1;
}
++k;
for (int i = 0; i <= S2.size(); i++)
for (int j = 0; j <= S3.size(); j++) {
if (!F[k][i][j]) continue;
if (i < S2.size()) {
int t = check(F[k][i][j], 2, i);
if (t <= n && (F[k][i + 1][j] == 0 || F[k][i + 1][j] > t))
F[k][i + 1][j] = t + 1;
}
if (j < S3.size()) {
int t = check(F[k][i][j], 3, j);
if (t <= n && (F[k][i][j + 1] == 0 || F[k][i][j + 1] > t))
F[k][i][j + 1] = t + 1;
}
}
}
if (x == 2) {
S2.push_back(*cr);
int k = S2.size() - 1;
for (int i = 0; i <= S1.size(); i++)
for (int j = 0; j <= S3.size(); j++) {
if (!F[i][k][j]) continue;
int t = check(F[i][k][j], 2, k);
if (t > n)
F[i][k + 1][j] = 0;
else
F[i][k + 1][j] = t + 1;
}
++k;
for (int i = 0; i <= S1.size(); i++)
for (int j = 0; j <= S3.size(); j++) {
if (!F[i][k][j]) continue;
if (i < S1.size()) {
int t = check(F[i][k][j], 1, i);
if (t <= n && (F[i + 1][k][j] == 0 || F[i + 1][k][j] > t))
F[i + 1][k][j] = t + 1;
}
if (j < S3.size()) {
int t = check(F[i][k][j], 3, j);
if (t <= n && (F[i][k][j + 1] == 0 || F[i][k][j + 1] > t))
F[i][k][j + 1] = t + 1;
}
}
}
if (x == 3) {
S3.push_back(*cr);
int k = S3.size() - 1;
for (int i = 0; i <= S1.size(); i++)
for (int j = 0; j <= S2.size(); j++) {
if (!F[i][j][k]) continue;
int t = check(F[i][j][k], 3, k);
if (t > n)
F[i][j][k + 1] = 0;
else
F[i][j][k + 1] = t + 1;
}
++k;
for (int i = 0; i <= S1.size(); i++)
for (int j = 0; j <= S2.size(); j++) {
if (!F[i][j][k]) continue;
if (i < S1.size()) {
int t = check(F[i][j][k], 1, i);
if (t <= n && (F[i + 1][j][k] == 0 || F[i + 1][j][k] > t))
F[i + 1][j][k] = t + 1;
}
if (j < S2.size()) {
int t = check(F[i][j][k], 2, j);
if (t <= n && (F[i][j + 1][k] == 0 || F[i][j + 1][k] > t))
F[i][j + 1][k] = t + 1;
}
}
}
} else {
if (x == 1) {
int k = S1.size();
for (int i = 0; i <= S2.size(); i++)
for (int j = 0; j <= S3.size(); j++) F[k][i][j] = 0;
S1.pop_back();
}
if (x == 2) {
int k = S2.size();
for (int i = 0; i <= S1.size(); i++)
for (int j = 0; j <= S3.size(); j++) F[i][k][j] = 0;
S2.pop_back();
}
if (x == 3) {
int k = S3.size();
for (int i = 0; i <= S1.size(); i++)
for (int j = 0; j <= S2.size(); j++) F[i][j][k] = 0;
S3.pop_back();
}
}
puts(F[S1.size()][S2.size()][S3.size()] ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int M = 255;
int n, q;
string buf;
int nx[N][26];
string s[3];
int f[M][M][M];
void build(int id) {
for (size_t i = (id == 0 ? s[0].size() : 0); i <= s[0].size(); i++) {
for (size_t j = (id == 1 ? s[1].size() : 0); j <= s[1].size(); j++) {
for (size_t k = (id == 2 ? s[2].size() : 0); k <= s[2].size(); k++) {
int& t = f[i][j][k];
t = n + 1;
if (i) {
t = min(t, nx[f[i - 1][j][k]][int(s[0][i - 1]) - 'a']);
}
if (j) {
t = min(t, nx[f[i][j - 1][k]][int(s[1][j - 1]) - 'a']);
}
if (k) {
t = min(t, nx[f[i][j][k - 1]][int(s[2][k - 1]) - 'a']);
}
}
}
}
}
int main() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cin >> n >> q;
cin >> buf;
for (int c = 0; c < 26; c++) {
nx[n][c] = nx[n + 1][c] = n + 1;
}
for (int i = n - 1; i >= 0; i--) {
copy_n(nx[i + 1], 26, nx[i]);
int c = int(buf[i]) - 'a';
nx[i][c] = i + 1;
}
for (int i = 0; i < q; i++) {
char ty;
int id;
cin >> ty >> id;
id--;
if (ty == '-') {
s[id].pop_back();
} else {
char c;
cin >> c;
s[id].push_back(c);
build(id);
}
if (f[s[0].size()][s[1].size()][s[2].size()] <= n) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;
int n, q, dp[255][255][255];
char s[100015], t[4][255];
int num[3];
vector<int> v[27];
int main() {
scanf("%d%d %s", &n, &q, s + 1);
for (int i = 1; i <= n; ++i) {
v[s[i] - 'a'].push_back(i);
}
memset(dp, INF, sizeof(dp));
dp[0][0][0] = 0;
for (int i = 1; i <= q; ++i) {
char op, c;
int k;
scanf(" %c", &op);
if ('+' == op) {
scanf("%d %c", &k, &c);
t[k][++num[k]] = c;
if (1 == k) {
for (int j = 0; j <= num[2]; ++j) {
for (int l = 0; l <= num[3]; ++l) {
dp[num[k]][j][l] = INF;
int id = t[k][num[k]] - 'a';
int sta = dp[num[k] - 1][j][l];
vector<int>::iterator it =
upper_bound(v[id].begin(), v[id].end(), sta);
if (it != v[id].end()) {
dp[num[k]][j][l] = min(dp[num[k]][j][l], *it);
}
if (j) {
id = t[2][j] - 'a';
sta = dp[num[k]][j - 1][l];
it = upper_bound(v[id].begin(), v[id].end(), sta);
if (it != v[id].end()) {
dp[num[k]][j][l] = min(dp[num[k]][j][l], *it);
}
}
if (l) {
id = t[3][l] - 'a';
sta = dp[num[k]][j][l - 1];
it = upper_bound(v[id].begin(), v[id].end(), sta);
if (it != v[id].end()) {
dp[num[k]][j][l] = min(dp[num[k]][j][l], *it);
}
}
}
}
} else if (2 == k) {
for (int i = 0; i <= num[1]; ++i) {
for (int l = 0; l <= num[3]; ++l) {
dp[i][num[k]][l] = INF;
int id = t[k][num[k]] - 'a';
int sta = dp[i][num[k] - 1][l];
vector<int>::iterator it =
upper_bound(v[id].begin(), v[id].end(), sta);
if (it != v[id].end()) {
dp[i][num[k]][l] = min(dp[i][num[k]][l], *it);
}
if (i) {
id = t[1][i] - 'a';
sta = dp[i - 1][num[k]][l];
it = upper_bound(v[id].begin(), v[id].end(), sta);
if (it != v[id].end()) {
dp[i][num[k]][l] = min(dp[i][num[k]][l], *it);
}
}
if (l) {
id = t[3][l] - 'a';
sta = dp[i][num[k]][l - 1];
it = upper_bound(v[id].begin(), v[id].end(), sta);
if (it != v[id].end()) {
dp[i][num[k]][l] = min(dp[i][num[k]][l], *it);
}
}
}
}
} else {
for (int i = 0; i <= num[1]; ++i) {
for (int j = 0; j <= num[2]; ++j) {
dp[i][j][num[k]] = INF;
int id = t[k][num[k]] - 'a';
int sta = dp[i][j][num[k] - 1];
vector<int>::iterator it =
upper_bound(v[id].begin(), v[id].end(), sta);
if (it != v[id].end()) {
dp[i][j][num[k]] = min(dp[i][j][num[k]], *it);
}
if (i) {
id = t[1][i] - 'a';
sta = dp[i - 1][j][num[k]];
it = upper_bound(v[id].begin(), v[id].end(), sta);
if (it != v[id].end()) {
dp[i][j][num[k]] = min(dp[i][j][num[k]], *it);
}
}
if (j) {
id = t[2][j] - 'a';
sta = dp[i][j - 1][num[k]];
it = upper_bound(v[id].begin(), v[id].end(), sta);
if (it != v[id].end()) {
dp[i][j][num[k]] = min(dp[i][j][num[k]], *it);
}
}
}
}
}
} else {
scanf("%d", &k);
--num[k];
}
puts(dp[num[1]][num[2]][num[3]] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e5 + 7;
const int Maxm = 252;
string a[4];
char s[Maxn], op[2], app[2];
int nxt[Maxn][26], g[4], dp[Maxm][Maxm][Maxm];
int main() {
int n, q, i;
scanf("%d%d%s", &n, &q, s + 1);
a[1] = a[2] = a[3] = "0";
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)
if (s[i + 1] == j + 'a')
nxt[i][j] = i + 1;
else
nxt[i][j] = nxt[i + 1][j];
}
while (q--) {
scanf("%s%d", op, &i);
if (op[0] == '+') {
scanf("%s", app);
a[i] += app[0];
int h = app[0] - 'a';
if (i == 1) {
int t = a[1].size() - 1;
for (int j = 0; j < a[2].size(); ++j) {
for (int k = 0; k < a[3].size(); ++k) {
dp[t][j][k] = nxt[dp[t - 1][j][k]][h];
if (j && nxt[dp[t][j - 1][k]][a[2][j] - 'a'] < dp[t][j][k])
dp[t][j][k] = nxt[dp[t][j - 1][k]][a[2][j] - 'a'];
if (k && nxt[dp[t][j][k - 1]][a[3][k] - 'a'] < dp[t][j][k])
dp[t][j][k] = nxt[dp[t][j][k - 1]][a[3][k] - 'a'];
}
}
} else if (i == 2) {
int t = a[2].size() - 1;
for (int j = 0; j < a[1].size(); ++j) {
for (int k = 0; k < a[3].size(); ++k) {
dp[j][t][k] = nxt[dp[j][t - 1][k]][h];
if (j && nxt[dp[j - 1][t][k]][a[1][j] - 'a'] < dp[j][t][k])
dp[j][t][k] = nxt[dp[j - 1][t][k]][a[1][j] - 'a'];
if (k && nxt[dp[j][t][k - 1]][a[3][k] - 'a'] < dp[j][t][k])
dp[j][t][k] = nxt[dp[j][t][k - 1]][a[3][k] - 'a'];
}
}
} else {
int t = a[3].size() - 1;
for (int j = 0; j < a[1].size(); ++j) {
for (int k = 0; k < a[2].size(); ++k) {
dp[j][k][t] = nxt[dp[j][k][t - 1]][h];
if (j && nxt[dp[j - 1][k][t]][a[1][j] - 'a'] < dp[j][k][t])
dp[j][k][t] = nxt[dp[j - 1][k][t]][a[1][j] - 'a'];
if (k && nxt[dp[j][k - 1][t]][a[2][k] - 'a'] < dp[j][k][t])
dp[j][k][t] = nxt[dp[j][k - 1][t]][a[2][k] - 'a'];
}
}
}
} else
a[i].pop_back();
puts(dp[a[1].size() - 1][a[2].size() - 1][a[3].size() - 1] <= n ? "YES"
: "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int dp[261][261][261];
char s[261];
int nxt[100010][26];
int pos[30];
int len[4];
vector<char> res[4];
int n, q;
int ok = 0;
int update(int i, int j, int k) {
dp[i][j][k] = n + 1;
if (i and dp[i - 1][j][k] != n + 1) {
int pos = dp[i - 1][j][k];
char ss = res[1][i - 1];
dp[i][j][k] = min(dp[i][j][k], nxt[pos][ss - 'a']);
}
if (j and dp[i][j - 1][k] != n + 1) {
int pos = dp[i][j - 1][k];
char ss = res[2][j - 1];
dp[i][j][k] = min(dp[i][j][k], nxt[pos][ss - 'a']);
}
if (k and dp[i][j][k - 1] != n + 1) {
int pos = dp[i][j][k - 1];
char ss = res[3][k - 1];
dp[i][j][k] = min(dp[i][j][k], nxt[pos][ss - 'a']);
}
}
int main() {
cin >> n >> q;
scanf("%s", s + 1);
for (int i = 0; i < 26; i++) pos[i] = n + 1;
for (int i = n; i >= 0; i--) {
for (int j = 0; j < 26; j++) nxt[i][j] = pos[j];
if (i) pos[s[i] - 'a'] = i;
}
dp[0][0][0] = 0;
while (q--) {
char ss;
scanf(" %c", &ss);
if (ss == '-') {
int st;
scanf("%d", &st);
len[st]--;
res[st].pop_back();
} else {
int st;
scanf("%d %c", &st, &ss);
res[st].push_back(ss);
len[st]++;
if (st == 1) {
for (int i = 0; i <= len[2]; i++)
for (int j = 0; j <= len[3]; j++) {
update(len[1], i, j);
}
}
if (st == 2) {
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[3]; j++) {
update(i, len[2], j);
}
}
if (st == 3) {
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[2]; j++) {
update(i, j, len[3]);
}
}
}
if (dp[len[1]][len[2]][len[3]] != n + 1)
puts("YES");
else
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
char s[100100], ss[4][100100];
int nxt[100100][26], N[4];
int dp[255][255][255], n;
inline void calc(int a_st, int a_ed, int b_st, int b_ed, int c_st, int c_ed) {
for (int i = a_st; i <= a_ed; i++) {
for (int j = b_st; j <= b_ed; j++) {
for (int k = c_st; k <= c_ed; k++) {
if (!i && !j && !k)
dp[i][j][k] = 0;
else {
dp[i][j][k] = 0x3f3f3f3f;
if (i && dp[i - 1][j][k] < n)
smin(dp[i][j][k], nxt[dp[i - 1][j][k] + 1][ss[1][i] - 'a']);
if (j && dp[i][j - 1][k] < n)
smin(dp[i][j][k], nxt[dp[i][j - 1][k] + 1][ss[2][j] - 'a']);
if (k && dp[i][j][k - 1] < n)
smin(dp[i][j][k], nxt[dp[i][j][k - 1] + 1][ss[3][k] - 'a']);
}
}
}
}
}
int main() {
int q;
scanf("%d %d %s", &n, &q, s + 1);
for (int i = 26; i--;) nxt[n + 1][i] = n + 1;
for (int i = n; i >= 1; i--) {
for (int j = 26; j--;) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i] - 'a'] = i;
}
while (q--) {
char c;
scanf(" %c", &c);
if (c == '+') {
int id;
scanf("%d %c", &id, &c);
ss[id][++N[id]] = c;
if (id == 1) calc(N[1], N[1], 0, N[2], 0, N[3]);
if (id == 2) calc(0, N[1], N[2], N[2], 0, N[3]);
if (id == 3) calc(0, N[1], 0, N[2], N[3], N[3]);
} else {
int id;
scanf("%d", &id);
N[id]--;
}
puts(dp[N[1]][N[2]][N[3]] <= n ? "YES" : "NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 260;
const int S = 1e5 + 5;
const int inf = 1e9 + 7;
int n, q, tmp;
int nxt[S][N], pos[30], dp[N][N][N];
int s1[N], s2[N], s3[N], l1 = 0, l2 = 0, l3 = 0;
char s[S], opt[10], ch[10];
void Init() {
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++) dp[i][j][k] = n + 1;
for (int i = 0; i < 26; i++) pos[i] = n + 1;
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j < 26; j++) nxt[i][j] = n + 1;
dp[0][0][0] = 0;
for (int i = n; i >= 0; i--) {
for (int j = 0; j < 26; j++) nxt[i][j] = pos[j];
pos[s[i] - 'a'] = i;
}
return;
}
void DO(int i, int j, int k) {
if (i > 0) dp[i][j][k] = min(dp[i][j][k], nxt[dp[i - 1][j][k]][s1[i]]);
if (j > 0) dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j - 1][k]][s2[j]]);
if (k > 0) dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j][k - 1]][s3[k]]);
return;
}
int main() {
scanf("%d%d", &n, &q);
scanf("%s", s + 1);
Init();
while (q--) {
scanf("%s", opt + 1);
scanf("%d", &tmp);
switch (opt[1]) {
case '+':
scanf("%s", ch + 1);
if (tmp == 1) {
s1[++l1] = ch[1] - 'a';
int i = l1;
for (int j = 0; j <= l2; j++)
for (int k = 0; k <= l3; k++) DO(i, j, k);
} else if (tmp == 2) {
s2[++l2] = ch[1] - 'a';
int j = l2;
for (int i = 0; i <= l1; i++)
for (int k = 0; k <= l3; k++) DO(i, j, k);
} else {
s3[++l3] = ch[1] - 'a';
int k = l3;
for (int i = 0; i <= l1; i++)
for (int j = 0; j <= l2; j++) DO(i, j, k);
}
break;
case '-':
if (tmp == 1) {
int i = l1;
for (int j = 0; j <= l2; j++)
for (int k = 0; k <= l3; k++) dp[i][j][k] = n + 1;
l1--;
} else if (tmp == 2) {
int j = l2;
for (int i = 0; i <= l1; i++)
for (int k = 0; k <= l3; k++) dp[i][j][k] = n + 1;
l2--;
} else {
int k = l3;
for (int i = 0; i <= l1; i++)
for (int j = 0; j <= l2; j++) dp[i][j][k] = n + 1;
l3--;
}
break;
}
if (dp[l1][l2][l3] <= 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 T>
bool get_int(T &x) {
char t = getchar();
bool neg = false;
x = 0;
for (; (t > '9' || t < '0') && t != '-' && t != EOF; t = getchar())
;
if (t == '-') neg = true, t = getchar();
if (t == EOF) return false;
for (; t <= '9' && t >= '0'; t = getchar()) x = x * 10 + t - '0';
if (neg) x = -x;
return true;
}
template <typename T>
void print_int(T x) {
if (x < 0) putchar('-'), x = -x;
short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
const int inf = 0x3f3f3f3f;
const long long Linf = 1ll << 61;
const double pi = acos(-1.0);
const int maxn = 100111;
char s[maxn], t[3][maxn];
int n, q, l[3], nxt[maxn][26];
int val[311][311][311];
void recalc(int u, int v, int w) {
int nv = n + 1;
if (u) nv = min(nv, nxt[min(n, val[u - 1][v][w]) + 1][t[0][u] - 'a']);
if (v) nv = min(nv, nxt[min(n, val[u][v - 1][w]) + 1][t[1][v] - 'a']);
if (w) nv = min(nv, nxt[min(n, val[u][v][w - 1]) + 1][t[2][w] - 'a']);
val[u][v][w] = nv;
}
int main() {
scanf("%d%d", &n, &q);
scanf("%s", s + 1);
for (int i = 0; i < 26; i++) nxt[n + 1][i] = n + 1;
for (int i = n; i >= 1; i--) {
memcpy(nxt[i], nxt[i + 1], sizeof(nxt[i]));
nxt[i][s[i] - 'a'] = i;
}
char op[5], opv[5];
int id;
while (q--) {
scanf("%s%d", op, &id);
id--;
if (op[0] == '-')
l[id]--;
else {
scanf("%s", opv);
t[id][++l[id]] = opv[0];
int lb[3] = {0, 0, 0}, rb[3] = {l[0], l[1], l[2]};
lb[id] = rb[id] = l[id];
for (int t0 = lb[0]; t0 <= rb[0]; t0++)
for (int t1 = lb[1]; t1 <= rb[1]; t1++)
for (int t2 = lb[2]; t2 <= rb[2]; t2++) recalc(t0, t1, t2);
}
if (val[l[0]][l[1]][l[2]] <= n)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nsz = 1e5, msz = 250, inf = 0x3f3f3f3f;
int n, m, s[nsz + 5], t[3][nsz + 5], b[nsz + 5], nxt[nsz + 5][26],
dp[msz + 5][msz + 5][msz + 5], sz[3];
int inline read() {
int res = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); res *= 10, res += c ^ 48, c = getchar())
;
return res;
}
char inline readc() {
char c = getchar();
for (; c != '-' && c != '+' && !isalpha(c); c = getchar())
;
return c;
}
void inline readstr() {
int sz = 0;
char c = getchar();
for (; !isalpha(c); c = getchar())
;
for (; isalpha(c); s[++sz] = c - 'a', c = getchar())
;
}
int inline min(int a, int b, int c, int d) { return min(min(a, b), min(c, d)); }
void inline upd(int id) {
int from[3] = {0, 0, 0};
from[id] = sz[id] - 1;
for (int i = from[0]; i <= sz[0]; ++i) {
for (int j = from[1]; j <= sz[1]; ++j) {
for (int k = from[2]; k <= sz[2]; ++k) {
if (!i && !j && !k) continue;
dp[i][j][k] = min(inf,
dp[i - 1][j][k] <= n && i && t[0][i] != -1
? nxt[dp[i - 1][j][k]][t[0][i]]
: inf,
dp[i][j - 1][k] <= n && j && t[1][j] != -1
? nxt[dp[i][j - 1][k]][t[1][j]]
: inf,
dp[i][j][k - 1] <= n && k && t[2][k] != -1
? nxt[dp[i][j][k - 1]][t[2][k]]
: inf);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
n = read();
m = read();
readstr();
memset(b, inf, sizeof(b));
memset(dp, inf, sizeof(dp));
memset(t, -1, sizeof(t));
dp[0][0][0] = 0;
for (int i = n; i >= 0; --i) {
for (int c = 0; c < 26; ++c) {
nxt[i][c] = b[c];
if (c == s[i]) {
b[c] = i;
}
}
}
for (int i = 1; i <= m; ++i) {
char cmd = readc();
int id = read() - 1;
if (cmd == '+') {
int c = readc() - 'a';
t[id][++sz[id]] = c;
upd(id);
} else if (cmd == '-') {
t[id][sz[id]--] = -1;
}
bool flag = dp[sz[0]][sz[1]][sz[2]] <= n;
cout << (flag ? "YES" : "NO") << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
char s[N];
int l[N][26], r[N][26], g[3][N], f[251][251][251];
int q, n;
void update(int *x, int v) {
if (!*x || *x > v) *x = v;
}
int main() {
scanf("%d %d", &n, &q);
scanf(" %s", s + 1);
for (int i = 1; i <= n; i++) {
s[i] -= 'a';
for (int j = 0; j < 26; j++) l[i][j] = l[i - 1][j];
if (i != 1) l[i][s[i - 1]] = i - 1;
}
for (int i = n; i >= 0; i--) {
for (int j = 0; j < 26; j++) r[i][j] = r[i + 1][j];
if (i != n) r[i][s[i + 1]] = i + 1;
}
while (q--) {
char sig, c;
int x;
scanf(" %c %d", &sig, &x);
x--;
if (sig == '+') {
scanf(" %c", &c), g[x][++g[x][0]] = c - 'a';
if (x == 0) {
for (int i = g[0][0] - 1; i <= g[0][0]; i++)
for (int j = 0; j <= g[1][0]; j++)
for (int k = 0; k <= g[2][0]; k++)
if (f[i][j][k] || (!i && !j && !k)) {
if (i != g[0][0] && r[f[i][j][k]][g[0][i + 1]])
update(&f[i + 1][j][k], r[f[i][j][k]][g[0][i + 1]]);
if (j != g[1][0] && r[f[i][j][k]][g[1][j + 1]])
update(&f[i][j + 1][k], r[f[i][j][k]][g[1][j + 1]]);
if (k != g[2][0] && r[f[i][j][k]][g[2][k + 1]])
update(&f[i][j][k + 1], r[f[i][j][k]][g[2][k + 1]]);
}
} else if (x == 1) {
for (int i = 0; i <= g[0][0]; i++)
for (int j = g[1][0] - 1; j <= g[1][0]; j++)
for (int k = 0; k <= g[2][0]; k++)
if (f[i][j][k] || (!i && !j && !k)) {
if (i != g[0][0] && r[f[i][j][k]][g[0][i + 1]])
update(&f[i + 1][j][k], r[f[i][j][k]][g[0][i + 1]]);
if (j != g[1][0] && r[f[i][j][k]][g[1][j + 1]])
update(&f[i][j + 1][k], r[f[i][j][k]][g[1][j + 1]]);
if (k != g[2][0] && r[f[i][j][k]][g[2][k + 1]])
update(&f[i][j][k + 1], r[f[i][j][k]][g[2][k + 1]]);
}
} else {
for (int i = 0; i <= g[0][0]; i++)
for (int j = 0; j <= g[1][0]; j++)
for (int k = g[2][0] - 1; k <= g[2][0]; k++)
if (f[i][j][k] || (!i && !j && !k)) {
if (i != g[0][0] && r[f[i][j][k]][g[0][i + 1]])
update(&f[i + 1][j][k], r[f[i][j][k]][g[0][i + 1]]);
if (j != g[1][0] && r[f[i][j][k]][g[1][j + 1]])
update(&f[i][j + 1][k], r[f[i][j][k]][g[1][j + 1]]);
if (k != g[2][0] && r[f[i][j][k]][g[2][k + 1]])
update(&f[i][j][k + 1], r[f[i][j][k]][g[2][k + 1]]);
}
}
} else {
if (x == 0) {
for (int i = 0; i <= g[1][0]; i++)
for (int j = 0; j <= g[2][0]; j++) f[g[0][0]][i][j] = 0;
} else if (x == 1) {
for (int i = 0; i <= g[0][0]; i++)
for (int j = 0; j <= g[2][0]; j++) f[i][g[1][0]][j] = 0;
} else {
for (int i = 0; i <= g[0][0]; i++)
for (int j = 0; j <= g[1][0]; j++) f[i][j][g[2][0]] = 0;
}
g[x][0]--;
}
if (f[g[0][0]][g[1][0]][g[2][0]] || (!g[0][0] && !g[1][0] && !g[2][0]))
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 100010, LOG = 20;
int n, m, k, u, v, x, y, t, a, b, ans;
int dp[251][251][251];
int sz[3];
vector<char> vec[3];
vector<int> pos[26];
string s;
char ch;
void print() {
if (dp[sz[0]][sz[1]][sz[2]] <= n)
cout << "YES\n";
else
cout << "NO\n";
}
int find_ch(int l, char c) {
return *upper_bound(pos[c - 'a'].begin(), pos[c - 'a'].end(), l);
}
void update(int sz0, int sz1, int sz2) {
dp[sz0][sz1][sz2] = n + 1;
if (sz0)
dp[sz0][sz1][sz2] =
min(dp[sz0][sz1][sz2], find_ch(dp[sz0 - 1][sz1][sz2], vec[0][sz0 - 1]));
if (sz1)
dp[sz0][sz1][sz2] =
min(dp[sz0][sz1][sz2], find_ch(dp[sz0][sz1 - 1][sz2], vec[1][sz1 - 1]));
if (sz2)
dp[sz0][sz1][sz2] =
min(dp[sz0][sz1][sz2], find_ch(dp[sz0][sz1][sz2 - 1], vec[2][sz2 - 1]));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> s;
s = "." + s;
for (int i = 1; i <= n; i++) pos[s[i] - 'a'].push_back(i);
for (int i = 0; i < 26; i++) pos[i].push_back(inf);
memset(dp, 31, sizeof(dp));
dp[0][0][0] = 0;
while (m--) {
cin >> ch;
if (ch == '-') {
cin >> x;
x--;
vec[x].pop_back();
sz[x]--;
print();
continue;
}
cin >> x >> ch;
x--;
vec[x].push_back(ch);
sz[x]++;
if (x == 0)
for (int sz1 = 0; sz1 <= sz[1]; sz1++)
for (int sz2 = 0; sz2 <= sz[2]; sz2++) update(sz[0], sz1, sz2);
if (x == 1)
for (int sz0 = 0; sz0 <= sz[0]; sz0++)
for (int sz2 = 0; sz2 <= sz[2]; sz2++) update(sz0, sz[1], sz2);
if (x == 2)
for (int sz0 = 0; sz0 <= sz[0]; sz0++)
for (int sz1 = 0; sz1 <= sz[1]; sz1++) update(sz0, sz1, sz[2]);
print();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
int a[100010];
int nex[100010][30];
int cha[30];
int dp[300][300][300];
int s[4][300], len[4];
bool flag = false;
int main() {
scanf("%d %d", &n, &q);
for (int i = 0; i < 26; i++) cha[i] = n + 1;
for (int i = 1; i <= n; i++) {
char c = getchar();
while (c < 'a' || c > 'z') c = getchar();
a[i] = c - 'a';
}
for (int i = n + 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
nex[i][j] = cha[j];
}
cha[a[i]] = i;
}
memset(len, 0, sizeof(len));
while (q--) {
char c = getchar();
while (c != '+' && c != '-') c = getchar();
int re;
scanf("%d", &re);
int num;
if (c == '+') {
c = getchar();
while (c < 'a' || c > 'z') c = getchar();
num = c - 'a';
s[re][++len[re]] = num;
int min1 = re == 1 ? len[1] : 0;
int min2 = re == 2 ? len[2] : 0;
int min3 = re == 3 ? len[3] : 0;
for (int i = min1; i <= len[1]; i++) {
for (int j = min2; j <= len[2]; j++) {
for (int k = min3; k <= len[3]; k++) {
int &val = dp[i][j][k];
val = n + 1;
if (i) val = min(val, nex[dp[i - 1][j][k]][s[1][i]]);
if (j) val = min(val, nex[dp[i][j - 1][k]][s[2][j]]);
if (k) val = min(val, nex[dp[i][j][k - 1]][s[3][k]]);
}
}
}
} else {
--len[re];
}
if (dp[len[1]][len[2]][len[3]] <= n)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[252][252][252];
char str[300300];
int nxt[26][300300];
char A[3][300300];
int ok[252][252][252];
int go(int a, int b, int c) {
if (ok[a][b][c]) return dp[a][b][c];
int ans = 300300;
if (a) ans = min(ans, nxt[A[0][a - 1] - 'a'][go(a - 1, b, c) + 1]);
if (b) ans = min(ans, nxt[A[1][b - 1] - 'a'][go(a, b - 1, c) + 1]);
if (c) ans = min(ans, nxt[A[2][c - 1] - 'a'][go(a, b, c - 1) + 1]);
ok[a][b][c] = 1;
return dp[a][b][c] = ans;
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
scanf(" %s", str);
for (int i = 0; i < 26; i++) nxt[i][n] = nxt[i][n + 1] = n;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) nxt[j][i] = nxt[j][i + 1];
nxt[str[i] - 'a'][i] = i;
}
int sz[3] = {0, 0, 0};
dp[0][0][0] = -1;
ok[0][0][0] = 1;
while (q--) {
char ch;
int id;
char add;
scanf(" %c %d", &ch, &id);
id--;
if (ch == '+') scanf(" %c", &add);
if (ch == '-') {
if (id == 0)
for (int j = 0; j <= sz[1]; j++)
for (int k = 0; k <= sz[2]; k++) ok[sz[id]][j][k] = 0;
if (id == 1)
for (int j = 0; j <= sz[0]; j++)
for (int k = 0; k <= sz[2]; k++) ok[j][sz[id]][k] = 0;
if (id == 2)
for (int j = 0; j <= sz[0]; j++)
for (int k = 0; k <= sz[1]; k++) ok[j][k][sz[id]] = 0;
sz[id]--;
} else {
A[id][sz[id]] = add;
sz[id]++;
int ans = go(sz[0], sz[1], sz[2]);
dp[sz[0]][sz[1]][sz[2]] = ans;
("dp = %d\n", ans);
}
if (dp[sz[0]][sz[1]][sz[2]] < n)
printf("YES\n");
else
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void pn(Arg1&& arg1) {
cout << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void pn(Arg1&& arg1, Args&&... args) {
cout << arg1 << "\n";
pn(args...);
}
template <typename Arg1>
void ps(Arg1&& arg1) {
cout << arg1 << " ";
}
template <typename Arg1, typename... Args>
void ps(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
ps(args...);
}
template <typename Arg1>
void rn(Arg1&& arg1) {
cin >> arg1;
}
template <typename Arg1, typename... Args>
void rn(Arg1&& arg1, Args&&... args) {
cin >> arg1;
rn(args...);
}
long long n, q;
string s;
long long dp[251][251][251];
long long table[100005][27];
string wordarray[3];
void solve() {
dp[0][0][0] = -1;
cin >> n >> q >> s;
for (long long col = 0; col < 26; col++) {
table[n][col] = n;
table[n + 1][col] = n;
}
for (long long i = s.size() - 1; i >= 0; i--) {
for (long long j = 0; j < 26; j++) {
if (s[i] == j + 'a') {
table[i][j] = i;
} else {
table[i][j] = table[i + 1][j];
}
}
}
while (q--) {
char si, c;
long long id;
cin >> si;
if (si == '+') {
cin >> id >> c;
id--;
wordarray[id] += c;
long long l1 = wordarray[0].size();
long long l2 = wordarray[1].size();
long long l3 = wordarray[2].size();
long long m1 = 0, m2 = 0, m3 = 0;
if (id == 0) {
m1 = l1;
} else if (id == 1) {
m2 = l2;
} else {
m3 = l3;
}
for (long long i = m1; i <= l1; i++) {
for (long long j = m2; j <= l2; j++) {
for (long long k = m3; k <= l3; k++) {
dp[i][j][k] = n;
if (i) {
dp[i][j][k] =
min(dp[i][j][k],
table[dp[i - 1][j][k] + 1][wordarray[0][i - 1] - 'a']);
}
if (j) {
dp[i][j][k] =
min(dp[i][j][k],
table[dp[i][j - 1][k] + 1][wordarray[1][j - 1] - 'a']);
}
if (k) {
dp[i][j][k] =
min(dp[i][j][k],
table[dp[i][j][k - 1] + 1][wordarray[2][k - 1] - 'a']);
}
}
}
}
} else {
cin >> id;
wordarray[id - 1].pop_back();
}
if (dp[wordarray[0].size()][wordarray[1].size()][wordarray[2].size()] < n) {
pn("YES");
} else {
pn("NO");
}
}
}
int main() {
clock_t z = clock();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
fprintf(stderr, "Total Time: %.7f\n", (double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
T& remin(T& a, T b) {
return a = (a < b) ? a : b;
}
namespace Solver {
const int INF = (int)1e9 + 7;
std::string s, a, b, c;
const int NMAX = 100002;
int nextPos[26][NMAX];
int minPref[251][251][251];
bool ok() {
return (minPref[(int)(a).size()][(int)(b).size()][(int)(c).size()] <=
(int)(s).size());
}
void init() {
std::fill(&nextPos[0][0], &nextPos[0][0] + 26 * NMAX, INF);
minPref[0][0][0] = 0;
for (char curChar = 'a'; curChar <= 'z'; ++curChar) {
for (int p = (int)(s).size() - 1; p >= 0; --p) {
nextPos[curChar - 'a'][p] =
(s[p] == curChar ? p : nextPos[curChar - 'a'][p + 1]);
}
}
}
void update(const int min_len_a, const int max_len_a, const int min_len_b,
const int max_len_b, const int min_len_c, const int max_len_c) {
for (int la = min_len_a; la <= max_len_a; ++la) {
for (int lb = min_len_b; lb <= max_len_b; ++lb) {
for (int lc = min_len_c; lc <= max_len_c; ++lc) {
minPref[la][lb][lc] = INF;
int prev;
if (la > 0 && (prev = minPref[la - 1][lb][lc]) < (int)(s).size()) {
remin(minPref[la][lb][lc], nextPos[a[la - 1] - 'a'][prev] + 1);
}
if (lb > 0 && (prev = minPref[la][lb - 1][lc]) < (int)(s).size()) {
remin(minPref[la][lb][lc], nextPos[b[lb - 1] - 'a'][prev] + 1);
}
if (lc > 0 && (prev = minPref[la][lb][lc - 1]) < (int)(s).size()) {
remin(minPref[la][lb][lc], nextPos[c[lc - 1] - 'a'][prev] + 1);
}
}
}
}
}
void add_char(int id, char newChar) {
if (id == 1) {
a.push_back(newChar);
update((int)(a).size(), (int)(a).size(), 0, (int)(b).size(), 0,
(int)(c).size());
} else if (id == 2) {
b.push_back(newChar);
update(0, (int)(a).size(), (int)(b).size(), (int)(b).size(), 0,
(int)(c).size());
} else {
c.push_back(newChar);
update(0, (int)(a).size(), 0, (int)(b).size(), (int)(c).size(),
(int)(c).size());
}
}
void rem_char(int id) {
if (id == 1) {
a.pop_back();
} else if (id == 2) {
b.pop_back();
} else {
c.pop_back();
}
}
} // namespace Solver
int main() {
using namespace Solver;
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int n, q;
while (std::cin >> n >> q) {
std::cin >> s;
init();
while (q--) {
char t;
int id;
std::cin >> t >> id;
if (t == '+') {
std::cin >> t;
add_char(id, t);
} else {
rem_char(id);
}
std::cout << (ok() ? "YES\n" : "NO\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0) {
putchar('-'), write(-x);
} else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 1e5 + 5, M = 255;
char p[N];
int s[4][N], nxt[N][28], f[M][M][M], n, q, len[4];
void init() {
for (int i = 0; i < 26; i++) nxt[n + 1][i] = nxt[n + 2][i] = n + 1;
for (int i = n; i; i--)
for (int j = 0; j < 26; j++) {
if (p[i] == j + 'a')
nxt[i][j] = i;
else
nxt[i][j] = nxt[i + 1][j];
}
}
void doit() {
char ch;
cin >> ch;
int id;
read(id);
if (ch == '+') {
cin >> ch;
s[id][++len[id]] = ch - 'a';
for (int i = (id == 1 ? len[1] : 0); i <= len[1]; i++)
for (int j = (id == 2 ? len[2] : 0); j <= len[2]; j++)
for (int k = (id == 3 ? len[3] : 0); k <= len[3]; k++) {
int &now = f[i][j][k];
now = n + 1;
if (i) now = min(now, nxt[f[i - 1][j][k] + 1][s[1][i]]);
if (j) now = min(now, nxt[f[i][j - 1][k] + 1][s[2][j]]);
if (k) now = min(now, nxt[f[i][j][k - 1] + 1][s[3][k]]);
}
} else {
len[id]--;
}
if (f[len[1]][len[2]][len[3]] <= n)
puts("YES");
else
puts("NO");
}
signed main() {
read(n);
read(q);
scanf("%s", p + 1);
init();
while (q--) doit();
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
using namespace std;
const int N = 1e5 + 7;
const int M = -1;
int n, len[4];
char s[N];
int t[4][N];
int dp[257][257][257], nxt[N][27];
void insert(int id, char c) {
len[id]++;
t[id][len[id]] = c - 'a';
for (int i = id == 1 ? len[1] : 0; i < (len[1] + 1); ++i) {
for (int j = id == 2 ? len[2] : 0; j < (len[2] + 1); ++j) {
for (int k = id == 3 ? len[3] : 0; k < (len[3] + 1); ++k) {
dp[i][j][k] = n + 1;
if (i) dp[i][j][k] = min(dp[i][j][k], nxt[dp[i - 1][j][k]][t[1][i]]);
if (j) dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j - 1][k]][t[2][j]]);
if (k) dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j][k - 1]][t[3][k]]);
}
}
}
}
int last[30];
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int q;
cin >> n >> q;
cin >> s + 1;
for (int i = 0; i < (26); ++i) last[i] = n + 1;
for (int i = (n + 2) - 1; i >= (0); --i) {
for (int j = 0; j < (26); ++j) nxt[i][j] = last[j];
if (i && i <= n) last[s[i] - 'a'] = i;
}
while (q--) {
char op;
int id;
cin >> op >> id;
if (op == '+') {
char c;
cin >> c;
insert(id, c);
} else {
len[id]--;
}
if (dp[len[1]][len[2]][len[3]] <= n)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
const long double PI = 3.141592653589793238462643383279502884197;
priority_queue<int, vector<int>, greater<int> > pq;
vector<char> v[3];
int dp[252][252][252];
int nxt[100003][27];
char s[100002];
int main() {
int n, q;
scanf("%d %d", &n, &q);
scanf("%s", s + 1);
for (int i = 0; i <= 26; i++) nxt[n + 1][i] = n + 1, nxt[n + 2][i] = n + 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= 26; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i] - 'a'] = i;
}
v[0].push_back(26);
v[1].push_back(26);
v[2].push_back(26);
while (q--) {
char a, c;
int b;
scanf(" %c %d", &a, &b);
b--;
if (a == '-') {
v[b].pop_back();
if (dp[(int)(v[0]).size() - 1][(int)(v[1]).size() - 1]
[(int)(v[2]).size() - 1] <= n)
printf("YES\n");
else
printf("NO\n");
continue;
}
scanf(" %c", &c);
c -= 'a';
v[b].push_back(c);
int st[3], ed[3];
for (int i = 0; i < 3; i++) {
st[i] = ed[i] = (int)(v[i]).size() - 1;
if (b != i) st[i] = 0;
}
for (int i = st[0]; i <= ed[0]; i++)
for (int j = st[1]; j <= ed[1]; j++)
for (int k = st[2]; k <= ed[2]; k++) {
dp[i][j][k] = n + 1;
if (i)
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i - 1][j][k] + 1][v[0][i]]);
if (j)
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j - 1][k] + 1][v[1][j]]);
if (k)
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j][k - 1] + 1][v[2][k]]);
}
if (dp[(int)(v[0]).size() - 1][(int)(v[1]).size() - 1]
[(int)(v[2]).size() - 1] <= n)
printf("YES\n");
else
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int n, q;
int a[3];
string p[3];
int nx[100005][26];
int dp[254][254][254];
void mn(int& x, int y) {
if (x == -1)
x = y;
else
x = min(x, y);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n >> q >> s;
for (char x = 'a'; x <= 'z'; x++) {
nx[n][x - 'a'] = n + 1;
nx[n + 1][x - 'a'] = n + 1;
}
for (int i = n - 1; i >= 0; i--) {
copy(nx[i + 1], nx[i + 1] + 26, nx[i]);
nx[i][s[i] - 'a'] = i + 1;
}
memset(dp, 255, sizeof(dp));
dp[0][0][0] = 0;
while (q--) {
char t;
int idx;
char x;
cin >> t >> idx;
idx--;
if (t == '-') {
for (int i = (idx == 0 ? a[0] : 0); i <= a[0]; i++)
for (int j = (idx == 1 ? a[1] : 0); j <= a[1]; j++)
for (int k = (idx == 2 ? a[2] : 0); k <= a[2]; k++) {
dp[i][j][k] = -1;
}
p[idx].pop_back();
a[idx]--;
} else {
cin >> x;
p[idx] += x;
a[idx]++;
for (int i = (idx == 0 ? a[0] : 0); i <= a[0]; i++)
for (int j = (idx == 1 ? a[1] : 0); j <= a[1]; j++)
for (int k = (idx == 2 ? a[2] : 0); k <= a[2]; k++) {
if (i) mn(dp[i][j][k], nx[dp[i - 1][j][k]][p[0][i - 1] - 'a']);
if (j) mn(dp[i][j][k], nx[dp[i][j - 1][k]][p[1][j - 1] - 'a']);
if (k) mn(dp[i][j][k], nx[dp[i][j][k - 1]][p[2][k - 1] - 'a']);
}
}
cout << (dp[a[0]][a[1]][a[2]] <= n ? "YES\n" : "NO\n");
}
}
|
#include <bits/stdc++.h>
int const MOD = 1000000007;
int const N = 1000005;
int const LN = 20;
int const inf = 8e18;
using namespace std;
int n, m;
int dp[N][30];
int ok[252][252][252];
vector<int> a[4];
int fn(int n1, int n2, int n3, int p1, int p2, int p3) {
for (int i = p1; i <= n1; i++)
for (int j = p2; j <= n2; j++)
for (int k = p3; k <= n3; k++) ok[i][j][k] = inf;
ok[0][0][0] = 0;
for (int i = p1; i <= n1; i++) {
for (int j = p2; j <= n2; j++) {
for (int k = p3; k <= n3; k++) {
if (i && ok[i - 1][j][k] != inf)
ok[i][j][k] = min(ok[i][j][k], dp[ok[i - 1][j][k] + 1][a[1][i - 1]]);
if (j && ok[i][j - 1][k] != inf)
ok[i][j][k] = min(ok[i][j][k], dp[ok[i][j - 1][k] + 1][a[2][j - 1]]);
if (k && ok[i][j][k - 1] != inf)
ok[i][j][k] = min(ok[i][j][k], dp[ok[i][j][k - 1] + 1][a[3][k - 1]]);
}
}
}
return ok[n1][n2][n3];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> n >> q;
string str;
cin >> str;
str = " " + str;
for (int i = 0; i < 30; i++) dp[n + 1][i] = inf;
for (int i = n; i > 0; i--) {
for (int j = 0; j < 30; j++) dp[i][j] = dp[i + 1][j];
dp[i][str[i] - 'a'] = i;
}
for (int i = 1; i <= q; i++) {
char tp;
cin >> tp;
int ans;
if (tp == '+') {
int k;
char ch;
cin >> k >> ch;
int p[5];
p[1] = 0;
p[2] = 0;
p[3] = 0;
a[k].push_back(ch - 'a');
p[k] = a[k].size();
int n1, n2, n3;
n1 = a[1].size();
n2 = a[2].size();
n3 = a[3].size();
fn(n1, n2, n3, p[1], p[2], p[3]);
} else {
int k;
cin >> k;
a[k].pop_back();
}
if (ok[a[1].size()][a[2].size()][a[3].size()] != inf)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 50;
int dp[255][255][255];
char str[maxn];
int go[maxn][26];
int len[5];
char s[5][255];
int main() {
int n, q;
cin >> n >> q;
cin >> str + 1;
for (int j = n; j <= n + 1; j++)
for (int i = 0; i < 26; i++) go[j][i] = n + 1;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
go[i][j] = go[i + 1][j];
}
go[i][str[i + 1] - 'a'] = i + 1;
}
while (q--) {
char op, ch;
int id;
cin >> op >> id;
if (op == '-')
len[id]--;
else {
cin >> ch;
len[id]++;
s[id][len[id]] = ch;
int a = 0, b = 0, c = 0;
if (id == 1) a = len[1];
if (id == 2) b = len[2];
if (id == 3) c = len[3];
for (int i = a; i <= len[1]; i++) {
for (int j = b; j <= len[2]; j++) {
for (int k = c; k <= len[3]; k++) {
dp[i][j][k] = n + 1;
if (i)
dp[i][j][k] =
min(dp[i][j][k], go[dp[i - 1][j][k]][s[1][i] - 'a']);
if (j)
dp[i][j][k] =
min(dp[i][j][k], go[dp[i][j - 1][k]][s[2][j] - 'a']);
if (k)
dp[i][j][k] =
min(dp[i][j][k], go[dp[i][j][k - 1]][s[3][k] - 'a']);
}
}
}
}
cout << (dp[len[1]][len[2]][len[3]] <= n ? "YES" : "NO") << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned seed = chrono::system_clock::now().time_since_epoch().count();
mt19937 Rand(seed);
uniform_int_distribution<long long> range(0, 1ll << 32);
inline void ucin() {
ios::sync_with_stdio(0);
cin.tie(0);
}
template <class T>
inline void chkmax(T &x, const T &y) {
if (x < y) x = y;
}
template <class T>
inline void chkmin(T &x, const T &y) {
if (x > y) x = y;
}
const int M = 255;
const int N = 1e5 + 10;
const int mod = 1e9 + 7;
int n, q, len[5], f[M][M][M], r[N][26];
char s[N], t[4][M];
int main() {
scanf("%d%d%s", &n, &q, s + 1);
for (int i = 0; i <= 25; ++i) r[n + 1][i] = r[n + 2][i] = n + 2;
for (int i = n; i >= 1; --i) {
s[i] -= 'a';
for (int j = 0; j <= 25; ++j) r[i][j] = s[i] == j ? i : r[i + 1][j];
}
f[0][0][0] = 0;
char op[5], ch[5];
for (int i = 1; i <= q; ++i) {
int x;
scanf("%s%d", op, &x);
if (*op == '+') {
scanf("%s", ch);
t[x][++len[x]] = *ch - '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) {
f[i][j][k] = n + 1;
if (i) f[i][j][k] = min(f[i][j][k], r[f[i - 1][j][k] + 1][t[1][i]]);
if (j) f[i][j][k] = min(f[i][j][k], r[f[i][j - 1][k] + 1][t[2][j]]);
if (k) f[i][j][k] = min(f[i][j][k], r[f[i][j][k - 1] + 1][t[3][k]]);
}
}
if (*op == '-') len[x]--;
puts(f[len[1]][len[2]][len[3]] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a[3];
string s;
int n, q;
int nxt[100005][26];
int dp[255][255][255];
void calc(int x, int y, int z) {
dp[x][y][z] = (1 << 30);
if (x && dp[x - 1][y][z] != (1 << 30))
dp[x][y][z] = min(dp[x][y][z], nxt[dp[x - 1][y][z] + 1][a[0][x - 1] - 'a']);
if (y && dp[x][y - 1][z] != (1 << 30))
dp[x][y][z] = min(dp[x][y][z], nxt[dp[x][y - 1][z] + 1][a[1][y - 1] - 'a']);
if (z && dp[x][y][z - 1] != (1 << 30))
dp[x][y][z] = min(dp[x][y][z], nxt[dp[x][y][z - 1] + 1][a[2][z - 1] - 'a']);
if ((!x) && (!y) && (!z)) dp[x][y][z] = -1;
}
int main() {
cin >> n >> q >> s;
for (int i = 0; i < 26; i++) nxt[n][i] = (1 << 30);
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;
}
calc(0, 0, 0);
while (q--) {
string x;
int y;
cin >> x >> y;
if (x == "+") {
string b;
cin >> b;
a[y - 1] += b;
for (int i = (y == 1 ? a[0].size() : 0); i <= a[0].size(); i++)
for (int j = (y == 2 ? a[1].size() : 0); j <= a[1].size(); j++)
for (int k = (y == 3 ? a[2].size() : 0); k <= a[2].size(); k++)
calc(i, j, k);
} else {
a[y - 1].pop_back();
}
cout << (dp[a[0].size()][a[1].size()][a[2].size()] <= n + 1 ? "YES" : "NO")
<< endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const int N = 100005;
const int N2 = 253;
int n, q, i, j, tab[N], res[N2][N2][N2], dl[5], w, bat[N][28], ss[5][N2];
char t[N], t1[10];
int compute(int w1, int w2, int w3) {
if (res[w1][w2][w3] != -1) {
return res[w1][w2][w3];
}
int r = INF, r1;
if (w1 > 0) {
r1 = compute(w1 - 1, w2, w3);
if (r1 != INF && bat[r1][ss[1][w1]] != -1) r = min(r, bat[r1][ss[1][w1]]);
}
if (w2 > 0) {
r1 = compute(w1, w2 - 1, w3);
if (r1 != INF && bat[r1][ss[2][w2]] != -1) r = min(r, bat[r1][ss[2][w2]]);
}
if (w3 > 0) {
r1 = compute(w1, w2, w3 - 1);
if (r1 != INF && bat[r1][ss[3][w3]] != -1) r = min(r, bat[r1][ss[3][w3]]);
}
res[w1][w2][w3] = r;
return r;
}
int main() {
scanf("%d %d\n", &n, &q);
scanf("%s\n", t);
for (i = 0; i < n; i++) tab[i + 1] = int(t[i]) - 'a';
for (i = 0; i < 26; i++) bat[n][i] = -1;
for (i = n - 1; i >= 0; i--) {
for (j = 0; j < 26; j++) bat[i][j] = bat[i + 1][j];
bat[i][tab[i + 1]] = i + 1;
}
res[0][0][0] = 0;
dl[1] = dl[2] = dl[3] = 0;
while (q--) {
fgets(t1, sizeof(t1), stdin);
w = int(t1[2]) - '0';
if (t1[0] == '+') {
dl[w]++;
ss[w][dl[w]] = int(t1[4]) - 'a';
if (w == 1)
for (i = 0; i <= dl[2]; i++)
for (j = 0; j <= dl[3]; j++) res[dl[1]][i][j] = -1;
if (w == 2)
for (i = 0; i <= dl[1]; i++)
for (j = 0; j <= dl[3]; j++) res[i][dl[2]][j] = -1;
if (w == 3)
for (i = 0; i <= dl[1]; i++)
for (j = 0; j <= dl[2]; j++) res[i][j][dl[3]] = -1;
if (compute(dl[1], dl[2], dl[3]) == INF)
printf("NO\n");
else
printf("YES\n");
} else {
dl[w]--;
if (compute(dl[1], dl[2], dl[3]) == INF)
printf("NO\n");
else
printf("YES\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, M = 255;
const int INF = 0x7f7f7f7f;
int n, q, len[3], p[N][26], f[M][M][M];
char s[N], t[3][M];
int calc(int x, int y, int z, char c) {
if (x < 0 || y < 0 || z < 0 || f[x][y][z] == INF) return INF;
return p[f[x][y][z]][c - 'a'];
}
void solve(int x) {
int l0 = (x == 0 ? len[0] : 0);
int l1 = (x == 1 ? len[1] : 0);
int l2 = (x == 2 ? len[2] : 0);
for (int i = l0; i <= len[0]; i++) {
for (int j = l1; j <= len[1]; j++) {
for (int k = l2; k <= len[2]; k++) {
f[i][j][k] = min(f[i][j][k], calc(i - 1, j, k, t[0][i]));
f[i][j][k] = min(f[i][j][k], calc(i, j - 1, k, t[1][j]));
f[i][j][k] = min(f[i][j][k], calc(i, j, k - 1, t[2][k]));
}
}
}
}
void erase(int x) {
int l0 = (x == 0 ? len[0] : 0);
int l1 = (x == 1 ? len[1] : 0);
int l2 = (x == 2 ? len[2] : 0);
for (int i = l0; i <= len[0]; i++) {
for (int j = l1; j <= len[1]; j++) {
for (int k = l2; k <= len[2]; k++) {
f[i][j][k] = INF;
}
}
}
}
int main() {
scanf("%d%d%s", &n, &q, s + 1);
fill(p[n], p[n] + 26, INF);
for (int i = n - 1; i >= 0; i--) {
copy(p[i + 1], p[i + 1] + 26, p[i]);
p[i][s[i + 1] - 'a'] = i + 1;
}
memset(f, 0x7f, sizeof(f));
f[0][0][0] = 0;
for (int i = 1; i <= q; i++) {
char opt;
cin >> opt;
int x;
scanf("%d", &x), x--;
if (opt == '+') {
cin >> t[x][++len[x]];
solve(x);
} else {
erase(x);
len[x]--;
}
printf(f[len[0]][len[1]][len[2]] <= n ? "Yes\n" : "No\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const int INF = 1e9;
const long long IINF = 1e18;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const char dir[4] = {'D', 'R', 'U', 'L'};
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v) is >> x;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
os << v[i] << (i + 1 == v.size() ? "" : " ");
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << '(' << p.first << ',' << p.second << ')';
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &m) {
os << '{';
for (auto itr = m.begin(); itr != m.end(); ++itr) {
os << '(' << itr->first << ',' << itr->second << ')';
if (++itr != m.end()) os << ',';
--itr;
}
os << '}';
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &s) {
os << '{';
for (auto itr = s.begin(); itr != s.end(); ++itr) {
os << *itr;
if (++itr != s.end()) os << ',';
--itr;
}
os << '}';
return os;
}
void debug_out() { cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head &&head, Tail &&...tail) {
cerr << head;
if (sizeof...(Tail) > 0) cerr << ", ";
debug_out(move(tail)...);
}
template <typename T>
T gcd(T x, T y) {
return y != 0 ? gcd(y, x % y) : x;
}
template <typename T>
T lcm(T x, T y) {
return x / gcd(x, y) * y;
}
template <class T1, class T2>
inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2>
inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int MAX_S = 255;
int dp[MAX_S][MAX_S][MAX_S];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, q;
cin >> n >> q;
string S;
cin >> S;
vector<vector<int>> nxt(n + 1, vector<int>(26, INF));
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;
}
auto next = [&](int x, char c) {
if (x == INF) return INF;
return nxt[x][c - 'a'] + 1;
};
for (int i = 0; i < MAX_S; ++i) {
for (int j = 0; j < MAX_S; ++j) {
for (int k = 0; k < MAX_S; ++k) {
dp[i][j][k] = INF;
}
}
}
dp[0][0][0] = 0;
vector<string> A(3, "");
auto add = [&](int id, char c) {
int s = A[id].size();
if (id == 0) {
for (int j = 0; j < MAX_S; ++j) {
for (int k = 0; k < MAX_S; ++k) {
chmin(dp[s + 1][j][k], next(dp[s][j][k], c));
}
}
for (int j = 0; j < MAX_S; ++j) {
for (int k = 0; k < MAX_S; ++k) {
if (j < A[1].size())
chmin(dp[s + 1][j + 1][k], next(dp[s + 1][j][k], A[1][j]));
if (k < A[2].size())
chmin(dp[s + 1][j][k + 1], next(dp[s + 1][j][k], A[2][k]));
}
}
} else if (id == 1) {
for (int i = 0; i < MAX_S; ++i) {
for (int k = 0; k < MAX_S; ++k) {
chmin(dp[i][s + 1][k], next(dp[i][s][k], c));
}
}
for (int i = 0; i < MAX_S; ++i) {
for (int k = 0; k < MAX_S; ++k) {
if (i < A[0].size())
chmin(dp[i + 1][s + 1][k], next(dp[i][s + 1][k], A[0][i]));
if (k < A[2].size())
chmin(dp[i][s + 1][k + 1], next(dp[i][s + 1][k], A[2][k]));
}
}
} else {
for (int i = 0; i < MAX_S; ++i) {
for (int j = 0; j < MAX_S; ++j) {
chmin(dp[i][j][s + 1], next(dp[i][j][s], c));
}
}
for (int i = 0; i < MAX_S; ++i) {
for (int j = 0; j < MAX_S; ++j) {
if (i < A[0].size())
chmin(dp[i + 1][j][s + 1], next(dp[i][j][s + 1], A[0][i]));
if (j < A[1].size())
chmin(dp[i][j + 1][s + 1], next(dp[i][j][s + 1], A[1][j]));
}
}
}
A[id] += c;
return dp[A[0].size()][A[1].size()][A[2].size()] < INF;
};
auto del = [&](int id) {
int s = A[id].size();
if (id == 0) {
for (int j = 0; j < MAX_S; ++j) {
for (int k = 0; k < MAX_S; ++k) {
dp[s][j][k] = INF;
}
}
} else if (id == 1) {
for (int i = 0; i < MAX_S; ++i) {
for (int k = 0; k < MAX_S; ++k) {
dp[i][s][k] = INF;
}
}
} else {
for (int i = 0; i < MAX_S; ++i) {
for (int j = 0; j < MAX_S; ++j) {
dp[i][j][s] = INF;
}
}
}
A[id].pop_back();
return dp[A[0].size()][A[1].size()][A[2].size()] < INF;
};
for (; q--;) {
char type;
int id;
cin >> type >> id;
--id;
if (type == '+') {
char c;
cin >> c;
cout << (add(id, c) ? "YES" : "NO") << '\n';
} else {
cout << (del(id) ? "YES" : "NO") << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int Get() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
int n, q;
int len[4];
int f[255][255][255];
char s[100005];
int nxt[100005][26];
char str[4][255];
void DP(int x, int y, int z) {
if (f[x][y][z] >= n) return;
if (x < len[1]) {
int t = str[1][x + 1] - 'a';
f[x + 1][y][z] = min(f[x + 1][y][z], nxt[f[x][y][z] + 1][t]);
}
if (y < len[2]) {
int t = str[2][y + 1] - 'a';
f[x][y + 1][z] = min(f[x][y + 1][z], nxt[f[x][y][z] + 1][t]);
}
if (z < len[3]) {
int t = str[3][z + 1] - 'a';
f[x][y][z + 1] = min(f[x][y][z + 1], nxt[f[x][y][z] + 1][t]);
}
}
int main() {
n = Get(), q = Get();
scanf("%s", s + 1);
for (int i = 0; i < 26; i++) nxt[n + 1][i] = n + 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j < 26; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i] - 'a'] = i;
}
memset(f, 0x3f, sizeof(f));
f[0][0][0] = 0;
char op;
while (q--) {
while (op = getchar(), op != '+' && op != '-')
;
if (op == '+') {
int x = Get();
char a;
while (a = getchar(), !isalpha(a))
;
str[x][++len[x]] = a;
if (x == 1) {
for (int i = 0; i <= len[2]; i++)
for (int j = 0; j <= len[3]; j++) f[len[x]][i][j] = 1e9;
for (int i = 0; i <= len[2]; i++)
for (int j = 0; j <= len[3]; j++)
for (int k = len[x] - 1; k <= len[x]; k++) DP(k, i, j);
} else if (x == 2) {
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[3]; j++) f[i][len[x]][j] = 1e9;
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[3]; j++)
for (int k = len[x] - 1; k <= len[x]; k++) DP(i, k, j);
} else {
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[2]; j++) f[i][j][len[x]] = 1e9;
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[2]; j++)
for (int k = len[x] - 1; k <= len[x]; k++) DP(i, j, k);
}
} else {
int x = Get();
len[x]--;
}
if (f[len[1]][len[2]][len[3]] <= n)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 255;
int dp[MAXN][MAXN][MAXN];
void init() {
for (int i = 0; i < MAXN; ++i) {
for (int j = 0; j < MAXN; ++j) {
for (int q = 0; q < MAXN; ++q) dp[i][j][q] = int(1e9);
}
}
dp[0][0][0] = -1;
}
void solve() {
int n, q;
cin >> n >> q;
string s;
cin >> s;
vector<vector<bool>> can(3, vector<bool>(n));
vector<string> cur(3);
init();
vector<vector<int>> closer(n, vector<int>(26, n));
for (int i = n - 1; i >= 0; --i) {
if (i != n - 1) {
closer[i] = closer[i + 1];
}
closer[i][s[i] - 'a'] = i;
}
while (q--) {
char type;
cin >> type;
int ind;
cin >> ind;
--ind;
if (type == '+') {
char newone;
cin >> newone;
cur[ind] += newone;
int len = int(cur[ind].size()) - 1;
if (ind == 0) {
for (int flen = 0; flen <= int(cur[1].size()); ++flen) {
for (int slen = 0; slen <= int(cur[2].size()); ++slen) {
int pos = dp[len][flen][slen];
if (pos >= n - 1) {
dp[len + 1][flen][slen] = int(1e9);
continue;
}
pos = closer[pos + 1][newone - 'a'];
if (pos < n) {
dp[len + 1][flen][slen] = pos;
} else {
dp[len + 1][flen][slen] = int(1e9);
}
}
}
for (int flen = 0; flen <= int(cur[1].size()); ++flen) {
for (int slen = 0; slen <= int(cur[2].size()); ++slen) {
int pos = dp[len + 1][flen][slen];
if (pos >= n - 1) continue;
if (flen != int(cur[1].size())) {
char f1 = cur[1][flen];
int pos1 = closer[pos + 1][f1 - 'a'];
dp[len + 1][flen + 1][slen] =
min(dp[len + 1][flen + 1][slen], pos1);
}
if (slen != int(cur[2].size())) {
char f2 = cur[2][slen];
int pos2 = closer[pos + 1][f2 - 'a'];
dp[len + 1][flen][slen + 1] =
min(dp[len + 1][flen][slen + 1], pos2);
}
}
}
}
if (ind == 1) {
for (int flen = 0; flen <= int(cur[0].size()); ++flen) {
for (int slen = 0; slen <= int(cur[2].size()); ++slen) {
int pos = dp[flen][len][slen];
if (pos >= n - 1) {
dp[flen][len + 1][slen] = int(1e9);
continue;
}
pos = closer[pos + 1][newone - 'a'];
if (pos < n) {
dp[flen][len + 1][slen] = pos;
} else {
dp[flen][len + 1][slen] = int(1e9);
}
}
}
for (int flen = 0; flen <= int(cur[0].size()); ++flen) {
for (int slen = 0; slen <= int(cur[2].size()); ++slen) {
int pos = dp[flen][len + 1][slen];
if (pos >= n - 1) continue;
if (flen != int(cur[0].size())) {
char f1 = cur[0][flen];
int pos1 = closer[pos + 1][f1 - 'a'];
dp[flen + 1][len + 1][slen] =
min(dp[flen + 1][len + 1][slen], pos1);
}
if (slen != int(cur[2].size())) {
char f2 = cur[2][slen];
int pos2 = closer[pos + 1][f2 - 'a'];
dp[flen][len + 1][slen + 1] =
min(dp[flen][len + 1][slen + 1], pos2);
}
}
}
}
if (ind == 2) {
for (int flen = 0; flen <= int(cur[0].size()); ++flen) {
for (int slen = 0; slen <= int(cur[1].size()); ++slen) {
int pos = dp[flen][slen][len];
if (pos >= n - 1) {
dp[flen][slen][len + 1] = int(1e9);
continue;
}
pos = closer[pos + 1][newone - 'a'];
if (pos < n) {
dp[flen][slen][len + 1] = pos;
} else {
dp[flen][slen][len + 1] = int(1e9);
}
}
}
for (int flen = 0; flen <= int(cur[0].size()); ++flen) {
for (int slen = 0; slen <= int(cur[1].size()); ++slen) {
int pos = dp[flen][slen][len + 1];
if (pos >= n - 1) continue;
if (flen != int(cur[0].size())) {
char f1 = cur[0][flen];
int pos1 = closer[pos + 1][f1 - 'a'];
dp[flen + 1][slen][len + 1] =
min(dp[flen + 1][slen][len + 1], pos1);
}
if (slen != int(cur[1].size())) {
char f2 = cur[1][slen];
int pos2 = closer[pos + 1][f2 - 'a'];
dp[flen][slen + 1][len + 1] =
min(dp[flen][slen + 1][len + 1], pos2);
}
}
}
}
} else {
cur[ind].pop_back();
int len = int(cur[ind].size());
if (ind == 0) {
for (int flen = 0; flen < MAXN; ++flen) {
for (int slen = 0; slen < MAXN; ++slen) {
dp[len + 1][flen][slen] = int(1e9);
}
}
}
if (ind == 1) {
for (int flen = 0; flen < MAXN; ++flen) {
for (int slen = 0; slen < MAXN; ++slen) {
dp[flen][len + 1][slen] = int(1e9);
}
}
}
if (ind == 2) {
for (int flen = 0; flen < MAXN; ++flen) {
for (int slen = 0; slen < MAXN; ++slen) {
dp[flen][slen][len + 1] = int(1e9);
}
}
}
}
int len1 = int(cur[0].size());
int len2 = int(cur[1].size());
int len3 = int(cur[2].size());
if (dp[len1][len2][len3] < n) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void relax(int*** dp, string* rel, int target, int i, int j, int** nextOcc) {
string r = rel[target];
if (target == 0) {
int best = nextOcc[r[r.length() - 1] - 'a'][dp[r.length() - 1][i][j]] + 1;
if (i > 0 && rel[1].size() >= i)
best =
min(best, nextOcc[rel[1][i - 1] - 'a'][dp[r.length()][i - 1][j]] + 1);
if (j > 0 && rel[2].size() >= j)
best =
min(best, nextOcc[rel[2][j - 1] - 'a'][dp[r.length()][i][j - 1]] + 1);
dp[r.length()][i][j] = best;
} else if (target == 1) {
int best = nextOcc[r[r.length() - 1] - 'a'][dp[i][r.length() - 1][j]] + 1;
if (i > 0 && rel[0].size() >= i)
best =
min(best, nextOcc[rel[0][i - 1] - 'a'][dp[i - 1][r.length()][j]] + 1);
if (j > 0 && rel[2].size() >= j)
best =
min(best, nextOcc[rel[2][j - 1] - 'a'][dp[i][r.length()][j - 1]] + 1);
dp[i][r.length()][j] = best;
} else {
int best = nextOcc[r[r.length() - 1] - 'a'][dp[i][j][r.length() - 1]] + 1;
if (i > 0 && rel[0].size() >= i)
best =
min(best, nextOcc[rel[0][i - 1] - 'a'][dp[i - 1][j][r.length()]] + 1);
if (j > 0 && rel[1].size() >= j)
best =
min(best, nextOcc[rel[1][j - 1] - 'a'][dp[i][j - 1][r.length()]] + 1);
dp[i][j][r.length()] = best;
}
}
int main() {
int n, q;
string s;
cin >> n >> q >> s;
int** nextOcc = new int*[26];
for (int i = 0; i < 26; i++) {
nextOcc[i] = new int[n + 2];
nextOcc[i][n] = n;
nextOcc[i][n + 1] = n;
}
for (int i = 0; i < 26; i++) {
for (int j = n - 1; j >= 0; j--) {
if (s[j] == 'a' + i) {
nextOcc[i][j] = j;
} else {
nextOcc[i][j] = nextOcc[i][j + 1];
}
}
}
int*** dp = new int**[251];
for (int i = 0; i < 251; i++) {
dp[i] = new int*[251];
for (int j = 0; j < 251; j++) {
dp[i][j] = new int[251];
for (int k = 0; k < 251; k++) {
dp[i][j][k] = 0;
}
}
}
string rel[3];
for (int i = 0; i < 3; i++) rel[i] = "";
while (q-- > 0) {
char c;
int r;
cin >> c >> r;
r--;
if (c == '+') {
char append;
cin >> append;
rel[r] += append;
int bound1 = r == 0 ? rel[1].length() : rel[0].length();
int bound2 = r == 2 ? rel[1].length() : rel[2].length();
for (int i = 0; i <= bound1; i++) {
for (int j = 0; j <= bound2; j++) {
relax(dp, rel, r, i, j, nextOcc);
}
}
} else {
rel[r] = rel[r].substr(0, rel[r].length() - 1);
}
if (dp[rel[0].length()][rel[1].length()][rel[2].length()] > n)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, MX = 305;
int n, q, u, a[3], dp[MX][MX][MX], nxt[N][26];
char t, pat[3][MX];
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> q >> s;
for (int i = 0; i < 26; i++) nxt[n + 1][i] = nxt[n + 2][i] = n + 1;
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][s[i - 1] - 'a'] = i;
}
while (q--) {
cin >> t >> u;
--u;
if (t == '-')
--a[u];
else {
++a[u];
cin >> pat[u][a[u]];
for (int i = (u == 0 ? a[0] : 0); i <= a[0]; i++)
for (int j = (u == 1 ? a[1] : 0); j <= a[1]; j++)
for (int k = (u == 2 ? a[2] : 0); k <= a[2]; k++)
if (i != 0 || j != 0 || k != 0) {
dp[i][j][k] = n + 1;
if (i > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k] + 1][pat[0][i] - 'a']);
if (j > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k] + 1][pat[1][j] - 'a']);
if (k > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1] + 1][pat[2][k] - 'a']);
}
}
cout << (dp[a[0]][a[1]][a[2]] == n + 1 ? "NO\n" : "YES\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct rge {
T b, e;
};
template <class T>
rge<T> range(T i, T j) {
return rge<T>{i, j};
}
struct debug {
template <class T>
debug& operator<<(const T&) {
return *this;
}
};
using ll = long long;
template <typename T>
void min_self(T& a, T b) {
a = min(a, b);
}
template <typename T>
void max_self(T& a, T b) {
a = max(a, b);
}
const int mxN = 255;
const int mxM = 100 * 1000 + 5;
int dp[mxN][mxN][mxN];
int dont_use_next[mxM][26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, q;
string s;
cin >> n >> q >> s;
for (int i = 0; i < int(mxM); i++)
for (int j = 0; j < int(26); j++) dont_use_next[i][j] = n;
for (int i = 0; i < int(mxN); i++)
for (int j = 0; j < int(mxN); j++)
for (int k = 0; k < int(mxN); k++) dp[i][j][k] = n;
dp[0][0][0] = -1;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < int(26); j++) {
if (s[i] - 'a' == j) {
dont_use_next[i][j] = i;
} else {
dont_use_next[i][j] = dont_use_next[i + 1][j];
}
}
}
string a[3];
while (q--) {
char c;
int idx;
cin >> c >> idx;
--idx;
if (c == '-') {
a[idx].pop_back();
} else {
char letter;
cin >> letter;
a[idx].push_back(letter);
int n1 = a[0].size(), n2 = a[1].size(), n3 = a[2].size();
if (idx == 0) {
for (int i = 0; i <= n2; i++) {
for (int j = 0; j <= n3; j++) {
int& me = dp[n1][i][j];
me = dont_use_next[dp[n1 - 1][i][j] + 1][letter - 'a'];
if (i > 0) {
min_self(me,
dont_use_next[dp[n1][i - 1][j] + 1][a[1][i - 1] - 'a']);
}
if (j > 0) {
min_self(me,
dont_use_next[dp[n1][i][j - 1] + 1][a[2][j - 1] - 'a']);
}
}
}
} else if (idx == 1) {
for (int i = 0; i <= n1; i++) {
for (int j = 0; j <= n3; j++) {
int& me = dp[i][n2][j];
me = dont_use_next[dp[i][n2 - 1][j] + 1][letter - 'a'];
if (i > 0) {
min_self(me,
dont_use_next[dp[i - 1][n2][j] + 1][a[0][i - 1] - 'a']);
}
if (j > 0) {
min_self(me,
dont_use_next[dp[i][n2][j - 1] + 1][a[2][j - 1] - 'a']);
}
}
}
} else {
for (int i = 0; i <= n1; i++) {
for (int j = 0; j <= n2; j++) {
int& me = dp[i][j][n3];
me = dont_use_next[dp[i][j][n3 - 1] + 1][letter - 'a'];
if (i > 0) {
min_self(me,
dont_use_next[dp[i - 1][j][n3] + 1][a[0][i - 1] - 'a']);
}
if (j > 0) {
min_self(me,
dont_use_next[dp[i][j - 1][n3] + 1][a[1][j - 1] - 'a']);
}
}
}
}
}
int n1 = a[0].size(), n2 = a[1].size(), n3 = a[2].size();
debug() << "[ "
<< "dp[n1][n2][n3]"
": "
<< (dp[n1][n2][n3]) << " ] ";
bool ok = dp[n1][n2][n3] < n;
if (ok) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
using li = long long;
using ld = long double;
void solve(bool);
void precalc();
clock_t start;
int main() {
start = clock();
int t = 1;
cout.sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
cout << fixed;
precalc();
while (t--) {
solve(true);
}
cout.flush();
return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
if (!w) return 1 % mod;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
template <typename T>
T gcd(T q, T w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
template <typename T>
T lcm(T q, T w) {
return q / gcd(q, w) * w;
}
template <typename T>
void make_unique(vector<T>& vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
template <typename T>
void relax_min(T& cur, T val) {
cur = min(cur, val);
}
template <typename T>
void relax_max(T& cur, T val) {
cur = max(cur, val);
}
mt19937 rng(
(unsigned long long)chrono::steady_clock::now().time_since_epoch().count());
void precalc() {}
const int C = 256;
int dp[C][C][C];
const int INF = (int)1e9;
void delete_info(int num, vector<vector<int>>& a) {
if (num == 0) {
for (int i = 0; i <= a[1].size(); ++i) {
for (int j = 0; j <= a[2].size(); ++j) {
dp[a[0].size()][i][j] = INF;
}
}
} else if (num == 1) {
for (int i = 0; i <= a[0].size(); ++i) {
for (int j = 0; j <= a[2].size(); ++j) {
dp[i][a[1].size()][j] = INF;
}
}
} else if (num == 2) {
for (int i = 0; i <= a[0].size(); ++i) {
for (int j = 0; j <= a[1].size(); ++j) {
dp[i][j][a[2].size()] = INF;
}
}
}
a[num].pop_back();
}
int n;
void update_info(int num, vector<vector<int>>& a, int c,
vector<vector<int>>& next_letter) {
if (num == 0) {
for (int i = 0; i <= a[1].size(); ++i) {
for (int j = 0; j <= a[2].size(); ++j) {
int pos = dp[a[0].size()][i][j];
int& cur_dp = dp[a[0].size() + 1][i][j];
if (pos < n) {
relax_min(cur_dp, next_letter[c][pos] + 1);
}
if (cur_dp == INF) {
continue;
}
if (i < a[1].size()) {
int new_dp = next_letter[a[1][i]][cur_dp] + 1;
relax_min(dp[a[0].size() + 1][i + 1][j], new_dp);
}
if (j < a[2].size()) {
int new_dp = next_letter[a[2][j]][cur_dp] + 1;
relax_min(dp[a[0].size() + 1][i][j + 1], new_dp);
}
}
}
} else if (num == 1) {
for (int i = 0; i <= a[0].size(); ++i) {
for (int j = 0; j <= a[2].size(); ++j) {
int pos = dp[i][a[1].size()][j];
int& cur_dp = dp[i][a[1].size() + 1][j];
if (pos < n) {
relax_min(cur_dp, next_letter[c][pos] + 1);
}
if (cur_dp == INF) {
continue;
}
if (i < a[0].size()) {
int new_dp = next_letter[a[0][i]][cur_dp] + 1;
relax_min(dp[i + 1][a[1].size() + 1][j], new_dp);
}
if (j < a[2].size()) {
int new_dp = next_letter[a[2][j]][cur_dp] + 1;
relax_min(dp[i][a[1].size() + 1][j + 1], new_dp);
}
}
}
} else if (num == 2) {
for (int i = 0; i <= a[0].size(); ++i) {
for (int j = 0; j <= a[1].size(); ++j) {
int pos = dp[i][j][a[2].size()];
int& cur_dp = dp[i][j][a[2].size() + 1];
if (pos < n) {
relax_min(cur_dp, next_letter[c][pos] + 1);
}
if (cur_dp == INF) {
continue;
}
if (i < a[0].size()) {
int new_dp = next_letter[a[0][i]][cur_dp] + 1;
relax_min(dp[i + 1][j][a[2].size() + 1], new_dp);
}
if (j < a[1].size()) {
int new_dp = next_letter[a[1][j]][cur_dp] + 1;
relax_min(dp[i][j + 1][a[2].size() + 1], new_dp);
}
}
}
}
a[num].push_back(c);
}
void solve(__attribute__((unused)) bool read) {
int Q;
if (read) {
cin >> n >> Q;
} else {
n = 100000;
Q = 1000;
}
string s;
if (read) {
cin >> s;
} else {
for (int i = 0; i < n; ++i) {
s += (char)('a' + rand() % 26);
}
}
for (int i = 0; i < C; ++i) {
for (int j = 0; j < C; ++j) {
for (int r = 0; r < C; ++r) {
dp[i][j][r] = INF;
}
}
}
vector<vector<int>> next_letter(26, vector<int>(n + 1, INF));
vector<int> next_pos(26, INF);
for (int i = n - 1; i >= 0; --i) {
next_pos[s[i] - 'a'] = i;
for (int c = 0; c < 26; ++c) {
next_letter[c][i] = next_pos[c];
}
}
dp[0][0][0] = 0;
vector<vector<int>> a(3);
while (Q--) {
char type;
int num;
if (read) {
cin >> type >> num;
--num;
} else {
num = rand() % 3;
type = '+';
if (a[num].size() == 250) {
type = '-';
}
}
if (type == '+') {
char c;
if (read) {
cin >> c;
} else {
c = (char)('a' + rand() % 26);
}
update_info(num, a, c - 'a', next_letter);
} else {
delete_info(num, a);
}
if (dp[a[0].size()][a[1].size()][a[2].size()] < INF) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 87, W = 255;
const int inf = 0x3f3f3f3f;
char s[N];
int dp[W][W][W];
int nx[N][26];
vector<int> t[3];
int& at(array<int, 3>& a) { return dp[a[0]][a[1]][a[2]]; }
void recalc(int f) {
vector<int> p = {0, 1, 2};
swap(p[0], p[f]);
array<int, 3> a, b;
a = b = {0, 0, 0};
for (int _ = -1; _ <= -1; ++_) {
int& i = a[p[0]];
int& j = a[p[1]];
int& k = a[p[2]];
i = ((int)(t[p[0]]).size()) + _;
for (j = 0; j < ((int)(t[p[1]]).size()); ++j)
for (k = 0; k < ((int)(t[p[2]]).size()); ++k) {
at(a) = inf;
}
}
for (int _ = -2; _ <= -1; ++_) {
int& i = a[p[0]];
int& j = a[p[1]];
int& k = a[p[2]];
i = ((int)(t[p[0]]).size()) + _;
for (j = 0; j < ((int)(t[p[1]]).size()); ++j)
for (k = 0; k < ((int)(t[p[2]]).size()); ++k) {
if (at(a) == inf) continue;
b = a;
for (int x = 0; x < 3; ++x) {
if (++b[x] < ((int)(t[x]).size())) {
at(b) = min(at(b), nx[at(a)][t[x][b[x]]]);
}
--b[x];
}
}
}
}
int main() {
ios::sync_with_stdio(0);
int n, q;
cin >> n >> q >> (s + 1);
fill_n(nx[n], 26, inf);
for (int i = n - 1; i >= 0; --i) {
copy_n(nx[i + 1], 26, nx[i]);
nx[i][s[i + 1] - 'a'] = i + 1;
}
t[0] = t[1] = t[2] = {-1};
memset(dp, 0x3f, sizeof dp);
dp[0][0][0] = 0;
while (q--) {
char o, c;
int i;
cin >> o >> i;
--i;
if (o == '+') {
cin >> c;
t[i].push_back(c - 'a');
recalc(i);
} else {
t[i].pop_back();
}
cout << (dp[((int)(t[0]).size()) - 1][((int)(t[1]).size()) - 1]
[((int)(t[2]).size()) - 1] != inf
? "YES\n"
: "NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e5 + 10;
int n, q;
char s[SIZE];
int nxt[SIZE][26];
string AA[3];
int dp[251][251][251];
void update(int &x, int v) {
if (x == -1 || x > v) x = v;
}
void update(int x, int y, int z) {
dp[x][y][z] = n + 1;
if (x && dp[x - 1][y][z] != n + 1)
update(dp[x][y][z], nxt[dp[x - 1][y][z] + 1][AA[0][x - 1] - 'a']);
if (y && dp[x][y - 1][z] != n + 1)
update(dp[x][y][z], nxt[dp[x][y - 1][z] + 1][AA[1][y - 1] - 'a']);
if (z && dp[x][y][z - 1] != n + 1)
update(dp[x][y][z], nxt[dp[x][y][z - 1] + 1][AA[2][z - 1] - 'a']);
}
int main() {
R(n, q);
scanf("%s", (s + 1));
for (int i = 0; i < (26); ++i) nxt[n + 1][i] = n + 1;
for (int i = n; i > 0; i--) {
for (int j = 0; j < (26); ++j) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i] - 'a'] = i;
}
for (int cs = 0; cs < (q); ++cs) {
int id;
string op, c;
R(op, id);
id--;
if (op == "+") {
R(c);
AA[id] += c;
if (!id) {
for (int j = 0; j < (((int)(AA[1]).size()) + 1); ++j)
for (int k = 0; k < (((int)(AA[2]).size()) + 1); ++k) {
update(((int)(AA[0]).size()), j, k);
}
} else if (id == 1) {
for (int i = 0; i < (((int)(AA[0]).size()) + 1); ++i)
for (int k = 0; k < (((int)(AA[2]).size()) + 1); ++k) {
update(i, ((int)(AA[1]).size()), k);
}
} else {
for (int i = 0; i < (((int)(AA[0]).size()) + 1); ++i)
for (int j = 0; j < (((int)(AA[1]).size()) + 1); ++j) {
update(i, j, ((int)(AA[2]).size()));
}
}
} else if (op == "-") {
AA[id].pop_back();
}
W(dp[((int)(AA[0]).size())][((int)(AA[1]).size())][((int)(AA[2]).size())] <=
n
? "YES"
: "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, Q;
string s;
string a, b, c;
int dp[255][255][255];
int nx[100005][26];
int main(void) {
cin >> n >> Q;
cin >> s;
s = "#" + s;
for (int i = 0; i < 26; i++) nx[s.size()][i] = s.size();
for (int i = s.size() - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) nx[i][j] = nx[i + 1][j];
if (i + 1 < s.size()) nx[i][s[i + 1] - '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] = s.size();
}
}
}
dp[0][0][0] = 0;
char t, ch;
int id;
for (int q = 0; q < Q; q++) {
cin >> t;
if (t == '-') {
cin >> id;
if (id == 1) a.erase(a.end() - 1);
if (id == 2) b.erase(b.end() - 1);
if (id == 3) c.erase(c.end() - 1);
} else {
cin >> id >> ch;
int A = a.size(), B = b.size(), C = c.size();
if (id == 1) {
a += ch, A++;
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] = s.size();
if (i > 0)
dp[i][j][k] =
min(dp[i][j][k], nx[dp[i - 1][j][k]][a[i - 1] - 'a']);
if (j > 0)
dp[i][j][k] =
min(dp[i][j][k], nx[dp[i][j - 1][k]][b[j - 1] - 'a']);
if (k > 0)
dp[i][j][k] =
min(dp[i][j][k], nx[dp[i][j][k - 1]][c[k - 1] - 'a']);
}
}
}
}
if (id == 2) {
b += ch, B++;
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] = s.size();
if (i > 0)
dp[i][j][k] =
min(dp[i][j][k], nx[dp[i - 1][j][k]][a[i - 1] - 'a']);
if (j > 0)
dp[i][j][k] =
min(dp[i][j][k], nx[dp[i][j - 1][k]][b[j - 1] - 'a']);
if (k > 0)
dp[i][j][k] =
min(dp[i][j][k], nx[dp[i][j][k - 1]][c[k - 1] - 'a']);
}
}
}
}
if (id == 3) {
c += ch, C++;
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] = s.size();
if (i > 0)
dp[i][j][k] =
min(dp[i][j][k], nx[dp[i - 1][j][k]][a[i - 1] - 'a']);
if (j > 0)
dp[i][j][k] =
min(dp[i][j][k], nx[dp[i][j - 1][k]][b[j - 1] - 'a']);
if (k > 0)
dp[i][j][k] =
min(dp[i][j][k], nx[dp[i][j][k - 1]][c[k - 1] - 'a']);
}
}
}
}
}
if (dp[a.size()][b.size()][c.size()] < s.size())
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 250 + 5;
int n, q;
char s[N], d[5][M];
int len[5], nxt[N][30];
int dp[M][M][M];
int main() {
while (~scanf("%d%d%s", &n, &q, s)) {
memset(len, 0, sizeof(len));
for (int i = 0; i <= 25; i++) nxt[n][i] = nxt[n + 1][i] = n + 1;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= 25; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i] - 'a'] = i + 1;
}
while (q--) {
char op;
int id;
scanf(" %c %d", &op, &id);
if (op == '-')
len[id]--;
else {
len[id]++;
scanf(" %c", &op);
d[id][len[id]] = op;
int l1, l2, l3;
l1 = l2 = l3 = 0;
if (id == 1) l1 = len[1];
if (id == 2) l2 = len[2];
if (id == 3) l3 = len[3];
for (int i = l1; i <= len[1]; i++)
for (int j = l2; j <= len[2]; j++)
for (int k = l3; k <= len[3]; k++) {
dp[i][j][k] = n + 1;
int pre, ch;
if (i) {
pre = dp[i - 1][j][k];
ch = d[1][i] - 'a';
dp[i][j][k] = min(nxt[pre][ch], dp[i][j][k]);
}
if (j) {
pre = dp[i][j - 1][k];
ch = d[2][j] - 'a';
dp[i][j][k] = min(nxt[pre][ch], dp[i][j][k]);
}
if (k) {
pre = dp[i][j][k - 1];
ch = d[3][k] - 'a';
dp[i][j][k] = min(nxt[pre][ch], dp[i][j][k]);
}
}
}
if (dp[len[1]][len[2]][len[3]] <= n)
puts("YES");
else
puts("NO");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int helper_table[100010][26];
int dp[256][256][256];
bool is_prime(int n) {
for (int i = 2; i <= sqrt(n); i++) {
if (!(n % i)) return false;
}
return true;
}
void solve(int index = 0) {
int n, q;
cin >> n >> q;
string s;
cin >> s;
for (int i = n + 1; i >= n; i--) {
for (int j = 0; j < 26; j++) helper_table[i][j] = n;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
if (s[i] == 'a' + j) {
helper_table[i][j] = i;
} else {
helper_table[i][j] = helper_table[i + 1][j];
}
}
}
string rel1 = "", rel2 = "", rel3 = "";
for (int i = 0; i < q; i++) {
char qtype;
cin >> qtype;
int index;
cin >> index;
int l1, l2, l3;
if (qtype == '+') {
char c;
cin >> c;
int mn1 = 0;
int mn2 = 0;
int mn3 = 0;
if (index == 1) {
rel1 += c;
l1 = rel1.length();
mn1 = l1;
} else if (index == 2) {
rel2 += c;
l2 = rel2.length();
mn2 = l2;
} else {
rel3 += c;
l3 = rel3.length();
mn3 = l3;
}
l1 = rel1.length();
l2 = rel2.length();
l3 = rel3.length();
dp[0][0][0] = -1;
for (int i = mn1; i <= l1; i++) {
for (int j = mn2; j <= l2; j++) {
for (int k = mn3; k <= l3; k++) {
if (i == 0 && j == 0 && k == 0) continue;
int x = n;
if (i != 0) {
int p = helper_table[(dp[i - 1][j][k]) + 1][rel1[i - 1] - 'a'];
x = min(x, p);
}
if (j != 0) {
int p = helper_table[(dp[i][j - 1][k]) + 1][rel2[j - 1] - 'a'];
x = min(x, p);
}
if (k != 0) {
int p = helper_table[(dp[i][j][k - 1]) + 1][rel3[k - 1] - 'a'];
x = min(x, p);
}
dp[i][j][k] = x;
}
}
}
} else {
if (index == 1) {
rel1 = rel1.substr(0, rel1.length() - 1);
} else if (index == 2) {
rel2 = rel2.substr(0, rel2.length() - 1);
} else {
rel3 = rel3.substr(0, rel3.length() - 1);
}
l1 = rel1.length();
l2 = rel2.length();
l3 = rel3.length();
}
if (dp[l1][l2][l3] < n) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
void multi_solve() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
solve(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, q;
string s;
int dp[251][251][251];
int nxt[26][112345];
int len[3];
int chs[3][250];
template <class T, class U>
inline void smax(T &a, U b) {
a = a > b ? a : b;
}
template <class T, class U>
inline void smin(T &a, U b) {
a = a < b ? a : b;
}
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(0);
cin >> n >> q;
cin >> s;
for (int i = 0; i < 26; i++) {
nxt[i][n] = nxt[i][n + 1] = n;
for (int j = n - 1; j >= 0; j--)
if (s[j] == 'a' + i)
nxt[i][j] = j;
else
nxt[i][j] = nxt[i][j + 1];
}
dp[0][0][0] = -1;
for (int t = 0; t < q; t++) {
char c;
int group;
cin >> c >> group;
group -= 1;
if (c == '+') {
char ch;
cin >> ch;
chs[group][len[group]] = ch - 'a';
len[group]++;
int i[3];
for (i[0] = group == 0 ? len[0] : 0; i[0] <= len[0]; i[0]++)
for (i[1] = group == 1 ? len[1] : 0; i[1] <= len[1]; i[1]++)
for (i[2] = group == 2 ? len[2] : 0; i[2] <= len[2]; i[2]++) {
if (!i[0] && !i[1] && !i[2]) continue;
dp[i[0]][i[1]][i[2]] = n;
for (int k = 0; k < 3; k++) {
if (i[k] > 0) {
smin(dp[i[0]][i[1]][i[2]],
nxt[chs[k][i[k] - 1]]
[dp[i[0] - (0 == k)][i[1] - (1 == k)][i[2] - (2 == k)] +
1]);
}
}
}
} else {
len[group]--;
}
cout << ((dp[len[0]][len[1]][len[2]] < n) ? "Yes" : "No") << "\n";
}
cout << flush;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const long long mod = 1e9 + 7;
const int inf = 1 << 30;
const int maxn = 1000500;
int n;
int a[maxn];
long long d;
vector<int> ans;
char s[maxn];
int f[10];
int norm(int x) {
x %= n;
if (x < 0) x += n;
return x;
}
inline void err() {
puts("NO");
exit(0);
}
char st[maxn];
string ss[4];
int dp[255][255][255];
int nxt[maxn][26];
void solve() {
int n, q;
scanf("%d%d", &n, &q);
scanf("%s", st);
for (int i = 0; i < (int)(26); ++i) nxt[n][i] = nxt[n + 1][i] = n;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < (int)(26); ++j) nxt[i][j] = nxt[i + 1][j];
nxt[i][st[i] - 'a'] = i;
}
char ty;
int id;
dp[0][0][0] = -1;
for (int i = 0; i < (int)(q); ++i) {
scanf(" %c %d", &ty, &id);
if (ty == '+') {
scanf(" %c", &ty);
ss[id] += ty;
for (int i = (id == 1 ? ss[1].size() : 0); i <= ss[1].size(); i++) {
for (int j = (id == 2 ? ss[2].size() : 0); j <= ss[2].size(); j++) {
for (int k = (id == 3 ? ss[3].size() : 0); k <= ss[3].size(); k++) {
dp[i][j][k] = n;
if (i)
dp[i][j][k] = min(dp[i][j][k],
nxt[dp[i - 1][j][k] + 1][ss[1][i - 1] - 'a']);
if (j)
dp[i][j][k] = min(dp[i][j][k],
nxt[dp[i][j - 1][k] + 1][ss[2][j - 1] - 'a']);
if (k)
dp[i][j][k] = min(dp[i][j][k],
nxt[dp[i][j][k - 1] + 1][ss[3][k - 1] - 'a']);
}
}
}
} else {
ss[id].pop_back();
}
puts(dp[ss[1].size()][ss[2].size()][ss[3].size()] >= n ? "NO" : "YES");
}
}
int main() {
int tc = 1;
for (int tt = 0; tt < (int)(tc); ++tt) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
void open(const char *s) {}
const double eps = 1e-8;
const int inf = 0x3f3f3f3f;
const int Minf = 0x7f7f7f7f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const long long MINF = 0x7f7f7f7f7f7f7f7fll;
const int N = 5e5 + 50;
char s[N], p[10], opt[10];
vector<int> S[4];
int nxt[N][26];
int f[255][255][255];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
cin >> (s + 1);
for (int i = (0); i <= (25); ++i) nxt[n][i] = n + 1, nxt[n + 1][i] = n + 1;
for (int i = (n - 1); i >= (0); --i) {
for (int j = (0); j <= (25); ++j) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i + 1] - 'a'] = i + 1;
}
for (int i = (0); i <= (254); ++i)
for (int j = (0); j <= (254); ++j)
for (int k = (0); k <= (254); ++k) f[i][j][k] = n + 1;
int L1 = 0, L2 = 0, L3 = 0;
f[0][0][0] = 0;
while (q--) {
int x;
cin >> opt >> x;
if (opt[0] == '+') {
cin >> p;
S[x].push_back(p[0] - 'a');
if (x == 1) {
++L1;
int i = L1;
for (int j = 0; j <= L2; ++j) {
for (int k = 0; k <= L3; ++k) {
if (i > 0)
f[i][j][k] = min(f[i][j][k], nxt[f[i - 1][j][k]][S[1][i - 1]]);
if (j > 0)
f[i][j][k] = min(f[i][j][k], nxt[f[i][j - 1][k]][S[2][j - 1]]);
if (k > 0)
f[i][j][k] = min(f[i][j][k], nxt[f[i][j][k - 1]][S[3][k - 1]]);
}
}
} else if (x == 2) {
++L2;
for (int i = 0; i <= L1; ++i) {
int j = L2;
for (int k = 0; k <= L3; ++k) {
if (i > 0)
f[i][j][k] = min(f[i][j][k], nxt[f[i - 1][j][k]][S[1][i - 1]]);
if (j > 0)
f[i][j][k] = min(f[i][j][k], nxt[f[i][j - 1][k]][S[2][j - 1]]);
if (k > 0)
f[i][j][k] = min(f[i][j][k], nxt[f[i][j][k - 1]][S[3][k - 1]]);
}
}
} else {
++L3;
for (int i = 0; i <= L1; ++i) {
for (int j = 0; j <= L2; ++j) {
int k = L3;
if (i > 0)
f[i][j][k] = min(f[i][j][k], nxt[f[i - 1][j][k]][S[1][i - 1]]);
if (j > 0)
f[i][j][k] = min(f[i][j][k], nxt[f[i][j - 1][k]][S[2][j - 1]]);
if (k > 0)
f[i][j][k] = min(f[i][j][k], nxt[f[i][j][k - 1]][S[3][k - 1]]);
}
}
}
} else {
S[x].pop_back();
if (x == 1) {
int i = L1;
for (int j = (0); j <= (L2); ++j)
for (int k = (0); k <= (L3); ++k) f[i][j][k] = n + 1;
--L1;
} else if (x == 2) {
int j = L2;
for (int i = (0); i <= (L1); ++i)
for (int k = (0); k <= (L3); ++k) f[i][j][k] = n + 1;
--L2;
} else {
int k = L3;
for (int i = (0); i <= (L1); ++i)
for (int j = (0); j <= (L2); ++j) f[i][j][k] = n + 1;
--L3;
}
}
if (f[L1][L2][L3] > n)
puts("NO");
else
puts("YES");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, now, pos;
int len[3 + 5], nex[100000 + 5][26 + 5];
int dp[255 + 5][255 + 5][255 + 5];
char op1[5], op2[5];
char s[100000 + 5], ss[3 + 5][100000 + 5];
int main() {
scanf("%d%d%s", &n, &q, s + 1);
memset(dp, 0x3f, sizeof dp);
dp[0][0][0] = 0;
for (int i = 0; i <= 26; i++) nex[n + 1][i] = nex[n + 2][i] = n + 1;
s[0] = 0;
for (int i = n; i >= 0; i--) {
now = s[i] - 'a';
for (int j = 0; j < 26; j++) {
if (j == now)
nex[i][j] = i;
else
nex[i][j] = nex[i + 1][j];
}
}
while (q--) {
scanf("%s", op1 + 1);
if (op1[1] == '+') {
scanf("%d%s", &pos, op2 + 1);
ss[pos][++len[pos]] = op2[1];
for (int i = (1 == pos ? len[1] : 0); i <= len[1]; i++) {
for (int j = (2 == pos ? len[2] : 0); j <= len[2]; j++) {
for (int k = (3 == pos ? len[3] : 0); k <= len[3]; k++) {
dp[i][j][k] = n + 1;
if (i)
dp[i][j][k] =
min(dp[i][j][k], nex[dp[i - 1][j][k] + 1][ss[1][i] - 'a']);
if (j)
dp[i][j][k] =
min(dp[i][j][k], nex[dp[i][j - 1][k] + 1][ss[2][j] - 'a']);
if (k)
dp[i][j][k] =
min(dp[i][j][k], nex[dp[i][j][k - 1] + 1][ss[3][k] - 'a']);
}
}
}
} else {
scanf("%d", &pos);
len[pos]--;
}
if (dp[len[1]][len[2]][len[3]] > n)
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, A = 26, M = 260;
string word;
int nxt[N][A];
int dp[M][M][M];
vector<char> s[3];
void compute(int start[3]) {
for (int i = start[0]; i <= s[0].size(); ++i)
for (int j = start[1]; j <= s[1].size(); ++j)
for (int k = start[2]; k <= s[2].size(); ++k) {
dp[i][j][k] = word.size() + 1;
if (i == 0 && j == 0 && k == 0) dp[i][j][k] = 0;
if (i != 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k]][s[0][i - 1] - 'a'] + 1);
if (j != 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k]][s[1][j - 1] - 'a'] + 1);
if (k != 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1]][s[2][k - 1] - 'a'] + 1);
}
}
int main() {
ios::sync_with_stdio(0);
int n, q;
cin >> n >> q;
cin >> word;
int last[A];
for (int i = 0; i < A; ++i) last[i] = n;
for (int j = 0; j < A; ++j) nxt[n][j] = nxt[n + 1][j] = last[j];
for (int i = n - 1; i >= 0; --i) {
last[word[i] - 'a'] = i;
for (int j = 0; j < A; ++j) nxt[i][j] = last[j];
}
while (q--) {
char p, c;
int si;
cin >> p >> si;
--si;
if (p == '+') {
cin >> c;
s[si].push_back(c);
int start[3] = {};
start[si] = s[si].size();
compute(start);
} else {
s[si].pop_back();
}
cout << (dp[s[0].size()][s[1].size()][s[2].size()] <= n ? "YES\n" : "NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long P = 1e9 + 7;
const int N = 1e5 + 5;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, q, i, stk[4][251], top[4];
int dp[251][251][251], nxt[N][26], tmp[N];
char ch, s[N];
void upd(int x, int y, int z) {
dp[x][y][z] = min(y ? nxt[dp[x][y - 1][z]][stk[2][y]] : n + 1,
z ? nxt[dp[x][y][z - 1]][stk[3][z]] : n + 1);
dp[x][y][z] = min(dp[x][y][z], x ? nxt[dp[x - 1][y][z]][stk[1][x]] : n + 1);
}
int main() {
scanf("%d%d", &n, &q);
scanf("%s\n", s + 1);
for (int i = (0); i <= (25); ++i) tmp[i] = n + 1;
for (int i = (n + 1); i >= (0); --i) {
for (int j = (0); j <= (25); ++j) nxt[i][j] = tmp[j];
if (i <= n && i >= 1) tmp[s[i] - 'a'] = i;
}
while (q--) {
scanf("%c ", &ch);
if (ch == '+') {
scanf("%d %c\n", &i, &ch);
stk[i][++top[i]] = ch - 'a';
int x = top[i];
if (i == 1)
for (int y = (0); y <= (top[2]); ++y)
for (int z = (0); z <= (top[3]); ++z) upd(x, y, z);
if (i == 2)
for (int y = (0); y <= (top[1]); ++y)
for (int z = (0); z <= (top[3]); ++z) upd(y, x, z);
if (i == 3)
for (int y = (0); y <= (top[1]); ++y)
for (int z = (0); z <= (top[2]); ++z) upd(y, z, x);
} else {
scanf("%d\n", &i);
--top[i];
}
printf(dp[top[1]][top[2]][top[3]] <= n ? "YES\n" : "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 8, MAXU = 1 << 17;
int dp[MAXN][MAXN][MAXN];
int step[MAXU][26];
vector<int> s[3];
int main() {
cin.sync_with_stdio(0);
cin.tie(nullptr);
int N, Q;
cin >> N >> Q;
string U;
cin >> U;
for (int i = 0; i < 26; ++i) {
step[N][i] = step[N + 1][i] = N + 1;
}
for (int i = N - 1; i >= 0; --i) {
for (int j = 0; j < 26; ++j) {
step[i][j] = step[i + 1][j];
}
step[i][U[i] - 'a'] = i;
}
while (Q--) {
string op;
cin >> op;
int u;
cin >> u;
--u;
if (op == "+") {
string ch;
cin >> ch;
s[u].push_back(ch[0] - 'a');
for (int i = u == 0 ? ((int)s[0].size() - 1) : 0; i <= (int)s[0].size();
++i)
for (int j = u == 1 ? ((int)s[1].size() - 1) : 0; j <= (int)s[1].size();
++j)
for (int k = u == 2 ? ((int)s[2].size() - 1) : 0;
k <= (int)s[2].size(); ++k) {
if (u == 0) dp[i + 1][j][k] = N + 1;
if (u == 1) dp[i][j + 1][k] = N + 1;
if (u == 2) dp[i][j][k + 1] = N + 1;
}
for (int i = u == 0 ? ((int)s[0].size() - 1) : 0; i <= (int)s[0].size();
++i)
for (int j = u == 1 ? ((int)s[1].size() - 1) : 0; j <= (int)s[1].size();
++j)
for (int k = u == 2 ? ((int)s[2].size() - 1) : 0;
k <= (int)s[2].size(); ++k) {
if (i < (int)s[0].size())
dp[i + 1][j][k] =
min(dp[i + 1][j][k], step[dp[i][j][k]][s[0][i]] + 1);
if (j < (int)s[1].size())
dp[i][j + 1][k] =
min(dp[i][j + 1][k], step[dp[i][j][k]][s[1][j]] + 1);
if (k < (int)s[2].size())
dp[i][j][k + 1] =
min(dp[i][j][k + 1], step[dp[i][j][k]][s[2][k]] + 1);
}
} else {
s[u].pop_back();
}
cout << ((dp[s[0].size()][s[1].size()][s[2].size()] <= N) ? "YES\n"
: "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int maxN = 255;
int dp[maxN][maxN][maxN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<vector<int>> a(26, vector<int>(n + 2, n));
string s;
vector<string> ws(4);
cin >> s;
for (int i = 0; i < 26; i++) {
for (int j = n; j >= 0; j--) {
a[i][j] = (s[j] == 'a' + i ? j : a[i][j + 1]);
}
}
for (int i = 0; i < maxN; i++) {
for (int j = 0; j < maxN; j++) {
for (int k = 0; k < maxN; k++) {
dp[i][j][k] = n;
}
}
}
dp[0][0][0] = -1;
while (q--) {
char c1, c2;
int p;
cin >> c1 >> p;
if (c1 == '+') {
cin >> c2;
ws[p].push_back(c2);
int sz1 = ws[1].size(), sz2 = ws[2].size(), sz3 = ws[3].size();
int imin = p == 1 ? sz1 : 0;
int jmin = p == 2 ? sz2 : 0;
int kmin = p == 3 ? sz3 : 0;
for (int i = imin; i <= sz1; i++) {
for (int j = jmin; j <= sz2; j++) {
for (int k = kmin; k <= sz3; k++) {
int val = n;
if (i) val = min(val, a[ws[1][i - 1] - 'a'][dp[i - 1][j][k] + 1]);
if (j) val = min(val, a[ws[2][j - 1] - 'a'][dp[i][j - 1][k] + 1]);
if (k) val = min(val, a[ws[3][k - 1] - 'a'][dp[i][j][k - 1] + 1]);
dp[i][j][k] = val;
}
}
}
} else {
ws[p].pop_back();
}
cout << (dp[ws[1].size()][ws[2].size()][ws[3].size()] < n ? "YES" : "NO")
<< '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 251;
const int M = 2e5 + 5;
const int star = 16;
const int MOD = 1e9 + 7;
int nxt[26][M], dp[N][N][N][3];
int get(int i, int j, int k, int l) {
int go = -1;
if (l == 0) {
for (int ll = 0; ll < 3; ll++)
if (dp[i - 1][j][k][ll] != -1) {
if (go == -1)
go = dp[i - 1][j][k][ll];
else
go = min(go, dp[i - 1][j][k][ll]);
}
} else if (l == 1) {
for (int ll = 0; ll < 3; ll++)
if (dp[i][j - 1][k][ll] != -1) {
if (go == -1)
go = dp[i][j - 1][k][ll];
else
go = min(go, dp[i][j - 1][k][ll]);
}
} else {
for (int ll = 0; ll < 3; ll++)
if (dp[i][j][k - 1][ll] != -1) {
if (go == -1)
go = dp[i][j][k - 1][ll];
else
go = min(go, dp[i][j][k - 1][ll]);
}
}
return go;
}
int main() {
int n, q, i, j, k, l, a, b, c;
cin >> n >> q;
string s, A = "", B = "", C = "";
cin >> s;
a = b = c = 0;
for (i = n - 1; i >= 0; i--) {
for (j = 0; j < 26; j++) {
nxt[j][i] = -1;
if (s[i] - 'a' == j) {
nxt[j][i] = i + 1;
} else if (i < n - 1)
nxt[j][i] = nxt[j][i + 1];
}
}
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
for (k = 0; k < N; k++)
for (l = 0; l < 3; l++) dp[i][j][k][l] = -1;
dp[0][0][0][0] = dp[0][0][0][1] = dp[0][0][0][2] = 0;
while (q--) {
char type, add;
int rel;
cin >> type;
if (type == '+') {
cin >> rel >> add;
int al, bl, cl, ah, bh, ch;
if (rel == 1) {
a++;
al = a;
ah = a;
bl = 0;
bh = b;
cl = 0;
ch = c;
A += add;
} else if (rel == 2) {
b++;
al = 0;
ah = a;
bl = b;
bh = b;
cl = 0;
ch = c;
B += add;
} else {
c++;
al = 0;
ah = a;
bl = 0;
bh = b;
cl = c;
ch = c;
C += add;
}
for (i = al; i <= ah; i++)
for (j = bl; j <= bh; j++)
for (k = cl; k <= ch; k++) {
dp[i][j][k][0] = dp[i][j][k][1] = dp[i][j][k][2] = -1;
int go;
if (i > 0) {
go = get(i, j, k, 0);
if (go != -1 && go < n) dp[i][j][k][0] = nxt[A[i - 1] - 'a'][go];
}
if (j > 0) {
go = get(i, j, k, 1);
if (go != -1 && go < n) dp[i][j][k][1] = nxt[B[j - 1] - 'a'][go];
}
if (k > 0) {
go = get(i, j, k, 2);
if (go != -1 && go < n) dp[i][j][k][2] = nxt[C[k - 1] - 'a'][go];
}
}
} else {
cin >> rel;
if (rel == 1) {
a--;
A.pop_back();
} else if (rel == 2) {
b--;
B.pop_back();
} else {
c--;
C.pop_back();
}
}
if (dp[a][b][c][0] != -1 || dp[a][b][c][1] != -1 || dp[a][b][c][2] != -1) {
cout << "YES\n";
} else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int INF = 0x3f3f3f3f;
char s[maxn], t[4][255];
int dp[255][255][255], len[4];
int nxt[maxn][26];
void update(int id) {
for (int i = id == 1 ? len[1] : 0; i <= len[1]; ++i) {
for (int j = id == 2 ? len[2] : 0; j <= len[2]; ++j) {
for (int k = id == 3 ? len[3] : 0; k <= len[3]; ++k) {
dp[i][j][k] = INF;
if (i && dp[i - 1][j][k] != INF)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k] + 1][t[1][i] - 'a']);
if (j && dp[i][j - 1][k] != INF)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k] + 1][t[2][j] - 'a']);
if (k && dp[i][j][k - 1] != INF)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1] + 1][t[3][k] - 'a']);
}
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
scanf("%s", s + 1);
for (int i = 0; i < 26; ++i) {
nxt[n + 1][i] = INF;
for (int j = n; j; --j) {
nxt[j][i] = nxt[j + 1][i];
if (s[j] - 'a' == i) nxt[j][i] = j;
}
}
char ch1, ch2, id, cmd[10];
while (m--) {
getchar();
scanf("%[^'\n']s", cmd);
ch1 = cmd[0];
id = cmd[2] - '0';
if (ch1 == '+') {
ch2 = cmd[4];
t[id][++len[id]] = ch2;
update(id);
} else if (ch1 == '-') {
--len[id];
}
if (dp[len[1]][len[2]][len[3]] != INF)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr long long TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
template <class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (int i = 0; i < (v.size()); i++) {
if (i) os << ",";
os << v[i];
}
os << "}";
return os;
}
const int maxn = 100010;
const int maxl = 260;
inline void chmin(int& x, int y) {
if (x > y) x = y;
}
int nx[30][maxn];
int dp[maxl][maxl][maxl];
int main() {
int n, q;
cin >> n >> q;
string sx;
cin >> sx;
for (int j = 0; j < (26); j++) nx[j][n] = n;
for (int i = n - 1; i >= 0; --i) {
int c = sx[i] - 'a';
for (int j = 0; j < (26); j++) nx[j][i] = nx[j][i + 1];
nx[c][i] = i;
}
for (int j = 0; j < (maxl); j++)
for (int k = 0; k < (maxl); k++)
for (int l = 0; l < (maxl); l++) dp[j][k][l] = maxn;
dp[0][0][0] = 0;
string s[3];
for (int i = 0; i < (q); i++) {
char type, cc = '!';
int id;
cin >> type >> id;
--id;
if (type == '+') {
cin >> cc;
s[id].push_back(cc);
int sl = s[id].size();
if (id == 0) {
for (int k = 0; k < (s[1].size() + 1); k++)
for (int l = 0; l < (s[2].size() + 1); l++) {
if (sl > 0 && dp[sl - 1][k][l] < n) {
int c = s[0].back() - 'a';
chmin(dp[sl][k][l], nx[c][dp[sl - 1][k][l]] + 1);
}
if (k > 0 && dp[sl][k - 1][l] < n) {
int c = s[1][k - 1] - 'a';
chmin(dp[sl][k][l], nx[c][dp[sl][k - 1][l]] + 1);
}
if (l > 0 && dp[sl][k][l - 1] < n) {
int c = s[2][l - 1] - 'a';
chmin(dp[sl][k][l], nx[c][dp[sl][k][l - 1]] + 1);
}
}
} else if (id == 1) {
for (int k = 0; k < (s[0].size() + 1); k++)
for (int l = 0; l < (s[2].size() + 1); l++) {
if (sl > 0 && dp[k][sl - 1][l] < n) {
int c = s[1].back() - 'a';
chmin(dp[k][sl][l], nx[c][dp[k][sl - 1][l]] + 1);
}
if (k > 0 && dp[k - 1][sl][l] < n) {
int c = s[0][k - 1] - 'a';
chmin(dp[k][sl][l], nx[c][dp[k - 1][sl][l]] + 1);
}
if (l > 0 && dp[k][sl][l - 1] < n) {
int c = s[2][l - 1] - 'a';
chmin(dp[k][sl][l], nx[c][dp[k][sl][l - 1]] + 1);
}
}
} else {
for (int k = 0; k < (s[0].size() + 1); k++)
for (int l = 0; l < (s[1].size() + 1); l++) {
if (sl > 0 && dp[k][l][sl - 1] < n) {
int c = s[2].back() - 'a';
chmin(dp[k][l][sl], nx[c][dp[k][l][sl - 1]] + 1);
}
if (k > 0 && dp[k - 1][l][sl] < n) {
int c = s[0][k - 1] - 'a';
chmin(dp[k][l][sl], nx[c][dp[k - 1][l][sl]] + 1);
}
if (l > 0 && dp[k][l - 1][sl] < n) {
int c = s[1][l - 1] - 'a';
chmin(dp[k][l][sl], nx[c][dp[k][l - 1][sl]] + 1);
}
}
}
} else {
int sl = s[id].size();
if (id == 0) {
for (int k = 0; k < (maxl); k++)
for (int l = 0; l < (maxl); l++) {
dp[sl][k][l] = maxn;
}
} else if (id == 1) {
for (int k = 0; k < (maxl); k++)
for (int l = 0; l < (maxl); l++) {
dp[k][sl][l] = maxn;
}
} else {
for (int k = 0; k < (maxl); k++)
for (int l = 0; l < (maxl); l++) {
dp[k][l][sl] = maxn;
}
}
s[id].pop_back();
}
puts(dp[s[0].size()][s[1].size()][s[2].size()] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, i0, n, m, nexts[100005][26], cnt, dp[255][255][255];
vector<int> v[4];
char s[100005];
int main() {
scanf("%d %d", &n, &m);
scanf("%s", s + 1);
for (i = 0; i < 26; i++) nexts[0][i] = INT_MAX;
for (i = n; i; i--) {
for (i0 = 0; i0 < 26; i0++) nexts[i][i0] = nexts[0][i0];
nexts[0][s[i] - 'a'] = i;
}
while (m--) {
char op;
scanf(" %c", &op);
if (op == '+') {
int x;
char y;
scanf("%d %c", &x, &y);
v[x].push_back(y - 'a');
if (x == 1) {
for (i = 0; i <= v[2].size(); i++) {
for (i0 = 0; i0 <= v[3].size(); i0++) {
int d = INT_MAX;
if (v[1].size() - 1 >= 0 && dp[v[1].size() - 1][i][i0] != INT_MAX)
d = min(d, nexts[dp[v[1].size() - 1][i][i0]][y - 'a']);
if (i - 1 >= 0 && dp[v[1].size()][i - 1][i0] != INT_MAX)
d = min(d, nexts[dp[v[1].size()][i - 1][i0]][v[2][i - 1]]);
if (i0 - 1 >= 0 && dp[v[1].size()][i][i0 - 1] != INT_MAX)
d = min(d, nexts[dp[v[1].size()][i][i0 - 1]][v[3][i0 - 1]]);
dp[v[1].size()][i][i0] = d;
}
}
}
if (x == 2) {
for (i = 0; i <= v[1].size(); i++) {
for (i0 = 0; i0 <= v[3].size(); i0++) {
int d = INT_MAX;
if (v[2].size() - 1 >= 0 && dp[i][v[2].size() - 1][i0] != INT_MAX)
d = min(d, nexts[dp[i][v[2].size() - 1][i0]][y - 'a']);
if (i - 1 >= 0 && dp[i - 1][v[2].size()][i0] != INT_MAX)
d = min(d, nexts[dp[i - 1][v[2].size()][i0]][v[1][i - 1]]);
if (i0 - 1 >= 0 && dp[i][v[2].size()][i0 - 1] != INT_MAX)
d = min(d, nexts[dp[i][v[2].size()][i0 - 1]][v[3][i0 - 1]]);
dp[i][v[2].size()][i0] = d;
}
}
}
if (x == 3) {
for (i = 0; i <= v[1].size(); i++) {
for (i0 = 0; i0 <= v[2].size(); i0++) {
int d = INT_MAX;
if (v[3].size() - 1 >= 0 && dp[i][i0][v[3].size() - 1] != INT_MAX)
d = min(d, nexts[dp[i][i0][v[3].size() - 1]][y - 'a']);
if (i - 1 >= 0 && dp[i - 1][i0][v[3].size()] != INT_MAX)
d = min(d, nexts[dp[i - 1][i0][v[3].size()]][v[1][i - 1]]);
if (i0 - 1 >= 0 && dp[i][i0 - 1][v[3].size()] != INT_MAX)
d = min(d, nexts[dp[i][i0 - 1][v[3].size()]][v[2][i0 - 1]]);
dp[i][i0][v[3].size()] = d;
}
}
}
} else {
int x;
scanf("%d", &x);
v[x].pop_back();
}
if (dp[v[1].size()][v[2].size()][v[3].size()] != INT_MAX)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
template <typename T>
struct hash_map_t {
vector<T> v, val, nxt;
vector<int> head;
int mod, tot, lastv;
T lastans;
bool have_ans;
hash_map_t(int md = 0) {
head.clear();
v.clear();
val.clear();
nxt.clear();
tot = 0;
mod = md;
nxt.resize(1);
v.resize(1);
val.resize(1);
head.resize(mod);
have_ans = 0;
}
bool count(int x) {
int u = x % mod;
for (register int i = head[u]; i; i = nxt[i]) {
if (v[i] == x) {
have_ans = 1;
lastv = x;
lastans = val[i];
return 1;
}
}
return 0;
}
void ins(int x, int y) {
int u = x % mod;
nxt.push_back(head[u]);
head[u] = ++tot;
v.push_back(x);
val.push_back(y);
}
int qry(int x) {
if (have_ans && lastv == x) return lastans;
count(x);
return lastans;
}
};
const int N = 1e5 + 5;
int f[255][255][255], nxt[N][26];
int len[5], wz[N];
char c[N], str[5][N];
int n, q;
char readchar() {
char c = getchar();
while (c != '+' && c != '-' && !(c >= 'a' && c <= 'z')) c = getchar();
return c;
}
void chkmin(int &x, int y) {
if (y == -1) {
y = N + 1;
}
x = min(x, y);
}
void calc(int x, int y, int z) {
f[x][y][z] = N + 1;
if (x && ~f[x - 1][y][z])
chkmin(f[x][y][z], nxt[f[x - 1][y][z]][str[1][x] - 'a']);
if (y && ~f[x][y - 1][z])
chkmin(f[x][y][z], nxt[f[x][y - 1][z]][str[2][y] - 'a']);
if (z && ~f[x][y][z - 1])
chkmin(f[x][y][z], nxt[f[x][y][z - 1]][str[3][z] - 'a']);
if (f[x][y][z] == N + 1) f[x][y][z] = -1;
if (!x && !y && !z) f[x][y][z] = 0;
}
int main() {
read(n);
read(q);
scanf("%s", c + 1);
for (register int i = 0; i < 26; i++) wz[i] = -1;
for (register int i = n; i >= 0; i--) {
for (register int j = 0; j < 26; j++) nxt[i][j] = wz[j];
if (!i) break;
wz[c[i] - 'a'] = i;
}
f[0][0][0] = 0;
while (q--) {
char opt = readchar();
if (opt == '+') {
int t;
read(t);
char v = readchar();
str[t][len[t] + 1] = v;
if (t == 1) {
++len[1];
for (register int j = 0; j <= len[2]; j++) {
for (register int k = 0; k <= len[3]; k++) {
calc(len[1], j, k);
}
}
}
if (t == 2) {
++len[2];
for (register int i = 0; i <= len[1]; i++) {
for (register int k = 0; k <= len[3]; k++) {
calc(i, len[2], k);
}
}
}
if (t == 3) {
++len[3];
for (register int i = 0; i <= len[1]; i++) {
for (register int j = 0; j <= len[2]; j++) {
calc(i, j, len[3]);
}
}
}
} else {
int t;
read(t);
if (t == 1) {
--len[1];
for (register int j = 0; j <= len[2]; j++) {
for (register int k = 0; k <= len[3]; k++) {
calc(len[1], j, k);
}
}
}
if (t == 2) {
--len[2];
for (register int i = 0; i <= len[1]; i++) {
for (register int k = 0; k <= len[3]; k++) {
calc(i, len[2], k);
}
}
}
if (t == 3) {
--len[3];
for (register int i = 0; i <= len[1]; i++) {
for (register int j = 0; j <= len[2]; j++) {
calc(i, j, len[3]);
}
}
}
}
if (f[len[1]][len[2]][len[3]] == -1)
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2,Ofast,inline,unroll-all-loops,-ffast-math")
#pragma GCC target("avx,sse2,sse3,sse4,popcnt")
using namespace std;
int nxt[100010][26], f[255][255][255], pos[26], n, q, a = 0, b = 0, c = 0;
char s[100010], A[255], B[255], C[255];
template <class T>
void read(T &x) {
char ch = x = 0;
bool fl = false;
while (!isdigit(ch)) fl |= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x = fl ? -x : x;
}
int main() {
read(n), read(q), scanf("%s", s + 1);
for (int i = 0; i < 26; i++) {
pos[i] = n + 1;
}
memcpy(nxt[n + 1], pos, sizeof(pos));
for (int i = n; ~i; i--) {
memcpy(nxt[i], pos, sizeof(pos)), pos[s[i] - 'a'] = i;
}
char op[10];
for (int i = 1, x; i <= q; i++) {
scanf("%s", op);
if (op[0] == '+') {
read(x), scanf("%s", op);
if (x == 1) {
A[++a] = op[0];
for (int b = 0; b <= ::b; b++) {
for (int c = 0; c <= ::c; c++) {
f[a][b][c] = 1 << 30;
if (a)
f[a][b][c] = min(f[a][b][c], nxt[f[a - 1][b][c]][A[a] - 'a']);
if (b)
f[a][b][c] = min(f[a][b][c], nxt[f[a][b - 1][c]][B[b] - 'a']);
if (c)
f[a][b][c] = min(f[a][b][c], nxt[f[a][b][c - 1]][C[c] - 'a']);
}
}
}
if (x == 2) {
B[++b] = op[0];
for (int a = 0; a <= ::a; a++) {
for (int c = 0; c <= ::c; c++) {
f[a][b][c] = 1 << 30;
if (a)
f[a][b][c] = min(f[a][b][c], nxt[f[a - 1][b][c]][A[a] - 'a']);
if (b)
f[a][b][c] = min(f[a][b][c], nxt[f[a][b - 1][c]][B[b] - 'a']);
if (c)
f[a][b][c] = min(f[a][b][c], nxt[f[a][b][c - 1]][C[c] - 'a']);
}
}
}
if (x == 3) {
C[++c] = op[0];
for (int a = 0; a <= ::a; a++) {
for (int b = 0; b <= ::b; b++) {
f[a][b][c] = 1 << 30;
if (a)
f[a][b][c] = min(f[a][b][c], nxt[f[a - 1][b][c]][A[a] - 'a']);
if (b)
f[a][b][c] = min(f[a][b][c], nxt[f[a][b - 1][c]][B[b] - 'a']);
if (c)
f[a][b][c] = min(f[a][b][c], nxt[f[a][b][c - 1]][C[c] - 'a']);
}
}
}
} else {
read(x);
if (x == 1) a--;
if (x == 2) b--;
if (x == 3) c--;
}
puts(f[a][b][c] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
constexpr int INF = 1e9;
int main() {
using namespace std;
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int n, q;
cin >> n >> q;
vector<char> str(n + 1);
for (int i = 1; i <= n; ++i) cin >> str[i];
vector<array<int, 26>> next(n + 2);
for (int i = 0; i < 26; ++i) {
next[n + 1][i] = INF;
for (int j = n; j; --j) {
if (str[j] == 'a' + i) {
next[j][i] = j;
} else {
next[j][i] = next[j + 1][i];
}
}
}
static array<int, 4> len;
static array<array<char, 255>, 4> cur;
static array<array<array<int, 255>, 255>, 255> dp;
auto update = [&](int x) -> void {
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] = INF;
if (i && dp[i - 1][j][k] != INF) {
dp[i][j][k] =
min(dp[i][j][k], next[dp[i - 1][j][k] + 1][cur[1][i] - 'a']);
}
if (j && dp[i][j - 1][k] != INF) {
dp[i][j][k] =
min(dp[i][j][k], next[dp[i][j - 1][k] + 1][cur[2][j] - 'a']);
}
if (k && dp[i][j][k - 1] != INF) {
dp[i][j][k] =
min(dp[i][j][k], next[dp[i][j][k - 1] + 1][cur[3][k] - 'a']);
}
}
}
}
};
while (q--) {
char c;
cin >> c;
if (c == '+') {
int i;
cin >> i >> c;
cur[i][++len[i]] = c;
update(i);
} else {
int i;
cin >> i;
--len[i];
}
cout << (dp[len[1]][len[2]][len[3]] != INF ? "YES\n" : "NO\n");
}
}
|
#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 = n;
if (dp[a - 1][i][j] < nxt)
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] < nxt)
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] < nxt)
nxt = min(nxt, *lower_bound(v[sc[j - 1]].begin(),
v[sc[j - 1]].end(), dp[a][i][j - 1]));
dp[a][i][j] = nxt + 1;
}
} else if (k == 2) {
sb[b++] = qs[0];
for (int i = 0; i <= a; i++)
for (int j = 0; j <= c; j++) {
nxt = n;
if (dp[i][b - 1][j] < nxt)
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] < nxt)
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] < nxt)
nxt = min(nxt, *lower_bound(v[sc[j - 1]].begin(),
v[sc[j - 1]].end(), dp[i][b][j - 1]));
dp[i][b][j] = nxt + 1;
}
} else {
sc[c++] = qs[0];
for (int i = 0; i <= a; i++)
for (int j = 0; j <= b; j++) {
nxt = n;
if (dp[i][j][c - 1] < nxt)
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] < nxt)
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] < nxt)
nxt = min(nxt, *lower_bound(v[sb[j - 1]].begin(),
v[sb[j - 1]].end(), dp[i][j - 1][c]));
dp[i][j][c] = nxt + 1;
}
}
} else {
cin >> k;
if (k == 1)
a--;
else if (k == 2)
b--;
else
c--;
}
if (dp[a][b][c] <= n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using ll = int;
const long long mod = 1e12 + 7;
const ll N = 2e5 + 5;
const int base = 400;
using ull = unsigned long long;
using namespace std;
string s, s1, s2, s3;
ll n, m, t, k, T, cnt, u, tong, v, a[N], ans, b[N], d[N][30], dp[260][260][260];
vector<ll> adj[N];
ll pw(ll k, ll n) {
ll total = 1;
for (; n; n >>= 1) {
if (n & 1) total = (total * k) % mod;
k = (k * k) % mod;
}
return total;
}
ll C(ll u, ll v) {
if (u > v) return 0;
ll t = v / u;
ll k = v % u;
return k * (t + 1) * (t + 1) + (u - k) * t * t;
}
void sol() {
cin >> n >> m >> s;
for (int i = 0; i < 26; i++) d[n + 1][i] = d[n + 2][i] = n + 1;
for (int i = n; i > 0; i--) {
for (int j = 0; j < 26; j++) d[i][j] = d[i + 1][j];
k = s[i - 1] - 'a';
d[i][k] = i;
}
ll n1 = 0, n2 = 0, n3 = 0;
while (m-- > 0) {
char ch;
ll tt;
cin >> ch;
if (ch == '+') {
cin >> tt >> ch;
k = ch - 'a';
if (tt == 1) {
s1 += ch;
++n1;
for (int l = 0; l <= n2; l++) {
for (int r = 0; r <= n3; r++) {
dp[n1][l][r] = d[dp[n1 - 1][l][r] + 1][k];
if (l > 0) {
t = s2[l - 1] - 'a';
dp[n1][l][r] = min(dp[n1][l][r], d[dp[n1][l - 1][r] + 1][t]);
}
if (r > 0) {
t = s3[r - 1] - 'a';
dp[n1][l][r] = min(dp[n1][l][r], d[dp[n1][l][r - 1] + 1][t]);
}
}
}
} else if (tt == 2) {
++n2;
s2 += ch;
for (int l = 0; l <= n1; l++) {
for (int r = 0; r <= n3; r++) {
dp[l][n2][r] = d[dp[l][n2 - 1][r] + 1][k];
if (l > 0) {
t = s1[l - 1] - 'a';
dp[l][n2][r] = min(dp[l][n2][r], d[dp[l - 1][n2][r] + 1][t]);
}
if (r > 0) {
t = s3[r - 1] - 'a';
dp[l][n2][r] = min(dp[l][n2][r], d[dp[l][n2][r - 1] + 1][t]);
}
}
}
} else {
++n3;
s3 += ch;
for (int l = 0; l <= n1; l++) {
for (int r = 0; r <= n2; r++) {
dp[l][r][n3] = d[dp[l][r][n3 - 1] + 1][k];
if (l > 0) {
t = s1[l - 1] - 'a';
dp[l][r][n3] = min(dp[l][r][n3], d[dp[l - 1][r][n3] + 1][t]);
}
if (r > 0) {
t = s2[r - 1] - 'a';
dp[l][r][n3] = min(dp[l][r][n3], d[dp[l][r - 1][n3] + 1][t]);
}
}
}
}
} else {
cin >> tt;
if (tt == 1) {
--n1;
s1.pop_back();
} else if (tt == 2) {
--n2;
s2.pop_back();
} else {
--n3;
s3.pop_back();
}
}
if (dp[n1][n2][n3] <= n) {
cout << "YES" << '\n';
} else
cout << "NO" << '\n';
}
}
int main() {
if (fopen("sequence"
".in",
"r")) {
freopen(
"sequence"
".in",
"r", stdin);
freopen(
"sequence"
".out",
"w", stdout);
}
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int ntest;
ntest = 1;
while (ntest-- > 0) sol();
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long nm = 0;
bool fh = true;
char cw = getchar();
for (; !isdigit(cw); cw = getchar()) fh ^= (cw == '-');
for (; isdigit(cw); cw = getchar()) nm = nm * 10 + (cw - '0');
return fh ? nm : -nm;
}
inline char readcw() {
char cw = getchar();
for (; (cw ^ '+') && (cw ^ '-') && (cw < 'a' || cw > 'z'); cw = getchar())
;
return cw;
}
int n, Q, F[252][252][252], last[252], nt[100020][32], Top1, Top2, Top3;
char ch[100020], S1[252], S2[252], S3[252];
inline void update(int x) {
for (int i = (x == 1) ? Top1 - 1 : 0; i <= Top1; i++)
for (int j = (x == 2) ? Top2 - 1 : 0; j <= Top2; j++)
for (int k = (x == 3) ? Top3 - 1 : 0; k <= Top3; k++) {
if (i + j + k > 0)
F[i][j][k] = n + 1;
else
F[i][j][k] = 0;
if (i > 0 && F[i - 1][j][k] < n)
F[i][j][k] = min(F[i][j][k], nt[F[i - 1][j][k]][S1[i] - 'a']);
if (j > 0 && F[i][j - 1][k] < n)
F[i][j][k] = min(F[i][j][k], nt[F[i][j - 1][k]][S2[j] - 'a']);
if (k > 0 && F[i][j][k - 1] < n)
F[i][j][k] = min(F[i][j][k], nt[F[i][j][k - 1]][S3[k] - 'a']);
}
}
int main() {
n = read(), Q = read(), scanf("%s", ch + 1);
for (int i = 0; i < 26; i++) last[i] = n + 1;
for (int i = n; ~i; --i) {
memcpy(nt[i], last, sizeof(nt[i]));
if (i) last[ch[i] - 'a'] = i;
}
while (Q--) {
char op = readcw(), cw;
int x;
if (op == '+') {
x = read(), cw = readcw();
if (x == 1) S1[++Top1] = cw;
if (x == 2) S2[++Top2] = cw;
if (x == 3) S3[++Top3] = cw;
update(x);
} else {
x = read();
if (x == 1) --Top1;
if (x == 2) --Top2;
if (x == 3) --Top3;
}
puts(F[Top1][Top2][Top3] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using std::min;
int next[100010][30], dp[300][300][300], len[5];
char ss[5][100010];
int main() {
int n, q;
char s[100010];
scanf("%d %d %s", &n, &q, s + 1);
for (int i = 0; i <= n + 5; i++) {
for (int j = 0; j < 26; j++) {
next[i][j] = n + 1;
}
}
for (int i = n; 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--) {
int a;
char op, b;
scanf(" %c", &op);
if (op == '+') {
scanf("%d %c", &a, &b);
len[a]++;
ss[a][len[a]] = b;
for (int i = (a == 1 ? len[a] : 0); i <= len[1]; i++) {
for (int j = (a == 2 ? len[a] : 0); j <= len[2]; j++) {
for (int k = (a == 3 ? len[a] : 0); k <= len[3]; k++) {
dp[i][j][k] = n + 1;
if (i)
dp[i][j][k] =
min(dp[i][j][k], next[dp[i - 1][j][k] + 1][ss[1][i] - 'a']);
if (j)
dp[i][j][k] =
min(dp[i][j][k], next[dp[i][j - 1][k] + 1][ss[2][j] - 'a']);
if (k)
dp[i][j][k] =
min(dp[i][j][k], next[dp[i][j][k - 1] + 1][ss[3][k] - 'a']);
}
}
}
} else {
scanf("%d", &a);
len[a]--;
}
if (dp[len[1]][len[2]][len[3]] > n)
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
inline int rd() {
int first = 0;
char p = getchar();
while (p < '0' || p > '9') p = getchar();
while (p >= '0' && p <= '9') first = first * 10 + p - '0', p = getchar();
return first;
}
const int N = 1e5 + 10, M = 300;
int n, q;
char s[N], a[4][M];
int dp[M][M][M], nxt[N][27], len[4];
void upd(int first) {
for (int i = first == 1 ? len[1] : 0; i <= len[1]; ++i) {
for (int j = first == 2 ? len[2] : 0; j <= len[2]; ++j) {
for (int k = first == 3 ? len[3] : 0; k <= len[3]; ++k) {
int &r = dp[i][j][k] = n + 2;
if (i && dp[i - 1][j][k] + 1 <= n)
r = min(r, nxt[dp[i - 1][j][k] + 1][a[1][i] - 'a']);
if (j && dp[i][j - 1][k] + 1 <= n)
r = min(r, nxt[dp[i][j - 1][k] + 1][a[2][j] - 'a']);
if (k && dp[i][j][k - 1] + 1 <= n)
r = min(r, nxt[dp[i][j][k - 1] + 1][a[3][k] - 'a']);
}
}
}
}
int main() {
scanf("%d%d%s", &n, &q, s + 1);
for (int i = 'a'; i <= 'z'; ++i) {
nxt[n + 1][i - 'a'] = n + 2;
for (int j = n; j >= 1; --j) {
if (s[j] == i)
nxt[j][i - 'a'] = j;
else
nxt[j][i - 'a'] = nxt[j + 1][i - 'a'];
}
}
for (int i = 1; i <= q; ++i) {
char op, c;
int first;
scanf(" %c%d", &op, &first);
if (op == '+') {
scanf(" %c", &c);
a[first][++len[first]] = c;
upd(first);
} else
--len[first];
puts(dp[len[1]][len[2]][len[3]] <= n ? "YES" : "NO");
}
}
|
#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wunused-function"
using namespace std;
namespace {
namespace shik {
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%" SCNd64, &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%" PRId64, x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
template <class T, class F = less<T>>
void sort_uniq(vector<T> &v, F f = F()) {
sort(begin(v), end(v), f);
v.resize(unique(begin(v), end(v)) - begin(v));
}
template <class T>
inline T bit(T x, int i) {
return (x >> i) & 1;
}
template <class T>
inline bool chkmax(T &a, const T &b) {
return b > a ? a = b, true : false;
}
template <class T>
inline bool chkmin(T &a, const T &b) {
return b < a ? a = b, true : false;
}
template <class T>
using MaxHeap = priority_queue<T>;
template <class T>
using MinHeap = priority_queue<T, vector<T>, greater<T>>;
const int N = 1e5 + 10;
const int M = 1010;
int n, m, nxt[N][26], fa[3][M], qp[M][3], ec[3][M];
vector<int> e[3][M];
char wu[N];
int nq[3] = {1, 1, 1};
vector<int> _dp;
int &dp(int a, int b, int c) { return _dp[a * nq[1] * nq[2] + b * nq[2] + c]; }
void main() {
R(n, m, wu);
for (int i = 0; i < int(26); i++) nxt[n][i] = n;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < int(26); j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][wu[i] - 'a'] = i;
}
int p[3] = {};
for (int i = 0; i < int(m); i++) {
char op;
int id;
R(op, id);
id--;
if (op == '+') {
char ch;
R(ch);
e[id][p[id]].push_back(nq[id]);
ec[id][nq[id]] = ch - 'a';
fa[id][nq[id]] = p[id];
p[id] = nq[id]++;
} else if (op == '-') {
p[id] = fa[id][p[id]];
} else
assert(0);
for (int j = 0; j < int(3); j++) qp[i][j] = p[j];
}
_dp.resize(nq[0] * nq[1] * nq[2]);
for (int &x : _dp) x = n;
dp(0, 0, 0) = -1;
for (int i = 0; i < int(nq[0]); i++)
for (int j = 0; j < int(nq[1]); j++)
for (int k = 0; k < int(nq[2]); k++) {
int me = dp(i, j, k);
if (me == n) continue;
for (int to : e[0][i]) chkmin(dp(to, j, k), nxt[me + 1][ec[0][to]]);
for (int to : e[1][j]) chkmin(dp(i, to, k), nxt[me + 1][ec[1][to]]);
for (int to : e[2][k]) chkmin(dp(i, j, to), nxt[me + 1][ec[2][to]]);
}
for (int i = 0; i < int(m); i++) {
int x = dp(qp[i][0], qp[i][1], qp[i][2]);
W(x < n ? "YES" : "NO");
}
}
} // namespace shik
} // namespace
int main() {
shik::main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 250 + 10;
const int inf = 1e8;
int n, dp[maxn][maxn][maxn], nex[30][100000 + 10];
string reg[4];
void update(int fi, int se, int th) {
dp[fi][se][th] = inf;
if (fi > 0 and dp[fi - 1][se][th] <= n) {
int idx = dp[fi - 1][se][th];
int k = (int)(reg[1][fi - 1] - 'a');
int badi = nex[k][idx + 1];
if (badi != -1) dp[fi][se][th] = min(dp[fi][se][th], badi);
}
if (se > 0 and dp[fi][se - 1][th] <= n) {
int idx = dp[fi][se - 1][th];
int k = (int)(reg[2][se - 1] - 'a');
int badi = nex[k][idx + 1];
if (badi != -1) dp[fi][se][th] = min(dp[fi][se][th], badi);
}
if (th > 0 and dp[fi][se][th - 1] <= n) {
int idx = dp[fi][se][th - 1];
int k = (int)(reg[3][th - 1] - 'a');
int badi = nex[k][idx + 1];
if (badi != -1) dp[fi][se][th] = min(dp[fi][se][th], badi);
}
}
int main() {
ios_base::sync_with_stdio(false);
int q;
cin >> n >> q;
string s;
cin >> s;
memset(nex, -1, sizeof nex);
for (int i = 0; i < 26; i++) {
int last = -1;
for (int j = n; j >= 1; j--) {
if ((int)(s[j - 1] - 'a') == i) last = j;
nex[i][j] = last;
}
}
memset(dp, 63, sizeof dp);
dp[0][0][0] = 0;
while (q--) {
char type;
cin >> type;
if (type == '+') {
int t;
char x;
cin >> t >> x;
reg[t] += x;
int k = (int)(x - 'a');
if (t == 1)
for (int i = 0; i <= reg[2].size(); i++)
for (int j = 0; j <= reg[3].size(); j++) update(reg[1].size(), i, j);
if (t == 2)
for (int i = 0; i <= reg[1].size(); i++)
for (int j = 0; j <= reg[3].size(); j++) update(i, reg[2].size(), j);
if (t == 3)
for (int i = 0; i <= reg[1].size(); i++)
for (int j = 0; j <= reg[2].size(); j++) update(i, j, reg[3].size());
} else {
int t;
cin >> t;
reg[t].pop_back();
}
if (dp[reg[1].size()][reg[2].size()][reg[3].size()] > s.size())
cout << "NO\n";
else
cout << "YES\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &val) {
int x = 0;
int bz = 1;
char c;
for (c = getchar(); (c < '0' || c > '9') && c != '-'; c = getchar())
;
if (c == '-') {
bz = -1;
c = getchar();
}
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
val = x * bz;
}
const int INF = 0x3f3f3f3f;
const int maxn = 2e5 + 100;
const int mod = 998244353;
int nxt[maxn][27];
int dp[300][300][300];
int n, m;
char S[maxn];
char s[4][maxn];
int len[3];
void cal(int i, int j, int k) {
dp[i][j][k] = n + 1;
if (i) dp[i][j][k] = min(nxt[dp[i - 1][j][k]][s[1][i] - 'a'], dp[i][j][k]);
if (j) dp[i][j][k] = min(nxt[dp[i][j - 1][k]][s[2][j] - 'a'], dp[i][j][k]);
if (k) dp[i][j][k] = min(nxt[dp[i][j][k - 1]][s[3][k] - 'a'], dp[i][j][k]);
}
int main() {
read(n);
read(m);
scanf("%s", S + 1);
S[n + 1] = 'z' + 1;
for (int i = 0; i <= 25; i++) nxt[n + 1][i] = n + 1;
for (int i = n; i >= 0; i--) {
for (int j = 0; j <= 25; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][S[i + 1] - 'a'] = i + 1;
}
int n1 = 0, n2 = 0, n3 = 0;
while (m--) {
char tmp[10];
scanf("%s", tmp);
if (tmp[0] == '+') {
int id;
scanf("%d%s", &id, tmp);
s[id][++len[id]] = tmp[0];
int mi1 = (id != 1 ? 0 : len[1]), mi2 = (id != 2 ? 0 : len[2]),
mi3 = (id != 3 ? 0 : len[3]);
for (int i = mi1; i <= len[1]; i++) {
for (int j = mi2; j <= len[2]; j++) {
for (int k = mi3; k <= len[3]; k++) {
cal(i, j, k);
}
}
}
} else {
int id;
read(id);
len[id]--;
}
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, inf;
int ne[100010][26];
int dp[260][260][260];
int now[4] = {};
string S, R[4];
int main() {
cin >> N >> Q >> S;
inf = N + 1;
for (int i = 0; i <= N + 1; i++)
for (int j = 0; j < 26; j++) ne[i][j] = inf;
for (int i = N; i >= 1; i--) {
for (int j = 0; j < 26; j++) {
if (S[i - 1] - 'a' == j)
ne[i - 1][j] = i;
else
ne[i - 1][j] = ne[i][j];
}
}
for (int i = 0; i <= N + 1; i++) {
for (int j = 0; j < 4; j++) {
cerr << ne[i][j] << " ";
}
cerr << endl;
}
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] = inf;
dp[0][0][0] = 0;
char type, c;
int r;
for (int i = 0; i < Q; i++) {
cin >> type;
if (type == '+') {
cin >> r >> c;
R[r] += c;
now[r]++;
if (r == 1) {
for (int j = 0; j <= now[2]; j++) {
for (int k = 0; k <= now[3]; k++) {
int a = ne[dp[now[r] - 1][j][k]][R[1][now[1] - 1] - 'a'];
if (j > 0) a = min(a, ne[dp[now[r]][j - 1][k]][R[2][j - 1] - 'a']);
if (k > 0) a = min(a, ne[dp[now[r]][j][k - 1]][R[3][k - 1] - 'a']);
dp[now[r]][j][k] = a;
}
}
} else if (r == 2) {
for (int i = 0; i <= now[1]; i++) {
for (int k = 0; k <= now[3]; k++) {
int a = ne[dp[i][now[r] - 1][k]][R[2][now[2] - 1] - 'a'];
if (i > 0) a = min(a, ne[dp[i - 1][now[r]][k]][R[1][i - 1] - 'a']);
if (k > 0) a = min(a, ne[dp[i][now[r]][k - 1]][R[3][k - 1] - 'a']);
dp[i][now[r]][k] = a;
}
}
} else {
for (int i = 0; i <= now[1]; i++) {
for (int j = 0; j <= now[2]; j++) {
int a = ne[dp[i][j][now[r] - 1]][R[3][now[3] - 1] - 'a'];
if (i > 0) a = min(a, ne[dp[i - 1][j][now[r]]][R[1][i - 1] - 'a']);
if (j > 0) a = min(a, ne[dp[i][j - 1][now[r]]][R[2][j - 1] - 'a']);
dp[i][j][now[r]] = a;
}
}
}
} else {
cin >> r;
R[r].pop_back();
now[r]--;
}
cout << (dp[now[1]][now[2]][now[3]] < N + 1 ? "YES" : "NO") << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MAXL = 255;
const int INF = (long long)1e9 + 5;
const long long MOD = 998244353;
int N, Q, nxt[MAXN][128], dp[MAXL][MAXL][MAXL];
string s, q[5];
vector<int> occ[128];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> Q >> s;
for (int i = 0; i < s.size(); i++) {
occ[s[i]].push_back(i);
}
for (int t = 0; t < 128; t++) {
int ptr2 = 0;
for (int i = 0; i <= s.size(); i++) {
nxt[i][t] = INF;
while (ptr2 < occ[t].size() && occ[t][ptr2] < i) ptr2++;
if (ptr2 < occ[t].size()) {
nxt[i][t] = occ[t][ptr2];
}
}
}
for (int i = 0; i < Q; i++) {
char t, add;
int id;
cin >> t >> id;
if (t == '+') {
cin >> add;
q[id].push_back(add);
if (id == 1) {
for (int i = 0; i <= q[2].size(); i++) {
for (int j = 0; j <= q[3].size(); j++) {
int best = INF, k = q[id].size(), ch = q[id].back();
if (k > 0 && dp[k - 1][i][j] <= N)
best = min(best, nxt[dp[k - 1][i][j]][q[1][k - 1]] + 1);
if (i > 0 && dp[k][i - 1][j] <= N)
best = min(best, nxt[dp[k][i - 1][j]][q[2][i - 1]] + 1);
if (j > 0 && dp[k][i][j - 1] <= N)
best = min(best, nxt[dp[k][i][j - 1]][q[3][j - 1]] + 1);
dp[k][i][j] = best;
}
}
} else if (id == 2) {
for (int i = 0; i <= q[1].size(); i++) {
for (int j = 0; j <= q[3].size(); j++) {
int best = INF, k = q[id].size(), ch = q[id].back();
if (i > 0 && dp[i - 1][k][j] <= N)
best = min(best, nxt[dp[i - 1][k][j]][q[1][i - 1]] + 1);
if (k > 0 && dp[i][k - 1][j] <= N)
best = min(best, nxt[dp[i][k - 1][j]][q[2][k - 1]] + 1);
if (j > 0 && dp[i][k][j - 1] <= N)
best = min(best, nxt[dp[i][k][j - 1]][q[3][j - 1]] + 1);
dp[i][k][j] = best;
}
}
} else {
for (int i = 0; i <= q[1].size(); i++) {
for (int j = 0; j <= q[2].size(); j++) {
int best = INF, k = q[id].size();
if (i > 0 && dp[i - 1][j][k] <= N)
best = min(best, nxt[dp[i - 1][j][k]][q[1][i - 1]] + 1);
if (j > 0 && dp[i][j - 1][k] <= N)
best = min(best, nxt[dp[i][j - 1][k]][q[2][j - 1]] + 1);
if (k > 0 && dp[i][j][k - 1] <= N)
best = min(best, nxt[dp[i][j][k - 1]][q[3][k - 1]] + 1);
dp[i][j][k] = best;
}
}
}
} else {
if (!q[id].empty()) {
q[id].pop_back();
}
}
if (dp[q[1].size()][q[2].size()][q[3].size()] <= N) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int MAX_N = 100100;
constexpr int MAX_LEN = 255;
constexpr int ALPHA = 26;
int n, m;
char s[MAX_N];
int nxt[MAX_N][ALPHA];
int last[ALPHA];
int dp[MAX_LEN][MAX_LEN][MAX_LEN];
vector<int> words[3];
int combine(int x, int y) {
if (x == -1) return y;
if (y == -1) return x;
return min(x, y);
}
int get_nxt(int i, int j) {
if (i == -1) return -1;
return nxt[i][j];
}
void update(int a, int b, int c) {
int best = -1;
if (a > 0) best = combine(best, get_nxt(dp[a - 1][b][c], words[0][a - 1]));
if (b > 0) best = combine(best, get_nxt(dp[a][b - 1][c], words[1][b - 1]));
if (c > 0) best = combine(best, get_nxt(dp[a][b][c - 1], words[2][c - 1]));
dp[a][b][c] = best;
}
int main() {
scanf(" %d %d", &n, &m);
scanf(" %s", s + 1);
for (int i = 1; i <= n; ++i) s[i] -= 'a';
memset(nxt, -1, sizeof(nxt));
memset(last, -1, sizeof(last));
for (int i = n; i >= 0; --i) {
for (int c = 0; c < ALPHA; ++c) {
nxt[i][c] = last[c];
}
last[s[i]] = i;
}
dp[0][0][0] = 0;
for (int i = 0; i < m; ++i) {
char typ;
int idx;
scanf(" %c %d", &typ, &idx);
--idx;
if (typ == '+') {
char let;
scanf(" %c", &let);
words[idx].push_back(let - 'a');
if (idx == 0) {
for (int b = 0; b <= words[1].size(); ++b) {
for (int c = 0; c <= words[2].size(); ++c) {
dp[words[0].size()][b][c] = -1;
}
}
for (int b = 0; b <= words[1].size(); ++b) {
for (int c = 0; c <= words[2].size(); ++c) {
update(words[0].size(), b, c);
}
}
} else if (idx == 1) {
for (int a = 0; a <= words[0].size(); ++a) {
for (int c = 0; c <= words[2].size(); ++c) {
dp[a][words[1].size()][c] = -1;
}
}
for (int a = 0; a <= words[0].size(); ++a) {
for (int c = 0; c <= words[2].size(); ++c) {
update(a, words[1].size(), c);
}
}
} else if (idx == 2) {
for (int a = 0; a <= words[0].size(); ++a) {
for (int b = 0; b <= words[1].size(); ++b) {
dp[a][b][words[2].size()] = -1;
}
}
for (int a = 0; a <= words[0].size(); ++a) {
for (int b = 0; b <= words[1].size(); ++b) {
update(a, b, words[2].size());
}
}
}
} else if (typ == '-') {
words[idx].pop_back();
} else {
assert(false);
}
printf(
"%s\n",
dp[(int)words[0].size()][(int)words[1].size()][(int)words[2].size()] ==
-1
? "NO"
: "YES");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[251][251][251];
char str[1000000];
char s[4][300];
int cpos[30], nt_pos[1000000][30];
int n, q;
void init() {
for (int i = 0; i < 26; ++i) {
cpos[i] = n + 1;
}
for (int i = n; i >= 0; --i) {
for (int j = 0; j < 26; ++j) {
nt_pos[i][j] = cpos[j];
}
if (i == 0) break;
cpos[str[i] - 'a'] = i;
}
}
int nt(int pos, char c) {
if (pos > n) return pos;
return nt_pos[pos][c - 'a'];
}
int min_t(int a, int b) {
if (a == -1) return b;
if (b == -1) return a;
return min(a, b);
}
int start[4], pos[4];
int main() {
cin >> n >> q;
cin >> str + 1;
init();
memset(dp, -1, sizeof(dp));
dp[0][0][0] = 0;
while (q--) {
int c;
char op, x;
cin >> op >> c;
if (op == '+') {
cin >> x;
pos[c]++;
s[c][pos[c]] = x;
memset(start, 0, sizeof(start));
start[c] = pos[c] - 1;
for (int i = start[1]; i <= pos[1]; ++i) {
for (int j = start[2]; j <= pos[2]; ++j) {
for (int k = start[3]; k <= pos[3]; ++k) {
if (dp[i][j][k] == -1) continue;
if (i + 1 <= pos[1])
dp[i + 1][j][k] =
min_t(nt(dp[i][j][k], s[1][i + 1]), dp[i + 1][j][k]);
if (j + 1 <= pos[2])
dp[i][j + 1][k] =
min_t(nt(dp[i][j][k], s[2][j + 1]), dp[i][j + 1][k]);
if (k + 1 <= pos[3])
dp[i][j][k + 1] =
min_t(nt(dp[i][j][k], s[3][k + 1]), dp[i][j][k + 1]);
}
}
}
if (dp[pos[1]][pos[2]][pos[3]] <= n) {
printf("YES\n");
} else {
printf("NO\n");
}
} else {
memset(start, 0, sizeof(start));
start[c] = pos[c];
for (int i = start[1]; i <= pos[1]; ++i)
for (int j = start[2]; j <= pos[2]; ++j)
for (int k = start[3]; k <= pos[3]; ++k) dp[i][j][k] = -1;
pos[c]--;
if (dp[pos[1]][pos[2]][pos[3]] <= n) {
printf("YES\n");
} else {
printf("NO\n");
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110000, M = 260, infty = 1000000000;
int n, q, len[3];
char s[N], ss[3][M];
int memo[M][M][M], nextt[N][26];
bool ismemo[M][M][M];
int calc(int a0, int a1, int a2) {
int a[3] = {a0, a1, a2};
if (ismemo[a0][a1][a2]) return memo[a0][a1][a2];
int best = infty;
for (int i = 0; i < (3); ++i)
if (a[i] > 0) {
--a[i];
int w = calc(a[0], a[1], a[2]);
if (w < n) {
best = min(best, nextt[w][ss[i][a[i]] - 'a'] + 1);
}
++a[i];
}
ismemo[a0][a1][a2] = 1;
return memo[a0][a1][a2] = best;
}
int main() {
scanf("%d%d%s", &n, &q, s);
ismemo[0][0][0] = 1;
memo[0][0][0] = 0;
for (int j = 0; j < (26); ++j) nextt[n][j] = infty;
for (int i = (n)-1; i >= 0; --i) {
for (int j = 0; j < (26); ++j) nextt[i][j] = nextt[i + 1][j];
nextt[i][s[i] - 'a'] = i;
}
for (int i = 0; i < (q); ++i) {
char c;
int k;
scanf(" %c%d", &c, &k);
--k;
if (c == '-') {
if (k == 0) {
for (int a1 = 0; a1 < (len[1] + 1); ++a1)
for (int a2 = 0; a2 < (len[2] + 1); ++a2) ismemo[len[0]][a1][a2] = 0;
} else if (k == 1) {
for (int a0 = 0; a0 < (len[0] + 1); ++a0)
for (int a2 = 0; a2 < (len[2] + 1); ++a2) ismemo[a0][len[1]][a2] = 0;
} else {
for (int a0 = 0; a0 < (len[0] + 1); ++a0)
for (int a1 = 0; a1 < (len[1] + 1); ++a1) ismemo[a0][a1][len[2]] = 0;
}
len[k]--;
} else {
char ch;
scanf(" %c", &ch);
ss[k][len[k]++] = ch;
}
int w = calc(len[0], len[1], len[2]);
puts(w == infty ? "NO" : "YES");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005, maxk = 27, maxm = 255;
int n, q;
int fir[maxn][maxk], len[4], f[maxm][maxm][maxm], s[4][maxm];
string S;
int main() {
scanf("%d%d", &n, &q);
cin >> S, S = " " + S;
for (int i = 1; i <= 26; i++) fir[n + 1][i] = fir[n + 2][i] = n + 1;
for (int i = n; i >= 1; i--)
for (int j = 1; j <= 26; j++)
fir[i][j] = S[i] - 96 == j ? i : fir[i + 1][j];
while (q--) {
char t, c;
int x;
for (t = getchar(); t != '+' && t != '-'; t = getchar())
;
scanf("%d", &x);
if (t == '+') {
for (c = getchar(); c < 'a' || c > 'z'; c = getchar())
;
len[x]++, s[x][len[x]] = c - 96;
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] = n + 1;
f[i][j][k] = min(f[i][j][k],
i == 0 ? n + 1 : fir[f[i - 1][j][k] + 1][s[1][i]]);
f[i][j][k] = min(f[i][j][k],
j == 0 ? n + 1 : fir[f[i][j - 1][k] + 1][s[2][j]]);
f[i][j][k] = min(f[i][j][k],
k == 0 ? n + 1 : fir[f[i][j][k - 1] + 1][s[3][k]]);
}
} else
len[x]--;
puts(f[len[1]][len[2]][len[3]] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
constexpr int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
constexpr int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T>
bool chmin(T& a, const T& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, q;
cin >> n >> q;
string s;
cin >> s;
vvi pos(26);
string a, b, c;
for (ll i = 0; i < ll(n); ++i) pos[s[i] - 'a'].push_back(i);
auto f = [&](char c, int i) {
auto tmp = lower_bound((pos[c - 'a']).begin(), (pos[c - 'a']).end(), i);
if (tmp == pos[c - 'a'].end()) return (int)1000000001ll;
return *tmp + 1;
};
vector<vvi> dp(251, vvi(251, vi(251, 1000000001ll)));
dp[0][0][0] = 0;
for (ll aa = 0; aa < ll(q); ++aa) {
char t;
cin >> t;
if (t == '+') {
int p;
char s;
cin >> p >> s;
p--;
if (p == 0)
a += s;
else if (p == 1)
b += s;
else
c += s;
if (p == 0) {
for (ll i = 0; i < ll(b.size() + 1); ++i)
for (ll j = 0; j < ll(c.size() + 1); ++j) {
dp[a.size()][i][j] = 1000000001ll;
}
for (ll i = 0; i < ll(b.size() + 1); ++i)
for (ll j = 0; j < ll(c.size() + 1); ++j) {
chmin(dp[a.size()][i][j], f(s, dp[a.size() - 1][i][j]));
if (i != 0)
chmin(dp[a.size()][i][j], f(b[i - 1], dp[a.size()][i - 1][j]));
if (j != 0)
chmin(dp[a.size()][i][j], f(c[j - 1], dp[a.size()][i][j - 1]));
}
} else if (p == 1) {
for (ll i = 0; i < ll(a.size() + 1); ++i)
for (ll j = 0; j < ll(c.size() + 1); ++j) {
dp[i][b.size()][j] = 1000000001ll;
}
for (ll i = 0; i < ll(a.size() + 1); ++i)
for (ll j = 0; j < ll(c.size() + 1); ++j) {
chmin(dp[i][b.size()][j], f(s, dp[i][b.size() - 1][j]));
if (i != 0)
chmin(dp[i][b.size()][j], f(a[i - 1], dp[i - 1][b.size()][j]));
if (j != 0)
chmin(dp[i][b.size()][j], f(c[j - 1], dp[i][b.size()][j - 1]));
}
} else {
for (ll i = 0; i < ll(a.size() + 1); ++i)
for (ll j = 0; j < ll(b.size() + 1); ++j) {
dp[i][j][c.size()] = 1000000001ll;
}
for (ll i = 0; i < ll(a.size() + 1); ++i)
for (ll j = 0; j < ll(b.size() + 1); ++j) {
chmin(dp[i][j][c.size()], f(s, dp[i][j][c.size() - 1]));
if (i != 0)
chmin(dp[i][j][c.size()], f(a[i - 1], dp[i - 1][j][c.size()]));
if (j != 0)
chmin(dp[i][j][c.size()], f(b[j - 1], dp[i][j - 1][c.size()]));
}
}
} else {
int p;
cin >> p;
if (p == 1)
a.pop_back();
else if (p == 2)
b.pop_back();
else
c.pop_back();
}
if (dp[a.size()][b.size()][c.size()] <= n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 100100;
const int MS = 300;
char st[MN];
vector<int> v[3];
int hp[MN][26];
char sr[MS][3];
int sp[3];
int dp[MS][MS][MS];
int ds(int a, int b, int c) {
if (a + b + c == 0) return 0;
if (dp[a][b][c] != -1) return dp[a][b][c];
int ma = MN;
if (a > 0) ma = min(ma, 1 + hp[ds(a - 1, b, c)][sr[a - 1][0] - 'a']);
if (b > 0) ma = min(ma, 1 + hp[ds(a, b - 1, c)][sr[b - 1][1] - 'a']);
if (c > 0) ma = min(ma, 1 + hp[ds(a, b, c - 1)][sr[c - 1][2] - 'a']);
return dp[a][b][c] = ma;
}
int main() {
int n, q;
scanf("%d %d ", &n, &q);
memset(dp, -1, sizeof(dp));
scanf("%s ", st);
for (int i = 0; i < 26; i++) {
hp[n + 2][i] = hp[n + 1][i] = hp[n][i] = n + 1;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
hp[i][j] = (j == st[i] - 'a') ? i : hp[i + 1][j];
}
}
while (q--) {
char a;
int b;
scanf("%c %d ", &a, &b);
b--;
if (a == '+') {
char c;
scanf("%c ", &c);
sr[sp[b]++][b] = c;
for (int i = 0; i < MS; i++) {
for (int j = 0; j < MS; j++) {
switch (b) {
case 0:
dp[sp[b]][i][j] = -1;
break;
case 1:
dp[i][sp[b]][j] = -1;
break;
case 2:
dp[i][j][sp[b]] = -1;
break;
}
}
}
} else {
sp[b]--;
}
printf("%s\n", ds(sp[0], sp[1], sp[2]) <= n ? "YES" : "NO");
}
}
|
#include <bits/stdc++.h>
const int N = 100000 + 10;
const int M = 250 + 10;
const int C = 26;
inline void applyMin(int &x, const int &y) { x = (y < x) ? y : x; }
int n, q;
int s[N];
int nex[N][C];
int a[3][M];
int b[3];
int f[M][M][M];
void ReadData() {
scanf("%d%d", &n, &q);
static char str[N];
scanf("%s", str + 1);
for (int i = 1; i <= n; i++) s[i] = (str[i] - 'a');
}
void InitNex() {
for (int j = 0; j < C; j++) nex[n + 1][j] = n + 1;
for (int i = n; i >= 0; i--)
for (int j = 0; j < C; j++)
nex[i][j] = (s[i + 1] == j) ? i + 1 : nex[i + 1][j];
}
void Expand(int x, int c) {
if (x == 0) {
for (int i = 0; i <= b[1]; i++)
for (int j = 0; j <= b[2]; j++) {
applyMin(f[b[0] + 1][i][j], nex[f[b[0]][i][j]][c]);
if (i < b[1])
applyMin(f[b[0] + 1][i + 1][j], nex[f[b[0] + 1][i][j]][a[1][i + 1]]);
if (j < b[2])
applyMin(f[b[0] + 1][i][j + 1], nex[f[b[0] + 1][i][j]][a[2][j + 1]]);
}
a[0][++b[0]] = c;
} else if (x == 1) {
for (int i = 0; i <= b[0]; i++)
for (int j = 0; j <= b[2]; j++) {
applyMin(f[i][b[1] + 1][j], nex[f[i][b[1]][j]][c]);
if (i < b[0])
applyMin(f[i + 1][b[1] + 1][j], nex[f[i][b[1] + 1][j]][a[0][i + 1]]);
if (j < b[2])
applyMin(f[i][b[1] + 1][j + 1], nex[f[i][b[1] + 1][j]][a[2][j + 1]]);
}
a[1][++b[1]] = c;
} else {
for (int i = 0; i <= b[0]; i++)
for (int j = 0; j <= b[1]; j++) {
applyMin(f[i][j][b[2] + 1], nex[f[i][j][b[2]]][c]);
if (i < b[0])
applyMin(f[i + 1][j][b[2] + 1], nex[f[i][j][b[2] + 1]][a[0][i + 1]]);
if (j < b[1])
applyMin(f[i][j + 1][b[2] + 1], nex[f[i][j][b[2] + 1]][a[1][j + 1]]);
}
a[2][++b[2]] = c;
}
}
void Backspace(int x) {
if (x == 0) {
for (int i = 0; i <= b[1]; i++)
for (int j = 0; j <= b[2]; j++) f[b[0]][i][j] = n + 1;
b[0]--;
} else if (x == 1) {
for (int i = 0; i <= b[0]; i++)
for (int j = 0; j <= b[2]; j++) f[i][b[1]][j] = n + 1;
b[1]--;
} else {
for (int i = 0; i <= b[0]; i++)
for (int j = 0; j <= b[1]; j++) f[i][j][b[2]] = n + 1;
b[2]--;
}
}
void AnswerQuery() {
for (int i = 0; i <= 250; i++)
for (int j = 0; j <= 250; j++)
for (int k = 0; k <= 250; k++) f[i][j][k] = n + 1;
f[0][0][0] = 0;
for (int i = 1; i <= q; i++) {
char opt[2];
int x;
char c[2];
scanf("%s", opt);
if (opt[0] == '+') {
scanf("%d%s", &x, c);
Expand(x - 1, c[0] - 'a');
} else {
scanf("%d", &x);
Backspace(x - 1);
}
puts(f[b[0]][b[1]][b[2]] <= n ? "YES" : "NO");
}
}
int main() {
ReadData();
InitNex();
AnswerQuery();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = (int)1e5 + 100;
const int maxK = 255;
int nxt[maxN][26];
char s[maxN];
int n, q;
int dp[maxK][maxK][maxK];
int len[3];
int a[3][maxK];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
srand(228);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
for (int i = 0; i < 26; i++) {
nxt[n][i] = n + 1;
for (int j = n - 1; j >= 0; j--) {
nxt[j][i] = nxt[j + 1][i];
if (s[j + 1] == i + 'a') nxt[j][i] = j + 1;
}
}
for (int i = 0; i < maxK; i++) {
for (int j = 0; j < maxK; j++) {
for (int k = 0; k < maxK; k++) {
dp[i][j][k] = n + 1;
}
}
}
dp[0][0][0] = 0;
for (int i = 1; i <= q; i++) {
char tp;
int v;
char c;
cin >> tp >> v;
v--;
if (tp == '-') {
len[v]--;
} else {
cin >> c;
int sy = c - 'a';
a[v][len[v]] = sy;
if (v == 0) {
len[0]++;
for (int j = 0; j <= len[1]; j++) {
for (int k = 0; k <= len[2]; k++) {
dp[len[0]][j][k] = n + 1;
}
}
for (int j = 0; j <= len[1]; j++) {
for (int k = 0; k <= len[2]; k++) {
int pref = dp[len[0] - 1][j][k];
if (pref >= n) continue;
dp[len[0]][j][k] = min(dp[len[0]][j][k], nxt[pref][sy]);
}
}
for (int j = 0; j <= len[1]; j++) {
for (int k = 0; k <= len[2]; k++) {
int pref = dp[len[0]][j][k];
if (pref >= n) continue;
if (j + 1 <= len[1]) {
dp[len[0]][j + 1][k] =
min(dp[len[0]][j + 1][k], nxt[pref][a[1][j]]);
}
if (k + 1 <= len[2]) {
dp[len[0]][j][k + 1] =
min(dp[len[0]][j][k + 1], nxt[pref][a[2][k]]);
}
}
}
} else if (v == 1) {
len[1]++;
for (int j = 0; j <= len[0]; j++) {
for (int k = 0; k <= len[2]; k++) {
dp[j][len[1]][k] = n + 1;
}
}
for (int j = 0; j <= len[0]; j++) {
for (int k = 0; k <= len[2]; k++) {
int pref = dp[j][len[1] - 1][k];
if (pref >= n) continue;
dp[j][len[1]][k] = min(dp[j][len[1]][k], nxt[pref][sy]);
}
}
for (int j = 0; j <= len[0]; j++) {
for (int k = 0; k <= len[2]; k++) {
int pref = dp[j][len[1]][k];
if (pref >= n) continue;
if (j + 1 <= len[0]) {
dp[j + 1][len[1]][k] =
min(dp[j + 1][len[1]][k], nxt[pref][a[0][j]]);
}
if (k + 1 <= len[2]) {
dp[j][len[1]][k + 1] =
min(dp[j][len[1]][k + 1], nxt[pref][a[2][k]]);
}
}
}
} else {
len[2]++;
for (int j = 0; j <= len[0]; j++) {
for (int k = 0; k <= len[1]; k++) {
dp[j][k][len[2]] = n + 1;
}
}
for (int j = 0; j <= len[0]; j++) {
for (int k = 0; k <= len[1]; k++) {
int pref = dp[j][k][len[2] - 1];
if (pref >= n) continue;
dp[j][k][len[2]] = min(dp[j][k][len[2]], nxt[pref][sy]);
}
}
for (int j = 0; j <= len[0]; j++) {
for (int k = 0; k <= len[1]; k++) {
int pref = dp[j][k][len[2]];
if (pref >= n) continue;
if (j + 1 <= len[0]) {
dp[j + 1][k][len[2]] =
min(dp[j + 1][k][len[2]], nxt[pref][a[0][j]]);
}
if (k + 1 <= len[1]) {
dp[j][k + 1][len[2]] =
min(dp[j][k + 1][len[2]], nxt[pref][a[1][k]]);
}
}
}
}
}
if (dp[len[0]][len[1]][len[2]] <= n)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const int MAXN = (int)1e5 + 5;
int n, q;
char s[MAXN];
int dp[255][255][255];
int help[MAXN][26];
string rel[4];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 0; i < 26; i++) help[n + 1][i] = n + 1;
for (int i = n + 1; i > 0; i--) {
for (int j = 0; j < 26; j++) help[i - 1][j] = help[i][j];
if (i != n + 1) help[i - 1][(int)(s[i] - 'a')] = i;
}
int i1 = 0, i2 = 0, i3 = 0;
dp[0][0][0] = 0;
while (q--) {
char c;
cin >> c;
if (c == '+') {
int a;
char b;
cin >> a >> b;
rel[a].push_back(b);
if (a == 1) {
i1++;
for (int j = 0; j <= i2; j++)
for (int k = 0; k <= i3; k++)
dp[i1][j][k] = help[dp[i1 - 1][j][k]][(int)(b - 'a')];
for (int j = 0; j <= i2; j++)
for (int k = 0; k <= i3; k++) {
if (k != 0)
dp[i1][j][k] =
min(dp[i1][j][k],
help[dp[i1][j][k - 1]][(int)(rel[3][k - 1] - 'a')]);
if (j != 0)
dp[i1][j][k] =
min(dp[i1][j][k],
help[dp[i1][j - 1][k]][(int)(rel[2][j - 1] - 'a')]);
}
} else if (a == 2) {
i2++;
for (int j = 0; j <= i1; j++)
for (int k = 0; k <= i3; k++)
dp[j][i2][k] = help[dp[j][i2 - 1][k]][(int)(b - 'a')];
for (int j = 0; j <= i1; j++)
for (int k = 0; k <= i3; k++) {
if (k != 0)
dp[j][i2][k] =
min(dp[j][i2][k],
help[dp[j][i2][k - 1]][(int)(rel[3][k - 1] - 'a')]);
if (j != 0)
dp[j][i2][k] =
min(dp[j][i2][k],
help[dp[j - 1][i2][k]][(int)(rel[1][j - 1] - 'a')]);
}
} else {
i3++;
for (int j = 0; j <= i1; j++)
for (int k = 0; k <= i2; k++)
dp[j][k][i3] = help[dp[j][k][i3 - 1]][(int)(b - 'a')];
for (int j = 0; j <= i1; j++)
for (int k = 0; k <= i2; k++) {
if (k != 0)
dp[j][k][i3] =
min(dp[j][k][i3],
help[dp[j][k - 1][i3]][(int)(rel[2][k - 1] - 'a')]);
if (j != 0)
dp[j][k][i3] =
min(dp[j][k][i3],
help[dp[j - 1][k][i3]][(int)(rel[1][j - 1] - 'a')]);
}
}
} else {
int a;
cin >> a;
rel[a].pop_back();
if (a == 1)
i1--;
else if (a == 2)
i2--;
else
i3--;
}
if (dp[i1][i2][i3] != n + 1)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, a[100010], str[4][255], l1, l2, l3, pos[30];
int table[100010][30], f[255][255][255], id, c;
char s[100010], opt[3], ch[3];
int main() {
scanf("%d %d", &n, &q);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
a[i] = s[i] - 'a';
}
for (int i = 0; i < 26; i++) {
pos[i] = n + 1;
table[n + 1][i] = n + 1;
}
for (int i = n; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
table[i][j] = pos[j];
}
pos[a[i]] = i;
}
while (q--) {
scanf("%s", opt);
if (opt[0] == '+') {
scanf("%d %s", &id, ch);
c = ch[0] - 'a';
if (id == 1) {
str[1][++l1] = c;
for (int i = 0; i <= l2; i++) {
for (int j = 0; j <= l3; j++) {
f[l1][i][j] = table[f[l1 - 1][i][j]][c];
if (i != 0) {
f[l1][i][j] = min(f[l1][i][j], table[f[l1][i - 1][j]][str[2][i]]);
}
if (j != 0) {
f[l1][i][j] = min(f[l1][i][j], table[f[l1][i][j - 1]][str[3][j]]);
}
}
}
} else if (id == 2) {
str[2][++l2] = c;
for (int i = 0; i <= l1; i++) {
for (int j = 0; j <= l3; j++) {
f[i][l2][j] = table[f[i][l2 - 1][j]][c];
if (i != 0) {
f[i][l2][j] = min(f[i][l2][j], table[f[i - 1][l2][j]][str[1][i]]);
}
if (j != 0) {
f[i][l2][j] = min(f[i][l2][j], table[f[i][l2][j - 1]][str[3][j]]);
}
}
}
} else {
str[3][++l3] = c;
for (int i = 0; i <= l1; i++) {
for (int j = 0; j <= l2; j++) {
f[i][j][l3] = table[f[i][j][l3 - 1]][c];
if (i != 0) {
f[i][j][l3] = min(f[i][j][l3], table[f[i - 1][j][l3]][str[1][i]]);
}
if (j != 0) {
f[i][j][l3] = min(f[i][j][l3], table[f[i][j - 1][l3]][str[2][j]]);
}
}
}
}
} else {
scanf("%d", &id);
if (id == 1) {
l1--;
} else if (id == 2) {
l2--;
} else {
l3--;
}
}
if (f[l1][l2][l3] <= n) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, nxt[100005][30], dp[252][252][252];
string s, x[5];
void solve() {
cin >> n >> q >> s;
s = '#' + s;
for (int i = n; i > 0; --i) {
for (int j = 0; j < 26; ++j)
if (i == n)
nxt[i][j] = n + 1;
else
nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i] - 'a'] = 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] = n + 1;
}
}
dp[0][0][0] = 0;
for (int i = 1; i < 4; ++i) x[i] = "";
while (q--) {
char type, y;
int rel;
cin >> type >> rel;
if (type == '-') {
x[rel].pop_back();
if (dp[(int)x[1].size()][(int)x[2].size()][(int)x[3].size()] <= n)
cout << "YES\n";
else
cout << "NO\n";
} else {
cin >> y;
x[rel] += y;
if (rel == 1) {
for (int i = 0; i < (int)x[2].size() + 1; ++i) {
for (int j = 0; j < (int)x[3].size() + 1; ++j) {
int ans = n + 1;
if (dp[(int)x[1].size() - 1][i][j] < n)
ans = nxt[dp[(int)x[1].size() - 1][i][j] + 1][x[1].back() - 'a'];
if (i > 0 && dp[(int)x[1].size()][i - 1][j] < n)
ans = min(
ans,
nxt[dp[(int)x[1].size()][i - 1][j] + 1][x[2][i - 1] - 'a']);
if (j > 0 && dp[(int)x[1].size()][i][j - 1] < n)
ans = min(
ans,
nxt[dp[(int)x[1].size()][i][j - 1] + 1][x[3][j - 1] - 'a']);
dp[(int)x[1].size()][i][j] = ans;
}
}
} else if (rel == 2) {
for (int i = 0; i < (int)x[1].size() + 1; ++i) {
for (int j = 0; j < (int)x[3].size() + 1; ++j) {
int ans = n + 1;
if (dp[i][(int)x[2].size() - 1][j] < n)
ans = nxt[dp[i][(int)x[2].size() - 1][j] + 1][x[2].back() - 'a'];
if (i > 0 && dp[i - 1][(int)x[2].size()][j] < n)
ans = min(
ans,
nxt[dp[i - 1][(int)x[2].size()][j] + 1][x[1][i - 1] - 'a']);
if (j > 0 && dp[i][(int)x[2].size()][j - 1] < n)
ans = min(
ans,
nxt[dp[i][(int)x[2].size()][j - 1] + 1][x[3][j - 1] - 'a']);
dp[i][(int)x[2].size()][j] = ans;
}
}
} else {
for (int i = 0; i < (int)x[1].size() + 1; ++i) {
for (int j = 0; j < (int)x[2].size() + 1; ++j) {
int ans = n + 1;
if (dp[i][j][(int)x[3].size() - 1] < n)
ans = nxt[dp[i][j][(int)x[3].size() - 1] + 1][x[3].back() - 'a'];
if (i > 0 && dp[i - 1][j][(int)x[3].size()] < n)
ans = min(
ans,
nxt[dp[i - 1][j][(int)x[3].size()] + 1][x[1][i - 1] - 'a']);
if (j > 0 && dp[i][j - 1][(int)x[3].size()] < n)
ans = min(
ans,
nxt[dp[i][j - 1][(int)x[3].size()] + 1][x[2][j - 1] - 'a']);
dp[i][j][(int)x[3].size()] = ans;
}
}
}
if (dp[(int)x[1].size()][(int)x[2].size()][(int)x[3].size()] <= n)
cout << "YES\n";
else
cout << "NO\n";
}
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int T = 1;
for (int t = 1; t < T + 1; ++t) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 5e7;
int dp[252][252][252], last[27], nxt[100005][27];
char s[100005], w[4][1005];
int n, m, len[4];
void reset(int u, int v, int q) {
if (!(u + v + q)) {
dp[u][v][q] = 0;
return;
}
dp[u][v][q] = INF;
if (u && INF > dp[u - 1][v][q])
dp[u][v][q] = min(dp[u][v][q], nxt[dp[u - 1][v][q]][w[1][u] - 'a']);
if (v && INF > dp[u][v - 1][q])
dp[u][v][q] = min(dp[u][v][q], nxt[dp[u][v - 1][q]][w[2][v] - 'a']);
if (q && INF > dp[u][v][q - 1])
dp[u][v][q] = min(dp[u][v][q], nxt[dp[u][v][q - 1]][w[3][q] - 'a']);
}
int main() {
scanf("%d%d", &n, &m);
scanf("%s", s + 1);
char f[2], c[2];
for (int i = 0; i < 26; i++) last[i] = INF;
for (int i = n; i >= 0; i--) {
for (int j = 0; j < 26; j++) nxt[i][j] = last[j];
if (i) last[s[i] - 'a'] = i;
}
int u;
for (int qqq = 1; qqq <= m; qqq++) {
scanf("%s", f);
if (f[0] == '+') {
scanf("%d%s", &u, c);
++len[u];
w[u][len[u]] = c[0];
if (u == 1) {
for (int i = 0; i <= len[2]; i++)
for (int j = 0; j <= len[3]; j++) reset(len[1], i, j);
}
if (u == 2) {
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[3]; j++) reset(i, len[2], j);
}
if (u == 3) {
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[2]; j++) reset(i, j, len[3]);
}
} else {
scanf("%d", &u);
--len[u];
}
if (dp[len[1]][len[2]][len[3]] <= n)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
const int M = 26;
const int K = 250;
char world[N];
int n;
char religion[3][K];
int relgionLen[3];
int dp[K + 1][K + 1][K + 1];
int nextC[M][N + 2];
void fillNext() {
for (int j = 0; j < M; j++) nextC[j][n] = nextC[j][n + 1] = n + 1;
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j < M; j++)
nextC[j][i] = j + 'a' == world[i] ? i + 1 : nextC[j][i + 1];
}
void updateDP(int a, int b, int c) {
auto& v = dp[a][b][c];
v = n + 1;
if (a) v = min(v, nextC[religion[0][a - 1] - 'a'][dp[a - 1][b][c]]);
if (b) v = min(v, nextC[religion[1][b - 1] - 'a'][dp[a][b - 1][c]]);
if (c) v = min(v, nextC[religion[2][c - 1] - 'a'][dp[a][b][c - 1]]);
}
void insert(int i, char c) {
religion[i][relgionLen[i]++] = c;
int l[3] = {0, 0, 0};
l[i] = relgionLen[i];
for (int a = l[0]; a <= relgionLen[0]; a++)
for (int b = l[1]; b <= relgionLen[1]; b++)
for (int c = l[2]; c <= relgionLen[2]; c++) updateDP(a, b, c);
}
void remove(int i) { relgionLen[i]--; }
signed main() {
iostream::sync_with_stdio(false);
int q;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> world[i];
fillNext();
while (q--) {
char t;
int i;
cin >> t >> i;
if (t == '+') {
char c;
cin >> c;
insert(i - 1, c);
} else {
assert(t == '-');
remove(i - 1);
}
bool valid = dp[relgionLen[0]][relgionLen[1]][relgionLen[2]] <= n;
cout << (valid ? "YES" : "NO") << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int maxL = 256;
const int alp = 26;
int n;
int nextCh[N][alp];
string pat;
int f[maxL][maxL][maxL];
string s[3];
bool minimize(int &x, int y) {
if (x > y)
x = y;
else
return 0;
return 1;
}
void calculate(int i0, int i1, int i2) {
if (i0 == 0 && i1 == 0 && i2 == 0) return;
int &ans = f[i0][i1][i2];
ans = n + 1;
if (i0 > 0) minimize(ans, nextCh[f[i0 - 1][i1][i2]][s[0][i0 - 1] - 'a'] + 1);
if (i1 > 0) minimize(ans, nextCh[f[i0][i1 - 1][i2]][s[1][i1 - 1] - 'a'] + 1);
if (i2 > 0) minimize(ans, nextCh[f[i0][i1][i2 - 1]][s[2][i2 - 1] - 'a'] + 1);
}
int main() {
int test;
cin >> n >> test >> pat;
for (int i = 0; i < alp; i++) nextCh[n][i] = nextCh[n + 1][i] = n;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < alp; j++) nextCh[i][j] = nextCh[i + 1][j];
nextCh[i][pat[i] - 'a'] = i;
}
while (test--) {
char ch;
int pos;
cin >> ch >> pos;
pos--;
if (ch == '-')
s[pos].pop_back();
else {
char use;
cin >> use;
s[pos].push_back(use);
for (int i0 = (pos == 0) * s[0].length(); i0 <= s[0].length(); i0++)
for (int i1 = (pos == 1) * s[1].length(); i1 <= s[1].length(); i1++)
for (int i2 = (pos == 2) * s[2].length(); i2 <= s[2].length(); i2++)
calculate(i0, i1, i2);
}
cout << (f[s[0].length()][s[1].length()][s[2].length()] <= n ? "YES\n"
: "NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 2;
const int maxm = 250 + 2;
const int ABC = 26;
int n, q;
char str[maxn];
int cnt[5], low[5];
int nxt[maxn][ABC], a[maxm][5];
int dp[maxm][maxm][maxm];
int change(char ch) { return ch - 'a'; }
int main() {
scanf("%d%d%s", &n, &q, str + 1);
for (int i = 0; i < ABC; i++) nxt[n][i] = nxt[n + 1][i] = n + 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j < ABC; j++) nxt[i - 1][j] = nxt[i][j];
nxt[i - 1][change(str[i])] = i;
}
dp[0][0][0] = 0;
while (q--) {
char type[2], ch[2];
int num;
scanf("%s%d", &type, &num);
if (type[0] == '-') cnt[num]--;
if (type[0] == '+') {
scanf("%s", ch);
a[++cnt[num]][num] = change(ch[0]);
memset(low, 0, sizeof(low));
low[num] = cnt[num];
for (int i = low[1]; i <= cnt[1]; i++)
for (int j = low[2]; j <= cnt[2]; j++)
for (int k = low[3]; k <= cnt[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]][a[i][1]]);
if (j)
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j - 1][k]][a[j][2]]);
if (k)
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j][k - 1]][a[k][3]]);
}
}
if (dp[cnt[1]][cnt[2]][cnt[3]] <= n)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int num = 0, k = 1;
char ch = getchar();
while (ch > '9' || ch < '0') k = ch == '-' ? -1 : 1, ch = getchar();
while (ch <= '9' && ch >= '0') num *= 10, num += ch - 48, ch = getchar();
return num * k;
}
int dp[251][251][251], nxt[100000 + 5][26],
la = 0, lb = 0, lc = 0, a[100000 + 5], b[100000 + 5], c[100000 + 5];
void update(int &x, int y, int z) {
if (!(~y)) return;
if (!nxt[y][z]) return;
if (!(~x))
x = nxt[y][z];
else
x = min(x, nxt[y][z]);
}
char s[100000 + 5], s1[10];
int main() {
int n = read(), q = read();
scanf("%s", s);
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;
}
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] = -1;
dp[0][0][0] = 0;
while (q--) {
scanf("%s", s1);
int pos = read(), tp;
if (s1[0] == '-') {
tp = 0;
} else
tp = 1, scanf("%s", s1);
if (tp) {
if (pos == 1) {
la++;
a[la] = s1[0] - 'a';
for (int i = 0; i <= lb; i++)
for (int j = 0; j <= lc; j++) {
update(dp[la][i][j], dp[la - 1][i][j], a[la]);
if (i) update(dp[la][i][j], dp[la][i - 1][j], b[i]);
if (j) update(dp[la][i][j], dp[la][i][j - 1], c[j]);
}
}
if (pos == 2) {
lb++;
b[lb] = s1[0] - 'a';
for (int i = 0; i <= la; i++)
for (int j = 0; j <= lc; j++) {
update(dp[i][lb][j], dp[i][lb - 1][j], b[lb]);
if (i) update(dp[i][lb][j], dp[i - 1][lb][j], a[i]);
if (j) update(dp[i][lb][j], dp[i][lb][j - 1], c[j]);
}
}
if (pos == 3) {
lc++;
c[lc] = s1[0] - 'a';
for (int i = 0; i <= la; i++)
for (int j = 0; j <= lb; j++) {
update(dp[i][j][lc], dp[i][j][lc - 1], c[lc]);
if (i) update(dp[i][j][lc], dp[i - 1][j][lc], a[i]);
if (j) update(dp[i][j][lc], dp[i][j - 1][lc], b[j]);
}
}
} else {
if (pos == 1) {
la--;
for (int i = 0; i <= lb; i++)
for (int j = 0; j <= lc; j++) dp[la + 1][i][j] = -1;
}
if (pos == 2) {
lb--;
for (int i = 0; i <= la; i++)
for (int j = 0; j <= lc; j++) dp[i][lb + 1][j] = -1;
}
if (pos == 3) {
lc--;
for (int i = 0; i <= la; i++)
for (int j = 0; j <= lb; j++) dp[i][j][lc + 1] = -1;
}
}
if (~dp[la][lb][lc])
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100005;
const int Maxl = 26;
const int Maxm = 252;
int n, q;
char str[Maxn];
int nxt[Maxn][Maxl];
vector<int> V[3];
int dp[Maxm][Maxm][Maxm];
void Forw(int a, int b, int c) {
for (int i = a; i <= V[0].size(); i++)
for (int j = b; j <= V[1].size(); j++)
for (int k = c; k <= V[2].size(); k++)
if (dp[i][j][k] < Maxn) {
int p = dp[i][j][k];
if (i + 1 <= V[0].size() && nxt[p + 1][V[0][i]] < Maxn)
dp[i + 1][j][k] = min(dp[i + 1][j][k], nxt[p + 1][V[0][i]]);
if (j + 1 <= V[1].size() && nxt[p + 1][V[1][j]] < Maxn)
dp[i][j + 1][k] = min(dp[i][j + 1][k], nxt[p + 1][V[1][j]]);
if (k + 1 <= V[2].size() && nxt[p + 1][V[2][k]] < Maxn)
dp[i][j][k + 1] = min(dp[i][j][k + 1], nxt[p + 1][V[2][k]]);
}
}
void Backw(int a, int b, int c) {
for (int i = a; i <= V[0].size(); i++)
for (int j = b; j <= V[1].size(); j++)
for (int k = c; k <= V[2].size(); k++) dp[i][j][k] = Maxn;
}
int main() {
scanf("%d %d", &n, &q);
scanf("%s", str);
for (int j = 0; j < Maxl; j++) nxt[n][j] = Maxn;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < Maxl; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][str[i] - 'a'] = i;
}
fill((int*)dp, (int*)dp + Maxm * Maxm * Maxm, Maxn);
dp[0][0][0] = -1;
while (q--) {
char typ;
int ind;
scanf(" %c %d", &typ, &ind);
ind--;
if (typ == '+') {
char ch;
scanf(" %c", &ch);
V[ind].push_back(ch - 'a');
if (ind == 0)
Forw(int(V[0].size()) - 1, 0, 0);
else if (ind == 1)
Forw(0, int(V[1].size()) - 1, 0);
else if (ind == 2)
Forw(0, 0, int(V[2].size()) - 1);
} else {
if (ind == 0)
Backw(V[0].size(), 0, 0);
else if (ind == 1)
Backw(0, V[1].size(), 0);
else if (ind == 2)
Backw(0, 0, V[2].size());
V[ind].pop_back();
}
printf("%s\n",
dp[V[0].size()][V[1].size()][V[2].size()] < n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int K = 255;
const int inf = 1e9;
int a[N];
int nxt[N][26];
int b[4][K];
int len[4];
int dp[K][K][K];
int n;
void yes() { cout << "YES\n"; }
void no() { cout << "NO\n"; }
void solve(int tp) {
dp[0][0][0] = 0;
int init1, init2, init3;
init1 = init2 = init3 = 0;
if (tp == 1)
init1 = len[1];
else if (tp == 2)
init2 = len[2];
else
init3 = len[3];
for (int i = init1; i <= len[1]; i++) {
for (int j = init2; j <= len[2]; j++) {
for (int k = init3; k <= len[3]; k++) {
int &cur = dp[i][j][k];
if (i || j || k) cur = inf;
if (i && dp[i - 1][j][k] < inf) {
cur = min(cur, nxt[dp[i - 1][j][k]][b[1][i]]);
}
if (j && dp[i][j - 1][k] < inf) {
cur = min(cur, nxt[dp[i][j - 1][k]][b[2][j]]);
}
if (k && dp[i][j][k - 1] < inf) {
cur = min(cur, nxt[dp[i][j][k - 1]][b[3][k]]);
}
}
}
}
if (dp[len[1]][len[2]][len[3]] < inf)
yes();
else
no();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> n >> T;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
a[i] = c - 'a';
}
int lol[26];
for (int i = 0; i < 26; i++) lol[i] = inf;
for (int i = n; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
nxt[i][j] = lol[j];
if (a[i] == j) lol[j] = i;
}
}
while (T--) {
char tp;
int id;
cin >> tp >> id;
if (tp == '+') {
char c;
cin >> c;
len[id]++;
b[id][len[id]] = c - 'a';
solve(id);
} else {
len[id]--;
if (dp[len[1]][len[2]][len[3]] < inf)
yes();
else
no();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int INF = 0x3f3f3f3f;
const int NINF = 0xc0c0c0c0;
const double PI = acos(-1.0);
const int maxn = 1e5 + 5;
char s[maxn];
vector<char> re[5];
int nxt[maxn][30], dp[255][255][255];
int main() {
std::ios::sync_with_stdio(false);
int n, q;
scanf("%d%d", &n, &q);
scanf("%s", s);
int last[30];
for (int i = 0; i < 30; i++) last[i] = n + 1;
for (int i = 0; i < 26; i++) nxt[n + 1][i] = n + 1;
for (int i = n; i >= 0; i--) {
for (int j = 0; j < 26; j++) nxt[i][j] = last[j];
if (i > 0) last[s[i - 1] - 'a'] = i;
}
dp[0][0][0] = 0;
while (q--) {
char op[2], c;
int k;
scanf("%s%d", op, &k);
if (op[0] == '+') {
scanf(" %c", &c);
re[k].push_back(c - 'a');
int mi1 = (k == 1) ? re[k].size() : 0;
int mi2 = (k == 2) ? re[k].size() : 0;
int mi3 = (k == 3) ? re[k].size() : 0;
for (int i = mi1; i <= re[1].size(); i++) {
for (int j = mi2; j <= re[2].size(); j++) {
for (int k = mi3; k <= re[3].size(); k++) {
dp[i][j][k] = n + 1;
if (i)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k]][re[1][i - 1]]);
if (j)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k]][re[2][j - 1]]);
if (k)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1]][re[3][k - 1]]);
}
}
}
} else
re[k].pop_back();
int n1 = re[1].size(), n2 = re[2].size(), n3 = re[3].size();
if (dp[n1][n2][n3] <= n)
puts("YES");
else
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int nxt[26][1010100];
int best[255][255][255];
string s;
int N, M;
string sa[3];
void update(int a1, int a2, int b1, int b2, int c1, int c2) {
for (int a = a1; a <= a2; ++a) {
for (int b = b1; b <= b2; ++b) {
for (int c = c1; c <= c2; ++c) {
best[a][b][c] = N + 1;
if (a == b && b == c && c == 0) {
best[a][b][c] = 0;
continue;
}
if (a) {
int cr = sa[0][a - 1] - 'a';
int val = nxt[cr][best[a - 1][b][c]];
best[a][b][c] = min(best[a][b][c], val);
}
if (b) {
int cr = sa[1][b - 1] - 'a';
int val = nxt[cr][best[a][b - 1][c]];
best[a][b][c] = min(best[a][b][c], val);
}
if (c) {
int cr = sa[2][c - 1] - 'a';
int val = nxt[cr][best[a][b][c - 1]];
best[a][b][c] = min(best[a][b][c], val);
}
}
}
}
}
int main() {
cin >> N >> M;
cin >> s;
for (int i = 0; i < (26); ++i)
nxt[i][(int)(s).size()] = nxt[i][(int)(s).size() + 1] = (int)(s).size() + 1;
for (int i = (int)(s).size() - 1; i >= 0; --i) {
for (int j = 0; j < (26); ++j) nxt[j][i] = nxt[j][i + 1];
nxt[s[i] - 'a'][i] = i + 1;
}
for (int i = 0; i < (M); ++i) {
string s;
int x;
cin >> s >> x;
--x;
if (s == "-") {
sa[x].pop_back();
} else {
string c;
cin >> c;
sa[x] += c;
if (x == 0) {
update((int)(sa[0]).size(), (int)(sa[0]).size(), 0, (int)(sa[1]).size(),
0, (int)(sa[2]).size());
} else if (x == 1) {
update(0, (int)(sa[0]).size(), (int)(sa[1]).size(), (int)(sa[1]).size(),
0, (int)(sa[2]).size());
} else {
update(0, (int)(sa[0]).size(), 0, (int)(sa[1]).size(),
(int)(sa[2]).size(), (int)(sa[2]).size());
}
}
if (best[(int)(sa[0]).size()][(int)(sa[1]).size()][(int)(sa[2]).size()] <=
N) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int pre[100009][26], sz[3];
char s[100009];
const int N = 251;
int dp[N][N][N], n, q;
int adj[3][N], t[3];
void solve(int x) {
for (int i = 0; i < 3; i++) t[i] = 0;
t[x] = sz[x];
for (int i = t[0]; i <= sz[0]; i++)
for (int j = t[1]; j <= sz[1]; j++)
for (int k = t[2]; k <= sz[2]; k++) {
if (i + j + k != 0) dp[i][j][k] = n + 1;
if (i) umin(dp[i][j][k], pre[dp[i - 1][j][k] + 1][adj[0][i]]);
if (j) umin(dp[i][j][k], pre[dp[i][j - 1][k] + 1][adj[1][j]]);
if (k) umin(dp[i][j][k], pre[dp[i][j][k - 1] + 1][adj[2][k]]);
}
}
int main() {
scanf("%d%d", &n, &q);
scanf("%s", s + 1);
for (int i = 0; i < 26; i++) pre[n + 1][i] = pre[n + 2][i] = 1000000007;
for (int i = n; i >= 1; i--) {
for (int j = 0; j < 26; j++) pre[i][j] = pre[i + 1][j];
pre[i][s[i] - 'a'] = i;
}
for (int i = 0; i < 3; i++) adj[i][0] = -1;
while (q--) {
char x, y;
int t;
scanf(" %c%d", &x, &t);
if (x == '+') {
scanf(" %c", &y);
adj[t - 1][++sz[t - 1]] = y - 'a';
solve(t - 1);
} else
sz[t - 1]--;
if (dp[sz[0]][sz[1]][sz[2]] <= n)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, l[5], dp[252][252][252];
int nexT[110000][30];
char s[111000], a[3][252];
int min(int aa, int bb) {
if (aa < bb) {
return aa;
} else {
return bb;
}
}
int main() {
cin >> n >> q;
cin >> s + 1;
for (int x = 0; x < 27; x++) {
nexT[n][x] = n + 1;
nexT[n + 1][x] = n + 1;
}
for (int x = n - 1; x >= 0; x--) {
for (int y = 0; y < 26; y++) {
nexT[x][y] = nexT[x + 1][y];
}
nexT[x][s[x + 1] - 'a'] = x + 1;
}
while (q--) {
char op[2];
int id;
cin >> op >> id;
id--;
if (op[0] == '-') {
l[id]--;
} else {
char ch[2];
cin >> ch;
a[id][++l[id]] = ch[0];
if (id == 0) {
int x = l[0];
for (int y = 0; y <= l[1]; y++) {
for (int z = 0; z <= l[2]; z++) {
dp[x][y][z] = n + 1;
if (x) {
dp[x][y][z] =
min(dp[x][y][z], nexT[dp[x - 1][y][z]][a[0][x] - 'a']);
}
if (y) {
dp[x][y][z] =
min(dp[x][y][z], nexT[dp[x][y - 1][z]][a[1][y] - 'a']);
}
if (z) {
dp[x][y][z] =
min(dp[x][y][z], nexT[dp[x][y][z - 1]][a[2][z] - 'a']);
}
}
}
} else if (id == 1) {
int y = l[1];
for (int x = 0; x <= l[0]; x++) {
for (int z = 0; z <= l[2]; z++) {
dp[x][y][z] = n + 1;
if (x) {
dp[x][y][z] =
min(dp[x][y][z], nexT[dp[x - 1][y][z]][a[0][x] - 'a']);
}
if (y) {
dp[x][y][z] =
min(dp[x][y][z], nexT[dp[x][y - 1][z]][a[1][y] - 'a']);
}
if (z) {
dp[x][y][z] =
min(dp[x][y][z], nexT[dp[x][y][z - 1]][a[2][z] - 'a']);
}
}
}
} else {
int z = l[2];
for (int x = 0; x <= l[0]; x++) {
for (int y = 0; y <= l[1]; y++) {
dp[x][y][z] = n + 1;
if (x) {
dp[x][y][z] =
min(dp[x][y][z], nexT[dp[x - 1][y][z]][a[0][x] - 'a']);
}
if (y) {
dp[x][y][z] =
min(dp[x][y][z], nexT[dp[x][y - 1][z]][a[1][y] - 'a']);
}
if (z) {
dp[x][y][z] =
min(dp[x][y][z], nexT[dp[x][y][z - 1]][a[2][z] - 'a']);
}
}
}
}
}
if (dp[l[0]][l[1]][l[2]] <= n) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
|
#include <bits/stdc++.h>
const int maxa = 26;
const int maxn = 250 + 7;
const int maxs = 1e5 + 7;
int n, m;
int A, B, C;
int sa[maxn];
int sb[maxn];
int sc[maxn];
char s[maxs];
int p[maxs][maxa];
int f[maxn][maxn][maxn];
int main() {
scanf("%d%d%s", &n, &m, s + 1);
for (int i = 0; i < maxa; ++i) p[n + 1][i] = n + 1;
for (int i = n; i; --i)
for (int j = 0; j < maxa; ++j)
p[i][j] = (s[i] - 'a' == j ? i : p[i + 1][j]);
for (int i = 1, x; i <= m; ++i) {
char ch;
scanf(" %c", &ch);
if (ch == '+') {
scanf("%d %c", &x, &ch);
if (x == 1) sa[++A] = ch - 'a';
if (x == 2) sb[++B] = ch - 'a';
if (x == 3) sc[++C] = ch - 'a';
for (int a = A * (x == 1); a <= A; ++a)
for (int b = B * (x == 2); b <= B; ++b)
for (int c = C * (x == 3); c <= C; ++c) {
f[a][b][c] = n + 1;
if (a && f[a - 1][b][c] < n)
f[a][b][c] = std::min(f[a][b][c], p[f[a - 1][b][c] + 1][sa[a]]);
if (b && f[a][b - 1][c] < n)
f[a][b][c] = std::min(f[a][b][c], p[f[a][b - 1][c] + 1][sb[b]]);
if (c && f[a][b][c - 1] < n)
f[a][b][c] = std::min(f[a][b][c], p[f[a][b][c - 1] + 1][sc[c]]);
}
} else
scanf("%d", &x), A -= (x == 1), B -= (x == 2), C -= (x == 3);
puts(f[A][B][C] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int N = 250;
const int NN = 1e5 + 5;
int memo[N + 5][N + 5][N + 5];
int najb[NN][32];
int n, q, kt, ak[4];
string ss, s[4];
char cc;
int dp(int a, int b, int c) {
if (memo[a][b][c] != -1) return memo[a][b][c];
if (a == 0 && b == 0 && c == 0) return memo[a][b][c] = 0;
memo[a][b][c] = inf;
int pom;
if (a != 0) {
pom = dp(a - 1, b, c);
if (pom < ((int)ss.size()))
memo[a][b][c] = min(memo[a][b][c], najb[pom + 1][s[1][a - 1] - 'a']);
}
if (b != 0) {
pom = dp(a, b - 1, c);
if (pom < ((int)ss.size()))
memo[a][b][c] = min(memo[a][b][c], najb[pom + 1][s[2][b - 1] - 'a']);
}
if (c != 0) {
pom = dp(a, b, c - 1);
if (pom < ((int)ss.size()))
memo[a][b][c] = min(memo[a][b][c], najb[pom + 1][s[3][c - 1] - 'a']);
}
return memo[a][b][c];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 0; i <= N; i++)
for (int j = 0; j <= N; j++)
for (int k = 0; k <= N; k++) memo[i][j][k] = -1;
cin >> n >> q >> ss;
ss = '#' + ss;
for (int j = 0; j <= 'z' - 'a' + 1; j++) najb[((int)ss.size())][j] = inf;
for (int i = ((int)ss.size()) - 1; i >= 1; i--) {
for (int j = 0; j <= 'z' - 'a' + 1; j++) najb[i][j] = najb[i + 1][j];
najb[i][ss[i] - 'a'] = i;
}
for (int te = 1; te <= q; te++) {
cin >> cc >> kt;
if (cc == '+') {
cin >> cc;
s[kt] += cc;
ak[kt]++;
} else {
s[kt].pop_back();
if (kt == 1) {
for (int i = 0; i <= ak[2]; i++)
for (int j = 0; j <= ak[3]; j++) memo[ak[1]][i][j] = -1;
} else if (kt == 2) {
for (int i = 0; i <= ak[1]; i++)
for (int j = 0; j <= ak[3]; j++) memo[i][ak[2]][j] = -1;
} else {
for (int i = 0; i <= ak[1]; i++)
for (int j = 0; j <= ak[2]; j++) memo[i][j][ak[3]] = -1;
}
ak[kt]--;
}
if (dp(ak[1], ak[2], ak[3]) != inf)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.