text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e18;
const int N = 100005;
const int E = 2000006;
vector<int> g[N];
int ne;
struct Edge {
int from, to;
long long flow, cap;
} edge[E];
int lvl[N], vis[N], pass, source = N - 2, target = N - 1;
int qu[N], qt, px[N];
long long run(int s, long long minE) {
if (s == target) return minE;
long long ans = 0;
for (; px[s] < (int)g[s].size(); px[s]++) {
int e = g[s][px[s]];
auto &v = edge[e], &rev = edge[e ^ 1];
if (lvl[v.to] != lvl[s] + 1 || v.flow >= v.cap) continue;
long long tmp = run(v.to, min(minE, v.cap - v.flow));
v.flow += tmp, rev.flow -= tmp;
ans += tmp, minE -= tmp;
if (minE == 0) break;
}
return ans;
}
bool bfs() {
qt = 0;
qu[qt++] = source;
lvl[source] = 1;
vis[source] = ++pass;
for (int i = 0; i < qt; i++) {
int u = qu[i];
px[u] = 0;
if (u == target) return true;
for (int e : g[u]) {
auto v = edge[e];
if (v.flow >= v.cap || vis[v.to] == pass) continue;
vis[v.to] = pass;
lvl[v.to] = lvl[u] + 1;
qu[qt++] = v.to;
}
}
return false;
}
long long flow() {
long long ans = 0;
while (bfs()) ans += run(source, oo);
return ans;
}
void addEdge(int u, int v, long long c = 1, long long rc = 0) {
edge[ne] = {u, v, 0, c};
g[u].push_back(ne++);
edge[ne] = {v, u, 0, rc};
g[v].push_back(ne++);
}
void reset_flow() {
for (int i = 0; i < ne; i++) edge[i].flow = 0;
}
char s[N];
int m, cnt_letter[300], cnt_bit[1 << 7];
int get_bit() {
int ans = 0;
for (int i = 0; s[i]; i++) ans |= 1 << int(s[i] - 'a');
return ans;
}
int bit[N];
int main() {
int n;
scanf("%s", s);
n = (int)strlen(s);
for (int i = 0; s[i]; i++) cnt_letter[int(s[i] - 'a')]++;
scanf("%d", &m);
for (int i = 0; i < n; i++) bit[i] = (1 << 6) - 1;
for (int i = 0; i < m; i++) {
int pos;
scanf("%d %s", &pos, s);
pos--;
bit[pos] = get_bit();
}
for (int i = 0; i < n; i++) cnt_bit[bit[i]]++;
for (int i = 0; i < 6; i++) {
addEdge(source, i, cnt_letter[i]);
}
for (int i = 0; i < 64; i++) {
addEdge(10 + i, target, cnt_bit[i]);
}
for (int i = 0; i < 6; i++)
if (cnt_letter[i])
for (int j = 0; j < 64; j++)
if (cnt_bit[j])
if ((1 << i) & j) addEdge(i, 10 + j, oo);
if (flow() < n) return printf("Impossible\n"), 0;
for (int i = 0; i < n; i++) {
edge[2 * (6 + bit[i])].cap--;
for (int j = 0; j < 6; j++)
if (bit[i] & (1 << j)) {
if (!edge[2 * j].cap) continue;
edge[2 * j].cap--;
reset_flow();
if (flow() == n - i - 1) {
s[i] = char(j + 'a');
break;
}
edge[2 * j].cap++;
}
}
s[n] = 0;
printf("%s\n", s);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, st[100010], t[6], g[1 << 6];
char c[100010], ans[100010];
int main() {
scanf("%s", c + 1);
n = strlen(c + 1);
for (int i = 1; i <= n; i++) t[c[i] - 'a']++, st[i] = (1 << 6) - 1;
int q, x;
scanf("%d", &q);
while (q--) {
scanf("%d%s", &x, c);
int p = 0;
for (int i = 0; i < strlen(c); i++) p |= (1 << (c[i] - 'a'));
st[x] &= p;
}
for (int i = 1; i <= n; i++)
for (int s = 0; s < (1 << 6); s++)
if (st[i] & s) g[s]++;
bool fll = 1;
for (int i = 1; i <= n; i++) {
for (int s = 0; s < (1 << 6); s++)
if (st[i] & s) g[s]--;
bool fx = 0;
for (int j = 0; j < 6; j++)
if (t[j] && ((st[i] >> j) & 1)) {
t[j]--;
bool fl = 1;
for (int s = 0; s < (1 << 6); s++) {
int sp = 0;
for (int k = 0; k < 6; k++)
if ((s >> k) & 1) sp += t[k];
fl &= (g[s] >= sp);
}
if (fl) {
fx = 1;
ans[i] = j + 'a';
break;
}
t[j]++;
}
fll &= fx;
}
if (!fll)
puts("Impossible");
else
for (int i = 1; i <= n; i++) printf("%c", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ns[(1 << 6)];
int s[(1 << 6)];
char str[100005];
int p[100005];
void solve() {
int n;
scanf("%s ", str + 1);
n = strlen(str + 1);
for (int i = n; i; --i) {
int al = str[i] - 'a';
for (int bit = 0; bit < (1 << 6); ++bit) {
if (bit & (1 << al)) {
ns[bit]++;
}
}
p[i] = (1 << 6) - 1;
}
int m;
scanf("%d ", &m);
for (int i = 1; i <= m; ++i) {
int pos;
scanf("%d ", &pos);
scanf("%s ", &str);
int len = strlen(str);
p[pos] = 0;
for (int j = 0; j < len; ++j) {
p[pos] |= (1 << (str[j] - 'a'));
}
}
for (int i = n; i; --i) {
for (int bit = 0; bit < (1 << 6); ++bit) {
if ((bit & (p[i])) == p[i]) {
++s[bit];
}
}
}
for (int bit = 0; bit < (1 << 6); ++bit) {
if (s[bit] > ns[bit]) {
printf("Impossible\n");
return;
}
}
for (int i = 1; i <= n; ++i) {
int curAl = -1;
for (int al = 0; al < 6 && curAl == -1; ++al) {
if ((1 << al) & p[i]) {
bool isGood = true;
for (int bit = 0; bit < (1 << 6) && isGood; ++bit) {
int tns = ns[bit], ts = s[bit];
if ((bit & (p[i])) == p[i]) {
--ts;
}
if (bit & (1 << al)) {
--tns;
}
if (ts > tns) {
isGood = false;
}
}
if (isGood) {
curAl = al;
}
}
}
assert(curAl != -1);
for (int bit = 0; bit < (1 << 6); ++bit) {
if ((bit & (p[i])) == p[i]) {
--s[bit];
}
}
for (int bit = 0; bit < (1 << 6); ++bit) {
if (bit & (1 << curAl)) {
--ns[bit];
}
}
putchar('a' + curAl);
}
putchar('\n');
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 101000;
const int maxA = 1 << 6;
int n;
char S[maxN];
int req[maxN];
int cnt[maxA + 10], alpha[maxA + 10], sum[maxA + 10];
int main() {
scanf("%s", S + 1);
int len = strlen(S + 1);
for (int i = 1; i <= len; i++) ++alpha[(1 << (S[i] - 'a'))];
for (int i = 1; i < maxA; i++)
alpha[i] = alpha[i - ((i) & (-i))] + alpha[i & (-i)];
scanf("%d", &n);
memset(req, -1, sizeof(req));
for (int i = 1; i <= n; i++) {
char ipt[10];
int pos, S = 0;
scanf("%d %s", &pos, ipt);
int l = strlen(ipt);
for (int j = 0; j < l; j++) S |= (1 << (ipt[j] - 'a'));
++cnt[S];
req[pos] = S;
}
for (int i = 1; i <= len; i++) {
S[i] = 0;
for (int j = 0; j < 6; j++)
if (alpha[(1 << (j))] && (req[i] == -1 || (req[i] & (1 << (j))))) {
bool flag = 1;
if (req[i] != -1) --cnt[req[i]];
for (int k = 0; k < maxA; k++)
if (k & (1 << (j))) --alpha[k];
for (int k = 0; k < maxA; k++) sum[k] = cnt[k];
for (int a = 0; a < 6; a++)
for (int b = 0; b < maxA; b++)
if (b & (1 << (a))) sum[b] += sum[b ^ (1 << (a))];
for (int k = 0; k < maxA; k++)
if (sum[k] > alpha[k]) flag = 0;
if (flag) {
S[i] = j + 'a';
break;
}
++cnt[req[i]];
for (int k = 0; k < maxA; k++)
if (k & (1 << (j))) ++alpha[k];
}
if (S[i] == 0) {
puts("Impossible");
return 0;
}
}
for (int i = 1; i <= len; i++) printf("%c", S[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 7;
const int infint = (int)1e9;
const long long inf = (long long)1e18;
string s;
int cnt[6], mask[MAXN], n, visited[6], ted[130];
bool hall() {
for (int mask = 0; mask < 64; mask++) {
int cntB = 0, cntA = 0;
for (int j = 0; j < 6; j++)
if ((mask >> j) & 1) cntB += cnt[j];
int M = mask;
while (M) {
cntA += ted[M];
M = (M - 1) & mask;
}
if (cntA > cntB) return 0;
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s >> n;
for (int i = 0; i < s.size(); i++) mask[i] = 63, cnt[s[i] - 'a']++;
for (int i = 0; i < n; i++) {
int idx, msk = 0;
string cur;
cin >> idx >> cur;
idx--;
memset(visited, 0, sizeof visited);
for (int j = 0; j < cur.size(); j++) msk += (1ll << (cur[j] - 'a'));
mask[idx] = msk;
ted[msk]++;
}
if (!hall()) return cout << "Impossible", 0;
vector<char> ans;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < 6; j++) {
if (((mask[i] >> j) & 1) == 0) continue;
ans.push_back((char)('a' + j));
cnt[j]--;
ted[mask[i]]--;
if (hall()) break;
ans.pop_back();
cnt[j]++;
ted[mask[i]]++;
}
}
for (auto u : ans) cout << u;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(int a) {
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(int a) {
if (a < 0) {
a = -a;
putchar('-');
}
write(a);
puts("");
}
const int M = 100005, N = 100005, oo = 1000000005;
int nextt[M], ed[M], di[M], son[M], nedge, n, m, deep[N], cur[N], que[N];
inline void aedge(int a, int b, int c) {
nextt[++nedge] = son[a];
son[a] = nedge;
ed[nedge] = b;
di[nedge] = c;
}
inline void insert(int a, int b, int c) {
aedge(a, b, c);
aedge(b, a, 0);
}
int tot;
bool bfs(int s, int t) {
for (int i = 1; i <= tot; i++) {
deep[i] = oo;
cur[i] = son[i];
}
que[0] = s;
deep[s] = 0;
int l = 0, r = 0;
while (l <= r) {
int k = que[l++];
for (int i = son[k]; i; i = nextt[i])
if (di[i] && deep[ed[i]] == oo) {
deep[ed[i]] = deep[k] + 1;
que[++r] = ed[i];
}
}
return deep[t] < oo;
}
inline int dfs(int now, int t, int limit) {
if (now == t || !limit) return limit;
int flow = 0, f;
for (int i = cur[now]; i; i = nextt[i]) {
cur[now] = i;
if (deep[ed[i]] == deep[now] + 1 &&
(f = dfs(ed[i], t, min(limit, di[i])))) {
di[i] -= f;
di[((i - 1) ^ 1) + 1] += f;
flow += f;
limit -= f;
if (!limit) break;
}
}
return flow;
}
int dinic(int s, int t) {
int ans = 0;
while (bfs(s, t)) ans += dfs(s, t, oo);
return ans;
}
const int inf = 100005;
int tong[6], cs[1 << 6], dq, tt[1 << 6], sum[1 << 6];
bool check() {
int s = 1, t = 2;
tot = 2 + (1 << 6);
nedge = 0;
for (int i = 1; i <= tot; i++) son[i] = 0;
for (int i = 0; i < 6; i++) insert(s, (1 << i) + 2, tong[i]);
for (int i = 0; i < (1 << 6); i++) sum[i] = cs[i];
for (int i = 0; i < 6; i++) {
for (int j = 0; j < (1 << 6); j++)
if (j >> i & 1) sum[j] += sum[j ^ (1 << i)];
}
for (int i = 1; i < (1 << 6); i++) {
tt[i] = 0;
for (int j = 0; j < 6; j++)
if (i >> j & 1) tt[i] += tong[j];
}
for (int i = 0; i < (1 << 6); i++)
if (sum[i] > tt[i]) return 0;
for (int i = 1; i < (1 << 6); i++) {
insert(i + 2, t, cs[i]);
for (int j = 0; j < 6; j++) {
if (i >> j & 1) break;
insert(i + 2, (i | (1 << j)) + 2, inf);
}
for (int j = 5; j >= 0; j--) {
if (i >> j & 1) break;
insert(i + 2, (i | (1 << j)) + 2, inf);
}
}
int ans = dinic(s, t);
return ans == dq;
}
char ch[N], ans[N];
int ycl[N];
int main() {
scanf("%s", ch + 1);
n = strlen(ch + 1);
for (int i = 1; i <= n; i++) {
tong[ch[i] - 'a']++;
ycl[i] = (1 << 6) - 1;
}
m = read();
while (m--) {
int pos = read(), s = 0;
scanf("%s", ch);
int len = strlen(ch);
for (int i = 0; i < len; i++) s |= 1 << (ch[i] - 'a');
ycl[pos] = s;
}
for (int i = 1; i <= n; i++) cs[ycl[i]]++;
dq = n;
if (!check()) {
puts("Impossible");
return 0;
}
for (int i = 1; i <= n; i++) {
cs[ycl[i]]--;
dq--;
for (int j = 0; j < 6; j++)
if ((ycl[i] >> j & 1) && tong[j]) {
tong[j]--;
if (check()) {
ans[i] = j + 'a';
break;
}
tong[j]++;
}
}
cout << (ans + 1) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
string s, ans = "";
int n, good[100010], numc[6];
pair<int, int> num[100];
void addNei(int pos, int val) {
for (int i = 1; i <= (1 << 6) - 1; i++) {
bool add = false;
for (int j = 0; j < 6; j++)
if ((i & (1 << j)) > 0 && (good[pos] & (1 << j))) add = true;
if (add) num[i].first += val;
}
}
void addCol(int col, int val) {
for (int i = 1; i <= (1 << 6) - 1; i++)
if ((i & (1 << col)) > 0) num[i].second += val;
}
bool check() {
for (int i = 1; i <= (1 << 6) - 1; i++)
if (num[i].first < num[i].second) return false;
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s >> n;
for (int i = 0; i < s.size(); i++) ++numc[s[i] - 'a'];
for (int i = 0; i < s.size(); i++) good[i] = (1 << 6) - 1;
int x;
string y;
for (int i = 0; i < n; i++) {
cin >> x >> y;
--x;
good[x] = 0;
for (int j = 0; j < y.size(); j++) good[x] |= (1 << (y[j] - 'a'));
}
for (int i = 0; i < s.size(); i++) {
for (int j = 1; j <= (1 << 6) - 1; j++) {
bool cont = false;
for (int k = 0; k < 6; k++)
if ((j & (1 << k)) > 0 && (good[i] & (1 << k)) > 0) cont = true;
if (cont) ++num[j].first;
}
}
for (int i = 1; i <= (1 << 6) - 1; i++)
for (int j = 0; j < 6; j++)
if ((i & (1 << j)) > 0) num[i].second += numc[j];
for (int i = 0; i < s.size(); i++) {
bool ok = false;
addNei(i, -1);
for (int j = 0; j < 6; j++) {
if ((good[i] & (1 << j)) == 0 || numc[j] == 0) continue;
addCol(j, -1);
if (check()) ok = true;
if (ok) {
ans.push_back(j + 'a');
--numc[j];
break;
}
addCol(j, 1);
}
if (!ok) {
puts("Impossible");
return 0;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + ch - 48, ch = getchar();
return x;
}
char s[N];
int n, v[N], suf[N][64], tot[64], sum[64];
void getv() {
int m = read();
memset(v, 0, sizeof v);
while (m--) {
int id = read();
char s[10];
scanf("%s", s + 1);
int len = strlen(s + 1);
for (int i = 1; i <= len; i++) v[id] |= 1 << (s[i] - 'a');
}
for (int i = 1; i <= n; i++)
if (v[i] == 0) v[i] = 63;
}
bool check(int p) {
sum[0] = 0;
for (int i = 1; i < 64; i++) {
sum[i] = sum[i ^ (i & -i)] + tot[i & -i];
if (sum[i] < suf[p][i]) return 0;
}
return 1;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
getv();
memset(tot, 0, sizeof tot);
for (int i = 1; i <= n; i++) tot[1 << (s[i] - 'a')]++;
memset(suf, 0, sizeof suf);
for (int i = n; i >= 1; i--) {
for (int j = 0; j < 64; j++) suf[i][j] = suf[i + 1][j];
suf[i][v[i]]++;
}
for (int id = 1; id <= n; id++)
for (int i = 1; i < 64; i <<= 1)
for (int j = 0; j < 64; j++)
if (j & i) suf[id][j] += suf[id][j ^ i];
if (!check(1)) {
printf("Impossible");
return 0;
}
for (int i = 1; i <= n; i++)
for (int j = v[i], k = j & -j; j; j -= k, k = j & -j) {
tot[k]--;
if (check(i + 1)) {
s[i] = 'a' + (int)floor(log(k) / log(2) + 0.01);
break;
}
tot[k]++;
}
puts(s + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int y;
int c;
int f;
edge(){};
edge(int y, int c, int f) : y(y), c(c), f(f){};
};
const int N = 100;
vector<edge> e;
vector<int> g[N];
int edge_num[N][N];
int char_vertex[6];
int mask_vertex[N];
int used[N];
int cc = 0;
int s, t;
void add_edge(int x, int y, int c) {
edge_num[x][y] = ((int)(e).size());
g[x].push_back(((int)(e).size()));
e.push_back(edge(y, c, 0));
edge_num[y][x] = ((int)(e).size());
g[y].push_back(((int)(e).size()));
e.push_back(edge(x, 0, 0));
}
int rem(int num) { return e[num].c - e[num].f; }
int dfs(int x, int mx) {
if (x == t) return mx;
if (used[x] == cc) return 0;
used[x] = cc;
for (auto num : g[x]) {
if (rem(num)) {
int pushed = dfs(e[num].y, min(mx, rem(num)));
if (pushed) {
e[num].f += pushed;
e[num ^ 1].f -= pushed;
return pushed;
}
}
}
return 0;
}
bool check(int ch, int mask) {
if ((mask & (1 << ch)) == 0) return false;
int cv = char_vertex[ch];
int mv = mask_vertex[mask];
int e1 = edge_num[s][cv];
int e2 = edge_num[mv][t];
if (e[e1].f == 0 || e[e2].f == 0) return false;
e[e1].f--;
e[e1 ^ 1].f++;
vector<int> affected_edges;
affected_edges.push_back(e1);
for (auto x : g[cv]) {
if ((x & 1) == 0 && e[x].f > 0) {
affected_edges.push_back(x);
e[x].f--;
e[x ^ 1].f++;
int y = e[x].y;
for (auto x2 : g[y]) {
if ((x2 & 1) == 0) {
affected_edges.push_back(x2);
e[x2].f--;
e[x2 ^ 1].f++;
break;
}
}
break;
}
}
if (e[e2].f < e[e2].c) {
e[e1].c--;
e[e2].c--;
return true;
}
affected_edges.push_back(e2);
e[e2].f--;
e[e2 ^ 1].f++;
for (auto x : g[mv]) {
if ((x & 1) == 1 && e[x].f < 0) {
affected_edges.push_back(x ^ 1);
e[x].f++;
e[x ^ 1].f--;
int y = e[x].y;
for (auto x2 : g[y]) {
if ((x2 & 1) == 1) {
affected_edges.push_back(x2 ^ 1);
e[x2].f++;
e[x2 ^ 1].f--;
break;
}
}
break;
}
}
cc++;
e[e1].c--;
e[e2].c--;
if (dfs(s, 1))
return true;
else {
e[e1].c++;
e[e2].c++;
for (auto x : affected_edges) {
e[x].f++;
e[x ^ 1].f--;
}
return false;
}
}
char buf[100043];
string allowed[100043];
int allowed_mask[100043];
int main() {
s = 70;
t = 71;
scanf("%s", buf);
string z = buf;
int n = ((int)(z).size());
int m;
scanf("%d", &m);
for (int i = 0; i < n; i++) {
allowed[i] = "abcdef";
allowed_mask[i] = 63;
}
for (int i = 0; i < m; i++) {
int idx;
scanf("%d", &idx);
--idx;
scanf("%s", buf);
allowed[idx] = buf;
allowed_mask[idx] = 0;
for (auto x : allowed[idx]) {
allowed_mask[idx] |= (1 << (x - 'a'));
}
}
for (int i = 0; i < 6; i++) char_vertex[i] = i;
for (int i = 0; i < (1 << 6); i++) mask_vertex[i] = i + 6;
for (int i = 0; i < (1 << 6); i++)
for (int j = 0; j < 6; j++)
if (i & (1 << j)) add_edge(char_vertex[j], mask_vertex[i], 100000);
for (int i = 0; i < 6; i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (z[j] == 'a' + i) cnt++;
add_edge(s, char_vertex[i], cnt);
}
for (int i = 0; i < (1 << 6); i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (allowed_mask[j] == i) cnt++;
add_edge(mask_vertex[i], t, cnt);
}
int flow = 0;
while (true) {
cc++;
int p = dfs(s, 100000);
if (p)
flow += p;
else
break;
}
if (flow != n) {
puts("Impossible");
return 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < 6; j++) {
if (check(j, allowed_mask[i])) {
printf("%c", j + 'a');
break;
}
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1e5) + 10;
const int MAX = 70;
int n, m, a[MAXN], b[MAXN][MAX], tmp[MAX], cnt[MAX];
char s[MAXN], s2[MAXN], ans[MAXN];
int main() {
scanf("%s%d", s + 1, &m);
n = strlen(s + 1);
for (int i = 1; i <= m; i++) {
int k, l;
scanf("%d%s", &k, s2 + 1);
l = strlen(s2 + 1);
for (int i = 1; i <= l; i++) a[k] |= 1 << s2[i] - 'a';
}
for (int i = 1; i <= n; i++)
if (!a[i]) a[i] = (1 << 6) - 1;
for (int i = 1; i <= n; i++) {
int x = s[i] - 'a';
for (int j = 0; j < (1 << 6); j++)
if (j >> x & 1) cnt[j]++;
}
for (int i = n; i >= 1; i--)
for (int j = 0; j < (1 << 6); j++) {
if ((j & a[i]) == a[i]) tmp[j]++;
b[i][j] = tmp[j];
}
for (int p = 1; p < n; p++) {
bool flag = 0;
for (int i = 0; i < 6; i++)
if (cnt[1 << i] && (a[p] >> i & 1)) {
bool FLAG = 1;
for (int j = 0; j < (1 << 6); j++)
if (cnt[j] - (j >> i & 1) < b[p + 1][j]) FLAG = 0;
if (FLAG) {
flag = 1, ans[p] = i + 'a';
for (int j = 0; j < (1 << 6); j++)
if (j >> i & 1) cnt[j]--;
}
}
if (!flag) {
puts("Impossible");
exit(0);
}
}
bool flag = 0;
for (int i = 0; i < 6; i++)
if (cnt[1 << i] && (a[n] >> i & 1)) {
flag = 1;
ans[n] = i + 'a';
break;
}
if (!flag) {
puts("Impossible");
exit(0);
}
ans[n + 1] = '\0';
puts(ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, sl, fh, flg, c[100010], cnt[1 << 6], f[100010][1 << 6];
char ch, s[100010], ans[100010];
int rd() {
sl = 0;
fh = 1;
ch = getchar();
while (ch < '0' || '9' < ch) {
if (ch == '-') fh = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') sl = sl * 10 + ch - '0', ch = getchar();
return sl * fh;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 1 << 6; ++j)
if (j & (1 << (s[i] - 'a'))) cnt[j]++;
}
for (int i = 1; i <= n; ++i) c[i] = (1 << 6) - 1;
m = rd();
for (int x, l, i = 1; i <= m; ++i) {
x = rd();
c[x] = 0;
scanf("%s", s + 1);
l = strlen(s + 1);
for (int j = 1; j <= l; ++j) c[x] |= 1 << (s[j] - 'a');
}
for (int i = n; i; --i)
for (int j = 0; j < 1 << 6; ++j) {
f[i][j] = f[i + 1][j];
if ((j & c[i]) == c[i]) f[i][j]++;
}
for (int i = 1; i <= n; ++i) {
flg = 0;
for (int x, j = 0; j < 6; ++j)
if (cnt[1 << j] && ((c[i] >> j) & 1)) {
x = 1;
for (int k = 0; x && k < 1 << 6; ++k)
if (f[i + 1][k] > cnt[k] - ((k >> j) & 1)) x = 0;
if (x) {
flg = 1;
ans[i] = 'a' + j;
for (int k = 0; k < 1 << 6; ++k)
if ((k >> j) & 1) cnt[k]--;
}
}
if (!flg) {
puts("Impossible");
return 0;
}
}
puts(ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int fullmask = (1 << 6) - 1;
char s[100005], buf[10];
int n, m;
int ok[100005];
int tmp[1 << 6], need[1 << 6], have[1 << 6], c[6];
inline bool doit(int mask, int ch) {
for (int i = 1; i < (1 << 6); ++i)
if (!((i | mask) ^ i)) {
--need[i];
}
for (int i = 1; i < (1 << 6); ++i)
if (i >> ch & 1) --have[i];
for (int i = 1; i < (1 << 6); ++i)
if (have[i] < need[i]) return 0;
return 1;
}
inline void redo(int mask, int ch) {
for (int i = 1; i < (1 << 6); ++i)
if (!((i | mask) ^ i)) {
++need[i];
}
for (int i = 1; i < (1 << 6); ++i)
if (i >> ch & 1) ++have[i];
}
int main() {
ios::sync_with_stdio(false);
cin >> s + 1 >> m;
n = strlen(s + 1);
for (int i = 1; i <= (n); ++i) ok[i] = fullmask;
for (int i = 1; i <= (n); ++i) ++c[s[i] - 'a'];
for (int i = 1; i <= (m); ++i) {
int pos;
cin >> pos >> buf;
int x = strlen(buf);
ok[pos] = 0;
for (int j = 0; j < (x); ++j) ok[pos] |= 1 << (buf[j] - 'a');
}
for (int i = 1; i <= (n); ++i) ++tmp[ok[i]];
for (int i = 1; i < (1 << 6); ++i) {
for (int j = i; j; j = (j - 1) & i) need[i] += tmp[j];
}
for (int i = 1; i < (1 << 6); ++i) {
for (int j = 0; j < 6; ++j)
if (i & (1 << j)) have[i] += c[j];
}
for (int i = 1; i < (1 << 6); ++i)
if (need[i] > have[i]) {
cout << "Impossible";
return 0;
}
for (int p = 1; p <= n; ++p) {
for (int ch = 0; ch < 6; ++ch)
if (ok[p] >> ch & 1) {
if (doit(ok[p], ch)) {
putchar(ch + 'a');
break;
} else
redo(ok[p], ch);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace whatever {
int readu() {
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
int value = ch - '0';
ch = getchar();
while (isdigit(ch)) {
value = value * 10 + ch - '0';
ch = getchar();
}
return value;
}
void run() {
static char s[100000 + 1];
gets(s);
int n = int(strlen(s));
static int cnt[6];
for (int i = 0; i < n; ++i) ++cnt[s[i] - 'a'];
static int allowed[100000];
fill_n(allowed, n, (1 << 6) - 1);
int m = readu();
while (--m != -1) {
int pos = readu() - 1;
gets(s);
int value = 0;
for (int i = 0; s[i] != '\0'; ++i) value += (1 << (s[i] - 'a'));
allowed[pos] = value;
}
static int supply[1 << 6];
for (int i = 0; i < n; ++i) ++supply[allowed[i]];
static int excess[1 << 6];
for (int i = 0; i < (1 << 6); ++i) {
for (int j = 0; j < 6; ++j)
if (i & (1 << j)) excess[i] -= cnt[j];
for (int j = 0; j < (1 << 6); ++j)
if (i & j) excess[i] += supply[j];
if (excess[i] < 0) {
puts("Impossible");
return;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < (1 << 6); ++j)
if (j & allowed[i]) excess[j] -= 1;
for (int ch = 0; ch < 6; ++ch)
if (allowed[i] & (1 << ch)) {
bool ok = true;
for (int j = 0; j < (1 << 6); ++j)
if (!(j & (1 << ch)) && excess[j] < 0) {
ok = false;
break;
}
if (ok) {
for (int j = 0; j < (1 << 6); ++j)
if (j & (1 << ch)) excess[j] += 1;
putchar('a' + ch);
break;
}
}
}
putchar('\n');
}
} // namespace whatever
int main() { whatever::run(); }
|
#include <bits/stdc++.h>
using namespace std;
char s[100010], ss[10], res[100010];
int cnt[6], m, n;
vector<int> al[100010], pos[6], me[64];
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; s[i]; i++) cnt[s[i] - 'a']++;
scanf("%d", &m);
for (int i = 1; i <= n; i++) al[i] = {0, 1, 2, 3, 4, 5};
for (int i = 0; i < m; i++) {
int x;
scanf("%d%s", &x, ss);
vector<int> tmp;
for (int j = 0; ss[j]; j++) tmp.push_back(ss[j] - 'a');
sort(tmp.begin(), tmp.end());
al[x] = tmp;
}
for (int i = 1; i <= n; i++)
for (int it : al[i]) pos[it].push_back(i);
for (int j = 1; j < 64; j++) {
vector<int> tmp1, tmp2;
for (int k = 0; k < 6; k++)
if ((1 << k) & j) {
merge(tmp1.begin(), tmp1.end(), pos[k].begin(), pos[k].end(),
back_inserter(tmp2));
tmp1 = tmp2;
tmp2.clear();
}
tmp1.resize(unique(tmp1.begin(), tmp1.end()) - tmp1.begin());
me[j] = tmp1;
}
for (int i = 1; i <= n; i++) {
int flag = 0;
for (int it : al[i]) {
if (!cnt[it]) continue;
cnt[it]--;
int j = 1;
for (; j < 64; j++) {
int sz = me[j].size() -
(upper_bound(me[j].begin(), me[j].end(), i) - me[j].begin());
int tot = 0;
for (int k = 0; k < 6; k++)
if ((1 << k) & j) {
tot += cnt[k];
}
if (sz < tot) {
break;
}
}
if (j == 64) {
flag = 1;
res[i] = it + 'a';
break;
}
cnt[it]++;
}
if (!flag) {
puts("Impossible");
return 0;
}
}
puts(res + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
int src, des, node;
vector<int> typ[110];
vector<int> adjl[110];
vector<int> rc[110];
vector<int> rev_idx[110];
void poriskar() {
for (int u = 0; u <= node; u++) {
for (int p = 0; p <= (int)adjl[u].size() - 1; p++) {
int v = adjl[u][p];
if (!typ[u][p]) continue;
rc[u][p] += rc[v][rev_idx[u][p]];
rc[v][rev_idx[u][p]] = 0;
}
}
}
void add_edge(int u, int v, int w) {
adjl[u].push_back(v);
adjl[v].push_back(u);
rc[u].push_back(w);
rc[v].push_back(0);
rev_idx[u].push_back(adjl[v].size() - 1);
rev_idx[v].push_back(adjl[u].size() - 1);
typ[u].push_back(1);
typ[v].push_back(0);
}
int lev[110];
int vis[110];
bool dinic_bfs() {
memset(vis, 0, sizeof(vis));
memset(lev, 0, sizeof(lev));
lev[src] = 0;
vis[src] = 1;
queue<int> myq;
myq.push(src);
while (!myq.empty()) {
int u = myq.front();
myq.pop();
int sz = adjl[u].size();
for (int i = 0; i <= sz - 1; i++) {
int v = adjl[u][i];
if (rc[u][i] == 0) {
continue;
}
if (vis[v] == 0) {
vis[v] = 1;
lev[v] = lev[u] + 1;
myq.push(v);
}
}
}
if (vis[des]) {
return 1;
}
return 0;
}
int shuru[110];
int dinic_dfs(int u, int flow) {
if (u == des) {
return flow;
}
for (int i = shuru[u]; i <= (int)adjl[u].size() - 1; i++) {
shuru[u] = i;
int v = adjl[u][i];
if ((lev[v] == lev[u] + 1) && (rc[u][i])) {
int ff = dinic_dfs(v, min(flow, rc[u][i]));
if (ff) {
rc[u][i] -= ff;
rc[v][rev_idx[u][i]] += ff;
return ff;
}
}
}
shuru[u] = adjl[u].size();
return 0;
}
int dinic() {
int ans = 0;
while (dinic_bfs()) {
memset(shuru, 0, sizeof(shuru));
while (1) {
int ff = dinic_dfs(src, INF);
if (ff == 0) break;
ans += ff;
}
}
return ans;
}
int rev_edge(int u, int tar, int ff) {
for (int i = 0; i <= (int)adjl[u].size() - 1; i++) {
int v = adjl[u][i];
if (v == tar) {
if (!typ[u][i]) continue;
if (!rc[u][i]) return 1;
rc[u][i] -= ff;
rc[v][rev_idx[u][i]] += ff;
return 0;
}
}
return 1;
}
void decreaseCap(int u, int tar) {
for (int i = 0; i <= (int)adjl[u].size() - 1; i++) {
if (!typ[u][i]) continue;
int v = adjl[u][i];
if (v == tar) rc[v][rev_idx[u][i]] -= 1;
}
return;
}
string str;
int cnt[30], mask[100010], bitCnt[100010], n;
int main() {
ios::sync_with_stdio(false);
int x, q, p;
cin >> str;
n = str.size();
for (int i = 0; i <= n - 1; i++) x = str[i] - 'a', cnt[x]++;
cin >> q;
for (int i = 1; i <= q; i++) {
cin >> p >> str;
int v = 0;
for (int ko = 0; ko <= str.size() - 1; ko++) {
int so = str[ko] - 'a';
v |= (1 << so);
}
mask[p] = v ^ ((1 << 6) - 1);
}
for (int i = 1; i <= n; i++) {
mask[i] = mask[i] ^ ((1 << 6) - 1);
bitCnt[mask[i]]++;
}
src = 6 + (1 << 6) + 1;
des = 6 + (1 << 6) + 2;
node = des;
for (int i = 0; i <= 5; i++) add_edge(i, des, cnt[i]);
for (int i = 0; i <= (1 << 6) - 1; i++) add_edge(src, i + 6, bitCnt[i]);
for (int i = 0; i <= (1 << 6) - 1; i++) {
int id = i + 6;
for (int ko = 0; ko <= 5; ko++)
if (i & (1 << ko)) add_edge(id, ko, INF);
}
if (dinic() == n) {
for (int i = 1; i <= n; i++) {
int u = mask[i];
u = u + 6;
for (int p = 0; p <= (int)adjl[u].size() - 1; p++) {
if (adjl[u][p] == src) continue;
poriskar();
int v = adjl[u][p];
if (rev_edge(src, u, 1)) continue;
if (rev_edge(v, des, 1)) continue;
if (dinic() == n - i) {
char ch = v + 'a';
decreaseCap(src, u);
decreaseCap(v, des);
cout << ch;
break;
}
}
}
} else
cout << "Impossible" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
char s[100005], ot[100005], ope[10];
int pos[100005];
int cnt[66], a[7], dp[66];
void ee() {
puts("Impossible");
exit(0);
}
void build() {
for (int(i) = 0; (i) < (int)(64); (i)++) dp[i] = cnt[i];
for (int j = 0; j < 6; j++) {
for (int i = 1; i < 64; i++) {
if (i & (1 << j)) {
dp[i] += dp[i - (1 << j)];
}
}
}
}
bool ck(int j) {
for (int(i) = 0; (i) < (int)(64); (i)++) {
int s = 0;
for (int(j) = 0; (j) < (int)(6); (j)++)
if (i & (1 << j)) s += a[j];
if (s < dp[i]) return 0;
}
return 1;
}
void dfs(int x) {
if (x == n + 1) {
puts(ot + 1);
exit(0);
}
if (pos[x] == 0) {
for (int(j) = 0; (j) < (int)(6); (j)++)
if (a[j]) {
ot[x] = 'a' + j;
a[j]--;
if (ck(j)) dfs(x + 1);
a[j]++;
}
ee();
} else {
for (int(i) = 0; (i) < (int)(64); (i)++)
if ((i & pos[x]) == pos[x]) dp[i]--;
for (int(j) = 0; (j) < (int)(6); (j)++)
if (pos[x] & (1 << j)) {
if (a[j]) {
ot[x] = 'a' + j;
a[j]--;
if (ck(j)) dfs(x + 1);
a[j]++;
}
}
ee();
}
}
void fmain(int ID) {
scanf("%s", s + 1);
n = strlen(s + 1);
scanf("%d", &m);
for (int(i) = 1; (i) <= (int)(m); (i)++) {
scanf("%d%s", &k, ope);
int z = strlen(ope);
int S = 0;
for (int(j) = 0; (j) < (int)(z); (j)++) {
int num = ope[j] - 'a';
S += 1 << num;
}
cnt[S]++;
pos[k] = S;
}
for (int(i) = 1; (i) <= (int)(n); (i)++) a[s[i] - 'a']++;
build();
dfs(1);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int S[100009], cnt[1 << 7], num[1 << 7];
char s[100009];
int len, n, nu;
inline long long rd() {
long long x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f ? -x : x;
}
int main() {
scanf("%s", s + 1);
len = strlen(s + 1);
int x;
int maxn = (1 << 6) - 1;
for (int i = 1; i <= len; ++i) {
int x = s[i] - 'a';
for (int j = 1; j <= maxn; ++j)
if (j & (1 << x)) cnt[j]++;
}
n = rd();
for (int i = 1; i <= n; ++i) {
x = rd();
scanf("%s", s + 1);
int xx = strlen(s + 1);
for (int j = 1; j <= xx; ++j) S[x] |= (1 << (s[j] - 'a'));
for (int j = 1; j <= maxn; ++j)
if ((j & S[x]) == S[x]) num[j]++;
}
for (int i = 1; i <= len; ++i)
if (!S[i]) {
S[i] = maxn;
num[S[i]]++;
}
for (int i = 1; i <= len; ++i) {
bool tag = 0;
for (int j = 0; j < 6; ++j)
if ((1 << j) & S[i]) {
bool tg = 0;
for (int k = 1; k <= maxn; ++k) {
int x = (k & (1 << j)) ? cnt[k] - 1 : cnt[k],
y = ((k & S[i]) == S[i]) ? num[k] - 1 : num[k];
if (x < y) {
tg = 1;
break;
}
}
if (!tg) {
tag = 1;
s[++nu] = j + 'a';
for (int k = 1; k <= maxn; ++k) {
if ((1 << j) & k) cnt[k]--;
if ((S[i] & k) == S[i]) num[k]--;
}
break;
}
}
if (!tag) {
puts("Impossible");
return 0;
}
}
for (int i = 1; i <= nu; ++i) printf("%c", s[i]);
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
template <class t, class u, class... w>
auto operator<<(t& o, u a) -> decltype(a.print(a), o) {
return o << "{", a.print(), o << "}";
}
using namespace std;
void DD(...) {}
using Pii = pair<int, int>;
template <class t, class u, class... w>
void DD(t s, u a, w... k) {
while (*s && *s != ',') cerr << *s++;
cerr << ": " << a << *s++;
DD(s, k...);
}
template <class t, class u, class... w>
auto operator<<(t& o, u a) -> decltype((a).begin(), (a).end(), o) {
return o << "[",
[&]() {
for (auto i : a) o << i << ", ";
}(),
o << "]";
}
using Vi = vector<int>;
template <class t, class u, class... w>
auto operator<<(t& o, u a) -> decltype(get<1>(a), o) {
return o << "(" << a.first << ", " << a.second << ")";
}
constexpr int ALPHA = 6;
constexpr int APOW = 1 << ALPHA;
int counts[ALPHA], hall[APOW];
Vi masks;
bool isHall() {
for (int mask = (0); mask < (APOW); mask++) {
int first = 0;
for (int i = (0); i < (ALPHA); i++)
if (mask & (1 << i)) first += counts[i];
if (first > hall[mask]) return false;
}
return true;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
string str;
cin >> str;
for (auto& c : (str)) counts[c - 'a']++;
masks.resize(str.size(), APOW - 1);
int n;
cin >> n;
while (n--) {
int i;
cin >> i >> str;
i--;
masks[i] = 0;
for (auto& c : (str)) masks[i] |= 1 << (c - 'a');
}
for (int mask = (0); mask < (APOW); mask++)
for (auto& opt : (masks))
if (opt & mask) hall[mask]++;
if (!isHall()) {
cout << "Impossible\n";
return 0;
}
for (int i = (0); i < (int((masks).size())); i++) {
int opt = masks[i];
for (int mask = (0); mask < (APOW); mask++)
if (opt & mask) hall[mask]--;
for (int chr = (0); chr < (ALPHA); chr++)
if (counts[chr] > 0 && (masks[i] & (1 << chr))) {
counts[chr]--;
if (isHall()) {
cout << char('a' + chr);
break;
}
counts[chr]++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void Main();
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(10);
Main();
}
string s;
int n, m;
vector<int> allowed, cnt;
vector<vector<int>> suf;
void Main() {
cin >> s >> m;
n = (int)s.size();
allowed.assign(n, (1 << 6) - 1);
for (int i = 0; i < m; i++) {
int pos;
string can;
cin >> pos >> can;
pos--;
allowed[pos] = 0;
for (auto el : can) {
allowed[pos] += (1 << (el - 'a'));
}
}
cnt.assign(6, 0);
for (auto el : s) {
cnt[el - 'a']++;
}
suf.resize(n + 1, vector<int>((1 << 6), 0));
for (int i = n - 1; i >= 0; i--) {
suf[i] = suf[i + 1];
for (int mask = 1; mask < (1 << 6); mask++) {
if (allowed[i] & mask) {
suf[i][mask]++;
}
}
}
bool ok = true;
string ans = "";
for (int i = 0; i < n; i++) {
bool any = false;
for (int cur = 0; cur < 6; cur++) {
if ((allowed[i] & (1 << cur)) && cnt[cur] > 0) {
cnt[cur]--;
bool all_right = true;
for (int mask = 1; mask < (1 << 6); mask++) {
bool skip = false;
for (int j = 0; j < 6; j++) {
if (((mask >> j) & 1) && cnt[j] == 0) {
skip = true;
break;
}
}
if (skip) {
continue;
}
int suf_cnt = suf[i + 1][mask];
int need_cnt = 0;
for (int j = 0; j < 6; j++) {
if (mask & (1 << j)) {
need_cnt += cnt[j];
}
}
if (suf_cnt < need_cnt) {
all_right = false;
break;
}
}
if (all_right) {
ans.push_back('a' + cur);
any = true;
break;
}
cnt[cur]++;
}
}
if (!any) {
ok = false;
break;
}
}
if (!ok) {
cout << "Impossible\n";
} else {
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int S[100008], cnt[1 << 7], num[1 << 7];
char s[100008];
int len, n, nu;
inline long long rd() {
long long x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f ? -x : x;
}
int main() {
scanf("%s", s + 1);
len = strlen(s + 1);
int x;
int maxn = (1 << 6) - 1;
for (int i = 1; i <= len; ++i) {
int x = s[i] - 'a';
for (int j = 1; j <= maxn; ++j)
if (j & (1 << x)) cnt[j]++;
}
n = rd();
for (int i = 1; i <= n; ++i) {
x = rd();
scanf("%s", s + 1);
int xx = strlen(s + 1);
for (int j = 1; j <= xx; ++j) S[x] |= (1 << (s[j] - 'a'));
for (int j = 1; j <= maxn; ++j)
if ((j & S[x]) == S[x]) num[j]++;
}
for (int i = 1; i <= len; ++i)
if (!S[i]) {
S[i] = maxn;
num[S[i]]++;
}
for (int i = 1; i <= len; ++i) {
bool tag = 0;
for (int j = 0; j < 6; ++j)
if ((1 << j) & S[i]) {
bool tg = 0;
for (int k = 1; k <= maxn; ++k) {
int x = (k & (1 << j)) ? cnt[k] - 1 : cnt[k],
y = ((k & S[i]) == S[i]) ? num[k] - 1 : num[k];
if (x < y) {
tg = 1;
break;
}
}
if (!tg) {
tag = 1;
s[++nu] = j + 'a';
for (int k = 1; k <= maxn; ++k) {
if ((1 << j) & k) cnt[k]--;
if ((S[i] & k) == S[i]) num[k]--;
}
break;
}
}
if (!tag) {
puts("Impossible");
return 0;
}
}
for (int i = 1; i <= nu; ++i) printf("%c", s[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXL = 100010;
const int INF = 0x3f3f3f3f;
char str[MAXL];
int mask[MAXL], cnt_mask[1 << 6], cnt_ch[6];
int source, sink, tot = 1;
const int MAXN = 400;
const int MAXM = 400000;
int to[MAXM], _next[MAXM], head[MAXN], cap[MAXM], num[400][400];
int pre[MAXN], cur[MAXN];
bool vis[MAXN];
void addEdge(int u, int v, int c) {
to[++tot] = v, _next[tot] = head[u], cap[tot] = c, head[u] = tot;
num[u][v] = tot;
}
int DFS(int u, int mmin) {
if (u == sink || mmin == 0) return mmin;
int flow = 0, f;
for (int &i = cur[u]; i; i = _next[i]) {
int v = to[i];
if (pre[v] == pre[u] + 1 && (f = DFS(v, min(mmin, cap[i]))) > 0) {
flow += f, cap[i] -= f, cap[i ^ 1] += f, mmin -= f;
if (mmin == 0) break;
}
}
return flow;
}
bool BFS() {
queue<int> q;
q.push(source);
memset(vis, false, sizeof(vis));
vis[source] = true;
pre[source] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = _next[i]) {
int v = to[i];
if (vis[v] || !cap[i]) continue;
pre[v] = pre[u] + 1, vis[v] = true;
q.push(v);
}
}
return vis[sink];
}
int maxFlow() {
int flow = 0;
while (BFS()) {
memcpy(cur, head, sizeof(head));
flow += DFS(source, INF);
}
return flow;
}
bool check(int mask, int c) {
if (!(mask & (1 << c))) return false;
int cv = c + 1, mv = mask + 6;
int ce = num[source][cv], me = num[mv][sink];
if (cap[ce ^ 1] == 0) return false;
cap[ce]++, cap[ce ^ 1]--;
vector<int> aff_edge;
aff_edge.push_back(ce);
for (int i = head[cv]; i; i = _next[i])
if (i % 2 == 0 && cap[i ^ 1] != 0) {
int x = to[i];
cap[i]++, cap[i ^ 1]--;
aff_edge.push_back(i);
for (int j = head[x]; j; j = _next[j])
if (j % 2 == 0 && cap[j ^ 1] != 0) {
cap[j]++, cap[j ^ 1]--;
aff_edge.push_back(j);
break;
}
break;
}
if (cap[me]) {
cap[ce]--;
cap[me]--;
return true;
}
cap[me]++, cap[me ^ 1]--;
aff_edge.push_back(me);
for (int i = head[mv]; i; i = _next[i])
if (i % 2 == 1 && cap[i] != 0) {
int x = to[i];
cap[i]--, cap[i ^ 1]++;
aff_edge.push_back(i ^ 1);
for (int j = head[x]; j; j = _next[j])
if (j % 2 == 1 && cap[j] != 0) {
cap[j]--, cap[j ^ 1]++;
aff_edge.push_back(j ^ 1);
break;
}
break;
}
cap[ce]--, cap[me]--;
if (BFS()) {
memcpy(cur, head, sizeof(head));
if (DFS(source, 1)) return true;
}
cap[ce]++, cap[me]++;
int ln = aff_edge.size();
for (int i = 0; i < ln; i++) {
int e = aff_edge[i];
cap[e]--, cap[e ^ 1]++;
}
return false;
}
int main() {
scanf("%s", str + 1);
int n = strlen(str + 1);
for (int i = 1; i <= n; i++) mask[i] = (1 << 6) - 1;
int m;
scanf("%d", &m);
int idx;
char sel[10];
for (int i = 1; i <= m; i++) {
scanf("%d%s", &idx, sel);
mask[idx] = 0;
for (int j = 0; sel[j]; j++) mask[idx] |= (1 << (sel[j] - 'a'));
}
for (int i = 1; i <= n; i++) {
cnt_mask[mask[i]]++;
cnt_ch[str[i] - 'a']++;
}
source = 0, sink = 6 + (1 << 6);
for (int i = 1; i <= 6; i++) {
addEdge(source, i, cnt_ch[i - 1]);
addEdge(i, source, 0);
}
for (int i = 1; i <= 6; i++)
for (int j = 1; j < (1 << 6); j++)
if ((1 << (i - 1)) & j) {
addEdge(i, j + 6, INF);
addEdge(j + 6, i, 0);
}
for (int j = 1; j < (1 << 6); j++) {
addEdge(j + 6, sink, cnt_mask[j]);
addEdge(sink, j + 6, cnt_mask[j]);
}
if (maxFlow() != n) {
printf("Impossible\n");
return 0;
}
for (int i = 1; i <= n; i++)
for (int j = 0; j < 6; j++)
if (check(mask[i], j)) {
printf("%c", j + 'a');
break;
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100010];
int n;
int func(char c) { return c - 'a'; }
int a[100010];
int c[1 << 6], f[1 << 6];
void _insert(int pos) {
for (int j = 1; j < 64; j++)
if (j & a[pos]) c[j]++;
}
void _delete(int pos) {
for (int j = 1; j < 64; j++)
if (j & a[pos]) c[j]--;
}
char ans[100010];
bool check() {
for (int j = 1; j < 64; j++)
if (f[j] > c[j]) return 0;
return 1;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) a[i] = 63;
int m;
scanf("%d", &m);
while (m--) {
int pos;
char tmp[10];
scanf("%d%s", &pos, tmp);
a[pos] = 0;
for (int i = 0; tmp[i]; i++) a[pos] |= 1 << (func(tmp[i]));
}
for (int i = 1; i <= n; i++) _insert(i);
for (int i = 1; i <= n; i++) f[1 << (func(s[i]))]++;
for (int j = 1; j < 64; j++) {
int t = __builtin_ctz(j);
if (j != (1 << t)) f[j] = f[j ^ (1 << t)] + f[1 << t];
}
for (int i = 1; i <= n; i++) {
_delete(i);
for (int j = 0; j < 6; j++)
if (f[1 << j] > 0 && ((a[i] >> j) & 1)) {
for (int k = 1; k < 64; k++)
if ((k >> j) & 1) f[k]--;
if (check()) {
ans[i] = j + 'a';
break;
}
for (int k = 1; k < 64; k++)
if ((k >> j) & 1) f[k]++;
}
if (!ans[i]) break;
}
ans[n + 1] = 0;
if (ans[n])
puts(ans + 1);
else
puts("Impossible");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MAXS = 1 << 6;
const int MAXC = 7;
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
template <typename T>
void write(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void writeln(T x) {
write(x);
puts("");
}
char s[MAXN];
int n, m, goal, bit[MAXC], a[MAXN], cnt[MAXS], sum[MAXS];
bool tryans(int bit, int pos) {
for (int i = 0; i <= goal; i++) {
if (i & bit) cnt[i]--;
if (i & a[pos]) sum[i]--;
}
for (int j = 0; j <= goal; j++) {
if (cnt[j] > sum[j]) {
for (int i = 0; i <= goal; i++) {
if (i & bit) cnt[i]++;
if (i & a[pos]) sum[i]++;
}
return false;
}
}
return true;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1), read(m);
for (int i = 1; i <= 6; i++) bit[i] = 1 << (i - 1);
goal = (1 << 6) - 1;
for (int i = 1; i <= n; i++) a[i] = goal;
for (int i = 1; i <= m; i++) {
int pos;
char tmp[15];
scanf("%d %s", &pos, tmp + 1);
int len = strlen(tmp + 1), tans = 0;
for (int j = 1; j <= len; j++) tans += bit[tmp[j] - 'a' + 1];
a[pos] = tans;
}
for (int i = 1; i <= n; i++) {
int tmp = bit[s[i] - 'a' + 1];
for (int j = 0; j <= goal; j++) {
if (j & tmp) cnt[j]++;
if (j & a[i]) sum[j]++;
}
}
for (int i = 0; i <= goal; i++)
if (cnt[i] > sum[i]) {
printf("Impossible\n");
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 6; j++)
if ((a[i] & bit[j]) != 0 && tryans(bit[j], i)) {
putchar('a' + j - 1);
break;
}
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
const int MX = 1 << 6;
const int ITS_SO_FUCKING_BIG = 1e9;
int cnt[MX], maskat[MAX], f[6], n, req;
char s[MAX];
template <int SZ>
struct Dinic {
int N = 0, s, t;
struct Edge {
int to, rev;
int flow, cap;
int id;
};
vector<Edge> adj[SZ];
void addEdge(int u, int v, int cap, int id = 0) {
N = max(N, max(u, v) + 1);
Edge a = {v, (int)adj[v].size(), 0, cap, id},
b = {u, (int)adj[u].size(), 0, 0, 0};
adj[u].push_back(a), adj[v].push_back(b);
}
int lvl[SZ];
typename vector<Edge>::iterator cur[SZ];
bool bfs() {
for (int i = 0; i < SZ; i++) lvl[i] = -1, cur[i] = adj[i].begin();
queue<int> q({s});
lvl[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto &e : adj[u])
if (lvl[e.to] == -1 && e.flow < e.cap) {
q.push(e.to);
lvl[e.to] = lvl[u] + 1;
}
}
return lvl[t] >= 0;
}
int dfs(int u, int flow) {
if (u == t || !flow) return flow;
for (; cur[u] != adj[u].end(); cur[u]++) {
Edge &e = *cur[u];
if (lvl[e.to] != lvl[u] + 1 || e.flow == e.cap) continue;
int df = dfs(e.to, min(flow, e.cap - e.flow));
if (df) {
e.flow += df;
adj[e.to][e.rev].flow -= df;
return df;
}
}
return 0;
}
int maxFlow(int _s, int _t) {
s = _s, t = _t;
int totFlow = 0;
while (bfs()) {
int df = dfs(s, numeric_limits<int>::max());
while (df) {
totFlow += df;
df = dfs(s, numeric_limits<int>::max());
}
}
return totFlow;
}
};
Dinic<71> Network;
bool do_the_good_stuff() {
for (int i = 0; i < 71; i++) Network.adj[i].clear();
int s = 0, t = 70;
for (int i = 1; i <= 6; i++) {
if (!f[i - 1]) continue;
Network.addEdge(s, i, f[i - 1]);
for (int mask = 1; mask < MX; mask++) {
if (!cnt[mask]) continue;
if ((mask >> (i - 1)) & 1)
Network.addEdge(i, mask + 6, ITS_SO_FUCKING_BIG);
}
}
for (int i = 7; i < t; i++)
if (cnt[i - 6]) Network.addEdge(i, t, cnt[i - 6]);
int flow = Network.maxFlow(s, t);
return flow == req;
}
int main() {
scanf("%s", s);
n = strlen(s);
req = n;
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int pos;
char cur[6];
scanf("%d", &pos);
scanf("%s", cur);
int len = strlen(cur);
int mask = 0;
for (int j = 0; j < len; j++) mask |= 1 << (cur[j] - 'a');
maskat[pos] = mask;
cnt[mask]++;
}
if (m == 0) {
sort(s, s + n);
return printf("%s", s), 0;
}
for (int i = 1; i <= n; i++) {
if (!maskat[i]) {
maskat[i] = MX - 1;
cnt[maskat[i]]++;
}
f[s[i - 1] - 'a']++;
}
if (!do_the_good_stuff()) return cout << "Impossible", 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 6; j++) {
if (((maskat[i] >> j) & 1) && f[j]) {
if (!(maskat[i] >> (j + 1))) {
f[j]--;
cnt[maskat[i]]--;
req--;
printf("%c", char('a' + j));
break;
}
f[j]--;
cnt[maskat[i]]--;
req--;
if (do_the_good_stuff()) {
printf("%c", char('a' + j));
break;
}
f[j]++;
cnt[maskat[i]]++;
req++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Edge {
public:
Edge(int i, int u, int v, int f, int c, bool b = false)
: id(i), from(u), to(v), flow(f), capacity(c), rid(-1), bReverse(b) {}
int id;
int rid;
int from;
int to;
int flow;
int capacity;
bool bReverse;
int remain() { return capacity - flow; }
void update(int x) { flow += x; }
void shrink(int x = 1) { capacity -= x; }
void pair(int r) { rid = r; }
int reverseEdge() { return rid; }
bool isReverse() { return bReverse; }
};
class Solution {
public:
Solution(int A = 6) : an(A), N(1 << A), size(0), s(-1), t(-1), clock(0) {}
string rename(string& s, vector<pair<int, string>>& rs) {
build(s, rs);
if (maximumFlow() != s.length()) {
return "";
}
string res;
for (int i = 0; i < s.length(); ++i) {
for (int j = 0; j < an; ++j) {
if (check(j, allowed[i])) {
res += 'a' + j;
break;
}
}
}
return res;
}
private:
int an;
int N;
int size;
int s;
int t;
int clock;
vector<vector<int>> graph;
vector<Edge> edges;
vector<int> allowed;
vector<int> charVertex;
vector<int> maskVertex;
unordered_map<unsigned int, int> edgeIds;
vector<int> visited;
unsigned int hash(int u, int v) {
unsigned int res = u;
res = res << 16 | v;
return res;
}
void build(string& str, vector<pair<int, string>>& rs) {
int n = str.length();
size = n;
graph.clear();
graph.resize(N * 2);
s = graph.size() - 2;
t = graph.size() - 1;
int idx = 0;
charVertex.resize(an);
for (int i = 0; i < an; ++i) {
charVertex[i] = idx++;
}
maskVertex.resize(N);
for (int i = 0; i < N; ++i) {
maskVertex[i] = idx++;
}
allowed.resize(n);
fill(allowed.begin(), allowed.end(), N - 1);
for (auto& p : rs) {
int j = p.first;
auto& t = p.second;
allowed[j] = 0;
for (auto c : t) {
allowed[j] |= 1 << (c - 'a');
}
}
edges.clear();
vector<int> cnts(an, 0);
for (auto c : str) {
++cnts[c - 'a'];
}
for (int i = 0; i < an; ++i) {
addEdge(s, charVertex[i], cnts[i]);
}
for (int i = 0; i < an; ++i) {
for (int j = 0; j < N; ++j) {
if (j & (1 << i)) {
addEdge(charVertex[i], maskVertex[j], 100000);
}
}
}
vector<int> mcnts(N, 0);
for (auto m : allowed) {
++mcnts[m];
}
for (int i = 0; i < N; ++i) {
addEdge(maskVertex[i], t, mcnts[i]);
}
visited.resize(graph.size());
fill(visited.begin(), visited.end(), 0);
}
int maximumFlow() {
int flow = 0;
while (true) {
++clock;
int inc = advance(s, 100000);
if (inc == 0) {
break;
}
flow += inc;
}
return flow;
}
int advance(int u, int mx) {
if (u == t) {
return mx;
}
if (visited[u] == clock) {
return 0;
}
visited[u] = clock;
for (auto e : graph[u]) {
int x = edges[e].remain();
if (x != 0) {
int inc = advance(edges[e].to, min(mx, x));
if (inc != 0) {
update(e, inc);
return inc;
}
}
}
return 0;
}
bool check(int c, int mask) {
if (!((1 << c) & mask)) {
return false;
}
int u = charVertex[c];
int v = maskVertex[mask];
int e1 = edgeIds[hash(s, u)];
int e2 = edgeIds[hash(v, t)];
if (edges[e1].flow == 0 || edges[e2].flow == 0) {
return false;
}
update(e1, -1);
vector<int> changed;
changed.push_back(e1);
for (auto e : graph[u]) {
if (edges[e].isReverse()) {
continue;
}
if (edges[e].flow > 0) {
int x = edges[e].to;
update(e, -1);
changed.push_back(e);
for (auto ex : graph[x]) {
if (edges[ex].isReverse()) {
continue;
}
update(ex, -1);
changed.push_back(ex);
break;
}
break;
}
}
if (edges[e2].flow < edges[e2].capacity) {
edges[e2].shrink();
edges[e1].shrink();
return true;
}
update(e2, -1);
changed.push_back(e2);
for (auto e : graph[v]) {
if (!edges[e].isReverse()) {
continue;
}
if (edges[e].flow < 0) {
int re = edges[e].reverseEdge();
update(re, -1);
changed.push_back(re);
int x = edges[e].to;
for (auto ex : graph[x]) {
if (!edges[ex].isReverse()) {
continue;
}
int rex = edges[ex].reverseEdge();
update(rex, -1);
changed.push_back(rex);
break;
}
break;
}
}
edges[e1].shrink();
edges[e2].shrink();
++clock;
if (advance(s, 1)) {
return true;
} else {
edges[e1].shrink(-1);
edges[e2].shrink(-1);
for (auto e : changed) {
update(e, 1);
}
return false;
}
}
void addEdge(int u, int v, int c) {
int idx = edges.size();
edgeIds[hash(u, v)] = idx;
graph[u].push_back(idx);
edges.emplace_back(idx, u, v, 0, c);
edgeIds[hash(v, u)] = ++idx;
graph[v].push_back(idx);
edges.emplace_back(idx, v, u, 0, 0, true);
pair(idx - 1, idx);
}
void pair(int x, int y) {
edges[x].pair(y);
edges[y].pair(x);
}
void update(int x, int v) {
edges[x].update(v);
edges[edges[x].reverseEdge()].update(-v);
}
void shrink(int x) { edges[x].shrink(); }
void print() {
for (int i = 0; i < an; ++i) {
int u = charVertex[i];
int e = edgeIds[hash(s, u)];
cout << "s -> " << i << " : " << edges[e].flow << endl;
}
for (int i = 0; i < N; ++i) {
int v = maskVertex[i];
int e = edgeIds[hash(v, t)];
if (edges[e].flow > 0) {
cout << i << " -> t : " << edges[e].flow << endl;
}
}
}
};
int main(int argc, char** argv) {
char buf[100100] = {0};
scanf("%s", buf);
string s(buf);
int m;
scanf("%d", &m);
vector<pair<int, string>> rs;
rs.reserve(m);
for (int i = 0; i < m; ++i) {
int j = 0;
scanf("%d", &j);
char buf2[10] = {0};
scanf("%s", buf2);
string ss(buf2);
rs.emplace_back(j - 1, ss);
}
Solution sol;
auto res = sol.rename(s, rs);
if (res.empty()) {
printf("Impossible\n");
} else {
printf("%s\n", res.c_str());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, albet[6], t, m, subset[64], neisz[64], mask[100005];
char r[10], output[100005];
bool tryplace(int i, int t) {
--albet[t];
for (int k = 0; k < 64; ++k) {
if (k >> t & 1) --subset[k];
if (mask[i] & k) --neisz[k];
}
for (int k = 0; k < 64; ++k) {
if (neisz[k] < subset[k]) {
goto undo;
}
}
return output[i] = 'a' + t;
undo:
for (int k = 0; k < 64; ++k) {
if (k >> t & 1) ++subset[k];
if (mask[i] & k) ++neisz[k];
}
++albet[t];
return 0;
}
int main() {
while ((t = getchar()) != '\n') ++n, ++albet[t - 'a'];
for (int i = 0; i < 64; ++i)
for (int j = 0; j < 6; ++j)
if (i >> j & 1) subset[i] += albet[j];
fill(mask, mask + n, (1 << 6) - 1);
int ___L___59;
scanf("%d", &___L___59);
while (___L___59--) {
scanf("%d", &t);
scanf("%s", r);
m = 0;
for (int i = 0; i < strlen(r); ++i) m |= 1 << r[i] - 'a';
mask[--t] = m;
}
for (int i = 0; i < n; ++i)
for (int k = 0; k < 64; ++k)
if (mask[i] & k) ++neisz[k];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 6; ++j)
if (mask[i] >> j & 1 && albet[j] && tryplace(i, j)) goto nx;
return puts("Impossible"), 0;
nx:;
}
puts(output);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int E = 2 * N;
const int oo = 1e8;
vector<int> g[N];
int ne;
struct Edge {
int from, to;
int flow, cap;
} edge[E];
int lvl[N], vis[N], pass, source = N - 2, target = N - 1, px[N];
int q[N], qt;
int run(int s, int minE) {
if (s == target) return minE;
int ans = 0;
for (; px[s] < (int)g[s].size(); px[s]++) {
int e = g[s][px[s]];
auto &v = edge[e], &rev = edge[e ^ 1];
if (lvl[v.to] != lvl[s] + 1 || v.flow >= v.cap) continue;
int tmp = run(v.to, min(minE, v.cap - v.flow));
v.flow += tmp, rev.flow -= tmp;
ans += tmp, minE -= tmp;
if (minE == 0) break;
}
return ans;
}
int bfs() {
qt = 0;
q[qt++] = source;
lvl[source] = 1;
vis[source] = ++pass;
int u;
for (int i = 0; i < qt; i++) {
px[u = q[i]] = 0;
if (u == target) return true;
for (int e : g[u]) {
auto &v = edge[e];
if (v.flow >= v.cap || vis[v.to] == pass) continue;
vis[v.to] = pass;
lvl[v.to] = lvl[u] + 1;
q[qt++] = v.to;
}
}
return false;
}
int flow() {
int ans = 0, tmp;
while (bfs()) {
while ((tmp = run(source, oo)) > 0) ans += tmp;
}
return ans;
}
void addEdge(int u, int v, int c) {
edge[ne] = {u, v, 0, c};
g[u].push_back(ne++);
edge[ne] = {v, u, 0, 0};
g[v].push_back(ne++);
}
void reset_flow() {
for (int i = 0; i < ne; i++) edge[i].flow = 0;
}
char s[N];
int m, cnt_letter[300], cnt_bit[1 << 7];
int get_bit() {
int ans = 0;
for (int i = 0; s[i]; i++) ans |= 1 << int(s[i] - 'a');
return ans;
}
int bit[N];
int main() {
int n;
scanf("%s", s);
n = (int)strlen(s);
for (int i = 0; s[i]; i++) cnt_letter[int(s[i] - 'a')]++;
scanf("%d", &m);
for (int i = 0; i < n; i++) bit[i] = (1 << 6) - 1;
for (int i = 0; i < m; i++) {
int pos;
scanf("%d %s", &pos, s);
pos--;
bit[pos] = get_bit();
}
for (int i = 0; i < n; i++) cnt_bit[bit[i]]++;
for (int i = 0; i < 6; i++) {
addEdge(source, i, cnt_letter[i]);
}
for (int i = 0; i < 64; i++) {
addEdge(10 + i, target, cnt_bit[i]);
}
for (int i = 0; i < 6; i++)
if (cnt_letter[i])
for (int j = 0; j < 64; j++)
if (cnt_bit[j])
if ((1 << i) & j) addEdge(i, 10 + j, oo);
if (flow() < n) return printf("Impossible\n"), 0;
for (int i = 0; i < n; i++) {
edge[2 * (6 + bit[i])].cap--;
for (int j = 0; j < 6; j++)
if (bit[i] & (1 << j)) {
if (!edge[2 * j].cap) continue;
edge[2 * j].cap--;
reset_flow();
if (flow() == n - i - 1) {
s[i] = char(j + 'a');
break;
}
edge[2 * j].cap++;
}
}
s[n] = 0;
printf("%s\n", s);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7, inf = 1e9 + 7, MOD = 998244353;
const long long INF = 2e18 + 7;
const int M = 1 << N;
const int A = 6;
int cou[A];
vector<int> posMask;
int maskAmount[1 << A];
int l;
void getLetters() {
string s;
cin >> s;
for (auto u : s) ++cou[u - 'a'];
l = s.size();
}
void getMasks() {
int n;
cin >> n;
int poss = 0;
while (n--) {
int pos;
string s;
cin >> pos >> s;
int mask = 0;
for (auto u : s) {
mask |= 1 << (u - 'a');
}
posMask[pos - 1] = mask;
}
}
void countMasks() {
for (int i = 0; i < l; ++i) {
for (int j = 0; j < (1 << A); ++j) {
if (posMask[i] & j) ++maskAmount[j];
}
}
}
bool check() {
for (int i = 0; i < (1 << A); ++i) {
int sum = 0;
for (int j = 0; j < A; ++j)
if ((1 << j) & i) sum += cou[j];
if (sum > maskAmount[i]) return false;
}
return true;
}
void del(int index) {
for (int i = 0; i < (1 << A); ++i) {
if (posMask[index] & i) --maskAmount[i];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
getLetters();
posMask.resize(l, (1 << A) - 1);
getMasks();
countMasks();
if (!check()) {
cout << "Impossible\n";
return 0;
}
string res;
for (int i = 0; i < l; ++i) {
del(i);
for (int j = 0; j < A; ++j) {
if (cou[j] > 0 && ((1 << j) & posMask[i])) {
--cou[j];
if (check()) {
res += 'a' + j;
break;
}
++cou[j];
}
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int need[64], has[64];
char buf[100010];
char ans[100010];
int ok[100010];
int cnt[26];
int n, m;
int main() {
scanf("%s", buf);
n = strlen(buf);
for (int i = 0; i < n; i++) cnt[buf[i] - 'a']++;
for (int i = 0; i < (1 << 6); i++) {
for (int j = 0; j < 6; j++)
if (i >> j & 1) has[i] += cnt[j];
}
for (int i = 0; i < n; i++) ok[i] = (1 << 26) - 1;
scanf("%d", &m);
while (m--) {
int x;
scanf("%d", &x);
x--;
ok[x] = 0;
scanf("%s", buf);
for (int i = 0; i < strlen(buf); i++) ok[x] |= (1 << (buf[i] - 'a'));
int st = ((1 << 6) - 1) ^ ok[x];
for (int i = st;; i = (i - 1) & st) {
need[ok[x] | i]++;
if (!i) break;
}
}
for (int i = 0; i < (1 << 6); i++) {
if (has[i] < need[i]) {
printf("Impossible");
return 0;
}
}
for (int i = 0; i < n; i++) {
if (ok[i] < (1 << 6)) {
int st = ((1 << 6) - 1) ^ ok[i];
for (int k = st;; k = (k - 1) & st) {
need[ok[i] | k]--;
if (!k) break;
}
}
for (int j = 0; j < 26; j++) {
if (!(ok[i] >> j & 1) || !cnt[j]) continue;
bool f = true;
cnt[j]--;
if (j < 6) {
for (int k = 0; k < (1 << 6); k++)
if (k >> j & 1) has[k]--;
for (int k = 0; k < (1 << 6); k++) {
if (has[k] < need[k]) {
f = false;
break;
}
}
if (!f) {
cnt[j]++;
for (int k = 0; k < (1 << 6); k++)
if (k >> j & 1) has[k]++;
}
}
if (f) {
ans[i] = char('a' + j);
break;
}
}
}
for (int i = 0; i < n; i++) printf("%c", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = (1 << 6);
int s[N], b[N][M], a[N], nm[M], c[N], zt[M], tot;
char lx[N];
bool check(int id, int ch) {
for (int i = 0; i <= tot; ++i) {
int pos = zt[i];
if ((i >> ch) & 1) {
pos--;
}
if (pos > b[id][i]) {
return false;
}
}
return true;
}
void fail() {
puts("Impossible");
exit(0);
}
int main() {
scanf("%s", lx + 1);
int n = strlen(lx + 1);
for (int i = 1; i <= n; ++i) {
int pos = lx[i] - 'a';
nm[pos]++;
}
tot = (1 << 6) - 1;
for (int i = 1; i <= n; ++i) s[i] = tot;
int m;
scanf("%d", &m);
for (int i = 1, x; i <= m; ++i) {
scanf("%d", &x);
scanf("%s", lx + 1);
int len = strlen(lx + 1);
s[x] = 0;
for (int j = 1; j <= len; ++j) {
int pos = lx[j] - 'a';
s[x] |= (1 << pos);
}
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j <= tot; ++j) {
b[i][j] = b[i + 1][j];
if (s[i] & j) b[i][j]++;
}
}
for (int j = 0; j <= tot; ++j)
for (int i = 0; i < 6; ++i) {
if ((j >> i) & 1) zt[j] += nm[i];
}
for (int i = 1; i <= n; ++i) {
bool flg = false;
for (int j = 0; j < 6; ++j) {
if (nm[j] && ((s[i] >> j) & 1) && check(i + 1, j)) {
flg = true;
nm[j]--;
c[i] = j;
break;
}
}
if (!flg) fail();
for (int j = 0; j <= tot; ++j) {
zt[j] = 0;
for (int k = 0; k < 6; ++k)
if ((j >> k) & 1) zt[j] += nm[k];
}
}
for (int i = 1; i <= n; ++i) {
printf("%c", c[i] + 'a');
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int E = 2 * N;
const int oo = 1e8;
vector<int> g[N];
int ne;
struct Edge {
int from, to;
int flow, cap;
} edge[E];
int lvl[N], vis[N], pass, source = N - 2, target = N - 1, px[N];
int q[N], qt;
int run(int s, int minE) {
if (s == target) return minE;
int ans = 0;
for (; px[s] < (int)g[s].size(); px[s]++) {
int e = g[s][px[s]];
auto &v = edge[e], &rev = edge[e ^ 1];
if (lvl[v.to] != lvl[s] + 1 || v.flow >= v.cap) continue;
int tmp = run(v.to, min(minE, v.cap - v.flow));
v.flow += tmp, rev.flow -= tmp;
ans += tmp, minE -= tmp;
if (minE == 0) break;
}
return ans;
}
int bfs() {
qt = 0;
q[qt++] = source;
lvl[source] = 1;
vis[source] = ++pass;
for (int i = 0; i < qt; i++) {
int u = q[i];
px[u] = 0;
if (u == target) return true;
for (int e : g[u]) {
auto v = edge[e];
if (v.flow >= v.cap || vis[v.to] == pass) continue;
vis[v.to] = pass;
lvl[v.to] = lvl[u] + 1;
q[qt++] = v.to;
}
}
return false;
}
int flow() {
int ans = 0, tmp;
while (bfs()) {
while ((tmp = run(source, oo)) > 0) ans += tmp;
}
return ans;
}
void addEdge(int u, int v, int c) {
edge[ne] = {u, v, 0, c};
g[u].push_back(ne++);
edge[ne] = {v, u, 0, 0};
g[v].push_back(ne++);
}
void reset_flow() {
for (int i = 0; i < ne; i++) edge[i].flow = 0;
}
char s[N];
int m, cnt_letter[300], cnt_bit[1 << 7];
int get_bit() {
int ans = 0;
for (int i = 0; s[i]; i++) ans |= 1 << int(s[i] - 'a');
return ans;
}
int bit[N];
int main() {
int n;
scanf("%s", s);
n = (int)strlen(s);
for (int i = 0; s[i]; i++) cnt_letter[int(s[i] - 'a')]++;
scanf("%d", &m);
for (int i = 0; i < n; i++) bit[i] = (1 << 6) - 1;
for (int i = 0; i < m; i++) {
int pos;
scanf("%d %s", &pos, s);
pos--;
bit[pos] = get_bit();
}
for (int i = 0; i < n; i++) cnt_bit[bit[i]]++;
for (int i = 0; i < 6; i++) {
addEdge(source, i, cnt_letter[i]);
}
for (int i = 0; i < 64; i++) {
addEdge(10 + i, target, cnt_bit[i]);
}
for (int i = 0; i < 6; i++)
if (cnt_letter[i])
for (int j = 0; j < 64; j++)
if (cnt_bit[j])
if ((1 << i) & j) addEdge(i, 10 + j, oo);
if (flow() < n) return printf("Impossible\n"), 0;
for (int i = 0; i < n; i++) {
edge[2 * (6 + bit[i])].cap--;
for (int j = 0; j < 6; j++)
if (bit[i] & (1 << j)) {
if (!edge[2 * j].cap) continue;
edge[2 * j].cap--;
reset_flow();
if (flow() == n - i - 1) {
s[i] = char(j + 'a');
break;
}
edge[2 * j].cap++;
}
}
s[n] = 0;
printf("%s\n", s);
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char s[100001];
char sx[100001];
int sum[1 << 6];
int m;
int setx[100001];
int cnt[6];
char ans[100001];
void read_data() {
scanf(" %s ", s);
n = strlen(s);
cin >> m;
int ix;
for (int i = 0; i < n; i++) setx[i] = (1 << 6) - 1;
for (int k = 0; k < m; k++) {
scanf("%d %s", &ix, sx);
ix--;
setx[ix] = 0;
for (int l = 0; l < strlen(sx); l++) setx[ix] |= 1 << (sx[l] - 'a');
}
}
bool check() {
for (int j = 1; j < (1 << 6); j++)
if (sum[j] > 0) {
int all_cnt = 0;
for (int l = 0; l < 6; l++)
if (j >> l & 1) all_cnt += cnt[l];
if (sum[j] > all_cnt) return false;
}
return true;
}
bool deal() {
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; i++) cnt[s[i] - 'a']++;
memset(sum, 0, sizeof(sum));
for (int i = 0; i < n; i++)
for (int j = 1; j < (1 << 6); j++)
if ((setx[i] & j) == setx[i]) sum[j]++;
if (!check()) return false;
for (int i = 0; i < n; i++) {
for (int j = 1; j < (1 << 6); j++)
if ((setx[i] & j) == setx[i]) sum[j]--;
bool flag = false;
for (int l = 0; l < 6; l++)
if (setx[i] >> l & 1 && cnt[l] > 0) {
cnt[l]--;
if (check()) {
ans[i] = 'a' + l;
flag = true;
break;
}
cnt[l]++;
}
if (!flag) return false;
}
return true;
}
int main() {
read_data();
if (!deal()) {
cout << "Impossible" << endl;
} else {
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long MAX = 1e5 + 5;
long long ava[65];
long long rava[65];
bool iso[MAX][6];
bool inv[MAX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << setprecision(25);
long long a, b, c, d, i, j, k, l;
long long e, f, m;
string s;
cin >> s;
string p;
l = s.size();
cin >> m;
while (m--) {
cin >> a;
a--;
inv[a] = true;
cin >> p;
c = 0;
for (i = 0; i < p.length(); i++) {
b = (long long)(p[i] - 'a');
iso[a][b] = true;
c += 1 << b;
}
for (i = 1; i < 64; i++) {
if ((i & c) > 0) ava[i]++;
}
}
for (i = 0; i < l; i++) {
if (!inv[i]) {
for (j = 1; j < 64; j++) ava[j]++;
for (j = 0; j < 6; j++) iso[i][j] = true;
}
b = (long long)(s[i] - 'a');
for (j = 1; j < 64; j++) {
if ((j & (1 << b)) > 0) rava[j]++;
}
}
for (i = 1; i < 64; i++) {
if (rava[i] > ava[i]) {
cout << "Impossible\n";
return 0;
}
}
char ans[l];
for (i = 0; i < l; i++) {
c = 0;
for (j = 0; j < 6; j++)
if (iso[i][j]) c += 1 << j;
for (j = 0; j < 6; j++) {
if (!iso[i][j]) continue;
bool fl = false;
for (k = 0; k < 64; k++) {
if ((k & (1 << j)) > 0) rava[k]--;
if (k & c) ava[k]--;
if (rava[k] > ava[k]) fl = true;
}
if (!fl) break;
for (k = 0; k < 64; k++) {
if ((k & (1 << j)) > 0) rava[k]++;
if (k & c) ava[k]++;
}
}
ans[i] = (char)('a' + j);
}
for (i = 0; i < l; i++) {
cout << ans[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using uint = unsigned;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
template <typename T>
using vt = std::vector<T>;
using vi = vt<int>;
using vvi = vt<vi>;
using vvvi = vt<vvi>;
using vl = vt<ll>;
using vvl = vt<vl>;
using vvvl = vt<vvl>;
using vb = vt<bool>;
using vpii = vt<pii>;
static inline void Solve();
int main(int argc, char* argv[]) {
;
Solve();
return 0;
}
constexpr int K = 6;
constexpr int CK = 1 << K;
constexpr int ALL = CK - 1;
bool check(int cntCh[K], int cntMsk[CK]) {
int cntChUnion[CK]{};
int cntSubs[CK]{};
for (int i = 0; i < K; i++) {
cntChUnion[1 << i] = cntCh[i];
}
for (int msk = 1; msk < CK; msk++) {
cntChUnion[msk] = cntChUnion[msk & (msk - 1)] + cntChUnion[msk & -msk];
cntSubs[msk] = cntMsk[msk];
}
for (int i = 0; i < K; i++) {
for (int msk = 1; msk < CK; msk++) {
if (msk & (1 << i)) {
cntSubs[msk] += cntSubs[msk ^ (1 << i)];
}
}
}
for (int msk = 1; msk < CK; msk++) {
if (cntChUnion[msk] < cntSubs[msk]) return false;
}
return true;
}
void Solve() {
string s;
cin >> s;
const int n = s.length();
int cntCh[K]{};
for (char c : s) cntCh[c - 'a']++;
vector<int> msks(n, ALL);
int cntMsk[CK]{};
cntMsk[ALL] = n;
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int j;
string t;
cin >> j >> t;
msks[j - 1] = 0;
for (char c : t) msks[j - 1] |= 1 << (c - 'a');
cntMsk[msks[j - 1]]++;
cntMsk[ALL]--;
}
if (!check(cntCh, cntMsk)) {
cout << "Impossible" << endl;
return;
}
string ans;
for (int i = 0; i < n; i++) {
cntMsk[msks[i]]--;
for (int j = 0; j < K; j++) {
if ((msks[i] & (1 << j)) && cntCh[j]) {
cntCh[j] -= 1;
if (check(cntCh, cntMsk)) {
ans.push_back('a' + j);
break;
}
cntCh[j] += 1;
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2,Ofast,inline,unroll-all-loops,-ffast-math")
#pragma GCC target("popcnt")
using namespace std;
int a[100010], b[64], f[64], cnt[6], n, m;
char s[100010];
template <class T>
void read(T &x) {
char ch = x = 0;
bool fl = false;
while (!isdigit(ch)) fl |= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x = fl ? -x : x;
}
bool check() {
memset(f, 0, sizeof(f));
for (int s = 0; s < 64; s++) {
f[63] += b[s], f[63 ^ s] -= b[s];
}
for (int i = 0; i < 6; i++) {
for (int s = 0; s < 64; s++) {
if (~s >> i & 1) f[s] += f[s ^ (1 << i)];
}
}
for (int s = 0; s < 64; s++) {
int tmp = 0;
for (int i = 0; i < 6; i++) {
if (s >> i & 1) tmp += cnt[i];
}
if (f[s] < tmp) return false;
}
return true;
}
int main() {
scanf("%s", s + 1), n = strlen(s + 1), read(m);
for (int i = 1; i <= n; i++) {
cnt[s[i] - 'a']++;
}
for (int i = 1, x; i <= m; i++) {
read(x), a[x] = 0, scanf("%s", s + 1);
for (int j = 1; s[j]; j++) {
a[x] |= 1 << s[j] - 'a';
}
}
for (int i = 1; i <= n; i++) {
b[a[i] = a[i] ? a[i] : 63]++;
}
if (!check()) return puts("Impossible"), 0;
for (int i = 1; i <= n; i++) {
b[a[i]]--;
for (int j = 0; j < 6; j++) {
if (~a[i] >> j & 1) continue;
cnt[j]--;
if (check()) {
putchar('a' + j);
break;
}
cnt[j]++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T>
using vec = vector<T>;
template <class T>
using vvec = vector<vec<T>>;
constexpr int A = 6;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string S;
cin >> S;
int N = S.size();
vec<int> cnt(A);
for (int i = 0; i < A; i++) cnt[i] = count(S.begin(), S.end(), (char)'a' + i);
int M;
cin >> M;
vec<string> T(N, "abcdef");
vec<int> flag(N);
vec<int> restriction(1 << A);
for (int i = 0; i < M; i++) {
int id;
string t;
cin >> id >> t;
sort(t.begin(), t.end());
id--;
T[id] = t;
int X = 0;
for (auto& c : t) X ^= (1 << (c - 'a'));
flag[id] = X;
restriction[X]++;
}
for (int i = 0; i < A; i++) {
for (int X = 0; X < (1 << A); X++)
if (X >> i & 1) restriction[X] += restriction[X ^ (1 << i)];
}
string ans = "";
auto check = [&](char c) {
for (int X = 0; X < (1 << A); X++) {
int c0 = 0;
for (int i = 0; i < A; i++)
if (X >> i & 1) {
c0 += cnt[i];
}
if (X >> (c - 'a') & 1) c0--;
if (c0 < restriction[X]) return false;
}
return true;
};
for (int i = 0; i < N; i++) {
bool ok = false;
if (flag[i])
for (int X = 0; X < (1 << A); X++)
if ((flag[i] & X) == flag[i]) restriction[X]--;
for (auto& c : T[i])
if (cnt[c - 'a']) {
if (check(c)) {
ok = true;
ans += c;
cnt[c - 'a']--;
break;
}
}
if (!ok) {
cout << "Impossible\n";
return 0;
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(1e5) + 100;
int n, m;
int sett[maxn];
int idx[1 << 6];
int cnt[6], sum[1 << 6];
char st[maxn], ans[maxn];
void read() {
scanf("%s", st);
n = strlen(st);
for (int i = 0; i < n; ++i) ++cnt[st[i] - 'a'];
for (int i = 1; i <= n; ++i) sett[i] = (1 << 6) - 1;
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
int idx;
scanf("%d %s", &idx, st);
sett[idx] = 0;
for (int j = 0; j < strlen(st); ++j) sett[idx] |= (1 << (st[j] - 'a'));
}
}
bool check() {
for (int i = 1; i < 1 << 6; ++i) {
int s = 0;
for (int j = 0; j < 6; ++j)
if (i >> j & 1) s += cnt[j];
if (sum[i] > s) return false;
}
return true;
}
void solve() {
for (int i = 0; i < 6; ++i) idx[1 << i] = i;
for (int i = 1; i <= n; ++i)
for (int j = 0; j < 1 << 6; ++j)
if ((sett[i] & j) == sett[i]) ++sum[j];
for (int i = 1; i <= n; ++i) {
bool flag = false;
for (int j = 0; j < 1 << 6; ++j)
if ((sett[i] & j) == sett[i]) --sum[j];
for (int j = 0; j < 6; ++j)
if ((sett[i] >> j & 1) && cnt[j]) {
--cnt[j];
if (check()) {
flag = true;
ans[i] = 'a' + j;
break;
}
++cnt[j];
}
if (!flag) {
puts("Impossible");
return;
}
}
puts(ans + 1);
}
int main() {
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[100002];
int n;
bitset<100002> mask[64];
int lef[64], rig[64];
bool li[100002];
char ans[100002];
void no() {
puts("Impossible");
exit(0);
}
int main() {
scanf("%s", str);
n = strlen(str);
for (int i = 0; i < n; ++i) {
int c = str[i] - 'a';
lef[1 << c]++;
}
int m;
scanf("%d", &m);
while (m--) {
int p;
scanf("%d", &p);
--p;
li[p] = 1;
char t[10];
scanf("%s", t);
int lt = strlen(t);
for (int i = 0; i < lt; ++i) {
int c = t[i] - 'a';
mask[1 << c][p] = 1;
}
}
for (int i = 0; i < n; ++i)
if (!li[i])
for (int j = 1; j < 64; ++j) mask[j][i] = 1;
for (int s = 1; s < 64; ++s) {
for (int i = 0; i < 6; ++i)
if ((s >> i & 1) && (s != (1 << i))) {
lef[s] += lef[1 << i];
mask[s] |= mask[1 << i];
}
rig[s] = mask[s].count();
if (lef[s] > rig[s]) no();
}
int sta = 63;
for (int s = 0; s < 64; ++s)
if (lef[s] == rig[s] && mask[s][0]) sta &= s;
for (int i = 0; i < n; ++i) {
bool ok = 0;
int x;
for (int c = 0; c < 6; ++c)
if ((sta >> c & 1) && lef[1 << c] && mask[1 << c][i]) {
ans[i] = (char)('a' + c);
x = c;
ok = 1;
break;
}
if (!ok) no();
sta = 63;
for (int s = 0; s < 64; ++s) {
if (s >> x & 1) --lef[s];
if (mask[s][i]) --rig[s];
if (lef[s] == rig[s] && mask[s][i + 1]) sta &= s;
}
}
printf("%s\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int edges[N];
int cnt[1 << 6];
int f[N][1 << 6];
int main() {
string str;
cin >> str;
int n = str.size();
for (int i = 0; i < n; i += 1) {
for (int j = 0; j < (1 << 6); j += 1) {
if (j & (1 << (str[i] - 'a'))) cnt[j] += 1;
}
edges[i] = (1 << 6) - 1;
}
int m;
cin >> m;
for (int i = 0; i < m; i += 1) {
int p;
string pos;
cin >> p >> pos;
p -= 1;
edges[p] = 0;
for (int j = 0; j < pos.size(); j += 1) {
edges[p] |= 1 << (pos[j] - 'a');
}
}
for (int i = n - 1; i >= 0; i -= 1) {
for (int j = 0; j < (1 << 6); j += 1) {
f[i][j] = f[i + 1][j];
if ((edges[i] & j) == edges[i]) f[i][j] += 1;
}
}
string ans(n, '0');
for (int i = 0; i < n; i += 1) {
bool find = false;
for (int j = 0; j < 6 && !find; j += 1) {
if ((1 << j) & edges[i]) {
bool flag = true;
for (int k = 0; k < (1 << 6) && flag; k += 1) {
if (f[i + 1][k] > cnt[k] - ((k >> j) & 1)) {
flag = false;
}
}
if (flag) {
find = true;
ans[i] = 'a' + j;
for (int k = 0; k < (1 << 6); k += 1) cnt[k] -= (k >> j) & 1;
}
}
}
if (!find) {
cout << "Impossible" << endl;
return 0;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int y;
int c;
int f;
edge(){};
edge(int y, int c, int f) : y(y), c(c), f(f){};
};
const int N = 100;
vector<edge> e;
vector<int> g[N];
int edge_num[N][N];
int char_vertex[6];
int mask_vertex[N];
int used[N];
int cc = 0;
int s, t;
void add_edge(int x, int y, int c) {
edge_num[x][y] = ((int)(e).size());
g[x].push_back(((int)(e).size()));
e.push_back(edge(y, c, 0));
edge_num[y][x] = ((int)(e).size());
g[y].push_back(((int)(e).size()));
e.push_back(edge(x, 0, 0));
}
int rem(int num) { return e[num].c - e[num].f; }
int dfs(int x, int mx) {
if (x == t) return mx;
if (used[x] == cc) return 0;
used[x] = cc;
for (auto num : g[x]) {
if (rem(num)) {
int pushed = dfs(e[num].y, min(mx, rem(num)));
if (pushed) {
e[num].f += pushed;
e[num ^ 1].f -= pushed;
return pushed;
}
}
}
return 0;
}
bool check(int ch, int mask) {
if ((mask & (1 << ch)) == 0) return false;
int cv = char_vertex[ch];
int mv = mask_vertex[mask];
int e1 = edge_num[s][cv];
int e2 = edge_num[mv][t];
if (e[e1].f == 0 || e[e2].f == 0) return false;
e[e1].f--;
e[e1 ^ 1].f++;
vector<int> affected_edges;
affected_edges.push_back(e1);
for (auto x : g[cv]) {
if ((x & 1) == 0 && e[x].f > 0) {
affected_edges.push_back(x);
e[x].f--;
e[x ^ 1].f++;
int y = e[x].y;
for (auto x2 : g[y]) {
if ((x2 & 1) == 0) {
affected_edges.push_back(x2);
e[x2].f--;
e[x2 ^ 1].f++;
break;
}
}
break;
}
}
if (e[e2].f < e[e2].c) {
e[e1].c--;
e[e2].c--;
return true;
}
affected_edges.push_back(e2);
e[e2].f--;
e[e2 ^ 1].f++;
for (auto x : g[mv]) {
if ((x & 1) == 1 && e[x].f < 0) {
affected_edges.push_back(x ^ 1);
e[x].f++;
e[x ^ 1].f--;
int y = e[x].y;
for (auto x2 : g[y]) {
if ((x2 & 1) == 1) {
affected_edges.push_back(x2 ^ 1);
e[x2].f++;
e[x2 ^ 1].f--;
break;
}
}
break;
}
}
cc++;
e[e1].c--;
e[e2].c--;
if (dfs(s, 1))
return true;
else {
e[e1].c++;
e[e2].c++;
for (auto x : affected_edges) {
e[x].f++;
e[x ^ 1].f--;
}
return false;
}
}
char buf[100043];
string allowed[100043];
int allowed_mask[100043];
int main() {
s = 70;
t = 71;
scanf("%s", buf);
string z = buf;
int n = ((int)(z).size());
int m;
scanf("%d", &m);
for (int i = 0; i < n; i++) {
allowed[i] = "abcdef";
allowed_mask[i] = 63;
}
for (int i = 0; i < m; i++) {
int idx;
scanf("%d", &idx);
--idx;
scanf("%s", buf);
allowed[idx] = buf;
allowed_mask[idx] = 0;
for (auto x : allowed[idx]) {
allowed_mask[idx] |= (1 << (x - 'a'));
}
}
for (int i = 0; i < 6; i++) char_vertex[i] = i;
for (int i = 0; i < (1 << 6); i++) mask_vertex[i] = i + 6;
for (int i = 0; i < (1 << 6); i++)
for (int j = 0; j < 6; j++)
if (i & (1 << j)) add_edge(char_vertex[j], mask_vertex[i], 100000);
for (int i = 0; i < 6; i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (z[j] == 'a' + i) cnt++;
add_edge(s, char_vertex[i], cnt);
}
for (int i = 0; i < (1 << 6); i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (allowed_mask[j] == i) cnt++;
add_edge(mask_vertex[i], t, cnt);
}
int flow = 0;
while (true) {
cc++;
int p = dfs(s, 100000);
if (p)
flow += p;
else
break;
}
if (flow != n) {
puts("Impossible");
return 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < 6; j++) {
if (check(j, allowed_mask[i])) {
printf("%c", j + 'a');
break;
}
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
char ch = getchar();
long long x = 0;
int op = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') op = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
return x * op;
}
int n, m, a[100005], b[100005][70], tmp[70], cnt[70];
char s[100005], s2[100005], ans[100005];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
m = read();
while (m--) {
int k = read(), l;
scanf("%s", s2 + 1);
l = strlen(s2 + 1);
for (int i = (1); i <= (l); i++) a[k] |= 1 << s2[i] - 'a';
}
for (int i = (1); i <= (n); i++)
if (!a[i]) a[i] = (1 << 6) - 1;
for (int i = (1); i <= (n); i++) {
int x = s[i] - 'a';
for (int j = (0); j <= ((1 << 6) - 1); j++)
if (j >> x & 1) cnt[j]++;
}
for (int i = (n); i >= (1); i--)
for (int j = (0); j <= ((1 << 6) - 1); j++) {
if ((j & a[i]) == a[i]) tmp[j]++;
b[i][j] = tmp[j];
}
for (int p = (1); p <= (n - 1); p++) {
bool flag = 0;
for (int i = (0); i <= (5); i++)
if (cnt[1 << i] && (a[p] >> i & 1)) {
bool chk = 1;
for (int j = (0); j <= ((1 << 6) - 1); j++)
if (cnt[j] - (j >> i & 1) < b[p + 1][j]) {
chk = 0;
break;
}
if (chk) {
flag = 1;
ans[p] = i + 'a';
for (int j = (0); j <= ((1 << 6) - 1); j++)
if (j >> i & 1) cnt[j]--;
}
}
if (!flag) {
puts("Impossible");
exit(0);
}
}
bool flag = 0;
for (int i = (0); i <= (5); i++)
if (cnt[1 << i] && (a[n] >> i & 1)) {
flag = 1;
ans[n] = i + 'a';
break;
}
if (!flag) {
puts("Impossible");
exit(0);
}
ans[n + 1] = '\0';
puts(ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 100010;
const long long E = 6;
const long long E2 = 1 << E;
long long n, m, masks[maxn], cnt[E];
string name, res;
struct Hall {
long long S[E2], NS[E2], brk;
void updateA(long long e, long long d) {
for (long long b = 0; b < E2; ++b) {
if (b >> e & 1) {
brk -= NS[b] < S[b];
S[b] += d;
brk += NS[b] < S[b];
}
}
}
void updateNA(long long mask, long long d) {
for (long long b = 0; b < E2; ++b) {
if (b & mask) {
brk -= NS[b] < S[b];
NS[b] += d;
brk += NS[b] < S[b];
}
}
}
bool sat() { return brk == 0; }
} hall;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> name;
n = name.size();
res = string(n, '?');
fill(masks, masks + n, E2 - 1);
cin >> m;
for (long long i = 0; i < m; ++i) {
string es;
long long idx;
cin >> idx >> es;
--idx;
masks[idx] = 0;
for (auto e : es) {
masks[idx] ^= 1 << (e - 'a');
}
}
for (long long i = 0; i < n; ++i) {
cnt[name[i] - 'a']++;
hall.updateA(name[i] - 'a', 1);
hall.updateNA(masks[i], 1);
}
for (long long i = 0; i < n; ++i) {
long long r = E;
hall.updateNA(masks[i], -1);
for (long long e = 0; e < E; ++e)
if ((masks[i] >> e & 1) && cnt[e]) {
hall.updateA(e, -1);
if (hall.sat()) {
r = e;
break;
}
hall.updateA(e, 1);
}
if (r == E) return cout << "Impossible\n", 0;
cnt[r]--;
res[i] = r + 'a';
}
cout << res << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int S[100008], cnt[1 << 7], num[1 << 7];
char s[100008];
int len, n, nu;
inline long long rd() {
long long x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f ? -x : x;
}
int main() {
int ooo = 0;
scanf("%s", s + 1);
len = strlen(s + 1);
int x;
int maxn = (1 << 6) - 1;
for (int i = 1; i <= len; ++i) {
int x = s[i] - 'a';
for (int j = 1; j <= maxn; ++j)
if (j & (1 << x)) cnt[j]++;
}
n = rd();
for (int i = 1; i <= n; ++i) {
x = rd();
scanf("%s", s + 1);
int xx = strlen(s + 1);
for (int j = 1; j <= xx; ++j) S[x] |= (1 << (s[j] - 'a'));
for (int j = 1; j <= maxn; ++j)
if ((j & S[x]) == S[x]) num[j]++;
}
for (int i = 1; i <= len; ++i)
if (!S[i]) {
S[i] = maxn;
num[S[i]]++;
}
for (int i = 1; i <= len; ++i) {
bool tag = 0;
for (int j = 0; j < 6; ++j)
if ((1 << j) & S[i]) {
bool tg = 0;
for (int k = 1; k <= maxn; ++k) {
int x = (k & (1 << j)) ? cnt[k] - 1 : cnt[k],
y = ((k & S[i]) == S[i]) ? num[k] - 1 : num[k];
if (x < y) {
tg = 1;
break;
}
}
if (!tg) {
tag = 1;
s[++nu] = j + 'a';
for (int k = 1; k <= maxn; ++k) {
if ((1 << j) & k) cnt[k]--;
if ((S[i] & k) == S[i]) num[k]--;
}
break;
}
}
if (!tag) {
puts("Impossible");
return 0;
}
}
for (int i = 1; i <= nu; ++i) printf("%c", s[i]);
int yyy = 0, zzz = 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long tot = 1;
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
tot = -1;
c = getchar();
}
long long sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum * tot;
}
inline void wr(long long x) {
if (x < 0) {
putchar('-');
wr(-x);
return;
}
if (x >= 10) wr(x / 10);
putchar(x % 10 + '0');
}
inline void wrn(long long x) {
wr(x);
putchar('\n');
}
inline void wri(long long x) {
wr(x);
putchar(' ');
}
inline void wrn(long long x, long long y) {
wri(x);
wrn(y);
}
inline void wrn(long long a, long long b, long long c) {
wri(a);
wrn(b, c);
}
long long op, k, n, m, f[200005], g[200005], tong[10], num[200005], sum[100],
ans[200005];
char str[200005], str1[200005];
long long check() {
for (long long i = (1); i <= ((1 << 6) - 1); i++) {
g[i] = 0;
f[i] = sum[i];
for (long long j = (0); j <= (5); j++) {
if ((i >> j) & 1) g[i] += tong[j];
}
}
for (long long i = (0); i <= (5); i++) {
for (long long j = (0); j <= ((1 << 6) - 1); j++) {
if ((j >> i) & 1) f[j] += f[j ^ (1 << i)];
}
}
for (long long i = (1); i <= ((1 << 6) - 1); i++) {
if (f[i] > g[i]) return 0;
}
return 1;
}
signed main() {
scanf("%s", str + 1);
n = strlen(str + 1);
for (long long i = (1); i <= (n); i++) {
tong[str[i] - 'a']++;
num[i] = (1 << 6) - 1;
}
m = read();
for (long long i = (1); i <= (m); i++) {
num[op = read()] = 0;
scanf("%s", str1 + 1);
k = strlen(str1 + 1);
for (long long j = (1); j <= (k); j++) num[op] |= (1 << (str1[j] - 'a'));
}
for (long long i = (1); i <= (n); i++) sum[num[i]]++;
if (!check()) {
puts("Impossible");
return 0;
}
for (long long i = (1); i <= (n); i++) {
sum[num[i]]--;
for (long long j = (0); j <= (5); j++) {
if ((num[i] >> j) & 1) {
tong[j]--;
if (check()) {
ans[i] = j;
break;
}
tong[j]++;
}
}
}
for (long long i = (1); i <= (n); i++) putchar('a' + ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e18;
const int N = 100005;
const int E = 2000006;
vector<int> g[N];
int ne;
struct Edge {
int from, to;
long long flow, cap;
} edge[E];
int lvl[N], vis[N], pass, start = N - 2, target = N - 1;
int qu[N], qt, px[N];
long long run(int s, int sink, long long minE) {
if (s == sink) return minE;
long long ans = 0;
for (; px[s] < (int)g[s].size(); px[s]++) {
int e = g[s][px[s]];
auto &v = edge[e], &rev = edge[e ^ 1];
if (lvl[v.to] != lvl[s] + 1 || v.flow >= v.cap) continue;
long long tmp = run(v.to, sink, min(minE, v.cap - v.flow));
v.flow += tmp, rev.flow -= tmp;
ans += tmp, minE -= tmp;
if (minE == 0) break;
}
return ans;
}
bool bfs(int source, int sink) {
qt = 0;
qu[qt++] = source;
lvl[source] = 1;
vis[source] = ++pass;
for (int i = 0; i < qt; i++) {
int u = qu[i];
px[u] = 0;
if (u == sink) return true;
for (int e : g[u]) {
auto v = edge[e];
if (v.flow >= v.cap || vis[v.to] == pass) continue;
vis[v.to] = pass;
lvl[v.to] = lvl[u] + 1;
qu[qt++] = v.to;
}
}
return false;
}
long long flow(int source = start, int sink = target) {
long long ans = 0;
while (bfs(source, sink)) ans += run(source, sink, oo);
return ans;
}
void addEdge(int u, int v, long long c = 1, long long rc = 0) {
edge[ne] = {u, v, 0, c};
g[u].push_back(ne++);
edge[ne] = {v, u, 0, rc};
g[v].push_back(ne++);
}
void reset_flow() {
for (int i = 0; i < ne; i++) edge[i].flow = 0;
}
char s[N];
int m, cnt_letter[300], cnt_bit[1 << 7];
int get_bit() {
int ans = 0;
for (int i = 0; s[i]; i++) ans |= 1 << int(s[i] - 'a');
return ans;
}
int bit[N];
int main() {
int n;
scanf("%s", s);
n = (int)strlen(s);
for (int i = 0; s[i]; i++) cnt_letter[int(s[i] - 'a')]++;
scanf("%d", &m);
for (int i = 0; i < n; i++) bit[i] = (1 << 6) - 1;
for (int i = 0, pos; i < m; i++) {
scanf("%d %s", &pos, s);
bit[pos - 1] = get_bit();
}
for (int i = 0; i < n; i++) cnt_bit[bit[i]]++;
for (int i = 0; i < 6; i++) {
addEdge(start, i, cnt_letter[i]);
}
for (int i = 0; i < 64; i++) {
addEdge(10 + i, target, cnt_bit[i]);
}
for (int i = 0; i < 6; i++)
if (cnt_letter[i])
for (int j = 0; j < 64; j++)
if (cnt_bit[j])
if ((1 << i) & j) addEdge(i, 10 + j, oo);
if (flow() < n) return printf("Impossible\n"), 0;
for (int i = 0; i < n; i++) {
edge[2 * (6 + bit[i])].cap--;
for (int j = 0; j < 6; j++)
if (bit[i] & (1 << j)) {
if (!edge[2 * j].cap) continue;
edge[2 * j].cap--;
reset_flow();
if (flow() == n - i - 1) {
s[i] = char(j + 'a');
break;
}
edge[2 * j].cap++;
}
}
s[n] = 0;
printf("%s\n", s);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int S = (1 << 6);
const int INF = 0x3f3f3f3f;
template <typename T>
inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
char s[MAXN];
int n, m, cnt[10], lim[MAXN], sub[MAXN][S];
int sum[S], id[S], ans[MAXN];
void init() {
for (int i = 0; i < 6; ++i) {
id[1 << i] = i;
}
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) {
++cnt[s[i] - 'a'];
lim[i] = S - 1;
}
read(m);
for (int i = 1; i <= m; ++i) {
int x;
read(x);
lim[x] = 0;
scanf("%s", s + 1);
int k = strlen(s + 1);
for (int j = 1; j <= k; ++j) {
lim[x] |= (1 << (s[j] - 'a'));
}
}
}
void solve() {
for (int i = n; i >= 1; --i) {
for (int j = 1; j < S; ++j) {
sub[i][j] = sub[i + 1][j] + ((lim[i] & j) == lim[i]);
}
}
for (int i = 1; i <= n; ++i) {
ans[i] = -1;
for (int j = 0; j < 6; ++j) {
if (!((lim[i] >> j) & 1)) continue;
if (!cnt[j]) continue;
--cnt[j];
bool ok = 1;
for (int s = 1; s < S && ok; ++s) {
int t = (s & (-s));
sum[s] = sum[s ^ t] + cnt[id[t]];
if (sum[s] < sub[i + 1][s]) ok = 0;
}
if (ok) {
ans[i] = j;
break;
}
++cnt[j];
}
if (ans[i] == -1) {
puts("Impossible");
return;
}
}
for (int i = 1; i <= n; ++i) {
putchar(ans[i] + 'a');
}
puts("");
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using maxHeap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
using minHeap = priority_queue<T, vector<T>, greater<T>>;
template <typename Iter>
ostream& _out(ostream& s, Iter b, Iter e) {
s << "[";
for (auto it = b; it != e; it++) s << (it == b ? "" : " ") << *it;
s << "]";
return s;
}
template <typename A, typename B>
ostream& operator<<(ostream& s, const pair<A, B>& p) {
return s << "(" << p.first << "," << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, const vector<T>& c) {
return _out(s, begin(c), end(c));
}
bool debug = 0;
template <typename T>
void DEBUG(const T& x) {
if (debug) cerr << x;
}
template <typename T, typename... Args>
void DEBUG(const T& head, const Args&... tail) {
if (debug) {
cerr << head;
DEBUG(tail...);
}
}
const int N = 100000 + 5;
inline int two(int x) { return 1 << x; }
inline int Uni(int a, int b) { return a | b; }
inline int Inter(int a, int b) { return a & b; }
inline bool inS(int a, int b) { return (b >> a) & 1; }
int able[N], cnt[6], type_cnt[64];
inline bool hall_theorem() {
for (int i = 0; i < 64; i++) {
int ngx = 0;
for (int j = 0; j < 64; j++) {
if (Inter(i, j) == 0) continue;
ngx += type_cnt[j];
}
int x = 0;
for (int j = 0; j < 6; j++)
if (inS(j, i)) x += cnt[j];
if (x > ngx) return false;
}
return true;
}
int main(int argc, char* argv[]) {
if (argc > 1 and string(argv[1]) == "-D") debug = 1;
if (!debug) {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
string ss;
cin >> ss;
for (auto c : ss) cnt[c - 'a']++;
int n = (int)((ss).size());
fill_n(able, n, 63);
int m;
cin >> m;
while (m--) {
int p;
cin >> p;
string s;
cin >> s;
able[--p] = 0;
for (auto c : s) able[p] |= two(c - 'a');
}
for (int i = 0; i < n; i++) type_cnt[able[i]]++;
string ans = "";
for (int i = 0; i < n; i++) {
bool done = false;
for (int c = 0; c < 6; c++) {
if (!inS(c, able[i])) continue;
if (cnt[c] == 0) continue;
cnt[c]--;
type_cnt[able[i]]--;
if (hall_theorem()) {
done = true;
ans += char(c + 'a');
break;
}
cnt[c]++;
type_cnt[able[i]]++;
}
if (done) continue;
cout << "Impossible\n";
return 0;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const int bign = 100033;
const int bigm = 27 * bign;
char str[bign];
int n, m;
int cnt[67];
int mtotal[67];
int tcnt[67];
int ttotal[67];
int vst[bign];
int mark[67][bign];
int mcap[bign][6];
int mymap[bign][6];
int nowu;
inline void addEdge(int u, int v, int mflow) {}
int main() {
scanf("%s", str);
n = strlen(str);
for (int i = 0; i < n; i++) {
cnt[1 << (str[i] - 'a')]++;
}
for (int i = 1; i < 64; i++)
for (int j = 1; j <= i; j <<= 1) {
if ((i & j) && i > j) cnt[i] += cnt[j];
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int pos;
scanf("%d", &pos);
pos--;
vst[pos] = 1;
scanf("%s", str);
for (int j = 0; j < strlen(str); j++) {
int xid = str[j] - 'a';
mymap[pos][xid] = 1;
}
}
for (int i = 0; i < n; i++) {
if (!vst[i]) {
for (int j = 0; j < 6; j++) {
mymap[i][j] = 1;
}
}
}
bool flag = true;
for (int i = 1; i < 64; i++) {
for (int k = 0; k < n; k++) {
bool tflag = true;
for (int j = 1, j1 = 0; j1 < 6; j <<= 1, j1++) {
if (mymap[k][j1] && !(j & i)) {
tflag = false;
break;
}
}
if (tflag) {
mark[i][k] = 1;
mtotal[i]++;
}
}
if (mtotal[i] > cnt[i]) {
flag = false;
break;
}
}
if (!flag) {
printf("Impossible\n");
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 6; j++) {
if (cnt[1 << j] > 0 && mymap[i][j]) {
bool tflag = true;
memcpy(tcnt, cnt, sizeof(cnt));
memcpy(ttotal, mtotal, sizeof(cnt));
for (int k = 1; k < 64; k++) {
if (k & (1 << j)) {
cnt[k]--;
}
if (mark[k][i]) {
mtotal[k]--;
}
if (cnt[k] < mtotal[k]) {
tflag = false;
break;
}
}
if (tflag) {
putchar('a' + j);
break;
} else {
memcpy(cnt, tcnt, sizeof(cnt));
memcpy(mtotal, ttotal, sizeof(ttotal));
}
}
}
}
putchar('\n');
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e5 + 10;
int a[MAXN], m, can[MAXN];
string s;
int dp[MAXN][1 << 6], cnt[6];
bool check(int index) {
for (int mask = 0; mask < 1 << 6; ++mask) {
int have = 0;
for (int i = 0; i < 6; ++i) {
if ((mask >> i) & 1) {
have += cnt[i];
}
}
if (have < dp[index][mask]) {
return false;
}
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin >> s;
int n = s.length();
for (int i = 0; i < s.length(); ++i) a[i + 1] = s[i] - 'a', cnt[a[i + 1]]++;
cin >> m;
for (int i = 1; i <= m; ++i) {
int pos;
string s;
cin >> pos >> s;
for (int j = 0; j < s.length(); ++j) {
can[pos] |= 1 << (s[j] - 'a');
}
}
for (int i = 1; i <= n; ++i)
if (!can[i]) can[i] = (1 << 6) - 1;
for (int i = n; i >= 1; --i) {
for (int mask = 0; mask < 1 << 6; ++mask) {
dp[i][mask] = max(dp[i][mask], dp[i + 1][mask]);
dp[i][mask | can[i]] = max(dp[i][mask | can[i]], dp[i + 1][mask] + 1);
}
}
string rest = "";
if (!check(1)) {
cout << "Impossible\n";
return 0;
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 6; ++j) {
if ((can[i] >> j) & 1)
if (cnt[j]) {
cnt[j]--;
if (!check(i + 1)) {
cnt[j]++;
} else {
rest += char('a' + j);
break;
}
}
}
}
cout << rest << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, k, w;
char s[100005];
int freq[15];
int edge[100005][10];
int cnt[100005][66];
int check(int x) {
int tmp = 0;
for (int i = (0); i < (64); i++) {
tmp = 0;
for (int k = (0); k < (6); k++)
if ((i & (1 << k)) > 0) tmp += freq[k];
int have = cnt[n - 1][i] - cnt[x - 1][i];
if (have < tmp) return 0;
}
return 1;
}
int ok;
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = (0); i < (n); i++) freq[s[i] - 'a']++;
scanf("%d", &k);
for (int i = (0); i < (k); i++) {
scanf("%d", &x);
scanf("%s", s);
m = strlen(s);
for (int j = (0); j < (m); j++) edge[x - 1][s[j] - 'a'] = 1;
}
for (int i = (0); i < (n); i++) {
x = 0;
for (int j = (0); j < (6); j++) x += edge[i][j];
if (x == 0)
for (int j = (0); j < (6); j++) edge[i][j] = 1;
}
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (64); j++) {
x = 0;
for (int k = (0); k < (6); k++) {
if ((j & (1 << k)) == 0) continue;
if (edge[i][k] == 1) x = 1;
}
cnt[i][j] += x;
if (i > 0) cnt[i][j] += cnt[i - 1][j];
}
}
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (6); j++)
if (edge[i][j] == 1) {
freq[j]--;
if (check(i + 1)) {
ok = 1;
printf("%c", 'a' + j);
break;
}
freq[j]++;
}
if (ok == 0) {
puts("Impossible");
return 0;
}
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100005], b[100005][70], t[70], cnt[70];
char s[100005], s2[100005], ans[100005];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
scanf("%d", &m);
while (m--) {
int k, l;
scanf("%d%s", &k, s2 + 1);
l = strlen(s2 + 1);
for (int i = 1; i <= l; i++) a[k] |= 1 << (s2[i] - 'a');
}
for (int i = 1; i <= n; i++)
if (!a[i]) a[i] = (1 << 6) - 1;
for (int i = 1; i <= n; i++) {
int x = s[i] - 'a';
for (int j = 0; j < (1 << 6); j++)
if (j >> x & 1) cnt[j]++;
}
for (int i = n; i >= 1; i--)
for (int j = 0; j < (1 << 6); j++) {
if ((j & a[i]) == a[i]) t[j]++;
b[i][j] = t[j];
}
for (int p = 1; p < n; p++) {
bool f = 0;
for (int i = 0; i <= 5; i++)
if (cnt[1 << i] && (a[p] >> i & 1)) {
bool ff = 1;
for (int j = 0; j < (1 << 6); j++)
if (cnt[j] - (j >> i & 1) < b[p + 1][j]) {
ff = 0;
break;
}
if (ff) {
f = 1;
ans[p] = 'a' + i;
for (int j = 0; j < (1 << 6); j++)
if (j >> i & 1) cnt[j]--;
}
}
if (!f) {
puts("Impossible");
return 0;
}
}
bool f = 0;
for (int i = 0; i <= 5; i++)
if (cnt[1 << i] && (a[n] >> i & 1)) {
f = 1;
ans[n] = 'a' + i;
break;
}
if (!f) {
puts("Impossible");
return 0;
}
ans[n + 1] = '\0';
puts(ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int y;
int c;
int f;
edge(){};
edge(int y, int c, int f) : y(y), c(c), f(f){};
};
const int N = 100;
vector<edge> e;
vector<int> g[N];
int edge_num[N][N];
int char_vertex[6];
int mask_vertex[N];
int used[N];
int cc = 0;
int s, t;
void add_edge(int x, int y, int c) {
edge_num[x][y] = ((int)(e).size());
g[x].push_back(((int)(e).size()));
e.push_back(edge(y, c, 0));
edge_num[y][x] = ((int)(e).size());
g[y].push_back(((int)(e).size()));
e.push_back(edge(x, 0, 0));
}
int rem(int num) { return e[num].c - e[num].f; }
int dfs(int x, int mx) {
if (x == t) return mx;
if (used[x] == cc) return 0;
used[x] = cc;
for (auto num : g[x]) {
if (rem(num)) {
int pushed = dfs(e[num].y, min(mx, rem(num)));
if (pushed) {
e[num].f += pushed;
e[num ^ 1].f -= pushed;
return pushed;
}
}
}
return 0;
}
bool check(int ch, int mask) {
if ((mask & (1 << ch)) == 0) return false;
int cv = char_vertex[ch];
int mv = mask_vertex[mask];
int e1 = edge_num[s][cv];
int e2 = edge_num[mv][t];
if (e[e1].f == 0 || e[e2].f == 0) return false;
e[e1].f--;
e[e1 ^ 1].f++;
vector<int> affected_edges;
affected_edges.push_back(e1);
for (auto x : g[cv]) {
if ((x & 1) == 0 && e[x].f > 0) {
affected_edges.push_back(x);
e[x].f--;
e[x ^ 1].f++;
int y = e[x].y;
for (auto x2 : g[y]) {
if ((x2 & 1) == 0) {
affected_edges.push_back(x2);
e[x2].f--;
e[x2 ^ 1].f++;
break;
}
}
break;
}
}
if (e[e2].f < e[e2].c) {
e[e1].c--;
e[e2].c--;
return true;
}
affected_edges.push_back(e2);
e[e2].f--;
e[e2 ^ 1].f++;
for (auto x : g[mv]) {
if ((x & 1) == 1 && e[x].f < 0) {
affected_edges.push_back(x ^ 1);
e[x].f++;
e[x ^ 1].f--;
int y = e[x].y;
for (auto x2 : g[y]) {
if ((x2 & 1) == 1) {
affected_edges.push_back(x2 ^ 1);
e[x2].f++;
e[x2 ^ 1].f--;
break;
}
}
break;
}
}
cc++;
e[e1].c--;
e[e2].c--;
if (dfs(s, 1))
return true;
else {
e[e1].c++;
e[e2].c++;
for (auto x : affected_edges) {
e[x].f++;
e[x ^ 1].f--;
}
return false;
}
}
char buf[100043];
string allowed[100043];
int allowed_mask[100043];
int main() {
s = 70;
t = 71;
scanf("%s", buf);
string z = buf;
int n = ((int)(z).size());
int m;
scanf("%d", &m);
for (int i = 0; i < n; i++) {
allowed[i] = "abcdef";
allowed_mask[i] = 63;
}
for (int i = 0; i < m; i++) {
int idx;
scanf("%d", &idx);
--idx;
scanf("%s", buf);
allowed[idx] = buf;
allowed_mask[idx] = 0;
for (auto x : allowed[idx]) {
allowed_mask[idx] |= (1 << (x - 'a'));
}
}
for (int i = 0; i < 6; i++) char_vertex[i] = i;
for (int i = 0; i < (1 << 6); i++) mask_vertex[i] = i + 6;
for (int i = 0; i < (1 << 6); i++)
for (int j = 0; j < 6; j++)
if (i & (1 << j)) add_edge(char_vertex[j], mask_vertex[i], 100000);
for (int i = 0; i < 6; i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (z[j] == 'a' + i) cnt++;
add_edge(s, char_vertex[i], cnt);
}
for (int i = 0; i < (1 << 6); i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (allowed_mask[j] == i) cnt++;
add_edge(mask_vertex[i], t, cnt);
}
int flow = 0;
while (true) {
cc++;
int p = dfs(s, 100000);
if (p)
flow += p;
else
break;
}
if (flow != n) {
puts("Impossible");
return 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < 6; j++) {
if (check(j, allowed_mask[i])) {
printf("%c", j + 'a');
break;
}
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int A = 6;
const int P = 1 << A;
int bit(int mask, int k) { return (mask >> k) & 1; }
void mask_print(int mask, int n = A) {
for (int i = 0; i < n; ++i) printf("%d", bit(mask, i));
}
int c[A];
int cnt[P];
int f[P], g[P];
bool check() {
for (int i = 0; i < P; ++i) f[i] = cnt[i];
for (int i = 0; i < P; ++i) {
f[i] = 0;
for (int j = i; j; j = (j - 1) & i) f[i] += cnt[j];
}
g[0] = 0;
for (int i = 1; i < P; ++i) {
int b = 31 - __builtin_clz(i);
g[i] = g[i ^ (1 << b)] + c[b];
if (g[i] < f[i]) return false;
}
return true;
}
const int N = (int)1e5 + 5;
char str[N], t[A + 1];
int mask[N];
int main() {
scanf("%s", str);
int n = strlen(str);
memset(c, 0, sizeof(c));
for (int i = 0; i < n; ++i) c[str[i] - 'a']++;
int m;
scanf("%d", &m);
while (m--) {
int pos;
scanf("%d %s", &pos, t);
--pos;
mask[pos] = 0;
int szt = strlen(t);
for (int i = 0; i < szt; ++i) mask[pos] |= 1 << (t[i] - 'a');
++cnt[mask[pos]];
}
if (!check()) {
printf("Impossible\n");
return 0;
}
for (int i = 0; i < n; ++i) {
if (!mask[i]) {
mask[i] = P - 1;
} else {
--cnt[mask[i]];
}
for (int ch = 0; ch < A; ++ch) {
if (bit(mask[i], ch) && c[ch]) {
--c[ch];
if (check()) {
printf("%c", char('a' + ch));
break;
}
++c[ch];
}
}
}
}
|
#include <bits/stdc++.h>
using uint = unsigned int;
constexpr uint MaxL(100000u);
constexpr unsigned short SIGMA(6u);
constexpr unsigned short FULL_STATE((1u << 6u) - 1u);
namespace IOManager {
constexpr uint FILESZ(1500010u);
unsigned char buf[FILESZ];
const unsigned char *ibuf = buf;
struct IOManager {
IOManager() { buf[fread(buf, 1u, FILESZ, stdin)] = ' '; }
~IOManager() {}
template <class _Tp>
inline operator _Tp() {
_Tp s = 0u;
for (; !isdigit(*ibuf); ++ibuf)
;
for (; isdigit(*ibuf); ++ibuf) s = (_Tp)(s * 10u + *ibuf - 48u);
return s;
}
template <class _Tp>
inline _Tp operator()(_Tp &rhs) {
_Tp s = 0u;
for (; !isdigit(*ibuf); ++ibuf)
;
for (; isdigit(*ibuf); ++ibuf) s = (_Tp)(s * 10u + *ibuf - 48u);
return rhs = s;
}
inline uint operator()(unsigned char *const &str) {
unsigned char *s = str;
for (; isspace(*ibuf); ++ibuf)
;
for (; !isspace(*ibuf);) *s++ = *ibuf++;
return *s = 0u, s - str;
}
inline uint operator()(char *str) { return (*this)((unsigned char *)str); }
inline uint operator()(const char *str) {
return (*this)((unsigned char *)str);
}
inline uint operator()(const unsigned char *str) {
return (*this)((unsigned char *)str);
}
};
} // namespace IOManager
IOManager::IOManager io;
using IOManager::ibuf;
unsigned char s[MaxL + 1u];
unsigned short vaild[MaxL + 1u];
unsigned short lg2[64u];
uint cnts[6u];
uint cntv[64u];
uint cntsum[64u];
inline bool chk() {
for (uint i = 1u; i <= 63u; ++i)
if ((cntsum[i] = cntsum[i ^ (i & -i)] + cnts[lg2[i & -i]]) + cntv[i ^ 63u] >
cntv[63u])
return false;
return true;
}
int main() {
lg2[1u] = 0u;
lg2[2u] = 1u;
lg2[4u] = 2u;
lg2[8u] = 3u;
lg2[16u] = 4u;
lg2[32u] = 5u;
const uint n = io(s + 1u);
for (uint i = 1u; i <= n; ++i) vaild[i] = 63u;
for (uint pos, m = io; m; --m) {
for (vaild[pos = io] = 0u; isspace(*ibuf); ++ibuf)
;
for (; !isspace(*ibuf);) vaild[pos] |= (1u << ((*ibuf++) - 97u));
}
for (uint i = 1u; i <= n; ++i) ++cnts[s[i] - 97u], ++cntv[vaild[i]];
for (uint i = 0u; i < 6u; ++i)
for (uint j = 0u; j <= 63u; ++j)
if ((j >> i) & 1u) cntv[j] += cntv[j ^ (1u << i)];
if (!chk()) return puts("Impossible"), 0;
unsigned char *Ans = s;
for (uint i = 1u; i <= n; ++i) {
for (uint j = vaild[i]; j != 63u; j = (j + 1u) | vaild[i]) --cntv[j];
--cntv[63u];
for (unsigned short c = 0u; c < 6u; ++c)
if ((vaild[i] >> c) & 1u) {
--cnts[c];
if (chk()) {
*++Ans = c + 97u;
break;
}
++cnts[c];
}
}
fwrite(s + 1u, 1u, n, stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N];
int cnt[N];
int need[N];
int n, m;
int getbit(int x, int i) { return (x >> i) & 1; }
void add(int x, int val) {
for (int mask = 0; mask < (1 << 6); mask++)
if (getbit(mask, x)) cnt[mask] += val;
}
bool check() {
for (int mask = 0; mask < (1 << 6); mask++)
if (cnt[mask] < need[mask]) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
for (char c : s) add(c - 'a', 1);
n = s.size();
for (int i = 1; i <= n; i++) a[i] = 63;
cin >> m;
for (int i = 1; i <= m; i++) {
int id;
string t;
cin >> id >> t;
int mask = 0;
for (char c : t) mask |= (1 << (c - 'a'));
a[id] = mask;
}
for (int i = 1; i <= n; i++) need[a[i]]++;
for (int i = 0; i < 6; i++)
for (int mask = 0; mask < (1 << 6); mask++)
if (getbit(mask, i)) need[mask] += need[mask ^ (1 << i)];
string ans;
for (int i = 1; i <= n; i++) {
bool found = false;
for (int mask = a[i]; mask < (1 << 6); mask = (mask + 1) | a[i])
need[mask]--;
for (int j = 0; j <= 5; j++)
if (getbit(a[i], j)) {
add(j, -1);
if (check()) {
ans += (char)j + 'a';
found = true;
break;
}
add(j, 1);
}
if (!found) {
ans = "Impossible";
break;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[100010][70], cnt[70], n, m;
int a[100010], sum[70];
char s[100010], pr[100010];
int main() {
scanf("%s", s);
int n = strlen(s);
scanf("%d", &m);
for (int i = 0; i < n; i++) {
int x = s[i] - 'a';
for (int j = 0; j < (1 << 6); j++)
if (j & (1 << x)) cnt[j]++;
}
int tag;
for (int i = 1; i <= m; i++) {
scanf("%d %s", &tag, s);
tag--;
int len = strlen(s);
for (int j = 0; j < len; j++) a[tag] |= (1 << (s[j] - 'a'));
}
for (int i = n - 1; i >= 0; i--) {
if (a[i] == 0) a[i] = (1 << 6) - 1;
for (int j = 0; j < (1 << 6); j++) {
if ((j & a[i]) == a[i]) sum[j]++;
dp[i][j] = sum[j];
}
}
for (int i = 0; i < n; i++) {
bool flag = 0;
for (int j = 0; j < 6; j++) {
if ((a[i] & (1 << j)) == 0) continue;
bool allow = 1;
for (int k = 0; k < (1 << 6); k++) {
if (k & (1 << j)) {
if (cnt[k] - 1 < dp[i + 1][k]) {
allow = 0;
break;
}
} else {
if (cnt[k] < dp[i + 1][k]) {
allow = 0;
break;
}
}
}
if (allow == 1) {
flag = 1;
pr[i] = 'a' + j;
for (int k = 0; k < (1 << 6); k++)
if (k & (1 << j)) cnt[k]--;
break;
}
}
if (flag == 0) {
printf("Impossible");
return 0;
}
}
printf("%s", pr);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, B = 7;
char s[N], t[N], ans[N];
int q, n, cnt[N][1 << B], tot[B];
vector<int> c[N];
inline bool check(int pos) {
for (int i = 0; i < (1 << 6); ++i) {
int sum = 0;
for (int j = 0; j < B; ++j)
if (i & (1 << j)) sum += tot[j];
if (cnt[pos][i] < sum) return 0;
}
return 1;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
scanf("%d", &q);
for (int pos, i = 1, len; i <= q; ++i) {
scanf("%d", &pos);
scanf("%s", t + 1);
len = strlen(t + 1);
sort(t + 1, t + 1 + len);
for (int j = 1; j <= len; ++j) c[pos].push_back(t[j] - 'a');
}
for (int i = n; i >= 1; --i) {
++tot[s[i] - 'a'];
if (!c[i].size())
for (int j = 0; j < B; ++j) c[i].push_back(j);
for (int j = 0; j < (1 << 6); ++j) {
cnt[i][j] = cnt[i + 1][j];
for (int k : c[i])
if (j & (1 << k)) {
++cnt[i][j];
break;
}
}
}
for (int i = 1; i <= n; ++i) {
bool flag = 0;
for (int u : c[i]) {
if (!tot[u]) continue;
--tot[u];
if (check(i + 1)) {
ans[i] = u + 'a';
flag = 1;
break;
}
++tot[u];
}
if (!flag) {
puts("Impossible");
return 0;
}
}
printf("%s", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, m, sz[maxn], link[maxn][1 << 6], x, cover[maxn];
char s[maxn], ans[maxn];
vector<int> t[maxn];
bool check(int x) {
for (int i = 0; i < 1 << 6; i++) {
int a = link[x][i], b = 0;
for (int j = 0; j < 6; j++)
if ((i >> j) & 1) b += sz[j];
if (a < b) return 0;
}
return 1;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) sz[s[i] - 'a']++;
cin >> m;
for (int i = 1; i <= m; i++) {
scanf("%d%s", &x, s + 1);
int len = strlen(s + 1);
for (int j = 1; j <= len; j++)
t[x].push_back(s[j] - 'a'), cover[x] += 1 << (s[j] - 'a');
}
for (int i = 1; i <= n; i++)
if (t[i].size() == 0) {
cover[i] = (1 << 6) - 1;
for (int j = 'a'; j <= 'f'; j++) t[i].push_back(j - 'a');
}
for (int i = n; i >= 1; i--) {
for (int j = 0; j < 1 << 6; j++)
if (j & cover[i])
link[i][j] = link[i + 1][j] + 1;
else
link[i][j] = link[i + 1][j];
}
for (int i = 1; i <= n; i++) {
sort(t[i].begin(), t[i].end());
for (auto c : t[i]) {
sz[c]--;
if (check(i + 1)) {
ans[i] = c + 'a';
break;
}
sz[c]++;
}
}
if (strlen(ans + 1) < n)
cout << "Impossible";
else
printf("%s", ans + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
int tot[26];
int match[8][65];
int vis[105];
int dfs(int a) {
for (int i = 0; i < 6; i++) {
if ((1 << i) & a) {
if (tot[i]) {
tot[i]--;
match[i][a]++;
return i;
} else {
for (int j = 0; j < 65; j++) {
if (match[i][j] && !vis[j]) {
vis[j] = 1;
if (dfs(j) != -1) {
match[i][j]--;
match[i][a]++;
return i;
}
}
}
}
}
}
return -1;
}
int main() {
char c[100005];
scanf("%s", c);
for (int i = 0; c[i] != 0; i++) {
tot[c[i] - 'a']++;
}
int len = strlen(c);
int num[100005];
fill(num, num + len, 63);
int m;
scanf("%d", &m);
while (m--) {
int pos;
char cc[10];
scanf("%d %s", &pos, cc);
int sum = 0;
for (int i = 0; cc[i] != 0; i++) {
sum |= (1 << (cc[i] - 'a'));
}
num[pos - 1] = sum;
}
for (int i = 0; i < len; i++) {
memset(vis, 0, sizeof(vis));
int first = dfs(num[i]);
if (first == -1) {
printf("Impossible\n");
return 0;
}
}
for (int i = 0; i < len; i++) {
for (int j = 0; j < 8; j++) {
if (match[j][num[i]]) {
match[j][num[i]]--;
tot[j]++;
break;
}
}
memset(vis, 0, sizeof(vis));
int first = dfs(num[i]);
printf("%c", first + 'a');
match[first][num[i]]--;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int kiek[6];
int kiti[1 << 6];
int koks[100000];
bool check() {
int suma = 0;
for (int i = 0; i < 6; i++)
if (kiek[i] < 0)
return false;
else
suma += kiek[i];
for (int sub = 0; sub < (1 << 6); sub++) {
int suma = 0;
for (int i = 0; i < 6; i++) {
if (((1 << i) & (sub)) > 0) {
suma += kiek[i];
}
}
int sumb = 0;
for (int msk = 0; msk < (1 << 6); msk++) {
if ((msk & sub) > 0) sumb += kiti[msk];
}
if (sumb < suma) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
for (char x : s) kiek[x - 'a']++;
int n = s.size();
int m;
cin >> m;
fill_n(koks, 100000, (1 << 6) - 1);
while (m--) {
int i;
string s;
cin >> i >> s;
i--;
int msk = 0;
for (char a : s) msk |= (1 << (a - 'a'));
koks[i] = msk;
}
for (int i = 0; i < n; i++) kiti[koks[i]]++;
string ans;
for (int i = 0; i < n; i++) {
kiti[koks[i]]--;
char x = 'z';
for (char a = 'a'; a <= 'f'; a++) {
kiek[a - 'a']--;
if (((koks[i] & (1 << (a - 'a'))) > 0) && check()) {
x = a;
break;
} else {
kiek[a - 'a']++;
}
}
if (x == 'z') {
cout << ans << endl;
cout << "Impossible"
<< "\n";
return 0;
}
ans.push_back(x);
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - 48;
ch = getchar();
}
return x * f;
}
template <typename T>
inline void Max(T &a, T b) {
if (a < b) a = b;
}
template <typename T>
inline void Min(T &a, T b) {
if (a > b) a = b;
}
const int N = 1e5 + 7;
int n, m;
int cnt[N][1 << 6], val[N], num[6], ans[N];
char s[N], s2[N];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) num[s[i] - 'a']++;
m = gi();
for (int i = 1; i <= m; ++i) {
int x = gi();
scanf("%s", s2 + 1);
int len = strlen(s2 + 1);
for (int j = 1; j <= len; ++j) val[x] |= (1 << s2[j] - 'a');
}
for (int i = n; i; --i) {
if (!val[i]) val[i] = (1 << 6) - 1;
for (int j = 0; j < 1 << 6; ++j) {
cnt[i][j] = cnt[i + 1][j];
if ((j & val[i]) == val[i]) cnt[i][j]++;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 6; ++j)
if (cnt[j] && val[i] >> j & 1) {
num[j]--;
bool fg = 1;
for (int S = 0; S < 1 << 6; ++S) {
int c = 0;
for (int k = 0; k < 6; ++k)
if (S >> k & 1) c += num[k];
if (c < cnt[i + 1][S]) fg = 0;
}
if (fg) {
ans[i] = j;
goto A;
}
num[j]++;
}
return puts("Impossible"), 0;
A:;
}
for (int i = 1; i <= n; ++i) printf("%c", ans[i] + 'a');
puts("");
return 0;
}
|
#include <bits/stdc++.h>
template <class t>
inline void read(t &s) {
s = 0;
register int f = 1;
register char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) s = (s << 3) + (s << 1) + (c ^ 48), c = getchar();
s *= f;
return;
}
template <class t, class... A>
inline void read(t &x, A &...a) {
read(x);
read(a...);
}
template <class t>
inline void write(t x) {
if (x < 0) putchar('-'), x = -x;
int buf[21], top = 0;
while (x) buf[++top] = x % 10, x /= 10;
if (!top) buf[++top] = 0;
while (top) putchar(buf[top--] ^ '0');
return;
}
inline void setIn(std::string s) {
freopen(s.c_str(), "r", stdin);
return;
}
inline void setOut(std::string s) {
freopen(s.c_str(), "w", stdout);
return;
}
inline void setIO(std::string s = "") {
setIn(s + ".in");
setOut(s + ".out");
return;
}
template <class t>
inline bool ckmin(t &x, t y) {
if (x > y) {
x = y;
return 1;
}
return 0;
}
template <class t>
inline bool ckmax(t &x, t y) {
if (x < y) {
x = y;
return 1;
}
return 0;
}
inline int lowbit(int x) { return x & (-x); }
const int MaxN = 1e5 + 50;
char str[MaxN];
int f[MaxN][1 << 6], T[6], vis[MaxN];
inline bool check(int st) {
for (int mask = 0; mask < (1 << 6); ++mask) {
register int s = 0;
for (int j = 0; j < 6; ++j)
if (mask & (1 << j)) s += T[j];
if (f[st][mask] < s) return false;
}
return true;
}
signed main(void) {
std::scanf("%s", str);
int n = std::strlen(str);
for (int i = 0; i < n; ++i) ++T[str[i] - 'a'];
int q;
read(q);
while (q--) {
int x;
std::string y;
read(x);
std::cin >> y;
int msk = 0;
for (auto i : y) msk |= (1 << (i - 'a'));
vis[x] = msk;
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) vis[i] = (1 << 6) - 1;
for (int i = n; i; --i)
for (int j = 0; j < (1 << 6); ++j) f[i][j] = f[i + 1][j] + !!(j & vis[i]);
if (!check(1)) return std::puts("Impossible"), 0;
for (int i = 1; i <= n; ++i)
for (int j = 0; j < 6; ++j)
if (T[j] && (vis[i] & (1 << j))) {
--T[j], str[i] = j + 'a';
if (check(i + 1)) break;
++T[j];
}
std::puts(str + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt[70], can[100100], have[70];
string str, ans;
inline void del(int u, int v) {
int i;
for (i = 0; i < 64; i++) {
if (i & can[u]) have[i]--;
if (i & (1 << v)) cnt[i]--;
}
}
inline void add(int u, int v) {
int i;
for (i = 0; i < 64; i++) {
if (i & can[u]) have[i]++;
if (i & (1 << v)) cnt[i]++;
}
}
inline bool check() {
int i;
for (i = 0; i < 64; i++) {
if (cnt[i] > have[i]) return 0;
}
return 1;
}
int main() {
ios::sync_with_stdio(0);
int i, j, tmp, p;
cin >> str;
n = str.size();
for (i = 0; i < str.size(); i++) {
cnt[1 << (str[i] - 'a')]++;
}
for (i = 1; i < 64; i++) {
for (j = i - 1; j >= 0; j--) {
if ((j & i) == j) {
cnt[i] = cnt[j] + cnt[j ^ i];
}
}
}
cin >> m;
for (i = 1; i <= n; i++) can[i] = 63;
for (i = 1; i <= m; i++) {
cin >> p >> str;
tmp = 0;
for (j = 0; j < str.size(); j++) {
tmp |= (1 << (str[j] - 'a'));
}
can[p] &= tmp;
}
for (i = 1; i <= n; i++) {
for (j = 0; j < 64; j++) {
if (can[i] & j) have[j]++;
}
}
if (!check()) {
puts("Impossible");
return 0;
}
for (i = 1; i <= n; i++) {
for (j = 0; j < 6; j++) {
if ((1 << j) & can[i]) {
del(i, j);
if (check()) {
ans += (char)(j + 'a');
break;
}
add(i, j);
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXLEN = 100000;
const int ALPH = 6;
struct G {
int n, m, s, t, totalflow;
vector<int> ghead, gnxt, gto, gcap;
void init(int _n, int _s, int _t) {
n = _n, m = 0, s = _s, t = _t, totalflow = 0;
ghead = vector<int>(n, -1), gnxt.clear(), gto.clear(), gcap.clear();
}
int addedge(int a, int b, int c) {
int ret = m;
gnxt.push_back(ghead[a]), ghead[a] = m, gto.push_back(b), gcap.push_back(c),
++m;
gnxt.push_back(ghead[b]), ghead[b] = m, gto.push_back(a), gcap.push_back(0),
++m;
return ret;
}
int maxflow(int lim) {
while (totalflow < lim) {
queue<int> q;
vector<int> back(n, -1);
vector<int> flow(n, 0);
q.push(s), back[s] = -2, flow[s] = INT_MAX;
while (!q.empty() && flow[t] == 0) {
int at = q.front();
q.pop();
for (int x = ghead[at]; x != -1; x = gnxt[x]) {
int to = gto[x];
if (gcap[x] == 0 || flow[to] != 0) continue;
q.push(to), back[to] = x ^ 1, flow[to] = min(gcap[x], flow[at]);
}
}
if (flow[t] == 0) break;
totalflow += flow[t];
for (int at = t; at != s; at = gto[back[at]]) {
gcap[back[at]] += flow[t];
gcap[back[at] ^ 1] -= flow[t];
}
}
return totalflow;
}
vector<int> rback;
vector<bool> rbeen;
void precalcreroute(int reid) {
int a = gto[reid ^ 1];
queue<int> q;
rback = vector<int>(n, -1);
rbeen = vector<bool>(n, false);
q.push(a), rback[a] = -2, rbeen[a] = true;
while (!q.empty()) {
int at = q.front();
q.pop();
for (int x = ghead[at]; x != -1; x = gnxt[x]) {
int to = gto[x];
if (gcap[x] == 0 || rbeen[to]) continue;
q.push(to), rback[to] = x ^ 1, rbeen[to] = true;
}
}
}
bool reroute(int leid, int reid) {
int a = gto[reid ^ 1], b = gto[leid];
if (!rbeen[b]) return false;
--gcap[leid ^ 1], --gcap[reid ^ 1];
for (int at = b; at != a; at = gto[rback[at]]) {
++gcap[rback[at]];
--gcap[rback[at] ^ 1];
}
return true;
}
};
char s[MAXLEN + 1];
int slen;
int cond[MAXLEN];
char ret[MAXLEN + 1];
int sid, tid, lid[ALPH], rid[1 << ALPH], nid;
int leid[ALPH], reid[1 << ALPH];
int have[ALPH], need[1 << ALPH];
G g;
bool solve() {
for (int i = (0); i < (ALPH); ++i) have[i] = 0;
for (int i = (0); i < (slen); ++i) ++have[s[i] - 'a'];
for (int j = (0); j < (1 << ALPH); ++j) need[j] = 0;
for (int i = (0); i < (slen); ++i) ++need[cond[i]];
nid = 0;
sid = nid++;
tid = nid++;
for (int i = (0); i < (ALPH); ++i) lid[i] = nid++;
for (int j = (0); j < (1 << ALPH); ++j) rid[j] = nid++;
g.init(nid, sid, tid);
for (int i = (0); i < (ALPH); ++i) leid[i] = g.addedge(sid, lid[i], have[i]);
for (int i = (0); i < (ALPH); ++i)
for (int j = (0); j < (1 << ALPH); ++j)
if (j & (1 << i)) g.addedge(lid[i], rid[j], min(have[i], need[j]));
for (int j = (0); j < (1 << ALPH); ++j)
reid[j] = g.addedge(rid[j], tid, need[j]);
if (g.maxflow(slen) != slen) return false;
for (int i = (0); i < (slen); ++i) {
bool found = false;
g.precalcreroute(reid[cond[i]]);
for (int c = (0); c < (ALPH); ++c)
if (have[c] > 0 && (cond[i] & (1 << c)) != 0 &&
g.reroute(leid[c], reid[cond[i]])) {
--have[c], --need[cond[i]], found = true, ret[i] = 'a' + c;
break;
}
assert(found);
}
ret[slen] = '\0';
return true;
}
void run() {
scanf("%s", s);
slen = strlen(s);
for (int i = (0); i < (slen); ++i) cond[i] = (1 << ALPH) - 1;
int nq;
scanf("%d", &nq);
for (int i = (0); i < (nq); ++i) {
int idx;
char buff[ALPH + 1];
scanf("%d%s", &idx, buff);
--idx, cond[idx] = 0;
for (int j = 0; buff[j] != '\0'; ++j) cond[idx] |= 1 << (buff[j] - 'a');
}
if (!solve()) {
printf("Impossible");
return;
}
printf("%s\n", ret);
}
void stress() {
for (int rep = (0); rep < (1); ++rep) {
slen = MAXLEN;
for (int i = (0); i < (slen); ++i) s[i] = i < ALPH ? 'a' + i : 'f';
s[slen] = '\0';
for (int i = (0); i < (slen); ++i) cond[i] = (1 << ALPH) - 1;
for (int i = (0); i < (ALPH); ++i) cond[slen - i - 1] = 1 << i;
bool res = solve();
printf("%c", res ? 'V' : 'x');
}
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
bool f = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = 1;
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
if (f) x = -x;
}
template <typename F>
inline void write(F x, char ed = '\n') {
static short st[30];
short tp = 0;
if (x < 0) putchar('-'), x = -x;
do st[++tp] = x % 10, x /= 10;
while (x);
while (tp) putchar('0' | st[tp--]);
putchar(ed);
}
template <typename T>
inline void Mx(T &x, T y) {
x < y && (x = y);
}
template <typename T>
inline void Mn(T &x, T y) {
x > y && (x = y);
}
const int lim = 63;
int cnt[10], to[10], siz[100];
bool check(void) {
for (int i = 1; i <= lim; i++)
if (siz[i] < 0) return 0;
return 1;
}
const int N = 200050;
int vis[N], a[N], m, n;
char s[N];
int main() {
scanf("%s", s + 1), read(m), n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
int c = s[i] - 'a';
cnt[c]++;
for (int j = 1; j <= lim; j++)
if (j >> c & 1) siz[j]--;
}
for (int i = 1, p; i <= m; i++) {
read(p), scanf("%s", s);
int t = strlen(s);
for (int i = 0; i < t; i++) vis[p] |= 1 << (s[i] - 'a');
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) vis[i] = 63;
for (int t = 0; t <= lim; t++)
if (vis[i] & t) siz[t]++;
}
if (!check()) return puts("Impossible"), 0;
for (int i = 1; i <= n; i++) {
for (int t = 0; t <= lim; t++)
if (vis[i] & t) siz[t]--;
for (int j = 0; j < 6; j++) {
if (!cnt[j] || !(vis[i] >> j & 1)) continue;
for (int t = 1; t <= lim; t++)
if (t >> j & 1) siz[t]++;
cnt[j]--;
if (check()) {
a[i] = j;
break;
}
for (int t = 1; t <= lim; t++)
if (t >> j & 1) siz[t]--;
cnt[j]++;
}
}
for (int i = 1; i <= n; i++) putchar('a' + a[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 1e6 + 7;
const double pi = acos(-1.0);
const double eps = 0.0000000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline void add(int &A, int B) {
A += B;
(A >= M) && (A -= M);
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = (long long)a * a % M)
if (b & 1) ret = (long long)ret * a % M;
return ret;
}
int n, m;
char S[maxn];
int mask[maxn];
int cnt[67];
int TaskA() {
int i, j, k, q;
n = strlen(S);
const int MAX = (1 << 6) - 1;
for (i = 0; i < n; i++) mask[i] = MAX;
scanf("%d", &m);
for (i = 0; i < m; i++) {
int pos;
char s[20];
scanf("%d", &pos);
pos--;
mask[pos] = 0;
scanf("%s", s);
int l = strlen(s);
for (j = 0; j < l; j++) mask[pos] |= 1 << (s[j] - 'a');
}
for (i = 0; i < n; i++)
for (k = 0; k < MAX; k++) {
if ((k >> (S[i] - 'a')) & 1) cnt[k]--;
if (mask[i] & k) cnt[k]++;
}
for (i = 0; i < n; i++) {
for (k = 0; k < MAX; k++)
if (mask[i] & k) cnt[k]--;
for (j = 0; j < 7; j++)
if ((mask[i] >> j) & 1) {
bool okay = true;
for (k = 0; k < MAX; k++) {
if (cnt[k] + ((k >> j) & 1) < 0) okay = false;
if (!okay) break;
}
if (okay) break;
}
if (j == 7) return 0 * puts("Impossible");
S[i] = j + 'a';
mask[i] = 1 << j;
for (k = 0; k < MAX; k++)
if (mask[i] & k) cnt[k]++;
}
puts(S);
return 0;
}
void initialize() {}
void Task_one() { TaskA(); }
void Task_T() {
int T;
scanf("%d", &T);
while (T--) TaskA();
}
void Task_more_n() {
while (~scanf("%d", &n)) TaskA();
}
void Task_more_n_m() {
while (~scanf("%d%d", &n, &m)) TaskA();
}
void Task_more_string() {
while (~scanf("%s", S)) TaskA();
}
int main() {
int startTime = clock();
initialize();
fprintf(stderr, "/--- initializeTime: %ld milliseconds ---/\n",
clock() - startTime);
Task_more_string();
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class T2>
inline int chkmax(T &x, const T2 &y) {
return x < y ? x = y, 1 : 0;
}
template <class T, class T2>
inline int chkmin(T &x, const T2 &y) {
return x > y ? x = y, 1 : 0;
}
const int MAXN = (1 << 18);
string s;
int n;
int cnt[6];
void read() {
cin >> s;
n = s.size();
for (char c : s) cnt[c - 'a']++;
}
bool used[MAXN];
int Msk[MAXN];
int S[1 << 6];
void solve() {
int q;
cin >> q;
while (q--) {
int p;
cin >> p;
p--;
string t;
cin >> t;
used[p] = 1;
int mask = 0;
for (char c : t) mask |= (1 << (c - 'a'));
Msk[p] = mask;
for (int m = 0; m < (1 << 6); m++)
if ((m & mask) == mask) S[m]++;
}
for (int i = 0; i < n; i++)
if (!used[i]) {
Msk[i] = (1 << 6) - 1;
for (int c = 0; c < (1 << 6); c++)
if (Msk[i] == (Msk[i] & c)) S[c]++;
}
for (int i = 0; i < n; i++) {
int found = -1;
for (int c = 0; c < 6; c++)
if (Msk[i] & (1 << c)) {
cnt[c]--;
for (int mask = 0; mask < (1 << 6); mask++)
if (Msk[i] == (mask & Msk[i])) S[mask]--;
bool ok = 1;
for (int mask = 0; mask < (1 << 6); mask++) {
int S = 0;
for (int p = 0; p < 6; p++)
if (mask & (1 << p)) S += cnt[p];
S -= ::S[mask];
if (S < 0) ok = 0;
}
if (ok) {
found = c;
break;
}
for (int mask = 0; mask < (1 << 6); mask++)
if (Msk[i] == (mask & Msk[i])) S[mask]++;
cnt[c]++;
}
if (found == -1) {
cout << "Impossible" << '\n';
return;
}
cout << (char)(found + 'a');
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast,no-stack-protector")
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\n";
err(++it, args...);
}
function<void(void)> ____ = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
template <typename T>
vector<T> &operator<<(vector<T> &__container, T x) {
__container.push_back(x);
return __container;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &__container) {
for (T _ : __container) out << _ << ' ';
return out;
}
void sci() {}
template <typename... Args>
void sci(int &x, Args &...args) {
scanf("%d", &x);
sci(args...);
}
void scl() {}
template <typename... Args>
void scl(long long int &x, Args &...args) {
scanf("%lld", &x);
scl(args...);
}
const int MAXN = 2e5 + 7;
char s[MAXN], buf[MAXN], ret[MAXN];
int n, m, mask[MAXN], len;
int cnt[6], mat[1 << 6], f[1 << 6];
void solve() {
scanf("%s", s + 1);
sci(m);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) cnt[s[i] - 'a']++;
for (int i = 1; i <= n; i++) mask[i] = (1 << 6) - 1;
for (int i = 1; i <= m; i++) {
int x;
sci(x);
scanf("%s", buf);
mask[x] = 0;
for (int j = 0, l = strlen(buf); j < l; j++)
mask[x] |= (1 << (buf[j] - 'a'));
}
for (int i = 1; i <= n; i++) mat[mask[i]]++;
auto check = [&]() -> bool {
for (int i = 0; i < (1 << 6); i++) f[i] = mat[i];
for (int bit = 0; bit < 6; bit++)
for (int msk = 0; msk < (1 << 6); msk++)
if (msk >> bit & 1) f[msk] += f[msk ^ (1 << bit)];
for (int msk = 0; msk < (1 << 6); msk++) {
int s = 0;
for (int bit = 0; bit < 6; bit++)
if (msk >> bit & 1) s += cnt[bit];
if (f[msk] > s) return false;
}
return true;
};
for (int i = 1; i <= n; i++) {
bool ok = false;
mat[mask[i]]--;
for (int ch = 0; ch < 6; ch++)
if ((mask[i] >> ch & 1) and cnt[ch]) {
cnt[ch]--;
if (!check())
cnt[ch]++;
else {
ok = true;
ret[len++] = char(ch + 'a');
break;
}
}
if (!ok) {
cout << "Impossible"
<< "\n";
return;
}
}
cout << ret << "\n";
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int E = 2005;
const int oo = 1e8;
struct Dinic {
vector<int> g[N];
int ne;
struct Edge {
int from, to;
int flow, cap;
} edge[E];
int lvl[N], vis[N], pass, source = N - 2, target = N - 1, px[N];
int q[N], qt;
int run(int s, int minE) {
if (s == target) return minE;
int ans = 0;
for (; px[s] < (int)g[s].size(); px[s]++) {
int e = g[s][px[s]];
auto &v = edge[e], &rev = edge[e ^ 1];
if (lvl[v.to] != lvl[s] + 1 || v.flow >= v.cap) continue;
int tmp = run(v.to, min(minE, v.cap - v.flow));
v.flow += tmp, rev.flow -= tmp;
ans += tmp, minE -= tmp;
if (minE == 0) break;
}
return ans;
}
int bfs() {
qt = 0;
q[qt++] = source;
lvl[source] = 1;
vis[source] = ++pass;
for (int i = 0; i < qt; i++) {
int u = q[i];
px[u] = 0;
if (u == target) return true;
for (int e : g[u]) {
auto v = edge[e];
if (v.flow >= v.cap || vis[v.to] == pass) continue;
vis[v.to] = pass;
lvl[v.to] = lvl[u] + 1;
q[qt++] = v.to;
}
}
return false;
}
int flow() {
int ans = 0, tmp;
while (bfs()) {
while ((tmp = run(source, oo)) > 0) ans += tmp;
}
return ans;
}
void addEdge(int u, int v, int c) {
edge[ne] = {u, v, 0, c};
g[u].push_back(ne++);
edge[ne] = {v, u, 0, 0};
g[v].push_back(ne++);
}
void reset_flow() {
for (int i = 0; i < ne; i++) edge[i].flow = 0;
}
};
char s[N];
int m, cnt_letter[300], cnt_bit[1 << 7];
int get_bit() {
int ans = 0;
for (int i = 0; s[i]; i++) ans |= 1 << int(s[i] - 'a');
return ans;
}
int bit[N];
int main() {
int n;
scanf("%s", s);
n = (int)strlen(s);
for (int i = 0; s[i]; i++) cnt_letter[int(s[i] - 'a')]++;
scanf("%d", &m);
for (int i = 0; i < n; i++) bit[i] = (1 << 6) - 1;
for (int i = 0; i < m; i++) {
int pos;
scanf("%d %s", &pos, s);
pos--;
bit[pos] = get_bit();
}
for (int i = 0; i < n; i++) cnt_bit[bit[i]]++;
Dinic d;
for (int i = 0; i < 6; i++) {
d.addEdge(d.source, i, cnt_letter[i]);
}
for (int i = 0; i < 64; i++) {
d.addEdge(10 + i, d.target, cnt_bit[i]);
}
for (int i = 0; i < 6; i++)
if (cnt_letter[i])
for (int j = 0; j < 64; j++)
if (cnt_bit[j])
if ((1 << i) & j) d.addEdge(i, 10 + j, oo);
if (d.flow() < n) return printf("Impossible\n"), 0;
for (int i = 0; i < n; i++) {
d.edge[2 * (6 + bit[i])].cap--;
for (int j = 0; j < 6; j++)
if (bit[i] & (1 << j)) {
if (!d.edge[2 * j].cap) continue;
d.edge[2 * j].cap--;
d.reset_flow();
if (d.flow() == n - i - 1) {
s[i] = char(j + 'a');
break;
}
d.edge[2 * j].cap++;
}
}
s[n] = 0;
printf("%s\n", s);
}
|
#include <bits/stdc++.h>
const int maxn = 1E+5 + 5;
int n, m, lim[maxn];
char s[maxn];
int cnt[6], tim[64];
inline bool check() {
for (int i = 1; i < 64; ++i) {
int tot = 0;
for (int j = 0; j < 6; ++j)
if (i >> j & 1) tot += cnt[j];
if (tot > tim[i]) return false;
}
return true;
}
inline void GT(int S, int v) {
for (int T = 1; T < 64; ++T)
if (S & T) tim[T] += v;
}
int main() {
scanf("%s%d", s + 1, &m), n = strlen(s + 1);
std::fill(lim + 1, lim + n + 1, 63);
for (int i = 1; i <= m; ++i) {
int p;
char c[10];
scanf("%d%s", &p, c);
int r = strlen(c);
lim[p] = 0;
for (int j = 0; j < r; ++j) lim[p] |= 1 << c[j] - 'a';
}
for (int i = 1; i <= n; ++i) ++cnt[s[i] - 'a'], GT(lim[i], 1);
if (!check()) return puts("Impossible"), 0;
for (int i = 1; i <= n; ++i) {
GT(lim[i], -1);
for (int j = 0; j < 6; ++j)
if (lim[i] >> j & 1) {
--cnt[j];
if (check()) {
putchar('a' + j);
break;
}
++cnt[j];
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
char s[N], ans[N];
int n, cnt[1 << 6], f[N][1 << 6], edge[N], m;
inline void init() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << 6); j++) {
if (j & (1 << (s[i] - 'a'))) {
cnt[j]++;
}
}
}
for (int i = 1; i <= n; i++) {
edge[i] = (1 << 6) - 1;
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
char S[10];
int x;
scanf("%d %s", &x, S + 1);
int len = strlen(S + 1);
edge[x] = 0;
for (int j = 1; j <= len; j++) {
edge[x] |= 1 << (S[j] - 'a');
}
}
}
inline void solve() {
for (int i = n; i; i--) {
for (int j = 0; j < (1 << 6); j++) {
f[i][j] = f[i + 1][j];
if ((j & edge[i]) == edge[i]) f[i][j]++;
}
}
bool ok = 0;
for (int i = 1; i <= n; i++) {
bool flag = false;
for (int j = 0; j < 6 && !flag; j++) {
if (cnt[1 << j] && (edge[i] & (1 << j))) {
ok = 1;
for (int k = 0; k < (1 << 6) && ok; k++) {
if (f[i + 1][k] > cnt[k] - ((k >> j) & 1)) {
ok = false;
}
}
if (ok) {
flag = 1;
ans[i] = 'a' + j;
for (int k = 0; k < (1 << 6); k++) {
if (k & (1 << j)) cnt[k]--;
}
}
}
}
if (!flag) {
puts("Impossible");
return;
}
}
puts(ans + 1);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
char ch[N];
int n, a[N], b[N], f[66], g[66];
int chk(int x, int y) {
int i, o = 1;
for (i = 0; i < 64; i = i + 1) {
if (i & (1 << x)) f[i]--;
if ((i | y) == i) g[i]--;
if (f[i] < g[i]) o = 0;
}
if (o) return 1;
for (i = 0; i < 64; i = i + 1) {
if (i & (1 << x)) f[i]++;
if ((i | y) == i) g[i]++;
}
return 0;
}
int main() {
int m, i, x;
scanf("%s%d", ch + 1, &m);
n = strlen(ch + 1);
for (i = 1; i <= n; i = i + 1) a[i] = 63, f[1 << (ch[i] - 'a')]++;
while (m--) {
scanf("%d%s", &x, ch + 1);
a[x] = 0;
for (i = 1; ch[i]; i = i + 1) a[x] |= (1 << (ch[i] - 'a'));
}
for (i = 1; i <= n; i = i + 1) g[a[i]]++;
for (x = 0; x < 6; x = x + 1)
for (i = 0; i < 64; i = i + 1)
if (i & (1 << x)) f[i] += f[i ^ (1 << x)], g[i] += g[i ^ (1 << x)];
for (i = 0; i < 64; i = i + 1) {
if (f[i] < g[i]) {
cout << "Impossible";
return 0;
}
}
for (i = 1; i <= n; i = i + 1) {
for (x = 0; x < 6; x = x + 1) {
if ((a[i] & (1 << x)) && chk(x, a[i])) {
b[i] = x;
break;
}
}
}
for (i = 1; i <= n; i = i + 1) cout << (char)(b[i] + 'a');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void die() {
cout << "Impossible" << endl;
exit(0);
}
const int limit = 100005;
int n;
int howmany[6];
int who[1 << 6][limit];
int nwho[1 << 6];
int valid[limit][6];
int occurs[limit];
bool possible() {
for (int c = 0; c < 1 << 6; c++) {
int s = 0;
for (int b = 0; b < 6; b++)
if (c & (1 << b)) s += howmany[b];
if (nwho[c] < s) return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
string S;
cin >> S;
n = int(S.size());
for (int i = 0; i < n; i++) howmany[S[i] - 'a']++;
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int pos;
cin >> pos >> S;
pos--;
occurs[pos] = 1;
for (int i = 0; i < int(S.size()); i++) {
int c = S[i] - 'a';
valid[pos][c] = 1;
}
}
for (int i = 0; i < n; i++)
if (not occurs[i])
for (int j = 0; j < 6; j++) valid[i][j] = 1;
for (int c = 0; c < 1 << 6; c++) {
for (int b = 0; b < 6; b++) {
if (c & (1 << b)) {
for (int i = 0; i < n; i++) {
if (valid[i][b] and who[c][i] == 0) {
who[c][i] = 1;
nwho[c]++;
}
}
}
}
}
string sol(n, 'a');
if (not possible()) die();
for (int i = 0; i < n; i++) {
bool found = false;
for (int b = 0; b < 6 and not found; b++) {
if (valid[i][b] and howmany[b]) {
howmany[b]--;
sol[i] = char('a' + b);
for (int c = 0; c < 1 << 6; c++) {
if (who[c][i]) {
who[c][i] = 0;
nwho[c]--;
}
}
if (possible()) {
found = true;
} else {
howmany[b]++;
for (int c = 0; c < 1 << 6; c++) {
for (int b = 0; b < 6; b++) {
if (valid[i][b] and (c & (1 << b))) {
if (not who[c][i]) {
who[c][i] = 1;
nwho[c]++;
}
}
}
}
}
}
}
}
cout << sol << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
char s[N], t[10];
int n, m, cnted[70], num[70], lk[N], U = 63;
int main() {
scanf("%s%d", s + 1, &m);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) lk[i] = 63;
for (int i = 1, c, p; i <= m; i++) {
scanf("%d%s", &p, t + 1);
lk[p] = 0;
c = strlen(t + 1);
for (int j = 1; j <= c; j++) lk[p] |= 1 << (t[j] - 'a');
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= U; j++) {
if ((1 << (s[i] - 'a')) & j) num[j]++;
if (j & lk[i]) cnted[j]++;
}
for (int i = 1; i <= U; i++)
if (num[i] > cnted[i]) return puts("Impossible"), 0;
for (int i = 1; i <= n; i++) {
int zt = lk[i];
for (int j = 1; j <= U; j++)
if ((lk[i] & j) && num[j] == cnted[j]) zt &= j;
for (int j = 0; j < 6; j++)
if (zt & (1 << j)) {
zt = 1 << j;
printf("%c", j + 'a');
break;
}
for (int j = 1; j <= U; j++)
if (j & zt) num[j]--;
for (int j = 1; j <= U; j++)
if (lk[i] & j) cnted[j]--;
}
}
|
#include <bits/stdc++.h>
using namespace std;
static inline void canhazfast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
template <typename T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) {
T x0 = 1, y0 = 0, x1 = 0, y1 = 1;
while (b) {
T q = a / b;
a %= b;
swap(a, b);
x0 -= q * x1;
swap(x0, x1);
y0 -= q * y1;
swap(y0, y1);
}
x = x0;
y = y0;
return a;
}
static inline int ctz(unsigned x) { return __builtin_ctz(x); }
static inline int ctzll(unsigned long long x) { return __builtin_ctzll(x); }
static inline int clz(unsigned x) { return __builtin_clz(x); }
static inline int clzll(unsigned long long x) { return __builtin_clzll(x); }
static inline int popcnt(unsigned x) { return __builtin_popcount(x); }
static inline int popcntll(unsigned long long x) {
return __builtin_popcountll(x);
}
static inline int bsr(unsigned x) { return 31 ^ clz(x); }
static inline int bsrll(unsigned long long x) { return 63 ^ clzll(x); }
int msk[100016];
char s[100016], ans[100016];
int fm[64], fc[64], cnt[8];
bool check() {
for (int i = 1; i < 64; ++i)
if (fm[i] < fc[i]) return false;
return true;
}
int main() {
int n, m;
scanf("%s%d", s, &m);
n = strlen(s);
for (int i = 0; i < n; ++i) ++cnt[s[i] - 'a'], msk[i] = 63;
for (int i = 0; i < m; ++i) {
int p;
char t[8];
scanf("%d%s", &p, t);
msk[--p] = 0;
for (int j = 0; t[j]; ++j) msk[p] |= 1 << (t[j] - 'a');
}
for (int i = 0; i < n; ++i) {
for (int j = 1; j < 64; ++j)
if (j & msk[i]) ++fm[j];
}
for (int c = 0; c < 6; ++c) {
for (int i = 1; i < 64; ++i)
if (i & (1 << c)) fc[i] += cnt[c];
}
if (!check()) return puts("Impossible"), 0;
for (int i = 0; i < n; ++i) {
for (int c = 0; c < 6; ++c) {
if (!(msk[i] & (1 << c))) continue;
ans[i] = c + 'a';
for (int j = 1; j < 64; ++j) {
if (j & (1 << c)) --fc[j];
if (j & msk[i]) --fm[j];
}
if (check()) break;
for (int j = 1; j < 64; ++j) {
if (j & (1 << c)) ++fc[j];
if (j & msk[i]) ++fm[j];
}
ans[i] = 0;
}
}
puts(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 10;
int n, m;
char str[N], ans[N];
int cnt[1 << 6], edge[N], f[N][1 << 6];
char tmp[10];
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
for (int i = 1; i <= n; i++)
for (int j = 0; j < (1 << 6); j++)
if (j & (1 << (str[i] - 'a'))) cnt[j]++;
for (int i = 1; i <= n; i++) edge[i] = (1 << 6) - 1;
scanf("%d", &m);
for (int i = 1, x; i <= m; i++) {
scanf("%d %s", &x, tmp);
int k = strlen(tmp);
edge[x] = 0;
for (int j = 0; j < k; j++) edge[x] += 1 << (tmp[j] - 'a');
}
for (int i = n; i >= 1; i--)
for (int j = 0; j < (1 << 6); j++) {
f[i][j] = f[i + 1][j];
if ((j & edge[i]) == edge[i]) f[i][j]++;
}
for (int i = 1; i <= n; i++) {
bool find = false;
for (int j = 0; j < 6 && !find; j++)
if (cnt[1 << j] && (edge[i] & (1 << j))) {
bool ok = true;
for (int k = 0; k < (1 << 6) && ok; k++)
if (f[i + 1][k] > cnt[k] - ((k >> j) & 1)) ok = false;
if (ok) {
find = true;
ans[i] = 'a' + j;
for (int k = 0; k < (1 << 6); k++)
if (k & (1 << j)) cnt[k]--;
}
}
if (!find) {
puts("Impossible\n");
return 0;
}
}
puts(ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
int can[MAX], cnt[MAX], freq[MAX];
int m;
string s, s2;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s;
cin >> m;
for (int i = 0; i < m; ++i) {
int idx;
cin >> idx;
idx--;
cin >> s2;
for (auto &c : s2) can[idx] |= (1 << (c - 'a'));
}
int n = s.size();
for (auto &c : s) freq[c - 'a']++;
for (int i = 0; i < n; ++i) {
if (!can[i]) can[i] = (1 << 6) - 1;
for (int mask = can[i]; mask < (1 << 6); mask = (mask + 1) | can[i])
cnt[mask]++;
}
for (int mask = 0; mask < (1 << 6); ++mask) {
int now = 0;
for (int bit = 0; bit < 6; ++bit) {
if ((mask & (1 << bit))) now += freq[bit];
}
if (now < cnt[mask]) return cout << "Impossible\n", 0;
}
for (int i = 0; i < n; ++i) {
for (int mask = can[i]; mask < (1 << 6); mask = (mask + 1) | can[i])
cnt[mask]--;
for (int c = 0; c < 6; ++c) {
if (!(can[i] & (1 << c))) continue;
freq[c]--;
bool flag = true;
for (int mask = 0; mask < (1 << 6); ++mask) {
int now = 0;
for (int bit = 0; bit < 6; ++bit) {
if ((mask & (1 << bit))) now += freq[bit];
}
if (now < cnt[mask]) flag = false;
}
if (flag) {
cout << (char)(c + 'a');
break;
}
freq[c]++;
}
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int S[100008], cnt[1 << 7], num[1 << 7];
char s[100008];
int len, n, nu;
inline long long rd() {
long long x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f ? -x : x;
}
int main() {
int ooo = 0;
scanf("%s", s + 1);
len = strlen(s + 1);
int x;
int maxn = (1 << 6) - 1;
for (int i = 1; i <= len; ++i) {
int x = s[i] - 'a';
for (int j = 1; j <= maxn; ++j)
if (j & (1 << x)) cnt[j]++;
}
n = rd();
for (int i = 1; i <= n; ++i) {
x = rd();
scanf("%s", s + 1);
int xx = strlen(s + 1);
for (int j = 1; j <= xx; ++j) S[x] |= (1 << (s[j] - 'a'));
for (int j = 1; j <= maxn; ++j)
if ((j & S[x]) == S[x]) num[j]++;
}
for (int i = 1; i <= len; ++i)
if (!S[i]) {
S[i] = maxn;
num[S[i]]++;
}
for (int i = 1; i <= len; ++i) {
bool tag = 0;
for (int j = 0; j < 6; ++j)
if ((1 << j) & S[i]) {
bool tg = 0;
for (int k = 1; k <= maxn; ++k) {
int x = (k & (1 << j)) ? cnt[k] - 1 : cnt[k],
y = ((k & S[i]) == S[i]) ? num[k] - 1 : num[k];
if (x < y) {
tg = 1;
break;
}
}
if (!tg) {
tag = 1;
s[++nu] = j + 'a';
for (int k = 1; k <= maxn; ++k) {
if ((1 << j) & k) cnt[k]--;
if ((S[i] & k) == S[i]) num[k]--;
}
break;
}
}
if (!tag) {
puts("Impossible");
return 0;
}
}
for (int i = 1; i <= nu; ++i) printf("%c", s[i]);
int yyy = 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int K = 6;
const int N = 101010;
char c[N], ans[N];
int n, msk[N], cnt[K];
int tot[1 << K], tot2[1 << K];
void no() {
puts("Impossible");
exit(0);
}
bool good() {
for (int i = 0; i < (1 << K); i++) tot2[i] = tot[i];
for (int i = 0; i < K; i++)
for (int j = 0; j < (1 << K); j++)
if ((j >> i) & 1) tot2[j] += tot2[j ^ (1 << i)];
for (int i = 1; i < (1 << K); i++) {
int gt = 0;
for (int j = 0; j < K; j++)
if ((i >> j) & 1) gt += cnt[j];
if (gt < tot2[i]) return false;
}
return true;
}
void solve() {
for (int i = 0; i < n; i++) {
int ok = -1;
tot[msk[i]]--;
for (int j = 0; j < 6; j++) {
cnt[j]--;
if (((msk[i] >> j) & 1) and good()) {
ok = j;
break;
}
cnt[j]++;
}
if (ok == -1) no();
ans[i] = (char)('a' + ok);
}
puts(ans);
}
int main() {
scanf("%s", c);
for (int i = 0; c[i]; i++) cnt[c[i] - 'a']++;
n = strlen(c);
for (int i = 0; i < n; i++) msk[i] = (1 << K) - 1;
int m;
scanf("%d", &m);
while (m--) {
int k;
scanf("%d%s", &k, c);
k--;
msk[k] = 0;
for (int i = 0; c[i]; i++) msk[k] |= (1 << (c[i] - 'a'));
}
for (int i = 0; i < n; i++) tot[msk[i]]++;
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int C = 26;
void add(int &x, int y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x) {
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % MOD;
b >>= 1;
a = 1ll * a * a % MOD;
}
return ret;
}
const int MAXN = 1e5 + 10;
const int XX = 6;
int id(char ch) { return ch - 'a'; }
string s;
int n, m;
int vec[MAXN];
int fr[XX];
int cnt[1 << XX], nei[1 << XX];
void solve() {
cin >> s;
n = s.size();
for (int i = 0; i < n; i++) ++fr[id(s[i])];
cin >> m;
fill(vec, vec + n, (1 << XX) - 1);
while (m--) {
int i;
string t;
cin >> i >> t;
--i;
vec[i] = 0;
for (char ch : t) vec[i] |= 1 << id(ch);
}
for (int i = 0; i < n; i++) {
for (int mask = 0; mask < (1 << XX); mask++) {
if (mask & vec[i]) {
++nei[mask];
}
}
}
for (int mask = 0; mask < (1 << XX); mask++) {
if (mask) {
int v = __builtin_ctz(mask);
cnt[mask] = cnt[mask ^ 1 << v] + fr[v];
}
if (cnt[mask] > nei[mask]) {
cout << "Impossible\n";
return;
}
}
for (int i = 0; i < n; i++) {
for (int mask = 0; mask < (1 << XX); mask++) {
if (mask & vec[i]) {
--nei[mask];
}
}
for (int ch = 0; ch < XX; ch++) {
if (!(vec[i] >> ch & 1)) continue;
int tmp[1 << XX];
memcpy(tmp, cnt, sizeof(cnt));
bool works = true;
for (int mask = 0; mask < (1 << XX); mask++) {
if (mask >> ch & 1) {
--tmp[mask];
}
if (tmp[mask] > nei[mask]) {
works = false;
}
}
if (works) {
cout << char('a' + ch);
memcpy(cnt, tmp, sizeof(tmp));
break;
}
}
}
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int te = 1;
for (int w = 1; w <= te; w++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100050;
int cnt[1 << 6], sub[1 << 6], mask[N];
bool Check(int m, int c) {
for (int i = 0; i < 1 << 6; i++) {
int a = cnt[i], b = sub[i];
if ((i & c) == c) a--;
if ((i & m) == m) b--;
if (a < b) return 0;
}
return 1;
}
void Del(int m, int c) {
for (int i = 0; i < 1 << 6; i++) {
if ((i & c) == c) cnt[i]--;
if ((i & m) == m) sub[i]--;
}
}
int main() {
string s;
cin >> s;
int n = s.size(), m;
for (int i = 0; i < n; i++) cnt[1 << (s[i] - 'a')]++;
for (int j = 0; j < 6; j++)
for (int i = 0; i < 1 << 6; i++)
if ((i >> j) & 1) cnt[i] += cnt[i ^ (1 << j)];
scanf("%i", &m);
while (m--) {
int id;
char c[7];
scanf("%i %s", &id, c);
int h = strlen(c);
for (int i = 0; i < h; i++) mask[id] |= 1 << (c[i] - 'a');
}
for (int i = 1; i <= n; i++) {
if (!mask[i]) mask[i] = 63;
sub[mask[i]]++;
}
for (int j = 0; j < 6; j++)
for (int i = 0; i < 1 << 6; i++)
if ((i >> j) & 1) sub[i] += sub[i ^ (1 << j)];
string sol;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 6; j++) {
if (((mask[i] >> j) & 1) && cnt[1 << j] && Check(mask[i], 1 << j)) {
sol += 'a' + j;
Del(mask[i], 1 << j);
break;
}
}
if (sol.size() != i) return printf("Impossible\n"), 0;
}
cout << sol << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 5;
int num[1 << 6], cnt[6];
void upd(int val, int v) {
for (int i = 0; i < 1 << 6; i++) {
if ((i & val) == val) num[i] += v;
}
}
bool work() {
for (int i = 0; i < 1 << 6; i++) {
int sum = 0;
for (int j = 0; j < i; j++) {
if (i & (1 << j)) sum += cnt[j];
}
if (sum < num[i]) return false;
}
return true;
}
int main() {
string s;
cin >> s;
int m;
cin >> m;
int pos[s.length()];
for (int i = 0; i < s.length(); i++) cnt[s[i] - 'a']++;
for (int i = 0; i < s.length(); i++) pos[i] = 63;
for (int i = 0; i < m; i++) {
int p;
string t;
cin >> p >> t;
--p;
int bit = 0;
for (int j = 0; j < t.length(); j++) {
bit += (1 << (t[j] - 'a'));
}
pos[p] = bit;
}
for (int i = 0; i < s.length(); i++) {
upd(pos[i], 1);
}
string ans = "";
string ref = "abcdef";
for (int i = 0; i < s.length(); i++) {
upd(pos[i], -1);
for (int j = 0; j < 6; j++) {
if ((pos[i] & (1 << j)) == 0) continue;
--cnt[j];
if (work()) {
ans += ref[j];
break;
}
++cnt[j];
}
}
if (ans.length() < s.length())
cout << "Impossible"
<< "\n";
else
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int N = 1e5 + 5;
int n;
char s[N];
int can[N];
int f[60], g[60];
char ans[N];
void add(int w, int x, int v) {
x = (1 << x);
for (int i = 0; i <= (1 << 6) - 1; i++)
if ((x & i) > 0) f[i] += v;
for (int i = 0; i <= (1 << 6) - 1; i++)
if ((can[w] & i) > 0) g[i] += v;
}
bool possible() {
bool ret = 1;
for (int i = 0; i <= (1 << 6) - 1; i++) ret &= (f[i] <= g[i]);
return ret;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) can[i] = (1 << 6) - 1;
for (int m = get(); m; m--) {
int x = get();
char cv[10];
scanf("%s", cv + 1);
can[x] = 0;
for (int j = 1; j <= strlen(cv + 1); j++) can[x] |= (1 << (cv[j] - 'a'));
}
for (int i = 1; i <= n; i++)
for (int j = 0; j <= (1 << 6) - 1; j++)
if ((can[i] & j) > 0) g[j]++;
for (int i = 1; i <= n; i++) {
int now = (1 << (s[i] - 'a'));
for (int j = 0; j <= (1 << 6) - 1; j++)
if ((now & j) > 0) f[j]++;
}
if (!possible()) return printf("Impossible\n"), 0;
for (int i = 1; i <= n; i++) {
for (int x = 0; x <= 5; x++)
if (((can[i] & (1 << x)) > 0)) {
add(i, x, -1);
if (possible()) {
ans[i] = 'a' + x;
break;
}
add(i, x, 1);
}
}
for (int i = 1; i <= n; i++) putchar(ans[i]);
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
template <typename Tp>
int getmin(Tp &x, Tp y) {
return y < x ? x = y, 1 : 0;
}
template <typename Tp>
int getmax(Tp &x, Tp y) {
return y > x ? x = y, 1 : 0;
}
template <typename Tp>
void read(Tp &x) {
x = 0;
char ch = getchar();
int f = 0;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') ch = getchar(), f = 1;
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
if (f) x = -x;
}
int n, m, st[maxn], f[maxn][64], now[64];
char s[maxn], ans[maxn];
void input() {
int p, tmp;
char t[10];
scanf("%s", s + 1);
n = strlen(s + 1);
read(m);
for (int i = 1; i <= n; i++)
for (int j = 1; j < 64; j++)
if (j & (1 << (s[i] - 'a'))) ++now[j];
for (int i = 1; i <= m; i++) {
read(p);
scanf("%s", t + 1);
tmp = 0;
for (int j = 1; t[j]; j++) tmp |= (1 << (t[j] - 'a'));
st[p] = tmp;
}
for (int i = n; i; i--) {
if (!st[i]) st[i] = 63;
for (int j = 1; j < 64; j++) {
f[i][j] = f[i + 1][j];
if (j & st[i]) ++f[i][j];
}
}
}
int main() {
input();
for (int i = 1; i <= n; i++) {
for (int j = 0, fg; j < 6; j++)
if (st[i] & (1 << j)) {
fg = 1;
for (int s = 1; s < 64; s++) {
int tmp = now[s];
if (s & (1 << j)) tmp--;
if (f[i + 1][s] < tmp) {
fg = 0;
break;
}
}
if (fg) {
for (int s = 1; s < 64; s++)
if (s & (1 << j)) --now[s];
ans[i] = 'a' + j;
break;
}
}
if (!ans[i]) {
puts("Impossible");
return 0;
}
}
puts(ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
const int cnt = (1 << 6) - 1;
int n, m, ans;
int st[100010], son[cnt + 10], num[6];
int sum[100010][cnt + 10];
char s[100010], ch[7], anss[100010];
inline void prework() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) num[s[i] - 'a']++;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int pos;
scanf("%d", &pos);
scanf("%s", ch + 1);
int l = strlen(ch + 1);
for (int j = 1; j <= l; j++) {
int c = ch[j] - 'a';
st[pos] |= (1 << c);
}
}
for (int i = 1; i <= n; i++)
if (st[i] == 0) st[i] = cnt;
for (int i = n; i >= 1; i--)
for (int j = 1; j <= cnt; j++) {
if ((st[i] & j) == st[i]) son[j]++;
sum[i][j] = son[j];
}
}
inline void mainwork() {
int ssum = 0;
bool flag;
for (int i = 1; i <= n; i++) {
ans = 0;
for (int c = 0; c < 6; c++) {
if (num[c] == 0 || (st[i] & (1 << c)) == 0) continue;
num[c]--;
flag = true;
for (int s = 1; s <= cnt && flag; s++) {
ssum = 0;
for (int j = 0; j < 6; j++)
if (s & (1 << j)) ssum += num[j];
if (ssum < sum[i + 1][s]) flag = false;
}
if (flag) {
ans = 1;
anss[i] = c + 'a';
break;
}
num[c]++;
}
if (!ans) return;
}
}
inline void print() {
if (ans)
for (int i = 1; i <= n; i++) printf("%c", anss[i]);
else
printf("Impossible");
}
int main() {
prework();
mainwork();
print();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
string s, ans = "";
long long tot[80], msk[100010], sum[80], cnt[10], m;
bool check(long long id) {
long long i;
for (i = 0; i < 64; i++) {
if (tot[i] > sum[i]) {
return false;
}
}
return true;
}
int main() {
string chs;
long long i, j, x, mask;
cin >> s >> m;
for (i = 0; i < s.size(); i++) {
cnt[s[i] - 'a']++;
msk[i] = 63;
}
for (i = 0; i < m; i++) {
cin >> x >> chs;
x--;
mask = 0;
for (j = 0; j < chs.size(); j++) {
mask |= (1 << (chs[j] - 'a'));
}
msk[x] = mask;
}
for (i = 0; i < s.size(); i++) {
mask = msk[i];
for (j = 0; j < 64; j++) {
if ((j & mask) == mask) {
tot[j]++;
}
}
}
for (i = 0; i < 64; i++) {
for (j = 0; j < 6; j++) {
if (i & (1 << j)) {
sum[i] += cnt[j];
}
}
}
for (i = 0; i < s.size(); i++) {
for (j = 0; j < 6; j++) {
if (!((1 << j) & msk[i])) {
continue;
}
for (x = 0; x < 64; x++) {
if ((x & msk[i]) == msk[i]) {
tot[x]--;
}
if (x & (1 << j)) {
sum[x]--;
}
}
if (check(j)) {
ans += (char)('a' + j);
cnt[j]--;
j = -1;
break;
}
for (x = 0; x < 64; x++) {
if ((x & msk[i]) == msk[i]) {
tot[x]++;
}
if (x & (1 << j)) {
sum[x]++;
}
}
}
if (j != -1) {
puts("Impossible");
return 0;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
char s[N], ans[N];
int n, cnt[1 << 6], f[N][1 << 6], edge[N], m;
inline void init() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << 6); j++) {
if (j & (1 << (s[i] - 'a'))) {
cnt[j]++;
}
}
}
for (int i = 1; i <= n; i++) {
edge[i] = (1 << 6) - 1;
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
char S[10];
int x;
scanf("%d %s", &x, S + 1);
int len = strlen(S + 1);
edge[x] = 0;
for (int j = 1; j <= len; j++) {
edge[x] |= 1 << (S[j] - 'a');
}
}
}
inline void solve() {
for (int i = n; i; i--) {
for (int j = 0; j < (1 << 6); j++) {
f[i][j] = f[i + 1][j];
if ((j & edge[i])) f[i][j]++;
}
}
bool ok = 0;
for (int i = 1; i <= n; i++) {
bool flag = false;
for (int j = 0; j < 6 && !flag; j++) {
if (cnt[1 << j] && (edge[i] & (1 << j))) {
ok = 1;
for (int k = 0; k < (1 << 6) && ok; k++) {
if (cnt[k] - ((k >> j) & 1) > f[i + 1][k]) {
ok = false;
}
}
if (ok) {
flag = 1;
ans[i] = 'a' + j;
for (int k = 0; k < (1 << 6); k++) {
if (k & (1 << j)) cnt[k]--;
}
}
}
}
if (!flag) {
puts("Impossible");
return;
}
}
puts(ans + 1);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int N;
int msk[100005];
int tot[1 << 10];
int fre[1 << 10];
int cnt[10];
bool chk() {
for (int m = 0; m < 1 << 6; m++) {
int lft = 0;
for (int i = 0; i < 6; i++) {
if (m >> i & 1) {
lft += cnt[i];
}
}
if (lft > tot[m]) {
return 0;
}
}
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s >> N;
fill(msk + 1, msk + 1 + s.size(), 63);
while (N--) {
int p;
cin >> p;
string k;
cin >> k;
msk[p] = 0;
for (char c : k) {
msk[p] |= (1 << (c - 'a'));
}
}
N = s.size();
for (int i = 1; i <= N; i++) {
cnt[s[i - 1] - 'a']++;
for (int m = 0; m < 64; m++) {
if (msk[i] & m) {
tot[m]++;
}
}
}
s.clear();
if (!chk()) {
cout << "Impossible\n";
return 0;
}
for (int i = 1; i <= N; i++) {
for (int m = 0; m < 64; m++) {
if (msk[i] & m) {
tot[m]--;
}
}
for (int c = 0; c < 6; c++) {
if (msk[i] & (1 << c) && cnt[c]) {
cnt[c]--;
if (chk()) {
s.push_back(c + 'a');
break;
}
cnt[c]++;
}
}
}
cout << s;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
char s[N], ans[N];
int n, cnt[1 << 6], f[N][1 << 6], edge[N], m;
inline void init() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << 6); j++) {
if (j & (1 << (s[i] - 'a'))) {
cnt[j]++;
}
}
}
for (int i = 1; i <= n; i++) edge[i] = (1 << 6) - 1;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
char S[10];
int x;
scanf("%d %s", &x, S + 1);
int len = strlen(S + 1);
edge[x] = 0;
for (int j = 1; j <= len; j++) edge[x] |= 1 << (S[j] - 'a');
}
}
inline void solve() {
for (int i = n; i; i--) {
for (int j = 0; j < (1 << 6); j++) {
f[i][j] = f[i + 1][j];
if ((j & edge[i]) == edge[i]) f[i][j]++;
}
}
bool ok = 0;
for (int i = 1; i <= n; i++) {
bool flag = false;
for (int j = 0; j < 6 && !flag; j++) {
if (cnt[1 << j] && (edge[i] & (1 << j))) {
ok = 1;
for (int k = 0; k < (1 << 6) && ok; k++) {
if (f[i + 1][k] > cnt[k] - ((k >> j) & 1)) {
ok = false;
}
}
if (ok) {
flag = 1;
ans[i] = 'a' + j;
for (int k = 0; k < (1 << 6); k++) {
if (k & (1 << j)) cnt[k]--;
}
}
}
}
if (!flag) {
puts("Impossible");
return;
}
}
puts(ans + 1);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e5;
const int AL = 6;
int cnt_let[1 << AL], cnt_mat[1 << AL], pos[MX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.size();
for (auto c : s) {
for (int mask = 0; mask < (1 << AL); ++mask) {
cnt_let[mask] += !!(mask & (1 << (c - 'a')));
}
}
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int a;
string t;
cin >> a >> t;
for (auto c : t) {
pos[a - 1] ^= 1 << (c - 'a');
}
}
for (int i = 0; i < n; ++i) {
if (!pos[i]) {
pos[i] = (1 << AL) - 1;
}
for (int mask = 0; mask < (1 << AL); ++mask) {
cnt_mat[mask] += !!(mask & pos[i]);
}
}
string ans(n, 0);
for (int i = 0; i < n; ++i) {
for (int mask = 0; mask < (1 << AL); ++mask) {
cnt_mat[mask] -= !!(mask & pos[i]);
}
int res = 0;
for (; res < AL; ++res) {
if (!(pos[i] & (1 << res))) continue;
bool ok = true;
for (int mask = 0; mask < (1 << AL) && ok; ++mask) {
int cnt = cnt_let[mask] - !!(mask & (1 << res));
ok &= (cnt <= cnt_mat[mask]);
}
if (ok) break;
}
if (res == AL) {
cout << "Impossible" << '\n';
return 0;
}
for (int mask = 0; mask < (1 << AL); ++mask) {
cnt_let[mask] -= !!(mask & (1 << res));
}
ans[i] = res + 'a';
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 12, alph = 7, full_ad = 63;
string s;
int n, m, cnt[alph], num[(1 << alph)], ad[maxn];
bool check_hall() {
for (int i = 0; i <= full_ad; i++) {
int val1 = 0;
for (int j = 0; j < alph; j++)
if (i & (1 << j)) val1 += cnt[j];
if (num[i] < val1) return 0;
}
return 1;
}
int main() {
cin >> s >> m;
n = s.size();
for (int i = 0; i < n; i++) ad[i] = full_ad;
for (auto x : s) cnt[x - 'a']++;
while (m--) {
int pos;
string SS;
cin >> pos >> SS;
ad[pos - 1] = 0;
for (auto x : SS) ad[pos - 1] += (1 << (x - 'a'));
}
for (int i = 0; i < n; i++)
for (int j = 0; j <= full_ad; j++) num[j] += (bool)(ad[i] & j);
for (int i = 0; i < n; i++) {
for (int j = 0; j <= full_ad; j++) num[j] -= (bool)(ad[i] & j);
bool find_ans = 0;
for (int j = 0; j < alph; j++) {
if (cnt[j] && (ad[i] & (1 << j))) {
cnt[j]--;
bool C = check_hall();
cnt[j]++;
find_ans |= C;
if (C) {
cnt[j]--;
s[i] = j + 'a';
break;
}
}
}
if (find_ans)
;
else
return cout << "Impossible", 0;
}
return cout << s, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, tot, x, t, fw, rt, ans;
char str[200010];
int s[200010], st[200010], ed[200010], nt[200010], p[200010], w[200010],
v[200010], pr[200010], fl[200010], q[200010], ss[200010];
void lk(int x, int y, int z) {
if (!st[x])
st[x] = ++tot;
else
nt[ed[x]] = ++tot;
ed[x] = tot;
p[tot] = y;
w[tot] = z;
if (!st[y])
st[y] = ++tot;
else
nt[ed[y]] = ++tot;
ed[y] = tot;
p[tot] = x;
}
void dfs(int x) {
v[x] = 1;
for (int i = st[x]; i; i = nt[i])
if (w[i] && (!v[p[i]])) {
pr[p[i]] = i ^ 1;
dfs(p[i]);
}
}
int main() {
for (scanf("%s", str); str[n]; n++) s[str[n] - 'a']++;
scanf("%d", &m);
tot = 1;
for (int i = (1); i <= (m); i++) {
for (int j = (0); j <= (5); j++) v[j] = 1;
t = 0;
scanf("%d", &x);
scanf("%s", str);
for (int j = 0; str[j]; j++) v[str[j] - 'a'] = 0;
for (int j = (0); j <= (5); j++)
if (v[j]) t += 1 << j;
q[x] = t;
}
for (int i = (0); i <= (5); i++) v[i] = 0;
for (int i = (1); i <= (n); i++) ss[q[i]]++;
for (int i = (0); i <= (5); i++) lk(1, 2 + i, s[i]);
for (int i = (0); i <= (62); i++) lk(8 + i, 71, ss[i]);
for (int i = (0); i <= (5); i++)
for (int j = (0); j <= (62); j++)
if (!((j >> i) & 1)) lk(2 + i, 8 + j, 1000000000);
for (;;) {
for (int i = (1); i <= (71); i++) v[i] = fl[i] = 0;
fl[1] = 1000000000;
for (int o = (1); o <= (71); o++) {
fw = 0;
for (int i = (1); i <= (71); i++)
if ((!v[i]) && (fl[i] > fw)) fw = fl[i], rt = i;
if (!fw) break;
v[rt] = 1;
for (int i = st[rt]; i; i = nt[i])
if (((w[i]) < (fw) ? (w[i]) : (fw)) > fl[p[i]]) {
fl[p[i]] = ((w[i]) < (fw) ? (w[i]) : (fw));
pr[p[i]] = i ^ 1;
}
}
if (!fl[71]) break;
ans += fl[71];
for (int i = pr[71]; i; i = pr[p[i]]) w[i] += fl[71], w[i ^ 1] -= fl[71];
}
if (ans < n) {
printf("Impossible");
return 0;
}
for (int i = (1); i <= (n); i++) {
for (int j = (1); j <= (71); j++) v[j] = 0;
pr[8 + q[i]] = 0;
dfs(8 + q[i]);
for (int j = (0); j <= (5); j++)
if (v[2 + j] && (!((q[i] >> j) & 1))) {
printf("%c", 'a' + j);
for (int k = pr[2 + j]; k; k = pr[p[k]]) w[k]++, w[k ^ 1]--;
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[101010], tmp[6];
int m;
vector<int> avail[101010];
int mask[101010];
int n;
int suf[101010][64];
int cnt[6];
int ans[101010];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
scanf("%d", &m);
for (int i = 1, p; i <= m; ++i) {
scanf("%d %s", &p, tmp);
int len = strlen(tmp);
for (int i = 0; i < len; ++i) {
avail[p].emplace_back(tmp[i] - 'a');
mask[p] |= (1 << (tmp[i] - 'a'));
}
}
for (int i = 1; i <= n; ++i) {
cnt[s[i] - 'a']++;
if (mask[i]) continue;
mask[i] = 63;
for (int j = 0; j < 6; ++j) avail[i].emplace_back(j);
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j < 64; ++j) {
suf[i][j] = suf[i + 1][j] + !!(mask[i] & j);
}
}
memset(ans, 0xff, sizeof ans);
for (int i = 1; i <= n; ++i) {
sort(avail[i].begin(), avail[i].end());
for (int c : avail[i]) {
cnt[c]--;
for (int j = 0; j < 64; ++j) {
int a = suf[i + 1][j], b = 0;
for (int k = 0; k < 6; ++k) b += ((j >> k) & 1) * cnt[k];
if (a < b) goto nextchoice;
}
ans[i] = c;
break;
nextchoice:;
cnt[c]++;
}
if (!~ans[i]) {
puts("Impossible");
return 0;
}
}
for (int i = 1; i <= n; ++i) putchar('a' + ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + ch - 48, ch = getchar();
return x;
}
char s[N];
int n, v[N], suf[N][64], tot[64], sum[64], Log[64];
void getv() {
int m = read();
memset(v, 0, sizeof v);
while (m--) {
int id = read();
char s[10];
scanf("%s", s + 1);
int len = strlen(s + 1);
for (int i = 1; i <= len; i++) v[id] |= 1 << (s[i] - 'a');
}
for (int i = 1; i <= n; i++)
if (v[i] == 0) v[i] = 63;
}
bool check(int p) {
sum[0] = 0;
for (int i = 1; i < 64; i++) {
sum[i] = sum[i ^ (i & -i)] + tot[i & -i];
if (sum[i] < suf[p][i]) return 0;
}
return 1;
}
int main() {
Log[1] = 0;
for (int i = 2; i < 64; i++) Log[i] = Log[i >> 1] + 1;
gets(s + 1);
n = strlen(s + 1);
getv();
memset(tot, 0, sizeof tot);
for (int i = 1; i <= n; i++) tot[1 << (s[i] - 'a')]++;
memset(suf, 0, sizeof suf);
for (int i = n; i >= 1; i--) {
for (int j = 0; j < 64; j++) suf[i][j] = suf[i + 1][j];
suf[i][v[i]]++;
}
for (int id = 1; id <= n; id++)
for (int i = 1; i < 64; i <<= 1)
for (int j = 0; j < 64; j++)
if (j & i) suf[id][j] += suf[id][j ^ i];
if (!check(1)) {
printf("Impossible");
return 0;
}
for (int i = 1; i <= n; i++)
for (int j = v[i], k = j & -j; j; j -= k, k = j & -j) {
tot[k]--;
if (check(i + 1)) {
s[i] = 'a' + Log[k];
break;
}
tot[k]++;
}
puts(s + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e5 + 42;
int seen[6];
int possible[nmax];
int there[nmax];
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
string inp;
cin >> inp;
for (auto k : inp) seen[k - 'a']++;
for (int i = 1; i <= inp.size(); i++) possible[i] = (1 << 6) - 1;
int m;
int pos;
string current;
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> pos >> current;
possible[pos] = 0;
for (auto k : current) possible[pos] += (1 << (k - 'a'));
}
for (int i = 1; i <= inp.size(); i++) there[possible[i]]++;
for (pos = 1; pos <= inp.size(); pos++) {
int actual = 0;
while (actual < 6) {
if ((possible[pos] & (1 << actual)) == 0 || seen[actual] == 0) {
actual++;
continue;
}
seen[actual]--;
there[possible[pos]]--;
bool ok = 1;
for (int left_side = 0; left_side < (1 << 6); left_side++) {
int want = 0, available = 0;
for (int j = 0; j < 6; j++)
if ((left_side & (1 << j))) want = want + seen[j];
for (int right_side = 0; right_side < (1 << 6); right_side++) {
if ((left_side & right_side)) available += there[right_side];
}
if (want > available) {
ok = 0;
break;
}
}
if (ok == 0) {
seen[actual]++;
there[possible[pos]]++;
actual++;
continue;
}
cout << char('a' + actual);
break;
}
if (actual == 6) {
cout << "Impossible" << endl;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int cnt[6], n, m, sum[N][64], g[64], h[64];
bool bz[N], ok[N][64];
char S[N], T[N];
int main() {
scanf("%s%d", S + 1, &m);
n = strlen(S + 1);
for (int i = 1; i <= n; i++) cnt[S[i] -= 'a']++;
for (int y, x; m--;) {
scanf("%d%s", &x, T);
y = strlen(T);
y = strlen(T);
bz[x] = 1;
for (int i = 0; i < y; i++) ok[x][T[i] - 'a'] = 1;
}
for (int i = 1; i <= n; i++)
if (!bz[i]) {
for (int j = 0; j < 6; j++) ok[i][j] = 1;
}
for (int i = n; i; i--) {
int s = 0;
for (int j = 0; j < 6; j++) s |= (ok[i][j] << j);
for (int j = 0; j < 64; j++) {
sum[i][j] = sum[i + 1][j];
if ((j & s) == s) sum[i][j]++;
}
}
for (int j, i = 1; i <= n; i++) {
for (j = 0; j < 6; j++)
if (cnt[j] && ok[i][j]) {
bool bz = 1;
cnt[j]--;
for (int k = 0; k < 6; k++) g[1 << k] = cnt[k];
for (int k = 1; k < 64; k++) {
g[k] = g[k ^ (k & -k)] + g[k & -k];
if (g[k] < sum[i + 1][k]) {
bz = 0;
break;
}
}
if (bz) {
putchar('a' + j);
break;
}
cnt[j]++;
}
if (j == 6) {
puts("Impossible");
return 0;
}
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 100010;
int n, m, expected_maxflow;
char s[maxn], ret[maxn];
int need_mask[maxn];
int charcnt[6], maskcnt[1 << 6];
int s_id() { return 6; }
int t_id() { return 7; }
int char_id(int c) { return c; }
int mask_id(int m) { return m + 8; }
string mid_to_string(int m) {
m -= 8;
string ret;
for (int i = 0; i < 6; ++i)
if (m & (1 << i)) ret += char('a' + i);
return ret;
}
const int max_id = (1 << 6) + 8;
struct Edge {
int from, to, cap, flow;
};
ostream& operator<<(ostream& os, const Edge& edge) {
os << "Edge: from " << edge.from << ", to " << edge.to << ", cap " << edge.cap
<< ", flow " << edge.flow;
os << endl;
return os;
}
vector<Edge> e[max_id];
int eid[max_id][max_id];
void add_edge(int from, int to, int cap, int flow) {
eid[from][to] = int(e[from].size());
e[from].push_back(Edge{from, to, cap, flow});
}
Edge& get_edge(int from, int to) { return e[from][eid[from][to]]; }
bool get_path(int& flow, vector<int>& nodes) {
vector<int> rest(max_id), pre(max_id);
rest[s_id()] = inf;
vector<int> q;
q.push_back(s_id());
while (q.size()) {
int u = q.back();
q.pop_back();
if (!rest[u]) continue;
for (auto& edge : e[u]) {
if (rest[edge.to]) continue;
if (edge.cap == edge.flow) continue;
rest[edge.to] = min(rest[u], edge.cap - edge.flow);
q.push_back(edge.to);
pre[edge.to] = u;
if (edge.to == t_id()) break;
}
}
if (rest[t_id()] == 0) return false;
flow = rest[t_id()];
nodes.clear();
for (int u = t_id(); true; u = pre[u]) {
nodes.push_back(u);
if (u == s_id()) break;
}
return true;
}
void add_flow(int deltaflow, const vector<int>& path) {
int path_size = path.size();
for (int i = 1; i < path_size; ++i) {
int from = path[i], to = path[i - 1];
get_edge(from, to).flow += deltaflow;
if (from != s_id() && to != t_id()) {
get_edge(to, from).flow += -deltaflow;
}
}
}
int get_max_flow() {
int max_flow = 0;
int deltaflow;
vector<int> path;
while (get_path(deltaflow, path)) {
max_flow += deltaflow;
add_flow(deltaflow, path);
}
return max_flow;
}
void cut_flow(int cid, int mid, int delta = -1, bool cat_cid_cap = true,
bool cut_mid_cap = true) {
if (cat_cid_cap) {
get_edge(s_id(), cid).cap += delta;
}
get_edge(s_id(), cid).flow += delta;
get_edge(cid, mid).flow += delta;
get_edge(mid, cid).flow -= delta;
if (cut_mid_cap) {
get_edge(mid, t_id()).cap += delta;
}
get_edge(mid, t_id()).flow += delta;
}
bool could_pick(int ch, int mask) {
int cid = char_id(ch);
int mid = mask_id(mask);
auto& s2c = get_edge(s_id(), cid);
if (s2c.cap <= 0) return false;
;
if (get_edge(cid, mid).flow > 0) {
cut_flow(cid, mid);
return true;
}
int other_mid = -1;
for (int i = 0; i < 1 << 6; ++i) {
if (~i & (1 << ch)) continue;
if (!maskcnt[i]) continue;
if (get_edge(cid, mask_id(i)).flow > 0) {
other_mid = mask_id(i);
break;
}
}
cut_flow(cid, other_mid, -1, true, false);
int other_cid = -1;
for (int i = 0; i < 6; ++i) {
if (~mask & (1 << i)) continue;
if (!charcnt[i]) continue;
if (get_edge(char_id(i), mid).flow > 0) {
other_cid = char_id(i);
break;
}
}
cut_flow(other_cid, mid, -1, false, true);
;
int flow;
vector<int> path;
if (get_path(flow, path)) {
;
add_flow(flow, path);
return true;
}
cut_flow(cid, other_mid, 1, true, false);
cut_flow(other_cid, mid, 1, false, true);
return false;
}
void solve() {
int max_flow = get_max_flow();
;
if (max_flow < expected_maxflow) {
puts("Impossible");
return;
}
for (int i = 0; i < n; ++i) {
int mask = need_mask[i];
for (int j = 0; j < 6; ++j) {
if (charcnt[j] <= 0) continue;
if (~mask & (1 << j)) continue;
bool could = could_pick(j, need_mask[i]);
if (could) {
ret[i] = j + 'a';
break;
}
}
}
printf("%s\n", ret);
}
int main() {
scanf("%s\n", s);
n = strlen(s);
scanf("%d\n", &m);
for (int i = 0; i < n; ++i) {
++charcnt[s[i] - 'a'];
need_mask[i] = (1 << 6) - 1;
}
for (int i = 0; i < m; ++i) {
int p;
char t[10];
scanf("%d %s\n", &p, t);
--p;
int tlen = strlen(t);
int mask = 0;
for (int k = 0; k < tlen; ++k) mask |= 1 << (t[k] - 'a');
need_mask[p] = mask;
}
for (int i = 0; i < n; ++i) {
++maskcnt[need_mask[i]];
++expected_maxflow;
}
for (int i = 0; i < 6; ++i) {
int cap = charcnt[i];
if (!cap) continue;
int from = s_id(), to = char_id(i);
add_edge(from, to, cap, 0);
}
for (int i = 0; i < 1 << 6; ++i) {
int cap = maskcnt[i];
if (!cap) continue;
int from = mask_id(i), to = t_id();
add_edge(from, to, cap, 0);
}
for (int i = 0; i < 1 << 6; ++i) {
if (!maskcnt[i]) continue;
int to = mask_id(i), cap = inf;
for (int j = 0; j < 6; ++j) {
if (!charcnt[j]) continue;
if (~i & (1 << j)) continue;
int from = char_id(j);
add_edge(from, to, cap, 0);
add_edge(to, from, 0, 0);
}
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int Mx = 1 << 6;
int n, m;
char s[N], ans[N];
int cnt[Mx], f[N][Mx], e[N];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < Mx; j++) {
if (j & (1 << (s[i] - 'a'))) cnt[j]++;
}
}
for (int i = 1; i <= n; i++) e[i] = Mx - 1;
scanf("%d", &m);
for (int i = 1, pos, ln; i <= m; i++) {
scanf("%d%s", &pos, s + 1);
e[pos] = 0;
ln = strlen(s + 1);
for (int j = 1; j <= ln; j++) e[pos] |= 1 << (s[j] - 'a');
}
for (int i = n; i; i--) {
for (int j = 0; j < Mx; j++) {
f[i][j] += f[i + 1][j];
if ((j & e[i]) == e[i]) f[i][j]++;
}
}
for (int i = 1, flg, ok; i <= n; i++) {
flg = 0;
for (int j = 0; j < 6; j++) {
if ((e[i] >> j & 1) == 0 || !cnt[1 << j]) continue;
ok = 1;
for (int k = 0; k < Mx; k++) {
if (f[i + 1][k] > cnt[k] - (k >> j & 1)) {
ok = 0;
break;
}
}
if (ok) {
flg = 1;
ans[i] = j + 'a';
for (int k = 0; k < Mx; k++)
if (k >> j & 1) cnt[k]--;
break;
}
}
if (!flg) return puts("Impossible"), 0;
}
puts(ans + 1);
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 1e5 + 500;
const int inf = 1e9 + 500;
inline char foot(const string &s) {
char ans = 0;
for (int i = 0; i < s.size(); i++) ans |= (1 << (s[i] - 'a'));
return ans;
}
int d[6];
int e[64];
char w[maxn];
int r[64];
char u[64];
inline void add(char a) {
for (char j = 0; j < 64; j++) e[j] += ((a | j) == j);
}
inline void eras(char a) {
for (char j = 0; j < 64; j++) e[j] -= ((a | j) == j);
}
inline bool ok() {
for (char i = 1; i < 64; i++) {
r[i] = r[i ^ (i & (-i))] + d[u[i]];
if (r[i] < e[i]) {
return 0;
}
}
return 1;
}
char best(char Q) {
char ans = Q;
for (char i = 1; i < 64; i++) {
r[i] = r[i ^ (i & (-i))] + d[u[i]];
if (r[i] == e[i]) {
ans &= (~i);
}
}
for (char i = 0; i < 6; i++)
if ((ans >> i) & 1) return ('a' + i);
}
int main() {
for (char i = 0; i < 64; i++) {
if (i & 1)
u[i] = 0;
else
u[i] = u[i / 2] + 1;
}
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int m = s.size();
for (int i = 0; i < m; i++) {
d[s[i] - 'a']++;
}
int n;
cin >> n;
for (int i = 0; i < m; i++) {
w[i] = 63;
}
for (int i = 0; i < n; i++) {
int pos;
string ss;
cin >> pos >> ss;
w[pos - 1] = foot(ss);
}
for (int i = 0; i < m; i++) {
add(w[i]);
}
if (!ok()) {
cout << "Impossible";
return 0;
}
string ans;
for (int i = 0; i < m; i++) {
eras(w[i]);
ans += best(w[i]);
d[ans.back() - 'a']--;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
string ss;
int n, m, cnt[7], dem[1 << 7], res[100005], dd[1 << 7], M[100005], id1[1 << 7],
id2[1 << 7];
int s, t, cur_time, d[1 << 7], pos[1 << 7];
vector<int> g[100005];
struct edge {
int u, v, c, f;
edge(int _u = 0, int _v = 0, int _c = 0, int _f = 0)
: u(_u), v(_v), c(_c), f(_f){};
} e[1000];
int cntE = 0;
void add_edge(int u, int v, int c) {
g[u].push_back(cntE);
e[cntE++] = edge(u, v, c, 0);
g[v].push_back(cntE);
e[cntE++] = edge(v, u, 0, 0);
}
bool BFS() {
dd[s] = ++cur_time;
queue<int> q;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
pos[u] = 0;
for (auto id : g[u]) {
int v = e[id].v;
if (dd[v] == cur_time || e[id].c == e[id].f) continue;
dd[v] = cur_time;
q.push(v);
d[v] = d[u] + 1;
}
}
return dd[t] == cur_time;
}
int DFS(int u, int delta) {
if (u == t || delta == 0) return delta;
for (; pos[u] < g[u].size(); pos[u]++) {
int id = g[u][pos[u]];
int v = e[id].v;
if (d[v] != d[u] + 1 || e[id].f == e[id].c) continue;
if (int x = DFS(v, min(delta, e[id].c - e[id].f))) {
e[id].f += x;
e[id ^ 1].f -= x;
return x;
}
}
return 0;
}
void buildGraph() {
for (int i = 0; i <= cntE; i++) e[i].f = 0;
}
int MaxFlow() {
buildGraph();
int MF = 0;
while (BFS()) {
while (int x = DFS(s, 1000000007)) MF += x;
}
return MF;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> ss;
n = ss.size();
for (auto c : ss) cnt[c - 'a']++;
cin >> m;
for (int i = 1; i <= m; i++) {
int pos, mask = 0;
cin >> pos >> ss;
for (auto c : ss) mask |= (1 << (c - 'a'));
M[pos] = mask;
dem[mask]++;
}
for (int i = 1; i <= n; i++)
if (M[i] == 0) M[i] = (1 << 6) - 1, dem[M[i]]++;
s = 6 + (1 << 6) + 2;
t = 6 + (1 << 6) + 3;
for (int i = 0; i <= 5; i++)
for (int j = 0; j <= (1 << 6) - 1; j++)
if (((j >> i) & 1)) add_edge(i, j + 6, 1000000007);
for (int i = 0; i <= 5; i++) {
id2[i] = cntE;
add_edge(s, i, cnt[i]);
}
for (int i = 0; i <= (1 << 6) - 1; i++) {
id1[i] = cntE;
add_edge(i + 6, t, dem[i]);
}
for (int i = 1; i <= n; i++) {
e[id1[M[i]]].c--;
bool flag = 0;
for (int j = 0; j <= 5; j++) {
if (!((M[i] >> j) & 1) || cnt[j] == 0) continue;
cnt[j]--;
res[i] = j;
e[id2[j]].c--;
if (MaxFlow() == (n - i)) {
flag = 1;
break;
}
cnt[j]++;
e[id2[j]].c++;
}
if (!flag) {
cout << "Impossible";
return 0;
}
}
for (int i = 1; i <= n; i++) cout << (char)('a' + res[i]);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.