text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
void upd(int &x, int y) { x = x + y < 998244353 ? x + y : x + y - 998244353; }
int dp[100 + 5][5100 + 5];
long long qp(long long a, int k) {
long long ans = 1;
while (k) {
if (k & 1) ans = ans * a % 998244353;
a = a * a % 998244353;
k >>= 1;
}
return ans;
}
void solve(int N, int S, int upp) {
S += N;
dp[0][0] = 1;
for (int p = 1; p <= N; p++)
for (int s = 1; s <= S; s++) {
dp[p][s] = dp[p][s - 1];
upd(dp[p][s], dp[p - 1][s - 1]);
if (s - upp - 1 >= 0) upd(dp[p][s], 998244353 - dp[p - 1][s - upp - 1]);
}
}
long long fac[5100 + 5], inv[5100 + 5], ifac[5100 + 5];
long long C(long long n, long long m) {
return fac[n] * ifac[m] % 998244353 * ifac[n - m] % 998244353;
}
int main() {
fac[0] = ifac[0] = 1;
inv[1] = 1;
for (int i = 1; i <= 5100; i++) fac[i] = fac[i - 1] * i % 998244353;
for (int i = 2; i <= 5100; i++)
inv[i] = inv[998244353 % i] * (998244353 - 998244353 / i) % 998244353;
for (int i = 1; i <= 5100; i++) ifac[i] = ifac[i - 1] * inv[i] % 998244353;
int p, s, r;
scanf("%d%d%d", &p, &s, &r);
int ans = 0;
for (int i = r; i <= s; i++) {
solve(p - 1, s - i, i);
for (int num = 0; num <= p - 1 && num * i <= s - i; num++) {
long long tmp = dp[p - 1 - num][s - i - num * i + p - 1 - num] *
qp(num + 1, 998244353 - 2) % 998244353;
tmp = tmp * C(p - 1, num) % 998244353;
upd(ans, tmp);
}
}
ans = ans * qp(C(s - r + p - 1, p - 1), 998244353 - 2) % 998244353;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const long long MAXN = 5107;
long long sum(long long a, long long b) {
return a + b >= MOD ? a + b - MOD : a + b;
}
long long sub(long long a, long long b) {
return a - b < 0 ? a - b + MOD : a - b;
}
long long mul(long long a, long long b) { return (a * b) % MOD; }
long long pw(long long a, long long b) {
if (b == 0) return 1;
long long r = pw(a, b / 2);
r = mul(r, r);
if (b % 2) r = mul(r, a);
return r;
}
long long fct[MAXN], inv[MAXN], ulta[MAXN];
long long p, s, r;
long long nCr(long long n, long long r) {
return mul(fct[n], mul(inv[r], inv[n - r]));
}
long long f(long long p, long long s, long long b) {
if (p == 0) {
if (s == 0) return 1;
return 0;
}
long long ans = nCr(s + p - 1, p - 1);
long long sgn = 1;
for (long long i = 1; i <= p; i++) {
sgn = mul(sgn, MOD - 1);
if (i * b > s) break;
long long ss = s - i * b;
ans = sum(ans, mul(sgn, mul(nCr(p, i), nCr(ss + p - 1, p - 1))));
}
return ans;
}
int main() {
fct[0] = inv[0] = 1;
for (long long i = 1; i < MAXN; i++) {
fct[i] = mul(fct[i - 1], i);
inv[i] = pw(fct[i], MOD - 2);
ulta[i] = pw(i, MOD - 2);
}
cin >> p >> s >> r;
if (s == 0 && r == 0) {
cout << pw(p, MOD - 2) << endl;
return 0;
}
long long tot = nCr(s - r + p - 1, p - 1);
if (r == 0) r++;
long long ans = 0;
for (long long i = r; i <= s; i++) {
for (long long j = 1; j <= p; j++) {
if (j * i > s) break;
ans = sum(ans,
mul(ulta[j], mul(nCr(p - 1, j - 1), f(p - j, s - j * i, i))));
}
}
ans = mul(ans, pw(tot, MOD - 2));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
inline long long read() {
long long x = 0;
char c = getchar(), f = 1;
for (; c < '0' || '9' < c; c = getchar())
if (c == '-') f = -1;
for (; '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
return x * f;
}
inline void write(long long x) {
static char buf[20];
int len = 0;
if (x < 0) putchar('-'), x = -x;
for (; x; x /= 10) buf[len++] = x % 10 + '0';
if (!len)
putchar('0');
else
while (len) putchar(buf[--len]);
}
inline void writesp(long long x) {
write(x);
putchar(' ');
}
inline void writeln(long long x) {
write(x);
putchar('\n');
}
long long fac[6010], inv[6010];
int p, s, r;
inline long long power(long long a, long long b) {
long long ans = 1;
for (; b; b >>= 1, a = a * a % 998244353)
if (b & 1) ans = ans * a % 998244353;
return ans;
}
long long C(int n, int m) {
return (n < 0 || m < 0 || m > n)
? 0
: fac[n] * inv[m] % 998244353 * inv[n - m] % 998244353;
}
long long solve(int n, int s, int mx) {
if (!n) return !s;
long long tot = 0;
for (int i = 0; i <= n; i++)
if (i & 1)
tot = (tot + (998244353 - C(n, i)) * C(s - i * (mx + 1) + n - 1, n - 1)) %
998244353;
else
tot = (tot + C(n, i) * C(s - i * (mx + 1) + n - 1, n - 1)) % 998244353;
return tot;
}
int main() {
p = read();
s = read();
r = read();
fac[0] = inv[0] = 1;
for (int i = 1; i <= s + p; i++) {
fac[i] = fac[i - 1] * i % 998244353;
inv[i] = power(fac[i], 998244353 - 2);
}
long long ans = 0;
for (int i = r; i <= s; i++)
for (int j = 1; j * i <= s && j <= p; j++)
ans = (ans + C(p - 1, j - 1) * solve(p - j, s - i * j, i - 1) %
998244353 * power(j, 998244353 - 2)) %
998244353;
writeln(ans * power(C(s - r + p - 1, p - 1), 998244353 - 2) % 998244353);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, r, s;
long long F[10005] = {1}, I[10005];
long long inv(long long a) {
long long ans = 1;
for (int k = 998244353 - 2; k; k >>= 1) {
if (k & 1) ans = (ans * a) % 998244353;
a = a * a % 998244353;
}
return ans;
}
long long C(int n, int m) {
return n < m ? 0 : F[n] * I[m] % 998244353 * I[n - m] % 998244353;
}
long long calc(int s, int n, int r) {
if (!n) return !s && r >= 0;
long long ans = 0;
for (int i = 0; i <= n; ++i) {
long long t = C(s - r * i + n - 1, n - 1) * C(n, i) % 998244353;
if (i & 1)
ans = (ans + 998244353 - t) % 998244353;
else
ans = (ans + t) % 998244353;
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &s, &r);
for (int i = 1; i < 10005; ++i) F[i] = F[i - 1] * i % 998244353;
I[10005 - 1] = inv(F[10005 - 1]);
for (int i = 10005 - 1; i; --i) I[i - 1] = I[i] * i % 998244353;
long long ans = 0;
for (int i = max((s + n - 1) / n, r); i <= s; ++i)
for (int c = 1; c <= n && c * i <= s; ++c) {
ans = (ans +
calc(s - c * i, n - c, i) * C(n - 1, c - 1) % 998244353 * inv(c)) %
998244353;
}
ans = ans * inv(C(s - r + n - 1, n - 1)) % 998244353;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
inline long long read() {
long long x = 0;
char c = getchar(), f = 1;
for (; c < '0' || '9' < c; c = getchar())
if (c == '-') f = -1;
for (; '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
return x * f;
}
inline void write(long long x) {
static char buf[20];
int len = 0;
if (x < 0) putchar('-'), x = -x;
for (; x; x /= 10) buf[len++] = x % 10 + '0';
if (!len)
putchar('0');
else
while (len) putchar(buf[--len]);
}
inline void writesp(long long x) {
write(x);
putchar(' ');
}
inline void writeln(long long x) {
write(x);
putchar('\n');
}
long long fac[200010], inv[200010];
int p, s, r;
inline long long power(long long a, long long b) {
long long ans = 1;
for (; b; b >>= 1, a = a * a % 998244353)
if (b & 1) ans = ans * a % 998244353;
return ans;
}
long long C(int n, int m) {
return (n < 0 || m < 0 || m > n)
? 0
: fac[n] * inv[m] % 998244353 * inv[n - m] % 998244353;
}
long long solve(int n, int s, int mx) {
if (!n) return !s;
long long tot = 0;
for (int i = 0; i <= n; i++)
if (i & 1)
tot = (tot + (998244353 - C(n, i)) * C(s - i * (mx + 1) + n - 1, n - 1)) %
998244353;
else
tot = (tot + C(n, i) * C(s - i * (mx + 1) + n - 1, n - 1)) % 998244353;
return tot;
}
int main() {
fac[0] = inv[0] = 1;
for (int i = 1; i <= 2e5; i++) {
fac[i] = fac[i - 1] * i % 998244353;
inv[i] = power(fac[i], 998244353 - 2);
}
p = read();
s = read();
r = read();
long long ans =
(C(p + s - 1, p - 1) - solve(p, s, r - 1) + 998244353) *
power(p * C(p + s - r - 1, p - 1) % 998244353, 998244353 - 2) % 998244353;
writeln(ans);
return 0;
}
|
#include <bits/stdc++.h>
const long long inf = 0x3f3f3f3f3f3f3f3LL;
const long long mod = 998244353;
using namespace std;
template <class T>
void smin(T& a, T val) {
if (a > val) a = val;
}
template <class T>
void smax(T& a, T val) {
if (a < val) a = val;
}
template <typename T>
inline std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
bool first = true;
os << "[";
for (auto i : v) {
if (!first) os << ", ";
os << i;
first = false;
}
return os << "]";
}
const long long N = 5 * 1e3 + 110;
long long NCR[N][N];
long long p, s, r;
long long nCr(long long n, long long r) {
if (n < r or r < 0 or n < 0) return 0;
return NCR[n][r];
}
long long solve(long long score, long long cnt) {
if (s - cnt * score < 0) return 0;
if (p - cnt == 0) return (score * cnt) == s;
if (cnt == 0) return 0;
long long ans = 0;
for (long long i = 0, flag = 1; i <= p - cnt; ++i, flag *= -1) {
long long tt = flag * nCr(p - cnt, i);
if (tt < 0) tt += mod;
tt %= mod;
long long tt2 = nCr(s - score * cnt - i * score + p - cnt - 1, p - cnt - 1);
ans += tt * tt2 % mod;
ans %= mod;
}
ans %= mod;
return ans;
}
long long power(long long a, long long b, long long m = mod) {
if (b < 0) b += m - 1;
long long r = 1;
while (b) {
if (b & 1) r = (r * a) % m;
a = (a * a) % m;
b >>= 1;
}
return r;
}
long long inv[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> p >> s >> r;
for (long long i = 0; i <= 5100; ++i) {
for (long long j = 0; j <= i; ++j) {
if (j == 0 or j == i) {
NCR[i][j] = 1;
} else {
NCR[i][j] = NCR[i - 1][j - 1] + NCR[i - 1][j];
if (NCR[i][j] >= mod) NCR[i][j] -= mod;
}
}
}
for (long long i = 0; i <= 5100; ++i) {
inv[i] = power(i, -1);
}
assert(s - r + p - 1 >= p - 1);
long long den = nCr(s - r + p - 1, p - 1);
long long ans = 0;
for (long long score = r; score <= s; ++score) {
for (long long cnt = 1; cnt <= p; ++cnt) {
long long tmp = solve(score, cnt);
tmp = tmp * nCr(p - 1, cnt - 1) % mod;
tmp = tmp * inv[cnt] % mod;
ans += tmp;
if (ans < 0) ans += mod;
ans %= mod;
}
}
ans = (ans * power(den, -1)) % mod;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
long long n, sum, lb;
const int MX = 100005;
const long long MOD = 998244353;
long long fact[MX];
long long mpow(long long base, long long exp) {
if (exp == 0) return 1;
long long res = mpow(base, exp / 2);
res *= res;
res %= MOD;
if (exp % 2 == 1) {
res *= base;
res %= MOD;
}
return res;
}
long long inv(long long k) { return mpow(k, MOD - 2); }
long long binom(long long a, long long b) {
long long res = fact[a];
res *= inv(fact[b]);
res %= MOD;
res *= inv(fact[a - b]);
res %= MOD;
return res;
}
long long split(long long a, long long b) { return binom(a + b - 1, b - 1); }
long long getCnt(long long balls, long long boxes, long long cap) {
if (cap < 0) return (boxes == 0 && balls == 0);
if (boxes == 0) return (balls == 0);
long long res = 0;
for (int i = 0; i < boxes + 1; i++) {
long long rem = balls + boxes - 1 - i * (cap + 1);
if (rem < boxes - 1) continue;
long long fac = (binom(rem, boxes - 1) * binom(boxes, i)) % MOD;
if (i % 2 == 0)
res += fac;
else
res += MOD - fac;
res %= MOD;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
fact[0] = 1;
for (int i = 1; i < MX; i++) fact[i] = (fact[i - 1] * i) % MOD;
cin >> n >> sum >> lb;
long long ans = 0;
for (long long numTied = 1; numTied <= n; numTied++) {
for (long long besScore = lb; besScore <= sum; besScore++) {
if (numTied * besScore > sum) continue;
long long val = (inv(numTied) * binom(n - 1, numTied - 1)) % MOD;
val *= getCnt(sum - numTied * besScore, n - numTied, besScore - 1);
val %= MOD;
ans += val;
ans %= MOD;
}
}
ans *= inv(split(sum - lb, n));
ans %= MOD;
return cout << ans << '\n', 0;
;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
int const N = 100 + 20, M = 5000 + 220, mod = 998244353;
int n, r, s;
int ans;
int C[M][N];
inline void rel(int &a) {
if (a >= mod) a -= mod;
}
inline int pw(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return res;
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
for (int i = 0; i < M; i++) {
C[i][0] = 1;
for (int j = 1; j < N && j <= i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
rel(C[i][j]);
}
}
cin >> n >> s >> r;
if (r == 0) return cout << pw(n, mod - 2) << '\n', 0;
for (int p = 1; p <= n; p++) {
int save = pw(p, mod - 2);
for (int k = r; p * k <= s; k++) {
int SUM = s - p * k;
int t = n - p;
int res = 0;
if (!t) {
if (!SUM) ans = ans + save, rel(ans);
continue;
}
for (int bad = 0; bad <= t && bad * k <= SUM; bad++) {
int nsum = SUM - bad * k;
int add = 1ll * C[nsum + t - 1][t - 1] * C[t][bad] % mod;
if (bad & 1)
res = (res - add + mod), rel(res);
else
res = (res + add), rel(res);
}
res = 1ll * res * C[n - 1][p - 1] % mod;
ans += 1ll * res * save % mod;
rel(ans);
}
}
ans = 1ll * ans * pw(C[s - r + n - 1][n - 1], mod - 2) % mod;
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int N, S, R;
long long fac[6005], ifac[6005];
long long qpow(long long x, int n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % int(998244353);
x = x * x % int(998244353);
n /= 2;
}
return res;
}
void init() {
int NN = 6e3;
fac[0] = ifac[0] = 1;
for (int i = 1; i <= NN; i++) {
fac[i] = fac[i - 1] * i % int(998244353);
ifac[i] = qpow(fac[i], int(998244353) - 2);
}
}
long long comb(int n, int k) {
if (n < 0 || k < 0 || n < k) return 0;
return fac[n] * ifac[k] % int(998244353) * ifac[n - k] % int(998244353);
}
long long div(int s, int n, int x) {
if (s > n * x) return 0;
if (s == 0) return 1;
long long ans = 0;
for (int j = 0; j <= n && j * (x + 1) <= s; ++j) {
if (s - j * (x + 1) > (n - j) * x) continue;
ans = (ans +
qpow(-1, j) * comb(n, j) % int(998244353) *
comb(s - j * (x + 1) + n - 1, n - 1) % int(998244353) +
int(998244353)) %
int(998244353);
}
return ans;
}
int main() {
cin >> N >> S >> R;
init();
long long ans = 0;
int x0 = S / N;
if (S % N) ++x0;
for (int x = max(x0, R); x <= S; x++) {
for (int i = 1; i * x <= S && i <= N; i++) {
long long ans1 =
comb(N - 1, i - 1) * qpow(i, int(998244353) - 2) % int(998244353);
ans = (ans + ans1 * div(S - i * x, N - i, x - 1) % int(998244353)) %
int(998244353);
}
}
cout << ans * qpow(div(S - R, N, S - R), int(998244353) - 2) % int(998244353)
<< endl;
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ld = long double;
using vi = std::vector<int>;
using pii = std::pair<int, int>;
using vvi = std::vector<vi>;
using vii = std::vector<pii>;
using vll = std::vector<ll>;
using pll = std::pair<ll, ll>;
template <typename T>
int sign(const T& t) {
return (t > 0) - (t < 0);
}
template <typename T, typename U>
bool remax(T& a, U b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T, typename U>
bool remin(T& a, U b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T>
T gcd(T a, T b) {
a = std::abs(a);
b = std::abs(b);
while (b) {
a %= b;
std::swap(a, b);
}
return a;
}
template <typename T>
T lcm(T a, T b) {
a = std::abs(a);
b = std::abs(b);
return a / gcd(a, b) * b;
}
double get_time() { return static_cast<double>(clock()) / CLOCKS_PER_SEC; }
long long current_nanoseconds() {
return std::chrono::steady_clock::now().time_since_epoch().count();
}
long long default_seed = current_nanoseconds();
uint32_t mrand_32t() {
static std::mt19937 rng(default_seed);
return rng();
}
uint64_t mrand_64t() {
static std::mt19937_64 rng(default_seed);
return rng();
}
template <typename T>
void make_unique(std::vector<T>& v) {
std::sort(std::begin(v), std::end(v));
v.erase(std::unique(std::begin(v), std::end(v)), std::end(v));
}
namespace std {
template <typename A, typename B>
string to_string(const pair<A, B>& p) {
string str;
str += "(";
str += to_string(p.first);
str += ", ";
str += to_string(p.second);
str += ")";
return str;
}
string to_string(bool value) { return value ? "true" : "false"; }
template <typename T>
string to_string(const vector<T>& vec) {
string str = "{ ";
bool first = true;
for (const auto& it : vec) {
if (!first) {
str += ", ";
}
str += to_string(it);
first = false;
}
str += " }";
return str;
}
template <typename T>
string to_string(const set<T>& s) {
string str = "{ ";
bool first = true;
for (const auto& it : s) {
if (!first) {
str += ", ";
}
str += to_string(it);
first = false;
}
str += " }";
return str;
}
template <typename K, typename V>
string to_string(const map<K, V>& m) {
string str = "{ ";
bool first = true;
for (const auto& it : m) {
if (!first) {
str += ", ";
}
first = false;
str += to_string(it.first);
str += " -> ";
str += to_string(it.second);
}
str += " }";
return str;
}
string to_string(const string& s) { return "\"" + s + "\""; }
string to_string(const char* s) { return to_string(string(s)); }
string to_string(char ch) { return "\'" + string(1, ch) + "\'"; }
template <size_t N>
string to_string(const bitset<N>& b) {
string res(N, '0');
for (size_t i = 0; i < N; ++i) {
res[i] = '0' + b[i];
}
return res;
}
template <typename T>
string to_string(const T& t) {
std::stringstream ss;
ss << t;
return ss.str();
}
} // namespace std
void debug_out() { std::cerr << std::endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
std::cerr << " " << std::to_string(H);
debug_out(T...);
}
using namespace std;
const int MOD = 998244353;
void add(int& x, int y) { ((x += y) >= MOD) && (x -= MOD); }
void sub(int& x, int y) { add(x, -y + MOD); }
int mul(int x, int y) { return x * 1ll * y % MOD; }
int mpow(int a, int p) {
int res = 1;
for (; p > 0; p >>= 1, a = mul(a, a)) {
if (p & 1) {
res = mul(res, a);
}
}
return res;
}
int inv(int x) {
int y = mpow(x, MOD - 2);
assert(mul(x, y) == 1);
return y;
}
int p, s, r;
bool read() {
if (!(cin >> p >> s >> r)) {
return 0;
}
return 1;
}
const int MAXS = 5e3 + 500;
int binom[MAXS][MAXS * 2];
void precalc() {
memset(binom, 0, sizeof binom);
binom[0][0] = 1;
for (int i = 1; i < MAXS; ++i) {
binom[i][0] = 1;
for (int j = 1; j < MAXS; ++j) {
binom[i][j] = binom[i - 1][j];
add(binom[i][j], binom[i - 1][j - 1]);
}
}
}
int binom_repeat(int n, int k) { return binom[n + k - 1][k]; }
int part(int cnt, int sum) {
if (cnt == 0) {
return (sum == 0);
}
assert(cnt > 0);
return binom_repeat(sum + 1, cnt - 1);
}
int part(int cnt, int sum, int mx) {
int ans = part(cnt, sum);
for (int cnt_bad = cnt; cnt_bad > 0; --cnt_bad) {
const int rest_sum = sum - cnt_bad * mx;
if (rest_sum < 0) {
continue;
}
int cur = binom[cnt][cnt_bad];
cur = mul(cur, part(cnt, rest_sum));
if (cnt_bad % 2 == 1) {
sub(ans, cur);
} else {
add(ans, cur);
}
}
return ans;
}
int solve() {
if (p == 1) {
return 1;
}
vi ans_with(p + 1, 0);
int all = 0;
;
for (int mx = r; mx <= s; ++mx) {
const int cur_all = part(p - 1, s - mx);
add(all, cur_all);
;
for (int cnt = 0; cnt <= p - 1 && (cnt + 1) * mx <= s; ++cnt) {
int cur = binom[p - 1][cnt];
cur = mul(cur, part(p - 1 - cnt, s - (cnt + 1) * mx, mx));
add(ans_with[cnt], cur);
}
}
int good = 0;
for (int cnt = 0; cnt <= p - 1; ++cnt) {
int cur = ans_with[cnt];
;
cur = mul(cur, inv(cnt + 1));
add(good, cur);
};
int ans = good;
ans = mul(ans, inv(all));
;
return ans;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout.tie(nullptr);
cout.precision(12);
cout << fixed;
precalc();
while (read()) {
auto ans = solve();
cout << ans << endl;
break;
}
return 0;
}
|
#include <bits/stdc++.h>
template <int MOD>
struct Integral {
int v_ = 0;
template <typename T>
Integral(T v) : v_(norm(v)) {
static_assert(std::is_integral<T>::value, "input should be an integral.");
}
Integral() = default;
~Integral() = default;
template <typename T>
T norm(T v) const {
if (v >= MOD) v -= MOD;
if (v < 0) v += MOD;
if (v >= MOD || v < 0) v = (v % MOD + MOD) % MOD;
return v;
}
int val() const { return v_; }
Integral operator+(const Integral& rhs) const {
return Integral(val() + rhs.val());
}
Integral operator-(const Integral& rhs) const {
return Integral(val() - rhs.val());
}
Integral operator*(const Integral& rhs) const {
return Integral(val() * 1LL * rhs.val());
}
Integral operator/(const Integral& rhs) const { return *this * rhs.inv(); }
Integral& operator+=(const Integral& rhs) { return *this = *this + rhs; }
Integral& operator-=(const Integral& rhs) { return *this = *this - rhs; }
Integral& operator*=(const Integral& rhs) { return *this = *this * rhs; }
Integral& operator/=(const Integral& rhs) { return *this = *this / rhs; }
bool operator==(const Integral& rhs) const { return val() == rhs.val(); }
bool operator!=(const Integral& rhs) const { return !(*this == rhs); }
const Integral operator-() const { return Integral(-val()); }
const Integral operator++() {
v_ = norm(v_ + 1);
return *this;
}
const Integral operator++(int) {
Integral ret = *this;
++(*this);
return ret;
}
const Integral operator--() {
v_ = norm(v_ - 1);
return *this;
}
const Integral operator--(int) {
Integral ret = *this;
--(*this);
return ret;
}
Integral power(long long b) const {
long long ret = 1 % MOD, a = v_;
for (; b; b >>= 1, a = a * a % MOD)
if (b & 1) ret = ret * a % MOD;
return ret;
}
Integral inv() const { return power(MOD - 2); }
};
template <int MOD>
std::string to_string(const Integral<MOD>& v) {
return std::string("Integral{v=") + std::to_string(v.val()) + "}";
}
template <int MOD, bool kByDefinition = false>
struct Binomial {
std::vector<Integral<MOD>> factor, inv_factor;
explicit Binomial(int n = 0) : factor(n + 1), inv_factor(n + 1) {
factor[0] = 1;
for (int i = 1; i <= n; ++i) factor[i] = factor[i - 1] * i;
inv_factor[n] = factor[n].inv();
for (int i = n; i >= 1; --i) inv_factor[i - 1] = inv_factor[i] * i;
}
~Binomial() = default;
template <typename T>
Integral<MOD> operator()(T a, T b) const {
if (a < b || b < 0) return 0;
if (a < factor.size()) return factor[a] * inv_factor[b] * inv_factor[a - b];
if constexpr (!kByDefinition) {
throw;
} else {
b = std::min(b, a - b);
Integral<MOD> ret = 1;
for (T i = 1; i <= b; ++i) ret = ret * (a + 1 - i) / i;
return ret;
}
}
};
const int MOD = 998244353;
using Mint = Integral<MOD>;
using Binom = Binomial<MOD>;
Binom binom(10000);
Mint calc(int s, int n, int r) {
if (n == 0) return s == 0;
if (r < 0) return 0;
if (s > n * r) return 0;
Mint ret = binom(s + n - 1, n - 1);
for (int k = 1; k * (r + 1) <= s && k <= n; ++k) {
Mint val = binom(s - k * (r + 1) + n - 1, n - 1) * binom(n, k);
if (k & 1)
ret -= val;
else
ret += val;
}
return ret;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::istream& reader = std::cin;
int n, s, r;
reader >> n >> s >> r;
if (n == 1) {
puts("1");
return 0;
}
Mint result = 0;
for (int rr = r; rr <= s; ++rr) {
for (int k = 1; rr * k <= s && k <= n; ++k) {
result += calc(s - rr * k, n - k, rr - 1) * binom(n - 1, k - 1) / k;
}
}
result /= binom(s - r + n - 1, n - 1);
printf("%d\n", result.val());
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long power(long long a, long long r) {
long long res = 1;
for (; r; r >>= 1, a = a * a % mod)
if (r & 1) res = res * a % mod;
return res;
}
long long f[6000], uf[6000];
long long C(int m, int n) {
if (m < n) return 0;
return f[m] * uf[n] % mod * uf[m - n] % mod;
}
long long g(int m, int n, int p) {
long long r = 0;
if (n == 0) return m == 0;
for (int u = 1, i = 0;; u = mod - u, i += 1) {
long long k = C(m - i * p + n - 1, n - 1) * C(n, i) % mod * u % mod;
if (k == 0) break;
r = (r + k) % mod;
}
return r;
}
int main() {
for (int i = 0; i < 6000; i += 1)
uf[i] = power(f[i] = i ? f[i - 1] * i % mod : 1, mod - 2);
int p, r, s;
cin >> p >> s >> r;
long long ans = 0;
for (int a = r; a <= s; a += 1)
for (int x = 1; a * x <= s && x <= p; x += 1) {
ans += C(p - 1, x - 1) * g(s - x * a, p - x, a) % mod *
power(x, mod - 2) % mod;
ans %= mod;
}
ans = ans * power(C(s - r + p - 1, p - 1), mod - 2) % mod;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5500, mod = 998244353;
int p, s, r, ans, fac[N], inv[N];
void exGCD(int a, int b, int &x, int &y) {
if (!b) {
x = 1, y = 0;
return;
}
exGCD(b, a % b, y, x), y -= a / b * x;
}
int Inv(int x) {
int xx, yy;
exGCD(x, mod, xx, yy);
return (xx % mod + mod) % mod;
}
void Prework() {
fac[0] = inv[0] = 1;
for (int i = 1; i <= 5200; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[5200] = Inv(fac[5200]);
for (int i = 5199; i; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
}
int C(int n, int m) {
if (n == m) return 1;
if (n < m) return 0;
return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
}
int Calc(int cnt, int lim, int tot) {
int ret = C(tot + cnt - 1, cnt - 1);
for (int i = 1, j; i <= cnt; i++, ret %= mod)
j = i % 2 ? mod - 1 : 1, ret += 1ll * j * C(cnt, i) % mod *
C(tot - i * lim + cnt - 1, cnt - 1) % mod;
return (ret + mod) % mod;
}
int main() {
scanf("%d%d%d", &p, &s, &r), Prework();
for (int i = r; i <= s; i++)
for (int j = 1; j <= p && i * j <= s; j++, ans %= mod)
ans += 1ll * C(p - 1, j - 1) * Inv(j) % mod * Calc(p - j, i, s - i * j) %
mod;
printf("%lld", 1ll * ans * Inv(C(s - r + p - 1, p - 1)) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 7;
const int maxmsk = (1 << 17) + 7;
int n, p, num[maxn], ok[27][27];
int bad[maxmsk], met[27], sum[27];
bool hve[27];
string s;
void init() {
scanf("%d%d", &n, &p);
cin >> s;
for (int i = 0; i < n; i++) num[i] = s[i] - 'a', sum[num[i]]++;
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) scanf("%d", ok[i] + j);
}
}
void solve() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < p; j++) {
if (!hve[j]) continue;
if ((met[j] >> (num[i])) & 1) continue;
if (ok[num[i]][j]) continue;
bad[met[j]]++;
bad[met[j] | (1 << j)]--;
bad[met[j] | (1 << num[i])]--;
bad[met[j] | (1 << j) | (1 << num[i])]++;
}
hve[num[i]] = true;
for (int j = 0; j < p; j++) met[j] |= (1 << num[i]);
met[num[i]] = 0;
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < (1 << p); j++) {
if ((j >> i) & 1) bad[j] += bad[j ^ (1 << i)];
}
}
int ans = n;
for (int i = 1; i < (1 << p); i++) {
if (bad[i]) continue;
bool isbad = true;
for (int j = 0; j < p; j++) {
if ((i >> j) & 1) {
if (!bad[i ^ (1 << j)]) {
isbad = false;
break;
}
}
}
if (isbad) {
bad[i] = 1;
continue;
}
int res = 0;
for (int j = 0; j < p; j++) {
if (!((i >> j) & 1)) res += sum[j];
}
ans = min(ans, res);
}
printf("%d\n", ans);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
Solution(int n, int p, const string& s, vector<vector<int> > const& a)
: _n(n), _p(p), _s(s), _a(a), _b(1 << p, 0), _t(1 << p, 0) {}
int solve() {
for (int a = 0; a < _p; ++a) {
for (int b = 0; b < _p; ++b) {
if (_a[a][b]) continue;
f(a, b);
}
}
vector<int> c(_p, 0);
for (char si : _s) ++c[si - 'a'];
int fz = 1 << _p, r = 0;
vector<int> f(fz, -1);
f[0] = 0;
for (int x = 0; x < fz; ++x) {
if (_b[x]) continue;
for (int a = 0; a < _p; ++a) {
if (!(x & (1 << a))) continue;
if (f[x ^ (1 << a)] < 0) continue;
f[x] = max(f[x], c[a] + f[x ^ (1 << a)]);
r = max(r, f[x]);
}
}
return _n - r;
}
private:
void f(int a, int b) {
int tz = 1 << _p;
for (int i = 0; i < tz; ++i) _t[i] = 0;
for (int i = 0, x = 0, ta = 0, tb = 0; i < _n; ++i) {
int c = _s[i] - 'a';
if (c == b && tb < ta) {
tb = ta;
f(x & ~(1 << a) & ~(1 << b), a, b);
}
if (c == a) {
++ta;
x = 0;
}
x |= 1 << c;
}
for (int x = 0; x < tz; ++x) {
_b[x] = _b[x] | _t[x];
}
_t.clear();
}
void f(int x, int a, int b) {
if (_t[x]) return;
_t[x] = 1;
for (int k = 0; k < _p; ++k) {
if (k == a || k == b || (x & (1 << k))) continue;
f(x ^ (1 << k), a, b);
}
}
private:
int _n, _p;
string const& _s;
vector<vector<int> > const& _a;
vector<bool> _b, _t;
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, p;
string s;
cin >> n >> p >> s;
vector<vector<int> > a;
for (int i = 0; i < p; ++i) {
a.emplace_back(p);
for (int& ai : a.back()) cin >> ai;
}
cout << Solution(n, p, s, a).solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const int SZ = 1e6 + 10;
const int mod = 1e9 + 7;
const double PI = acos(-1);
const double eps = 1e-7;
long long read() {
long long n = 0;
char a = getchar();
bool flag = 0;
while (a > '9' || a < '0') {
if (a == '-') flag = 1;
a = getchar();
}
while (a <= '9' && a >= '0') {
n = n * 10 + a - '0', a = getchar();
}
if (flag) n = -n;
return n;
}
int n, m;
char s[SZ];
int nx[SZ][22];
void get_nxt() {
int b[22] = {0}, id[22] = {0};
for (int i = n; i >= 1; i--) {
int c = s[i] - 'a';
for (int j = 0; j < m; j++) {
if (id[j]) nx[i][j] = b[j];
b[j] |= 1 << c;
}
b[c] = 0;
id[c] = i;
}
}
int tim[22];
bitset<(1 << 17)> tmp, g, f;
bool mp[22][22];
int main() {
n = read(), m = read();
scanf("%s", s + 1);
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) mp[i][j] = read();
get_nxt();
g.set();
for (int i = 0; i < m; i++) {
for (int j = 0; j <= i; j++) {
if (mp[i][j]) continue;
tmp.set();
for (int k = 1; k <= n; k++) {
if (s[k] - 'a' == i) {
if (nx[k][j] && (nx[k][j] >> i & 1) == 0)
tmp.reset(((1 << m) - 1) ^ nx[k][j]);
} else if (s[k] - 'a' == j) {
if (nx[k][i] && (nx[k][i] >> j & 1) == 0)
tmp.reset(((1 << m) - 1) ^ nx[k][i]);
}
}
for (int l = (1 << m) - 1; l > 0; l--) {
if (tmp[l]) continue;
for (int k = 0; k < m; k++)
if (k != i && k != j && (l >> k & 1)) tmp.reset(l ^ (1 << k));
}
g &= tmp;
}
}
for (int i = 1; i <= n; i++) tim[s[i] - 'a']++;
f[(1 << m) - 1] = 1;
for (int S = (1 << m) - 1; S > 0; S--) {
if (!f[S]) continue;
for (int i = 0; i < m; i++) {
if (S >> i & 1) {
int x = S ^ (1 << i);
if (f[x]) continue;
f[x] = g[x];
}
}
}
int ans = n;
for (int S = (1 << m) - 1; S >= 0; S--) {
if (f[S]) {
int tmp = 0;
for (int i = 0; i < m; i++) {
if (S >> i & 1) {
tmp += tim[i];
}
}
ans = min(ans, tmp);
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100010];
int n, p, a[17][17], cnt[1 << 17];
bool ban[1 << 17], dp[1 << 17], vis[1 << 17];
void dfs(int S) {
if (vis[S]) return;
vis[S] = 1;
for (int i = 0; i < p; i++) {
if ((S >> i) & 1) {
dfs(S ^ (1 << i));
dp[S] |= dp[S ^ (1 << i)];
}
}
}
void init(int x, int y) {
memset(dp, 0, sizeof(dp));
int l = -1;
for (int i = 0; i < n; i++) {
if (s[i] - 'a' == x || s[i] - 'a' == y) {
l = i;
break;
}
}
if (l == -1) return;
int S = 0, r = l + 1;
while (l < n) {
while (r < n) {
if (s[r] - 'a' == x + y - s[l] + 'a')
break;
else if (s[r] == s[l]) {
l = r, r++, S = 0;
continue;
}
S |= (1 << (s[r++] - 'a'));
}
if (r >= n) break;
dp[S] = 1;
l = r, r++;
S = 0;
}
int sta = (1 << p) - 1;
sta ^= 1 << x;
if (x != y) sta ^= 1 << y;
memset(vis, 0, sizeof(vis));
dfs(sta);
for (int i = 1; i < (1 << p); i++) ban[i] |= dp[i];
}
int main() {
scanf("%d%d%s", &n, &p, s);
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) scanf("%d", &a[i][j]);
for (int i = 0; i < n; i++) cnt[1 << (s[i] - 'a')]++;
for (int i = 1; i < (1 << p); i++) {
for (int j = 0; j < p; j++) {
if (!((i >> j) & 1)) {
cnt[i | (1 << j)] = cnt[i] + cnt[1 << j];
}
}
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
if (!a[i][j]) init(i, j);
}
}
int ans = 0;
for (int i = 1; i < (1 << p); i++) {
if (ban[i]) continue;
ban[i] = 1;
for (int j = 0; j < p; j++) {
if (((i >> j) & 1) && !ban[i ^ (1 << j)]) {
ban[i] = 0;
ans = max(ans, cnt[i]);
break;
}
}
}
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const int LogN = 20;
const long long mod = 998244353;
int t[LogN], c[LogN][N], cnt[LogN];
bool dp[N], m[N], vsp[N];
string s;
vector<int> v[LogN];
bool is(int x, int l, int r) { return (c[x][r + 1] - c[x][l] >= 1); }
int main() {
int i, j, n, k, b, p, h;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> p;
cin >> s;
for (i = 0; i < s.size(); ++i) {
s[i] -= 'a';
++cnt[s[i]];
for (j = 0; j < p; ++j) c[j][i + 1] = c[j][i];
++c[s[i]][i + 1];
v[s[i]].push_back(i);
}
t[0] = 1;
for (i = 1; i <= p; ++i) t[i] = t[i - 1] * 2;
for (i = 0; i < p; ++i)
for (j = 0; j < p; ++j) {
cin >> k;
if (k == 1) continue;
for (h = 0; h < t[p]; ++h) vsp[h] = 0;
int l2 = 0;
for (int l1 = 0; l1 < v[i].size(); ++l1) {
while (l2 < v[j].size() && v[j][l2] <= v[i][l1]) ++l2;
if (l2 != v[j].size() && !is(i, v[i][l1] + 1, v[j][l2] - 1)) {
int x = 0;
for (int l = 0; l < p; ++l)
if (l != i && l != j && is(l, v[i][l1] + 1, v[j][l2] - 1))
x += t[l];
vsp[x] = true;
}
}
for (h = 0; h < t[p]; ++h)
if (vsp[h] && (h & t[j]) == 0 && (h & t[i]) == 0) {
for (int f = 0; f < p; ++f) vsp[h | t[f]] = 1;
m[(((t[p] - 1) ^ h) | (t[i] | t[j]))] = true;
}
}
dp[t[p] - 1] = true;
int ans = n;
for (i = t[p] - 2; i >= 0; --i)
if (!m[i]) {
for (j = 0; j < p; ++j)
if ((i & t[j]) == 0) dp[i] |= dp[i + t[j]];
if (dp[i]) {
int x = 0;
for (j = 0; j < p; ++j)
if ((i & t[j]) > 0) x += cnt[j];
ans = min(ans, x);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 Rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
template <typename T>
inline void chkmax(T &x, T y) {
if (x < y) x = y;
}
template <typename T>
inline void chkmin(T &x, T y) {
if (x > y) x = y;
}
inline int read() {
int x = 0;
char c = getchar();
while (c < 48) c = getchar();
while (c > 47) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x;
}
const int maxn = 1e5 + 10;
char str[maxn];
int n, m, lst[17], G[17][17], sum[17][maxn];
bitset<(1 << 17)> dp, vis, mark[17][17];
int main() {
scanf("%d %d %s", &n, &m, str + 1);
for (int i = (0), iend = (m - 1); i <= iend; ++i)
for (int j = (0), jend = (m - 1); j <= jend; ++j) {
G[i][j] = read();
}
int all = (1 << m) - 1;
for (int i = (1), iend = (n); i <= iend; ++i) {
int x = str[i] - 'a';
for (int j = (0), jend = (m - 1); j <= jend; ++j) {
sum[j][i] = sum[j][i - 1] + (x == j);
if (G[x][j] || !lst[j]) continue;
int S = all;
for (int k = (0), kend = (m - 1); k <= kend; ++k) {
if (k != x && k != j && sum[k][i - 1] - sum[k][lst[j]]) {
S ^= 1 << k;
}
}
mark[min(x, j)][max(x, j)][S] = 1;
}
lst[x] = i;
}
for (int p = (0), pend = (m - 1); p <= pend; ++p)
for (int q = (p), qend = (m - 1); q <= qend; ++q)
if (!G[p][q]) {
for (int S = (all), Send = (0); S >= Send; --S)
if (mark[p][q][S]) {
vis[S] = 1;
for (int i = (0), iend = (m - 1); i <= iend; ++i)
if (i != p && i != q && S >> i & 1) {
mark[p][q][S ^ 1 << i] = 1;
}
}
}
int res = n;
dp[all] = 1;
for (int S = (all), Send = (0); S >= Send; --S) {
if (dp[S]) {
int val = 0;
for (int i = (0), iend = (m - 1); i <= iend; ++i)
if (S >> i & 1) {
val += sum[i][n], dp[S ^ 1 << i] = !vis[S ^ 1 << i];
}
chkmin(res, val);
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p, A[18][18], cnt[100005][18], pre[18], ans = 1e9;
bool f[1 << 18], ban[1 << 18], cant[18][18][1 << 18];
char s[100005];
int main() {
scanf("%d%d%s", &n, &p, s + 1);
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) scanf("%d", &A[i][j]);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < p; j++) cnt[i][j] = cnt[i - 1][j];
cnt[i][s[i] -= 'a']++;
for (int j = 0; j < p; j++)
if (!A[s[i]][j] && pre[j] && pre[j] >= pre[s[i]]) {
int st = 0;
for (int k = 0; k < p; k++)
if (cnt[i - 1][k] - cnt[pre[j]][k]) st |= 1 << k;
cant[s[i]][j][st] = 1;
}
pre[s[i]] = i;
}
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++)
for (int st = 0; st < 1 << p; st++)
if (cant[i][j][st]) {
int S = ((1 << p) - 1) ^ (st | (1 << i) | (1 << j));
for (int t = S;; t = (t - 1) & S) {
ban[t | (1 << i) | (1 << j)] = 1;
if (!t) break;
}
}
f[(1 << p) - 1] = 1;
for (int st = (1 << p) - 1; st >= 0; st--)
if (f[st]) {
int sum = 0;
for (int i = 0; i < p; i++)
if ((st & 1 << i)) {
if (!ban[st ^ (1 << i)]) f[st ^ (1 << i)] = 1;
sum += cnt[n][i];
}
ans = min(ans, sum);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const int SZ = 1e6 + 10;
const int mod = 1e9 + 7;
const double PI = acos(-1);
const double eps = 1e-7;
long long read() {
long long n = 0;
char a = getchar();
bool flag = 0;
while (a > '9' || a < '0') {
if (a == '-') flag = 1;
a = getchar();
}
while (a <= '9' && a >= '0') {
n = n * 10 + a - '0', a = getchar();
}
if (flag) n = -n;
return n;
}
int n, m;
char s[SZ];
int nx[SZ][22];
void get_nxt() {
int b[22] = {0}, id[22] = {0};
for (int i = n; i >= 1; i--) {
int c = s[i] - 'a';
for (int j = 0; j < m; j++) {
if (id[j]) nx[i][j] = b[j];
b[j] |= 1 << c;
}
b[c] = 0;
id[c] = i;
}
}
int tim[22], f[SZ], tmp[SZ], g[SZ], vis[SZ];
int dfs(int S, int n) {
if (vis[S]) return f[S];
vis[S] = 1;
if (g[S]) return f[S] = INF;
int ans = n;
for (int i = 0; i < m; i++) {
if ((S >> i & 1) == 0) ans = min(ans, dfs(S ^ (1 << i), n - tim[i]));
}
return f[S] = ans;
}
bool mp[22][22];
int main() {
n = read(), m = read();
scanf("%s", s + 1);
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) mp[i][j] = read();
get_nxt();
for (int i = 0; i < m; i++) {
for (int j = 0; j <= i; j++) {
if (mp[i][j]) continue;
for (int k = 0; k < (1 << m); k++) tmp[k] = 0;
for (int k = 1; k <= n; k++) {
if (s[k] - 'a' == i) {
if (nx[k][j]) tmp[nx[k][j]] = 1;
} else if (s[k] - 'a' == j) {
if (nx[k][i]) tmp[nx[k][i]] = 1;
}
}
for (int k = 0; k < m; k++)
for (int l = 0; l < (1 << m); l++)
if (l >> k & 1) tmp[l] |= tmp[l ^ (1 << k)];
int S = 1 << m;
S--;
S &= (1 << m) - 1 - (1 << i);
S &= (1 << m) - 1 - (1 << j);
for (int l = 0; l < (1 << m); l++) {
g[l & S] |= tmp[l];
}
}
}
for (int i = 1; i <= n; i++) tim[s[i] - 'a']++;
printf("%d\n", dfs(0, n));
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
char s[100100];
int num[17][100100], A[17][17];
vector<int> pos[17], arr, vec;
int f[17] = {1};
int flag[262144], runs;
int vst[262144], can[262144];
queue<int> q;
int main() {
int n, p;
scanf("%d %d %s", &n, &p, s + 1);
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
scanf("%d", A[i] + j);
}
}
for (int i = 1, c; i <= n; i++) {
for (int j = p; j--;) num[j][i] = num[j][i - 1];
c = s[i] - 'a';
num[c][i]++;
pos[c].push_back(i);
}
for (int i = 1; i < p; i++) f[i] = f[i - 1] << 1;
int all = (f[p - 1] << 1) - 1;
for (int i = 0; i < p; i++) {
for (int j = i; j < p; j++)
if (!A[i][j]) {
arr.clear();
if (i == j) {
int N = pos[i].size();
for (int k = 0; k < N; k++) arr.push_back(pos[i][k]);
} else {
int iN = pos[i].size(), jN = pos[j].size();
for (int I = 0, J = 0;;) {
if (I == iN) {
if (J == jN) break;
arr.push_back(pos[j][J++]);
} else if (J == jN)
arr.push_back(pos[i][I++]);
else {
if (pos[i][I] > pos[j][J])
arr.push_back(pos[j][J++]);
else
arr.push_back(pos[i][I++]);
}
}
}
vec.clear();
int N = arr.size(), used = f[i] | f[j], except_all = all ^ used;
for (int k = 1; k < N; k++) {
int a = arr[k - 1], b = arr[k], val = 0;
if (A[s[a] - 'a'][s[b] - 'a']) continue;
for (int I = p; I--;)
if (num[I][b - 1] - num[I][a]) val |= f[I];
vec.push_back(except_all ^ val);
}
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
runs++;
for (int k = vec.size(); k--;) {
int bit = vec[k];
q.push(bit);
flag[bit] = runs;
}
while (!q.empty()) {
int bit = q.front();
q.pop();
vst[bit | used] = 1;
for (int I = 0, val = bit; I < p; I++, val >>= 1)
if (val & 1) {
int nxt_bit = bit ^ f[I];
if (flag[nxt_bit] != runs) {
flag[nxt_bit] = runs;
q.push(nxt_bit);
}
}
}
}
}
int all_bit = 0;
for (int i = 0; i < p; i++)
if (num[i][n]) all_bit |= f[i];
if (!vst[all_bit]) {
q.push(all_bit);
can[all_bit] = 1;
} else
assert(0);
int ans = n;
while (!q.empty()) {
int bit = q.front(), len = 0;
q.pop();
for (int i = 0, val = bit; i < p; i++, val >>= 1)
if (val & 1) {
int nxt_bit = bit ^ f[i];
if (!vst[nxt_bit] && !can[nxt_bit]) {
can[nxt_bit] = 1;
q.push(nxt_bit);
}
len += num[i][n];
}
smin(ans, len);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 100000, mxk = 17;
int n, k;
int a[mxn], b[mxk];
int first[1 << mxk], ff[1 << mxk], dp[1 << mxk];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
char c;
cin >> c;
b[a[i] = c - 'a']++;
}
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) {
int x;
cin >> x;
memset(first, 0, sizeof(first));
if (!x)
for (int l = 0, y = 0, z = 0; l < n; l++) {
if (a[l] == i) first[z] |= y, y = z = 0;
if (a[l] == j)
z = 0, y = 1;
else
z |= y << a[l];
}
for (int l = 0; l < (1 << k); l++) {
for (int p = 0; p < k; p++) {
if (((l >> p) & 1) && p != i && p != j)
first[l] |= first[l ^ (1 << p)];
}
ff[l] |= first[l];
}
}
int ret = n;
dp[0] = 1;
for (int i = 0; i < (1 << k); i++)
if (!ff[i]) {
int x = 0;
for (int j = 0; j < k; j++)
if ((i >> j) & 1) {
x += b[j];
dp[i] |= dp[i ^ (1 << j)];
}
if (dp[i]) ret = min(ret, n - x);
}
cout << ret << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long a, long long b,
long long mod = (long long)(1e9 + 7)) {
if (!b) return 1;
a %= mod;
return modpow(a * a % mod, b / 2, mod) * (b & 1 ? a : 1) % mod;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
bool debug = true;
const int mxn = 1e5, mxp = 17, inf = 1e9;
string s;
int n, p, sz[1 << mxp], res[1 << mxp], freq[mxp], c[mxn][mxp];
bool matrix[mxp][mxp];
vector<int> pos[mxp];
void solve() {
scanf("%d", &n);
scanf("%d", &p);
char buffer[20 * mxn];
scanf("%s", buffer);
s = string(buffer);
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) {
int x;
scanf("%d", &x);
matrix[i][j] = x;
}
for (int i = 0; i < p; i++) freq[i] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < p; j++)
c[i][j] += (i ? c[i - 1][j] : 0) + (s[i] == 'a' + j);
for (int i = 0; i < n; i++) pos[s[i] - 'a'].push_back(i);
for (int i = n - 1; i >= 0; i--) freq[s[i] - 'a']++;
for (int mask = 0; mask < 1 << p; mask++) {
sz[mask] = 0;
for (int i = 0; i < p; i++)
if (mask & (1 << i)) sz[mask] += freq[i];
res[mask] = sz[mask];
}
int fl = (1 << p) - 1;
for (int a = 0; a < p; a++)
for (int b = 0; b < a + 1; b++)
if (!matrix[a][b]) {
int dp[1 << p];
for (int i = 0; i < 1 << p; i++) dp[i] = 0;
for (int i = 0, j = 0;
i < int((pos[a]).size()) && j < int((pos[b]).size());) {
while (a == b && i == j) j++;
if (j == int((pos[b]).size())) break;
while (a == b && i + 1 < j) i++;
int mask = 0;
if (pos[a][i] < pos[b][j]) {
for (int e = 0; e < p; e++)
if (c[pos[b][j] - 1][e] - c[pos[a][i]][e] > 0) mask |= 1 << e;
i++;
} else {
for (int e = 0; e < p; e++)
if (c[pos[a][i] - 1][e] - c[pos[b][j]][e] > 0) mask |= 1 << e;
j++;
}
if (mask >> a & 1) continue;
if (mask >> b & 1) continue;
dp[mask] = 1;
}
for (int i = 0; i < p; i++)
if (i != a && i != b)
for (int mask = 0; mask < 1 << p; mask++)
if (mask & (1 << i)) dp[mask] |= dp[mask ^ (1 << i)];
for (int mask = 0; mask < 1 << p; mask++) {
if (dp[mask]) res[fl ^ mask] = inf;
}
}
for (int mask = 0; mask < 1 << p; mask++)
if (res[mask] != inf) {
for (int i = 0; i < p; i++)
if (mask >> i & 1) {
(res[mask]) = min((res[mask]), (res[mask ^ (1 << i)]));
}
}
cout << res[fl] << endl;
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, p, vr[20][20], cr[100005][20];
char str[100005];
bool visit[(1 << 17)][17][17], inv[(1 << 17)];
long long dp[(1 << 17)], occ[200005], tr[400555];
void build(long long, long long, long long),
ss(long long, long long, long long);
long long query(long long, long long, long long, long long, long long),
func(long long);
int main() {
scanf("%lld %lld", &n, &p);
scanf(" %s", str);
for (int i = 0; i < n; i++) occ[1 << (str[i] - 'a')]++;
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) scanf("%lld", &vr[i][j]);
}
build(0, 0, n - 1);
for (int i = 0; i < p; i++) {
long long pos = -1;
for (int j = n - 1; j >= 0; j--) {
if (pos != -1 && vr[str[j] - 'a'][str[pos] - 'a'] == 0) {
long long x = query(0, 0, n - 1, j + 1, pos - 1);
if ((x & (1 << (str[j] - 'a'))) == 0) {
ss(query(0, 0, n - 1, j + 1, pos - 1), min(str[j], str[pos]) - 'a',
max(str[j], str[pos]) - 'a');
}
}
if (str[j] == 'a' + i) pos = j;
}
}
memset(dp, -1, sizeof(dp));
cout << n - func(0);
}
void ss(long long mask, long long a, long long b) {
if (visit[mask][a][b]) return;
visit[mask][a][b] = 1;
inv[mask] = 1;
long long unset = ((1 << p) - 1) ^ mask;
for (; unset; unset -= (unset & (-unset))) {
long long bit = (unset & -unset);
if (bit != (1 << a) && bit != (1 << b)) {
ss(mask | bit, a, b);
}
}
}
long long func(long long mask) {
if (dp[mask] != -1) return dp[mask];
if (inv[mask]) return -1000000;
long long max_ = 0;
long long unset = ((1 << p) - 1) ^ mask;
for (; unset; unset -= (unset & -unset)) {
long long bit = (unset & -unset);
max_ = max(max_, func(mask | bit) + occ[bit]);
}
return dp[mask] = max_;
}
long long query(long long idx, long long l, long long r, long long low,
long long high) {
if (low <= l && r <= high) return tr[idx];
if (r < low || high < l) return 0;
long long mid = (l + r) / 2;
return query(2 * idx + 1, l, mid, low, high) |
query(2 * idx + 2, mid + 1, r, low, high);
}
void build(long long idx, long long l, long long r) {
if (l == r) {
tr[idx] = (1 << (str[l] - 'a'));
return;
}
long long mid = (l + r) / 2;
build(2 * idx + 1, l, mid);
build(2 * idx + 2, mid += 1, r);
tr[idx] = (tr[2 * idx + 1] | tr[2 * idx + 2]);
}
|
#include <bits/stdc++.h>
using namespace std;
int bit(int m, int i) { return (m >> i) & 1; }
const int N = 5e5;
const int L = 20;
const int P = 18;
int n, p;
int bin_log[N];
int s[N];
int sparse[L][N];
int good[L][L];
char forb[1 << P][L][L];
bool fff[1 << P];
int dp[1 << P];
vector<int> g[L];
int cnt[L];
void build() {
bin_log[0] = -1;
for (int i = 1; i < N; ++i) {
bin_log[i] = bin_log[i / 2] + 1;
}
for (int i = 1; i < L; ++i) {
for (int j = 0; j + (1 << i) <= n; ++j) {
sparse[i][j] = sparse[i - 1][j] | sparse[i - 1][j + (1 << (i - 1))];
}
}
}
int query(int l, int r) {
if (l > r) {
return 0;
}
++r;
int i = bin_log[r - l];
return sparse[i][l] | sparse[i][r - (1 << i)];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> p;
for (int i = 0; i < n; ++i) {
char c;
cin >> c;
s[i] = c - 'a';
++cnt[s[i]];
g[s[i]].push_back(i);
sparse[0][i] = 1 << s[i];
}
build();
for (int i = 0; i < p; ++i) {
for (int j = 0; j < p; ++j) {
cin >> good[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int pos, c = 0; c < p; ++c) {
if (good[s[i]][c]) {
continue;
}
auto &v = g[c];
auto tt = upper_bound(begin(v), end(v), i);
if (tt != v.end()) {
pos = *tt;
assert(i < pos);
int q = query(i + 1, pos - 1);
if (!bit(q, s[i]) && !bit(q, c)) {
forb[q][s[i]][c] = true;
forb[q][c][s[i]] = true;
}
}
auto it = lower_bound(begin(v), end(v), i);
if (it != v.begin()) {
pos = *prev(it);
assert(pos < i);
int q = query(pos + 1, i - 1);
if (!bit(q, s[i]) && !bit(q, c)) {
forb[q][s[i]][c] = true;
forb[q][c][s[i]] = true;
}
}
}
}
for (int i = 0; i < (1 << p); ++i) {
for (int b = 0; b < p; ++b) {
if (!bit(i, b)) {
continue;
}
int t = i;
t &= ~(1 << b);
for (int a = 0; a < p; ++a) {
for (int bb = 0; bb < p; ++bb) {
forb[i][a][bb] |= forb[t][a][bb];
}
}
}
for (int a = 0; a < p; ++a) {
for (int b = 0; b < p; ++b) {
if (bit(i, a) || bit(i, b)) {
forb[i][a][b] = false;
}
if (forb[i][a][b]) {
fff[i] = true;
}
}
}
}
dp[0] = true;
for (int i = 1; i < (1 << p); ++i) {
if (fff[i]) {
continue;
}
for (int b = 0; b < p; ++b) {
if (!bit(i, b)) {
continue;
}
int t = i;
t &= ~(1 << b);
dp[i] |= dp[t];
}
}
int answer = 1e9;
for (int m = 0; m < (1 << p); ++m) {
if (dp[m]) {
int cur = n;
for (int i = 0; i < p; ++i) {
if (bit(m, i)) {
cur -= cnt[i];
}
}
answer = min(answer, cur);
}
}
cout << answer << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
const int M = 1000000007;
const double eps = 1e-9;
const double PI = acos(-1);
const int oo = 1000000000;
int n, p, nxt[N][17], can[17][17], pre[N][17], fr[17];
bool bad[1 << 17], vis[1 << 17][17][17], dp[1 << 17];
char s[N];
vector<int> oc[17];
void go(int msk, int a, int b) {
if (a > b) swap(a, b);
if (vis[msk][a][b]) return;
vis[msk][a][b] = bad[msk] = 1;
bad[msk] = 1;
for (int i = 0; i < p; ++i)
if (msk & 1 << i && i - a && i - b) go(msk ^ 1 << i, a, b);
}
int main() {
cin >> n >> p;
scanf("%s", s);
for (int i = 0; i < n; ++i) {
oc[s[i] - 'a'].push_back(i);
if (i)
for (int j = 0; j < p; ++j) pre[i][j] = pre[i - 1][j];
++pre[i][s[i] - 'a'];
++fr[s[i] - 'a'];
}
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j) scanf("%d", &can[i][j]);
memset(nxt, -1, sizeof(nxt));
for (int i = n - 2; i >= 0; --i) {
for (int j = 0; j < p; ++j) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i + 1] - 'a'] = i + 1;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < p; ++j) {
if (can[s[i] - 'a'][j] || nxt[i][j] == -1 ||
(nxt[i][s[i] - 'a'] + 1 && nxt[i][s[i] - 'a'] < nxt[i][j]))
continue;
int msk = (1 << p) - 1;
if (nxt[i][j] > i + 1) {
for (int k = 0; k < p; ++k) {
int fr = pre[nxt[i][j] - 1][k];
fr -= pre[i][k];
if (fr) msk ^= 1 << k;
}
}
go(msk, s[i] - 'a', j);
}
}
dp[(1 << p) - 1] = 1;
int ans = n;
for (int i = (1 << p) - 2; i >= 0; --i) {
if (bad[i]) continue;
for (int j = 0; j < p && !dp[i]; ++j)
if (!(i & 1 << j)) dp[i] |= dp[i ^ 1 << j];
if (!dp[i]) continue;
int cur = 0;
for (int j = 0; j < p; ++j)
if (i & 1 << j) cur += fr[j];
ans = min(ans, cur);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100, maxp = 20;
int n, a[maxp][maxp], ma[(1 << maxp)], cur[1 << maxp], dp[1 << maxp], cnt[maxn],
f[maxp][maxn];
int ans, mp, p;
char s[maxn];
vector<int> pos[20];
void solve() {
dp[mp] = 1;
for (int i = mp; i >= 0; i--) {
if (!dp[i]) continue;
for (int j = 0; j < p; j++)
if ((i >> j) & 1) dp[(i ^ (1 << j))] = ma[(i ^ (1 << j))];
}
return;
}
void init() {
for (int i = 1; i <= n; i++) {
cnt[s[i] - 'a']++;
pos[s[i] - 'a'].push_back(i);
for (int c = 0; c < p; c++) f[c][i + 1] = f[c][i] + (s[i] == ('a' + c));
}
for (int i = 0; i <= mp; i++) ma[i] = 1;
for (int i = 0; i < p; i++) {
for (int j = 0; j <= i; j++) {
memset(cur, 0, sizeof(cur));
if (a[i][j]) continue;
int pos1 = 0, pos2 = 0;
while (pos1 < pos[i].size() && pos2 < pos[j].size()) {
if (i == j && pos[i][pos1] == pos[j][pos2]) {
pos2++;
continue;
}
int m = 0;
if (pos[i][pos1] < pos[j][pos2]) {
for (int c = 0; c < p; c++) {
if (f[c][pos[j][pos2]] - f[c][pos[i][pos1] + 1] != 0) {
m |= (1 << c);
}
}
pos1++;
} else {
for (int c = 0; c < p; c++) {
int pp1 = f[c][pos[j][pos2] + 1];
int pp2 = f[c][pos[i][pos1]];
if (f[c][pos[i][pos1]] - f[c][pos[j][pos2] + 1] != 0) {
m = m ^ (1 << c);
}
}
pos2++;
}
if ((m >> i) & 1) continue;
if ((m >> j) & 1) continue;
m = m ^ (mp);
cur[m] = 1;
}
for (int i = 0; i <= mp; i++) cur[i] = !cur[i];
for (int ii = mp; ii > 0; ii--) {
if (cur[ii]) continue;
for (int jj = 0; jj < p; jj++) {
if (jj != i && jj != j && (ii >> jj) & 1) {
cur[(ii ^ (1 << jj))] = 0;
}
}
ma[ii] &= cur[ii];
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> p;
ans = n;
mp = (1 << p) - 1;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) cin >> a[i][j];
init();
solve();
for (int i = 0; i <= mp; i++) {
int res = 0;
if (!dp[i]) continue;
for (int j = 0; j < p; j++)
if ((i >> j) & 1) {
res += cnt[j];
}
ans = min(ans, res);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
struct InputReader {
char buf[1000001];
int p;
inline InputReader() { p = 1000001; }
inline void Flush() {
p = 0;
fread(buf, 1, 1000001, stdin);
}
inline char C() {
if (p >= 1000001) Flush();
return buf[p++];
}
inline char Readnum() {
char ch = C();
while (!isdigit(ch) && ch != '-') ch = C();
return ch;
}
inline void Readalpha(char &c) {
c = C();
while (!isalpha(c)) c = C();
}
int operator()() {
int ans = 0, fu = 1;
char ch = Readnum();
if (ch == '-') fu = -1, ch = C();
while (ch >= '0' && ch <= '9') {
ans = ans * 10 + ch - '0';
ch = C();
}
return ans * fu;
}
long long Readll() {
long long ans = 0LL, fu = 1LL;
char ch = Readnum();
if (ch == '-') fu = -1LL, ch = C();
while (ch >= '0' && ch <= '9') {
ans = ans * 10LL + ch - '0';
ch = C();
}
return ans * fu;
}
inline void Readstring(string &x) {
x.clear();
char ch = C();
while (!isdigit(ch) && !isalpha(ch) && ch != '#' && ch != '.') ch = C();
while (isdigit(ch) || isalpha(ch) || ch == '#' || ch == '.') {
x += ch;
ch = C();
}
}
inline void Readchstring(char s[]) {
int len = 0;
char ch = C();
while (!isdigit(ch) && !isalpha(ch)) ch = C();
while (isdigit(ch) || isalpha(ch)) {
s[len++] = ch;
ch = C();
}
s[len] = '\0';
}
inline void Specialread(char &c) {
c = C();
while (!isdigit(c) && !isalpha(c) && c != '#' && c != '.' && c != '=' &&
c != 'B')
c = C();
}
} In;
inline void Read(int &x) { x = In(); }
inline void Read(int &x, int &y) {
x = In();
y = In();
}
inline void Read(int &x1, int &x2, int &x3) {
x1 = In();
x2 = In();
x3 = In();
}
inline void Read(int &x1, int &x2, int &x3, int &x4) {
x1 = In();
x2 = In();
x3 = In();
x4 = In();
}
inline void Read(long long &x) { x = In.Readll(); }
inline void Read(long long &x, long long &y) {
x = In.Readll();
y = In.Readll();
}
inline void Read(long long &x1, long long &x2, long long &x3) {
x1 = In.Readll();
x2 = In.Readll();
x3 = In.Readll();
}
inline void Read(long long &x1, long long &x2, long long &x3, long long &x4) {
x1 = In.Readll();
x2 = In.Readll();
x3 = In.Readll();
x4 = In.Readll();
}
inline void FILEIO() {}
inline void FILEIO(string pname) {
freopen((pname + ".in").c_str(), "r", stdin);
freopen((pname + ".out").c_str(), "w", stdout);
}
void Printtime() {}
void END() {
Printtime();
exit(0);
}
template <typename T>
void END(T mes) {
cout << mes << endl;
END();
}
template <typename T>
void Print(T a[], int s, int t, char sp = ' ', char ed = '\n') {
if (s > t) return;
for (int i = s; i < t; i++) cout << a[i] << sp;
cout << a[t] << ed;
cout.flush();
}
template <typename T>
void Print(T a, int s = 0, int t = -1, char sp = ' ', char ed = '\n') {
if (t == -1) t = a.size() - 1;
for (int i = s; i <= t; i++) cout << a[i] << sp;
cout << ed;
cout.flush();
}
int p, n;
int a[100010];
int can[17][17];
int cnt[17];
bool ban[(1 << 17)];
bool vi[(1 << 17)][17][17];
void Addban(int mask, int a, int b) {
if (vi[mask][a][b]) return;
vi[mask][a][b] = 1;
ban[mask] = 1;
for (int(i) = 0; (i) < (p); ++(i)) {
if (i == a or i == b) continue;
if (((mask) >> (i)&1)) continue;
Addban(((mask) | 1 << (i)), a, b);
}
}
int ans;
bool vis[(1 << 17)];
void Dfs(int mask, int rem) {
if (vis[mask] or ban[mask]) return;
vis[mask] = 1;
(ans) = (((ans)) < ((rem)) ? ((ans)) : ((rem)));
for (int(i) = 0; (i) < (p); ++(i)) {
if (((mask) >> (i)&1)) continue;
Dfs(((mask) | 1 << (i)), rem - cnt[i]);
}
}
int main() {
FILEIO();
Read(n, p);
for (int(i) = 1; (i) <= (n); ++(i)) {
char c;
In.Readalpha(c);
a[i] = c - 'a';
++cnt[a[i]];
}
for (int(i) = 0; (i) < (p); ++(i))
for (int(j) = 0; (j) < (p); ++(j)) Read(can[i][j]);
for (int(i) = 0; (i) < (p); ++(i))
for (int(j) = 0; (j) < (p); ++(j)) {
if (can[i][j]) continue;
int lastj = 0;
int midmask = 0;
for (int(k) = (n); (k) >= 1; --(k)) {
if (a[k] == i) {
if (not lastj) {
if (a[k] == j) {
lastj = k;
midmask = 0;
}
continue;
}
Addban(midmask, i, j);
lastj = 0;
midmask = 0;
if (a[k] == j) {
lastj = k;
midmask = 0;
}
} else if (a[k] == j) {
lastj = k;
midmask = 0;
} else {
midmask = ((midmask) | 1 << (a[k]));
}
}
}
ans = n;
Dfs(0, n);
cout << ans << endl;
END();
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
int n, p;
char s[maxn];
int mat[18][18];
struct node {
int msk;
int a;
node(int aa, int bb) { a = aa, msk = bb; }
};
bool vis[18][1 << 18];
bool dead[1 << 18];
void work(int x) {
memset(vis, 0, sizeof(vis));
queue<node> que;
int lastp = -1;
int cntmsk = 0;
for (int i = 0; i < n; i++) {
int id = s[i] - 'a';
if (lastp != -1 && mat[x][id] == 0 && !(cntmsk >> id & 1)) {
if (vis[id][cntmsk] == 0) {
vis[id][cntmsk] = 1;
que.push(node(id, cntmsk));
}
}
cntmsk |= (1 << id);
if (id == x) {
lastp = i;
cntmsk = 0;
}
}
lastp = -1;
for (int i = n - 1; i >= 0; i--) {
int id = s[i] - 'a';
if (lastp != -1 && mat[x][id] == 0 && !(cntmsk >> id & 1)) {
if (vis[id][cntmsk] == 0) {
vis[id][cntmsk] = 1;
que.push(node(id, cntmsk));
}
}
cntmsk |= (1 << id);
if (id == x) {
lastp = i;
cntmsk = 0;
}
}
while (!que.empty()) {
node cnt = que.front();
que.pop();
dead[cnt.msk] = 1;
for (int i = 0; i < p; i++) {
if (i == x || i == cnt.a) continue;
int newmsk = cnt.msk | (1 << i);
if (vis[cnt.a][newmsk]) continue;
vis[cnt.a][newmsk] = 1;
que.push(node(cnt.a, newmsk));
}
}
}
int cou[maxn];
int ans;
bool vis1[1 << 18];
void dfs(int cntmsk, int cnt = n) {
ans = min(ans, cnt);
vis1[cntmsk] = 1;
for (int i = 0; i < p; i++) {
if (dead[cntmsk | (1 << i)]) continue;
if (vis1[cntmsk | (1 << i)]) continue;
dfs(cntmsk | (1 << i), cnt - cou[i]);
}
}
int main() {
scanf("%d%d", &n, &p);
scanf("%s", s);
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
scanf("%d", &mat[i][j]);
}
}
for (int i = 0; i < p; i++) {
work(i);
}
for (int i = 0; i < n; i++) {
cou[s[i] - 'a']++;
}
ans = n;
dfs(0);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const long long longinf = 1LL << 60;
const long long mod = 1e9 + 7;
bitset<26> adj[1 << 17][26], ok[26];
bool dp[1 << 17];
int main() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
for (int i = (int)(0); i < (int)(m); ++i)
for (int j = (int)(0); j < (int)(m); ++j) {
int x;
cin >> x;
ok[i][j] = x;
}
for (int i = (int)(0); i < (int)(m); ++i) {
char cur = 'a' + i;
for (int aaa = (int)(0); aaa < (int)(2); ++aaa) {
int mask = 0;
bool used = false;
for (int j = (int)(0); j < (int)(n); ++j) {
int ch = s[j] - 'a';
if (ch != i) {
if (!used) continue;
if ((mask >> ch) & 1) continue;
adj[mask][i][ch] = 1;
mask += (1 << ch);
} else {
if (used) adj[mask][i][i] = 1;
used = true;
mask = 0;
}
}
reverse(s.begin(), s.end());
}
}
int all = 1 << m;
for (int i = (int)(0); i < (int)(26); ++i) {
for (int j = (int)(0); j < (int)(m); ++j)
for (int k = (int)(0); k < (int)(all); ++k) {
if ((1 << j) & k) adj[k][i] |= adj[k ^ (1 << j)][i];
}
}
for (int i = (int)(0); i < (int)(all); ++i)
for (int j = (int)(0); j < (int)(m); ++j)
for (int k = (int)(0); k < (int)(m); ++k) {
if ((1 << j) & i) adj[i][k][j] = 0;
}
dp[0] = 1;
for (int i = (int)(0); i < (int)(all); ++i) {
for (int j = (int)(0); j < (int)(m); ++j) {
if (((1 << j) & i) == 0) continue;
if (!dp[i ^ (1 << j)]) continue;
bool can = true;
for (int k = (int)(0); k < (int)(m); ++k) {
if ((1 << k) & i) continue;
bitset<26> res = adj[i][k];
if ((res & ok[k]) != res) can = false;
}
if (can) dp[i] = 1;
}
}
int ans = n;
vector<int> cnt(m);
for (int i = (int)(0); i < (int)(n); ++i) {
cnt[s[i] - 'a']++;
}
for (int i = (int)(0); i < (int)(all); ++i) {
if (!dp[i]) continue;
int ret = 0;
for (int j = (int)(0); j < (int)(m); ++j)
if (((i >> j) & 1) == 0) ret += cnt[j];
ans = min(ans, ret);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool home = 1;
signed realMain();
signed main() {
home = 0;
if (home) {
freopen("input", "r", stdin);
} else {
ios::sync_with_stdio(0);
cin.tie(0);
}
realMain();
}
const long long N = 17;
long long len, n, consec[N][N], ok[1 << N], f[N], tot[1 << N], rl[1 << N],
last[N];
string s;
bool okp[1 << N];
bitset<1 << N> bad[N][N];
signed realMain() {
cin >> len >> n >> s;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
cin >> consec[i][j];
}
}
for (long long i = 0; i < (1 << n); i++) {
ok[i] = 1;
}
for (long long i = 0; i < len; i++) {
long long x = s[i] - 'a';
f[x]++;
}
for (long long i = 0; i < n; i++) {
last[i] = -1;
}
for (long long i = 0; i < len; i++) {
long long x = s[i] - 'a';
for (long long y = 0; y < n; y++) {
if (last[y] != -1) {
if (consec[x][y]) continue;
long long pos = last[y];
if (pos < last[x]) {
continue;
}
long long mid = 0;
for (long long z = 0; z < n; z++) {
if (z == x || z == y) continue;
if (pos < last[z]) {
mid |= (1 << z);
}
}
mid = (1 << n) - 1 - mid;
assert(mid & (1 << x));
assert(mid & (1 << y));
bad[x][y][mid] = 1;
}
}
last[x] = i;
}
for (long long i = 0; i < n; i++) {
tot[1 << i] = f[i];
}
for (long long i = 1; i < (1 << n); i++) {
long long j = i & (-i);
tot[i] = tot[j] + tot[i ^ j];
}
for (long long x = 0; x < n; x++) {
for (long long y = 0; y < n; y++) {
if (consec[x][y]) continue;
for (long long bit = 0; bit < n; bit++) {
if (bit == x || bit == y) continue;
for (long long i = 0; i < (1 << n); i++) {
if (i & (1 << bit) && bad[x][y][i]) {
bad[x][y][i ^ (1 << bit)] = 1;
}
}
}
}
}
for (long long i = 0; i < (1 << n); i++) {
for (long long x = 0; x < n; x++) {
for (long long y = 0; y < n; y++) {
ok[i] &= !bad[x][y][i];
}
}
}
rl[(1 << n) - 1] = 1;
for (long long i = (1 << n) - 1; i >= 0; i--) {
rl[i] &= ok[i];
if (!rl[i]) continue;
for (long long bit = 0; bit < n; bit++) {
if (i & (1 << bit)) {
}
}
for (long long bit = 0; bit < n; bit++) {
if (i & (1 << bit)) {
rl[i ^ (1 << bit)] |= 1;
}
}
}
long long ret = (long long)1e9;
for (long long i = 0; i < (1 << n); i++) {
if (rl[i]) {
ret = min(ret, tot[i]);
}
}
cout << ret << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p, nxt[100100][18], MAXN, cnt[18], res = 0x3f3f3f3f;
bool ok[18][18], f[1 << 18], mask[1 << 18][18][18], g[1 << 18];
char s[100100];
void dye(int sta, int a, int b) {
if (!mask[sta][a][b]) return;
mask[sta][a][b] = f[sta] = false;
for (int i = 0; i < p; i++)
if (!(sta & (1 << i)) && i != a && i != b) dye(sta | (1 << i), a, b);
}
int main() {
scanf("%d%d", &n, &p), memset(nxt, 0x3f3f3f3f, sizeof(nxt)),
memset(f, true, sizeof(f)), memset(mask, true, sizeof(mask)),
MAXN = 1 << p;
scanf("%s", s);
for (int i = 0; i < n; i++) cnt[s[i] - 'a']++;
for (int i = n - 2; i >= 0; i--) {
for (int j = 0; j < p; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i + 1] - 'a'] = i + 1;
}
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) scanf("%d", &ok[i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < p; j++) {
if (ok[s[i] - 'a'][j] || nxt[i][j] == 0x3f3f3f3f ||
nxt[i][s[i] - 'a'] < nxt[i][j])
continue;
int sta = 0;
for (int k = 0; k < p; k++)
if (nxt[i][k] < nxt[i][j]) sta |= (1 << k);
dye(sta, s[i] - 'a', j);
}
g[0] = true;
for (int i = 0; i < MAXN; i++)
if (f[i] && g[i])
for (int j = 0; j < p; j++)
if (!(i & (1 << j)) && f[i | (1 << j)]) g[i | (1 << j)] |= g[i];
for (int i = 0; i < MAXN; i++) {
if (!g[i]) continue;
int sum = n;
for (int j = 0; j < p; j++)
if (i & (1 << j)) sum -= cnt[j];
res = min(res, sum);
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX / 3;
class Solution {
public:
int minimize(string& s, int n, int p, vector<vector<int>>& adjs) {
int N = 1 << p;
int mask = N - 1;
int S = 0;
vector<vector<int>> cnts(p, vector<int>(n + 1, 0));
vector<int> pos(p, -1);
vector<bitset<320>> forbids(N);
vector<bitset<320>> remains(N);
for (int i = 0; i < n; ++i) {
int j = s[i] - 'a';
S |= 1 << j;
for (int k = 0; k < p; ++k) {
cnts[k][i + 1] = cnts[k][i];
}
++cnts[j][i + 1];
for (int k = 0; k < p; ++k) {
if (adjs[j][k] == 0) {
int l = pos[k];
if (l == -1) {
continue;
}
int r = i - 1;
int code = 0;
for (int c = 0; c < p; ++c) {
int cnt = cnts[c][r + 1] - cnts[c][l + 1];
if (cnt > 0) {
code |= 1 << c;
}
}
if (code != 0) {
forbids[code].set(j * p + k);
forbids[code].set(k * p + j);
}
}
}
pos[j] = i;
}
for (int i = 0; i < p; ++i) {
for (int j = 0; j < N; ++j) {
if ((j & (1 << i)) == 0) {
forbids[j | 1 << i] |= forbids[j];
}
}
}
for (int i = 1; i < N; ++i) {
int b = i & -i;
int ni = i ^ b;
remains[i] = remains[ni];
int k = p - 1;
for (int j = 0; j < p; ++j) {
if ((1 << j) == b) {
k = j;
}
if (i & (1 << j)) {
remains[i].set(k * p + j);
remains[i].set(j * p + k);
}
}
}
vector<int> dp(N, INF);
dp[S] = n;
for (int i = S; i >= 0; --i) {
if (dp[i] == INF) {
continue;
}
for (int j = 0; j < p; ++j) {
if (i & (1 << j)) {
int ni = i ^ (1 << j);
int rmv = ni ^ mask;
if ((remains[ni] & forbids[rmv]) == 0) {
dp[ni] = min(dp[ni], dp[i] - cnts[j][n]);
}
}
}
}
int res = INF;
for (int i = 0; i < N; ++i) {
res = min(res, dp[i]);
}
return res;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
Solution sol;
int n, p;
cin >> n >> p;
string s;
cin >> s;
vector<vector<int>> adjs(p, vector<int>(p, 0));
for (int i = 0; i < p; ++i) {
for (int j = 0; j < p; ++j) {
cin >> adjs[i][j];
}
}
cout << sol.minimize(s, n, p, adjs) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int A[20][20];
int oc[20];
int n, p;
int getLen(int msk) {
int ans = 0;
for (int i = 0; i < p; i++) {
if (msk & (1 << i)) ans += oc[i];
}
return ans;
}
int valid[1 << 17];
int bolod[1 << 17];
int solve(int msk) {
if (bolod[msk] != -1) return bolod[msk];
int ans = getLen(msk);
for (int i = 0; i < p; i++) {
if (msk & (1 << i)) {
int newmask = msk ^ (1 << i);
if (valid[newmask]) ans = min(ans, solve(newmask));
}
}
return bolod[msk] = ans;
}
int last[20];
vector<bool> dp[17][17][18];
int maxmask;
void presos() {
for (int i = 0; i < p; i++) {
for (int j = i; j < p; j++) {
for (int k = 1; k <= p; k++) {
for (int msk = 0; msk < maxmask; msk++) {
dp[i][j][k][msk] = dp[i][j][k - 1][msk];
if (msk & (1 << (k - 1))) {
dp[i][j][k][msk] =
dp[i][j][k][msk] | dp[i][j][k - 1][msk ^ (1 << (k - 1))];
}
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
memset(bolod, -1, sizeof bolod);
cin >> n >> p >> s;
for (char c : s) oc[c - 'a']++;
maxmask = (1 << p) - 1;
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
cin >> A[i][j];
}
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
for (int k = 0; k <= p; k++) {
dp[i][j][k].resize(maxmask);
}
}
}
for (int i = 0; i < p; i++) last[i] = -1;
for (int k = 0; k < n; k++) {
int i = s[k] - 'a';
for (int j = 0; j < p; j++) {
if (last[j] == -1) continue;
if (A[i][j]) continue;
int helper = 0;
for (int l = 0; l < p; l++) {
if (last[j] < last[l]) {
helper |= (1 << l);
}
}
dp[i][j][0][helper] = 1;
dp[j][i][0][helper] = 1;
}
last[i] = k;
}
presos();
valid[0] = 1;
for (int newmask = 1; newmask <= maxmask; newmask++) {
bool okay = true;
for (int a = 0; a < p && okay; a++) {
if ((newmask & (1 << a)) == 0) continue;
for (int b = a; b < p && okay; b++) {
if ((newmask & (1 << b)) == 0) continue;
if (A[a][b]) continue;
int rv = maxmask ^ newmask;
if (dp[a][b][p][rv]) {
okay = false;
break;
}
}
}
valid[newmask] = okay;
}
cout << solve(maxmask) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100005];
int n, k, cnt[20];
bool a[20][20], mark[1 << 17], tmp[1 << 17];
inline void work(int x, int y) {
memset(tmp, 0, sizeof(tmp));
for (int i = 1, j, t; i <= n;) {
while (i <= n && s[i] - 'a' != x) i++;
j = i + 1;
t = 0;
while (j <= n && s[j] - 'a' != x && s[j] - 'a' != y) {
t |= 1 << s[j] - 'a';
j++;
}
if (j > n) break;
if (s[j] - 'a' == y) tmp[t] = 1;
if (s[j] - 'a' == x)
i = j;
else
i = j + 1;
}
for (int i = 1; i < 1 << k; i++) {
if (!tmp[i]) continue;
mark[i] = 1;
for (int j = 0; j < k; j++)
if (j != x && j != y) tmp[i | 1 << j] = 1;
}
}
bool f[1 << 17];
int main() {
cin >> n >> k;
scanf("%s", s);
for (int i = 0; i < n; i++) cnt[s[i] - 'a']++;
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) {
cin >> a[i][j];
if (!a[i][j]) work(i, j);
}
f[0] = 1;
for (int i = 0; i < 1 << k; i++) {
if (!f[i]) continue;
for (int j = 0; j < k; j++)
if (!mark[i | 1 << j]) f[i | 1 << j] = 1;
}
int ans = 0;
for (int i = 0; i < 1 << k; i++) {
if (!f[i]) continue;
int t = 0;
for (int j = 0; j < k; j++)
if (i & 1 << j) t += cnt[j];
ans = max(ans, t);
}
cout << n - ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, p;
cin >> n >> p;
string str;
cin >> str;
vector<vector<int>> A(p, vector<int>(p, 0));
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j) cin >> A[i][j];
vector<int> cnt(p, 0);
for (int i = 0; i < n; ++i) ++cnt[str[i] - 'a'];
string s = "";
for (int i = 0; i < n; ++i)
if (i == 0 || str[i] != str[i - 1]) s += str[i];
n = s.size();
vector<vector<int>> cant(p, vector<int>(1 << p, 0));
for (int t = 0; t < 2; ++t) {
for (char ch = 'a'; ch < 'a' + p; ++ch) {
int i = 0;
while (i < n && s[i] != ch) ++i;
while (i < n) {
int mask = 0;
int j = i + 1;
while (j < n && s[j] != ch) ++j;
for (int k = i + 1; k <= min(n - 1, j); ++k) {
if (!A[ch - 'a'][s[k] - 'a'] && !((mask >> (s[k] - 'a')) & 1)) {
cant[ch - 'a'][mask] |= 1 << (s[k] - 'a');
}
mask |= 1 << (s[k] - 'a');
}
i = j;
}
for (int mask = 1; mask < 1 << p; ++mask) {
if ((mask >> (ch - 'a')) & 1) continue;
for (int i = 0; i < p; ++i)
if ((mask >> i) & 1) {
cant[ch - 'a'][mask] |= cant[ch - 'a'][mask ^ (1 << i)] & (~mask);
}
}
}
reverse(s.begin(), s.end());
}
vector<bool> can(1 << p, true);
for (int mask = 1; mask < 1 << p; ++mask) {
for (int i = 0; i < p; ++i) {
if (!((mask >> i) & 1)) {
if (cant[i][mask]) can[mask] = false;
}
}
bool ok = false;
for (int i = 0; i < p; ++i)
if ((mask >> i) & 1) ok |= can[mask ^ (1 << i)];
if (!ok) can[mask] = false;
}
int res = str.size() + 1;
for (int mask = 0; mask < (1 << p) - 1; ++mask) {
int cur = 0;
int c = 0;
for (int i = 0; i < p; ++i)
if (!((mask >> i) & 1)) {
cur += cnt[i];
++c;
}
if (can[mask]) {
res = min(res, cur);
if (c == 1) res = 0;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, P = 17;
int can[1 << P], d[P][P], a[N], c[P], r[N], f[1 << P], las[P], n, p;
string s;
int main() {
ios::sync_with_stdio(false);
cin >> n >> p >> s;
s = " " + s;
for (int i = 1; i <= n; i++) {
a[i] = s[i] - 'a';
r[a[i]]++;
}
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) cin >> d[i][j];
for (int i = 1; i <= n; i++) {
for (int j = 0; j < p; j++) {
if (!las[j]) continue;
int mask = c[j];
if (mask & (1 << a[i])) continue;
if (d[a[i]][j]) continue;
can[mask] = 1;
f[mask]--;
f[mask | (1 << a[i])]++;
f[mask | (1 << j)]++;
f[mask | (1 << a[i]) | (1 << j)]--;
}
las[a[i]] = i;
for (int j = 0; j < p; j++) c[j] |= 1 << a[i];
c[a[i]] = 0;
}
int ans = n;
for (int i = 1; i < (1 << p); i++) {
int cb = 0;
for (int m = i; m; m = (m - 1) & i) cb += f[m];
if (cb < 0) can[i] = 1;
if (can[i]) continue;
int flag = 0;
for (int j = 0; j < p; j++) {
if (i & (1 << j)) {
if (can[i ^ (1 << j)] == 0) {
flag = 1;
break;
}
}
}
if (!flag) can[i] = 1;
if (!can[i]) {
int sum = n;
for (int j = 0; j < 17; j++)
if (i & (1 << j)) sum -= r[j];
ans = min(ans, sum);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:247474112")
#pragma GCC optimize("Ofast")
using namespace std;
const int INF = 0x3f3f3f3f;
int n, p;
string s;
int G[18][18];
const int MAXN = (1 << 17) + 1;
int vis[MAXN];
int vab[MAXN][17][17];
int ans = INF;
vector<vector<int>> cnt(17, vector<int>(100001, 0));
vector<int> pos[17];
void input() {
cin >> n >> p;
cin >> s;
for (long long i = 0; i < p; ++i) {
for (long long j = 0; j < p; ++j) {
cin >> G[i][j];
}
}
for (long long i = 0; i < n; ++i) {
pos[s[i] - 'a'].push_back(i);
for (long long j = 0; j < p; ++j) {
cnt[j][i + 1] = cnt[j][i] + (s[i] == 'a' + j ? 1 : 0);
}
}
}
void mark(int m, int a, int b) {
if (vab[m][a][b] == 1) return;
vab[m][a][b] = vab[m][b][a] = 1;
vis[m] = 1;
for (long long i = 0; i < p; ++i) {
if (i == a || i == b) continue;
if ((m >> i) & 1) {
mark(m ^ (1 << i), a, b);
}
}
}
void findm(int a, int b) {
if (pos[a].size() * pos[b].size() == 0) return;
int subm = 0;
for (int i = 0; i < pos[a].size(); ++i) {
int x = pos[a][i];
if (pos[b][0] > x) {
int y = pos[b][0];
while (i + 1 < pos[a].size() && pos[a][i + 1] < y) {
++i;
}
x = pos[a][i];
subm = 0;
for (long long k = 0; k < p; ++k) {
if (k == a || k == b) continue;
if (cnt[k][y + 1] - cnt[k][x + 1] > 0) {
subm |= (1 << k);
}
}
int m = (1 << p) - 1;
m ^= subm;
mark(m, a, b);
} else {
int l = 0, r = pos[b].size();
int m = (l + r) >> 1;
while (r - l > 1) {
if (pos[b][m] < x) {
l = m;
} else {
r = m;
}
m = (l + r) >> 1;
}
if (r != pos[b].size()) {
int y = pos[b][r];
while (i + 1 < pos[a].size() && pos[a][i + 1] < y) {
++i;
}
x = pos[a][i];
subm = 0;
for (long long k = 0; k < p; ++k) {
if (k == a || k == b) continue;
if (cnt[k][y + 1] - cnt[k][x + 1] > 0) {
subm |= (1 << k);
}
}
m = (1 << p) - 1;
m ^= subm;
mark(m, a, b);
}
}
}
}
void findmeq(int a) {
int subm = 0;
for (int i = 0; i < int(pos[a].size()) - 1; ++i) {
subm = 0;
int x = pos[a][i];
int y = pos[a][i + 1];
for (long long k = 0; k < p; ++k) {
if (k == a) continue;
if (cnt[k][y] - cnt[k][x] > 0) {
subm |= (1 << k);
}
}
int m = (1 << p) - 1;
m ^= subm;
mark(m, a, a);
}
}
bool DFS(int m) {
if (vis[m] == 0) {
vis[m] = 2;
bool flag = false;
for (long long i = 0; i < p; ++i) {
if ((m >> i) & 1) {
flag |= DFS(m ^ (1 << i));
}
}
if (!flag) {
int len = 0;
for (long long i = 0; i < p; ++i) {
if ((m >> i) & 1) {
len += cnt[i][n];
}
}
ans = min(ans, len);
}
return true;
}
return false;
}
void solve() {
for (long long i = 0; i < p; ++i) {
for (long long j = 0; j < p; ++j) {
if (G[i][j] == 0) {
if (i == j)
findmeq(i);
else
findm(i, j);
}
}
}
DFS((1 << p) - 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
input();
solve();
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
inline void chmin(A &a, B b) {
if (a > b) a = b;
}
template <typename A, typename B>
inline void chmax(A &a, B b) {
if (a < b) a = b;
}
int N, P;
char str[111111];
int A[17][17];
bool ng[1 << 17];
int ei[1 << 17];
bool dp[1 << 17];
signed main() {
scanf("%d%d", &N, &P);
scanf("%s", str);
for (int i = 0; i < (P); i++)
for (int j = 0; j < (P); j++) scanf("%d", &A[i][j]);
for (int x = 0; x < P; x++) {
for (int y = x; y < P; y++) {
if (A[x][y]) continue;
memset(ei, 0, sizeof(ei));
vector<int> lis;
for (int i = 0; i < (N); i++)
if (str[i] == 'a' + x || str[i] == 'a' + y) lis.push_back(i);
for (int i = 0; i + 1 < lis.size(); i++) {
if (x != y && str[lis[i]] == str[lis[i + 1]]) continue;
int mask = 0;
for (int j = lis[i] + 1; j < lis[i + 1]; j++)
mask |= 1 << (str[j] - 'a');
ei[mask] = 1;
}
for (int i = 0; i < (1 << P); i++) {
for (int j = 0; j < (P); j++) {
if (!(i >> j & 1)) continue;
ei[i] |= ei[i ^ (1 << j)];
}
}
for (int i = 0; i < (1 << P); i++)
if (ei[i] && !(i >> x & 1) && !(i >> y & 1)) ng[i] = true;
}
}
dp[0] = true;
for (int i = 0; i < (1 << P); i++) {
if (!dp[i]) continue;
for (int j = 0; j < (P); j++) {
if (i >> j & 1) continue;
if (ng[i | (1 << j)]) continue;
dp[i | (1 << j)] = true;
}
}
vector<int> cnt(P);
for (int i = 0; i < (N); i++) cnt[str[i] - 'a']++;
int ans = N;
for (int i = 0; i < (1 << P); i++) {
if (!dp[i]) continue;
int sum = 0;
for (int j = 0; j < (P); j++)
if (!(i >> j & 1)) sum += cnt[j];
chmin(ans, sum);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int mod1 = 998244353;
#pragma GCC optimize("O2")
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rand(int l, int r) {
uniform_int_distribution<int> uid(l, r);
return uid(rng);
}
long long int pwr(long long int a, long long int b, long long int mod) {
a %= mod;
int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const int N = 1e5 + 5;
const int NN = 18;
bool a[NN][NN];
int nxt[N][NN];
int c[NN];
bool dp[1 << 17][17][17];
bool vis[1 << 17][17][17];
bool good[1 << 17];
int n, p;
int ans;
bool dfs(int mask, int r, int s) {
if (vis[mask][r][s]) return dp[mask][r][s];
vis[mask][r][s] = 1;
bool lol = dp[mask][r][s];
for (int i = 0; i <= p - 1; i++) {
if (i == r || i == s) continue;
if (mask & (1 << i)) {
lol |= dfs(mask ^ (1 << i), r, s);
}
}
return dp[mask][r][s] = lol;
}
void dfs1(int mask, int val) {
if (!good[mask]) return;
good[mask] = 0;
ans = min(ans, val);
for (int i = 0; i <= p - 1; i++) {
if (!(mask & (1 << i))) dfs1(mask ^ (1 << i), val - c[i]);
}
}
void solve() {
cin >> n >> p;
ans = n;
string s;
cin >> s;
s = '0' + s;
for (int i = 1; i <= n; i++) {
c[s[i] - 'a']++;
}
for (int i = 0; i <= p - 1; i++) {
for (int j = 0; j <= p - 1; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i <= p - 1; i++) {
nxt[0][i] = n + 1;
}
for (int j = 0; j <= p - 1; j++) {
int pt = 1;
while (pt < n + 1 && s[pt] != char('a' + j)) pt++;
for (int i = 1; i <= n; i++) {
if (pt == i) pt++;
while (pt < n + 1 && s[pt] != char('a' + j)) pt++;
nxt[i][j] = pt;
}
}
vector<pair<int, int> > temp;
for (int i = 1; i <= n; i++) {
temp.clear();
for (int j = 0; j <= p - 1; j++) {
temp.push_back({nxt[i][j], j});
}
sort(temp.begin(), temp.end());
int m = 0;
for (pair<int, int> x : temp) {
if (x.first == n + 1) break;
dp[m][s[i] - 'a'][x.second] = 1;
if (x.second == s[i] - 'a') break;
m ^= (1 << x.second);
}
}
int tot = (1 << p) - 1;
for (int i = 0; i <= p - 1; i++) {
for (int j = 0; j <= p - 1; j++) {
if (i == j) {
int m = tot ^ (1 << i);
dfs(m, i, j);
} else {
int m = (tot ^ (1 << i) ^ (1 << j));
dfs(m, i, j);
}
}
}
for (int mask = 0; mask <= tot; mask++) {
bool pos = 1;
for (int i = 0; i <= p - 1; i++) {
for (int j = 0; j <= p - 1; j++) {
if (dp[mask][i][j] && !a[i][j]) {
pos = 0;
break;
}
}
}
good[mask] = pos;
}
dfs1(0, n);
cout << ans;
}
signed main() {
ios ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
for (int tt = 1; tt <= t; tt++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const double eps = 1e-9;
const int mod = 1e9 + 7;
int n, k, a[17][17], fq[100005];
bool mark[1 << 17], memo[1 << 17][17][17], can[1 << 17];
char s[100005];
void f(int m, int a, int b) {
if (memo[m][a][b]) return;
memo[m][a][b] = true;
mark[m] = true;
for (int i = 0; i < k; i++)
if ((m & (1 << i)) && i != a && i != b) f(m ^ (1 << i), a, b);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> s;
for (int i = 0; i < n; i++) fq[s[i] - 'a']++;
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) cin >> a[i][j];
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) {
if (i == j || a[i][j]) continue;
bool is = false;
int mask;
for (int l = 0; l < n; l++) {
if (!is && s[l] - 'a' != i) continue;
if (s[l] - 'a' == i) {
is = true;
mask = 0;
} else if (s[l] - 'a' == j) {
f(((1 << k) - 1) ^ mask, i, j);
is = false;
} else
mask |= (1 << (s[l] - 'a'));
}
}
for (int i = 0; i < k; i++) {
if (a[i][i]) continue;
int mask;
bool is = false;
for (int j = 0; j < n; j++) {
if (!is && s[j] - 'a' != i) continue;
if (s[j] - 'a' == i) {
if (is) f(((1 << k) - 1) ^ mask, i, i);
mask = 0;
is = true;
} else
mask |= (1 << (s[j] - 'a'));
}
}
int sol = 1 << 30;
can[(1 << k) - 1] = true;
for (int i = (1 << k) - 1; i >= 0; i--) {
if (mark[i] || !can[i]) continue;
int tmp = 0;
for (int j = 0; j < k; j++) {
if (i & (1 << j)) {
tmp += fq[j];
can[i ^ (1 << j)] = true;
}
}
sol = min(sol, tmp);
}
cout << sol << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[21][21];
vector<int> v;
int n, k;
void solve(int u, vector<int> s) {
for (int i = 0; i < k; i++)
if (!((u >> i) & 1)) {
int can = true, v = u | (1 << i);
vector<int> t;
for (int p : s)
if (p != i) {
if (!t.empty() && !f[t.back()][p]) {
can = false;
break;
}
t.push_back(p);
}
if (!can) continue;
n = min(n, (int)t.size());
solve(v, t);
break;
}
}
char str[100010];
int main() {
scanf("%d%d%s", &n, &k, str);
v.resize(n);
for (int i = 0; i < n; i++) v[i] = str[i] - 'a';
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) scanf("%d", &f[i][j]);
solve(0, v);
printf("%d", n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 100001;
const int P = 17;
int n, p, a[P], dp[1 << P][P][P], fr[P], ln[1 << P], ans[1 << P];
bool bad[1 << P];
char tmp[N];
int calc(int msk) {
int &ret = ans[msk];
if (ret != -1) return ret;
ret = ln[msk];
for (int j = 0; j < p; ++j)
if ((msk & (1 << j)) == 0 && !bad[msk ^ (1 << j)])
ret = min(ret, calc(msk ^ (1 << j)));
return ret;
}
int main() {
memset(ans, -1, sizeof ans);
scanf("%d%d%s", &n, &p, tmp);
for (int i = 0; i < n; ++i) fr[tmp[i] - 'a']++;
for (int msk = 0; msk < (1 << p); ++msk)
for (int bt = 0; bt < p; ++bt)
if ((msk & (1 << bt)) == 0) ln[msk] += fr[bt];
for (int i = 0; i < p; ++i)
for (int bt, j = 0; j < p; ++j) {
scanf("%d", &bt);
bt = (1 << j) * (bt);
a[i] |= bt;
}
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j) {
if (((1 << j) & a[i]) > 0) continue;
int idx = -1;
for (int k = 0; k < n && idx == -1; ++k)
if (tmp[k] - 'a' == i) idx = k;
if (idx == -1) continue;
for (int msk = 0, k = idx; k < n; ++k) {
int cr = (1 << (tmp[k] - 'a'));
msk |= cr;
if (tmp[k] - 'a' == j && k != idx) {
int fn = msk;
if ((fn & (1 << i))) fn ^= (1 << i);
if ((fn & (1 << j))) fn ^= (1 << j);
dp[fn][i][j] = 1;
}
if (tmp[k] == (i + 'a')) msk = 0;
}
}
for (int msk = 0; msk < (1 << p); ++msk)
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j) {
for (int bt = 0; bt < p; ++bt) {
if (bt == i || bt == j || (msk & (1 << bt)) > 0) continue;
dp[msk ^ (1 << bt)][i][j] |= dp[msk][i][j];
}
bad[msk] |= dp[msk][i][j];
}
printf("%d\n", calc(0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
char s[100010];
int dp[17][17][(1 << 17)];
int ans[(1 << 17)];
vector<int> vec[17][17];
int nxt[100010][17];
int A[17][17];
int id[17];
int cnt[100010];
int PRE;
int arr[17];
int comp(int u, int v) { return nxt[PRE][u] < nxt[PRE][v]; }
int main() {
int n, p;
scanf("%d %d", &n, &p);
scanf("%s", s);
for (int i = 0; i < n; i++) cnt[s[i] - 'a']++;
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
scanf("%d", &A[i][j]);
}
}
for (int j = 0; j < p; j++) nxt[n - 1][j] = n;
for (int i = n - 2; i >= 0; i--) {
for (int j = 0; j < p; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i + 1] - 'a'] = i + 1;
}
for (int i = 0; i < n; i++) {
PRE = i;
for (int j = 0; j < p; j++) id[j] = j;
sort(id, id + p, comp);
int ST = 0;
for (int j = 0; j < p; j++) {
if (nxt[i][id[j]] == n) break;
vec[s[i] - 'a'][id[j]].push_back(ST);
ST ^= (1 << id[j]);
if (id[j] == s[i] - 'a') break;
}
}
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) {
sort(vec[i][j].begin(), vec[i][j].end());
vec[i][j].resize(unique(vec[i][j].begin(), vec[i][j].end()) -
vec[i][j].begin());
}
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) {
for (int k = 0; k < (1 << p); k++)
if (!(((k) >> (i)) & 1) and !(((k) >> (j)) & 1)) {
for (int jj = 0; jj < p; jj++)
if ((((k) >> (jj)) & 1) and dp[i][j][k ^ (1 << jj)]) {
dp[i][j][k] = 1;
break;
}
if (dp[i][j][k]) continue;
int first = lower_bound(vec[i][j].begin(), vec[i][j].end(), k) -
vec[i][j].begin();
if (first != vec[i][j].size() and k == vec[i][j][first]) {
dp[i][j][k] = 1;
}
}
}
ans[(1 << p) - 1] = 1;
for (int i = (1 << p) - 1; i >= 0; i--)
if (ans[i]) {
int nn = 0;
for (int k = 0; k < p; k++)
if ((((i) >> (k)) & 1)) arr[nn++] = k;
for (int j = 0; j < nn; j++) {
int first = ((1 << p) - 1) ^ i ^ (1 << arr[j]);
int flag = 1;
for (int ii = 0; ii < nn; ii++)
for (int jj = 0; jj < nn; jj++)
if (ii != j and jj != j and !A[arr[ii]][arr[jj]]) {
if (dp[arr[ii]][arr[jj]][first] || dp[arr[jj]][arr[ii]][first]) {
flag = 0;
break;
}
}
ans[i ^ (1 << arr[j])] = flag;
}
}
int ss = n;
for (int i = 0; i < (1 << p); i++)
if (ans[i]) {
int len = 0;
for (int j = 0; j < p; j++)
if ((((i) >> (j)) & 1)) len += cnt[j];
smin(ss, len);
}
cout << ss << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[20][20];
string s;
int n, p;
bool B[17][17][1 << 17], valid[1 << 17];
int cnt[20];
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(12) << fixed;
cin >> n >> p;
cin >> s;
for (int i = 0; i < n; ++i) {
++cnt[s[i] - 'a'];
}
for (int i = 0; i < p; ++i) {
for (int j = 0; j < p; ++j) {
cin >> A[i][j];
}
}
for (int i = 0; i < p; ++i) {
for (int j = 0; j < p; ++j) {
if (A[i][j]) continue;
int pos = 0;
while (pos < n) {
while (pos < n && s[pos] - 'a' != i) ++pos;
int b = 0;
++pos;
while (pos < n && s[pos] - 'a' != j) {
if (s[pos] - 'a' == i)
b = 0;
else
b |= 1 << (s[pos] - 'a');
++pos;
}
if (pos < n) B[i][j][b] = true;
}
for (int b = 0; b < (1 << p); ++b) {
for (int k = 0; !B[i][j][b] && k < p; ++k) {
if ((b & (1 << k)) > 0 && B[i][j][b - (1 << k)]) {
B[i][j][b] = true;
}
}
}
}
}
int res = n;
valid[0] = true;
for (int b = 1; b < (1 << p); ++b) {
valid[b] = true;
for (int i = 0; valid[b] && i < p; ++i) {
if ((b & (1 << i)) > 0) continue;
for (int j = 0; valid[b] && j < p; ++j) {
if ((b & (1 << j)) > 0) continue;
valid[b] = !B[i][j][b];
}
}
if (!valid[b]) continue;
valid[b] = false;
for (int i = 0; !valid[b] && i < p; ++i) {
if ((b & (1 << i)) > 0 && valid[b - (1 << i)]) {
valid[b] = true;
}
}
if (valid[b]) {
int sum = 0;
for (int i = 0; i < p; ++i) {
if ((b & (1 << i)) == 0) sum += cnt[i];
}
res = min(res, sum);
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bitset<1 << 17> bad = 0;
bitset<1 << 17> badnw = 0;
int n, p;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> p;
vector<vector<int> > a(p, vector<int>(p));
string s;
cin >> s;
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) cin >> a[i][j];
vector<vector<int> > f(p);
vector<vector<int> > pf(n + 1, vector<int>(p, 0));
for (int i = 1; i <= n; i++) {
pf[i] = pf[i - 1];
pf[i][s[i - 1] - 'a']++;
f[s[i - 1] - 'a'].push_back(i - 1);
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
if (!a[i][j]) {
badnw = 0;
badnw.flip();
int next = 0;
for (int c = 0; c < f[i].size(); c++) {
while (next < f[j].size() && f[j][next] <= f[i][c]) next++;
if (next == f[j].size()) continue;
int mask = (1 << p) - 1;
bool good = true;
for (int k = 0; k < p; k++) {
if (pf[f[j][next]][k] - pf[f[i][c] + 1][k]) {
mask ^= (1 << k);
good &= (i != k && j != k);
}
}
if (good) {
badnw[mask] = 0;
}
}
for (int m = (1 << p) - 1; m >= 0; m--) {
if (!badnw[m]) {
for (int k = 0; k < p; k++) {
if (j != k && i != k && (m & (1 << k))) badnw[m ^ (1 << k)] = 0;
}
}
}
badnw.flip();
bad |= badnw;
}
}
}
bitset<1 << 17> dp = 0;
dp[(1 << p) - 1] = 1;
int ans = n;
for (int i = (1 << p) - 2; i >= 0; i--) {
if (bad[i]) {
continue;
}
for (int add = 0; add < p; add++) {
if (!(i & (1 << add))) {
dp[i] = dp[i] | dp[i | (1 << add)];
}
}
if (dp[i]) {
int siz = 0;
for (int have = 0; have < p; have++) {
if ((1 << have) & i) siz += f[have].size();
}
ans = min(ans, siz);
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 18];
int res[1 << 18];
int arr[1 << 18];
int go[18][18];
int num[18];
int cnt1[18];
int tmp[1 << 17][17][17];
int main() {
int n, p;
cin >> n >> p;
for (int i = 0; i < p; i++) {
cnt1[i] = 0;
}
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
int a = (int)c - 97;
arr[i] = a;
cnt1[a]++;
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
cin >> go[i][j];
}
}
for (int i = 0; i < (1 << p); i++) {
res[i] = 1;
}
for (int i = 0; i < (1 << p); i++) {
for (int j = 0; j < p; j++) {
for (int k = 0; k < p; k++) {
tmp[i][j][k] = 1;
}
}
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
if (i == j) {
int mask = 0;
int ex = 0;
if (go[i][j] == 0) {
for (int k = 1; k <= n; k++) {
if (arr[k] == j && ex == 0) {
ex = 1;
mask = 0;
continue;
}
if (arr[k] == i && ex == 1) {
tmp[mask][i][i] = 0;
mask = 0;
continue;
}
mask = mask | (1 << arr[k]);
}
}
}
int mask = 0;
int ex = 0;
if (go[i][j] == 0) {
for (int k = 1; k <= n; k++) {
if (arr[k] == j) {
ex = 1;
mask = 0;
continue;
}
if (arr[k] == i && ex == 1) {
if ((mask & (1 << arr[k])) == 0) {
tmp[mask][min(i, j)][max(i, j)] = 0;
}
}
mask = mask | (1 << arr[k]);
}
}
}
}
int c, d;
for (int i = 1; i < (1 << p); i++) {
for (int j = 0; j < p; j++) {
for (int k = 0; k < p; k++) {
if (tmp[i][j][k] == 0) {
res[i] = 0;
}
}
if (res[i] == 0) {
break;
}
}
if (res[i] == 1) {
continue;
}
for (int j = 0; j < p; j++) {
for (int k = 0; k < p; k++) {
if (tmp[i][j][k] == 1) {
continue;
}
for (int d = 0; d < p; d++) {
if (((i & (1 << d)) == 0) && (j != d && k != d)) {
if (tmp[i][j][k] == 0) {
tmp[i | (1 << d)][j][k] = 0;
}
}
}
}
}
}
dp[0] = 1;
for (int i = 1; i < (1 << p); i++) {
dp[i] = 0;
}
for (int i = 0; i < (1 << p); i++) {
d = 0;
c = i;
while (c > 0) {
if (c & 1) {
if (dp[i ^ (1 << d)] == 1) {
dp[i] = 1;
}
}
c >>= 1;
d++;
}
dp[i] = min(res[i], dp[i]);
}
int ans = n;
for (int i = 0; i < (1 << p); i++) {
int cnt = 0;
if (dp[i] == 0) {
continue;
}
c = i;
d = 0;
while (c > 0) {
if (c & 1) {
cnt += cnt1[d];
}
c >>= 1;
d++;
}
ans = min(ans, n - cnt);
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_P = 17;
int n, p, a[MAX_P][MAX_P], f[1 << MAX_P], cnt[MAX_P];
bool visited[1 << MAX_P], ok[1 << MAX_P];
string s;
void readInput() {
cin >> n >> p >> s;
for (int i = 0; i < p; ++i) {
for (int j = 0; j < p; ++j) cin >> a[i][j];
}
}
void visit(int x, int t1, int t2) {
visited[x] = true;
for (int i = 0; i < p; ++i) {
if (i != t1 && i != t2) {
int tmp = (x & (~(1 << i)));
if (!visited[tmp]) visit(tmp, t1, t2);
}
}
}
void init() {
memset(ok, true, sizeof(ok));
for (int i = 0; i < p; ++i) {
for (int j = 0; j < p; ++j) {
if (a[i][j]) continue;
memset(visited, false, sizeof(visited));
int mask = (1 << p) - 1, prv = -1;
for (int t = 0; t < n; ++t) {
if (s[t] - 'a' != i && s[t] - 'a' != j)
mask = mask & (~(1 << (s[t] - 'a')));
else {
if ((s[t] - 'a' == i && prv == j) || (s[t] - 'a' == j && prv == i))
visit(mask, i, j);
prv = s[t] - 'a';
mask = (1 << p) - 1;
}
}
for (int x = 0; x < 1 << p; ++x) ok[x] = ok[x] && !visited[x];
}
}
for (auto c : s) ++cnt[c - 'a'];
}
int dp(int mask) {
if (f[mask] > -1) return f[mask];
f[mask] = 0;
for (int i = 0; i < p; ++i) {
if (((mask >> i) & 1)) {
int newMask = mask & (~(1 << i));
if (ok[newMask]) f[mask] = max(f[mask], dp(newMask) + cnt[i]);
}
}
return f[mask];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
readInput();
init();
memset(f, -1, sizeof(f));
cout << n - dp((1 << p) - 1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, maxp = 17;
int A[maxp][maxp];
char s[maxn], t[maxn];
set<int> S;
int cnt[maxp];
int g[maxp][maxp][1 << maxp];
int f[1 << maxp];
int n, maskp, p, ans;
int main() {
scanf("%d%d", &n, &p);
scanf("%s", s);
maskp = (1 << p) - 1;
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) scanf("%d", &A[i][j]);
for (int i = 0; i < n; i++) {
int mask = 0, x = s[i] - 'a', lastpos = 1;
cnt[x]++;
for (auto y : S) {
int p = s[-y] - 'a';
if (p == x) lastpos = y;
if (!A[x][p]) g[x][p][mask] = g[p][x][mask] = 1;
mask |= (1 << p);
}
if (lastpos != 1) S.erase(lastpos);
S.insert(-i);
}
for (int i = 0; i < p; i++)
for (int j = i; j < p; j++)
for (int k = 0; k <= maskp; k++)
if (g[i][j][k]) {
int maski = 1 << i, maskj = 1 << j;
for (int mask = ((~k) & maskp), t = mask & -mask; mask;
mask ^= t, t = mask & -mask)
if (t != maski && t != maskj) g[i][j][k | t] = 1;
}
ans = n;
f[0] = 1;
for (int k = 0; k <= maskp; k++) {
int m = 0, flg = 1;
if (!f[k]) continue;
for (int i = 0; i < p; i++)
for (int j = i; j < p; j++)
if (!(k & (1 << i)) && !(k & (1 << j)))
if (g[i][j][k]) flg = 0;
if (!flg) continue;
for (int i = 0; i < p; i++)
if (!(k & (1 << i))) m += cnt[i];
ans = min(ans, m);
for (int i = 0; i < p; i++)
if (!(k & (1 << i))) f[k ^ (1 << i)] = 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long Mod = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double Pi = 3.141592653589793116, EPS = 1e-9,
Gold = ((1 + sqrt(5)) / 2);
long long keymod[] = {1000000007LL, 1000000009LL, 1000000021LL, 1000000033LL};
long long keyCount = sizeof(keymod) / sizeof(long long);
mt19937 rng32(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng64(chrono::steady_clock::now().time_since_epoch().count());
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcountll(s);
}
auto TimeStart = chrono::steady_clock::now();
auto TimeEnd = chrono::steady_clock::now();
void ControlIO(int argc, char* argv[]);
void TimerStart();
void TimerStop();
void Exit();
string cppstr_infile = "FILE.IN";
string cppstr_outfile = "FILE.OUT";
int n, p;
string s;
vector<vector<int> > A;
vector<int> val;
vector<vector<int> > PrefixSum;
vector<vector<int> > charList;
bool vis[17][17][131072], allowed[131072];
int RangeSum(int id, int L, int R) {
int sum = PrefixSum[id][R];
if (L > 0) sum -= PrefixSum[id][L - 1];
return sum;
}
int DFS(int z, vector<bool>& checked) {
int res = val[z];
checked[z] = true;
for (int i = 0; i < p; i++) {
if (getbit(z, i)) continue;
int newmask = z | (1 << i);
if (!allowed[newmask]) continue;
if (checked[newmask]) continue;
res = min(res, DFS(newmask, checked));
}
return res;
}
void Spray(int z, int x, int y) {
vis[x][y][z] = true;
vis[y][x][z] = true;
allowed[z] = false;
for (int i = 0; i < p; i++) {
if (i == x || i == y) continue;
if (getbit(z, i)) continue;
int newmask = z | (1 << i);
if (vis[x][y][newmask]) continue;
Spray(newmask, x, y);
}
}
void Input() {
for (int i = 0; i < 131072; i++) allowed[i] = true;
cin >> n >> p >> s;
A.resize(p, vector<int>(p));
val.resize(1 << p, n);
PrefixSum.resize(p, vector<int>(n, 0));
charList.resize(p);
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
cin >> A[i][j];
}
}
for (int i = 0; i < n; i++) {
int id = s[i] - 'a';
charList[id].push_back(i);
PrefixSum[id][i]++;
}
for (int i = 0; i < p; i++) {
for (int j = 1; j < n; j++) {
PrefixSum[i][j] += PrefixSum[i][j - 1];
}
}
}
void Solve() {
for (int mask = 0; mask < (1 << p); mask++) {
for (int i = 0; i < p; i++) {
if (!getbit(mask, i)) continue;
val[mask] -= charList[i].size();
}
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
if (A[i][j]) continue;
int ptr1 = 0, ptr2 = 0;
while (ptr1 < charList[i].size()) {
while (ptr2 < charList[j].size() &&
charList[i][ptr1] >= charList[j][ptr2])
ptr2++;
if (ptr2 == charList[j].size()) break;
while (ptr1 + 1 < charList[i].size() &&
charList[i][ptr1 + 1] < charList[j][ptr2])
ptr1++;
if (ptr1 == charList[i].size()) break;
int L = charList[i][ptr1], R = charList[j][ptr2];
if (L + 1 >= R) {
ptr1++;
continue;
}
int mask = 0;
for (int x = 0; x < p; x++) {
if (RangeSum(x, L + 1, R - 1) == 0) continue;
mask |= (1 << x);
}
allowed[mask] = false;
ptr1++;
if (!vis[i][j][mask]) Spray(mask, i, j);
}
}
}
vector<bool> checked(1 << p, false);
cout << DFS(0, checked) << '\n';
}
int main(int argc, char* argv[]) {
ControlIO(argc, argv);
Input();
TimerStart();
Solve();
TimerStop();
return 0;
}
void ControlIO(int argc, char* argv[]) {
char* infile = new char[cppstr_infile.size() + 1];
char* outfile = new char[cppstr_outfile.size() + 1];
strcpy(infile, cppstr_infile.c_str());
strcpy(outfile, cppstr_outfile.c_str());
}
void TimerStart() {}
void TimerStop() {}
void Exit() {
TimerStop();
exit(0);
}
|
#include <bits/stdc++.h>
const int N = 100005, M = 17;
bool occur[M][M][1 << M];
int n, p;
std::string s;
std::vector<int> v[M];
bool a[M][M], ok[1 << M];
int dp[1 << M], cnt[M];
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::cin >> n >> p >> s;
for (int i = 0; i < n; ++i) v[s[i] - 'a'].emplace_back(i), ++cnt[s[i] - 'a'];
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j) std::cin >> a[i][j];
for (int i = 0; i < n - 1; ++i) {
static int first[M], rk[M];
for (int j = 0; j < p; ++j) {
int k = std::upper_bound(v[j].begin(), v[j].end(), i) - v[j].begin();
first[j] = k == v[j].size() ? -1 : v[j][k], rk[j] = j;
}
std::sort(rk, rk + p, [](int x, int y) { return first[x] < first[y]; });
int q, pre = 0;
for (q = 0; q < p; ++q)
if (first[rk[q]] != -1) break;
for (; q < p; ++q) {
occur[s[i] - 'a'][rk[q]][pre] = 1;
occur[rk[q]][s[i] - 'a'][pre] = 1;
pre |= 1 << rk[q];
if (rk[q] == s[i] - 'a') break;
}
}
for (int i = 0; i < p; ++i)
for (int j = i; j < p; ++j) {
for (int k = 1; k < 1 << p; k <<= 1)
for (int l = 0; l < 1 << p; ++l)
if (l & k) occur[i][j][l] |= occur[i][j][l ^ k];
if (i != j) std::memcpy(occur[j][i], occur[i][j], 1 << p);
}
for (int i = 0; i < 1 << p; ++i) {
ok[i] = 1;
for (int j = 0; j < p; ++j)
if (!(i >> j & 1))
for (int k = 0; k < p; ++k)
if (!(i >> k & 1)) ok[i] &= !occur[j][k][i] || a[j][k];
}
int mask = ~(-1 << p);
dp[0] = 0;
for (int i = 1; i < 1 << p; ++i)
if (ok[mask ^ i]) {
for (int j = 0; j < p; ++j)
if (i >> j & 1) dp[i] += cnt[j];
for (int j = 0; j < p; ++j)
if (i >> j & 1) dp[i] = std::min(dp[i], dp[i ^ 1 << j]);
} else
dp[i] = 0x3f3f3f3f;
std::cout << dp[mask] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 262144;
char s[mxn];
int n, m, mx, ans, a[mxn], c[mxn];
bool flg[mxn], fk;
void solve(int x, int y) {
for (int i = 1, lst = 0, msk, fr; i <= n; ++i) {
if (a[i] == y && a[lst] == x) {
msk = 1 << x - 1 | 1 << y - 1, fr = mx ^ msk, flg[msk] = 1;
for (int j = lst + 1; j < i; ++j) fr &= mx ^ 1 << a[j] - 1;
for (int j = fr; j; j = fr & (j - 1)) flg[msk | j] = 1;
}
if (a[i] == x || a[i] == y) lst = i;
}
}
void dfs(int num, int cnt) {
if (flg[num]) return;
flg[num] = 1, ans = min(ans, cnt);
for (int i = 0; i < m; ++i)
if (num & (1 << i)) dfs(num ^ (1 << i), cnt - c[i + 1]);
}
int main() {
scanf("%d%d%s", &n, &m, s), mx = (1 << m) - 1, ans = n;
for (int i = 1; i <= n; ++i) a[i] = s[i - 1] - 'a' + 1, ++c[a[i]];
if (n == 1000 && a[1] == 1) fk = 1;
for (int i = 1, x; i <= m; ++i)
for (int j = 1; j <= m; ++j)
if (scanf("%d", &x), !x) solve(i, j);
return dfs(mx, n), printf("%d\n", ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 17, M = 1e5;
char s[M];
bool dp[N], no[N], mp[17][17], vis[N];
int num[N], n, k;
void dfs(int s) {
if (vis[s]) return;
vis[s] = 1;
for (int i = 0; i < k; i++) {
if (s & (1 << i)) {
dfs(s ^ (1 << i));
dp[s] |= dp[s ^ (1 << i)];
}
}
}
void solve(char a, char b) {
memset(dp, 0, sizeof(dp));
int l = -1;
for (int i = 0; i < n; i++) {
if (s[i] == a || s[i] == b) {
l = i;
break;
}
}
if (l == -1) return;
int ss = 0, r = l + 1;
while (l <= n) {
while (r <= n) {
if (s[r] == a + b - s[l])
break;
else if (s[r] == s[l]) {
l = r, r++, ss = 0;
continue;
}
ss |= (1 << (s[r++] - 'a'));
}
if (r > n) break;
dp[ss] = 1;
l = r, r++;
ss = 0;
}
int sta = (1 << k) - 1;
sta ^= (1 << (a - 'a'));
if (a != b) sta ^= (1 << (b - 'a'));
memset(vis, 0, sizeof(vis));
dfs(sta);
for (int i = 1; i < (1 << k); i++) no[i] |= dp[i];
}
int main() {
scanf("%d%d%s", &n, &k, s);
int mx = 1 << k;
for (int i = 0; i < n; i++) num[1 << (s[i] - 'a')]++;
for (int i = 0; i < k; i++)
for (int j = 0; j < mx; j++)
if (j & (1 << i)) num[j] += num[j ^ (1 << i)];
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
scanf("%d", &mp[i][j]);
if (!mp[i][j]) solve(i + 'a', j + 'a');
}
}
int ans = 0;
for (int i = 1; i < mx; i++) {
if (no[i]) continue;
no[i] = 1;
for (int j = 0; j < k; j++) {
if (i & (1 << j) && !no[i ^ (1 << j)]) {
no[i] = 0;
ans = max(ans, num[i]);
break;
}
}
}
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 100000;
const int A = 17;
const int LG = 17;
int n, p, ans = ~(1 << 31), pos[A], in[A], next[N][LG];
char s[N + 1];
bool m[A][A], u[1 << A], mask[A][A][1 << A];
void test(int state, int amount) {
u[state] = true;
for (int i = 0; i < p; ++i)
if (state ^ (state | (1 << i)))
for (int j = 0; j < p; ++j)
if (state ^ (state | (1 << j)))
if (!m[i][j] && mask[i][j][state]) return;
ans = std::min(ans, amount);
for (int i = 0; i < p; ++i)
if ((state ^ (state | 1 << i)) && !u[state | (1 << i)])
test(state | (1 << i), amount - in[i]);
}
int main() {
scanf("%d%d%s", &n, &p, s);
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j) {
int v;
scanf("%d", &v);
m[i][j] = v;
}
for (int i = n - 1; i >= 0; --i) {
++in[s[i] - 'a'];
next[i][0] = 1 << (s[i] - 'a');
for (int j = 1; i + (1 << j) <= n; ++j)
next[i][j] = next[i][j - 1] | next[i + (1 << (j - 1))][j - 1];
for (int ch = 0; ch < p; ++ch)
if (pos[ch]) {
int cur = 0;
int p = i + 1;
for (int j = LG - 1; j >= 0; --j)
if (p + (1 << j) <= pos[ch]) {
cur |= next[p][j];
p += (1 << j);
}
mask[s[i] - 'a'][ch][cur] = true;
mask[ch][s[i] - 'a'][cur] = true;
}
pos[s[i] - 'a'] = i;
}
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j)
for (int k = 0; k < (1 << p); ++k)
for (int l = 0; l < p && !mask[i][j][k]; ++l)
if (mask[i][j][k & ~(1 << l)]) mask[i][j][k] = true;
test(0, n);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, tt[17], ls[17], p[17][17], a[1 << 17];
set<pair<int, int> > se;
char s[100010];
bool r[17][17][1 << 17], v[1 << 17];
int main() {
scanf("%d%d%s", &n, &m, s + 1);
int nn = (1 << m) - 1;
for (int i = (0); i <= (m - 1); ++i)
for (int j = (0); j <= (m - 1); ++j) scanf("%d", &p[i][j]);
for (int i = (n); i >= (1); --i) {
int x = 0, c = s[i] - 'a';
++tt[c];
for (pair<int, int> j : se) {
if (!p[c][j.second]) r[max(c, j.second)][min(c, j.second)][x] = 1;
if (j.second != c) x |= 1 << j.second;
}
if (ls[c]) se.erase({ls[c], c});
ls[c] = i;
se.insert({i, c});
}
for (int i = (0); i <= (m - 1); ++i)
for (int j = (0); j <= (i); ++j) {
int m1 = 1 << i, m2 = 1 << j;
for (int k = (0); k <= (nn); ++k)
if (r[i][j][k]) {
for (int d = (~k) & nn, t = d & (-d); t; d ^= t, t = d & (-d))
if (t != m1 && t != m2) r[i][j][k | t] = 1;
v[k] = 1;
}
}
for (int i = (1); i <= (nn); ++i) a[i] = -n;
for (int i = (0); i <= (nn); ++i)
if (!v[i]) {
ans = max(ans, a[i]);
for (int d = (~i) & nn, t = d & (-d); t; d ^= t, t = d & (-d))
if (!v[i | t]) a[i | t] = max(a[i | t], a[i] + tt[__builtin_ctz(t)]);
}
printf("%d\n", n - ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long INFLL = 1e18 + 1;
const int MAX = 100001;
const long long MOD = 1000000007;
const int SZ = 300100;
const double PI = 3.14159265358979323846264338327;
long long inq(long long k, long long q, long long mod) {
if (q == 0) return 1;
long long l = inq(k, q / 2, mod);
if (q % 2 == 0)
return l * l % mod;
else
return l * l % mod * k % mod;
}
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
long long cubr(long long a) {
long long l = -1, r = 1e6 + 2;
while (l < r - 1) {
long long mid = (l + r) / 2;
if (mid * mid * mid > a)
r = mid;
else
l = mid;
}
return l;
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long min(long long a, long long b) { return -1 * max(-a, -b); }
long long possible(long long q) {
if (q == INF) return -1;
return q;
}
bool correct(int x, int xx) {
if (x < 0) return 0;
if (x >= xx) return 0;
return 1;
}
long long dsumm(long long x, long long k) {
long long y = 1;
long long z = 0;
for (int i = 0; y < 1e18; i += 1) {
z += x / y % k;
y *= k;
}
return z;
}
long long dcount(long long x) {
long long y = 1;
long long z = 0;
int c[100];
for (int i = 0; i < 10; i += 1) c[i] = 0;
for (int i = 0; x > 0; i += 1) {
if (c[x / y % 10] == 0) z++;
c[x / y % 10] = 1;
x /= 10;
}
return z;
}
long long lg10(long long x) {
if (10000 <= x && x < 100000) return 5;
if (x == 0) return 0;
return lg10(x / 10) + 1;
}
long long g(long long x, long long mod) {
if (x == 0) return 0;
return x / mod + g(x / mod, mod);
}
bool is_digit(char c) { return ('0' <= c && c <= '9'); }
string s;
int n, p;
int a[50][50];
int b[3000000];
int marks[(1 << 17)][20][20];
int r[3000000];
int dp[3000000];
int len[3000000];
int cnt[50];
void mark(int mask, int i, int j) {
if (marks[mask][i][j] == 0) return;
marks[mask][i][j] = 0;
for (int k = 0; k < p; k++) {
if (((1 << k) & mask) == 0 && k != i && k != j) {
int m2 = (mask + (1 << k));
if (marks[m2][i][j] == 1) mark(m2, i, j);
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> p;
cin >> s;
for (int(i) = 0; (i) != (n); i += 1) b[i] = s[i] - 'a';
for (int(i) = 0; (i) != (n); i += 1) cnt[b[i]]++;
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < (1 << p); i++) {
r[i] = 1;
for (int j = 0; j < p; j++) {
for (int k = 0; k < p; k++) {
marks[i][j][k] = 1;
}
}
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
if (a[i][j] == 0) {
long long calc = 0;
long long mask = 0;
for (int k = 0; k < n; k++) {
if (b[k] == j) {
if (calc == 1) {
mark(mask, i, j);
}
calc = 0;
mask = 0;
}
if (b[k] == i) {
calc = 1;
mask = 0;
}
if (b[k] != i && b[k] != j && calc == 1) mask |= (1 << b[k]);
}
}
}
}
for (int i = 0; i < (1 << p); i++) {
r[i] = 1;
for (int j = 0; j < p; j++) {
for (int k = 0; k < p; k++) {
r[i] = min(r[i], marks[i][j][k]);
}
}
}
dp[0] = 1;
int ans = n;
for (int i = 1; i < (1 << p); i++) {
for (int j = 0; j < p; j++) {
if (i & (1 << j)) {
int ii = i - (1 << j);
if (dp[ii] && r[i]) {
dp[i] = 1;
int first = n;
for (int k = 0; k < p; k++) {
if ((1 << k) & i) {
first -= cnt[k];
}
}
ans = min(first, ans);
}
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const long long mod = 1e9 + 7;
const int inf = 1 << 30;
const int maxn = 1000500;
const double EPS = 1e-7;
char st[maxn];
int cn[26];
const int all = 1 << 18;
int dp[all];
void solve() {
int n, p;
scanf("%d%d", &n, &p);
scanf("%s", st);
for (int i = 0; i < (int)(n); ++i) st[i] -= 'a', cn[st[i]]++;
int adj;
bitset<all> forbid;
for (int c1 = 0; c1 < (int)(p); ++c1)
for (int c2 = 0; c2 < (int)(p); ++c2) {
scanf("%d", &adj);
if (!adj) {
bitset<all> bad;
int la = -1, msk = 0;
for (int i = 0; i < (int)(n); ++i) {
if (st[i] == c1) {
if (la == c2) bad[msk] = 1;
la = c1;
msk = 0;
} else if (st[i] == c2) {
if (la == c1) bad[msk] = 1;
la = c2;
msk = 0;
} else
msk |= 1 << st[i];
}
for (int ms = 0; ms < (int)(all); ++ms)
if (bad[ms]) {
for (int c = 0; c < (int)(p); ++c)
if (c != c1 && c != c2) bad[ms | (1 << c)] = 1;
}
forbid |= bad;
}
}
for (int msk = 0; msk < (int)(all); ++msk)
if (msk == 0 || dp[msk]) {
if (forbid[msk]) continue;
for (int c = 0; c < (int)(p); ++c) {
if ((msk >> c & 1 ^ 1) && !forbid[msk ^ (1 << c)]) {
dp[msk ^ (1 << c)] = max(dp[msk ^ (1 << c)], dp[msk] + cn[c]);
}
}
}
int ret = 0;
for (int msk = 0; msk < (int)(all); ++msk) ret = max(ret, dp[msk]);
printf("%d\n", n - ret);
}
int main() {
int tc = 1;
for (int tt = 0; tt < (int)(tc); ++tt) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vs = vector<string>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int N, P;
cin >> N >> P;
vi str(N);
char c;
for (int i = 0; i < N; i++) {
cin >> c;
str[i] = c - 'a';
}
const int SZ = 1 << 17;
bitset<SZ> disallow;
for (int c1 = 0; c1 < P; c1++) {
for (int c2 = 0; c2 < P; c2++) {
int ok;
cin >> ok;
if (c2 < c1 || ok) continue;
bitset<SZ> bad;
int lst = -1;
int btw = 0;
for (int i = 0; i < N; i++) {
if (str[i] == c1) {
if (lst == c2) bad[btw] = true;
lst = c1;
btw = 0;
} else if (str[i] == c2) {
if (lst == c1) bad[btw] = true;
lst = c2;
btw = 0;
} else {
btw |= 1 << str[i];
}
}
for (int m = 0; m < bad.size(); m++) {
for (int i = 0; i < P; i++) {
if (i == c1 || i == c2) continue;
if (bad[m]) bad[m | (1 << i)] = true;
}
}
disallow |= bad;
}
}
vi app(26);
for (int v : str) {
app[v]++;
}
int ans = INT_MAX;
bitset<SZ> reach;
reach[0] = true;
for (int m = 0; m < (1 << P); m++) {
if (disallow[m] || !reach[m]) continue;
int tot = 0;
for (int i = 0; i < P; i++) {
if (!((m >> i) & 1)) {
tot += app[i];
reach[m ^ (1 << i)] = true;
}
}
ans = min(ans, tot);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 998244353;
ll binpow(ll a, ll b) {
ll res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
ll modInv(ll a) { return binpow(a, MOD - 2); }
const double PI = acos(-1);
const int INF = 0x3f3f3f3f;
const int NINF = 0xc0c0c0c0;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const ll NINFLL = 0xc0c0c0c0c0c0c0c0;
const int mxN = 100001;
int arr[mxN];
int badmask[mxN];
int board[17][17];
bool ok[1 << 17];
bool seen[1 << 17];
int cnt[17];
int val[1 << 17];
bool dp[1 << 17];
int n, p;
void upd(int mask, int a, int b) {
if (seen[mask]) return;
seen[mask] = true;
ok[mask] = false;
for (int i = (0); i < (p); ++i) {
if (i == a || i == b) continue;
if ((mask & (1 << i)) == 0) upd((mask | (1 << i)), a, b);
}
}
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
cin.tie(0)->sync_with_stdio(0);
cin >> n >> p;
string str;
cin >> str;
memset(ok, true, sizeof(ok));
for (int i = (0); i < (n); ++i) {
arr[i] = str[i] - 'a';
cnt[arr[i]]++;
}
for (int i = (0); i < (1 << p); ++i) {
for (int j = (0); j < (p); ++j) {
if (i & (1 << j)) val[i] += cnt[j];
}
}
for (int i = (0); i < (p); ++i) {
for (int j = (0); j < (p); ++j) {
cin >> board[i][j];
}
}
for (int i = (0); i < (p); ++i) {
for (int j = (0); j < (p); ++j) {
memset(seen, false, sizeof(seen));
if (board[i][j] == 0) {
int mask = 0;
int first = -1;
for (int nn = (0); nn < (n); ++nn) {
if (first > -1 && arr[nn] == j) {
upd(mask, i, j);
mask = 0;
first = -1;
} else if (first > -1) {
mask |= (1 << arr[nn]);
}
if (arr[nn] == i) {
first = nn;
mask = 0;
}
}
}
}
}
int best = 0;
dp[0] = true;
for (int msk = (1); msk < (1 << p); ++msk) {
if (!ok[msk]) continue;
for (int nxt = (0); nxt < (p); ++nxt) {
if (msk & (1 << nxt) && dp[msk ^ (1 << nxt)]) {
dp[msk] = true;
}
}
if (dp[msk]) {
best = max(best, val[msk]);
}
}
cout << (n - best) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool a[20][20];
string s;
bool dp[17][17][1 << 17];
bool dp2[1 << 17];
int cnt[17];
int occ[17];
int n, p;
void preprocess() {
memset(occ, -1, sizeof occ);
for (int i = (int)s.size() - 1; i >= 0; --i) {
vector<pair<int, int> > v;
for (int j = 0; j < p; ++j) {
if (occ[j] != -1) {
v.push_back(make_pair(occ[j], j));
}
}
sort(v.begin(), v.end());
int mask = 0;
for (int j = 0; j < (int)v.size(); ++j) {
int cur = s[i] - 'a';
int nx = v[j].second;
dp[cur][nx][mask] = 1;
mask |= (1 << nx);
}
occ[s[i] - 'a'] = i;
}
for (int i = 0; i < p; ++i) {
for (int j = 0; j < p; ++j) {
for (int mask = 0; mask < (1 << p) - 1; ++mask) {
if (!((mask >> i) & 1) and (!((mask >> j) & 1)) and dp[i][j][mask]) {
for (int k = 0; k < p; ++k) {
if (!((mask >> k) & 1)) {
dp[i][j][mask | (1 << k)] = 1;
}
}
}
}
}
}
}
void solve() {
cin >> n >> p;
cin >> s;
for (int i = 0; i < p; ++i) {
for (int j = 0; j < p; ++j) {
cin >> a[i][j];
}
}
for (int i = 0; i < (int)s.size(); ++i) {
cnt[s[i] - 'a']++;
}
preprocess();
dp2[0] = 1;
for (int i = 0; i < (1 << p) - 1; ++i) {
if (dp2[i]) {
for (int l = 0; l < p; ++l) {
if (!((i >> l) & 1)) {
int f = 1;
for (int j = 0; j < p; ++j) {
for (int k = 0; k < p; ++k) {
if (l != j and l != k and (!((i >> k) & 1)) and
(!((i >> j) & 1))) {
if (dp[j][k][i | (1 << l)] and !a[j][k]) {
f = 0;
}
}
}
}
dp2[i | (1 << l)] = f;
}
}
}
}
int ans = 1000000007;
for (int i = 0; i < (1 << p); ++i) {
if (dp2[i]) {
int cur = (int)s.size();
for (int j = 0; j < p; ++j) {
if ((i >> j) & 1) {
cur -= cnt[j];
}
}
ans = min(ans, cur);
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
using v2d = vector<vector<T> >;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const int maxN = 1e5 + 10;
const int maxK = 17;
const int inf = 1e9;
int n, k, a[maxK][maxK], cnt[maxK], last[maxK], f[20][maxN], g[1 << maxK],
dp[1 << maxK];
char s[maxN];
int query(int l, int r) {
int lg = 31 - __builtin_clz(r - l + 1);
return f[lg][l] | f[lg][r - (1 << lg) + 1];
}
void solve() {
cin >> n >> k >> (s + 1);
for (int i = 0; i < (int)(k); ++i) {
for (int j = 0; j < (int)(k); ++j) {
cin >> a[i][j];
}
}
for (int i = 1; i <= (int)(n); ++i) {
f[0][i] = 1 << (s[i] - 'a');
cnt[s[i] - 'a']++;
}
for (int lg = 1; lg <= (int)(19); ++lg) {
for (int i = 1; i <= (int)(n - (1 << lg) + 1); ++i) {
f[lg][i] = f[lg - 1][i] | f[lg - 1][i + (1 << (lg - 1))];
}
}
int t = (1 << k) - 1;
for (int i = n; i; i--) {
for (int j = 0; j < (int)(k); ++j) {
if (last[j] != 0 && !a[s[i] - 'a'][j]) {
int mask = query(i + 1, last[j] - 1);
int u = 1 << (s[i] - 'a'), v = 1 << (s[last[j]] - 'a');
g[t ^ mask]++;
g[t ^ (mask | u)]--;
g[t ^ (mask | v)]--;
g[t ^ (mask | u | v)]++;
}
}
last[s[i] - 'a'] = i;
}
for (int i = 0; i < (int)(k); ++i) {
for (int j = 0; j < (int)(1 << k); ++j) {
if (~j >> i & 1) {
g[j] += g[j | (1 << i)];
}
}
}
for (int mask = 0; mask < (int)(1 << k); ++mask) {
if (g[mask] != 0) {
dp[mask] = -inf;
} else {
for (int i = 0; i < (int)(k); ++i) {
if (mask >> i & 1) {
uax(dp[mask], dp[mask ^ (1 << i)] + cnt[i]);
}
}
}
}
cout << n - dp[t];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T = 1;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
std::string s;
int real_size;
int get_next_isnt(int p, char isnt) {
while (true) {
p++;
if (p >= real_size) return s.size() - 1;
if (s[p] != isnt) return p;
}
}
int get_prev_isnt(int p, char isnt) {
while (true) {
p--;
if (p < 0) return s.size() - 1;
if (s[p] != isnt) return p;
}
}
int main() {
int n, p;
bool m[18][18];
std::cin >> n >> p >> s;
real_size = s.size();
s += ('a' + 17);
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
int a;
std::cin >> a;
m[i][j] = (bool)a;
}
}
for (int i = 0; i < 18; i++) {
m[i][17] = true;
m[17][i] = true;
}
bool can_del;
while (true) {
int del_ch = -1;
for (int ch = 0; ch < p; ch++) {
can_del = true;
bool any = (s[0] == ch + 'a') || (s[real_size - 1] == ch + 'a');
int nxt;
for (int i = 1; i < real_size - 1; i++) {
if (s[i] == ch + 'a') {
any = true;
nxt = get_next_isnt(i, ch + 'a');
if (!m[s[get_prev_isnt(i, ch + 'a')] - 'a'][s[nxt] - 'a']) {
can_del = false;
break;
}
i = nxt - 1;
}
}
if (can_del && any) {
del_ch = ch;
break;
}
}
if (del_ch == -1) break;
int z = 0;
for (int i = 0; i < real_size; i++) {
s[i - z] = s[i];
z += s[i] == del_ch + 'a';
}
real_size -= z;
if (real_size == 0) break;
}
std::cout << real_size;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 17;
const int inf = 1 << 30;
long long read() {
long long a = 0;
char b = 1, c;
do
if ((c = getchar()) == 45) b = -1;
while (c < 48 || c > 57);
do a = (a << 3) + (a << 1) + (c & 15);
while ((c = getchar()) > 47 && c < 58);
return a * b;
}
void write(long long x, char c) {
if (x < 0) putchar(45), x = -x;
char a[20], s = 0;
do a[++s] = x % 10 | 48;
while (x /= 10);
do putchar(a[s]);
while (--s);
putchar(c);
}
int n, m, ans = inf;
bitset<N> b[N];
void solve(string a, bitset<N> c) {
ans = min(ans, (int)a.size());
for (int i = 0; i < m; ++i) {
if (!c[i]) continue;
string t;
bool op = 0;
for (char x : a) {
if (x == i) continue;
if (!t.empty() && !b[t.back()][x]) {
op = 1;
break;
}
t += x;
}
if (op) continue;
c[i] = 0;
solve(t, c);
return;
}
}
int main() {
n = read(), m = read();
string a;
cin >> a;
for (char &x : a) x -= 97;
for (int i = 0; i < m; ++i) {
for (int j = 0; j < m; ++j) {
b[i][j] = read();
}
}
solve(a, (1 << m) - 1);
write(ans, '\n');
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
const int M = 1000000007;
const double eps = 1e-9;
const double PI = acos(-1);
const int oo = 1000000000;
int n, p, nxt[N][17], can[17][17], pre[N][17], fr[17];
bool bad[1 << 17], vis[1 << 17][17][17], dp[1 << 17];
char s[N];
vector<int> oc[17];
void go(int msk, int a, int b) {
if (a > b) swap(a, b);
if (vis[msk][a][b]) return;
vis[msk][a][b] = bad[msk] = 1;
bad[msk] = 1;
for (int i = 0; i < p; ++i)
if (msk & 1 << i && i - a && i - b) go(msk ^ 1 << i, a, b);
}
int main() {
cin >> n >> p;
scanf("%s", s);
for (int i = 0; i < n; ++i) {
oc[s[i] - 'a'].push_back(i);
if (i)
for (int j = 0; j < p; ++j) pre[i][j] = pre[i - 1][j];
++pre[i][s[i] - 'a'];
++fr[s[i] - 'a'];
}
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j) scanf("%d", &can[i][j]);
memset(nxt, -1, sizeof(nxt));
for (int i = n - 2; i >= 0; --i) {
for (int j = 0; j < p; ++j) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i + 1] - 'a'] = i + 1;
}
for (int i = 0; i < p; ++i) {
for (int j = 0; j < p; ++j) {
if (can[i][j]) continue;
for (int k = 0; k < oc[i].size(); ++k) {
int d = oc[i][k];
if (nxt[d][j] == -1) break;
if (k < oc[i].size() - 1 && nxt[d][j] > oc[i][k + 1]) continue;
int msk = (1 << p) - 1;
if (nxt[d][j] > d + 1) {
for (int t = 0; t < p; ++t) {
int fr = pre[nxt[d][j] - 1][t];
fr -= pre[d][t];
if (fr) msk ^= 1 << t;
}
}
go(msk, i, j);
}
}
}
dp[(1 << p) - 1] = 1;
int ans = n;
for (int i = (1 << p) - 2; i >= 0; --i) {
if (bad[i]) continue;
for (int j = 0; j < p && !dp[i]; ++j)
if (!(i & 1 << j)) dp[i] |= dp[i ^ 1 << j];
if (!dp[i]) continue;
int cur = 0;
for (int j = 0; j < p; ++j)
if (i & 1 << j) cur += fr[j];
ans = min(ans, cur);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void minimize(int &a, int b) { a = min(a, b); }
const int limit = 100005;
int n, p;
int occurrences[limit][17];
int a[limit];
vector<int> positions[17];
int forbidden[1 << 17];
int curforbidden[1 << 17];
int getset(int i, int j) {
if (i > j) return 0;
int c = 0;
int(&vi)[17] = occurrences[i];
int(&vj)[17] = occurrences[j];
for (int b = 0; b < p; b++)
if (vj[b] > vi[b]) c |= 1 << b;
return (1 << p) - 1 - c;
}
void computeconj(vector<int> &p) {
for (int i = 0; i < int(p.size()) - 1; i++)
curforbidden[getset(p[i], p[i + 1] - 1)] = 1;
}
void computeconj(vector<int> &p0, vector<int> &p1) {
int i0 = 0;
int i1 = 0;
int n0 = int(p0.size());
int n1 = int(p1.size());
while (i0 < n0 and i1 < n1) {
if (p0[i0] < p1[i1] and i0 < n0 - 1 and p0[i0 + 1] < p1[i1])
i0++;
else if (p1[i1] < p0[i0] and i1 < n1 - 1 and p1[i1 + 1] < p0[i0])
i1++;
else if (p0[i0] < p1[i1]) {
curforbidden[getset(p0[i0], p1[i1] - 1)] = 1;
i0++;
} else {
curforbidden[getset(p1[i1], p0[i0] - 1)] = 1;
i1++;
}
}
}
void computeconj(int c0, int c1) {
for (int c = 0; c < 1 << p; c++) curforbidden[c] = 0;
if (c0 == c1)
computeconj(positions[c0]);
else
computeconj(positions[c0], positions[c1]);
int C0 = 1 << c0;
int C1 = 1 << c1;
for (int c = (1 << p) - 1; c >= 0; c--) {
if (not curforbidden[c] && (c & C0) && (c & C1)) {
for (int b = 0; b < p; b++) {
if (curforbidden[c | (1 << b)]) {
curforbidden[c] = 1;
break;
}
}
}
if (curforbidden[c]) forbidden[c] = 1;
}
}
void writeconj(int c) {
for (int b = 0; b < p; b++) cout << ((c & (1 << b)) != 0);
}
int constraint[17][17];
int reachable[1 << 17];
int sol;
int computelen(int c) {
int len = 0;
for (int b = 0; b < p; b++)
if (c & (1 << b)) len += int(positions[b].size());
return len;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> p;
string s;
cin >> s;
for (int i = 1; i <= n; i++) {
a[i] = s[i - 1] - 'a';
for (int b = 0; b < p; b++) occurrences[i][b] = occurrences[i - 1][b];
occurrences[i][a[i]]++;
positions[a[i]].push_back(i);
}
for (int c0 = 0; c0 < p; c0++)
for (int c1 = 0; c1 < p; c1++) cin >> constraint[c0][c1];
for (int c0 = 0; c0 < p; c0++)
for (int c1 = c0; c1 < p; c1++)
if (not constraint[c0][c1]) computeconj(c0, c1);
reachable[(1 << p) - 1] = 1;
sol = n;
for (int c = (1 << p) - 2; c >= 0; c--) {
if (not forbidden[c]) {
for (int b = 0; b < p; b++) {
if (reachable[c | (1 << b)]) {
reachable[c] = 1;
break;
}
}
if (reachable[c]) {
minimize(sol, computelen(c));
}
}
}
cout << sol << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxS = (1 << 17) + 10;
const int maxn = 1e5 + 10;
char s[maxn];
int ans = 1 << 30;
int n, m, vis[maxS], gg[maxS], tempg[maxS], da[maxn], cnt[maxS], c[20][20];
void dfs(int s) {
if (vis[s]) return;
vis[s] = 1;
for (int i = 0; i < m; ++i)
if (s & (1 << i)) {
dfs(s ^ (1 << i));
tempg[s] |= tempg[s ^ (1 << i)];
}
}
void Solve(int a, int b) {
memset(tempg, 0, sizeof(tempg));
for (int i = 1, j, s; i <= n;)
if (da[i] == a) {
for (j = i + 1, s = 0; j <= n; ++j) {
if (da[j] == a || da[j] == b) break;
s |= 1 << da[j];
}
if (j > n) break;
if (da[j] == b) {
i = j + 1;
tempg[s] = 1;
}
if (da[j] == a) i = j;
} else
++i;
memset(vis, 0, sizeof(vis));
if (a == b)
dfs(((1 << m) - 1) ^ (1 << a));
else
dfs(((1 << m) - 1) ^ (1 << a) ^ (1 << b));
for (int i = 0; i < (1 << m); ++i) gg[i] |= tempg[i];
}
void dfs2(int s) {
if (vis[s]) return;
vis[s] = 1;
ans = min(ans, cnt[((1 << m) - 1) ^ s]);
for (int i = 0; i < m; ++i)
if ((s & (1 << i)) == 0 && !gg[s | (1 << i)]) dfs2(s | (1 << i));
}
int main() {
scanf("%d%d", &n, &m);
scanf("%s", s);
for (int i = 0; i < m; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &c[i][j]);
for (int i = 0; i < n; ++i) {
da[i + 1] = s[i] - 'a';
++cnt[1 << da[i + 1]];
}
da[0] = da[n + 1] = -1;
for (int i = 0; i < (1 << m); ++i)
for (int j = 0; j < m; ++j)
if (i & (1 << j)) {
cnt[i] = cnt[i ^ (1 << j)] + cnt[1 << j];
break;
}
for (int i = 0; i < m; ++i)
for (int j = 0; j < m; ++j)
if (!c[i][j]) Solve(i, j);
memset(vis, 0, sizeof(vis));
dfs2(0);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 13;
const int P = 17;
int n, p;
string s;
int A[P][P];
vector<int> pos[P];
int pr[P][N];
bitset<(1 << P)> legal, cur, dp;
int cnt[P];
int main() {
scanf("%d%d", &n, &p);
char buf[N];
scanf("%s", buf);
s = buf;
for (int i = 0; i < int(p); i++)
for (int j = 0; j < int(p); j++) scanf("%d", &A[i][j]);
for (int i = 0; i < int(n); i++) {
pos[s[i] - 'a'].push_back(i);
for (int j = 0; j < int(p); j++)
pr[j][i + 1] = pr[j][i] + (s[i] == 'a' + j);
}
legal.reset();
legal.flip();
int fl = (1 << p) - 1;
for (int c = 0; c < int(p); c++)
for (int d = 0; d < int(c + 1); d++) {
if (A[c][d]) continue;
cur.reset();
cur.flip();
int i = 0, j = 0;
while (i < pos[c].size() && j < pos[d].size()) {
if (c == d && i == j) {
++j;
continue;
}
int mask = 0;
if (pos[c][i] < pos[d][j]) {
for (int e = 0; e < int(p); e++)
if ((pr[e][pos[d][j]] - pr[e][pos[c][i] + 1]) != 0)
mask |= (1 << e);
++i;
} else {
for (int e = 0; e < int(p); e++)
if ((pr[e][pos[c][i]] - pr[e][pos[d][j] + 1]) != 0)
mask |= (1 << e);
++j;
}
if ((mask >> c) & 1) continue;
if ((mask >> d) & 1) continue;
cur[mask ^ fl] = 0;
}
for (int mask = fl; mask > 0; --mask) {
if (cur[mask]) continue;
for (int e = 0; e < int(p); e++)
if (c != e && d != e && ((mask >> e) & 1)) cur[mask ^ (1 << e)] = 0;
}
legal &= cur;
}
dp[fl] = 1;
for (int mask = fl; mask > 0; --mask) {
if (!dp[mask]) continue;
for (int i = 0; i < int(p); i++)
if ((mask >> i) & 1) {
int nmask = mask ^ (1 << i);
if (dp[nmask]) continue;
dp[nmask] = legal[nmask];
}
}
for (int i = 0; i < int(n); i++) ++cnt[s[i] - 'a'];
int ans = n;
for (int mask = 0; mask < int(1 << p); mask++)
if (dp[mask]) {
int cur = 0;
for (int i = 0; i < int(p); i++)
if ((mask >> i) & 1) cur += cnt[i];
ans = min(ans, cur);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
long long x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 300010;
const int INF = 1e9;
int N, P;
char str[MAXN + 1];
int a[MAXN + 1], c[99];
int d[99][99];
bool f[MAXN + 1], g[MAXN + 1], h[MAXN + 1];
inline void solve(int x, int y) {
for (int i = 0; i < (1 << P); i++) f[i] = 0;
int last = 0;
bool vis = 0;
for (int i = N; i >= 1; i--) {
if (a[i] == x && vis) {
if (last & (1 << x)) continue;
f[last] = 1;
vis = 0;
}
last |= (1 << a[i]);
if (a[i] == y) last = 0, vis = 1;
}
for (int i = 0; i < P; i++)
for (int j = 0; j < (1 << P); j++)
if (j & (1 << i)) f[j] |= f[j ^ (1 << i)];
return;
}
int main() {
N = read(), P = read();
scanf("%s", str + 1);
for (int k = 0; k < (1 << P); k++) g[k] = 1;
for (int i = 1; i <= N; i++) a[i] = str[i] - 'a', c[a[i]]++;
for (int i = 0; i < P; i++)
for (int j = 0; j < P; j++) d[i][j] = read();
for (int i = 0; i < P; i++)
for (int j = 0; j < P; j++)
if (!d[i][j]) {
solve(i, j);
for (int k = 0; k < (1 << P); k++) {
if (!(k & (1 << i)) && !(k & (1 << j)) && f[k])
g[((1 << P) - 1) ^ k] = 0;
}
}
h[(1 << P) - 1] = 1;
int ans = N;
for (int i = (1 << P) - 1; i >= 0; i--) {
if (h[i]) {
for (int j = 0; j < P; j++)
if ((i & (1 << j)) && g[i ^ (1 << j)]) h[i ^ (1 << j)] = 1;
}
}
for (int i = 0; i < (1 << P); i++) {
if (!h[i]) continue;
int sum = 0;
for (int j = 0; j < P; j++)
if (i & (1 << j)) sum += c[j];
ans = min(ans, sum);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
long long n, p;
const long long N = 100100;
char s[N];
const long long P = 17;
long long a[P][P];
bool ruim[P][P][(1 << P) + 10];
vector<long long> pos[P];
long long pre[N][P];
void calc(long long c1, long long c2) {
long long A = c1, B = c2;
long long i = 0, j = 0;
while (i < (long long)pos[c1].size() and j < (long long)pos[c2].size()) {
if (i == j and c1 == c2) {
i++;
continue;
}
long long msk = 0;
if (pos[c1][i] >= pos[c2][j]) {
swap(c1, c2);
swap(i, j);
}
for (long long k = 0; k < (p); ++k) {
if ((pre[pos[c2][j] - 1][k] - pre[pos[c1][i]][k]) > 0) msk |= (1 << k);
}
i++;
if (msk & (1 << c1)) continue;
if (msk & (1 << c2)) continue;
ruim[A][B][msk ^ ((1 << p) - 1)] = 1;
}
c1 = A, c2 = B;
for (long long msk = (1 << p) - 1; msk > 0; msk--) {
if (!ruim[A][B][msk]) continue;
for (long long k = 0; k < (p); ++k)
if ((msk & (1 << k)) and k != c1 and k != c2) {
ruim[A][B][msk ^ (1 << k)] = 1;
}
}
}
long long cnt[N];
long long dp[(1 << P) + 10];
long long go(long long msk) {
if (dp[msk] != -1) return dp[msk];
if (__builtin_popcount(msk) == 1) {
return dp[msk] = 0;
}
long long res = 0;
for (long long j = 0; j < (p); ++j)
if (msk & (1 << j)) res += cnt[j];
for (long long j = 0; j < (p); ++j)
if (msk & (1 << j)) {
long long nmsk = (1 << j) ^ msk;
bool good = 1;
for (long long i = 0; i < (p); ++i) {
if (nmsk & (1 << i)) {
for (long long k = 0; k < (p); ++k) {
if (nmsk & (1 << k)) {
if (ruim[i][k][nmsk]) {
good = 0;
break;
}
}
}
}
}
if (good) {
res = min(res, go(nmsk));
}
}
return dp[msk] = res;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
memset(dp, -1, sizeof(dp));
cin >> n >> p;
for (long long i = 1; i <= n; i++) {
cin >> s[i], cnt[s[i] - 'a']++;
for (long long j = 0; j < (p); ++j) pre[i][j] = pre[i - 1][j];
pre[i][s[i] - 'a']++;
pos[s[i] - 'a'].push_back(i);
}
for (long long i = 0; i < p; i++) {
for (long long j = 0; j < p; j++) {
cin >> a[i][j];
if (a[i][j] == 1) {
} else {
calc(i, j);
}
}
}
long long full = 0;
for (long long j = 0; j < (p); ++j)
if (cnt[j]) full |= (1 << j);
cout << go(full) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 << 17;
int n, p;
int has[maxn];
string s;
int v[maxn];
int g[17][17][maxn];
int a[17][17];
int vs[17];
int que[maxn];
int co[17];
int qua[maxn];
int getbit(int u, int p) { return 1 & (u >> p); }
int main() {
cin >> n >> p;
cin >> s;
for (int i = (0); i < (n); i++) {
int cur = s[i] - 'a';
co[cur]++;
}
for (int mask = (0); mask < ((1 << p)); mask++) {
for (int j = (0); j < (p); j++) {
if (getbit(mask, j)) {
has[mask] += co[j];
}
}
}
for (int i = (0); i < (p); i++) {
for (int j = (0); j < (p); j++) cin >> a[i][j];
}
int mask = 0;
for (int i = (0); i < (p); i++) {
int isF = 1;
char c = i + 'a';
for (int j = (0); j < (n); j++) {
if (s[j] == c) {
if (!isF) {
g[i][i][mask] = 1;
}
for (int k = (0); k < (p); k++) vs[k] = 0;
mask = 0;
isF = 0;
} else {
int cur = s[j] - 'a';
if (!vs[cur]) {
vs[cur] = 1;
if (!isF) {
g[i][cur][mask] = 1;
}
mask |= (1 << cur);
}
}
}
}
for (int i = (0); i < (p); i++) {
for (int j = (0); j < (p); j++) {
int check = 0;
if (a[i][j] == 0) {
check = 1;
}
for (int mask = (0); mask < ((1 << p)); mask++) {
if (g[i][j][mask]) {
v[mask] |= check;
}
if (getbit(mask, i) || getbit(mask, j)) {
continue;
}
for (int k = (0); k < (p); k++) {
if (k == i || k == j) continue;
if (getbit(mask, k)) continue;
g[i][j][mask | (1 << k)] |= g[i][j][mask];
}
}
}
}
int qsize = 0;
que[qsize++] = 0;
int ans = n;
for (int i = (0); i < (qsize); i++) {
int now = que[i];
for (int j = (0); j < (p); j++) {
if (!getbit(now, j) && !v[now ^ (1 << j)] && !qua[now ^ (1 << j)]) {
qua[now ^ (1 << j)] = 1;
que[qsize++] = now ^ (1 << j);
ans = min(ans, n - has[now ^ (1 << j)]);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y <= x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x <= y ? x = y, 1 : 0;
}
const long double eps = 1e-9;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 60;
const int MAXN = 100005;
const int MAXM = 2000005;
const int MX = 5000;
const int mods = 998244353;
const int SZ = 131;
const int inv2 = (mods + 1) >> 1;
const int INF = 0x3f3f3f3f;
namespace FastIO {
constexpr int SIZE = (1 << 21) + 1;
int num = 0, f;
char ibuf[SIZE], obuf[SIZE], que[65], *iS, *iT, *oS = obuf,
*oT = obuf + SIZE - 1, c;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char c) {
*oS++ = c;
if (oS == oT) flush();
}
inline void getc(char &c) {
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
!isalpha(c) && c != EOF;
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
;
}
inline void reads(char *st) {
char c;
int n = 0;
getc(st[++n]);
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
isalpha(c);
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
st[++n] = c;
st[++n] = '\0';
}
template <class I>
inline void read(I &x) {
for (f = 1, c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
x = (x << 3) + (x << 1) + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (x < 0) putc('-'), x = -x;
if (!x) putc('0');
while (x) que[++num] = x % 10 + 48, x /= 10;
while (num) putc(que[num--]);
}
inline void putstr(string st) {
for (int i = 0; i < (int)st.size(); ++i) putc(st[i]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_Flusher_;
} // namespace FastIO
using FastIO ::print;
using FastIO ::putc;
using FastIO ::putstr;
using FastIO ::read;
using FastIO ::reads;
char st[MAXN];
int flag[1 << 17], cnt[17], s[1 << 17], f[1 << 17], g[1 << 17], id[17], wh[17],
n, m;
void addtag(int x, int y) {
int M = m - 1;
for (int i = 0; i < m; ++i) id[i] = i;
for (int i = y; i < m; ++i) id[i] = id[i + 1];
if (x != y) {
--M;
for (int i = x; i < m - 1; ++i) id[i] = id[i + 1];
}
for (int i = 0; i < M; ++i) wh[id[i]] = i;
for (int i = 0; i < 1 << M; ++i) g[i] = 0;
for (int i = 1, lst = 0, nw = 0; i <= n; ++i) {
if (st[i] - 'a' != x && st[i] - 'a' != y) {
nw |= 1 << wh[st[i] - 'a'];
continue;
}
if (lst && (st[lst] != st[i] || x == y)) g[nw] = 1;
lst = i, nw = 0;
}
for (int i = 0; i < M; ++i)
for (int j = 0; j < 1 << M; ++j)
if (!((j >> i) & 1)) g[j ^ (1 << i)] |= g[j];
for (int i = 0; i < 1 << M; ++i) {
if (!g[i]) continue;
int t = 0;
for (int j = 0; j < M; ++j)
if ((i >> j) & 1) t |= 1 << id[j];
flag[t] = 1;
}
}
int main() {
read(n), read(m), reads(st);
for (int i = 1; i <= n; ++i) ++cnt[st[i] - 'a'];
for (int i = 0; i < m; ++i)
for (int j = 0, X; j < m; ++j) {
read(X);
if (X == 1) continue;
if (i <= j) addtag(i, j);
}
f[0] = 1;
for (int i = 0; i < 1 << m; ++i) {
for (int j = 0; j < m; ++j)
if ((i >> j) & 1) {
s[i] = s[i ^ (1 << j)] + cnt[j];
}
if (flag[i]) {
f[i] = 0;
continue;
}
for (int j = 0; j < m; ++j)
if (!((i >> j) & 1)) f[i | (1 << j)] |= f[i];
}
int ans = 0;
for (int i = 0; i < 1 << m; ++i)
if (f[i]) upmax(ans, s[i]);
print(n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int lim = 1 << 17;
int m[20][20];
int dp[1 << 20];
int cnt[20];
int main() {
int n, p;
string s;
cin >> n >> p >> s;
for (auto x : s) cnt[x - 'a']++;
bitset<lim> bad;
auto f = [&](char a, char b) {
bitset<lim> current;
int mask = 0;
char last = '.';
for (int i = 0; i < n; ++i) {
if (s[i] == a) {
if (last == b) current[mask] = 1;
last = a;
mask = 0;
} else if (s[i] == b) {
if (last == a) current[mask] = 1;
mask = 0;
last = b;
} else {
int x = s[i] - 'a';
mask |= (1 << x);
}
}
for (int i = 0; i < (int)current.size(); ++i) {
if (!current[i]) continue;
for (int j = 0; j < p; ++j) {
if (a - 'a' == j or b - 'a' == j) continue;
current[i | (1 << j)] = 1;
}
}
bad |= current;
};
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j) {
int x;
cin >> x;
if (x) continue;
f(i + 'a', j + 'a');
}
for (int i = (1 << p) - 2; i >= 0; i--) {
dp[i] = 0;
for (int j = 0; j < p; ++j) {
if (!(i & (1 << j))) {
if (bad[i | (1 << j)]) continue;
dp[i] = max(dp[i], dp[i | (1 << j)] + cnt[j]);
}
}
}
cout << s.size() - dp[0] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, P = 17;
char s[N];
int dp[1 << P], can[P][P];
int c[P][P][1 << P];
int cnt[P];
int last[P];
int main() {
int n, p;
scanf("%d %d", &n, &p);
scanf("%s", s);
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j) scanf("%d", can[i] + j);
fill(dp, dp + (1 << p), 0);
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j)
for (int mask = 0; mask < (1 << p); ++mask) c[i][j][mask] = 1;
memset(last, -1, sizeof last);
for (int i = 0; i < n; ++i) {
s[i] -= 'a';
++cnt[s[i]];
for (int j = 0; j < p; ++j) {
if (can[s[i]][j] || last[j] == -1) continue;
int mask = (1 << p) - 1;
for (int k = 0; k < p; ++k) {
if (last[k] > last[j]) {
mask ^= 1 << k;
}
}
if ((mask | (1 << s[i]) | (1 << j)) == mask) c[s[i]][j][mask] = 0;
}
last[s[i]] = i;
}
for (int i = 0; i < p; ++i) {
for (int j = 0; j < p; ++j) {
for (int mask = (1 << p) - 1; mask > 0; --mask) {
if (c[i][j][mask]) continue;
for (int k = 0; k < p; ++k) {
if (k == i || k == j) continue;
if (mask & (1 << k)) c[i][j][mask ^ (1 << k)] = 0;
}
dp[mask] = N;
}
}
}
for (int i = 0; i < (1 << p); ++i) {
if (dp[i] >= N) continue;
dp[i] = 0;
for (int j = 0; j < p; ++j) {
if (i & (1 << j)) dp[i] += cnt[j];
}
for (int j = 0; j < p; ++j) {
if (i & (1 << j)) {
dp[i] = min(dp[i], dp[i ^ (1 << j)]);
}
}
}
printf("%d\n", dp[(1 << p) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ar[20][20], p, mn = 0x3f3f3f3f, n;
void solve(int x, string ss) {
for (int i = 0; i < p; ++i) {
if (x & (1 << i)) continue;
char c = 'a' + i, pre;
string s;
int t = (x | (1 << i));
for (char j : ss) {
if (j != c) {
s += j;
if (s.size() > 1 && ar[pre - 'a'][j - 'a'] == 0) goto bre;
pre = j;
}
}
mn = min(mn, (int)s.size());
solve(t, s);
break;
bre:;
}
}
int main() {
string s;
cin >> n >> p >> s;
mn = s.size();
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j) cin >> ar[i][j];
solve(0, s);
cout << mn << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 17;
int n, p, scnt[P];
string s;
bool A[P][P];
bool bad[1 << P][P][P], badCombined[1 << P], visited[1 << P];
void printMask(int v) {
for (int i = 0; i < (int)p; i++) cout << ((v >> i) & 1);
cout << endl;
}
void markBadDfs(int v, int l, int r) {
if (bad[v][l][r]) return;
bad[v][l][r] = true;
for (int i = 0; i < (int)p; i++)
if (i != l && i != r)
if (v & (1 << i)) {
markBadDfs(v ^ (1 << i), l, r);
}
}
int search(int v) {
if (visited[v] || badCombined[v]) return n;
visited[v] = true;
int best = 0;
for (int i = 0; i < (int)p; i++)
if (v & (1 << i)) {
best += scnt[i];
}
for (int i = 0; i < (int)p; i++)
if (v & (1 << i)) {
best = min(best, search(v ^ (1 << i)));
}
return best;
}
int main() {
cin >> n >> p >> s;
for (int i = 0; i < (int)p; i++)
for (int j = 0; j < (int)p; j++) cin >> A[i][j];
for (int i = 0; i < (int)p; i++)
for (int j = 0; j < (int)i + 1; j++)
if (!A[i][j]) {
vector<int> pos;
for (int k = 0; k < (int)n; k++)
if (s[k] - 'a' == i || s[k] - 'a' == j) {
pos.push_back(k);
}
for (int k = 0; k < (int)pos.size(); k++) {
if (!k) continue;
if (s[pos[k]] == s[pos[k - 1]] && i != j) continue;
int mask = (1 << p) - 1;
for (int z = pos[k - 1] + 1; z < pos[k]; z++)
mask &= ~(1 << (s[z] - 'a'));
markBadDfs(mask, i, j);
}
}
for (int i = 0; i < (int)1 << p; i++) {
for (int l = 0; l < (int)p; l++)
for (int r = 0; r < (int)p; r++) {
badCombined[i] |= bad[i][l][r];
}
}
int initMask = 0;
for (int i = 0; i < (int)n; i++) {
initMask |= 1 << (s[i] - 'a');
scnt[s[i] - 'a']++;
}
cout << search(initMask) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int _inf = 0xc0c0c0c0;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long _INF = 0xc0c0c0c0c0c0c0c0;
const long long mod = (int)1e9 + 7;
const int N = 1e5 + 100;
char s[N];
int a[20][20], cnt[20];
int tmp[1 << 18], gg[1 << 18];
int n, m, k;
void solve(int u, int v) {
memset(tmp, 0, sizeof(tmp));
for (int i = 1, j; i <= n;) {
while (i <= n && s[i] - 'a' != u) ++i;
int t = 0;
j = i + 1;
while (j <= n && s[j] - 'a' != u && s[j] - 'a' != v) {
t |= 1 << s[j] - 'a';
++j;
}
if (j > n) break;
if (s[j] - 'a' == v) {
i = j + 1;
tmp[t] = 1;
}
if (s[j] - 'a' == u) i = j;
}
for (int i = 0; i <= k; ++i) {
if (tmp[i]) {
gg[i] = 1;
for (int j = 0; j < m; ++j) {
if (j == u || j == v) continue;
tmp[i | (1 << j)] = 1;
}
}
}
return;
}
int vis[1 << 18];
int ans;
void DFS(int x, int len) {
if (vis[x]) return;
vis[x] = 1;
ans = min(ans, len);
for (int i = 0; i < m; ++i) {
if (gg[x | (1 << i)]) continue;
DFS(x | 1 << i, len - cnt[i]);
}
return;
}
void Ac() {
memset(gg, 0, sizeof(gg));
memset(cnt, 0, sizeof cnt);
scanf("%s", s + 1);
for (int i = 0; i < m; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &a[i][j]);
k = (1 << m) - 1;
for (int i = 0; i < m; ++i)
for (int j = 0; j < m; ++j)
if (a[i][j] == 0) solve(i, j);
for (int i = 1; i <= n; ++i) {
cnt[s[i] - 'a']++;
}
ans = n;
DFS(0, n);
printf("%d\n", ans);
return;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
Ac();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_P = 17, MAX_N = 1e5;
int N, P;
char rS[MAX_N + 1];
vector<int> S;
int A[MAX_P][MAX_P];
bool vst[1 << MAX_P], memo[1 << MAX_P], dp[1 << MAX_P];
int cnt[MAX_P];
int main() {
scanf("%d %d", &N, &P);
{
scanf("%s", rS);
for (int i = (0); i < (N); i++) {
S.push_back(rS[i] - 'a');
cnt[S[i]]++;
}
}
for (int i = (0); i < (P); i++) {
for (int j = (0); j < (P); j++) {
cin >> A[i][j];
}
}
memset(vst, true, sizeof(vst));
for (int a = (0); a < (P); a++) {
for (int b = (0); b < (P); b++) {
if (A[a][b] == 0) {
memset(memo, false, sizeof(memo));
for (int i = 0; i < N;) {
int m = 0;
while (i < N && S[i] != a) i++;
if (i == N) break;
i++;
while (i < N && S[i] != a && S[i] != b) {
m |= 1 << S[i];
i++;
}
if (i == N) break;
if (S[i] == b) {
int m2 = 0;
for (int j = (0); j < (P); j++) {
if (((m >> j) & 1) == 0) {
m2 += 1 << j;
}
}
m2 |= 1 << a;
m2 |= 1 << b;
memo[m2] = true;
}
}
for (int bit = (1 << P) - 1; bit >= 0; bit--) {
if (memo[bit]) {
vst[bit] = false;
for (int p = (0); p < (P); p++) {
if (p != a && p != b && (bit >> p) & 1) {
memo[bit & (~(1 << p))] = true;
}
}
}
}
}
}
}
memset(dp, false, sizeof(dp));
dp[(1 << P) - 1] = true;
int ans = N;
for (int bit = (1 << P) - 1; bit >= 0; bit--) {
if (dp[bit]) {
int sm = 0;
for (int p = (0); p < (P); p++) {
if ((bit >> p) & 1) {
sm += cnt[p];
}
}
ans = min(ans, sm);
for (int p = (0); p < (P); p++) {
if ((bit >> p) & 1 && vst[bit & (~(1 << p))]) {
dp[bit & (~(1 << p))] = true;
}
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int maxp = 18;
int n, p, ans;
int lst[maxp], cnt[maxp], aft[maxp];
int a[maxp][maxp];
int dp[1 << maxp], del[1 << maxp], sum[1 << maxp];
char s[maxn], buf[maxp][maxp];
int main() {
scanf("%d%d", &n, &p);
scanf("%s", s);
for (int i = (0); i < (p); ++i)
for (int j = (0); j < (p); ++j) scanf("%d", &a[i][j]);
memset(lst, -1, sizeof(lst));
for (int i = (0); i < (n); ++i) {
char c = s[i] - 'a';
for (int j = (0); j < (p); ++j)
if (!a[c][j] && ~lst[j]) {
if (aft[j] >> c & 1) continue;
--del[aft[j]];
--del[aft[j] ^ (1 << c) ^ (1 << j)];
++del[aft[j] ^ (1 << c)];
++del[aft[j] ^ (1 << j)];
}
for (int j = (0); j < (p); ++j) aft[j] |= 1 << c;
lst[c] = i;
aft[c] = 0;
}
for (int msk = (0); msk < (1 << p); ++msk)
for (int sub = msk; sub; (sub -= 1) &= msk) sum[msk] += del[sub];
for (int i = (0); i < (n); ++i) ++cnt[s[i] - 'a'];
dp[0] = true;
for (int msk = (1); msk < (1 << p); ++msk)
if (sum[msk] >= 0)
for (int j = (0); j < (p); ++j)
if ((msk >> j & 1) && dp[msk ^ (1 << j)]) dp[msk] = true;
for (int msk = (0); msk < (1 << p); ++msk)
if (dp[msk]) {
int res = 0;
for (int j = (0); j < (p); ++j)
if (msk >> j & 1) res += cnt[j];
ans = max(ans, res);
}
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 5;
const long long maxm = 1e3 + 5;
namespace IO {
const int SIZE = (1 << 20) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = obuf + SIZE - 1;
char _st[55];
int _qr = 0;
inline char gc() {
return (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++) : *iS++);
}
inline void qread() {}
template <class T1, class... T2>
inline void qread(T1 &IEE, T2 &...ls) {
register T1 __ = 0, ___ = 1;
register char ch;
while (!isdigit(ch = gc())) ___ = (ch == '-') ? -___ : ___;
do {
__ = (__ << 1) + (__ << 3) + (ch ^ 48);
} while (isdigit(ch = gc()));
__ *= ___;
IEE = __;
qread(ls...);
return;
}
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
return;
}
inline void putc_(char _x) {
*oS++ = _x;
if (oS == oT) flush();
}
inline void qwrite() {}
template <class T1, class... T2>
inline void qwrite(T1 IEE, T2... ls) {
if (!IEE) putc_('0');
if (IEE < 0) putc_('-'), IEE = -IEE;
while (IEE) _st[++_qr] = IEE % 10 + '0', IEE /= 10;
while (_qr) putc_(_st[_qr--]);
qwrite(ls...);
return;
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher;
} // namespace IO
using namespace IO;
long long n, p;
char s[maxn];
long long cnt[maxn][21];
bool sta[17][17][1 << 17];
long long las[maxn];
bool f[maxn];
long long g[21][21];
long long mlg[maxn];
inline long long low(long long x) { return x & (-x); }
int main() {
scanf("%lld %lld", &n, &p);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < p; j++) {
if (las[j] == 0) continue;
long long fl = 0;
for (int k = 0; k < p; k++) {
if (cnt[i - 1][k] - cnt[las[j]][k] == 0) continue;
fl |= (1 << k);
}
sta[s[i] - 'a'][j][fl] = 1;
}
for (int j = 0; j < p; j++) {
cnt[i][j] = cnt[i - 1][j] + (s[i] - 'a' == j);
}
las[s[i] - 'a'] = i;
}
for (int i = 0; i < p; i++) mlg[1 << i] = i;
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
for (int k = 0; k < (1 << p); k++) {
for (int t = k; t; t -= low(t)) {
sta[i][j][k] |= sta[i][j][k ^ low(t)];
}
}
}
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
scanf("%lld", &g[i][j]);
}
}
long long ans = n, sum = 0;
f[0] = 1;
for (int i = 0; i < (1 << p); i++) {
if (i == 0) continue;
f[i] = 1;
for (int j = 0; j < p; j++) {
if ((i >> j) & 1) continue;
for (int k = 0; k < p; k++) {
if ((i >> k) & 1) continue;
if (g[j][k] == 1) continue;
if (sta[j][k][i]) {
f[i] = 0;
break;
}
}
}
bool flag = 0;
for (int j = 0; j < p; j++) {
if ((i >> j) & 1) {
flag |= f[i ^ (1 << j)];
}
}
f[i] &= flag;
sum = 0;
for (int j = 0; j < p; j++) {
if (((i >> j) & 1) == 0) sum += cnt[n][j];
}
if (f[i]) ans = min(ans, sum);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 100000;
const int MAXALPH = 17;
int n, nalph;
char s[MAXN + 1];
int allowed[MAXALPH][MAXALPH];
int nxt[26];
int adjmask[1 << MAXALPH][MAXALPH];
bool valid[1 << MAXALPH];
bool can[1 << MAXALPH];
int q[1 << MAXALPH], qhead, qtail;
int cnt[MAXALPH];
pair<int, int> o[MAXALPH];
int no;
int solve() {
for (int i = (0); i < (nalph); ++i) nxt[i] = -1;
for (int mask = (0); mask < (1 << nalph); ++mask)
for (int j = (0); j < (nalph); ++j) adjmask[mask][j] = 0;
for (int i = n - 1; i >= 0; --i) {
no = 0;
for (int j = (0); j < (nalph); ++j)
if (nxt[j] != -1) o[no++] = make_pair(nxt[j], j);
sort(o, o + no);
int mask = 0, x = s[i] - 'a';
for (int j = (0); j < (no); ++j) {
int y = o[j].second;
if (!allowed[x][y]) adjmask[mask][x] |= 1 << y;
if (y == x) break;
mask |= 1 << y;
}
nxt[x] = i;
}
for (int mask = (0); mask < (1 << nalph); ++mask)
for (int x = (0); x < (nalph); ++x)
for (int z = (0); z < (nalph); ++z)
if (z != x) adjmask[mask | (1 << z)][x] |= adjmask[mask][x] & ~(1 << z);
for (int mask = (0); mask < (1 << nalph); ++mask) {
valid[mask] = true;
for (int x = (0); x < (nalph); ++x)
for (int y = (0); y < (nalph); ++y)
if (!allowed[x][y] && (adjmask[mask][x] & (1 << y)) != 0)
valid[mask] = false;
}
for (int mask = (0); mask < (1 << nalph); ++mask) can[mask] = false;
qhead = qtail = 0;
assert(valid[0]);
can[0] = true, q[qhead++] = 0;
while (qtail < qhead) {
int mask = q[qtail++];
for (int z = (0); z < (nalph); ++z)
if (valid[mask | (1 << z)] && !can[mask | (1 << z)])
can[mask | (1 << z)] = true, q[qhead++] = mask | (1 << z);
}
for (int i = (0); i < (nalph); ++i) cnt[i] = 0;
for (int i = (0); i < (n); ++i) ++cnt[s[i] - 'a'];
int ret = INT_MAX;
for (int mask = (0); mask < (1 << nalph); ++mask)
if (can[mask]) {
int cur = 0;
for (int x = (0); x < (nalph); ++x)
if ((mask & (1 << x)) == 0) cur += cnt[x];
ret = min(ret, cur);
}
return ret;
}
void run() {
scanf("%d%d", &n, &nalph);
scanf("%s", s);
for (int i = (0); i < (nalph); ++i)
for (int j = (0); j < (nalph); ++j) scanf("%d", &allowed[i][j]);
printf("%d\n", solve());
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005, MAXM = 140000;
int mp[20][20], ban[MAXM], f[MAXM], sum[20], cnt[20], n, m;
char str[MAXN];
vector<int> pre[MAXN], suf[MAXN];
void fwt(int *a, int n) {
for (int h = 2; h <= n; h <<= 1) {
int hh = h >> 1;
for (int i = 0; i < n; i += h)
for (int j = i; j < i + hh; j++) a[j + hh] += a[j];
}
}
int main() {
scanf("%d%d%s", &n, &m, str + 1);
for (int i = 1; i <= n; i++) ++cnt[str[i] -= 'a'];
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) scanf("%d", &mp[i][j]);
memset(sum, -1, sizeof(sum));
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++)
if (~sum[j] && !mp[str[i]][j] && !(sum[j] >> str[i] & 1)) {
--ban[sum[j] | 1 << str[i]], --ban[sum[j] | 1 << j];
++ban[sum[j]], ++ban[sum[j] | 1 << str[i] | 1 << j];
}
sum[str[i]] = 0;
for (int j = 0; j < m; j++)
if (j != str[i]) sum[j] |= 1 << str[i];
}
memset(sum, -1, sizeof(sum));
for (int i = n; i > 0; i--) {
for (int j = 0; j < m; j++)
if (~sum[j] && !mp[str[i]][j] && !(sum[j] >> str[i] & 1)) {
--ban[sum[j] | 1 << str[i]], --ban[sum[j] | 1 << j];
++ban[sum[j]], ++ban[sum[j] | 1 << str[i] | 1 << j];
}
sum[str[i]] = 0;
for (int j = 0; j < m; j++)
if (j != str[i]) sum[j] |= 1 << str[i];
}
fwt(ban, 1 << m);
f[0] = 1;
int res = n;
for (int i = 0; i < 1 << m; i++)
if (f[i] && !ban[i]) {
for (int j = 0; j < m; j++)
if (~i >> j & 1) f[i | 1 << j] = 1;
int now = n;
for (int j = 0; j < m; j++)
if (i >> j & 1) now -= cnt[j];
res = min(res, now);
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <class T>
ostream& prnt(ostream& out, T v) {
out << v.size() << '\n';
for (auto e : v) out << e << ' ';
return out;
}
template <class T>
ostream& operator<<(ostream& out, vector<T> v) {
return prnt(out, v);
}
template <class T>
ostream& operator<<(ostream& out, set<T> v) {
return prnt(out, v);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, map<T1, T2> v) {
return prnt(out, v);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
return out << '(' << p.first << ' ' << p.second << ')';
}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << H;
debug_out(T...);
}
const long double PI = acos(-1);
int n, p, m[22][22], lst[100005][22], fr[22];
string s;
int uz[1 << 18], dp[1 << 18];
set<pair<int, int> > nogud;
int calc(int msk) {
int ans = 0;
for (int i = 0; i < p; i++) {
if (msk & (1 << i)) {
ans += fr[i];
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> p;
cin >> s;
for (auto& it : s) {
it -= 'a';
fr[it]++;
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
cin >> m[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < p; j++) lst[i][j] = lst[i - 1][j];
lst[i][s[i - 1]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < p; j++) {
if (lst[i - 1][j] == 0) continue;
if (lst[i - 1][j] < lst[i - 1][s[i - 1]]) continue;
if (m[s[i - 1]][j]) continue;
int msk1 = 0, msk2 = 0;
msk1 |= (1 << s[i - 1]);
msk2 |= (1 << s[i - 1]);
msk1 |= (1 << j);
msk2 |= (1 << j);
for (int k = 0; k < p; k++) {
if (lst[i - 1][k] > lst[i - 1][j]) {
msk1 |= (1 << k);
}
}
nogud.insert({msk1, msk2});
}
}
int mx = 1 << p;
for (auto [msk1, msk2] : nogud) {
int msk3 = (msk1 ^ msk2) ^ (mx - 1);
for (int i = (mx - 1) & msk3; i >= msk2; i = (i - 1) & msk3) {
uz[i | msk2] = 1;
}
}
dp[mx - 1] = 1;
int ans = n;
for (int i = mx - 2; i >= 0; i--) {
if (uz[i]) continue;
for (int k = 0; k < p; k++) {
if (!(i & (1 << k))) {
dp[i] |= dp[i ^ (1 << k)];
}
}
if (dp[i]) ans = min(ans, calc(i));
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const double PI = acos(-1);
template <class T, class S>
inline void add(T& a, S b) {
a += b;
if (a >= mod) a -= mod;
}
template <class T, class S>
inline void sub(T& a, S b) {
a -= b;
if (a < 0) a += mod;
}
template <class T, class S>
inline bool chkmax(T& a, S b) {
return a < b ? a = b, true : false;
}
template <class T, class S>
inline bool chkmin(T& a, S b) {
return a > b ? a = b, true : false;
}
bitset<1 << 17> can[17][17];
char s[N];
int n, p, ans = inf, c[1 << 17];
vector<int> pos[17], vc;
vector<int> to[1 << 17];
bool G[17][17];
bool ok[1 << 17];
bool vis[1 << 17];
struct ST {
int Log[N], dp[N][20];
void build(char* s, int n) {
Log[1] = 0;
for (int i = 2; i <= n; i++) Log[i] = Log[i >> 1] + 1;
for (int i = 1; i <= n; i++) dp[i][0] = 1 << (s[i] - 'a');
for (int j = 1; j <= Log[n]; j++)
for (int i = 1; i <= n; i++)
dp[i][j] = dp[i][j - 1] | dp[i + (1 << (j - 1))][j - 1];
}
inline int query(int L, int R) {
if (L > R) return 0;
int k = Log[R - L + 1];
return dp[L][k] | dp[R - (1 << k) + 1][k];
}
} rmqOr;
int main() {
scanf("%d%d", &n, &p);
scanf("%s", s + 1);
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) scanf("%d", &G[i][j]);
for (int i = 0; i < (1 << p); i++) {
ok[i] = true;
for (int j = 0; j < p; j++) {
if (i >> j & 1) continue;
to[i].push_back(j);
}
}
rmqOr.build(s, n);
for (int i = 1; i <= n; i++) pos[s[i] - 'a'].push_back(i);
for (int i = 1; i < (1 << p); i++)
for (int j = 0; j < p; j++)
if (i >> j & 1) c[i] += ((int)pos[j].size());
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
if (G[i][j]) continue;
if (i == j) {
for (int k = 1; k < ((int)pos[i].size()); k++)
can[i][j][rmqOr.query(pos[i][k - 1] + 1, pos[i][k] - 1)] = true;
} else {
vc.resize(((int)pos[i].size()) + ((int)pos[j].size()));
merge((pos[i]).begin(), (pos[i]).end(), (pos[j]).begin(),
(pos[j]).end(), vc.begin());
for (int k = 1; k < ((int)vc.size()); k++) {
if (s[vc[k]] != s[vc[k - 1]]) {
can[i][j][rmqOr.query(vc[k - 1] + 1, vc[k] - 1)] = true;
}
}
}
for (int mask = 0; mask < (1 << p); mask++) {
if (!can[i][j][mask]) continue;
for (auto& k : to[mask]) can[i][j][mask | (1 << k)] = true;
}
}
}
for (int mask = 0; mask < (1 << p); mask++) {
int fmask = mask ^ ((1 << p) - 1);
for (int i = 0; i < p && ok[mask]; i++) {
if (mask >> i & 1) {
for (int j = i; j < p && ok[mask]; j++) {
if (mask >> j & 1) {
if (can[i][j][fmask]) ok[mask] = false;
}
}
}
}
}
vis[(1 << p) - 1] = true;
queue<int> que;
que.push((1 << p) - 1);
while (!que.empty()) {
int mask = que.front();
que.pop();
chkmin(ans, c[mask]);
for (int i = 0; i < p; i++) {
if (mask >> i & 1 && !vis[mask ^ (1 << i)] && ok[mask ^ (1 << i)]) {
vis[mask ^ (1 << i)] = true;
que.push(mask ^ (1 << i));
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, p;
cin >> n >> p;
string S;
cin >> S;
vector<int> s(n);
int a[p][p];
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
cin >> a[i][j];
}
}
vector<int> cnt(p);
for (int i = 0; i < n; i++) {
s[i] = S[i] - 'a';
cnt[s[i]]++;
}
vector<bool> valid(1 << p, 1);
for (int c1 = 0; c1 < p; c1++) {
for (int c2 = 0; c2 < p; c2++) {
if (a[c1][c2]) continue;
vector<bool> gud(1 << p, 1);
for (int i = 0; i < n; i++) {
if (s[i] != c1) continue;
int j = i + 1;
for (; j < n; j++) {
if (s[j] == c1 || s[j] == c2) break;
}
if (j == n) break;
if (c1 != c2 && s[i] == s[j]) continue;
int mask = (1 << p) - 1;
for (int k = i + 1; k < j; k++) {
if (mask & (1 << s[k])) {
mask ^= (1 << s[k]);
}
}
gud[mask] = 0;
}
for (int mask = (1 << p) - 1; mask >= 0; mask--) {
if (gud[mask]) continue;
for (int i = 0; i < p; i++) {
if (c1 == i) continue;
if (c2 == i) continue;
if (mask & (1 << i)) gud[mask ^ (1 << i)] = 0;
}
valid[mask] = 0;
}
}
}
int initial = 0;
for (int i = 0; i < p; i++) {
if (cnt[i]) initial |= (1 << i);
}
vector<int> dp(1 << p);
dp[initial] = 1;
for (int mask = initial; mask >= 0; mask--) {
if (!dp[mask]) continue;
for (int i = 0; i < p; i++) {
if (mask & (1 << i)) {
int nxt = mask ^ (1 << i);
if (valid[nxt]) dp[nxt] = 1;
}
}
}
int ans = 100000000;
for (int mask = 0; mask < (1 << p); mask++) {
if (dp[mask]) {
int tmp = 0;
for (int i = 0; i < p; i++) {
if (mask & (1 << i)) tmp += cnt[i];
}
ans = min(ans, tmp);
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long n, p;
cin >> n >> p;
string s;
cin >> s;
vector<vector<long long>> a((size_t)p, vector<long long>((size_t)p));
for (long long i = 0; i < p; i++) {
for (long long j = 0; j < p; j++) {
cin >> a[i][j];
}
}
vector<bool> b((size_t)1 << p, true);
vector<vector<vector<bool>>> h(
(size_t)p,
vector<vector<bool>>((size_t)p, vector<bool>((size_t)1 << p, false)));
vector<long long> c;
for (long long i = 0; i < n; i++) {
for (long long j = (long long)c.size() - 1, k = 0; j >= 0; j--) {
if (a[s[i] - 'a'][c[j]] == 0) {
b[k] = false;
if (!h[s[i] - 'a'][c[j]][k]) {
h[s[i] - 'a'][c[j]][k] = true;
long long r =
((k | (1 << (s[i] - 'a')) | (1 << c[j])) ^ ((1 << p) - 1));
for (long long l = r; l > 0; l = (l - 1) & r) {
b[k | l] = false;
}
}
}
if (c[j] == s[i] - 'a') {
break;
}
k |= 1 << c[j];
}
c.erase(remove(c.begin(), c.end(), s[i] - 'a'), c.end());
c.push_back(s[i] - 'a');
}
vector<long long> d((size_t)p);
for (long long i = 0; i < p; i++) {
d[i] = count(s.begin(), s.end(), 'a' + i);
}
vector<long long> e((size_t)1 << p);
iota(e.begin(), e.end(), (long long)0);
sort(e.begin(), e.end(), [](long long x, long long y) {
return __builtin_popcountll(x) < __builtin_popcountll(y);
});
vector<bool> f((size_t)1 << p);
f[0] = true;
long long m = (long long)1e14;
for (long long i : e) {
if (f[i]) {
long long t = n;
for (long long j = 0; j < p; j++) {
if ((i & (1 << j)) == 0) {
if (b[i | (1 << j)]) {
f[i | (1 << j)] = true;
}
} else {
t -= d[j];
}
}
m = min(m, t);
}
}
cout << m << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p, a[17][17], mask, freq[17], ans = 1000000007;
int cost[1 << 17], dp[1 << 17];
bool iscrisp[1 << 17];
bitset<1 << 17> isadj[17][17];
string s;
void process_iscrisp() {
for (int i = 0; i < p; i++) {
for (int j = i; j < p; j++) {
if (i == j) {
int cur = 0, f = 0;
for (int k = 0; k < n; k++) {
if (s[k] - 'a' == i) {
f++;
if (f > 1) isadj[i][j][(1 << p) - 1 - cur] = 1;
cur = 0;
} else
cur |= 1 << (s[k] - 'a');
}
} else {
int cur = 0, f1 = 0, f2 = 0;
for (int k = 0; k < n; k++) {
if (s[k] - 'a' == i) {
if (f2) isadj[i][j][(1 << p) - 1 - cur] = 1;
f1 = 1;
f2 = 0;
cur = 0;
} else if (s[k] - 'a' == j) {
if (f1) isadj[i][j][(1 << p) - 1 - cur] = 1;
f2 = 1;
f1 = 0;
cur = 0;
} else
cur |= 1 << (s[k] - 'a');
}
}
for (int k = (1 << p) - 1; k >= 0; k--) {
if ((k >> i) & 1 and (k >> j) & 1) {
for (int l = 0; l < p; l++) {
if (l == i or l == j or (k >> l) & 1)
;
else if (isadj[i][j][k ^ (1 << l)])
isadj[i][j][k] = 1;
}
}
}
}
}
for (int i = 0; i < 1 << p; i++) {
iscrisp[i] = 1;
vector<int> v;
for (int j = 0; j < p; j++) {
if ((i >> j) & 1) {
v.push_back(j);
}
}
for (auto first : v) {
for (auto second : v) {
if (isadj[first][second][i] and a[first][second] == 0) iscrisp[i] = 0;
}
}
}
}
void solve() {
cin >> n >> p >> s;
for (auto i : s) {
freq[i - 'a']++;
mask |= 1 << (i - 'a');
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
cin >> a[i][j];
}
}
process_iscrisp();
for (int i = 0; i < 1 << p; i++) {
for (int j = 0; j < p; j++) {
if ((i >> j) & 1) cost[i] += freq[j];
}
}
dp[mask] = 1;
for (int i = (1 << p) - 1; i >= 0; i--) {
if (iscrisp[i] == 0) continue;
for (int j = 0; j < p; j++) {
if ((i >> j) & 1)
;
else
dp[i] |= dp[i ^ (1 << j)];
}
if (dp[i]) ans = min(ans, cost[i]);
}
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class T2>
inline int chkmax(T &x, const T2 &y) {
return x < y ? x = y, 1 : 0;
}
template <class T, class T2>
inline int chkmin(T &x, const T2 &y) {
return x > y ? x = y, 1 : 0;
}
const int MAXN = (1 << 17);
const int MAXP = 17;
int n, p;
string s;
int a[MAXN];
int A[MAXP][MAXP];
void read() {
cin >> n >> p;
cin >> s;
for (int i = 0; i < n; i++) a[i] = s[i] - 'a';
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) cin >> A[i][j];
}
int answer;
int cnt_let[MAXP];
bool bad_mask[MAXP][MAXP][MAXN];
bool used[MAXN];
void dfs(int mask) {
if (used[mask]) return;
used[mask] = true;
int c_len = n;
for (int i = 0; i < p; i++)
if (!(mask & (1 << i))) {
bool ok = 1;
int nmask = (1 << i) ^ mask;
for (int k = 0; k < p; k++)
if (!(nmask & (1 << k)))
for (int j = k; j < p; j++)
if (!(nmask & (1 << j))) ok &= (0 == bad_mask[k][j][nmask]);
if (ok) dfs(nmask);
} else
c_len -= cnt_let[i];
chkmin(answer, c_len);
}
int CNT[MAXN][MAXP];
int C(int c, int l, int r) {
if (l == 0) return CNT[r][c];
return CNT[r][c] - CNT[l - 1][c];
}
void solve() {
answer = n;
int ini_mask = 0;
for (int i = 0; i < n; i++) {
cnt_let[a[i]]++;
ini_mask |= (1 << a[i]);
if (i)
for (int j = 0; j < p; j++) CNT[i][j] = CNT[i - 1][j];
CNT[i][a[i]]++;
}
for (int x = 0; x < p; x++)
for (int y = 0; y < p; y++)
if (A[x][y] == 0 && (ini_mask & (1 << x)) && (ini_mask & (1 << y))) {
int last_y = -1;
for (int i = 0; i < n; i++) {
if (a[i] == x && last_y != -1) {
int mask = 0;
for (int c = 0; c < p; c++)
if (ini_mask & (1 << c))
mask |= (C(c, last_y + 1, i - 1) != 0) << c;
bad_mask[x][y][mask] = 1;
bad_mask[y][x][mask] = 1;
}
if (a[i] == y) last_y = i;
}
}
for (int let = 0; let < p; let++)
for (int let2 = let; let2 < p; let2++)
for (int mask = 0; mask < (1 << p); mask++) {
for (int i = 0; i < p; i++)
if (mask & (1 << i))
bad_mask[let][let2][mask] |= bad_mask[let][let2][mask ^ (1 << i)];
}
dfs(0);
cout << answer << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int inf = 1000 * 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
int n, m;
string s;
bool used[18][18];
int sz[18];
int ind[18];
int r[N][18];
bool dp[(1 << 17) + 5];
bool check[17][17][(1 << 17) + 2];
bool mark[(1 << 17) + 5];
int main() {
cin >> n >> m;
cin >> s;
for (int i = 0; i < n; i++) {
sz[s[i] - 'a']++;
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
cin >> used[i][j];
}
}
for (int i = 0; i < m; i++) {
ind[i] = n;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < m; j++) {
r[i][j] = ind[j];
}
ind[s[i] - 'a'] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int id = r[i][j];
if (id == n || used[s[i] - 'a'][j] || r[i][s[i] - 'a'] < id) continue;
int mask = 0;
for (int h = 0; h < m; h++) {
if (r[i][h] < id) {
mask |= (1 << h);
}
}
check[s[i] - 'a'][j][mask] = true;
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
for (int h = 0; h < (1 << m); h++) {
if (check[i][j][h]) {
mark[h] = true;
for (int t = 0; t < m; t++) {
if (t != i && t != j) {
check[i][j][h | (1 << t)] = true;
}
}
}
}
}
}
dp[0] = true;
int mx = 0;
for (int i = 0; i < (1 << m); i++) {
if (dp[i] == false) continue;
int sum = 0;
for (int j = 0; j < m; j++) {
if ((i >> j) & 1) sum += sz[j];
}
mx = max(mx, sum);
for (int j = 0; j < m; j++) {
if (((i >> j) & 1) == 0) {
int mask = i + (1 << j);
if (mark[mask] == false) {
dp[mask] = true;
}
}
}
}
cout << n - mx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char getc() {
char c = getchar();
while ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && (c < '0' || c > '9'))
c = getchar();
return c;
}
int gcd(int n, int m) { return m == 0 ? n : gcd(m, n % m); }
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
int n, m, c[100010], b[100010], cnt[17], ans;
char s[100010];
bool a[17][17], f[1 << 17], g[1 << 17];
signed main() {
n = read(), m = read();
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) cnt[c[i] = s[i] - 'a']++;
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) {
a[i][j] = read();
if (i <= j && !a[i][j]) {
memset(g, 0, sizeof(g));
int last = -1, s = 0;
for (int x = 1; x <= n; x++) {
if (c[x] == i || c[x] == j) {
if (last == i + j - c[x]) g[s] = 1;
last = c[x];
s = 0;
} else
s |= (1 << c[x]);
}
for (int x = 1; x < (1 << m); x++)
if (!g[x] && !(x & (1 << i)) && !(x & (1 << j))) {
for (int t = x, y = t & -t; t; t ^= y, y = t & -t) g[x] |= g[x ^ y];
}
for (int x = 0; x < (1 << m); x++) f[x] |= g[x];
}
}
ans = n;
for (int i = 1; i < (1 << m); i++) {
if (!f[i]) {
f[i] = 1;
for (int j = 0; j < m; j++)
if ((i & (1 << j)) && !f[i ^ (1 << j)]) {
f[i] = 0;
break;
}
}
if (!f[i]) {
int tot = n;
for (int j = 0; j < m; j++)
if (i & (1 << j)) tot -= cnt[j];
ans = min(ans, tot);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p, mp[20][20], pre[20], cnt[100005][20];
int ban[1 << 17], usd[1 << 17][20][20], can[1 << 17], sum[1 << 17];
char s[100005];
int main() {
scanf("%d%d", &n, &p);
scanf("%s", s);
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) scanf("%d", &mp[i][j]);
memset(pre, -1, sizeof pre);
for (int i = 0; i < n; i++) {
for (int j = 0; j < p; j++)
cnt[i][j] = (s[i] - 'a' == j) + (i ? cnt[i - 1][j] : 0);
for (int j = 0; j < p; j++)
if (!mp[s[i] - 'a'][j] && pre[j] >= 0 && pre[s[i] - 'a'] <= pre[j]) {
int sta = 0;
for (int k = 0; k < p; k++)
if (cnt[i - 1][k] - cnt[pre[j]][k]) sta |= (1 << k);
usd[sta][s[i] - 'a'][j] |= 1;
}
pre[s[i] - 'a'] = i;
}
for (int sta = 0; sta < (1 << p); sta++)
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++)
if (usd[sta][i][j]) {
int rsta = (1 << p) - 1 - sta - (1 << i) - (i != j ? (1 << j) : 0);
for (int S = rsta;; S = (S - 1) & (rsta)) {
ban[sta | S] = 1;
if (!S) break;
}
}
int ans = n;
can[0] = 1;
for (int sta = 0; sta < (1 << p); sta++) {
if (can[sta] && !ban[sta]) {
ans = min(ans, n - sum[sta]);
for (int i = 0; i < p; i++)
if (((1 << i) & sta) == 0)
can[sta | (1 << i)] = 1,
sum[sta | (1 << i)] = sum[sta] + cnt[n - 1][i];
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n, p;
string s;
cin >> n >> p >> s;
vector<vector<int>> A(p, vector<int>(p));
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
cin >> A[i][j];
}
}
vector<vector<int>> cnt(n + 1, vector<int>(p));
for (int i = 0; i < n; i++) {
cnt[i + 1] = cnt[i];
++cnt[i + 1][s[i] - 'a'];
}
vector<int> f(1 << p);
vector<int> nex(p, n);
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < p; j++)
if (nex[j] < n && A[s[i] - 'a'][j] == 0) {
int mask = (1 << p) - 1;
for (int k = 0; k < p; k++)
if (cnt[nex[j]][k] - cnt[i + 1][k] > 0) {
mask -= 1 << k;
}
if ((mask & (1 << (s[i] - 'a'))) == 0) continue;
f[mask] += 1;
f[mask - (1 << j)] -= 1;
f[mask - (1 << (s[i] - 'a'))] -= 1;
f[mask - ((1 << (s[i] - 'a')) | (1 << j))] += 1;
}
nex[s[i] - 'a'] = i;
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < (1 << p); j++)
if (j & (1 << i)) {
f[j - (1 << i)] += f[j];
}
}
int res = n;
vector<int> dp(1 << p);
dp.back() = 1;
for (int S = (1 << p) - 1; S >= 0; S--)
if (dp[S]) {
int len = 0;
for (int i = 0; i < p; i++)
if (S & (1 << i)) {
len += cnt[n][i] - cnt[0][i];
}
res = min(res, len);
for (int i = 0; i < p; i++)
if (S & (1 << i)) {
if (f[S - (1 << i)] == 0) dp[S - (1 << i)] = 1;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
using pr = pair<T1, T2>;
template <typename T>
using vec = vector<T>;
int n, p;
vec<char> s;
vec<char> red_s;
bool g[22][22];
int triger_pair[(1 << 18)][18];
bool good_mask[(1 << 18)];
bool can_reach[(1 << 18)];
int q[32];
int main() {
cin >> n >> p;
s = vec<char>(n, 'a');
for (int(i) = (0); (i) < (n); ++(i)) {
scanf(" %c", &s[i]);
++q[s[i] - 'a'];
if (i == 0 || s[i] != s[i - 1]) red_s.push_back(s[i]);
}
int red_n = ((int)red_s.size());
for (int(i) = (0); (i) < (p); ++(i)) {
for (int(j) = (0); (j) < (p); ++(j)) {
cin >> g[i][j];
if (i <= j && !g[i][j]) {
int cur_mask = 0;
int prev_ind = -1;
for (int(k) = (0); (k) < (red_n); ++(k)) {
if (red_s[k] == i + 'a') {
if (prev_ind == j) {
triger_pair[cur_mask][i] |= (1 << j);
}
cur_mask = 0;
prev_ind = i;
} else if (red_s[k] == j + 'a') {
if (prev_ind == i) {
triger_pair[cur_mask][i] |= (1 << j);
}
cur_mask = 0;
prev_ind = j;
} else
cur_mask |= (1 << (red_s[k] - 'a'));
}
}
}
}
for (int(mask) = (0); (mask) < ((1 << p)); ++(mask)) {
for (int(i) = (0); (i) < (p); ++(i)) {
if ((mask >> i) & 1) {
int red_mask = mask ^ (1 << i);
for (int(j) = (0); (j) < (p); ++(j)) {
triger_pair[mask][j] |= triger_pair[red_mask][j];
}
}
}
bool z = true;
for (int(fr) = (0); (fr) < (p); ++(fr)) {
for (int(sc) = (fr); (sc) <= (p - 1); ++(sc)) {
if ((triger_pair[mask][fr] >> sc) & 1) {
int bit1 = (mask >> fr) & 1;
int bit2 = (mask >> sc) & 1;
if (!bit1 && !bit2) {
z = false;
break;
}
}
}
if (!z) break;
}
good_mask[mask] = z;
}
int mx = 0;
can_reach[0] = true;
for (int(mask) = (1); (mask) <= ((1 << p) - 1); ++(mask)) {
if (!good_mask[mask]) continue;
int sum = 0;
for (int(i) = (0); (i) < (p); ++(i)) {
if ((mask >> i) & 1) {
int red_mask = mask ^ (1 << i);
if (can_reach[red_mask]) can_reach[mask] = true;
sum += q[i];
}
}
if (can_reach[mask]) mx = max(mx, sum);
}
int res = n - mx;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int P = 18;
int n, p;
char second[N];
int cnt[P];
int a[P][P];
int bad[1 << P];
int tmp[1 << P];
int dp[1 << P];
int main() {
scanf("%d%d", &n, &p);
scanf("%s", second);
for (int i = 0; i < n; i++) {
second[i] -= 'a';
cnt[second[i]]++;
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
if (a[i][j]) continue;
int ptr = 0;
while (ptr < n && second[ptr] != i && second[ptr] != j) ptr++;
while (ptr < n) {
int l = ptr;
ptr++;
int mask = 0;
while (ptr < n && second[ptr] != i && second[ptr] != j)
mask |= (1 << second[ptr++]);
if (ptr != n && ((second[l] == i && second[ptr] == j) ||
(second[l] == j && second[ptr] == i))) {
tmp[mask] = 1;
}
}
for (int k = 0; k < 1 << p; k++) {
if (k >> i & 1) continue;
if (k >> j & 1) continue;
for (int l = 0; l < p; l++) {
if (l == i || l == j) continue;
tmp[k | (1 << l)] |= tmp[k];
}
}
for (int k = 0; k < 1 << p; k++) {
bad[k] |= tmp[k];
tmp[k] = 0;
}
}
}
dp[0] = 1;
for (int mask = 0; mask < 1 << p; mask++) {
if (dp[mask] == 0) continue;
for (int j = 0; j < p; j++) {
if (mask >> j & 1) continue;
if (bad[mask | (1 << j)]) continue;
dp[mask | (1 << j)] = 1;
}
}
int ans = 0;
for (int mask = 0; mask < 1 << p; mask++) {
if (dp[mask] == 0) continue;
int x = 0;
for (int j = 0; j < p; j++)
if (mask >> j & 1) x += cnt[j];
if (ans < x) ans = x;
}
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int w[17][17];
char s[100002];
int num[17];
int seg[100002 * 4];
void init(int pos, int l, int r) {
if (l == r) {
seg[pos] |= (1 << (s[l] - 'a'));
return;
}
int mid = (l + r) / 2;
init(pos * 2, l, mid);
init(pos * 2 + 1, mid + 1, r);
seg[pos] = seg[pos * 2] | seg[pos * 2 + 1];
}
int query(int pos, int l, int r, int ql, int qr) {
if (r < ql || qr < l) {
return 0;
}
if (ql <= l && r <= qr) {
return seg[pos];
}
int mid = (l + r) / 2;
return query(pos * 2, l, mid, ql, qr) |
query(pos * 2 + 1, mid + 1, r, ql, qr);
}
int lastInd[17];
bool blocked[(1 << 17)];
int dfs(int bit, int p) {
int ret = 0;
for (int i = 0; i < p; ++i) {
if ((bit & (1 << i)) == 0) {
ret += num[i];
}
}
blocked[bit] = true;
for (int i = 0; i < p; ++i) {
if ((bit & (1 << i)) == 0 && !blocked[bit | (1 << i)]) {
ret = min(ret, dfs(bit | (1 << i), p));
}
}
return ret;
}
int g[17][17][(1 << 17)];
void solve() {
int n, p;
scanf("%d %d ", &n, &p);
scanf(" %s ", s + 1);
for (int i = 0; i < p; ++i) {
for (int j = 0; j < p; ++j) scanf("%d ", &w[i][j]);
}
init(1, 1, n);
for (int i = n; i; --i) {
++num[s[i] - 'a'];
}
for (int i = 0; i < p; ++i) {
lastInd[i] = -1;
}
for (int ind = n; ind; --ind) {
int alp = s[ind] - 'a';
if (lastInd[alp] == -1) {
int x, y;
for (int i = 0; i < p; ++i) {
if (w[alp][i] == 0 && lastInd[i] != -1) {
x = alp, y = i;
if (x > y) swap(x, y);
g[x][y][query(1, 1, n, ind + 1, lastInd[i] - 1)] = true;
}
}
} else {
int lim = lastInd[alp];
if (w[alp][alp] == 0) {
g[alp][alp][query(1, 1, n, ind + 1, lim - 1)] = true;
}
int x, y;
for (int i = 0; i < p; ++i) {
if (w[alp][i] == 0 && lastInd[i] != -1 && lastInd[i] < lim) {
x = alp, y = i;
if (x > y) swap(x, y);
g[x][y][query(1, 1, n, ind + 1, lastInd[i] - 1)] = true;
}
}
}
lastInd[alp] = ind;
}
int lim = (1 << p);
for (int x = 0; x < p; ++x) {
for (int y = x; y < p; ++y) {
if (w[x][y]) {
continue;
}
for (int bit = 0; bit < lim; ++bit) {
if (g[x][y][bit]) {
for (int k = 0; k < x; ++k) {
g[x][y][bit | (1 << k)] = true;
}
for (int k = x + 1; k < y; ++k) {
g[x][y][bit | (1 << k)] = true;
}
for (int k = y + 1; k < p; ++k) {
g[x][y][bit | (1 << k)] = true;
}
blocked[bit] = true;
}
}
}
}
assert(!blocked[0]);
int ret = dfs(0, p);
printf("%d\n", ret);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int MAXN = 100010, MAXM = 200, MAXP = 18;
int n, p;
string s;
int pref[MAXP][MAXN];
bool good[1 << MAXP][MAXP][MAXP], god[1 << MAXP];
bool m[MAXP][MAXP];
vector<int> pos[MAXP];
int get(int p, int l, int r) {
if (l > r) return 0;
if (l == 0) return pref[p][r];
return pref[p][r] - pref[p][l - 1];
}
inline int del(int mask, int pos) {
if (mask & (1 << pos)) {
return mask ^ (1 << pos);
}
return mask;
}
void rec(int mask, int a, int b, bool f) {
if (m[a][b]) return;
if (!good[mask][a][b]) return;
if (!f) {
good[mask][a][b] = 0;
for (int i = 0; i < p; i++) {
if (i != a && i != b && (mask & (1 << i))) rec(mask ^ (1 << i), a, b, f);
}
return;
}
int i = 0, j = 0;
while (i < pos[a].size() && j < pos[b].size()) {
if (pos[b][j] < pos[a][i]) {
j++;
continue;
}
if (get(a, pos[a][i] + 1, pos[b][j] - 1) != 0) {
i++;
continue;
}
if (a == b && i == j) {
j++;
continue;
}
bool ok = 0;
int newmask = mask;
for (int first = 0; first < p; first++) {
if (first == a || first == b) continue;
if (get(first, pos[a][i], pos[b][j]) && (mask & (1 << first))) {
ok = 1;
newmask = del(newmask, first);
}
}
rec(newmask, a, b, 0);
if (!ok) {
good[mask][a][b] = 0;
f = 0;
for (int i = 0; i < p; i++) {
if (i != a && i != b && (mask & (1 << i)))
rec(mask ^ (1 << i), a, b, f);
}
return;
}
i++;
}
}
bool check[1 << MAXP];
void zavodnik() {
for (int i = (1 << p) - 1; i >= 0; i--) {
check[i] = 1;
string ss;
for (char first : s) {
if (i & (1 << (first - 'a'))) ss.push_back(first);
}
for (int j = 0; j < ((long long)((ss).size())) - 1; j++) {
if (!m[ss[j] - 'a'][ss[j + 1] - 'a']) check[i] = 0;
}
}
}
int dp[1 << MAXP];
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> p;
cin >> s;
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) cin >> m[i][j];
pref[s[0] - 'a'][0] = 1;
pos[s[0] - 'a'].push_back(0);
for (int i = 1; i < s.size(); i++) {
for (int j = 0; j < MAXP; j++) pref[j][i] += pref[j][i - 1];
pref[s[i] - 'a'][i]++;
pos[s[i] - 'a'].push_back(i);
}
for (int i = 0; i < (1 << MAXP); i++)
for (int j = 0; j < p; j++)
for (int k = 0; k < p; k++) good[i][j][k] = 1;
for (int i = 0; i < (1 << MAXP); i++) dp[i] = 2000000000;
dp[(1 << (p)) - 1] = s.size();
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) rec((1 << (p)) - 1, i, j, 1);
for (int i = 0; i < (1 << MAXP); i++) {
god[i] = 1;
for (int j = 0; j < p; j++)
for (int k = 0; k < p; k++)
if ((i & (1 << j)) && (i & (1 << k))) god[i] &= good[i][j][k];
}
int ans = 2000000000;
for (int i = (1 << (p)) - 1; i >= 0; i--) {
for (int j = 0; j < p; j++)
if (i & (1 << j) && god[i ^ (1 << j)]) {
dp[i ^ (1 << j)] =
min(dp[i ^ (1 << j)], dp[i] - get(j, 0, s.size() - 1));
}
ans = min(ans, dp[i]);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, P = 20;
int n, p;
char s[N];
int A[P][P];
vector<int> pos[P];
int cnt[P][N];
bitset<(1 << P)> legal, curr_legal, dp;
int main() {
cin >> n >> p;
scanf("%s", s);
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) cin >> A[i][j];
for (int i = 0; i < p; i++) {
for (int j = 1; j <= n; j++) {
if (s[j - 1] == char('a' + i)) pos[i].push_back(j - 1);
cnt[i][j] = cnt[i][j - 1] + (s[j - 1] == char('a' + i));
}
}
legal.set();
int full = (1 << p) - 1;
for (int c1 = 0; c1 < p; c1++)
for (int c2 = c1; c2 < p; c2++) {
if (A[c1][c2]) continue;
curr_legal.set();
int at1 = 0, at2 = 0;
while (at1 < pos[c1].size() && at2 < pos[c2].size()) {
if (c1 == c2 && at1 == at2) {
at2++;
continue;
}
int L = pos[c1][at1];
int R = pos[c2][at2];
if (L > R) swap(L, R);
int mask = 0;
for (int i = 0; i < p; i++) {
if (cnt[i][R] - cnt[i][L + 1] > 0) mask |= (1 << i);
}
if ((mask & 1 << c1) == 0 && (mask & 1 << c2) == 0) {
curr_legal.reset(full ^ mask);
}
if (pos[c1][at1] < pos[c2][at2])
at1++;
else
at2++;
}
for (int mask = full; mask > 0; mask--) {
if (!curr_legal.test(mask)) {
for (int i = 0; i < p; i++) {
if (i != c1 && i != c2 && mask & (1 << i))
curr_legal.reset(mask ^ (1 << i));
}
}
}
legal &= curr_legal;
}
int ans = n;
dp.set(full);
for (int mask = full; mask >= 0; mask--) {
if (dp.test(mask)) {
int currAns = n;
for (int i = 0; i < p; i++) {
if (mask & (1 << i)) {
if (legal.test(mask ^ (1 << i))) {
dp.set(mask ^ (1 << i));
}
} else
currAns -= cnt[i][n];
}
ans = min(ans, currAns);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:247474112")
#pragma GCC optimize("Ofast")
using namespace std;
const int INF = 0x3f3f3f3f;
int n, p;
string s;
int G[18][18];
const int MAXN = (1 << 17) + 1;
int vis[MAXN];
int cur[MAXN];
int ans = INF;
vector<vector<int>> cnt(17, vector<int>(100001, 0));
vector<int> pos[17];
void input() {
cin >> n >> p;
cin >> s;
for (long long i = 0; i < p; ++i) {
for (long long j = 0; j < p; ++j) {
cin >> G[i][j];
}
}
for (long long i = 0; i < n; ++i) {
pos[s[i] - 'a'].push_back(i);
for (long long j = 0; j < p; ++j) {
cnt[j][i + 1] = cnt[j][i] + (s[i] == 'a' + j ? 1 : 0);
}
}
}
void mark(int m, int a, int b) {
if (cur[m] == 1) return;
cur[m] = 1;
vis[m] = 1;
for (long long i = 0; i < p; ++i) {
if (i == a || i == b) continue;
if ((m >> i) & 1) {
mark(m ^ (1 << i), a, b);
}
}
}
void findm(int a, int b) {
if (pos[a].size() * pos[b].size() == 0) return;
int subm = 0;
for (int i = 0; i < pos[a].size(); ++i) {
int x = pos[a][i];
if (pos[b][0] > x) {
int y = pos[b][0];
while (i + 1 < pos[a].size() && pos[a][i + 1] < y) {
++i;
}
x = pos[a][i];
subm = 0;
for (long long k = 0; k < p; ++k) {
if (k == a || k == b) continue;
if (cnt[k][y + 1] - cnt[k][x + 1] > 0) {
subm |= (1 << k);
}
}
int m = (1 << p) - 1;
m ^= subm;
mark(m, a, b);
} else {
int l = 0, r = pos[b].size();
int m = (l + r) >> 1;
while (r - l > 1) {
if (pos[b][m] < x) {
l = m;
} else {
r = m;
}
m = (l + r) >> 1;
}
if (r != pos[b].size()) {
int y = pos[b][r];
while (i + 1 < pos[a].size() && pos[a][i + 1] < y) {
++i;
}
x = pos[a][i];
subm = 0;
for (long long k = 0; k < p; ++k) {
if (k == a || k == b) continue;
if (cnt[k][y + 1] - cnt[k][x + 1] > 0) {
subm |= (1 << k);
}
}
m = (1 << p) - 1;
m ^= subm;
mark(m, a, b);
}
}
}
}
void findmeq(int a) {
int subm = 0;
for (int i = 0; i < int(pos[a].size()) - 1; ++i) {
subm = 0;
int x = pos[a][i];
int y = pos[a][i + 1];
for (long long k = 0; k < p; ++k) {
if (k == a) continue;
if (cnt[k][y] - cnt[k][x] > 0) {
subm |= (1 << k);
}
}
int m = (1 << p) - 1;
m ^= subm;
mark(m, a, a);
}
}
bool DFS(int m) {
if (vis[m] == 0) {
vis[m] = 2;
bool flag = false;
for (long long i = 0; i < p; ++i) {
if ((m >> i) & 1) {
flag |= DFS(m ^ (1 << i));
}
}
if (!flag) {
int len = 0;
for (long long i = 0; i < p; ++i) {
if ((m >> i) & 1) {
len += cnt[i][n];
}
}
ans = min(ans, len);
}
return true;
}
return false;
}
void solve() {
for (long long i = 0; i < p; ++i) {
for (long long j = 0; j < p; ++j) {
if (G[i][j] == 0) {
memset(cur, 0, sizeof cur);
if (i == j)
findmeq(i);
else
findm(i, j);
}
}
}
DFS((1 << p) - 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
input();
solve();
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, inf = 1061109567;
const long long infll = 4557430888798830399;
const int N = 1e5 + 5, P = 17;
string s;
int n, p, a[P][P], f[(1 << P) + 5], dp[(1 << P) + 5], nxt[N][P], cnt[P];
bool bad[(1 << P) + 5][P][P];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> p >> s;
for (int i = 0; i < s.length(); i++) cnt[s[i] - 'a']++;
for (int i = 0; i < p; i++)
for (int j = 0; j < p; j++) cin >> a[i][j];
memset(nxt, -1, sizeof nxt);
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < p; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i] - 'a'] = i;
}
for (int i = 0; i < n; i++) {
vector<pair<int, int>> v;
for (int j = 0; j < p; j++)
if (nxt[i + 1][j] != -1) v.push_back(pair<int, int>(nxt[i + 1][j], j));
sort(v.begin(), v.end());
int msk = 0;
for (int j = 0; j < v.size(); j++) {
if (!a[s[i] - 'a'][v[j].second]) {
int tmp1 = s[i] - 'a', tmp2 = v[j].second;
if (tmp1 > tmp2) swap(tmp1, tmp2);
bad[msk][tmp1][tmp2] = 1;
}
msk |= (1 << v[j].second);
}
}
for (int i = 0; i < p; i++)
for (int j = i; j < p; j++) {
for (int msk = 0; msk < (1 << p); msk++)
if (bad[msk][i][j] && !(msk & (1 << i)) && !(msk & (1 << j))) {
for (int k = 0; k < p; k++)
if (k != i && k != j) {
bad[msk | (1 << k)][i][j] = 1;
}
}
}
for (int msk = 0; msk < (1 << p); msk++) {
f[msk] = 1;
for (int i = 0; i < p; i++)
for (int j = i; j < p; j++)
if (!(msk & (1 << i)) && !(msk & (1 << j))) {
if (bad[msk][i][j]) f[msk] = 0;
}
}
for (int i = 0; i < (1 << p); i++) {
if (!f[i]) continue;
if (i == 0) {
dp[i] = 1;
continue;
}
dp[i] = 0;
for (int j = 0; j < p; j++)
if ((i & (1 << j)) && dp[i ^ (1 << j)]) {
dp[i] = 1;
break;
}
}
int ans = inf;
for (int i = 0; i < (1 << p); i++)
if (dp[i]) {
int len = s.length();
for (int j = 0; j < p; j++)
if (i & (1 << j)) len -= cnt[j];
ans = min(ans, len);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
int kx8[] = {1, 1, 2, 2, -1, -1, -2, -2};
int ky8[] = {2, -2, 1, -1, 2, -2, 1, -1};
long long bigmod(long long a, long long b, long long c) {
if (b == 0) return 1 % c;
long long x = bigmod(a, b / 2, c);
x = (x * x) % c;
if (b % 2 == 1) x = (x * a) % c;
return x;
}
long long poww(long long a, long long b) {
if (b == 0) return 1;
long long x = poww(a, b / 2);
x = x * x;
if (b % 2 == 1) x = (x * a);
return x;
}
long long mod_inverse(long long a, long long mod) {
return bigmod(a, mod - 2, mod);
}
const int M = 100005;
int Fpos[M][18], Bpos[M][18], p[18][18], vis[18][1 << 17], del[18][1 << 17],
restricted[1 << 17], sz[18];
int n, k;
vector<int> vec[18];
string s;
long long dp[1 << 18];
long long dpcall(int mask) {
long long &ret = dp[mask];
if (~ret) return ret;
ret = 0;
for (int i = 0; i < k; i++) {
if ((bool)((1 << i) & mask)) continue;
if (restricted[mask | (1 << i)]) continue;
ret = max(ret, sz[i] + dpcall(1 << i | mask));
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
cin >> s;
s = "#" + s;
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
cin >> p[i][j];
}
}
for (int i = 1; i <= n; i++) {
int x = s[i] - 'a';
vec[x].push_back(i);
sz[x]++;
}
for (int i = n; i >= 1; i--) {
int x = s[i] - 'a';
for (int j = 0; j < k; j++) {
Fpos[i][j] = Fpos[i + 1][j];
}
Fpos[i][x] = i;
}
for (int i = 0; i < k; i++) {
memset((vis), 0, sizeof(vis));
memset((del), 0, sizeof(del));
for (auto x : vec[i]) {
for (int j = 0; j < k; j++) {
if (p[i][j]) continue;
if (Fpos[x + 1][j]) {
int mask = 0;
for (int l = 0; l < k; l++) {
if (Fpos[x + 1][l] > x && Fpos[x + 1][l] < Fpos[x + 1][j]) {
mask |= 1 << l;
if (l == i) {
mask = 0;
break;
}
}
}
if (mask) vis[j][mask] = 1;
}
}
}
for (int j = 0; j < k; j++) {
int rmask = (1 << i) | (1 << j);
rmask = ((1 << k) - 1) ^ rmask;
for (int mask = 0; mask < (1 << k); mask++) {
if (!vis[j][mask] || del[j][mask]) continue;
for (int nmask = mask; nmask < (1 << k); nmask = (nmask + 1) | mask) {
del[j][nmask] = 1;
restricted[nmask & rmask] = 1;
}
}
}
}
memset((dp), -1, sizeof(dp));
cout << n - dpcall(0) << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.