text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int dp[252][252][252];
int hlp[100010][27];
int n, q;
string s, s1, s2, s3;
void make(int a, int b, int c) {
if (a) {
if (dp[a - 1][b][c] != 2000000011)
dp[a][b][c] = min(dp[a][b][c], hlp[dp[a - 1][b][c]][s1[a - 1] - 'a']);
}
if (b) {
if (dp[a][b - 1][c] != 2000000011)
dp[a][b][c] = min(dp[a][b][c], hlp[dp[a][b - 1][c]][s2[b - 1] - 'a']);
}
if (c) {
if (dp[a][b][c - 1] != 2000000011)
dp[a][b][c] = min(dp[a][b][c], hlp[dp[a][b][c - 1]][s3[c - 1] - 'a']);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q >> s;
for (int i = 0; i < (27); ++i) hlp[n][i] = 2000000011;
for (int i = n - 1; i >= (0); i--) {
for (int j = 0; j < (27); ++j) hlp[i][j] = hlp[i + 1][j];
hlp[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] = 2000000011;
}
}
dp[0][0][0] = 0;
int l1 = 0, l2 = 0, l3 = 0;
for (int I = 0; I < (q); ++I) {
char c;
int par;
cin >> c >> par;
if (c == '+') {
char t;
cin >> t;
if (par == 1) {
s1 += t;
l1++;
for (int i = 0; i <= (l2); i++) {
for (int j = 0; j <= (l3); j++) make(l1, i, j);
}
} else if (par == 2) {
s2 += t;
l2++;
for (int i = 0; i <= (l1); i++) {
for (int j = 0; j <= (l3); j++) make(i, l2, j);
}
} else {
s3 += t;
l3++;
for (int i = 0; i <= (l1); i++) {
for (int j = 0; j <= (l2); j++) make(i, j, l3);
}
}
} else {
if (par == 1) {
for (int i = 0; i <= (l2); i++) {
for (int j = 0; j <= (l3); j++) dp[l1][i][j] = 2000000011;
}
s1.pop_back();
l1--;
} else if (par == 2) {
for (int i = 0; i <= (l1); i++) {
for (int j = 0; j <= (l3); j++) dp[i][l2][j] = 2000000011;
}
s2.pop_back();
l2--;
} else {
for (int i = 0; i <= (l1); i++) {
for (int j = 0; j <= (l2); j++) dp[i][j][l3] = 2000000011;
}
s3.pop_back();
l3--;
}
}
cout << ((dp[l1][l2][l3] <= n) ? "YES\n" : "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:247474112")
#pragma GCC optimize("Ofast")
using namespace std;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const int INF = 0x3f3f3f3f;
void accelerate() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int n, q;
const int MAXN = 1e5 + 1;
string wou;
int dp[251][251][251];
int pos[3][251];
int nex[MAXN][26];
char s[3][251];
int cnt[3];
int solve(int i = cnt[0], int j = cnt[1], int k = cnt[2]) {
if (i == 0 && j == 0 && k == 0) {
return -1;
}
int &res = dp[i][j][k];
if (res != -1) {
return res;
}
res = INF;
if (i > 0) {
int tmp = solve(i - 1, j, k);
if (tmp != INF) res = min(res, nex[tmp + 1][s[0][i - 1] - 'a']);
}
if (j > 0) {
int tmp = solve(i, j - 1, k);
if (tmp != INF) res = min(res, nex[tmp + 1][s[1][j - 1] - 'a']);
}
if (k > 0) {
int tmp = solve(i, j, k - 1);
if (tmp != INF) res = min(res, nex[tmp + 1][s[2][k - 1] - 'a']);
}
return res;
}
int main() {
accelerate();
cin >> n >> q;
cin >> wou;
int pre[26];
memset(nex, INF, sizeof nex);
memset(pre, 0, sizeof pre);
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; ++i) {
int shf = wou[i] - 'a';
for (int j = pre[shf]; j < i + 1; ++j) {
nex[j][shf] = i;
}
pre[shf] = i + 1;
}
for (int i = 0; i < q; ++i) {
char sg;
cin >> sg;
int nm;
cin >> nm;
--nm;
if (sg == '+') {
char ch;
cin >> ch;
s[nm][cnt[nm]] = ch;
++cnt[nm];
for (int t0 = 0; t0 < cnt[(nm + 1) % 3] + 1; ++t0) {
for (int t1 = 0; t1 < cnt[(nm + 2) % 3] + 1; ++t1) {
if (nm == 0) {
dp[cnt[nm]][t0][t1] = -1;
} else if (nm == 1) {
dp[t1][cnt[nm]][t0] = -1;
} else {
dp[t0][t1][cnt[nm]] = -1;
}
}
}
if (solve() != INF) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else {
--cnt[nm];
if (solve() != INF) {
cout << "yes" << endl;
} else {
cout << "no" << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
char str[100010];
int dp[26][100010];
int maxP[260][260][260];
int len[3];
char desc[3][260];
int main(void) {
int N, Q;
cin >> N >> Q;
cin >> str;
for (int i = 0; i < 26; i++) dp[i][N] = 100010;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 26; j++) {
if (str[N - 1 - i] == 'a' + j)
dp[j][N - 1 - i] = N - i;
else
dp[j][N - 1 - i] = dp[j][N - i];
}
}
for (int i = 0; i < 260; i++) {
for (int j = 0; j < 260; j++) {
for (int k = 0; k < 260; k++) maxP[i][j][k] = 100010;
}
}
maxP[0][0][0] = 0;
for (int q = 0; q < Q; q++) {
char o, c;
int i;
cin >> o >> i;
i--;
if (o == '+') {
cin >> c;
desc[i][len[i]++] = c;
if (i == 0) {
for (int j = 0; j < 260; j++) {
for (int k = 0; k < 260; k++) {
if (maxP[len[0] - 1][j][k] < 100010)
maxP[len[0]][j][k] = dp[c - 'a'][maxP[len[0] - 1][j][k]];
else
maxP[len[0]][j][k] = 100010;
if (j && maxP[len[0]][j - 1][k] < 100010)
maxP[len[0]][j][k] =
min(maxP[len[0]][j][k],
dp[desc[1][j - 1] - 'a'][maxP[len[0]][j - 1][k]]);
if (k && maxP[len[0]][j][k - 1] < 100010)
maxP[len[0]][j][k] =
min(maxP[len[0]][j][k],
dp[desc[2][k - 1] - 'a'][maxP[len[0]][j][k - 1]]);
}
}
}
if (i == 1) {
for (int j = 0; j < 260; j++) {
for (int k = 0; k < 260; k++) {
if (maxP[j][len[1] - 1][k] < 100010)
maxP[j][len[1]][k] = dp[c - 'a'][maxP[j][len[1] - 1][k]];
else
maxP[j][len[1]][k] = 100010;
if (j && maxP[j - 1][len[1]][k] < 100010)
maxP[j][len[1]][k] =
min(maxP[j][len[1]][k],
dp[desc[0][j - 1] - 'a'][maxP[j - 1][len[1]][k]]);
if (k && maxP[j][len[1]][k - 1] < 100010)
maxP[j][len[1]][k] =
min(maxP[j][len[1]][k],
dp[desc[2][k - 1] - 'a'][maxP[j][len[1]][k - 1]]);
}
}
}
if (i == 2) {
for (int j = 0; j < 260; j++) {
for (int k = 0; k < 260; k++) {
if (maxP[j][k][len[2] - 1] < 100010)
maxP[j][k][len[2]] = dp[c - 'a'][maxP[j][k][len[2] - 1]];
else
maxP[j][k][len[2]] = 100010;
if (j && maxP[j - 1][k][len[2]] < 100010)
maxP[j][k][len[2]] =
min(maxP[j][k][len[2]],
dp[desc[0][j - 1] - 'a'][maxP[j - 1][k][len[2]]]);
if (k && maxP[j][k - 1][len[2]] < 100010)
maxP[j][k][len[2]] =
min(maxP[j][k][len[2]],
dp[desc[1][k - 1] - 'a'][maxP[j][k - 1][len[2]]]);
}
}
}
} else
len[i]--;
cout << (maxP[len[0]][len[1]][len[2]] < 100010 ? "YES" : "NO") << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void outarr(Tp _begin, Tp _end, const char* _delim = " ") {
for (Tp current = _begin; current != _end; ++current) {
std::cout << *current << _delim;
}
std::cout << '\n';
}
using ll = long long;
using pii = std::pair<int, int>;
constexpr int INF = 0x3f3f3f3f;
constexpr int MOD = static_cast<const int>(1e9 + 7);
string s;
int dp[255][255][255];
int nxt[100000][26];
int len[3];
string religions[3];
void Init() {
memset(dp, INF, sizeof(dp));
dp[0][0][0] = 0;
for (char c = 'a'; c <= 'z'; ++c) {
nxt[static_cast<int>((s).size()) - 1][c - 'a'] =
s.back() == c ? static_cast<int>((s).size()) - 1
: static_cast<int>((s).size());
for (int i = static_cast<int>((s).size()) - 2; i >= 0; --i) {
nxt[i][c - 'a'] = s[i] == c ? i : nxt[i + 1][c - 'a'];
}
}
}
void Add(int i, char c) {
int f = i == 0 ? 1 : 0;
int ff = i == 2 ? 1 : 2;
for (int a = 0; a <= len[f]; ++a) {
for (int b = 0; b <= len[ff]; ++b) {
if (i == 0) {
int k = dp[len[i]][a][b];
if (k < static_cast<int>((s).size()) &&
nxt[k][c - 'a'] < static_cast<int>((s).size())) {
dp[len[i] + 1][a][b] = min(dp[len[i] + 1][a][b], nxt[k][c - 'a'] + 1);
}
} else if (i == 1) {
int k = dp[a][len[i]][b];
if (k < static_cast<int>((s).size()) &&
nxt[k][c - 'a'] < static_cast<int>((s).size())) {
dp[a][len[i] + 1][b] = min(dp[a][len[i] + 1][b], nxt[k][c - 'a'] + 1);
}
} else {
int k = dp[a][b][len[i]];
if (k < static_cast<int>((s).size()) &&
nxt[k][c - 'a'] < static_cast<int>((s).size())) {
dp[a][b][len[i] + 1] = min(dp[a][b][len[i] + 1], nxt[k][c - 'a'] + 1);
}
}
}
}
++len[i];
religions[i] += c;
for (int a = 0; a <= len[f]; ++a) {
for (int b = 0; b <= len[ff]; ++b) {
if (i == 0) {
int k = dp[len[i]][a][b];
if (len[f] > 0 && a < len[f]) {
char z = religions[f][a];
if (k < static_cast<int>((s).size()) &&
nxt[k][z - 'a'] < static_cast<int>((s).size())) {
dp[len[i]][a + 1][b] =
min(dp[len[i]][a + 1][b], nxt[k][z - 'a'] + 1);
}
}
if (len[ff] > 0 && b < len[ff]) {
char z = religions[ff][b];
if (k < static_cast<int>((s).size()) &&
nxt[k][z - 'a'] < static_cast<int>((s).size())) {
dp[len[i]][a][b + 1] =
min(dp[len[i]][a][b + 1], nxt[k][z - 'a'] + 1);
}
}
} else if (i == 1) {
int k = dp[a][len[i]][b];
if (len[f] > 0 && a < len[f]) {
char z = religions[f][a];
if (k < static_cast<int>((s).size()) &&
nxt[k][z - 'a'] < static_cast<int>((s).size())) {
dp[a + 1][len[i]][b] =
min(dp[a + 1][len[i]][b], nxt[k][z - 'a'] + 1);
}
}
if (len[ff] > 0 && b < len[ff]) {
char z = religions[ff][b];
if (k < static_cast<int>((s).size()) &&
nxt[k][z - 'a'] < static_cast<int>((s).size())) {
dp[a][len[i]][b + 1] =
min(dp[a][len[i]][b + 1], nxt[k][z - 'a'] + 1);
}
}
} else {
int k = dp[a][b][len[i]];
if (len[f] > 0 && a < len[f]) {
char z = religions[f][a];
if (k < static_cast<int>((s).size()) &&
nxt[k][z - 'a'] < static_cast<int>((s).size())) {
dp[a + 1][b][len[i]] =
min(dp[a + 1][b][len[i]], nxt[k][z - 'a'] + 1);
}
}
if (len[ff] > 0 && b < len[ff]) {
char z = religions[ff][b];
if (k < static_cast<int>((s).size()) &&
nxt[k][z - 'a'] < static_cast<int>((s).size())) {
dp[a][b + 1][len[i]] =
min(dp[a][b + 1][len[i]], nxt[k][z - 'a'] + 1);
}
}
}
}
}
}
void Del(int i) {
int f = i == 0 ? 1 : 0;
int ff = i == 2 ? 1 : 2;
for (int a = 0; a <= len[f]; ++a) {
for (int b = 0; b <= len[ff]; ++b) {
if (i == 0) {
dp[len[i]][a][b] = INF;
} else if (i == 1) {
dp[a][len[i]][b] = INF;
} else {
dp[a][b][len[i]] = INF;
}
}
}
--len[i];
religions[i].pop_back();
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, q;
cin >> n >> q >> s;
Init();
while (q--) {
char cmd;
int i;
cin >> cmd >> i;
--i;
if (cmd == '+') {
char c;
cin >> c;
Add(i, c);
} else {
Del(i);
}
cout << (dp[len[0]][len[1]][len[2]] <= n ? "YES" : "NO") << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
int t1, t2, t3;
int n, q;
char s[100005];
int ahead[26][100005];
int a1, a2, a3;
char b1[256], b2[256], b3[256];
int dp[256][256][256];
char q1;
int q2;
int main() {
scanf("%d%d", &n, &q);
scanf(" %s", s);
for (int i = 0; i < n; i++) {
ahead[s[i] - 'a'][i] = i + 1;
}
for (int i = 0; i < 26; i++) {
ahead[i][n + 1] = n + 1;
ahead[i][n] = n + 1;
for (int j = n - 1; j >= 0; j--) {
if (!ahead[i][j]) {
ahead[i][j] = ahead[i][j + 1];
}
}
}
while (q--) {
scanf(" %c%d", &q1, &q2);
if (q2 == 1) {
if (q1 == '+') {
a1++;
scanf(" %c", b1 + a1);
b1[a1] -= 'a';
int i = a1;
for (int j = 0; j <= a2; j++)
for (int k = 0; k <= a3; k++) {
t1 = n + 1;
if (i) {
t2 = ahead[b1[i]][dp[i - 1][j][k]];
if (t1 > t2) t1 = t2;
}
if (j) {
t2 = ahead[b2[j]][dp[i][j - 1][k]];
if (t1 > t2) t1 = t2;
}
if (k) {
t2 = ahead[b3[k]][dp[i][j][k - 1]];
if (t1 > t2) t1 = t2;
}
dp[i][j][k] = t1;
}
} else {
a1--;
}
}
if (q2 == 2) {
if (q1 == '+') {
a2++;
scanf(" %c", b2 + a2);
b2[a2] -= 'a';
int j = a2;
for (int i = 0; i <= a1; i++)
for (int k = 0; k <= a3; k++) {
t1 = n + 1;
if (i) {
t2 = ahead[b1[i]][dp[i - 1][j][k]];
if (t1 > t2) t1 = t2;
}
if (j) {
t2 = ahead[b2[j]][dp[i][j - 1][k]];
if (t1 > t2) t1 = t2;
}
if (k) {
t2 = ahead[b3[k]][dp[i][j][k - 1]];
if (t1 > t2) t1 = t2;
}
dp[i][j][k] = t1;
}
} else {
a2--;
}
}
if (q2 == 3) {
if (q1 == '+') {
a3++;
scanf(" %c", b3 + a3);
b3[a3] -= 'a';
int k = a3;
for (int i = 0; i <= a1; i++)
for (int j = 0; j <= a2; j++) {
t1 = n + 1;
if (i) {
t2 = ahead[b1[i]][dp[i - 1][j][k]];
if (t1 > t2) t1 = t2;
}
if (j) {
t2 = ahead[b2[j]][dp[i][j - 1][k]];
if (t1 > t2) t1 = t2;
}
if (k) {
t2 = ahead[b3[k]][dp[i][j][k - 1]];
if (t1 > t2) t1 = t2;
}
dp[i][j][k] = t1;
}
} else {
a3--;
}
}
if (0) {
for (int i = 0; i <= a1; i++)
for (int j = 0; j <= a2; j++)
for (int k = 0; k <= a3; k++)
printf("dp %d %d %d = %d\n", i, j, k, dp[i][j][k]);
}
if (dp[a1][a2][a3] == n + 1)
printf("NO\n");
else
printf("YES\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
char arr[100010];
int nex[26][100010];
int mem[252][252][252];
int str[4][252];
int main() {
int n, q, i, j, k;
scanf("%d%d%s", &n, &q, arr + 1);
for (i = 0; i < 26; i++) {
int p = n + 1;
nex[i][p] = p;
for (j = n; j >= 0; j--) {
nex[i][j] = p;
if (arr[j] == 'a' + i) p = j;
}
}
int s1 = 0, s2 = 0, s3 = 0;
for (int qi = 0; qi < q; qi++) {
char t, c;
int x;
scanf(" %c%d", &t, &x);
if (t == '+') {
scanf(" %c", &c);
int ci = c - 'a';
if (x == 1) {
str[x][s1 + 1] = ci;
for (j = 0; j <= s2; j++) {
for (k = 0; k <= s3; k++) {
int &cur = mem[s1 + 1][j][k];
cur = nex[ci][mem[s1][j][k]];
if (j) cur = min(cur, nex[str[2][j]][mem[s1 + 1][j - 1][k]]);
if (k) cur = min(cur, nex[str[3][k]][mem[s1 + 1][j][k - 1]]);
}
}
s1++;
} else if (x == 2) {
str[x][s2 + 1] = ci;
for (i = 0; i <= s1; i++) {
for (k = 0; k <= s3; k++) {
int &cur = mem[i][s2 + 1][k];
cur = nex[ci][mem[i][s2][k]];
if (i) cur = min(cur, nex[str[1][i]][mem[i - 1][s2 + 1][k]]);
if (k) cur = min(cur, nex[str[3][k]][mem[i][s2 + 1][k - 1]]);
}
}
s2++;
} else {
str[x][s3 + 1] = ci;
for (i = 0; i <= s1; i++) {
for (j = 0; j <= s2; j++) {
int &cur = mem[i][j][s3 + 1];
cur = nex[ci][mem[i][j][s3]];
if (i) cur = min(cur, nex[str[1][i]][mem[i - 1][j][s3 + 1]]);
if (j) cur = min(cur, nex[str[2][j]][mem[i][j - 1][s3 + 1]]);
}
}
s3++;
}
} else {
if (x == 1)
s1--;
else if (x == 2)
s2--;
else
s3--;
}
if (mem[s1][s2][s3] > n)
puts("NO");
else
puts("YES");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, q, x;
cin >> n >> q;
string s;
cin >> s;
vector<vector<int> > z(n + 1, vector<int>(26, 1000000000));
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j < 26; j++) z[i][j] = j == s[i] - 'a' ? i : z[i + 1][j];
static int dp[251][251][251];
string d[3];
for (int qi = 0; qi < q; qi++) {
char o, c;
cin >> o >> x;
x--;
if (o == '+') {
cin >> c;
d[x] += c;
int n1 = d[0].size(), n2 = d[1].size(), n3 = d[2].size();
for (int i = (x == 0) ? n1 : 0; i <= n1; i++)
for (int j = (x == 1) ? n2 : 0; j <= n2; j++)
for (int k = (x == 2) ? n3 : 0; k <= n3; k++) {
dp[i][j][k] = 1000000000;
if (i > 0 && dp[i - 1][j][k] != 1000000000)
dp[i][j][k] =
min(dp[i][j][k], z[dp[i - 1][j][k]][d[0][i - 1] - 'a'] + 1);
if (j > 0 && dp[i][j - 1][k] != 1000000000)
dp[i][j][k] =
min(dp[i][j][k], z[dp[i][j - 1][k]][d[1][j - 1] - 'a'] + 1);
if (k > 0 && dp[i][j][k - 1] != 1000000000)
dp[i][j][k] =
min(dp[i][j][k], z[dp[i][j][k - 1]][d[2][k - 1] - 'a'] + 1);
}
} else if (o == '-') {
d[x].erase(d[x].end() - 1);
}
cout << (dp[d[0].size()][d[1].size()][d[2].size()] != 1000000000 ? "YES"
: "NO")
<< endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, q, wlcjewoc[26][200100], currel, sz[3], dp[255][255][255];
string s;
char op, r[3][255];
int main() {
cin >> n >> q >> s;
s = " " + s;
for (int i = 0; i < 26; i++) wlcjewoc[i][n + 1] = n + 1;
for (int l = 0; l < 26; l++)
for (int i = n; i >= 0; i--)
wlcjewoc[l][i] = (s[i + 1] - 'a' == l ? i + 1 : wlcjewoc[l][i + 1]);
memset(dp, INF, sizeof dp);
dp[0][0][0] = 0;
while (q--) {
cin >> op >> currel;
if (op == '+') {
cin >> op;
r[currel - 1][++sz[currel - 1]] = op;
for (int i = (currel == 1 ? sz[0] - 1 : 0); i <= sz[0]; i++)
for (int j = (currel == 2 ? sz[1] - 1 : 0); j <= sz[1]; j++)
for (int k = (currel == 3 ? sz[2] - 1 : 0); k <= sz[2]; k++) {
if (i > 0)
dp[i][j][k] =
min(dp[i][j][k], wlcjewoc[r[0][i] - 'a'][dp[i - 1][j][k]]);
if (j > 0)
dp[i][j][k] =
min(dp[i][j][k], wlcjewoc[r[1][j] - 'a'][dp[i][j - 1][k]]);
if (k > 0)
dp[i][j][k] =
min(dp[i][j][k], wlcjewoc[r[2][k] - 'a'][dp[i][j][k - 1]]);
}
} else {
for (int i = (currel == 1 ? sz[0] : 0); i <= sz[0]; i++)
for (int j = (currel == 2 ? sz[1] : 0); j <= sz[1]; j++)
for (int k = (currel == 3 ? sz[2] : 0); k <= sz[2]; k++)
dp[i][j][k] = INF;
sz[currel - 1]--;
}
cout << (dp[sz[0]][sz[1]][sz[2]] <= n ? "YES" : "NO") << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 255;
int dp[M][M][M], go[N][26], len[4];
char s[4][M], w[N];
int main() {
int n, q;
scanf("%d%d", &n, &q);
scanf("%s", w + 1);
for (int i = 0; i < 26; i++) go[n + 1][i] = go[n][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][w[i + 1] - 'a'] = i + 1;
}
char op[4], ch[4];
int id;
while (q--) {
scanf("%s%d", op, &id);
if (op[0] == '-')
len[id]--;
else {
scanf("%s", ch);
s[id][++len[id]] = ch[0];
for (int p1 = id == 1 ? len[1] : 0; p1 <= len[1]; p1++)
for (int p2 = id == 2 ? len[2] : 0; p2 <= len[2]; p2++)
for (int p3 = id == 3 ? len[3] : 0; p3 <= len[3]; p3++)
dp[p1][p2][p3] = n + 1;
for (int p1 = id == 1 ? len[1] : 0; p1 <= len[1]; p1++)
for (int p2 = id == 2 ? len[2] : 0; p2 <= len[2]; p2++)
for (int p3 = id == 3 ? len[3] : 0; p3 <= len[3]; p3++) {
if (p1 > 0)
dp[p1][p2][p3] =
min(dp[p1][p2][p3], go[dp[p1 - 1][p2][p3]][s[1][p1] - 'a']);
if (p2 > 0)
dp[p1][p2][p3] =
min(dp[p1][p2][p3], go[dp[p1][p2 - 1][p3]][s[2][p2] - 'a']);
if (p3 > 0)
dp[p1][p2][p3] =
min(dp[p1][p2][p3], go[dp[p1][p2][p3 - 1]][s[3][p3] - 'a']);
}
}
if (dp[len[1]][len[2]][len[3]] <= n)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, Q;
int a[100005];
int sig[100005][26];
int memo[255][255][255];
vector<int> s[4];
int dp(int i, int j, int k) {
if (!i && !j && !k) return 0;
if (memo[i][j][k] != -1) return memo[i][j][k];
int ans = N + 1;
if (i) ans = min(ans, sig[dp(i - 1, j, k) + 1][s[1][i - 1]]);
if (j) ans = min(ans, sig[dp(i, j - 1, k) + 1][s[2][j - 1]]);
if (k) ans = min(ans, sig[dp(i, j, k - 1) + 1][s[3][k - 1]]);
return memo[i][j][k] = ans;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> N >> Q;
memset(memo, -1, sizeof memo);
for (int i = 1; i <= N; i++) {
char c;
cin >> c;
a[i] = c - 'a';
}
for (int i = 0; i < 26; i++) {
sig[N + 1][i] = N + 1;
sig[N + 2][i] = N + 1;
}
for (int i = N; i >= 1; i--) {
for (int j = 0; j < 26; j++) sig[i][j] = sig[i + 1][j];
sig[i][a[i]] = i;
}
while (Q--) {
char op;
cin >> op;
if (op == '+') {
int x;
char c;
cin >> x >> c;
s[x].push_back(c - 'a');
for (int i = 0; i <= 250; i++)
for (int j = 0; j <= 250; j++) {
if (x == 1) memo[s[x].size()][i][j] = -1;
if (x == 2) memo[i][s[x].size()][j] = -1;
if (x == 3) memo[i][j][s[x].size()] = -1;
}
} else {
int x;
cin >> x;
s[x].pop_back();
}
if (dp(s[1].size(), s[2].size(), s[3].size()) <= N)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T vmin(T v) {
return v;
}
template <typename T, typename... Args>
inline T vmin(T first, Args... args) {
return min(first, vmin(args...));
}
template <typename T>
inline T vmax(T v) {
return v;
}
template <typename T, typename... Args>
inline T vmax(T first, Args... args) {
return max(first, vmax(args...));
}
template <typename T, typename... Args>
inline void smin(T &first, Args... args) {
first = vmin(first, args...);
}
template <typename T, typename... Args>
inline void smax(T &first, Args... args) {
first = vmax(first, args...);
}
const long double eps = 1e-15;
const int maxN = 1 * 250 + 5, mod = (int)1e9 + 7, inf = (int)1e9 + 1;
const int maxNN = 1 * 100000 + 10;
int dp[maxN][maxN][maxN];
int first[26][maxNN];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, q;
string s;
string ss[3] = {"", "", ""};
cin >> n >> q;
cin >> s;
fill(*first, *first + sizeof(first) / sizeof(int), n);
fill(**dp, **dp + sizeof(dp) / sizeof(int), -1);
for (int i = (int)(n)-1; i >= (int)(0); --i) {
for (int j = (int)(0); j < (int)(26); ++j) first[j][i] = first[j][i + 1];
first[s[i] - 'a'][i] = i;
}
while (q--) {
char c, cc;
int xx;
cin >> c >> xx;
int i0 = ((int)ss[0].size());
int j0 = ((int)ss[1].size());
int k0 = ((int)ss[2].size());
if (c == '+') {
cin >> cc;
ss[xx - 1] += cc;
int i1 = ((int)ss[0].size());
int j1 = ((int)ss[1].size());
int k1 = ((int)ss[2].size());
for (int i = (int)(i0 == i1 ? -1 : i1 - 1); i < (int)(i1); ++i)
for (int j = (int)(j0 == j1 ? -1 : j1 - 1); j < (int)(j1); ++j)
for (int k = (int)(k0 == k1 ? -1 : k1 - 1); k < (int)(k1); ++k)
dp[i + 1][j + 1][k + 1] = vmin(
(i >= 0 ? first[ss[0][i] - 'a'][dp[i][j + 1][k + 1] + 1] : n),
(j >= 0 ? first[ss[1][j] - 'a'][dp[i + 1][j][k + 1] + 1] : n),
(k >= 0 ? first[ss[2][k] - 'a'][dp[i + 1][j + 1][k] + 1] : n));
} else
ss[xx - 1].pop_back();
if (dp[((int)ss[0].size())][((int)ss[1].size())][((int)ss[2].size())] < n)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[100010];
int ch[26];
int nex[100010][26];
int dp[252][252][252];
int l[3];
char b[3][252];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i <= 250; i++)
for (int y = 0; y <= 250; y++)
for (int z = 0; z <= 250; z++) dp[i][y][z] = n + 1;
dp[0][0][0] = 0;
for (int i = 1; i <= n; i++) scanf(" %1c", &a[i]);
for (int i = 0; i < 26; i++) ch[i] = n + 1;
for (int i = n; i >= 0; i--) {
for (int y = 0; y < 26; y++) nex[i][y] = ch[y];
if (i) ch[a[i] - 'a'] = i;
}
while (m--) {
char q;
scanf(" %1c", &q);
if (q == '+') {
int w;
char e;
scanf("%d %1c", &w, &e);
w--;
l[w]++;
b[w][l[w]] = e;
if (w == 0) {
int i = l[0];
for (int y = 0; y <= l[1]; y++) {
for (int z = 0; z <= l[2]; z++) {
dp[i][y][z] = n + 1;
if (i && dp[i - 1][y][z] != n + 1)
dp[i][y][z] =
min(dp[i][y][z], nex[dp[i - 1][y][z]][b[0][i] - 'a']);
if (y && dp[i][y - 1][z] != n + 1)
dp[i][y][z] =
min(dp[i][y][z], nex[dp[i][y - 1][z]][b[1][y] - 'a']);
if (z && dp[i][y][z - 1] != n + 1)
dp[i][y][z] =
min(dp[i][y][z], nex[dp[i][y][z - 1]][b[2][z] - 'a']);
}
}
} else if (w == 1) {
int y = l[1];
for (int i = 0; i <= l[0]; i++) {
for (int z = 0; z <= l[2]; z++) {
dp[i][y][z] = n + 1;
if (i && dp[i - 1][y][z] != n + 1)
dp[i][y][z] =
min(dp[i][y][z], nex[dp[i - 1][y][z]][b[0][i] - 'a']);
if (y && dp[i][y - 1][z] != n + 1)
dp[i][y][z] =
min(dp[i][y][z], nex[dp[i][y - 1][z]][b[1][y] - 'a']);
if (z && dp[i][y][z - 1] != n + 1)
dp[i][y][z] =
min(dp[i][y][z], nex[dp[i][y][z - 1]][b[2][z] - 'a']);
}
}
} else {
int z = l[2];
for (int i = 0; i <= l[0]; i++) {
for (int y = 0; y <= l[1]; y++) {
dp[i][y][z] = n + 1;
if (i && dp[i - 1][y][z] != n + 1)
dp[i][y][z] =
min(dp[i][y][z], nex[dp[i - 1][y][z]][b[0][i] - 'a']);
if (y && dp[i][y - 1][z] != n + 1)
dp[i][y][z] =
min(dp[i][y][z], nex[dp[i][y - 1][z]][b[1][y] - 'a']);
if (z && dp[i][y][z - 1] != n + 1)
dp[i][y][z] =
min(dp[i][y][z], nex[dp[i][y][z - 1]][b[2][z] - 'a']);
}
}
}
if (dp[l[0]][l[1]][l[2]] <= n)
puts("YES");
else
puts("NO");
} else {
int w;
scanf("%d", &w);
w--;
b[w][l[w]] = 0;
l[w]--;
if (dp[l[0]][l[1]][l[2]] <= n)
puts("YES");
else
puts("NO");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int inf = 1 << 30;
const int maxn = 100000 + 5;
int n, q, nxt[maxn][26];
char s[maxn];
string reg[maxn];
int dp[255][255][255], len[3];
int main() {
scanf("%d%d%s", &n, &q, s + 1);
for (int i = 0; i < 26; i++) nxt[n][i] = nxt[n + 1][i] = n + 1;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i + 1] - 'a'] = i + 1;
}
char op[2], ch[2];
int tp;
while (q--) {
scanf("%s%d", op, &tp);
tp--;
if (op[0] == '+') {
scanf("%s", ch);
len[tp]++;
reg[tp] += ch[0];
int x = 0, y = 0, z = 0;
if (tp == 0) x = len[0];
if (tp == 1) y = len[1];
if (tp == 2) z = len[2];
for (int i = x; i <= len[0]; i++) {
for (int j = y; j <= len[1]; j++) {
for (int k = z; k <= len[2]; k++) {
dp[i][j][k] = n + 1;
if (i > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k]][reg[0][i - 1] - 'a']);
if (j > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k]][reg[1][j - 1] - 'a']);
if (k > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1]][reg[2][k - 1] - 'a']);
}
}
}
} else {
len[tp]--;
reg[tp].pop_back();
}
if (dp[len[0]][len[1]][len[2]] >= n + 1)
puts("NO");
else
puts("YES");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[100010];
int dp[26][100010];
int maxP[260][260][260];
int len[3];
char desc[3][260];
int main(void) {
int N, Q;
cin >> N >> Q;
cin >> str;
for (int i = 0; i < 26; i++) dp[i][N] = 100010;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 26; j++) {
if (str[N - 1 - i] == 'a' + j)
dp[j][N - 1 - i] = N - i;
else
dp[j][N - 1 - i] = dp[j][N - i];
}
}
for (int i = 0; i < 260; i++) {
for (int j = 0; j < 260; j++) {
for (int k = 0; k < 260; k++) maxP[i][j][k] = 100010;
}
}
maxP[0][0][0] = 0;
for (int q = 0; q < Q; q++) {
char o, c;
int i;
cin >> o >> i;
i--;
if (o == '+') {
cin >> c;
desc[i][len[i]++] = c;
if (i == 0) {
for (int j = 0; j <= len[1]; j++) {
for (int k = 0; k <= len[2]; k++) {
if (maxP[len[0] - 1][j][k] < 100010)
maxP[len[0]][j][k] = dp[c - 'a'][maxP[len[0] - 1][j][k]];
else
maxP[len[0]][j][k] = 100010;
if (j && maxP[len[0]][j - 1][k] < 100010)
maxP[len[0]][j][k] =
min(maxP[len[0]][j][k],
dp[desc[1][j - 1] - 'a'][maxP[len[0]][j - 1][k]]);
if (k && maxP[len[0]][j][k - 1] < 100010)
maxP[len[0]][j][k] =
min(maxP[len[0]][j][k],
dp[desc[2][k - 1] - 'a'][maxP[len[0]][j][k - 1]]);
}
}
}
if (i == 1) {
for (int j = 0; j <= len[0]; j++) {
for (int k = 0; k <= len[2]; k++) {
if (maxP[j][len[1] - 1][k] < 100010)
maxP[j][len[1]][k] = dp[c - 'a'][maxP[j][len[1] - 1][k]];
else
maxP[j][len[1]][k] = 100010;
if (j && maxP[j - 1][len[1]][k] < 100010)
maxP[j][len[1]][k] =
min(maxP[j][len[1]][k],
dp[desc[0][j - 1] - 'a'][maxP[j - 1][len[1]][k]]);
if (k && maxP[j][len[1]][k - 1] < 100010)
maxP[j][len[1]][k] =
min(maxP[j][len[1]][k],
dp[desc[2][k - 1] - 'a'][maxP[j][len[1]][k - 1]]);
}
}
}
if (i == 2) {
for (int j = 0; j <= len[0]; j++) {
for (int k = 0; k <= len[1]; k++) {
if (maxP[j][k][len[2] - 1] < 100010)
maxP[j][k][len[2]] = dp[c - 'a'][maxP[j][k][len[2] - 1]];
else
maxP[j][k][len[2]] = 100010;
if (j && maxP[j - 1][k][len[2]] < 100010)
maxP[j][k][len[2]] =
min(maxP[j][k][len[2]],
dp[desc[0][j - 1] - 'a'][maxP[j - 1][k][len[2]]]);
if (k && maxP[j][k - 1][len[2]] < 100010)
maxP[j][k][len[2]] =
min(maxP[j][k][len[2]],
dp[desc[1][k - 1] - 'a'][maxP[j][k - 1][len[2]]]);
}
}
}
} else {
if (i == 0) {
for (int j = 0; j < 260; j++) {
for (int k = 0; k < 260; k++) maxP[len[0]][j][k] = 100010;
}
}
if (i == 1) {
for (int j = 0; j < 260; j++) {
for (int k = 0; k < 260; k++) maxP[j][len[1]][k] = 100010;
}
}
if (i == 2) {
for (int j = 0; j < 260; j++) {
for (int k = 0; k < 260; k++) maxP[j][k][len[2]] = 100010;
}
}
len[i]--;
}
cout << (maxP[len[0]][len[1]][len[2]] < 100010 ? "YES" : "NO") << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 1e5 + 5;
char str[maxn];
int dp[255][255][255];
char A[5][255];
int nxt[maxn][30];
int n[5], N, Q;
void init() {
for (int i = 0; i <= 26; i++) nxt[N][i] = nxt[N + 1][i] = N;
for (int i = N - 1; i >= 0; i--) {
memcpy(nxt[i], nxt[i + 1], sizeof(nxt[i]));
nxt[i][str[i] - 'a'] = i;
}
dp[0][0][0] = -1;
}
void cal(int a, int b, int c) {
int ch, Min = inf;
if (a) {
ch = A[1][a - 1] - 'a';
Min = min(Min, nxt[dp[a - 1][b][c] + 1][ch]);
}
if (b) {
ch = A[2][b - 1] - 'a';
Min = min(Min, nxt[dp[a][b - 1][c] + 1][ch]);
}
if (c) {
ch = A[3][c - 1] - 'a';
Min = min(Min, nxt[dp[a][b][c - 1] + 1][ch]);
}
dp[a][b][c] = Min;
}
void solve(int t) {
int a = n[1], b = n[2], c = n[3];
for (int i = t == 1 ? a : 0; i <= a; i++)
for (int j = t == 2 ? b : 0; j <= b; j++)
for (int k = t == 3 ? c : 0; k <= c; k++) cal(i, j, k);
}
int main() {
scanf("%d%d", &N, &Q);
scanf("%s", str);
init();
while (Q--) {
char tem[10];
int t;
scanf("%s%d", tem, &t);
if (tem[0] == '-') {
n[t]--;
} else {
scanf("%s", tem);
A[t][n[t]++] = tem[0];
solve(t);
}
puts(dp[n[1]][n[2]][n[3]] < N ? "YES" : "NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 255;
int n, q, idx, pos[30][N], dp[M][M][M], len[5];
vector<int> a[5];
char type, car;
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q >> s;
s = " " + s;
for (int i = 1; i <= 26; i++) {
pos[i][n + 1] = n + 1;
for (int j = n; j >= 1; j--) {
if (s[j] - 96 == i) {
pos[i][j] = j;
} else {
pos[i][j] = pos[i][j + 1];
}
}
}
dp[0][0][0] = 0;
for (int i = 1; i <= 3; i++) a[i].push_back(0);
for (int vl = 1; vl <= q; vl++) {
cin >> type >> idx;
if (type == '-') {
len[idx]--;
a[idx].pop_back();
} else {
cin >> car;
int tmp = car - 96;
if (idx == 1) {
len[1]++;
a[1].push_back(tmp);
for (int i = 0; i <= len[2]; i++) {
for (int j = 0; j <= len[3]; j++) {
dp[len[1]][i][j] =
pos[a[1][len[1]]][min(n + 1, dp[len[1] - 1][i][j] + 1)];
if (i >= 1) {
dp[len[1]][i][j] =
min(dp[len[1]][i][j],
pos[a[2][i]][min(n + 1, dp[len[1]][i - 1][j] + 1)]);
}
if (j >= 1) {
dp[len[1]][i][j] =
min(dp[len[1]][i][j],
pos[a[3][j]][min(n + 1, dp[len[1]][i][j - 1] + 1)]);
}
}
}
}
if (idx == 2) {
len[2]++;
a[2].push_back(tmp);
for (int i = 0; i <= len[1]; i++) {
for (int j = 0; j <= len[3]; j++) {
dp[i][len[2]][j] =
pos[a[2][len[2]]][min(n + 1, dp[i][len[2] - 1][j] + 1)];
if (i >= 1) {
dp[i][len[2]][j] =
min(dp[i][len[2]][j],
pos[a[1][i]][min(n + 1, dp[i - 1][len[2]][j] + 1)]);
}
if (j >= 1) {
dp[i][len[2]][j] =
min(dp[i][len[2]][j],
pos[a[3][j]][min(n + 1, dp[i][len[2]][j - 1] + 1)]);
}
}
}
}
if (idx == 3) {
len[3]++;
a[3].push_back(tmp);
for (int i = 0; i <= len[1]; i++) {
for (int j = 0; j <= len[2]; j++) {
dp[i][j][len[3]] =
pos[a[3][len[3]]][min(n + 1, dp[i][j][len[3] - 1] + 1)];
if (i >= 1) {
dp[i][j][len[3]] =
min(dp[i][j][len[3]],
pos[a[1][i]][min(n + 1, dp[i - 1][j][len[3]] + 1)]);
}
if (j >= 1) {
dp[i][j][len[3]] =
min(dp[i][j][len[3]],
pos[a[2][j]][min(n + 1, dp[i][j - 1][len[3]] + 1)]);
}
}
}
}
}
if (dp[len[1]][len[2]][len[3]] <= n) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 250 + 5;
const int M = 100000 + 5;
int dp[N][N][N];
int nxt[M][26];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
string str;
cin >> str;
memset(nxt, 0x3f, sizeof(nxt));
for (int i = n; i > 0; --i) {
for (int j = 0; j < 26; ++j) {
nxt[i][j] = nxt[i + 1][j];
}
nxt[i][str[i - 1] - 'a'] = i;
}
vector<char> r1(N);
vector<char> r2(N);
vector<char> r3(N);
int n1, n2, n3;
n1 = n2 = n3 = 0;
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0] = 0;
while (q--) {
char cmd[5];
int reli;
cin >> cmd >> reli;
reli--;
if (cmd[0] == '+') {
int last = 0x3f3f3f3f;
cin >> cmd;
if (reli == 0) {
r1[n1++] = cmd[0];
for (int i = 0; i <= n2; ++i) {
for (int j = 0; j <= n3; ++j) {
dp[n1][i][j] = 0x3f3f3f3f;
if (i && dp[n1][i - 1][j] != 0x3f3f3f3f)
dp[n1][i][j] =
min(nxt[dp[n1][i - 1][j] + 1][r2[i - 1] - 'a'], dp[n1][i][j]);
if (j && dp[n1][i][j - 1] != 0x3f3f3f3f)
dp[n1][i][j] =
min(nxt[dp[n1][i][j - 1] + 1][r3[j - 1] - 'a'], dp[n1][i][j]);
if (dp[n1 - 1][i][j] != 0x3f3f3f3f)
dp[n1][i][j] = min(nxt[dp[n1 - 1][i][j] + 1][r1[n1 - 1] - 'a'],
dp[n1][i][j]);
}
}
last = min(last, dp[n1][n2][n3]);
} else if (reli == 1) {
r2[n2++] = cmd[0];
for (int i = 0; i <= n1; ++i) {
for (int j = 0; j <= n3; ++j) {
dp[i][n2][j] = 0x3f3f3f3f;
if (i && dp[i - 1][n2][j] != 0x3f3f3f3f)
dp[i][n2][j] =
min(nxt[dp[i - 1][n2][j] + 1][r1[i - 1] - 'a'], dp[i][n2][j]);
if (j && dp[i][n2][j - 1] != 0x3f3f3f3f)
dp[i][n2][j] =
min(nxt[dp[i][n2][j - 1] + 1][r3[j - 1] - 'a'], dp[i][n2][j]);
if (dp[i][n2 - 1][j] != 0x3f3f3f3f)
dp[i][n2][j] = min(nxt[dp[i][n2 - 1][j] + 1][r2[n2 - 1] - 'a'],
dp[i][n2][j]);
}
}
last = min(last, dp[n1][n2][n3]);
} else if (reli == 2) {
r3[n3++] = cmd[0];
for (int i = 0; i <= n1; ++i) {
for (int j = 0; j <= n2; ++j) {
dp[i][j][n3] = 0x3f3f3f3f;
if (i && dp[i - 1][j][n3] != 0x3f3f3f3f)
dp[i][j][n3] =
min(nxt[dp[i - 1][j][n3] + 1][r1[i - 1] - 'a'], dp[i][j][n3]);
if (j && dp[i][j - 1][n3] != 0x3f3f3f3f)
dp[i][j][n3] =
min(nxt[dp[i][j - 1][n3] + 1][r2[j - 1] - 'a'], dp[i][j][n3]);
if (dp[i][j][n3 - 1] != 0x3f3f3f3f)
dp[i][j][n3] = min(nxt[dp[i][j][n3 - 1] + 1][r3[n3 - 1] - 'a'],
dp[i][j][n3]);
}
}
last = min(last, dp[n1][n2][n3]);
}
puts(last == 0x3f3f3f3f ? "NO" : "YES");
} else {
if (reli == 0)
n1--;
else if (reli == 1)
n2--;
else
n3--;
puts(dp[n1][n2][n3] == 0x3f3f3f3f ? "NO" : "YES");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100010], S[3][255];
int dp[255][255][255];
int pos[100010][26];
int r[5], st[5];
int main() {
int n, q;
scanf("%d%d", &n, &q);
scanf("%s", s + 1);
for (int i = n + 2; i >= 1; i--) {
for (int j = 0; j < 26; j++) {
if (i > n)
pos[i][j] = n + 1;
else {
if (s[i] - 'a' == j)
pos[i][j] = i;
else
pos[i][j] = pos[i + 1][j];
}
}
}
while (q--) {
int x;
char ss;
scanf(" %c %d", &ss, &x);
if (ss == '+') {
char tt;
scanf(" %c ", &tt);
S[x][r[x]++] = tt - 'a';
for (int i = 1; i <= 3; i++) st[i] = 0;
st[x] = r[x];
for (int i = st[1]; i <= r[1]; i++) {
for (int j = st[2]; j <= r[2]; j++) {
for (int k = st[3]; k <= r[3]; k++) {
dp[i][j][k] = n + 1;
if (i)
dp[i][j][k] =
min(dp[i][j][k], pos[dp[i - 1][j][k] + 1][S[1][i - 1]]);
if (j)
dp[i][j][k] =
min(dp[i][j][k], pos[dp[i][j - 1][k] + 1][S[2][j - 1]]);
if (k)
dp[i][j][k] =
min(dp[i][j][k], pos[dp[i][j][k - 1] + 1][S[3][k - 1]]);
}
}
}
} else
r[x]--;
if (dp[r[1]][r[2]][r[3]] <= n)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, M = 250 + 7;
int n, m, k, op[N], len[5], ch[N][M], opt[M][M][M];
char t, s[N], ro[N][3];
int main() {
scanf("%d%d%s", &n, &m, s + 1);
for (int i = n; i >= 0; i--) {
for (int x = 1; x <= 26; x++) ch[i][x] = op[x];
if (i <= 0) continue;
op[s[i] - 'a' + 1] = i;
}
for (int i = 1; i <= m; i++) {
t = getchar();
while (t != '+' && t != '-') t = getchar();
if (t == '-') {
scanf("%d", &k), len[k]--;
if (opt[len[1]][len[2]][len[3]] ||
(len[1] == 0 && len[2] == 0 && len[3] == 0))
puts("YES");
else
puts("NO");
if (k == 1) {
for (int i = 0; i <= len[2]; i++)
for (int j = 0; j <= len[3]; j++) opt[len[k] + 1][i][j] = 0;
}
if (k == 2) {
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[3]; j++) opt[i][len[k] + 1][j] = 0;
}
if (k == 3) {
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[2]; j++) opt[i][j][len[k] + 1] = 0;
}
} else {
scanf("%d", &k), len[k]++, t = getchar();
while (t < 'a' || 'z' < t) t = getchar();
ro[len[k]][k] = t;
if (k == 1) {
for (int i = len[k] - 1; i <= len[k]; i++)
for (int j = 0; j <= len[2]; j++)
for (int z = 0; z <= len[3]; z++) {
if (!opt[i][j][z] && (!(i == 0 && j == 0 && z == 0))) continue;
int x = opt[i][j][z];
if (i < len[1]) {
int vc = ro[i + 1][1] - 'a' + 1;
if (!opt[i + 1][j][z] || opt[i + 1][j][z] > ch[x][vc]) {
if (ch[x][vc]) opt[i + 1][j][z] = ch[x][vc];
}
}
if (j < len[2]) {
int vc = ro[j + 1][2] - 'a' + 1;
if (!opt[i][j + 1][z] || opt[i][j + 1][z] > ch[x][vc]) {
if (ch[x][vc]) opt[i][j + 1][z] = ch[x][vc];
}
}
if (z < len[3]) {
int vc = ro[z + 1][3] - 'a' + 1;
if (!opt[i][j][z + 1] || opt[i][j][z + 1] > ch[x][vc]) {
if (ch[x][vc]) opt[i][j][z + 1] = ch[x][vc];
}
}
}
}
if (k == 2) {
for (int i = 0; i <= len[1]; i++)
for (int j = len[2] - 1; j <= len[2]; j++)
for (int z = 0; z <= len[3]; z++) {
if (!opt[i][j][z] && (!(i == 0 && j == 0 && z == 0))) continue;
int x = opt[i][j][z];
if (i < len[1]) {
int vc = ro[i + 1][1] - 'a' + 1;
if (!opt[i + 1][j][z] || opt[i + 1][j][z] > ch[x][vc]) {
if (ch[x][vc]) opt[i + 1][j][z] = ch[x][vc];
}
}
if (j < len[2]) {
int vc = ro[j + 1][2] - 'a' + 1;
if (!opt[i][j + 1][z] || opt[i][j + 1][z] > ch[x][vc]) {
if (ch[x][vc]) opt[i][j + 1][z] = ch[x][vc];
}
}
if (z < len[3]) {
int vc = ro[z + 1][3] - 'a' + 1;
if (!opt[i][j][z + 1] || opt[i][j][z + 1] > ch[x][vc]) {
if (ch[x][vc]) opt[i][j][z + 1] = ch[x][vc];
}
}
}
}
if (k == 3) {
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[2]; j++)
for (int z = len[3] - 1; z <= len[3]; z++) {
if (!opt[i][j][z] && (!(i == 0 && j == 0 && z == 0))) continue;
int x = opt[i][j][z];
if (i < len[1]) {
int vc = ro[i + 1][1] - 'a' + 1;
if (!opt[i + 1][j][z] || opt[i + 1][j][z] > ch[x][vc]) {
if (ch[x][vc]) opt[i + 1][j][z] = ch[x][vc];
}
}
if (j < len[2]) {
int vc = ro[j + 1][2] - 'a' + 1;
if (!opt[i][j + 1][z] || opt[i][j + 1][z] > ch[x][vc]) {
if (ch[x][vc]) opt[i][j + 1][z] = ch[x][vc];
}
}
if (z < len[3]) {
int vc = ro[z + 1][3] - 'a' + 1;
if (!opt[i][j][z + 1] || opt[i][j][z + 1] > ch[x][vc]) {
if (ch[x][vc]) opt[i][j][z + 1] = ch[x][vc];
}
}
}
}
if (opt[len[1]][len[2]][len[3]] ||
(len[1] == 0 && len[2] == 0 && len[3] == 0))
puts("YES");
else
puts("NO");
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 1000000, MAXM = 260;
using namespace std;
int n, m, a, b, c;
int f[MAXM][MAXM][MAXM], nxt[MAXN][26], A[MAXN], B[MAXN], C[MAXN];
char s[MAXN];
inline void init() {
scanf("%d %d", &n, &m);
scanf("%s", s + 1);
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) nxt[i][s[i] - 'a'] = i;
}
}
int main() {
init();
int x;
char opt[5];
while (m--) {
scanf("%s", opt);
if (opt[0] == '+') {
scanf("%d", &x);
scanf("%s", opt);
if (x == 1) {
A[++a] = opt[0] - 'a';
for (int i = 0; i <= b; i++)
for (int j = 0; j <= c; j++) {
f[a][i][j] = nxt[f[a - 1][i][j] + 1][A[a]];
if (i) f[a][i][j] = min(f[a][i][j], nxt[f[a][i - 1][j] + 1][B[i]]);
if (j) f[a][i][j] = min(f[a][i][j], nxt[f[a][i][j - 1] + 1][C[j]]);
}
}
if (x == 2) {
B[++b] = opt[0] - 'a';
for (int i = 0; i <= a; i++)
for (int j = 0; j <= c; j++) {
f[i][b][j] = nxt[f[i][b - 1][j] + 1][B[b]];
if (i) f[i][b][j] = min(f[i][b][j], nxt[f[i - 1][b][j] + 1][A[i]]);
if (j) f[i][b][j] = min(f[i][b][j], nxt[f[i][b][j - 1] + 1][C[j]]);
}
}
if (x == 3) {
C[++c] = opt[0] - 'a';
for (int i = 0; i <= a; i++)
for (int j = 0; j <= b; j++) {
f[i][j][c] = nxt[f[i][j][c - 1] + 1][C[c]];
if (i) f[i][j][c] = min(f[i][j][c], nxt[f[i - 1][j][c] + 1][A[i]]);
if (j) f[i][j][c] = min(f[i][j][c], nxt[f[i][j - 1][c] + 1][B[j]]);
}
}
if (f[a][b][c] <= n)
printf("YES\n");
else
printf("NO\n");
} else {
scanf("%d", &x);
if (x == 1) a--;
if (x == 2) b--;
if (x == 3) c--;
if (f[a][b][c] <= n)
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> let[26];
int n;
const int maxn = 1e5;
int get_id[26][maxn];
string s;
void build() {
for (int i = 0; i < 26; ++i) {
int st = n, id = 0;
if (let[i].size()) st = let[i][0];
for (int j = 0; j < n; ++j) {
if (s[j] - 'a' == i) ++id;
if (id < let[i].size())
st = let[i][id];
else
st = n;
get_id[i][j] = st;
}
}
}
int get_next(int num, char ch) {
if (num == -1) {
if (let[ch - 'a'].size()) return let[ch - 'a'][0];
return n;
}
if (num == n) return n;
return get_id[ch - 'a'][num];
}
void solve() {
int q;
cin >> n >> q;
cin >> s;
for (int i = 0; i < n; ++i) let[s[i] - 'a'].push_back(i);
build();
int dp[3][251][251];
for (int i = 0; i <= 250; ++i)
for (int j = 0; j <= 250; ++j) dp[0][i][j] = n;
for (int i = 0; i <= 250; ++i)
for (int j = 0; j <= 250; ++j) dp[1][i][j] = n;
for (int i = 0; i <= 250; ++i)
for (int j = 0; j <= 250; ++j) dp[2][i][j] = n;
vector<string> st(3);
dp[0][0][0] = -1;
dp[1][0][0] = -1;
dp[2][0][0] = -1;
while (q) {
--q;
char type;
cin >> type;
if (type == '-') {
int num;
cin >> num;
--num;
st[num].erase(st[num].begin() + st[num].size() - 1);
for (int i = 0; i < 251; ++i)
for (int j = 0; j < 251; ++j) dp[num][i][j] = n;
dp[num][0][0] = -1;
for (int i = 0; i <= st[(num + 1) % 3].size(); ++i) {
for (int j = 0; j <= st[(num + 2) % 3].size(); ++j) {
if (i)
dp[num][i][j] =
min(dp[num][i][j],
get_next(dp[num][i - 1][j], st[(num + 1) % 3][i - 1]));
if (j)
dp[num][i][j] =
min(dp[num][i][j],
get_next(dp[num][i][j - 1], st[(num + 2) % 3][j - 1]));
}
}
for (int i = 0; i < st[num].size(); ++i) {
for (int j = 0; j <= st[(num + 1) % 3].size(); ++j) {
for (int k = 0; k <= st[(num + 2) % 3].size(); ++k) {
int val = get_next(dp[num][j][k], st[num][i]);
if (j)
val = min(val,
get_next(dp[num][j - 1][k], st[(num + 1) % 3][j - 1]));
if (k)
val = min(val,
get_next(dp[num][j][k - 1], st[(num + 2) % 3][k - 1]));
dp[num][j][k] = val;
}
}
}
for (int i = 0; i <= st[(num + 2) % 3].size(); ++i)
dp[(num + 1) % 3][i][st[num].size() + 1] = n;
for (int i = 0; i <= st[(num + 1) % 3].size(); ++i)
dp[(num + 2) % 3][st[num].size() + 1][i] = n;
} else {
int num;
char ch;
cin >> num >> ch;
--num;
st[num] += ch;
for (int i = 0; i <= st[(num + 1) % 3].size(); ++i) {
for (int j = 0; j <= st[(num + 2) % 3].size(); ++j) {
int val = get_next(dp[num][i][j], ch);
if (i)
val =
min(val, get_next(dp[num][i - 1][j], st[(num + 1) % 3][i - 1]));
if (j)
val =
min(val, get_next(dp[num][i][j - 1], st[(num + 2) % 3][j - 1]));
dp[num][i][j] = val;
}
}
for (int i = 0; i <= st[(num + 2) % 3].size(); ++i)
dp[(num + 1) % 3][i][st[num].size()] =
dp[num][st[(num + 1) % 3].size()][i];
for (int i = 0; i <= st[(num + 1) % 3].size(); ++i)
dp[(num + 2) % 3][st[num].size()][i] =
dp[num][i][st[(num + 2) % 3].size()];
}
if (dp[0][st[1].size()][st[2].size()] != n)
cout << "YES\n";
else
cout << "NO\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[100010], s[4][260];
int n, q, len[4], p[30], nxt[100010][30], dp[260][260][260];
int main() {
ios::sync_with_stdio(0);
cin >> n >> q;
cin >> str + 1;
for (int i = 0; i < 26; ++i) p[i] = n + 1;
for (int i = n + 2; i >= 1; --i) {
if (i <= n) p[str[i] - 'a'] = i;
for (int j = 0; j < 26; ++j) nxt[i][j] = p[j];
}
for (int i = 0; i <= 255; ++i)
for (int j = 0; j <= 255; ++j)
for (int k = 0; k <= 255; ++k) dp[i][j][k] = n + 1;
dp[0][0][0] = 0;
while (q--) {
int num;
char op, ch;
cin >> op >> num;
if (op == '+') {
cin >> ch;
s[num][++len[num]] = ch;
for (int i = (num == 1 ? len[1] : 0); i <= len[1]; ++i)
for (int j = (num == 2 ? len[2] : 0); j <= len[2]; ++j)
for (int k = (num == 3 ? len[3] : 0); k <= len[3]; ++k) {
if (i > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k] + 1][s[1][i] - 'a']);
if (j > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k] + 1][s[2][j] - 'a']);
if (k > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1] + 1][s[3][k] - 'a']);
}
} else {
for (int i = (num == 1 ? len[1] : 0); i <= len[1]; ++i)
for (int j = (num == 2 ? len[2] : 0); j <= len[2]; ++j)
for (int k = (num == 3 ? len[3] : 0); k <= len[3]; ++k)
dp[i][j][k] = n + 1;
len[num]--;
}
if (dp[len[1]][len[2]][len[3]] <= n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long s = 0, w = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * w;
}
int Next[100010][31];
int dp[260][260][260];
char s[100010];
int n, m;
int q[4][100010];
inline void update(int wch) {
for (register int i = (wch == 1 ? q[1][0] : 0); i <= q[1][0]; i++) {
for (register int j = (wch == 2 ? q[2][0] : 0); j <= q[2][0]; j++) {
for (register int k = (wch == 3 ? q[3][0] : 0); k <= q[3][0]; k++) {
dp[i][j][k] = 1e9;
if (i && dp[i - 1][j][k] != 1e9 &&
Next[dp[i - 1][j][k] + 1][q[1][i]] != -1)
dp[i][j][k] = min(dp[i][j][k], Next[dp[i - 1][j][k] + 1][q[1][i]]);
if (j && dp[i][j - 1][k] != 1e9 &&
Next[dp[i][j - 1][k] + 1][q[2][j]] != -1)
dp[i][j][k] = min(dp[i][j][k], Next[dp[i][j - 1][k] + 1][q[2][j]]);
if (k && dp[i][j][k - 1] != 1e9 &&
Next[dp[i][j][k - 1] + 1][q[3][k]] != -1)
dp[i][j][k] = min(dp[i][j][k], Next[dp[i][j][k - 1] + 1][q[3][k]]);
}
}
}
}
int main() {
n = read(), m = read();
scanf("%s", s + 1);
for (register int j = 1; j <= 26; j++) Next[n + 1][j] = -1;
for (register int i = n; i >= 0; i--) {
for (register int j = 1; j <= 26; j++) {
if (s[i] == char(j + 'a' - 1))
Next[i][j] = i;
else
Next[i][j] = Next[i + 1][j];
}
}
while (m--) {
char opt;
cin >> opt;
if (opt == '+') {
int x;
char c;
cin >> x >> c;
q[x][++q[x][0]] = c - 'a' + 1;
update(x);
} else {
int x;
cin >> x;
q[x][0]--;
}
if (dp[q[1][0]][q[2][0]][q[3][0]] != 1e9) {
printf("YES\n");
} else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const int N = 252;
int lb[100005][26];
int dp[N][N][N];
string a, b, c;
void solve() {
int n, q;
string s;
cin >> n >> q >> s;
for (int c = 0; c < 26; c++) {
lb[n][c] = n;
lb[n + 1][c] = n;
for (int i = n - 1; i >= 0; i--) {
lb[i][c] = lb[i + 1][c];
if (s[i] == 'a' + c) {
lb[i][c] = i;
}
}
}
dp[0][0][0] = -1;
for (int z = 0; z < q; z++) {
string choice;
int i;
cin >> choice >> i;
if (choice == "+") {
string tmp;
cin >> tmp;
char ch = tmp[0];
if (i == 1) {
a.push_back(ch);
int x = (int)((a).size());
for (int p = 0; p < (int)((b).size()) + 1; p++) {
for (int q = 0; q < (int)((c).size()) + 1; q++) {
dp[x][p][q] = lb[dp[x - 1][p][q] + 1][a[x - 1] - 'a'];
if (p) amin(dp[x][p][q], lb[dp[x][p - 1][q] + 1][b[p - 1] - 'a']);
if (q) amin(dp[x][p][q], lb[dp[x][p][q - 1] + 1][c[q - 1] - 'a']);
}
}
} else if (i == 2) {
b.push_back(ch);
int x = (int)((b).size());
for (int p = 0; p < (int)((a).size()) + 1; p++) {
for (int q = 0; q < (int)((c).size()) + 1; q++) {
dp[p][x][q] = lb[dp[p][x - 1][q] + 1][b[x - 1] - 'a'];
if (p) amin(dp[p][x][q], lb[dp[p - 1][x][q] + 1][a[p - 1] - 'a']);
if (q) amin(dp[p][x][q], lb[dp[p][x][q - 1] + 1][c[q - 1] - 'a']);
}
}
} else {
c.push_back(ch);
int x = (int)((c).size());
for (int p = 0; p < (int)((a).size()) + 1; p++) {
for (int q = 0; q < (int)((b).size()) + 1; q++) {
dp[p][q][x] = lb[dp[p][q][x - 1] + 1][c[x - 1] - 'a'];
if (p) amin(dp[p][q][x], lb[dp[p - 1][q][x] + 1][a[p - 1] - 'a']);
if (q) amin(dp[p][q][x], lb[dp[p][q - 1][x] + 1][b[q - 1] - 'a']);
}
}
}
} else {
if (i == 1) {
a.pop_back();
} else if (i == 2) {
b.pop_back();
} else {
c.pop_back();
}
}
int ans = dp[(int)((a).size())][(int)((b).size())][(int)((c).size())];
if (ans < n) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int M = 255;
int n, q;
int dp[M][M][M], nxt[N][26];
string Religion[3], st;
int len(int id) { return Religion[id].size(); }
int main() {
cin >> n >> q;
cin >> st;
for (int c = 0; c < 26; ++c) nxt[n + 1][c] = n + 1;
for (int i = n; i >= 0; --i) {
for (int c = 0; c < 26; ++c) nxt[i][c] = nxt[i + 1][c];
if (i < n) nxt[i][st[i] - 'a'] = i + 1;
}
for (int i = 0; i < M; ++i) {
for (int j = 0; j < M; ++j) {
for (int k = 0; k < M; ++k) dp[i][j][k] = n + 1;
}
}
dp[0][0][0] = 0;
while (q--) {
char type;
int id;
cin >> type >> id;
--id;
if (type == '+') {
char c;
cin >> c;
Religion[id].push_back(c);
if (id == 0) {
int i = len(id);
for (int j = 0; j <= len(1); ++j) {
for (int k = 0; k <= len(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]][Religion[0][i - 1] - 'a']);
if (j)
dp[i][j][k] = min(dp[i][j][k],
nxt[dp[i][j - 1][k]][Religion[1][j - 1] - 'a']);
if (k)
dp[i][j][k] = min(dp[i][j][k],
nxt[dp[i][j][k - 1]][Religion[2][k - 1] - 'a']);
}
}
} else if (id == 1) {
int j = len(id);
for (int i = 0; i <= len(0); ++i) {
for (int k = 0; k <= len(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]][Religion[0][i - 1] - 'a']);
if (j)
dp[i][j][k] = min(dp[i][j][k],
nxt[dp[i][j - 1][k]][Religion[1][j - 1] - 'a']);
if (k)
dp[i][j][k] = min(dp[i][j][k],
nxt[dp[i][j][k - 1]][Religion[2][k - 1] - 'a']);
}
}
} else if (id == 2) {
int k = len(id);
for (int i = 0; i <= len(0); ++i) {
for (int j = 0; j <= len(1); ++j) {
dp[i][j][k] = N + 1;
if (i)
dp[i][j][k] = min(dp[i][j][k],
nxt[dp[i - 1][j][k]][Religion[0][i - 1] - 'a']);
if (j)
dp[i][j][k] = min(dp[i][j][k],
nxt[dp[i][j - 1][k]][Religion[1][j - 1] - 'a']);
if (k)
dp[i][j][k] = min(dp[i][j][k],
nxt[dp[i][j][k - 1]][Religion[2][k - 1] - 'a']);
}
}
}
} else {
Religion[id].pop_back();
}
if (dp[len(0)][len(1)][len(2)] <= n)
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int seed = 131;
int n, m, nex[30][MAXN], pos[30];
string opt, ch;
char str[MAXN];
int id, dp[260][260][260], cnt[4];
char s[4][300];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
cin >> (str + 1);
for (int i = 0; i <= 25; i++) pos[i] = n + 1, nex[i][n + 1] = n + 1;
for (int i = n; i >= 0; i--) {
for (int j = 0; j <= 25; j++) nex[j][i] = pos[j];
if (i >= 1) pos[str[i] - 'a'] = i;
}
for (int cas = 1; cas <= m; cas++) {
cin >> opt >> id;
if (opt == "+") {
cin >> ch;
ch[0] -= 'a';
cnt[id]++;
s[id][cnt[id]] = ch[0];
if (id == 1) {
for (int i = 0; i <= cnt[2]; i++) {
for (int j = 0; j <= cnt[3]; j++) {
dp[cnt[1]][i][j] = nex[ch[0]][dp[cnt[1] - 1][i][j]];
if (i > 0)
dp[cnt[1]][i][j] =
min(dp[cnt[1]][i][j], nex[s[2][i]][dp[cnt[1]][i - 1][j]]);
if (j > 0)
dp[cnt[1]][i][j] =
min(dp[cnt[1]][i][j], nex[s[3][j]][dp[cnt[1]][i][j - 1]]);
}
}
} else if (id == 2) {
for (int i = 0; i <= cnt[1]; i++) {
for (int j = 0; j <= cnt[3]; j++) {
dp[i][cnt[2]][j] = nex[ch[0]][dp[i][cnt[2] - 1][j]];
if (i > 0)
dp[i][cnt[2]][j] =
min(dp[i][cnt[2]][j], nex[s[1][i]][dp[i - 1][cnt[2]][j]]);
if (j > 0)
dp[i][cnt[2]][j] =
min(dp[i][cnt[2]][j], nex[s[3][j]][dp[i][cnt[2]][j - 1]]);
}
}
} else if (id == 3) {
for (int i = 0; i <= cnt[1]; i++) {
for (int j = 0; j <= cnt[2]; j++) {
dp[i][j][cnt[3]] = nex[ch[0]][dp[i][j][cnt[3] - 1]];
if (i > 0)
dp[i][j][cnt[3]] =
min(dp[i][j][cnt[3]], nex[s[1][i]][dp[i - 1][j][cnt[3]]]);
if (j > 0)
dp[i][j][cnt[3]] =
min(dp[i][j][cnt[3]], nex[s[2][j]][dp[i][j - 1][cnt[3]]]);
}
}
}
} else
cnt[id]--;
if (dp[cnt[1]][cnt[2]][cnt[3]] > n)
cout << "NO\n";
else
cout << "YES\n";
}
return 0;
}
|
#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];
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];
auto itr = idx[c].lower_bound(dp[i - 1][j][k] + 1);
if (itr != idx[c].end()) dp[i][j][k] = min(dp[i][j][k], *itr);
}
if (j > 0) {
int c = t[1][j];
auto itr = idx[c].lower_bound(dp[i][j - 1][k] + 1);
if (itr != idx[c].end()) dp[i][j][k] = min(dp[i][j][k], *itr);
}
if (k > 0) {
int c = t[2][k];
auto itr = idx[c].lower_bound(dp[i][j][k - 1] + 1);
if (itr != idx[c].end()) dp[i][j][k] = min(dp[i][j][k], *itr);
}
}
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);
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;
const int N = 1e5 + 5, M = 255;
namespace {
template <typename T>
inline void read(T &x) {
x = 0;
T f = 1;
static char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ 48);
x *= f;
}
inline void Min(int &a, int b) {
if (b < a) a = b;
}
} // namespace
int n, m, q, l[4], cnt[50], las[N][50], dp[M][M][M];
char a[N], c[2], d[4][M];
inline void init() {
fill(cnt, cnt + 45, n + 1);
fill(las[n + 1], las[n + 1] + 45, n + 1);
for (int i = n; ~i; --i) {
for (int j = 0; j < 26; ++j) las[i][j] = cnt[j];
if (i) cnt[(a[i] - 'a')] = i;
}
}
int main() {
read(n), read(q), scanf("%s", a + 1);
init();
for (; q--;) {
scanf("%s", c + 1);
if (c[1] == '+') {
read(m), scanf("%s", c);
++l[m], d[m][l[m]] = *c;
for (int p1 = m == 1 ? l[m] : 0; p1 <= l[1]; ++p1) {
for (int p2 = m == 2 ? l[m] : 0; p2 <= l[2]; ++p2) {
for (int p3 = m == 3 ? l[m] : 0; p3 <= l[3]; ++p3) {
dp[p1][p2][p3] = n + 1;
if (p1)
dp[p1][p2][p3] = min(dp[p1][p2][p3],
las[dp[p1 - 1][p2][p3]][(d[1][p1] - 'a')]);
if (p2)
dp[p1][p2][p3] = min(dp[p1][p2][p3],
las[dp[p1][p2 - 1][p3]][(d[2][p2] - 'a')]);
if (p3)
dp[p1][p2][p3] = min(dp[p1][p2][p3],
las[dp[p1][p2][p3 - 1]][(d[3][p3] - 'a')]);
}
}
}
} else
read(m), --l[m];
printf(dp[l[1]][l[2]][l[3]] <= n ? "YES\n" : "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const int MOD = 1e9 + 7;
const int MAX = 1e5 + 10;
const long long LNF = 2e18;
int n, q, m = 'z' - 'a' + 1;
int P[MAX][30];
char S[MAX], T[4][256];
int D[256][256][256];
int A[4];
inline int f(char c) { return c - 'a'; }
inline int g(int i, int j, int k, char c) {
int d = D[i][j][k];
if (d >= n) return INF;
return P[d + 1][c - 'a'];
}
inline int h(int i, int j, int k) {
int res = INF;
if (i > 0) res = min(res, g(i - 1, j, k, T[1][i]));
if (j > 0) res = min(res, g(i, j - 1, k, T[2][j]));
if (k > 0) res = min(res, g(i, j, k - 1, T[3][k]));
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q >> (S + 1);
for (int i = 0; i < m; i++) P[n + 1][i] = INF;
for (int i = n; i >= 0; i--) {
for (int j = 0; j < m; j++) P[i][j] = P[i + 1][j];
P[i][S[i] - 'a'] = i;
}
for (int qq = 1; qq <= q; qq++) {
char ord, c;
int x;
cin >> ord >> x;
if (ord == '+') {
cin >> c;
A[x]++, T[x][A[x]] = c;
if (x == 1) {
int i = A[x];
for (int j = 0; j <= A[2]; j++)
for (int k = 0; k <= A[3]; k++) D[i][j][k] = h(i, j, k);
} else if (x == 2) {
int j = A[x];
for (int i = 0; i <= A[1]; i++)
for (int k = 0; k <= A[3]; k++) D[i][j][k] = h(i, j, k);
} else if (x == 3) {
int k = A[x];
for (int i = 0; i <= A[1]; i++)
for (int j = 0; j <= A[2]; j++) D[i][j][k] = h(i, j, k);
}
} else
A[x]--;
cout << (D[A[1]][A[2]][A[3]] < INF ? "YES" : "NO") << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using vpdd = vector<pdd>;
template <typename T>
void ckmin(T &a, const T &b) {
a = min(a, b);
}
template <typename T>
void ckmax(T &a, const T &b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2> &p);
template <class T>
void re(vector<T> &a);
template <class T, size_t SZ>
void re(array<T, SZ> &a);
template <class T>
void re(T &x) {
cin >> x;
}
void re(double &x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg &first, Args &...rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2> &p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T> &a) {
for (int i = 0; i < int((a).size()); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ> &a) {
for (int i = 0; i < SZ; i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <typename T>
struct is_outputtable {
template <typename C>
static constexpr decltype(declval<ostream &>() << declval<const C &>(),
bool())
test(int) {
return true;
}
template <typename C>
static constexpr bool test(...) {
return false;
}
static constexpr bool value = test<T>(int());
};
template <
class T, typename V = decltype(declval<const T &>().begin()),
typename S = typename enable_if<!is_outputtable<T>::value, bool>::type>
void pr(const T &x);
template <class T,
typename V = decltype(declval<ostream &>() << declval<const T &>())>
void pr(const T &x) {
cout << x;
}
template <class T1, class T2>
void pr(const pair<T1, T2> &x);
template <class Arg, class... Args>
void pr(const Arg &first, const Args &...rest) {
pr(first);
pr(rest...);
}
template <class T, bool pretty = true>
void prContain(const T &x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto &a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T &x) {
prContain<T, false>(x);
pr("\n");
}
template <class T1, class T2>
void pr(const pair<T1, T2> &x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, typename V, typename S>
void pr(const T &x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg &first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg &first, const Args &...rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T> &v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::const_iterator find(const vector<T> &v, const T &x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(const vector<T> &v, const T &x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename I>
struct _reversed_struct {
I &v_;
explicit _reversed_struct(I &v) : v_{v} {}
typename I::reverse_iterator begin() const { return v_.rbegin(); }
typename I::reverse_iterator end() const { return v_.rend(); }
};
template <typename I>
_reversed_struct<I> reversed(I &v) {
return _reversed_struct<I>(v);
}
} // namespace __algorithm
using namespace __algorithm;
namespace __io {
void setIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << setprecision(15);
}
} // namespace __io
using namespace __io;
constexpr char A = 'a';
constexpr int MAX = 250 + 1;
constexpr int INF = 1e9;
const string YES = "YES", NO = "NO";
int main() {
setIO();
int n, q;
re(n, q);
string second;
re(second);
vvi indices(26);
for (int i = 0; i < int((second).size()); i++) {
indices[second[i] - A].push_back(i + 1);
}
auto get = [&](int i, int c) {
auto it = upper_bound((indices[c]).begin(), (indices[c]).end(), i);
if (it == indices[c].end()) return INF;
return *it;
};
vector<vvi> dp(MAX, vvi(MAX, vi(MAX, INF)));
dp[0][0][0] = 0;
array<int, 3> len{};
vector<vector<int>> words(3);
for (int query = 0; query < q; query++) {
char type;
re(type);
int dim;
re(dim);
dim--;
if (type == '+') {
len[dim]++;
char letter;
re(letter);
int c = letter - A;
words[dim].push_back(c);
auto fill = [&](int i, int j, int k) {
dp[i][j][k] = INF;
if (i - 1 >= 0)
ckmin(dp[i][j][k], get(dp[i - 1][j][k], words[0][i - 1]));
if (j - 1 >= 0)
ckmin(dp[i][j][k], get(dp[i][j - 1][k], words[1][j - 1]));
if (k - 1 >= 0)
ckmin(dp[i][j][k], get(dp[i][j][k - 1], words[2][k - 1]));
};
for (int i = dim == 0 ? len[0] : 0; i <= len[0]; i++) {
for (int j = dim == 1 ? len[1] : 0; j <= len[1]; j++) {
for (int k = dim == 2 ? len[2] : 0; k <= len[2]; k++) {
if (i + j + k == 0) continue;
fill(i, j, k);
}
}
}
} else {
len[dim]--;
words[dim].pop_back();
}
bool ans = dp[len[0]][len[1]][len[2]] != INF;
ps(ans ? YES : NO);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[251][251][251];
int main() {
int n, q;
cin >> n >> q;
string s;
cin >> s;
int maxNum = n + 1;
int preP[n + 2][26];
for (int i = 0; i < 26; i++) {
preP[n][i] = maxNum;
preP[n + 1][i] = maxNum;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) preP[i][j] = preP[i + 1][j];
preP[i][s[i] - 'a'] = i + 1;
}
int rel;
char op, ch;
dp[0][0][0] = 0;
int tempA, tempB, tempC, x;
vector<char> religion[4];
for (int i = 0; i < q; i++) {
cin >> op;
if (op == '+') {
cin >> rel >> ch;
religion[rel].push_back(ch);
if (rel == 1) {
int i = religion[rel].size();
for (int j = 0; j <= religion[2].size(); j++) {
for (int k = 0; k <= religion[3].size(); k++) {
x = dp[i - 1][j][k];
tempA = preP[x][religion[rel][i - 1] - 'a'];
dp[i][j][k] = tempA;
if (j > 0) {
x = dp[i][j - 1][k];
tempB = preP[x][religion[2][j - 1] - 'a'];
dp[i][j][k] = min(dp[i][j][k], tempB);
}
if (k > 0) {
x = dp[i][j][k - 1];
tempC = preP[x][religion[3][k - 1] - 'a'];
dp[i][j][k] = min(dp[i][j][k], tempC);
}
}
}
}
if (rel == 2) {
int i = religion[rel].size();
for (int j = 0; j <= religion[1].size(); j++) {
for (int k = 0; k <= religion[3].size(); k++) {
x = dp[j][i - 1][k];
tempA = preP[x][religion[rel][i - 1] - 'a'];
dp[j][i][k] = tempA;
if (j > 0) {
x = dp[j - 1][i][k];
tempB = preP[x][religion[1][j - 1] - 'a'];
dp[j][i][k] = min(dp[j][i][k], tempB);
}
if (k > 0) {
x = dp[j][i][k - 1];
tempC = preP[x][religion[3][k - 1] - 'a'];
dp[j][i][k] = min(dp[j][i][k], tempC);
}
}
}
}
if (rel == 3) {
int i = religion[rel].size();
for (int j = 0; j <= religion[1].size(); j++) {
for (int k = 0; k <= religion[2].size(); k++) {
x = dp[j][k][i - 1];
tempA = preP[x][religion[rel][i - 1] - 'a'];
dp[j][k][i] = tempA;
if (j > 0) {
x = dp[j - 1][k][i];
tempB = preP[x][religion[1][j - 1] - 'a'];
dp[j][k][i] = min(dp[j][k][i], tempB);
}
if (k > 0) {
x = dp[j][k - 1][i];
tempC = preP[x][religion[2][k - 1] - 'a'];
dp[j][k][i] = min(dp[j][k][i], tempC);
}
}
}
}
int i = religion[1].size(), j = religion[2].size(),
k = religion[3].size();
if (dp[i][j][k] <= n) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else {
cin >> rel;
religion[rel].pop_back();
int i = religion[1].size(), j = religion[2].size(),
k = religion[3].size();
if (dp[i][j][k] <= n) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 1000 + 10;
const int maxn5 = 5 * 1000 * 100 + 10;
const int maxn3 = 250 + 10;
const long long mod = 1000 * 1000 * 1000 + 7;
const long long inf = 1LL * 2 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 10;
string t[4];
int dp[maxn3][maxn3][maxn3], sz[5];
vector<int> av[50];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
string s;
cin >> s;
t[1] = s;
t[2] = s;
t[3] = s;
t[1].push_back('1');
t[2].push_back('3');
t[3].push_back('4');
dp[0][0][0] = -1;
for (int i = 0; i < n; i++) av[s[i] - 'a'].push_back(i);
for (int i = 0; i < 30; i++) av[i].push_back(maxn5);
for (int jj = 0; jj < q; jj++) {
char op;
cin >> op;
bool re;
if (op == '-') {
int a;
cin >> a;
sz[a]--;
if (sz[1] > n or sz[2] > n or sz[3] > n)
re = false;
else
re = dp[sz[1]][sz[2]][sz[3]] < maxn5;
} else {
int a;
cin >> a;
char r;
cin >> r;
sz[a]++;
if (sz[a] > n)
re = false;
else {
t[a][sz[a]] = r;
for (int i = (a == 1 ? sz[a] : 0); i <= sz[1]; i++) {
for (int j = (a == 2 ? sz[a] : 0); j <= sz[2]; j++) {
for (int k = (a == 3 ? sz[a] : 0); k <= sz[3]; k++) {
dp[i][j][k] = maxn5;
if (i != 0 and dp[i - 1][j][k] != maxn5) {
int ans =
av[t[1][i] - 'a']
[upper_bound(av[t[1][i] - 'a'].begin(),
av[t[1][i] - 'a'].end(), dp[i - 1][j][k]) -
av[t[1][i] - 'a'].begin()];
dp[i][j][k] = min(ans, dp[i][j][k]);
}
if (j != 0 and dp[i][j - 1][k] != maxn5) {
int ans =
av[t[2][j] - 'a']
[upper_bound(av[t[2][j] - 'a'].begin(),
av[t[2][j] - 'a'].end(), dp[i][j - 1][k]) -
av[t[2][j] - 'a'].begin()];
dp[i][j][k] = min(ans, dp[i][j][k]);
}
if (k != 0 and dp[i][j][k - 1] != maxn5) {
int ans =
av[t[3][k] - 'a']
[upper_bound(av[t[3][k] - 'a'].begin(),
av[t[3][k] - 'a'].end(), dp[i][j][k - 1]) -
av[t[3][k] - 'a'].begin()];
dp[i][j][k] = min(ans, dp[i][j][k]);
}
}
}
}
re = dp[sz[1]][sz[2]][sz[3]] < maxn5;
}
}
cout << (re ? "YES\n" : "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 555;
char saveori[maxn];
int pos[maxn][53];
int dp[300][300][300];
string s[4];
void solve() {
int n, m;
cin >> n >> m;
scanf("%s", saveori + 1);
memset(pos, 0x3f, sizeof(pos));
memset(dp, 0x3f, sizeof(dp));
int inf = pos[0][0];
for (int i = n - 1; i >= 0; i--) {
for (int j = 'a' - 'a'; j <= 'z' - 'a'; j++) {
pos[i][j] = pos[i + 1][j];
}
int nowc = saveori[i + 1] - 'a';
pos[i][nowc] = i + 1;
}
s[0] = "";
s[1] = "";
s[2] = "";
dp[0][0][0] = 0;
while (m--) {
char str[3];
scanf("%s", str);
int id;
scanf("%d", &id);
id--;
if (str[0] == '+') {
scanf("%s", str);
s[id] += str[0];
int nowlen = s[id].size();
if (id == 0) {
for (int i = 0; i <= s[1].size(); i++) {
for (int j = 0; j <= s[2].size(); j++) {
dp[nowlen][i][j] = inf;
if (nowlen && dp[nowlen - 1][i][j] <= n)
dp[nowlen][i][j] =
min(pos[dp[nowlen - 1][i][j]][s[0][nowlen - 1] - 'a'],
dp[nowlen][i][j]);
if (i && dp[nowlen][i - 1][j] <= n)
dp[nowlen][i][j] =
min(pos[dp[nowlen][i - 1][j]][s[1][i - 1] - 'a'],
dp[nowlen][i][j]);
if (j && dp[nowlen][i][j - 1] <= n)
dp[nowlen][i][j] =
min(pos[dp[nowlen][i][j - 1]][s[2][j - 1] - 'a'],
dp[nowlen][i][j]);
}
}
} else if (id == 1) {
for (int i = 0; i <= s[0].size(); i++) {
for (int j = 0; j <= s[2].size(); j++) {
dp[i][nowlen][j] = inf;
if (nowlen && dp[i][nowlen - 1][j] <= n)
dp[i][nowlen][j] =
min(pos[dp[i][nowlen - 1][j]][s[1][nowlen - 1] - 'a'],
dp[i][nowlen][j]);
if (i && dp[i - 1][nowlen][j] <= n)
dp[i][nowlen][j] =
min(pos[dp[i - 1][nowlen][j]][s[0][i - 1] - 'a'],
dp[i][nowlen][j]);
if (j && dp[i][nowlen][j - 1] <= n)
dp[i][nowlen][j] =
min(pos[dp[i][nowlen][j - 1]][s[2][j - 1] - 'a'],
dp[i][nowlen][j]);
}
}
} else {
for (int i = 0; i <= s[0].size(); i++) {
for (int j = 0; j <= s[1].size(); j++) {
dp[i][j][nowlen] = inf;
if (nowlen && dp[i][j][nowlen - 1] <= n)
dp[i][j][nowlen] =
min(pos[dp[i][j][nowlen - 1]][s[2][nowlen - 1] - 'a'],
dp[i][j][nowlen]);
if (i && dp[i - 1][j][nowlen] <= n)
dp[i][j][nowlen] =
min(pos[dp[i - 1][j][nowlen]][s[0][i - 1] - 'a'],
dp[i][j][nowlen]);
if (j && dp[i][j - 1][nowlen] <= n)
dp[i][j][nowlen] =
min(pos[dp[i][j - 1][nowlen]][s[1][j - 1] - 'a'],
dp[i][j][nowlen]);
}
}
}
} else {
s[id] = s[id].substr(0, s[id].size() - 1);
int nowlen = s[id].size();
if (id == 0) {
for (int i = 0; i <= s[1].size(); i++) {
for (int j = 0; j <= s[2].size(); j++) {
dp[nowlen + 1][i][j] = inf;
}
}
}
if (id == 1) {
for (int i = 0; i <= s[0].size(); i++) {
for (int j = 0; j <= s[2].size(); j++) {
dp[i][nowlen + 1][j] = inf;
}
}
}
if (id == 2) {
for (int i = 0; i <= s[0].size(); i++) {
for (int j = 0; j <= s[1].size(); j++) {
dp[i][j][nowlen + 1] = inf;
}
}
}
}
if (dp[s[0].size()][s[1].size()][s[2].size()] > n) {
puts("NO");
} else {
puts("YES");
}
}
}
signed main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110000;
const int MAXL = 300;
const int MAXS = 26;
char s[MAXN], a[4][MAXL];
int l[4], t[MAXS], nxt[MAXN][MAXS];
int f[MAXL][MAXL][MAXL];
int main() {
int n, q;
scanf("%d%d%s", &n, &q, s + 1);
for (int i = 0; i < MAXS; i++) t[i] = n + 1;
for (int i = n + 1; i >= 0; i--) {
for (int j = 0; j < MAXS; j++) nxt[i][j] = t[j];
if (s[i]) t[s[i] - 'a'] = i;
}
while (q--) {
char opt[2], c[2];
int x;
scanf("%s%d", opt, &x);
if (opt[0] == '+') {
scanf("%s", c);
a[x][++l[x]] = c[0];
int s1 = 0, s2 = 0, s3 = 0;
if (x == 1)
s1 = l[1];
else if (x == 2)
s2 = l[2];
else
s3 = l[3];
for (int i = s1; i <= l[1]; i++)
for (int j = s2; j <= l[2]; j++)
for (int k = s3; k <= l[3]; k++) {
f[i][j][k] = i == 0 && j == 0 && k == 0 ? 0 : n + 1;
if (i > 0)
f[i][j][k] = min(f[i][j][k], nxt[f[i - 1][j][k]][a[1][i] - 'a']);
if (j > 0)
f[i][j][k] = min(f[i][j][k], nxt[f[i][j - 1][k]][a[2][j] - 'a']);
if (k > 0)
f[i][j][k] = min(f[i][j][k], nxt[f[i][j][k - 1]][a[3][k] - 'a']);
}
} else
l[x]--;
puts(f[l[1]][l[2]][l[3]] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
int ri() {
int x;
scanf("%d", &x);
return x;
}
int64_t ri64() {
int64_t x;
scanf("%lld", &x);
return x;
}
void wi(int x) { printf("%d\n", x); }
void wvi(vector<int> &v) {
for (int i = 0; i < v.size(); i++) printf("%d ", v[i]);
printf("\n");
}
void dbg(string &str, int x) {
cout << str << ": ";
wi(x);
}
void dbg(string &str, vector<int> &x) {
cout << str << ": ";
wvi(x);
}
int R[251][251][251];
int main() {
int n = ri();
int q = ri();
string str;
cin >> str;
vector<vector<int> > P(n + 1, vector<int>(26, -1));
vector<int> lst(26, -1);
for (int i = n - 1; i >= 0; i--) {
int x = str[i] - 'a';
lst[x] = i;
for (int j = 0; j < 26; j++) P[i][j] = lst[j];
}
vector<vector<int> > A(3);
R[0][0][0] = 0;
for (int cnt = 0; cnt < q; cnt++) {
string x;
cin >> x;
int type;
cin >> type;
type--;
if (x[0] == '+') {
string y;
cin >> y;
int c = y[0] - 'a';
A[type].push_back(c);
int m = A[type].size();
if (type == 0) {
for (int i = 0; i <= A[1].size(); i++) {
for (int j = 0; j <= A[2].size(); j++) {
int ans = -1;
if (R[m - 1][i][j] != -1 && P[R[m - 1][i][j]][c] != -1)
ans = 1 + P[R[m - 1][i][j]][c];
if (i > 0 && (R[m][i - 1][j] != -1)) {
int t = P[R[m][i - 1][j]][A[1][i - 1]];
if (t != -1) {
if (ans == -1 || ans > (1 + t)) ans = 1 + t;
}
}
if (j > 0 && (R[m][i][j - 1] != -1)) {
int t = P[R[m][i][j - 1]][A[2][j - 1]];
if (t != -1) {
if (ans == -1 || ans > (1 + t)) ans = 1 + t;
}
}
R[m][i][j] = ans;
}
}
}
if (type == 1) {
for (int i = 0; i <= A[0].size(); i++) {
for (int j = 0; j <= A[2].size(); j++) {
int ans = -1;
if (R[i][m - 1][j] != -1 && P[R[i][m - 1][j]][c] != -1)
ans = 1 + P[R[i][m - 1][j]][c];
if (i > 0 && (R[i - 1][m][j] != -1)) {
int t = P[R[i - 1][m][j]][A[0][i - 1]];
if (t != -1) {
if (ans == -1 || ans > (1 + t)) ans = 1 + t;
}
}
if (j > 0 && (R[i][m][j - 1] != -1)) {
int t = P[R[i][m][j - 1]][A[2][j - 1]];
if (t != -1) {
if (ans == -1 || ans > (1 + t)) ans = 1 + t;
}
}
R[i][m][j] = ans;
}
}
}
if (type == 2) {
for (int i = 0; i <= A[0].size(); i++) {
for (int j = 0; j <= A[1].size(); j++) {
int ans = -1;
if (R[i][j][m - 1] != -1 && P[R[i][j][m - 1]][c] != -1)
ans = 1 + P[R[i][j][m - 1]][c];
if (i > 0 && (R[i - 1][j][m] != -1)) {
int t = P[R[i - 1][j][m]][A[0][i - 1]];
if (t != -1) {
if (ans == -1 || ans > (1 + t)) ans = 1 + t;
}
}
if (j > 0 && (R[i][j - 1][m] != -1)) {
int t = P[R[i][j - 1][m]][A[1][j - 1]];
if (t != -1) {
if (ans == -1 || ans > (1 + t)) ans = 1 + t;
}
}
R[i][j][m] = ans;
}
}
}
} else {
A[type].pop_back();
}
if (R[A[0].size()][A[1].size()][A[2].size()] != -1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 100050;
const int T = 255;
int readInt() {
int ans = 0, c, f = 1;
while (!isdigit(c = getchar()))
if (c == '-') f *= -1;
do ans = ans * 10 + c - '0';
while (isdigit(c = getchar()));
return ans * f;
}
char s[N], op[2];
char p1[N], p2[N], p3[N];
int n, q, nxt[N][26], F[T][T][T], n1, n2, n3;
inline void dp(int a, int b, int c) {
int xa = a > 0 ? nxt[F[a - 1][b][c]][p1[a - 1] - 'a'] : n + 1;
int xb = b > 0 ? nxt[F[a][b - 1][c]][p2[b - 1] - 'a'] : n + 1;
int xc = c > 0 ? nxt[F[a][b][c - 1]][p3[c - 1] - 'a'] : n + 1;
F[a][b][c] = std::min(xa, std::min(xb, xc));
}
int main() {
n = readInt();
q = readInt();
scanf("%s", s);
for (int i = 0; i < 26; ++i) nxt[n][i] = nxt[n + 1][i] = n + 1;
for (int i = n - 1; i >= 0; --i) {
memcpy(nxt[i], nxt[i + 1], sizeof nxt[i + 1]);
nxt[i][s[i] - 'a'] = i + 1;
}
F[0][0][0] = 0;
while (q--) {
int o;
scanf("%s%d", op, &o);
if (*op == '-')
--(o == 1 ? n1 : o == 2 ? n2 : n3);
else if (o == 1) {
scanf("%s", p1 + (n1++));
for (int j = 0; j <= n2; ++j)
for (int k = 0; k <= n3; ++k) dp(n1, j, k);
} else if (o == 2) {
scanf("%s", p2 + (n2++));
for (int i = 0; i <= n1; ++i)
for (int k = 0; k <= n3; ++k) dp(i, n2, k);
} else {
scanf("%s", p3 + (n3++));
for (int i = 0; i <= n1; ++i)
for (int j = 0; j <= n2; ++j) dp(i, j, n3);
}
puts(F[n1][n2][n3] <= n ? "YES" : "NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400000;
const int B = 500;
int n, q;
string w[4], s;
int nxt[N][26];
int f[252][252][252];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> q;
cin >> s;
for (int i = 0; i < 26; i++) {
nxt[n + 1][i] = n + 1;
nxt[n][i] = n + 1;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
nxt[i][j] = nxt[i + 1][j];
}
nxt[i][s[i] - 'a'] = i + 1;
}
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 (; q >= 1; q--) {
string tp, c;
int x;
cin >> tp >> x;
if (tp == "+") {
cin >> c;
w[x] += c;
vector<int> l = {0, 0, 0};
vector<int> r = {(int)w[1].size(), (int)w[2].size(), (int)w[3].size()};
l[x - 1] = w[x].size() - 1;
for (int i = l[0]; i <= r[0]; i++) {
for (int j = l[1]; j <= r[1]; j++) {
for (int k = l[2]; k <= r[2]; k++) {
if (i < r[0]) {
f[i + 1][j][k] =
min(f[i + 1][j][k], nxt[f[i][j][k]][w[1][i] - 'a']);
}
if (j < r[1]) {
f[i][j + 1][k] =
min(f[i][j + 1][k], nxt[f[i][j][k]][w[2][j] - 'a']);
}
if (k < r[2]) {
f[i][j][k + 1] =
min(f[i][j][k + 1], nxt[f[i][j][k]][w[3][k] - 'a']);
}
}
}
}
} else {
vector<int> l = {0, 0, 0};
vector<int> r = {(int)w[1].size(), (int)w[2].size(), (int)w[3].size()};
l[x - 1] = w[x].size();
for (int i = l[0]; i <= r[0]; i++) {
for (int j = l[1]; j <= r[1]; j++) {
for (int k = l[2]; k <= r[2]; k++) {
f[i][j][k] = n + 1;
}
}
}
w[x].pop_back();
}
if (f[w[1].size()][w[2].size()][w[3].size()] < n + 1) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, Q;
char ss[200001];
long long num[200001];
string s[4];
long long dp[255][255][255];
long long Next[200001][26];
vector<string> ans;
char c, ch;
long long x;
void run(long long x) {
for (long long i = x == 1 ? s[1].size() : 0; i <= s[1].size(); i++) {
for (long long j = x == 2 ? s[2].size() : 0; j <= s[2].size(); j++) {
for (long long k = x == 3 ? s[3].size() : 0; k <= s[3].size(); k++) {
if (i && dp[i - 1][j][k] != 1e9)
dp[i][j][k] =
min(dp[i][j][k], Next[dp[i - 1][j][k]][s[1][i - 1] - 'a']);
if (j && dp[i][j - 1][k] != 1e9)
dp[i][j][k] =
min(dp[i][j][k], Next[dp[i][j - 1][k]][s[2][j - 1] - 'a']);
if (k && dp[i][j][k - 1] != 1e9)
dp[i][j][k] =
min(dp[i][j][k], Next[dp[i][j][k - 1]][s[3][k - 1] - 'a']);
}
}
}
}
void clear(long long x) {
for (long long i = x == 1 ? s[1].size() : 0; i <= s[1].size(); i++) {
for (long long j = x == 2 ? s[2].size() : 0; j <= s[2].size(); j++) {
for (long long k = x == 3 ? s[3].size() : 0; k <= s[3].size(); k++) {
dp[i][j][k] = 1e9;
}
}
}
}
signed main() {
ios::sync_with_stdio(false);
cin >> n >> Q;
for (long long i = 0; i < (n); i++) {
cin >> ss[i + 1];
}
for (long long i = 0; i < (n + 1); i++)
for (long long j = 0; j < (26); j++) Next[i][j] = 1e9;
for (long long i = 0; i < (4); i++) {
s[i] = "";
}
for (long long i = n; i; i--) {
for (long long j = 0; j < (26); j++) {
char c = 'a' + j;
if (ss[i] == c) {
Next[i - 1][j] = i;
} else {
Next[i - 1][j] = Next[i][j];
}
}
}
for (long long i = 0; i < (255); i++)
for (long long j = 0; j < (255); j++)
for (long long k = 0; k < (255); k++) dp[i][j][k] = 1e9;
dp[0][0][0] = 0;
for (long long q = 0; q < (Q); q++) {
cin >> c >> x;
if (c == '+') {
cin >> ch;
s[x] += ch;
run(x);
} else {
clear(x);
s[x].pop_back();
}
if (dp[s[1].size()][s[2].size()][s[3].size()] != 1e9)
ans.push_back("YES");
else
ans.push_back("NO");
}
for (auto sss : ans) cout << sss << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100005];
int nxt[100005][30];
int sa[255], sb[255], sc[255];
int f[255][255][255];
int main() {
int n, q;
cin >> n >> q >> s + 1;
for (int j = 0; j < 26; j++) nxt[n + 1][j] = nxt[n + 2][j] = n + 1;
for (int i = n; i; i--) {
memcpy(nxt[i], nxt[i + 1], sizeof(nxt[i]));
nxt[i][s[i] - 'a'] = i;
}
int m = min(q, 252), la = 0, lb = 0, lc = 0;
for (int i = 0; i <= m; i++)
for (int j = 0; j <= m; j++)
for (int k = 0; k <= m; k++) f[i][j][k] = n + 1;
f[0][0][0] = 0;
while (q--) {
char opt;
int x;
cin >> opt >> x;
if (opt == '+') {
char add;
cin >> add;
if (x == 1) {
sa[++la] = add - 'a';
for (int i = 0; i <= m; i++)
for (int j = 0; j <= m; j++) {
f[la][i][j] = nxt[f[la - 1][i][j] + 1][sa[la]];
if (i)
f[la][i][j] = min(f[la][i][j], nxt[f[la][i - 1][j] + 1][sb[i]]);
if (j)
f[la][i][j] = min(f[la][i][j], nxt[f[la][i][j - 1] + 1][sc[j]]);
}
} else if (x == 2) {
sb[++lb] = add - 'a';
for (int i = 0; i <= m; i++)
for (int j = 0; j <= m; j++) {
f[i][lb][j] = nxt[f[i][lb - 1][j] + 1][sb[lb]];
if (i)
f[i][lb][j] = min(f[i][lb][j], nxt[f[i - 1][lb][j] + 1][sa[i]]);
if (j)
f[i][lb][j] = min(f[i][lb][j], nxt[f[i][lb][j - 1] + 1][sc[j]]);
}
} else {
sc[++lc] = add - 'a';
for (int i = 0; i <= m; i++)
for (int j = 0; j <= m; j++) {
f[i][j][lc] = nxt[f[i][j][lc - 1] + 1][sc[lc]];
if (i)
f[i][j][lc] = min(f[i][j][lc], nxt[f[i - 1][j][lc] + 1][sa[i]]);
if (j)
f[i][j][lc] = min(f[i][j][lc], nxt[f[i][j - 1][lc] + 1][sb[j]]);
}
}
} else {
if (x == 1) {
for (int i = 0; i <= m; i++)
for (int j = 0; j <= m; j++) f[la][i][j] = n + 1;
la--;
} else if (x == 2) {
for (int i = 0; i <= m; i++)
for (int j = 0; j <= m; j++) f[i][lb][j] = n + 1;
lb--;
} else if (x == 3) {
for (int i = 0; i <= m; i++)
for (int j = 0; j <= m; j++) f[i][j][lc] = n + 1;
lc--;
}
}
if (f[la][lb][lc] > n)
puts("NO");
else
puts("YES");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e6 + 3;
long long inf = 1e18;
double eps = 1e-2;
ifstream in("input.txt");
ofstream out("output.txt");
int main() {
int n, q;
cin >> n >> q;
string s;
cin >> s;
vector<vector<int>> links(n + 3, vector<int>(26, n + 1));
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
links[i][j] = links[i + 1][j];
}
links[i][s[i] - 'a'] = i;
}
string s1, s2, s3;
vector<vector<vector<int>>> dp(
251, vector<vector<int>>(251, vector<int>(251, n + 2)));
dp[0][0][0] = 0;
int a = 0, b = 0, c = 0;
for (int w = 0; w < q; w++) {
char ch;
cin >> ch;
int t;
cin >> t;
if (ch == '+') {
cin >> ch;
if (t == 1) {
s1.push_back(ch);
a++;
for (int i = 0; i <= b; i++) {
for (int j = 0; j <= c; j++) {
dp[a][i][j] = links[dp[a - 1][i][j]][ch - 'a'] + 1;
if (i > 0)
dp[a][i][j] =
min(dp[a][i][j], links[dp[a][i - 1][j]][s2[i - 1] - 'a'] + 1);
if (j > 0)
dp[a][i][j] =
min(dp[a][i][j], links[dp[a][i][j - 1]][s3[j - 1] - 'a'] + 1);
}
}
}
if (t == 2) {
s2.push_back(ch);
b++;
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= c; j++) {
dp[i][b][j] = links[dp[i][b - 1][j]][ch - 'a'] + 1;
if (i > 0)
dp[i][b][j] =
min(dp[i][b][j], links[dp[i - 1][b][j]][s1[i - 1] - 'a'] + 1);
if (j > 0)
dp[i][b][j] =
min(dp[i][b][j], links[dp[i][b][j - 1]][s3[j - 1] - 'a'] + 1);
}
}
}
if (t == 3) {
s3.push_back(ch);
c++;
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= b; j++) {
dp[i][j][c] = links[dp[i][j][c - 1]][ch - 'a'] + 1;
if (i > 0)
dp[i][j][c] =
min(dp[i][j][c], links[dp[i - 1][j][c]][s1[i - 1] - 'a'] + 1);
if (j > 0)
dp[i][j][c] =
min(dp[i][j][c], links[dp[i][j - 1][c]][s2[j - 1] - 'a'] + 1);
}
}
}
} else {
if (t == 1) {
for (int i = 0; i <= b; i++) {
for (int j = 0; j <= c; j++) {
dp[a][i][j] = n + 2;
}
}
s1.pop_back();
a--;
}
if (t == 2) {
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= c; j++) {
dp[i][b][j] = n + 2;
}
}
s2.pop_back();
b--;
}
if (t == 3) {
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= b; j++) {
dp[i][j][c] = n + 2;
}
}
s3.pop_back();
c--;
}
}
if (dp[a][b][c] != n + 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[255][255][255], nxt[100005][26], n, q, len[5], lst[60];
char a[3][1005], s[100005];
inline void dp(int i, int j, int k) {
if (!(i | j | k)) return;
f[i][j][k] = n + 1;
if (i && f[i - 1][j][k] <= n)
f[i][j][k] = min(f[i][j][k], nxt[f[i - 1][j][k]][a[1][i] - 'a']);
if (j && f[i][j - 1][k] <= n)
f[i][j][k] = min(f[i][j][k], nxt[f[i][j - 1][k]][a[2][j] - 'a']);
if (k && f[i][j][k - 1] <= n)
f[i][j][k] = min(f[i][j][k], nxt[f[i][j][k - 1]][a[3][k] - 'a']);
}
int main() {
scanf("%d%d%s", &n, &q, s + 1);
for (int i = 0; i < 26; i++) lst[i] = n + 1;
for (int i = n; i >= 0; i--) {
for (int j = 0; j < 26; ++j) nxt[i][j] = lst[j];
if (i) lst[s[i] - 'a'] = i;
}
while (q--) {
char opt[3], ch[3];
int x;
scanf("%s%d", opt, &x);
if (opt[0] == '+') {
scanf("%s", ch);
a[x][++len[x]] = ch[0];
if (x == 1) {
for (int i = 0; i <= len[2]; i++)
for (int j = 0; j <= len[3]; j++) dp(len[x], i, j);
} else if (x == 2) {
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[3]; j++) dp(i, len[x], j);
} else {
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[2]; j++) dp(i, j, len[x]);
}
} else
len[x]--;
printf("%s\n", f[len[1]][len[2]][len[3]] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[100010];
int dp[26][100010];
int maxP[260][260][260];
int len[3];
int idx[3];
char desc[3][260];
int get() {
int ans = 100010;
for (int i = 0; i < 3; i++) {
if (!idx[i]) continue;
idx[i]--;
int m = maxP[idx[0]][idx[1]][idx[2]];
idx[i]++;
if (m == 100010) continue;
ans = min(ans, dp[desc[i][idx[i] - 1] - 'a'][m]);
}
return ans;
}
int main(void) {
setbuf(stdout, 0);
int N, Q;
cin >> N >> Q;
cin >> str;
for (int i = 0; i < 26; i++) dp[i][N] = 100010;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 26; j++) {
if (str[N - 1 - i] == 'a' + j)
dp[j][N - 1 - i] = N - i;
else
dp[j][N - 1 - i] = dp[j][N - i];
}
}
for (int q = 0; q < Q; q++) {
char o, c;
int i;
cin >> o >> i;
i--;
if (o == '+') {
cin >> c;
desc[i][len[i]++] = c;
idx[i] = len[i];
int jj = (i < 1);
int kk = 1 + (i < 2);
for (int j = 0; j <= len[jj]; j++) {
idx[jj] = j;
for (int k = 0; k <= len[kk]; k++) {
idx[kk] = k;
maxP[idx[0]][idx[1]][idx[2]] = get();
}
}
} else
len[i]--;
cout << (maxP[len[0]][len[1]][len[2]] < 100010 ? "YES\n" : "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int dp[N][26], f[255][255][255], pre[5][255], len[5], x;
char s[N], op[5], ch[5];
int main() {
int n, q;
scanf("%d%d%s", &n, &q, s + 1);
for (int j = 0; j < 26; j++) dp[n + 1][j] = dp[n][j] = n + 1;
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j < 26; j++)
dp[i][j] = (s[i + 1] - 'a' == j ? i + 1 : dp[i + 1][j]);
while (q--) {
scanf("%s%d", op, &x);
if (op[0] == '-')
len[x]--;
else {
scanf("%s", ch);
len[x]++;
pre[x][len[x]] = ch[0];
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], dp[f[i - 1][j][k]][pre[1][i] - 'a']);
if (j)
f[i][j][k] = min(f[i][j][k], dp[f[i][j - 1][k]][pre[2][j] - 'a']);
if (k)
f[i][j][k] = min(f[i][j][k], dp[f[i][j][k - 1]][pre[3][k] - 'a']);
}
}
printf("%s\n", f[len[1]][len[2]][len[3]] <= n ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
inline int read() {
int X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
char str[100005];
int trie[100005][28];
char s[4][100005];
int top[4];
int up[4];
int down[4];
int dp[305][305][305];
char op;
char tmp;
int main() {
int n, q;
cin >> n >> q;
cin >> (str + 1);
for (int i = 0; i <= 26; i++) {
trie[n + 1][i] = trie[n + 2][i] = n + 1;
}
str[0] = 0;
for (int i = n; i >= 0; i--) {
int cur = str[i] - 'a';
for (int j = 0; j < 26; j++) {
if (j == cur) {
trie[i][j] = i;
} else {
trie[i][j] = trie[i + 1][j];
}
}
}
memset(dp, 0x3f, sizeof dp);
dp[0][0][0] = 0;
while (q--) {
int id;
cin >> op;
if (op == '+') {
cin >> id >> tmp;
s[id][++top[id]] = tmp;
for (int i = 1; i <= 3; i++) {
if (i == id) {
down[i] = top[i];
} else {
down[i] = 0;
}
up[i] = top[i];
}
for (int i = down[1]; i <= up[1]; i++) {
for (int j = down[2]; j <= up[2]; j++) {
for (int k = down[3]; k <= up[3]; k++) {
dp[i][j][k] = n + 1;
if (i) {
dp[i][j][k] =
min(dp[i][j][k], trie[dp[i - 1][j][k] + 1][s[1][i] - 'a']);
}
if (j) {
dp[i][j][k] =
min(dp[i][j][k], trie[dp[i][j - 1][k] + 1][s[2][j] - 'a']);
}
if (k) {
dp[i][j][k] =
min(dp[i][j][k], trie[dp[i][j][k - 1] + 1][s[3][k] - 'a']);
}
}
}
}
} else {
cin >> id;
top[id]--;
}
if (dp[top[1]][top[2]][top[3]] > n) {
cout << "NO" << endl;
;
} else {
cout << "YES" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mn = 100005;
char s[mn], t[5], c[5];
int nxt[mn][26], f[300][300][300];
int ss[4][mn];
int main() {
int n, m;
scanf("%d%d%s", &n, &m, s + 1);
memset(nxt, 0x3f, sizeof nxt);
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];
if (i < n) nxt[i][s[i + 1] - 'a'] = i + 1;
}
int x = 0, y = 0, z = 0;
while (m--) {
int num;
scanf("%s%d", t, &num);
if (t[0] == '+') {
scanf("%s", c);
if (num == 1) {
ss[1][++x] = c[0];
for (int i = x; i <= x; i++)
for (int j = 0; j <= y; j++)
for (int k = 0; k <= z; k++) {
if (i + j + k) f[i][j][k] = n + 1;
if (i)
f[i][j][k] =
min(f[i][j][k], nxt[f[i - 1][j][k]][ss[1][i] - 'a']);
if (j)
f[i][j][k] =
min(f[i][j][k], nxt[f[i][j - 1][k]][ss[2][j] - 'a']);
if (k)
f[i][j][k] =
min(f[i][j][k], nxt[f[i][j][k - 1]][ss[3][k] - 'a']);
}
} else if (num == 2) {
ss[2][++y] = c[0];
for (int j = y; j <= y; j++)
for (int i = 0; i <= x; i++)
for (int k = 0; k <= z; k++) {
if (i + j + k) f[i][j][k] = n + 1;
if (i)
f[i][j][k] =
min(f[i][j][k], nxt[f[i - 1][j][k]][ss[1][i] - 'a']);
if (j)
f[i][j][k] =
min(f[i][j][k], nxt[f[i][j - 1][k]][ss[2][j] - 'a']);
if (k)
f[i][j][k] =
min(f[i][j][k], nxt[f[i][j][k - 1]][ss[3][k] - 'a']);
}
} else {
ss[3][++z] = c[0];
for (int k = z; k <= z; k++)
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++) {
if (i + j + k) f[i][j][k] = n + 1;
if (i)
f[i][j][k] =
min(f[i][j][k], nxt[f[i - 1][j][k]][ss[1][i] - 'a']);
if (j)
f[i][j][k] =
min(f[i][j][k], nxt[f[i][j - 1][k]][ss[2][j] - 'a']);
if (k)
f[i][j][k] =
min(f[i][j][k], nxt[f[i][j][k - 1]][ss[3][k] - 'a']);
}
}
} else {
if (num == 1)
--x;
else if (num == 2)
--y;
else
--z;
}
printf("%s\n", f[x][y][z] > n ? "NO" : "YES");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxm = 256;
int main() {
int n, m;
cin >> n >> m;
string str;
cin >> str;
vector<vector<vector<int> > > dp(
maxm, vector<vector<int> >(maxm, vector<int>(maxm, 0)));
vector<vector<char> > word(3);
vector<vector<int> > tab(n + 3, vector<int>(26, n));
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
if (str[i] - 'a' == j) {
tab[i][j] = i;
} else {
tab[i][j] = tab[i + 1][j];
}
}
}
dp[0][0][0] = -1;
for (int i = 0; i < m; i++) {
char sym;
int a;
cin >> sym >> a;
a--;
if (sym == '+') {
char tmp;
cin >> tmp;
word[a].push_back(tmp);
for (int i = (a == 0 ? word[a].size() : 0); i <= word[0].size(); i++) {
for (int j = (a == 1 ? word[a].size() : 0); j <= word[1].size(); j++) {
for (int k = (a == 2 ? word[a].size() : 0); k <= word[2].size();
k++) {
dp[i][j][k] = n;
if (i > 0) {
dp[i][j][k] = min(dp[i][j][k],
tab[dp[i - 1][j][k] + 1][word[0][i - 1] - 'a']);
}
if (j > 0) {
dp[i][j][k] = min(dp[i][j][k],
tab[dp[i][j - 1][k] + 1][word[1][j - 1] - 'a']);
}
if (k > 0) {
dp[i][j][k] = min(dp[i][j][k],
tab[dp[i][j][k - 1] + 1][word[2][k - 1] - 'a']);
}
}
}
}
} else {
word[a].pop_back();
}
if (dp[word[0].size()][word[1].size()][word[2].size()] < n) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[131072];
vector<int> avail[256];
string r[4];
int dp[256][256][256];
int main() {
int n, q;
scanf("%d%d", &n, &q);
scanf("%s", str);
for (int i = 0; i < n; i++) {
avail[str[i]].push_back(i);
}
memset(dp, 0x3F, sizeof(dp));
dp[0][0][0] = -1;
while (q--) {
char cmd[2];
scanf("%s", cmd);
if (cmd[0] == '+') {
char chr[2];
int i;
scanf("%d%s", &i, chr);
char c = chr[0];
r[i].push_back(c);
int rsz = r[i].size();
vector<int>::iterator it;
if (i == 1) {
for (int j = 0; j <= r[2].size(); j++) {
for (int k = 0; k <= r[3].size(); k++) {
int c1 = 0;
char d1 = r[1][rsz - 1];
it = upper_bound(avail[d1].begin(), avail[d1].end(),
dp[rsz - 1][j][k]);
if (it == avail[d1].end())
c1 = 1e9;
else
c1 = *it;
int c2 = 1e9;
if (j != 0) {
char d2 = r[2][j - 1];
it = upper_bound(avail[d2].begin(), avail[d2].end(),
dp[rsz][j - 1][k]);
if (it == avail[d2].end())
c2 = 1e9;
else
c2 = *it;
}
int c3 = 1e9;
if (k != 0) {
char d3 = r[3][k - 1];
it = upper_bound(avail[d3].begin(), avail[d3].end(),
dp[rsz][j][k - 1]);
if (it == avail[d3].end())
c3 = 1e9;
else
c3 = *it;
}
dp[rsz][j][k] = min(c1, min(c2, c3));
}
}
} else if (i == 2) {
for (int j = 0; j <= r[1].size(); j++) {
for (int k = 0; k <= r[3].size(); k++) {
int c1 = 1e9;
if (j != 0) {
char d1 = r[1][j - 1];
it = upper_bound(avail[d1].begin(), avail[d1].end(),
dp[j - 1][rsz][k]);
if (it == avail[d1].end())
c1 = 1e9;
else
c1 = *it;
}
char d2 = r[2][rsz - 1];
int c2 = 1e9;
it = upper_bound(avail[d2].begin(), avail[d2].end(),
dp[j][rsz - 1][k]);
if (it == avail[d2].end())
c2 = 1e9;
else
c2 = *it;
int c3 = 1e9;
if (k != 0) {
char d3 = r[3][k - 1];
it = upper_bound(avail[d3].begin(), avail[d3].end(),
dp[j][rsz][k - 1]);
if (it == avail[d3].end())
c3 = 1e9;
else
c3 = *it;
}
dp[j][rsz][k] = min(c1, min(c2, c3));
}
}
} else if (i == 3) {
for (int j = 0; j <= r[1].size(); j++) {
for (int k = 0; k <= r[2].size(); k++) {
int c1 = 1e9;
if (j != 0) {
char d1 = r[1][j - 1];
it = upper_bound(avail[d1].begin(), avail[d1].end(),
dp[j - 1][k][rsz]);
if (it == avail[d1].end())
c1 = 1e9;
else
c1 = *it;
}
int c2 = 1e9;
if (k != 0) {
char d2 = r[2][k - 1];
it = upper_bound(avail[d2].begin(), avail[d2].end(),
dp[j][k - 1][rsz]);
if (it == avail[d2].end())
c2 = 1e9;
else
c2 = *it;
}
int c3 = 1e9;
char d3 = r[3][rsz - 1];
it = upper_bound(avail[d3].begin(), avail[d3].end(),
dp[j][k][rsz - 1]);
if (it == avail[d3].end())
c3 = 1e9;
else
c3 = *it;
dp[j][k][rsz] = min(c1, min(c2, c3));
}
}
}
} else {
int i;
scanf("%d", &i);
r[i].pop_back();
}
if (dp[r[1].size()][r[2].size()][r[3].size()] > n) {
printf("NO\n");
} else {
printf("YES\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int MAXINT = 2e9;
ll MAXLL = 9e18;
vector<vector<vector<int>>> cubedp(
300, vector<vector<int>>(300, vector<int>(300, 5 + (1e5))));
vector<vector<int>> occ(30, vector<int>(10 + (1e5), 5 + (1e5)));
int main() {
cubedp[0][0][0] = 0;
int n;
int q;
cin >> n >> q;
string word;
cin >> word;
for (int i = (0); i < (int)(n); ++i) {
char ch = word[i];
for (int u = i; occ[ch - 'a'][u] == 5 + (1e5); u--) {
occ[ch - 'a'][u] = i;
}
}
vector<string> rels = {"", "", ""};
for (int querry = (0); querry < (int)(q); ++querry) {
char qtype;
cin >> qtype;
int reli;
cin >> reli;
reli--;
if (qtype == '+') {
char addchar;
cin >> addchar;
rels[reli] += addchar;
int ast = (reli == 0 ? rels[0].size() : 0);
int bst = (reli == 1 ? rels[1].size() : 0);
int cst = (reli == 2 ? rels[2].size() : 0);
for (int a = (ast); a < (int)(rels[0].size() + 1); ++a) {
for (int b = (bst); b < (int)(rels[1].size() + 1); ++b) {
for (int c = (cst); c < (int)(rels[2].size() + 1); ++c) {
cubedp[a][b][c] = n + 5;
if (a)
cubedp[a][b][c] =
min(cubedp[a][b][c],
occ[rels[0][a - 1] - 'a'][cubedp[a - 1][b][c]]);
if (b)
cubedp[a][b][c] =
min(cubedp[a][b][c],
occ[rels[1][b - 1] - 'a'][cubedp[a][b - 1][c]]);
if (c)
cubedp[a][b][c] =
min(cubedp[a][b][c],
occ[rels[2][c - 1] - 'a'][cubedp[a][b][c - 1]]);
cubedp[a][b][c]++;
}
}
}
} else {
rels[reli].pop_back();
}
if (cubedp[rels[0].size()][rels[1].size()][rels[2].size()] <= n)
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 256;
const int AL = 26;
int dp[MX][MX][MX];
int nxt[AL][100001];
string s[3];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q;
string t;
cin >> n >> q >> t;
for (int i = n; i >= 0; --i) {
for (int j = 0; j < AL; ++j) {
if (i >= n) {
nxt[j][i] = n;
} else if (t[i] == j + 'a') {
nxt[j][i] = i;
} else {
nxt[j][i] = nxt[j][i + 1];
}
}
}
for (int i = 0; i < MX; ++i) {
for (int j = 0; j < MX; ++j) {
for (int k = 0; k < MX; ++k) {
dp[i][j][k] = n;
}
}
}
dp[0][0][0] = -1;
while (q--) {
int a;
char type;
cin >> type >> a;
--a;
if (type == '+') {
char c;
cin >> c;
s[a] += c;
for (int i = a == 0 ? s[0].size() - 1u : 0; i <= int(s[0].size()); ++i) {
for (int j = a == 1 ? s[1].size() - 1u : 0; j <= int(s[1].size());
++j) {
for (int k = a == 2 ? s[2].size() - 1u : 0; k <= int(s[2].size());
++k) {
if (dp[i][j][k] < n) {
if (i < int(s[0].size())) {
dp[i + 1][j][k] =
min(dp[i + 1][j][k], nxt[s[0][i] - 'a'][dp[i][j][k] + 1]);
}
if (j < int(s[1].size())) {
dp[i][j + 1][k] =
min(dp[i][j + 1][k], nxt[s[1][j] - 'a'][dp[i][j][k] + 1]);
}
if (k < int(s[2].size())) {
dp[i][j][k + 1] =
min(dp[i][j][k + 1], nxt[s[2][k] - 'a'][dp[i][j][k] + 1]);
}
}
}
}
}
} else {
for (int i = a == 0 ? s[0].size() : 0; i <= int(s[0].size()); ++i) {
for (int j = a == 1 ? s[1].size() : 0; j <= int(s[1].size()); ++j) {
for (int k = a == 2 ? s[2].size() : 0; k <= int(s[2].size()); ++k) {
dp[i][j][k] = n;
}
}
}
s[a].pop_back();
}
int res = dp[s[0].size()][s[1].size()][s[2].size()];
cout << (res < n ? "YES" : "NO") << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
const int MAX_LEN = 250;
int n, q;
cin >> n >> q;
string s;
cin >> s;
vector<vector<int> > nxt(n + 1, vector<int>(int('z' - 'a' + 1), n));
for (int i = n - 1; i >= 0; --i) {
nxt[i] = nxt[i + 1];
nxt[i][int(s[i] - 'a')] = i;
}
vector<vector<vector<int> > > end(
MAX_LEN + 1,
vector<vector<int> >(MAX_LEN + 1, vector<int>(MAX_LEN + 1, n + 1)));
end[0][0][0] = 0;
vector<string> rel(3, "");
for (; q > 0; --q) {
char op;
cin >> op;
if (op == '+') {
int r;
char c;
cin >> r >> c;
--r;
rel[r] += c;
for (int i = (r == 0 ? int(rel[0].size()) : 0); i <= int(rel[0].size());
++i) {
for (int j = (r == 1 ? int(rel[1].size()) : 0); j <= int(rel[1].size());
++j) {
for (int k = (r == 2 ? int(rel[2].size()) : 0);
k <= int(rel[2].size()); ++k) {
if (i > 0 && end[i - 1][j][k] < n) {
end[i][j][k] =
min(end[i][j][k],
nxt[end[i - 1][j][k]][int(rel[0][i - 1] - 'a')] + 1);
}
if (j > 0 && end[i][j - 1][k] < n) {
end[i][j][k] =
min(end[i][j][k],
nxt[end[i][j - 1][k]][int(rel[1][j - 1] - 'a')] + 1);
}
if (k > 0 && end[i][j][k - 1] < n) {
end[i][j][k] =
min(end[i][j][k],
nxt[end[i][j][k - 1]][int(rel[2][k - 1] - 'a')] + 1);
}
}
}
}
} else {
int r;
cin >> r;
--r;
for (int i = (r == 0 ? int(rel[0].size()) : 0); i <= int(rel[0].size());
++i) {
for (int j = (r == 1 ? int(rel[1].size()) : 0); j <= int(rel[1].size());
++j) {
for (int k = (r == 2 ? int(rel[2].size()) : 0);
k <= int(rel[2].size()); ++k) {
end[i][j][k] = n + 1;
}
}
}
rel[r].pop_back();
}
if (end[rel[0].size()][rel[1].size()][rel[2].size()] <= n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1123456;
const int maxm = 255;
int n, q, l0, l1, l2;
char s[maxn], op[5];
int nxt[maxn][26], dp[maxm][maxm][maxm];
vector<int> lis[3];
int main() {
scanf("%d%d", &n, &q);
scanf("%s", s);
fill(nxt[n], nxt[n] + 26, n);
fill(nxt[n + 1], nxt[n + 1] + 26, n);
for (int(i) = (n - 1); (i) >= (0); (i)--) {
int idx = s[i] - 'a';
for (int(j) = (0); (j) <= ((26) - 1); (j)++) {
nxt[i][j] = nxt[i + 1][j];
if (j == idx) nxt[i][j] = i;
}
}
dp[0][0][0] = -1;
while (q--) {
scanf("%s", op);
if (op[0] == '+') {
int idx;
char ch;
scanf("%d %c", &idx, &ch);
idx--;
ch -= 'a';
lis[idx].emplace_back(ch);
switch (idx) {
case 0: {
l0++;
for (int(j) = (0); (j) <= ((l1 + 1) - 1); (j)++)
for (int(k) = (0); (k) <= ((l2 + 1) - 1); (k)++) {
dp[l0][j][k] = nxt[dp[l0 - 1][j][k] + 1][ch];
if (j)
dp[l0][j][k] =
min(dp[l0][j][k], nxt[dp[l0][j - 1][k] + 1][lis[1][j - 1]]);
if (k)
dp[l0][j][k] =
min(dp[l0][j][k], nxt[dp[l0][j][k - 1] + 1][lis[2][k - 1]]);
}
break;
}
case 1: {
l1++;
for (int(i) = (0); (i) <= ((l0 + 1) - 1); (i)++)
for (int(k) = (0); (k) <= ((l2 + 1) - 1); (k)++) {
dp[i][l1][k] = nxt[dp[i][l1 - 1][k] + 1][ch];
if (i)
dp[i][l1][k] =
min(dp[i][l1][k], nxt[dp[i - 1][l1][k] + 1][lis[0][i - 1]]);
if (k)
dp[i][l1][k] =
min(dp[i][l1][k], nxt[dp[i][l1][k - 1] + 1][lis[2][k - 1]]);
}
break;
}
case 2: {
l2++;
for (int(i) = (0); (i) <= ((l0 + 1) - 1); (i)++)
for (int(j) = (0); (j) <= ((l1 + 1) - 1); (j)++) {
dp[i][j][l2] = nxt[dp[i][j][l2 - 1] + 1][ch];
if (i)
dp[i][j][l2] =
min(dp[i][j][l2], nxt[dp[i - 1][j][l2] + 1][lis[0][i - 1]]);
if (j)
dp[i][j][l2] =
min(dp[i][j][l2], nxt[dp[i][j - 1][l2] + 1][lis[1][j - 1]]);
}
break;
}
default:
assert(0);
}
} else {
int idx;
scanf("%d", &idx);
idx--;
if (!idx)
l0--;
else if (idx == 1)
l1--;
else
l2--;
lis[idx].pop_back();
}
puts(dp[l0][l1][l2] == n ? "NO" : "YES");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int P = 260;
int pw[3] = {1, P, P *P};
char s[100010];
int nxt[100010][26];
char t[3][260];
int len[3];
int dp[17576000];
char buf[10];
int getn(int a, int b, int c, int d, int e, int f) {
return pw[a] * b + pw[c] * d + pw[e] * f;
}
char getc() {
scanf("%s", buf);
return buf[0];
}
void chmin(int &a, int b) { a = a < b ? a : b; }
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] = nxt[n][i] = n + 1;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
if (s[i + 1] - 'a' == j)
nxt[i][j] = i + 1;
else
nxt[i][j] = nxt[i + 1][j];
}
}
dp[0] = 0;
while (q--) {
char op = getc();
int x;
scanf("%d", &x);
x--;
if (op == '+') {
char c = getc();
t[x][++len[x]] = c;
int p1 = (x + 1) % 3, p2 = (x + 2) % 3;
for (int i = 0; i <= len[p1]; i++) {
for (int j = 0; j <= len[p2]; j++) {
int now = getn(x, len[x], p1, i, p2, j);
dp[now] = INF;
if (i)
chmin(dp[now],
nxt[dp[getn(x, len[x], p1, i - 1, p2, j)]][t[p1][i] - 'a']);
if (j)
chmin(dp[now],
nxt[dp[getn(x, len[x], p1, i, p2, j - 1)]][t[p2][j] - 'a']);
chmin(dp[now],
nxt[dp[getn(x, len[x] - 1, p1, i, p2, j)]][t[x][len[x]] - 'a']);
}
}
} else
len[x]--;
printf(dp[getn(0, len[0], 1, len[1], 2, len[2])] <= n ? "YES\n" : "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
char s[100010];
int f2[100010][30], f[260][260][260], len[10];
char str[10][300];
int main() {
int n = inp();
int q = inp();
scanf("%s", s + 1);
for (int i = 0; i < 26; i++) {
f2[n + 1][i] = 2147483647;
for (int j = n; j >= 0; j--) {
f2[j][i] = f2[j + 1][i];
if (s[j] == 'a' + i) f2[j][i] = j + 1;
}
}
while (q--) {
char op = getchar();
while (op != '+' && op != '-') op = getchar();
if (op == '+') {
int x = inp();
char ch = getchar();
while (ch < 'a' || ch > 'z') ch = getchar();
str[x][++len[x]] = ch;
if (x == 1) {
int i = len[1] - 1;
for (int j = 0; j <= len[2]; j++)
for (int u = 0; u <= len[3]; u++) f[i + 1][j][u] = 2147483647;
for (i = len[1] - 1; i <= len[1]; i++)
for (int j = 0; j <= len[2]; j++)
for (int u = 0; u <= len[3]; u++) {
int ff = f[i][j][u];
if (ff == 2147483647) continue;
if (i != len[1])
f[i + 1][j][u] =
std::min(f[i + 1][j][u], f2[ff][str[1][i + 1] - 'a']);
if (j != len[2])
f[i][j + 1][u] =
std::min(f[i][j + 1][u], f2[ff][str[2][j + 1] - 'a']);
if (u != len[3])
f[i][j][u + 1] =
std::min(f[i][j][u + 1], f2[ff][str[3][u + 1] - 'a']);
}
} else if (x == 2) {
int j = len[2] - 1;
for (int i = 0; i <= len[1]; i++)
for (int u = 0; u <= len[3]; u++) f[i][j + 1][u] = 2147483647;
for (int i = 0; i <= len[1]; i++)
for (j = len[2] - 1; j <= len[2]; j++)
for (int u = 0; u <= len[3]; u++) {
int ff = f[i][j][u];
if (ff == 2147483647) continue;
if (i != len[1])
f[i + 1][j][u] =
std::min(f[i + 1][j][u], f2[ff][str[1][i + 1] - 'a']);
if (j != len[2])
f[i][j + 1][u] =
std::min(f[i][j + 1][u], f2[ff][str[2][j + 1] - 'a']);
if (u != len[3])
f[i][j][u + 1] =
std::min(f[i][j][u + 1], f2[ff][str[3][u + 1] - 'a']);
}
} else {
int u = len[3] - 1;
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[2]; j++) f[i][j][u + 1] = 2147483647;
for (int i = 0; i <= len[1]; i++)
for (int j = 0; j <= len[2]; j++)
for (u = len[3] - 1; u <= len[3]; u++) {
int ff = f[i][j][u];
if (ff == 2147483647) continue;
if (i != len[1])
f[i + 1][j][u] =
std::min(f[i + 1][j][u], f2[ff][str[1][i + 1] - 'a']);
if (j != len[2])
f[i][j + 1][u] =
std::min(f[i][j + 1][u], f2[ff][str[2][j + 1] - 'a']);
if (u != len[3])
f[i][j][u + 1] =
std::min(f[i][j][u + 1], f2[ff][str[3][u + 1] - 'a']);
}
}
} else {
int x = inp();
len[x]--;
}
if (f[len[1]][len[2]][len[3]] != 2147483647)
printf("YES\n");
else
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int nxt[100005][26];
string str, s[3];
int dp[255][255][255];
int main(int argc, const char *argv[]) {
ios_base ::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cout << fixed << setprecision(12);
cin >> n >> m >> str;
fill(nxt[n], nxt[n + 1], n + 1);
for (int i = n - 1; ~i; --i)
for (int j = 0; j < 26; ++j)
if (str[i] - 'a' != j)
nxt[i][j] = nxt[i + 1][j];
else
nxt[i][j] = i + 1;
for (int i = 0; i < 3; ++i) s[i].push_back('_');
dp[0][0][0] = 0;
while (m--) {
char op;
int r;
cin >> op >> r, --r;
if (op == '+') {
char ch;
cin >> ch;
s[r].push_back(ch);
int r1 = (r + 1) % 3, r2 = (r1 + 1) % 3, c = (int)s[r].size() - 1;
for (int a = 0; a < (int)s[r1].size(); ++a)
for (int b = 0; b < (int)s[r2].size(); ++b) {
int i = ((r1 == 0) ? a : ((r2 == 0 ? b : c)));
int j = ((r1 == 1) ? a : ((r2 == 1 ? b : c)));
int k = ((r1 == 2) ? a : ((r2 == 2 ? b : c)));
dp[i][j][k] = 0x3f3f3f3f;
if (i)
dp[i][j][k] =
min(dp[i][j][k],
max(dp[i - 1][j][k], nxt[dp[i - 1][j][k]][s[0][i] - 'a']));
if (j)
dp[i][j][k] =
min(dp[i][j][k],
max(dp[i][j - 1][k], nxt[dp[i][j - 1][k]][s[1][j] - 'a']));
if (k)
dp[i][j][k] =
min(dp[i][j][k],
max(dp[i][j][k - 1], nxt[dp[i][j][k - 1]][s[2][k] - 'a']));
}
} else if (op == '-')
s[r].pop_back();
else
throw "Bad Input!!";
puts(dp[(int)s[0].size() - 1][(int)s[1].size() - 1][(int)s[2].size() - 1] <=
n
? "YES"
: "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T CHMAX(T& x, const T y) {
return x = (x < y) ? y : x;
}
template <class T>
inline T CHMIN(T& x, const T y) {
return x = (x > y) ? y : x;
}
using PII = pair<int, int>;
using PLL = pair<long long, long long>;
using LL = long long;
using ULL = unsigned long long;
template <class T>
using V = vector<T>;
template <class T>
using V2 = vector<vector<T>>;
template <class T, int W = 255>
using A = array<T, W>;
template <class T, int W = 255, int H = 255>
using A2 = array<array<T, W>, W>;
const int INF = 1 << 20;
int n, q;
std::string religion_word;
V<V<int>> next_oc;
V<std::string> words;
int dp[252][252][252];
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
;
cin >> n;
cin >> q;
cin >> religion_word;
next_oc.resize(n + 2);
words.resize(3);
for (int i = 0; i < static_cast<int>(26); i++) {
next_oc[n].push_back(n);
next_oc[n + 1].push_back(n);
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
char c = religion_word[i];
if (j == c - 'a')
next_oc[i].push_back(i);
else
next_oc[i].push_back(next_oc[i + 1][j]);
}
}
dp[0][0][0] = -1;
for (int l = 0; l < static_cast<int>(q); l++) {
char action;
cin >> action;
int group;
cin >> group;
group--;
if (action == '+') {
char c;
cin >> c;
words[group] += c;
int start0 = (group == 0) ? words[0].size() : 0;
int start1 = (group == 1) ? words[1].size() : 0;
int start2 = (group == 2) ? words[2].size() : 0;
for (int i = start0; i <= words[0].size(); i++) {
for (int j = start1; j <= words[1].size(); j++) {
for (int k = start2; k <= words[2].size(); k++) {
int& x = dp[i][j][k];
x = n;
if (i >= 1)
x = std::min(next_oc[dp[i - 1][j][k] + 1][words[0][i - 1] - 'a'],
x);
if (j >= 1)
x = std::min(next_oc[dp[i][j - 1][k] + 1][words[1][j - 1] - 'a'],
x);
if (k >= 1)
x = std::min(next_oc[dp[i][j][k - 1] + 1][words[2][k - 1] - 'a'],
x);
}
}
}
} else {
words[group].pop_back();
}
if (dp[words[0].size()][words[1].size()][words[2].size()] == n)
cout << "NO"
<< "\n";
else
cout << "YES"
<< "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2, M = 251;
const long long MOD = 998244853;
const long long INF = 1e9;
int f[M][M][M], last[N][26], len[3], n, q, id;
string s[3], WoU;
char add, c;
void preprocess() {
for (int j = 0; j < 26; j++) last[n + 1][j] = n + 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j < 26; j++) last[i][j] = last[i + 1][j];
last[i][WoU[i] - 'a'] = i;
}
for (int i = 0; i < M; i++) {
for (int j = 0; j < M; j++) {
for (int k = 0; k < M; k++) f[i][j][k] = n + 1;
}
}
f[0][0][0] = 0;
}
void update(int id) {
for (int i = (id == 0) ? len[0] : 0; i <= len[0]; i++) {
for (int j = (id == 1) ? len[1] : 0; j <= len[1]; j++) {
for (int k = (id == 2) ? len[2] : 0; k <= len[2]; k++) {
int op0 = (i > 0 && f[i - 1][j][k] < n)
? last[f[i - 1][j][k] + 1][s[0][i - 1] - 'a']
: n + 1,
op1 = (j > 0 && f[i][j - 1][k] < n)
? last[f[i][j - 1][k] + 1][s[1][j - 1] - 'a']
: n + 1,
op2 = (k > 0 && f[i][j][k - 1] < n)
? last[f[i][j][k - 1] + 1][s[2][k - 1] - 'a']
: n + 1;
f[i][j][k] = min({f[i][j][k], op0, op1, op2});
}
}
}
}
void process() {
cin >> add >> id;
if (add == '+') cin >> c;
id--;
if (add == '+')
s[id] += c, len[id]++;
else {
s[id].pop_back();
for (int i = (id == 0) ? len[0] : 0; i <= len[0]; i++)
for (int j = (id == 1) ? len[1] : 0; j <= len[1]; j++)
for (int k = (id == 2) ? len[2] : 0; k <= len[2]; k++)
f[i][j][k] = n + 1;
len[id]--;
}
update(id);
if (f[len[0]][len[1]][len[2]] <= n)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cin >> n >> q >> WoU;
n = WoU.size();
WoU = ' ' + WoU;
preprocess();
while (q--) process();
}
|
#include <bits/stdc++.h>
using namespace std;
void chmin(int& a, int b) { a = min(a, b); }
int main() {
int N, Q;
cin >> N >> Q;
string S;
cin >> S;
S = " " + S;
static int nxt[100002][26];
int INF = N + 1;
vector<int> now(26, INF);
for (int i = INF; i >= 0; i--) {
for (int k = 0; k < 26; k++) nxt[i][k] = now[k];
if (0 < i && i <= N) now[S[i] - 'a'] = i;
}
const int M = 250;
static int dp[M + 1][M + 1][M + 1];
for (int i = 0; i <= M; i++)
for (int j = 0; j <= M; j++)
for (int k = 0; k <= M; k++) dp[i][j][k] = INF;
dp[0][0][0] = 0;
int len[3] = {0};
string need[3];
while (Q--) {
char sign;
cin >> sign;
if (sign == '+') {
int p;
char c;
cin >> p >> c;
p--;
need[p].push_back(c);
len[p]++;
int lb[3] = {0}, ub[3];
for (int i = 0; i < 3; i++) {
ub[i] = len[i];
if (i == p) lb[i] = len[i];
}
for (int i = lb[0]; i <= ub[0]; i++)
for (int j = lb[1]; j <= ub[1]; j++)
for (int k = lb[2]; k <= ub[2]; k++) {
dp[i][j][k] = INF;
if (i > 0)
chmin(dp[i][j][k], nxt[dp[i - 1][j][k]][need[0][i - 1] - 'a']);
if (j > 0)
chmin(dp[i][j][k], nxt[dp[i][j - 1][k]][need[1][j - 1] - 'a']);
if (k > 0)
chmin(dp[i][j][k], nxt[dp[i][j][k - 1]][need[2][k - 1] - 'a']);
}
} else {
int p;
cin >> p;
p--;
need[p].pop_back();
len[p]--;
}
bool res = (dp[len[0]][len[1]][len[2]] < INF);
cout << (res ? "YES" : "NO") << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[252][252][252];
vector<int> let[26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
string ws;
cin >> ws;
for (int i = 0; i < n; i++) {
let[ws[i] - 'a'].push_back(i + 1);
}
dp[0][0][0] = 0;
string s1, s2, s3;
while (q--) {
char cc;
cin >> cc;
int i;
char ad;
if (cc == '+') {
cin >> i >> ad;
ad -= 'a';
if (i == 1) {
for (int j1 = 0; j1 <= s2.size(); j1++) {
for (int k1 = 0; k1 <= s3.size(); k1++) {
int l = dp[s1.size()][j1][k1];
int m = -1;
if (l != -1) {
auto m1It = upper_bound(let[ad].begin(), let[ad].end(), l);
m = (m1It != let[ad].end() ? *m1It : -1);
}
if (j1 > 0) {
int c = s2[j1 - 1] - 'a';
l = dp[s1.size() + 1][j1 - 1][k1];
if (l != -1) {
auto m1It = upper_bound(let[c].begin(), let[c].end(), l);
int m1 = (m1It != let[c].end() ? *m1It : -1);
if (m1 != -1 && (m == -1 || m > m1)) m = m1;
}
}
if (k1 > 0) {
int c = s3[k1 - 1] - 'a';
l = dp[s1.size() + 1][j1][k1 - 1];
if (l != -1) {
auto m1It = upper_bound(let[c].begin(), let[c].end(), l);
int m1 = (m1It != let[c].end() ? *m1It : -1);
if (m1 != -1 && (m == -1 || m > m1)) m = m1;
}
}
dp[s1.size() + 1][j1][k1] = m;
}
}
s1 += (ad + 'a');
} else if (i == 2) {
for (int j1 = 0; j1 <= s1.size(); j1++) {
for (int k1 = 0; k1 <= s3.size(); k1++) {
int l = dp[j1][s2.size()][k1];
int m = -1;
if (l != -1) {
auto m1It = upper_bound(let[ad].begin(), let[ad].end(), l);
m = (m1It != let[ad].end() ? *m1It : -1);
}
if (j1 > 0) {
int c = s1[j1 - 1] - 'a';
l = dp[j1 - 1][s2.size() + 1][k1];
if (l != -1) {
auto m1It = upper_bound(let[c].begin(), let[c].end(), l);
int m1 = (m1It != let[c].end() ? *m1It : -1);
if (m1 != -1 && (m == -1 || m > m1)) m = m1;
}
}
if (k1 > 0) {
int c = s3[k1 - 1] - 'a';
l = dp[j1][s2.size() + 1][k1 - 1];
if (l != -1) {
auto m1It = upper_bound(let[c].begin(), let[c].end(), l);
int m1 = (m1It != let[c].end() ? *m1It : -1);
if (m1 != -1 && (m == -1 || m > m1)) m = m1;
}
}
dp[j1][s2.size() + 1][k1] = m;
}
}
s2 += (ad + 'a');
} else {
for (int j1 = 0; j1 <= s1.size(); j1++) {
for (int k1 = 0; k1 <= s2.size(); k1++) {
int l = dp[j1][k1][s3.size()];
int m = -1;
if (l != -1) {
auto m1It = upper_bound(let[ad].begin(), let[ad].end(), l);
m = (m1It != let[ad].end() ? *m1It : -1);
}
if (j1 > 0) {
int c = s1[j1 - 1] - 'a';
l = dp[j1 - 1][k1][s3.size() + 1];
if (l != -1) {
auto m1It = upper_bound(let[c].begin(), let[c].end(), l);
int m1 = (m1It != let[c].end() ? *m1It : -1);
if (m1 != -1 && (m == -1 || m > m1)) m = m1;
}
}
if (k1 > 0) {
int c = s2[k1 - 1] - 'a';
l = dp[j1][k1 - 1][s3.size() + 1];
if (l != -1) {
auto m1It = upper_bound(let[c].begin(), let[c].end(), l);
int m1 = (m1It != let[c].end() ? *m1It : -1);
if (m1 != -1 && (m == -1 || m > m1)) m = m1;
}
}
dp[j1][k1][s3.size() + 1] = m;
}
}
s3 += (ad + 'a');
}
} else {
cin >> i;
if (i == 1) {
s1.pop_back();
} else if (i == 2) {
s2.pop_back();
} else {
s3.pop_back();
}
}
cout << (dp[s1.size()][s2.size()][s3.size()] != -1 ? "YES\n" : "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int block_size = 320;
const long long mod = 1e9 + 7;
const long long inf = 1e9 + 7;
const long double eps = 1e-9;
const double PI = atan(1) * 4;
template <typename T>
inline int sign(const T &a) {
if (a < 0) return -1;
if (a > 0) return 1;
return 0;
}
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
template <typename T, typename S>
inline bool upmin(T &a, const S &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S>
inline bool upmax(T &a, const S &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline void in(T &x) {
x = 0;
T f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
long long twop(int x) { return 1LL << x; }
template <typename A, typename B>
inline void in(A &x, B &y) {
in(x);
in(y);
}
template <typename A, typename B, typename C>
inline void in(A &x, B &y, C &z) {
in(x);
in(y);
in(z);
}
template <typename A, typename B, typename C, typename D>
inline void in(A &x, B &y, C &z, D &d) {
in(x);
in(y);
in(z);
in(d);
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
namespace SOLVE {
int n, q;
string s;
int nxt[100010][26];
int dp[255][255][255];
vector<int> word[3];
void solve(int i, int j, int k) {
dp[i][j][k] = inf;
if (i and dp[i - 1][j][k] <= n)
upmin(dp[i][j][k], nxt[dp[i - 1][j][k]][word[0][i]]);
if (j and dp[i][j - 1][k] <= n)
upmin(dp[i][j][k], nxt[dp[i][j - 1][k]][word[1][j]]);
if (k and dp[i][j][k - 1] <= n)
upmin(dp[i][j][k], nxt[dp[i][j][k - 1]][word[2][k]]);
}
void main() {
cin >> n >> q >> s;
for (long long i = 0; i < n; i++) s[i] -= 'a';
s = " " + s;
for (long long i = 0; i < 26; i++) nxt[n][i] = inf;
for (long long i = n - 1; i >= 0; i--) {
for (long long j = 0; j < 26; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i + 1]] = i + 1;
}
for (long long i = 0; i < 3; i++) word[i].push_back(0);
dp[0][0][0] = 0;
while (q--) {
string op;
cin >> op;
int id;
cin >> id;
id--;
if (op == "+") {
string sss;
cin >> sss;
int ch = sss[0] - 'a';
word[id].push_back(ch);
if (id == 0) {
for (long long b = 0; b < ((int)word[1].size()); b++) {
for (long long c = 0; c < ((int)word[2].size()); c++) {
solve(((int)word[0].size()) - 1, b, c);
}
}
}
if (id == 1) {
for (long long b = 0; b < ((int)word[0].size()); b++) {
for (long long c = 0; c < ((int)word[2].size()); c++) {
solve(b, ((int)word[1].size()) - 1, c);
}
}
}
if (id == 2) {
for (long long b = 0; b < ((int)word[0].size()); b++) {
for (long long c = 0; c < ((int)word[1].size()); c++) {
solve(b, c, ((int)word[2].size()) - 1);
}
}
}
} else {
word[id].pop_back();
}
cout << ((dp[((int)word[0].size()) - 1][((int)word[1].size()) - 1]
[((int)word[2].size()) - 1] <= n)
? "YES"
: "NO")
<< endl;
}
}
} // namespace SOLVE
signed main() {
int t;
t = 1;
while (t--) {
SOLVE::main();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n;
cin >> n >> s;
int cnt0 = 0, cnt1 = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
cnt0++;
} else
cnt1++;
}
if (cnt0 != cnt1) {
cout << "1" << endl;
cout << s << endl;
} else {
cout << "2" << endl;
cout << s[0] << " " << s.substr(1, n);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, nr, i;
char s[104];
int main() {
scanf("%d", &n);
scanf("%s", &s);
n--;
nr = 0;
for (i = 0; i <= n; i++) {
if (s[i] == '0')
nr++;
else
nr--;
}
if (nr != 0)
printf("%d\n%s\n", 1, s);
else {
printf("2\n%c ", s[0]);
for (i = 1; i <= n; i++) printf("%c", s[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v0;
vector<int> v1;
int cntZero = 0, cntOne = 0;
int n = 0;
string s;
int main() {
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '0')
cntZero++;
else
cntOne++;
}
if (cntOne == cntZero) {
cout << 2 << endl;
cout << s[0] << ' ';
cout << s.substr(1) << endl;
} else {
cout << 1 << endl;
cout << s << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
string s;
cin >> s;
int one = 0;
int zero = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1')
one++;
else
zero++;
}
if (one != zero) {
cout << 1 << endl;
cout << s << endl;
} else if (one == zero) {
cout << 2 << endl;
cout << s[0] << " ";
for (int i = 1; i < n; i++) {
cout << s[i];
}
cout << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
string s;
cin >> s;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0')
cnt++;
else
cnt--;
}
if (cnt != 0) {
cout << 1 << endl << s << endl;
} else {
cout << 2 << endl << s[0] << " " << s.substr(1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void Solve() {
int n, one = 0, zero = 0;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++)
if (s[i] == '1')
one++;
else
zero++;
if (one == zero)
cout << 2 << endl << s.substr(0, n - 1) << ' ' << s[n - 1];
else
cout << 1 << endl << s;
}
int main() { Solve(); }
|
#include <bits/stdc++.h>
using namespace std;
long long int ara[1000006];
int main() {
long long int t, zero = 0, one = 0;
scanf("%lld", &t);
string str;
cin >> str;
for (long long int i = 0; i < t; i++) {
if (str[i] == '0')
zero++;
else
one++;
}
if (zero == one) {
cout << "2" << endl;
for (long long int i = 0; i < t - 1; i++) cout << str[i];
cout << " " << str[t - 1] << endl;
} else {
cout << "1" << endl;
for (long long int i = 0; i < t; i++) cout << str[i];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)(1e6 + 5);
const int LOG = (int)(20);
int n, zeros, ones;
char s[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> s + 1;
for (int i = 1; i <= n; i++) {
if (s[i] == '1')
ones++;
else
zeros++;
}
if (ones != zeros) {
cout << 1 << "\n";
cout << s + 1;
} else {
cout << 2 << "\n";
cout << s[1] << " " << s + 2;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int len, cnt = 0, cnt2 = 0, cnt3 = 0, cnt4 = 0, i, p;
char s[100000], s2[10000], s3[10000];
cin >> len >> s;
if (len == 1)
cout << "1\n" << s;
else {
for (i = 0; i < len / 2; i++) {
s2[i] = s[i];
if (s2[i] == '1')
cnt++;
else
cnt2++;
}
s2[i] = '\0';
for (i = len / 2, p = 0; i < len; i++, p++) {
s3[p] = s[i];
if (s3[p] == '1')
cnt3++;
else
cnt4++;
}
s3[p] = '\0';
if ((cnt == cnt3) && (cnt2 == cnt4) && (cnt + cnt3) == (cnt4 + cnt2)) {
for (int i = 0; i < len - 1; i++) {
s2[i] = s[i];
}
s2[i + 1] = '\0';
s3[0] = s[len - 1];
s3[1] = '\0';
cout << "2\n" << s2 << " " << s3;
} else if ((cnt + cnt3) == (cnt4 + cnt2)) {
cout << "2\n" << s2 << " " << s3;
} else {
cout << "1\n" << s;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[2] = {0, 0};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int len;
string str;
cin >> len >> str;
for (int i = 0; i < len; i++) arr[str[i] - '0']++;
if (arr[0] != arr[1]) {
cout << "1\n" << str << '\n';
} else {
char ch = str.back();
str.pop_back();
cout << "2\n" << str << ' ' << ch << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ar[] = {0, 0, 1, -1};
int ac[] = {1, -1, 0, 0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(7);
int n;
cin >> n;
string s;
cin >> s;
int cnt0, cnt1;
cnt0 = cnt1 = 0;
for (int i = 0; i < n; i++)
if (s[i] == '0')
cnt0++;
else
cnt1++;
if (cnt0 == cnt1) {
cout << 2 << '\n' << s.substr(0, n - 1) << ' ' << s.back();
} else
cout << 1 << ' ' << s << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0;
string s;
cin >> n;
cin >> s;
if (n % 2) {
cout << 1 << endl << s;
} else {
for (int i = 0; i < n; ++i) sum += s[i] - '0';
if (sum == n / 2) {
cout << 2 << endl;
for (int i = 0; i < n - 1; ++i) cout << s[i];
cout << ' ' << s[n - 1];
} else
cout << 1 << endl << s;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int i, count1 = 0, count0 = 0, n, j;
string s1;
cin >> n;
cin >> s1;
for (i = 0; s1[i]; i++) {
if (s1[i] == '0')
count0++;
else
count1++;
}
if (abs(count1 - count0)) return cout << 1 << "\n" << s1, 0;
if (s1.size() == 2)
return cout << 2 << "\n" << s1[0] << " " << s1[1], 0;
else {
cout << 2 << "\n";
if (n / 2 & 1) {
for (i = 0; i <= s1.size() / 2 - 1; i++) cout << s1[i];
cout << " ";
for (i = s1.size() / 2; i < s1.size(); i++) cout << s1[i];
} else {
for (i = 0; i < s1.size() / 2 - 1; i++) cout << s1[i];
cout << " ";
for (i = s1.size() / 2 - 1; i < s1.size(); i++) cout << s1[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, a = 0, b = 0;
cin >> n;
string s;
cin >> s;
for (i = 0; i < n; i++) {
if (s[i] == '0')
a++;
else
b++;
}
if (a == b) {
cout << 2 << endl;
for (i = 0; i < n - 1; i++) cout << s[i];
cout << " " << s[n - 1];
} else
cout << 1 << endl << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char* arr;
int* sarr;
cin >> n;
arr = new char[n];
sarr = new int[n];
int n1 = 0;
for (int i = 0; i < n; i++) {
char x;
cin >> x;
arr[i] = x;
if (x == '1') {
n1++;
}
}
if (n1 != n - n1) {
cout << "1" << endl;
for (int i = 0; i < n; i++) {
cout << arr[i];
}
return 0;
}
cout << "2" << endl;
for (int i = 0; i < n - 1; i++) {
cout << arr[i];
}
cout << " " << arr[n - 1];
return 0;
}
|
#include <bits/stdc++.h>
int main() {
char s[101];
int n, k = 0;
scanf("%d %s", &n, s);
for (int i = 0; i < n; ++i) k += s[i] == '1';
if (2 * k == n) {
printf("2\n");
char c = s[n - 1];
s[n - 1] = 0;
printf("%s %c\n", s, c);
} else
printf("1\n%s\n", s);
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
long long i, j, n;
int main() {
cin >> n;
string s;
cin >> s;
long long o = 0, e = 0;
for (i = 0; i < n; i++) {
if (s[i] == '1')
o++;
else
e++;
}
if (o != e) {
cout << 1 << endl;
cout << s << endl;
} else {
cout << 2 << endl;
for (i = 0; i < n; i++) {
long long pivot = i;
long long one = 0, zero = 0;
for (j = 0; j <= i; j++) {
if (s[j] == '1')
one++;
else
zero++;
}
long long so = o - one;
long long se = e - zero;
if (one != zero && so != se) {
for (j = 0; j <= i; j++) cout << s[j];
cout << " ";
for (j = i + 1; j < n; j++) cout << s[j];
return 0;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
string str;
cin >> n >> str;
long long c1 = 0;
long long c2 = 0;
for (long long i = 0; i < n; i++) {
if (str[i] == '0')
c1++;
else
c2++;
}
if (c1 == c2) {
cout << 2 << "\n";
cout << str[0] << " ";
for (long long i = 1; i < n; i++) cout << str[i];
} else {
cout << 1 << "\n" << str << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, i, count1 = 0, count0 = 0;
cin >> n;
string s;
cin >> s;
for (i = 0; i < n; i++) {
if (s[i] == '0')
count0++;
else
count1++;
}
if (count0 != count1) {
cout << "1" << endl << s << endl;
} else {
cout << "2" << endl;
cout << s[0] << " ";
for (i = 1; i < n; i++) cout << s[i];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
string g;
cin >> n >> g;
long long l = g.length();
long long i, z = 0, o = 0;
for (i = 0; i < l; i++) {
if (g[i] == '0') o++;
}
z = l - o;
if (z != o)
cout << 1 << endl << g << endl;
else {
cout << 2 << endl << g[0] << " ";
for (i = 1; i < l; i++) {
cout << g[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string str;
cin >> str;
int one = 0, zero = 0;
for (int i = 0; i < n; ++i) {
if (str[i] == '0')
zero++;
else
one++;
}
if (n == 1 || one != zero) {
cout << "1\n";
cout << str;
} else {
cout << "2\n";
cout << str[0] << " ";
for (int i = 1; i < n; ++i) cout << str[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(12);
int l;
cin >> l;
string s;
cin >> s;
size_t t = 0;
for (auto c : s) t += (c == '1');
if (t * 2 == s.length()) {
cout << 2 << endl;
cout << s[0] << " " << s.substr(1) << endl;
} else {
cout << 1 << endl;
cout << s << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, c1 = 0, c2 = 0, c;
string s;
cin >> n;
cin >> s;
for (i = 0; i < s.size(); i++) {
if (s[i] == '1') {
c1++;
} else if (s[i] == '0') {
c2++;
}
}
if (c1 != c2) {
c = 1;
cout << c << endl;
cout << s << endl;
} else if (c1 == c2) {
c = 2;
cout << c << endl;
cout << s[0] << " ";
for (i = 1; i < s.size(); i++) {
cout << s[i];
}
}
}
|
#include <bits/stdc++.h>
char s[105];
char ans1[105];
char ans2[105];
int num_0_total = 0;
int num_1_total = 0;
int main() {
memset(s, '\0', sizeof(s));
memset(ans1, '\0', sizeof(s));
memset(ans2, '\0', sizeof(s));
int n;
std::cin >> n;
std::cin >> s;
int lens = strlen(s);
for (int i = 0; i < lens; i++) {
if (s[i] == '0')
num_0_total += 1;
else
num_1_total += 1;
}
if (num_0_total != num_1_total) {
printf("%d\n", 1);
printf("%s\n", s);
return 0;
}
int num_0_left = 0;
int num_1_left = 0;
for (int i = 0; i < lens; i++) {
if (s[i] == '0')
num_0_left += 1;
else
num_1_left += 1;
int num_0_right = num_0_total - num_0_left;
int num_1_right = num_1_total - num_1_left;
if (num_0_left != num_1_left && num_0_right != num_1_right) {
printf("%d\n", 2);
strncpy(ans1, s + 0, i + 1);
strncpy(ans2, s + i + 1, lens - i - 1);
printf("%s %s\n", ans1, ans2);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int nCr(long long int n, long long int k) {
long long int C[k + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long int i = 1; i <= n; i++) {
for (long long int j = min(i, k); j > 0; j--) C[j] = C[j] + C[j - 1];
}
return C[k];
}
struct node {
int x;
int r;
int iq;
};
bool sorte(struct node a, struct node b) { return a.x < b.x; }
vector<long long int> mark(long long int p, vector<long long int> a,
long long int n) {
for (long long int i = 2; i * p < n; i++) {
a[i * p] = 1;
}
return a;
}
vector<long long int> sieve(vector<long long int> a, long long int n) {
a[0] = 1;
a[1] = 1;
for (long long int i = 2; i < sqrt(n); i++) {
if (a[i] == 0) {
a = mark(i, a, n);
}
}
return a;
}
vector<pair<long long int, long long int> > mergeIntervals(
vector<pair<long long int, long long int> > a) {
vector<pair<long long int, long long int> > ans;
sort(a.begin(), a.end());
stack<pair<long long int, long long int> > s;
s.push(a[0]);
for (long long int i = 1; i < a.size(); i++) {
if (a[i].first > s.top().second) {
s.push(a[i]);
} else if (a[i].second > s.top().second) {
pair<long long int, long long int> t = s.top();
t.second = a[i].second;
s.pop();
s.push(t);
}
}
stack<pair<long long int, long long int> > st;
while (!s.empty()) {
st.push(s.top());
s.pop();
}
while (!st.empty()) {
ans.push_back(st.top());
st.pop();
}
return ans;
}
int main() {
long long int n;
cin >> n;
string s;
cin >> s;
long long int z = 0;
long long int o = 0;
for (long long int i = 0; i < n; i++) {
if (s[i] == '0') {
z++;
} else {
o++;
}
}
if (z != o) {
cout << 1 << endl;
cout << s;
} else {
cout << 2 << endl;
cout << s[0] << " ";
for (long long int i = 1; i < n; i++) {
cout << s[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
char str[n + 2];
cin >> str;
int zero = 0;
for (int i = 0; i < n; ++i) {
if (str[i] == '0') zero += 1;
}
if (zero != (n - zero)) {
cout << 1 << "\n" << str;
} else {
char c = str[n - 1];
str[n - 1] = 0;
cout << 2 << "\n" << str << " " << c << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n, _o = 0, _n = 0;
cin >> n;
string s = "";
char x;
for (int64_t i = 0; i < n; i++) {
cin >> x;
s += x;
if (x == '0')
_n++;
else
_o++;
}
if (_n != _o) {
cout << 1 << '\n' << s;
return 0;
} else {
cout << 2 << '\n' << s.substr(0, s.size() - 1) << ' ' << s[s.size() - 1];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, c0 = 0, c1 = 0;
cin >> n;
string s;
cin >> s;
for (i = 0; i < n; i++) {
if (s[i] == '0')
c0++;
else
c1++;
}
if (c0 != c1)
cout << 1 << "\n" << s;
else {
cout << 2 << "\n";
cout << s[0] << " ";
for (i = 1; i < n; i++) cout << s[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int cz = 0, co = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0')
cz++;
else
co++;
}
if (n == 1) {
cout << '1' << endl;
cout << s << endl;
}
if (n > 1) {
if (cz == co) {
cout << 2 << endl;
cout << s[0] << " ";
for (int i = 1; i < n; i++) cout << s[i];
cout << endl;
} else {
cout << '1' << endl;
cout << s << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
int x = count(s.begin(), s.end(), '0');
int y = count(s.begin(), s.end(), '1');
if (x == y) {
cout << 2 << endl;
cout << s[0] << " ";
for (int i = 1; i < n; i++) cout << s[i];
cout << endl;
} else
cout << 1 << endl << s << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
string s;
cin >> s;
ll z = 0, o = 0;
for (ll i = 0; i < s.size(); ++i) {
if (s[i] == '0')
++z;
else
++o;
}
if (z != o) {
cout << 1 << "\n";
cout << s << "\n";
} else {
cout << 2 << "\n";
cout << s[0] << " ";
for (ll i = 1; i < s.size(); ++i) cout << s[i];
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long n;
string second;
long long cnt1 = 0, cnt2 = 0;
vector<long long> v;
int32_t main() {
ios_base::sync_with_stdio();
cin.tie();
cout.tie();
;
cin >> n;
cin >> second;
for (long long i = 0; i < n; i++)
if (second[i] == '0') {
cnt1++;
} else
cnt2++;
if (cnt1 != cnt2) {
cout << 1 << endl;
cout << second;
} else {
cout << 2 << endl;
for (long long i = 0; i < n - 1; i++) cout << second[i];
cout << ' ';
cout << second[n - 1];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int count0 = 0, count1 = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0') {
count0++;
} else {
count1++;
}
}
if (count0 != count1) {
cout << 1 << endl;
cout << s;
} else {
cout << 2 << endl;
for (int i = 0; i < s.size() - 1; i++) {
cout << s[i];
}
cout << " " << s[s.size() - 1];
}
}
|
#include <bits/stdc++.h>
using namespace std;
void ready() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int main() {
ready();
int n;
string s;
cin >> n >> s;
int a = 0, b = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1')
a++;
else
b++;
}
if (a == b) {
cout << 2 << '\n';
cout << s[0] << " ";
for (int i = 1; i < n; i++) cout << s[i];
cout << '\n';
} else {
cout << 1 << '\n';
cout << s << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
string k;
cin >> n >> k;
if (n % 2) {
printf("1 %s\n", k.c_str());
return 0;
}
int cant[] = {0, 0};
for (auto x : k) {
cant[x - '0']++;
}
if (cant[0] != cant[1]) {
printf("1 %s\n", k.c_str());
return 0;
}
char first = k[0];
string left = "";
for (int i = 1; i < n; i++) {
left += k[i];
}
printf("2\n%c %s\n", first, left.c_str());
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int len;
scanf("%d", &len);
char matrix[len];
scanf("%s", matrix);
int ones = 0, zeros = 0, count = 1;
for (int i = 0; i < len; i++) {
if (matrix[i] == '1')
ones++;
else
zeros++;
}
if (ones != zeros)
printf("%d\n%s\n", count, matrix);
else {
printf("2\n");
printf("%c ", matrix[0]);
for (int j = 1; j < len; j++) {
printf("%c", matrix[j]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const long long int MAXN = 2e5 + 1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
string s;
cin >> s;
if (n & 1)
cout << "1\n" << s;
else {
int cnt = 0;
for (int i = 0; i < n; ++i) cnt += s[i] == '1';
if (cnt != n / 2) {
cout << "1\n" << s;
} else {
cout << "2\n";
cout << s[0] << " ";
for (int i = 0; i < n - 1; ++i) cout << s[i + 1];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
int cnt[] = {0, 0};
for (int i = 0; i < n; ++i) {
cnt[s[i] - '0']++;
}
if (cnt[0] != cnt[1]) {
cout << "1\n" << s;
} else {
cout << "2\n" << s[0] << " ";
for (int i = 1; i < n; ++i) cout << s[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
int cnt0 = 0, cnt1 = 0;
for (auto c : s) {
if (c == '0') {
cnt0++;
} else {
cnt1++;
}
}
if (cnt0 != cnt1) {
cout << "1\n" << s << "\n";
} else {
cout << "2\n" << s[0] << " " << s.substr(1, n - 1) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
vector<char> arr(n);
long long forZero = 0, forOne = 0;
for (long long i = 0; i < n; ++i) {
cin >> arr[i];
if (arr[i] == '1') {
forOne += 1;
} else {
forZero += 1;
}
}
if (forOne != forZero) {
cout << "1\n";
for (char e : arr) {
cout << e;
}
} else {
cout << "2\n";
for (long long i = 0; i < n - 1; ++i) {
cout << arr[i];
}
cout << ' ' << arr[n - 1];
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e14;
const long long int mod = 1e9 + 7;
long long int power(long long int x, long long int y) {
if (y == 0) return 1;
long long int a = power(x, y / 2);
a = (a * a) % mod;
if (y % 2) a = (a * x % mod) % mod;
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t, x;
int i, j, k = 0, n, l, r, m, low, high, y, mid, cnt = 1, sa = 0, sb = 0, a, b,
c, q, flag = 0, c0 = 0, c1 = 0;
cin >> n;
string s, s1, s2;
cin >> s;
n = s.length();
for (i = 0; i < s.length(); i++) {
if (s[i] == '0')
c0++;
else
c1++;
}
if (c0 != c1) {
cout << "1" << endl;
cout << s << endl;
} else {
cout << "2" << endl;
for (i = 0; i < n - 1; i++) cout << s[i];
cout << " ";
cout << s[n - 1] << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.