text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int mod = 998244353;
int main() {
string s;
cin >> s;
int l = s.size();
vector<vector<int> > nck(l + 1);
for (int i = 0; i < l + 1; i++) nck[i].resize(l + 1);
nck[0][0] = 1;
for (int n = 1; n < l + 1; n++) {
nck[n][0] = 1;
for (int k = 1; k < n + 1; k++)
nck[n][k] = (nck[n - 1][k] + nck[n - 1][k - 1]) % mod;
for (int k = n + 1; k < l + 1; k++) nck[n][k] = 0;
}
vector<int> lefts(l), rights(l), marks(l);
int ls = 0, rs = 0, qs = 0;
for (int i = 0; i < l; i++) {
ls += s[i] == '(' ? 1 : 0;
rs += s[i] == ')' ? 1 : 0;
qs += s[i] == '?' ? 1 : 0;
lefts[i] = ls;
rights[i] = rs;
marks[i] = qs;
}
long long ans = 0;
for (int g = 0; g < l; g++) {
for (int i = 0; i < l; i++) {
int a = lefts[i];
int b = rights[l - 1] - rights[i];
int c = marks[i];
int d = marks[l - 1] - marks[i];
if (g >= a && g >= b) {
ans += ((((long long)nck[c][g - a] * (long long)nck[d][g - b]) % mod) *
(long long)g) %
mod;
ans %= mod;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename G>
struct triple {
G first, second, T;
triple(G x, G y, G z) : first(x), second(y), T(z) {}
triple() : first(0), second(0), T(0) {}
};
const long long mod = 998244353;
string s;
vector<vector<long long>> dp[2][2];
vector<int> ac;
vector<long long> pot;
long long solve(int l, int r, bool x, bool y) {
if (r - l <= 0) return 0;
if (dp[x][y][l][r] != -1) return dp[x][y][l][r];
if ((!x && s[l] == ')') || (!y && s[r] == '(')) return 0;
dp[x][y][l][r] = 0;
if (x && (s[l] == ')' || s[l] == '?'))
dp[x][y][l][r] = (dp[x][y][l][r] + solve(l + 1, r, true, false)) % mod;
if (y && (s[r] == '(' || s[r] == '?'))
dp[x][y][l][r] = (dp[x][y][l][r] + solve(l, r - 1, false, true)) % mod;
if (x && y && (s[l] == ')' || s[l] == '?') && (s[r] == '(' || s[r] == '?'))
dp[x][y][l][r] = (dp[x][y][l][r] + solve(l + 1, r - 1, true, true)) % mod;
if ((s[l] == '(' || s[l] == '?') && (s[r] == ')' || s[r] == '?')) {
long long temp = solve(l + 1, r - 1, true, true);
dp[x][y][l][r] = (dp[x][y][l][r] + temp) % mod;
dp[x][y][l][r] = (dp[x][y][l][r] + pot[ac[r] - ac[l + 1]]) % mod;
}
return dp[x][y][l][r];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
int n = s.size();
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
dp[i][j] = vector<vector<long long>>(n, vector<long long>(n, -1));
ac = vector<int>(n + 1);
for (int i = 1; i <= n; i++) ac[i] = ac[i - 1] + (s[i - 1] == '?');
pot = vector<long long>(n + 1);
pot[0] = 1;
for (int i = 1; i <= n; i++) pot[i] = pot[i - 1] * 2 % mod;
cout << solve(0, n - 1, true, true) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e3 + 10;
const int MOD = 998244353;
long long dp[MAXN][MAXN];
int prefix[MAXN];
long long fpow(long long x, long long n, const long long &mod) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * x % mod;
x = x * x % mod;
n >>= 1;
}
return ret;
}
int main() {
string str;
cin >> str;
int N = str.size();
prefix[0] = int(str[0] == '?');
for (int i = 1; i < N; ++i) prefix[i] = prefix[i - 1] + int(str[i] == '?');
for (int len = 2; len <= N; ++len)
for (int l = 0; l + len - 1 < N; ++l) {
int r = l + len - 1;
if (str[l] != '(') (dp[l][r] += dp[l + 1][r]) %= MOD;
if (str[r] != ')') (dp[l][r] += dp[l][r - 1]) %= MOD;
if (str[l] != '(' and str[r] != ')')
((dp[l][r] -= dp[l + 1][r - 1]) += MOD) %= MOD;
if (str[l] != ')' and str[r] != '(') {
(dp[l][r] += dp[l + 1][r - 1]) %= MOD;
(dp[l][r] += fpow(2, prefix[r - 1] - prefix[l], MOD)) %= MOD;
}
}
cout << dp[0][N - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 10;
const int mod = 998244353;
long long dp[N][N];
int sum[N];
char s[N];
int js(int l, int r) { return sum[r] - sum[l - 1]; }
long long p[N];
int main() {
p[0] = 1;
for (int i = 1; i < N; i++) p[i] = (p[i - 1] * 2) % mod;
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
if (s[i] == '?')
sum[i] = sum[i - 1] + 1;
else
sum[i] = sum[i - 1];
}
for (int i = 1; i <= n; i++) dp[i][i] = 0;
for (int len = 2; len <= n; len++) {
for (int l = 1; l <= n + 1 - len; l++) {
int r = len + l - 1;
if (s[l] != '(') dp[l][r] = (dp[l][r] + dp[l + 1][r]) % mod;
if (s[r] != ')') dp[l][r] = (dp[l][r] + dp[l][r - 1]) % mod;
if (s[l] != '(' && s[r] != ')')
dp[l][r] = (dp[l][r] - dp[l + 1][r - 1] + mod) % mod;
if (s[l] != ')' && s[r] != '(')
dp[l][r] = (dp[l][r] + dp[l + 1][r - 1] + p[js(l + 1, r - 1)]) % mod;
}
}
printf("%lld\n", dp[1][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
long long power(long long x, long long y) {
long long ret = 1;
while (y) {
if (y & 1) ret = ret * x % 998244353;
x = x * x % 998244353;
y >>= 1;
}
return ret;
}
long long pre[404040];
long long f[2020][2020];
char s[404040];
int main() {
scanf("%s", s + 1);
int len = strlen(s + 1);
for (int i = 1; i <= len; i++) pre[i + 1] = pre[i] + (s[i] == '?');
for (int l = 2; l <= len; l++) {
for (int i = 1; i + l - 1 <= len; i++) {
int j = i + l - 1;
if (s[i] != '(') (f[i][j] += f[i + 1][j]) %= 998244353;
if (s[j] != ')') (f[i][j] += f[i][j - 1]) %= 998244353;
if (s[i] != '(' && s[j] != ')')
f[i][j] = (f[i][j] - f[i + 1][j - 1] + 998244353) % 998244353;
if (s[i] != ')' && s[j] != '(')
f[i][j] = (f[i][j] + f[i + 1][j - 1] + power(2, pre[j] - pre[i + 1])) %
998244353;
}
}
printf("%lld", f[1][len]);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int out = 0, fh = 1;
char jp = getchar();
while ((jp > '9' || jp < '0') && jp != '-') jp = getchar();
if (jp == '-') fh = -1, jp = getchar();
while (jp >= '0' && jp <= '9') out = out * 10 + jp - '0', jp = getchar();
return out * fh;
}
const int P = 998244353;
int add(int a, int b) { return (a + b >= P) ? (a + b - P) : (a + b); }
void inc(int &a, int b) { a = add(a, b); }
int mul(int a, int b) { return 1LL * a * b % P; }
int fpow(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = mul(res, a);
a = mul(a, a);
b >>= 1;
}
return res;
}
const int N = 2019;
char buf[N];
int n, f[N][N], s[N];
int sum(int L, int R) {
if (L > R) return 0;
return add(s[R], P - s[L - 1]);
}
int main() {
scanf("%s", buf + 1);
n = strlen(buf + 1);
for (int i = 1; i <= n; ++i) s[i] = s[i - 1] + (buf[i] == '?');
for (int len = 2; len <= n; ++len)
for (int i = 1; i + len - 1 <= n; ++i) {
int j = i + len - 1;
if (buf[i] != '(') inc(f[i][j], f[i + 1][j]);
if (buf[j] != ')') inc(f[i][j], f[i][j - 1]);
if (buf[i] != '(' && buf[j] != ')') inc(f[i][j], P - f[i + 1][j - 1]);
if (buf[i] != ')' && buf[j] != '(')
inc(f[i][j], add(f[i + 1][j - 1], fpow(2, sum(i + 1, j - 1))));
}
cout << f[1][n] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
long long power(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % 998244353;
y = y / 2, x = (x * x) % 998244353;
}
return res % 998244353;
}
long long dp[2005][2005][2];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long long n = s.length();
long long i, j;
dp[0][0][0] = 1;
for (i = 1; i <= n; i++) {
for (j = 0; j <= n; j++) {
if (s[i - 1] != ')') {
dp[i][j + 1][0] += dp[i - 1][j][0];
dp[i][j + 1][0] %= 998244353;
}
if (s[i - 1] != '(') {
dp[i][j][0] += dp[i - 1][j][0];
dp[i][j][0] %= 998244353;
}
}
}
dp[n + 1][0][1] = 1;
for (i = n; i >= 1; i--) {
for (j = 0; j <= n; j++) {
if (s[i - 1] != '(') {
dp[i][j + 1][1] += dp[i + 1][j][1];
dp[i][j + 1][1] %= 998244353;
}
if (s[i - 1] != ')') {
dp[i][j][1] += dp[i + 1][j][1];
dp[i][j][1] %= 998244353;
}
}
}
long long ans = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
ans = ans + dp[i][j][0] * dp[i + 1][j][1] % 998244353 * j % 998244353;
ans %= 998244353;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
long long read() {
long long w = 0, f = 1;
char c = ' ';
while (c < '0' || c > '9')
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++),
f = c == '-' ? -1 : f;
while (c >= '0' && c <= '9')
w = w * 10 + c - 48,
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
return w * f;
}
long long n, a[2005], w[2005], dp[2005][2005], p[2005] = {1};
const long long mod = 998244353;
char s[2005];
void init() {
for (long long i = 1; i < 2005; i++) p[i] = (p[i - 1] << 1) % mod;
}
signed main() {
init();
scanf("%s", s);
n = strlen(s);
for (long long i = 1; i <= n; i++)
a[i] = (s[i - 1] == '?') ? 0 : (s[i - 1] == '(' ? 1 : -1),
w[i] = w[i - 1] + (!a[i]);
long long x;
for (long long i = 2; i <= n; i++)
for (long long j = 1; j <= n - i + 1; j++) {
x = i + j - 1;
if (a[x] != -1) dp[j][x] = (dp[j][x] + dp[j][x - 1]) % mod;
if (a[j] != 1)
dp[j][x] = (dp[j][x] + dp[j + 1][x] -
(a[x] == -1 ? 0 : dp[j + 1][x - 1]) + mod) %
mod;
if (a[j] != -1)
dp[j][x] = (dp[j][x] +
(a[x] == 1 ? 0 : p[w[x - 1] - w[j]] + dp[j + 1][x - 1])) %
mod;
}
printf("%lld", dp[1][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
void read(int &a) {
a = 0;
int d = 1;
char ch;
while (ch = getchar(), ch > '9' || ch < '0')
if (ch == '-') d = -1;
a = ch ^ 48;
while (ch = getchar(), ch >= '0' && ch <= '9')
a = (a << 3) + (a << 1) + (ch ^ 48);
a *= d;
}
long long f[2005][2005];
int p[2005];
char a[2005];
int quickmod(int x, int y) {
int res = 1, base = x;
while (y) {
if (y & 1) res = 1ll * res * base % mod;
base = 1ll * base * base % mod;
y >>= 1;
}
return res;
}
int main() {
scanf("%s", a);
int len = strlen(a);
for (register int i = 0; i < len; i++)
p[i + 1] = p[i], p[i + 1] += a[i] == '?';
for (register int t = 2; t <= len; t++) {
for (register int i = 0; i < len - t + 1; i++) {
int j = i + t - 1;
if (a[i] != '(') (f[i][j] += f[i + 1][j]) %= mod;
if (a[j] != ')') (f[i][j] += f[i][j - 1]) %= mod;
if (a[i] != '(' && a[j] != ')')
f[i][j] = (f[i][j] - f[i + 1][j - 1] + mod) % mod;
if (a[i] != ')' && a[j] != '(')
f[i][j] =
(f[i][j] + f[i + 1][j - 1] + quickmod(2, p[j] - p[i + 1])) % mod;
}
}
printf("%lld", f[0][len - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353;
long long int fac[2000];
long long int pwr(long long int num) {
long long int pw = mod - 2;
long long int res = 1;
while (pw) {
if (pw % 2) res = (res * num) % mod;
pw /= 2;
num = (num * num) % mod;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
fac[0] = 1;
for (int i = 1; i < 2000; i++) fac[i] = (fac[i - 1] * i) % mod;
string s;
cin >> s;
int n = s.length();
long long int cnt1 = 0, cnt2 = 0, cnt3 = 0;
long long int CNT1[2005];
long long int CNT2[2005];
long long int CNT3[2005];
for (int i = 0; i < n; i++) {
if (s[i] == '(')
cnt1++;
else if (s[i] == ')')
cnt2++;
else
cnt3++;
CNT1[i] = cnt1;
CNT2[i] = cnt2;
CNT3[i] = cnt3;
}
long long int ans = 0;
for (int i = 0; i < n - 1; i++) {
if (CNT1[i] + CNT3[i] < cnt2 - CNT2[i] ||
CNT1[i] > cnt2 + cnt3 - CNT2[i] - CNT3[i])
continue;
long long int left = CNT3[i];
long long int right = cnt3 - CNT3[i];
long long int minLeft = max(0ll, cnt2 - CNT2[i] - CNT1[i]);
long long int minRight = max(0ll, CNT1[i] + CNT2[i] - cnt2);
long long int minDeep = max(CNT1[i], cnt2 - CNT2[i]);
for (int j = 0; j <= min(left - minLeft, right - minRight); j++) {
long long int temp1 = (((fac[left] * pwr(fac[minLeft + j])) % mod) *
pwr(fac[left - minLeft - j])) %
mod;
long long int temp2 = (((fac[right] * pwr(fac[minRight + j])) % mod) *
pwr(fac[right - minRight - j])) %
mod;
ans += (((temp1 * temp2) % mod) * (minDeep + j)) % mod;
ans %= mod;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2002;
const int mod = 998244353;
int mul(int a, int b) { return a * 1ll * b % mod; }
int add(int a, int b) {
if (a + b >= mod) return a + b - mod;
return a + b;
}
int dpl[N][N], dpr[N][N];
char s[N];
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
dpl[0][0] = 1;
dpr[n + 1][0] = 1;
for (int i = (1); i <= (n); ++i) {
for (int j = (0); j <= (n); ++j) {
if (s[i] != '(') dpl[i][j] = dpl[i - 1][j];
if (j > 0 && s[i] != ')') dpl[i][j] = add(dpl[i][j], dpl[i - 1][j - 1]);
}
}
for (int i = (n); i >= (1); --i) {
for (int j = (0); j <= (n); ++j) {
if (j > 0 && s[i] != '(') dpr[i][j] = dpr[i + 1][j - 1];
if (s[i] != ')') dpr[i][j] = add(dpr[i][j], dpr[i + 1][j]);
}
}
int ans = 0;
for (int i = (1); i <= (n - 1); ++i) {
for (int j = (0); j <= (n); ++j) {
ans = add(ans, mul(j, mul(dpl[i][j], dpr[i + 1][j])));
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 2500, MOD = 998244353;
long long cntq[MX];
long long dp[MX][MX];
string s;
long long mod(long long x_) { return (x_ + MOD) % MOD; }
long long modpow(long long x_, long long N_) {
if (N_ == 0) return 1;
long long a = modpow(x_, N_ / 2);
a = (a * a) % MOD;
if (N_ % 2) a = (a * x_) % MOD;
return a;
}
long long getQuestions(int i, int j) {
if (j < i) return 0;
return cntq[j + 1] - cntq[i];
}
long long getAns(int i, int j) {
if (j <= i) return 0;
if (dp[i][j] == -1) {
long long ans = 0;
if (s[i] != '(') ans = mod(ans + getAns(i + 1, j));
if (s[j] != ')') ans = mod(ans + getAns(i, j - 1));
if (s[i] != '(' && s[j] != ')') ans = mod(ans - getAns(i + 1, j - 1));
if (s[i] != ')' && s[j] != '(') {
ans = mod(ans + modpow(2, getQuestions(i + 1, j - 1)) +
getAns(i + 1, j - 1));
}
dp[i][j] = ans;
}
return dp[i][j];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> s;
cntq[0] = 0;
for (int i = int(0); i < int(s.size()); i++)
cntq[i + 1] = cntq[i] + (s[i] == '?' ? 1 : 0);
for (int i = int(0); i < int(MX); i++)
for (int j = int(0); j < int(MX); j++) dp[i][j] = -1;
cout << getAns(0, s.size() - 1) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e3 + 10;
const int MOD = 998244353;
const double eps = 1e-6;
long long QuickPow(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = ans * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return ans;
}
char s[MAXN];
long long dp[MAXN][MAXN], sum[MAXN];
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
memset(sum, 0, sizeof(sum));
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + (s[i] == '?');
for (int len = 2; len <= n; ++len) {
for (int l = 1, r = l + len - 1; r <= n; ++l, ++r) {
if (s[l] != '(') dp[l][r] = (dp[l][r] + dp[l + 1][r]) % MOD;
if (s[r] != ')') dp[l][r] = (dp[l][r] + dp[l][r - 1]) % MOD;
if (s[l] != '(' && s[r] != ')')
dp[l][r] = (dp[l][r] - dp[l + 1][r - 1] + MOD) % MOD;
if (s[l] != ')' && s[r] != '(')
dp[l][r] =
(dp[l][r] + dp[l + 1][r - 1] + QuickPow(2, sum[r - 1] - sum[l])) %
MOD;
}
}
printf("%lld\n", dp[1][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int dp[2][2005][2005], dp2[2][2005][2005];
inline void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
string s;
cin >> s;
int n = s.length();
if (s[0] == '(' || s[0] == '?') dp[1][0][1] = 1;
if (s[0] == ')' || s[0] == '?') dp[0][0][0] = 1;
for (int i = 0; i + 1 < n; ++i)
for (int d = 0; d <= i + 1; ++d)
for (int k = 0; k < 2; ++k) {
if (s[i + 1] == '(' || s[i + 1] == '?')
add(dp[1][i + 1][d + 1], dp[k][i][d]);
if (s[i + 1] == ')' || s[i + 1] == '?')
add(dp[0][i + 1][d], dp[k][i][d]);
}
if (s.back() == '(' || s.back() == '?') dp2[0][n - 1][0] = 1;
if (s.back() == ')' || s.back() == '?') dp2[1][n - 1][1] = 1;
for (int i = n - 1; i - 1 >= 0; --i)
for (int d = 0; d <= n - i; ++d)
for (int k = 0; k < 2; ++k) {
if (s[i - 1] == '(' || s[i - 1] == '?')
add(dp2[0][i - 1][d], dp2[k][i][d]);
if (s[i - 1] == ')' || s[i - 1] == '?')
add(dp2[1][i - 1][d + 1], dp2[k][i][d]);
}
int ans = 0;
for (int i = 0; i + 1 < n; ++i)
for (int d = 1; d <= n; ++d) {
int l = 0, r = 0;
add(l, dp[0][i][d]);
add(l, dp[1][i][d]);
add(r, dp2[0][i + 1][d]);
add(r, dp2[1][i + 1][d]);
add(ans, (long long)r * l % mod * d % mod);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int powmod(int a, int b, int p) {
int ans = 1;
for (; b; a = (long long)a * a % p, (b >>= 1))
if (b & 1) ans = (long long)ans * a % p;
return ans;
}
int n, a[2001], s[2001], f[2001][2001];
char c[2001], ch;
int main() {
scanf("%s", c + 1);
n = strlen(c + 1);
for (int i = 1; i <= n; i++) {
ch = c[i];
if (ch == '(')
a[i] = 1;
else if (ch == ')')
a[i] = -1;
}
for (int i = 1; i <= n; i++)
if (a[i])
s[i] = s[i - 1];
else
s[i] = s[i - 1] + 1;
for (int l = 2; l <= n; l++)
for (int i = 1, j = l; j <= n; i++, j++) {
if (a[i] != 1) (f[i][j] += f[i + 1][j]) %= 998244353;
if (a[j] != -1) (f[i][j] += f[i][j - 1]) %= 998244353;
if (a[i] != 1 && a[j] != -1)
(f[i][j] -= f[i + 1][j - 1] - 998244353) %= 998244353;
if (a[i] != -1 && a[j] != 1)
(f[i][j] += (f[i + 1][j - 1] + powmod(2, s[j - 1] - s[i], 998244353)) %
998244353) %= 998244353;
}
printf("%d", f[1][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2010;
const long long mod = 998244353;
long long pw(long long a, long long b) {
if (b == 0) return 1;
long long k = pw(a, b / 2);
k = (k * k) % mod;
if (b & 1) k = (k * a) % mod;
return k;
}
long long n, m;
long long dp[maxn][maxn], cnt[maxn], f[maxn][maxn];
string s;
signed main() {
s += ".";
string ss;
cin >> ss;
n = ss.size();
s += ss;
for (long long i = 1; i <= n; i++) cnt[i] = cnt[i - 1] + (s[i] == '?');
for (long long t = 2; t <= n; t++)
for (long long l = 1; l + t - 1 <= n; l++) {
long long r = l + t - 1;
if (t == 2) f[l][r] = (s[l] != ')');
if (s[l] == ')') {
dp[l][r] = dp[l + 1][r];
f[l][r] = f[l + 1][r];
continue;
}
if (s[r] == '(') {
dp[l][r] = dp[l][r - 1];
continue;
}
if (t == 2) {
dp[l][r] = 1;
continue;
}
long long K = pw(2, cnt[r - 1] - cnt[l]);
f[l][r] = K + dp[l + 1][r - 1];
if (s[l] == '?') f[l][r] += f[l + 1][r];
f[l][r] %= mod;
if (s[l] == '(' && s[r] == ')') dp[l][r] = (dp[l + 1][r - 1] + K) % mod;
if (s[l] == '?' && s[r] == ')')
dp[l][r] = (dp[l + 1][r] + dp[l + 1][r - 1] + K) % mod;
if (s[l] == '(' && s[r] == '?')
dp[l][r] = (dp[l][r - 1] + dp[l + 1][r - 1] + K) % mod;
if (s[l] == '?' && s[r] == '?')
dp[l][r] = (dp[l][r - 1] + dp[l + 1][r] + K) % mod;
}
cout << dp[1][n];
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 10;
const int mod = 998244353;
char s[maxn];
long long dp[maxn][maxn], sum[maxn];
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
int main(int argc, const char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> (s + 1);
int n = int(strlen(s + 1));
for (int i = (1), _ = (int(strlen(s + 1))); i <= _; i++) {
sum[i] = sum[i - 1] + (s[i] == '?');
}
for (int len = (2), _ = (n); len <= _; len++) {
for (int l = 1, r = l + len - 1; r <= n; ++l, ++r) {
if (s[l] != '(') dp[l][r] = (dp[l][r] + dp[l + 1][r]) % mod;
if (s[r] != ')') dp[l][r] = (dp[l][r] + dp[l][r - 1]) % mod;
if (s[l] != '(' && s[r] != ')')
dp[l][r] = (dp[l][r] - dp[l + 1][r - 1] + mod) % mod;
if (s[l] != ')' && s[r] != '(')
dp[l][r] =
(dp[l][r] + dp[l + 1][r - 1] + qpow(2, sum[r - 1] - sum[l])) % mod;
}
}
cout << dp[1][n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
char str[222222];
int n;
const long long mod = 998244353;
long long dp[2222][2222][2][2];
long long sum[2222], pw2[2222];
int main() {
scanf("%s", str + 1);
register int i, ii;
pw2[0] = 1;
for (i = 1; str[i + 1]; i++)
if (str[i] != ')' && str[i + 1] != '(') dp[i][i + 1][0][1] = 1;
n = i;
for (i = 1; i <= n; i++)
sum[i] = sum[i - 1] + (str[i] == '?'), pw2[i] = (pw2[i - 1] * 2) % mod;
for (i = 2; i < n; i++)
for (ii = 1; ii + i <= n; ii++) {
int l = ii, r = ii + i;
long long ls = dp[l + 1][r - 1][0][0] + dp[l + 1][r - 1][0][1] +
dp[l + 1][r - 1][1][0] + dp[l + 1][r - 1][1][1];
if (str[l] != ')' && str[r] != '(')
dp[l][r][0][1] += ls + pw2[sum[r - 1] - sum[l]];
if (str[l] != '(' && str[r] != ')') dp[l][r][1][0] += ls;
if (str[l] != ')' && str[r] != ')')
dp[l][r][0][0] += dp[l][r - 1][0][1] + dp[l][r - 1][0][0];
if (str[l] != '(' && str[r] != '(')
dp[l][r][1][1] += dp[l + 1][r][0][1] + dp[l + 1][r][1][1];
dp[l][r][0][0] %= mod;
dp[l][r][0][1] %= mod;
dp[l][r][1][0] %= mod;
dp[l][r][1][1] %= mod;
}
printf("%I64d\n",
(dp[1][n][0][0] + dp[1][n][0][1] + dp[1][n][1][0] + dp[1][n][1][1]) %
mod);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
int add(int a, int b) { return (a + b) % MOD; }
int sub(int a, int b) { return (a - b + MOD) % MOD; }
int mul(int a, int b) { return ((long long)a * b) % MOD; }
int inv(int a) {
int b = 1;
for (int i = 0; (1 << i) <= (MOD - 2); i++) {
if ((1 << i) & (MOD - 2)) b = mul(b, a);
a = mul(a, a);
}
return b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int X = 0;
for (char c : s)
if (c == '?') X++;
vector<int> fact(X + 1);
fact[0] = 1;
for (int i = 1; i <= X; i++) fact[i] = mul(fact[i - 1], i);
vector<int> sum1(X + 2);
sum1[X + 1] = 0;
for (int i = X; i >= 0; i--) {
sum1[i] = mul(fact[X], inv(mul(fact[i], fact[X - i])));
sum1[i] = add(sum1[i], sum1[i + 1]);
}
vector<int> sum2(X + 1);
sum2[X] = 0;
for (int i = X - 1; i >= 0; i--) {
sum2[i] = mul(fact[X - 1], inv(mul(fact[i], fact[X - 1 - i])));
sum2[i] = add(sum2[i], sum2[i + 1]);
}
int A = 0, B = 0, C = 0, sol = 0;
for (char c : s)
if (c == ')') C++;
for (char c : s) {
if (c == '(') {
A++;
int T = max(0, min(X + 1, A + B - C));
sol = add(sol, sum1[T]);
} else if (c == '?') {
B++;
int T = max(0, min(X, A + B - C));
sol = add(sol, sum2[T]);
} else if (c == ')') {
C--;
}
}
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int maxn = 62;
const int inf = 1000000009;
const int mod = 998244353;
char op[2009];
int dp[2009][2009], pq[2009][2009];
int gh[2009];
int main() {
gh[0] = 1;
scanf("%s", op);
int n = strlen(op);
for (int i = 1; i <= n; ++i) gh[i] = gh[i - 1] * 2 % mod;
for (int i = 0; i < n; ++i)
if (op[i] == '?') pq[i][i] = 1;
for (int i = n - 1; i >= 0; --i) {
for (int j = i + 1; j < n; ++j) {
if (op[i] == '?' && op[j] == '?') {
if (j == i + 1) {
dp[i][j] = 1;
} else {
dp[i][j] = 0;
dp[i][j] = (dp[i][j] + gh[pq[i + 1][j - 1]]) % mod;
dp[i][j] = (dp[i][j] + dp[i][j - 1]) % mod;
dp[i][j] = (dp[i][j] + dp[i + 1][j]) % mod;
}
} else if (op[i] == '?') {
if (j == i + 1 && op[j] == ')')
dp[i][j] = 1;
else if (j > i + 1) {
dp[i][j] = 0;
if (op[j] == ')') {
dp[i][j] =
(((dp[i][j] + dp[i + 1][j - 1]) % mod + gh[pq[i + 1][j - 1]]) %
mod +
dp[i + 1][j]) %
mod;
} else {
dp[i][j] = (dp[i][j] + dp[i][j - 1]) % mod;
}
}
} else if (op[j] == '?') {
if (j == i + 1 && op[i] == '(')
dp[i][j] = 1;
else if (j > i + 1) {
dp[i][j] = 0;
if (op[i] == '(') {
dp[i][j] =
(((dp[i][j] + dp[i + 1][j - 1]) % mod + gh[pq[i + 1][j - 1]]) %
mod +
dp[i][j - 1]) %
mod;
} else {
dp[i][j] = (dp[i][j] + dp[i + 1][j]) % mod;
}
}
} else {
if (j == i + 1 && op[i] == '(' && op[j] == ')')
dp[i][j] = 1;
else if (j > i + 1) {
dp[i][j] = 0;
if (op[i] == '(' && op[j] == ')')
dp[i][j] = (dp[i + 1][j - 1] + gh[pq[i + 1][j - 1]]) % mod;
else if (op[i] == '(')
dp[i][j] = dp[i][j - 1];
else if (op[j] == ')')
dp[i][j] = dp[i + 1][j];
else
dp[i][j] = dp[i + 1][j - 1];
}
}
if (j > i + 1)
pq[i][j] = pq[i + 1][j - 1];
else
pq[i][j] = 0;
if (op[i] == '?') ++pq[i][j];
if (op[j] == '?') ++pq[i][j];
}
}
cout << dp[0][n - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 5;
const int mod = 998244353;
int dp[maxn][maxn], sum[maxn];
char s[maxn];
long long quick_pow(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y >>= 1;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (s[i] == '?');
for (int len = 2; len <= n; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int j = i + len - 1;
if (s[i] != '(') dp[i][j] = (dp[i][j] + dp[i + 1][j]) % mod;
if (s[j] != ')') dp[i][j] = (dp[i][j] + dp[i][j - 1]) % mod;
if (s[i] != '(' && s[j] != ')')
dp[i][j] = (dp[i][j] - dp[i + 1][j - 1] + mod) % mod;
if (s[i] != ')' && s[j] != '(')
dp[i][j] = (1ll * dp[i][j] + dp[i + 1][j - 1] +
quick_pow(2, sum[j - 1] - sum[i])) %
mod;
}
}
cout << dp[1][n] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 998244353;
long long modpow(long long base, long long exp, long long modulus = M) {
base %= modulus;
long long result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % modulus;
base = (base * base) % modulus;
exp >>= 1;
}
return result;
}
long long modinv(long long a, long long mod = M) { return modpow(a, mod - 2); }
string s;
int n;
long long f[1000010], invf[1000010];
long long C(long long a, long long b) {
if (b > a || b < 0 || a < 0) return 0;
return (((f[a] * invf[b]) % M) * invf[a - b]) % M;
}
int main() {
ios::sync_with_stdio(false);
cin >> s;
n = s.length();
f[0] = invf[0] = 1;
for (int i = 1; i <= n; ++i) {
f[i] = (f[i - 1] * i) % M;
invf[i] = modinv(f[i]);
}
int lb = 0, rb = 0, lq = 0, rq = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == ')')
++rb;
else if (s[i] == '?')
++rq;
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == ')') --rb;
if (s[i] == '(') ++lb;
if (s[i] == '?') --rq, ++lq;
ans += (1ll * lb * C(lq + rq, rq - lb + rb) +
1ll * lq * C(lq + rq - 1, rq - lb + rb - 1)) %
M;
ans %= M;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
using ll = long long;
ll mod = 998244353;
string s;
int n;
ll dp[maxn][maxn];
int pref[maxn];
ll bigmod(ll a, ll b) {
if (b == 0) return 1;
if (b & 1) {
ll ret = bigmod(a, b - 1);
return (ret * a) % mod;
} else {
ll ret = bigmod(a, b >> 1);
return (ret * ret) % mod;
}
}
ll call(int l, int r) {
if (l >= r) return 0;
if (dp[l][r] != -1) return dp[l][r];
ll ret = 0;
if (s[l] != '(') {
ret = (ret + call(l + 1, r)) % mod;
}
if (s[r] != ')') {
ret = (ret + call(l, r - 1)) % mod;
}
if (s[l] != '(' && s[r] != ')') {
ret = (ret - call(l + 1, r - 1) + mod) % mod;
}
if (s[l] != ')' && s[r] != '(') {
ret =
((ret + call(l + 1, r - 1) % mod) + bigmod(2, pref[r - 1] - pref[l])) %
mod;
}
return dp[l][r] = ret;
}
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s;
int n = s.size();
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; ++i) {
pref[i] = (s[i] == '?');
if (i) {
pref[i] = pref[i - 1] + pref[i];
}
}
cout << call(0, n - 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2,Ofast,inline,unroll-all-loops,-ffast-math")
using namespace std;
const int mod = 119 << 23 | 1;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int MOD = 119 << 23 | 1;
int dp[2020][2020];
int P[2020];
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
string s;
cin >> s;
int n = s.length();
for (int i = 0; i < n; i++) {
P[i + 1] = P[i];
P[i + 1] += (s[i] == '?');
}
for (int Len = 2; Len < n + 1; Len++) {
for (int l = 0; l < n - Len + 1; l++) {
int r = l + Len - 1;
if (s[l] != '(') {
(dp[l][r] += dp[l + 1][r]) %= mod;
}
if (s[r] != ')') {
(dp[l][r] += dp[l][r - 1]) %= mod;
}
if (s[l] != '(' && s[r] != ')') {
((dp[l][r] -= dp[l + 1][r - 1]) += mod) %= mod;
}
if (s[l] != ')' && s[r] != '(') {
(dp[l][r] += dp[l + 1][r - 1]) %= mod;
(dp[l][r] += powmod(2, P[r] - P[l + 1])) %= mod;
}
}
}
cout << dp[0][n - 1];
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 2e3 + 7;
const long long mod = 998244353;
using namespace std;
char s[maxn];
long long dp[maxn][maxn];
long long sum[maxn];
long long qpow(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans *= x, ans %= mod;
y >>= 1;
x *= x;
x %= mod;
}
return (ans + mod) % mod;
}
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + (s[i] == '?');
for (int len = 2; len <= n; ++len) {
for (int i = 1, j = i + len - 1; j <= n; ++i, ++j) {
if (s[i] != '(') dp[i][j] = (dp[i][j] + dp[i + 1][j]) % mod;
if (s[j] != ')') dp[i][j] = (dp[i][j] + dp[i][j - 1]) % mod;
if (s[i] != '(' && s[j] != ')')
dp[i][j] = (dp[i][j] - dp[i + 1][j - 1] + mod) % mod;
if (s[i] != ')' && s[j] != '(')
dp[i][j] =
(dp[i][j] + dp[i + 1][j - 1] + qpow(2ll, sum[j - 1] - sum[i])) %
mod;
}
}
printf("%lld\n", dp[1][n]);
}
|
#include <bits/stdc++.h>
const int mod = 998244353;
using namespace std;
char s[3000];
int dp1[3000][3000], dp2[3000][3000];
void sol() {
memset(dp2, 0, sizeof(dp2));
memset(dp1, 0, sizeof(dp1));
int n = strlen(s + 1);
dp1[0][0] = 1;
dp2[n + 1][0] = 1;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= i; ++j) {
if (s[i] == '(') {
if (j) dp1[i][j] = (dp1[i][j] + dp1[i - 1][j - 1]) % mod;
} else if (s[i] == ')') {
dp1[i][j] = (dp1[i][j] + dp1[i - 1][j]) % mod;
} else {
dp1[i][j] = (dp1[i][j] + dp1[i - 1][j]) % mod;
if (j) {
dp1[i][j] = (dp1[i][j] + dp1[i - 1][j - 1]) % mod;
}
}
}
}
for (int i = n; i > 0; --i) {
for (int j = 0; j <= n - i + 1; ++j) {
if (s[i] == ')') {
if (j) dp2[i][j] = (dp2[i][j] + dp2[i + 1][j - 1]) % mod;
} else if (s[i] == '(') {
dp2[i][j] = (dp2[i][j] + dp2[i + 1][j]) % mod;
} else {
dp2[i][j] = (dp2[i][j] + dp2[i + 1][j]) % mod;
if (j) dp2[i][j] = (dp2[i][j] + dp2[i + 1][j - 1]) % mod;
}
}
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= (i, n - i); ++j) {
ans = (ans + ((1ll * j * dp1[i][j]) % mod) * dp2[i + 1][j]) % mod;
}
}
cout << ans << endl;
}
int main() {
cin >> s + 1;
sol();
}
|
#include <bits/stdc++.h>
const long long mod = 1e8 + 0;
const long long modd = 998244353;
const long long maxn = 2e3 + 10;
const double eps = 1e-8;
using namespace std;
char s[maxn];
int g[maxn][maxn], f[maxn][maxn];
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 0; i <= n + 1; i++) {
if (s[i] == '(') break;
f[i][0] = 1;
}
for (int i = n + 1; i >= 1; i--) {
if (s[i] == ')') break;
g[i][0] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++) {
if (s[i] == '(')
f[i][j] = f[i - 1][j - 1];
else if (s[i] == ')')
f[i][j] = f[i - 1][j];
else
f[i][j] = (f[i - 1][j] + f[i - 1][j - 1]) % modd;
}
for (int i = n; i >= 1; i--)
for (int j = 1; j <= n - i + 1; j++) {
if (s[i] == ')')
g[i][j] = g[i + 1][j - 1];
else if (s[i] == '(')
g[i][j] = g[i + 1][j];
else
g[i][j] = (g[i + 1][j] + g[i + 1][j - 1]) % modd;
}
int ans = 0;
for (int i = 1; i < n; i++)
for (int j = 1; j <= min(i, n - i); j++) {
ans += 1ll * f[i][j] * g[i + 1][j] % modd * j % modd;
ans %= modd;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
long long f[2001], dp[2001][2001], m = 998244353;
long long fun(long long i, long long j) {
if (i == 0)
return (f[j]);
else
return (f[j] - f[i - 1]);
}
long long fpow(long long a, long long p) {
if (p == 0) return (1);
long long b = fpow(a, p / 2);
if (p % 2 == 0)
return ((b * b) % m);
else
return ((((b * b) % m) * a) % m);
}
int main() {
string s;
cin >> s;
if (s[0] == '?') f[0] = 1;
for (long long i = 1; i < s.length(); i++) {
if (s[i] == '?') f[i] += 1;
f[i] += f[i - 1];
}
for (long long i = 2; i <= s.length(); i++) {
for (long long j = 0; j <= (s.length() - i); j++) {
if (s[j] != '(')
dp[j][j + i - 1] = (dp[j][j + i - 1] + dp[j + 1][j + i - 1]) % m;
if (s[j + i - 1] != ')')
dp[j][j + i - 1] = (dp[j][j + i - 1] + dp[j][j + i - 2]) % m;
if ((s[j] != '(') && (s[j + i - 1] != ')'))
dp[j][j + i - 1] = (dp[j][j + i - 1] - dp[j + 1][j + i - 2] + m) % m;
if ((s[j] != ')') && (s[j + i - 1] != '('))
dp[j][j + i - 1] = (dp[j][j + i - 1] + dp[j + 1][j + i - 2] +
(long long)fpow(2, fun(j + 1, j + i - 2))) %
m;
}
}
cout << dp[0][s.length() - 1];
}
|
#include <bits/stdc++.h>
int64_t kk = 998244353;
std::vector<bool> pos(char c) {
std::vector<bool> res(2, false);
if (c == '(' || c == '?') res[0] = true;
if (c == ')' || c == '?') res[1] = true;
return res;
}
int main() {
std::string s;
std::cin >> s;
std::vector<std::vector<int64_t>> dp(s.size() + 1,
std::vector<int64_t>(s.size() + 1, 0));
auto dp_count = dp;
for (int i = 0; i <= s.size(); ++i) dp_count[i][i] = 1;
for (int len = 1; len <= s.size(); ++len) {
for (int beg = 0; beg + len <= s.size(); ++beg) {
dp_count[beg][beg + len] = dp_count[beg + 1][beg + len];
if (s[beg] == '?') {
dp_count[beg][beg + len] *= 2;
dp_count[beg][beg + len] %= kk;
}
}
}
for (int len = 1; len <= s.size(); ++len) {
for (int beg = 0; beg + len <= s.size(); ++beg) {
auto beg_ = pos(s[beg]), last_ = pos(s[beg + len - 1]);
int64_t& ans = dp[beg][beg + len];
if (beg_[1]) {
ans += dp[beg + 1][beg + len];
ans %= kk;
}
if (last_[0]) {
ans += dp[beg][beg + len - 1];
ans %= kk;
}
if (len != 1 && beg_[1] && last_[0]) {
ans -= dp[beg + 1][beg + len - 1];
if (ans < 0) ans += kk;
}
if (len != 1 && beg_[0] && last_[1]) {
ans += dp[beg + 1][beg + len - 1];
ans %= kk;
ans += dp_count[beg + 1][beg + len - 1];
ans %= kk;
}
}
}
std::cout << dp[0][s.size()];
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long Sn;
char S[2020];
long long dp[2020][2020];
long long qn[2020], p2[2020];
long long i, j, k, ans;
int main() {
scanf("%s", S);
Sn = strlen(S);
p2[0] = 1;
for (i = 0; i < Sn; i++) {
qn[i + 1] = qn[i] + (S[i] == '?');
p2[i + 1] = p2[i] * 2 % (long long)998244353;
}
for (i = 1; i < Sn; i++) {
if (S[i - 1] != ')' && S[i] != '(') {
dp[i - 1][i] = 1;
}
}
for (i = 2; i < Sn; i++) {
for (j = i; j < Sn; j++) {
long long l = j - i, r = j;
if (S[l] != '(') dp[l][r] += dp[l + 1][r];
if (S[r] != ')') dp[l][r] += dp[l][r - 1];
if (S[l] != '(' && S[r] != ')') dp[l][r] -= dp[l + 1][r - 1];
if (S[l] != ')' && S[r] != '(')
dp[l][r] += dp[l + 1][r - 1] + p2[qn[r] - qn[l + 1]];
dp[l][r] %= (long long)998244353;
}
}
printf("%lld", dp[0][Sn - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long inf = 1LL << 50;
const int N = 2000;
long long dp[N][N] = {0};
long long powers[N + 5] = {0};
int sums[N + 5] = {0};
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin.exceptions(cin.failbit);
string str;
cin >> str;
int n = str.size();
int last = 0;
powers[0] = 1;
for (int i = 0; i < n; i++) {
dp[i][i] = 0;
powers[i + 1] = (powers[i] * 2) % mod;
sums[i] = last + (str[i] == '?');
last = sums[i];
}
sums[n] = last;
for (int d = 1; d < n; d++) {
for (int l = 0; l < n - d; l++) {
int r = l + d;
if (str[l] != '(') {
dp[l][r] += (dp[l][r] + dp[l + 1][r]) % mod;
}
if (str[r] != ')') {
dp[l][r] = (dp[l][r] + dp[l][r - 1]) % mod;
}
if (str[l] != '(' && str[r] != ')') {
dp[l][r] = (dp[l][r] - dp[l + 1][r - 1] + mod) % mod;
}
if (str[l] != ')' && str[r] != '(') {
dp[l][r] =
(dp[l][r] + dp[l + 1][r - 1] + powers[sums[r - 1] - sums[l]]) % mod;
}
}
}
cout << dp[0][n - 1] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
using ll = long long;
ll mod = 998244353;
string s;
int n;
ll dp[maxn][maxn];
int pref[maxn];
ll bigmod(ll a, ll b) {
ll ret = 1;
while (b) {
if (b & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ret;
}
ll call(int l, int r) {
if (l >= r) return 0;
if (dp[l][r] != -1) return dp[l][r];
ll ret = 0;
if (s[l] != '(') {
ret = (ret + call(l + 1, r)) % mod;
}
if (s[r] != ')') {
ret = (ret + call(l, r - 1)) % mod;
}
if (s[l] != '(' && s[r] != ')') {
ret = (ret - call(l + 1, r - 1) + mod) % mod;
}
if (s[l] != ')' && s[r] != '(') {
ret =
((ret + call(l + 1, r - 1) % mod) + bigmod(2, pref[r - 1] - pref[l])) %
mod;
}
return dp[l][r] = ret;
}
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s;
int n = s.size();
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; ++i) {
pref[i] = (s[i] == '?');
if (i) {
pref[i] = pref[i - 1] + pref[i];
}
}
cout << call(0, n - 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2050;
const int inf = 0x3f3f3f3f;
const int mod = 998244353;
long long fpow(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long dp[maxn][maxn], a[maxn];
char s[maxn];
int main() {
int i, j, k, m, n;
scanf("%s", s + 1);
n = strlen(s + 1);
for (i = 1; i <= n; i++) a[i] = a[i - 1] + (s[i] == '?');
for (k = 2; k <= n; k++)
for (i = 1; i + k - 1 <= n; i++) {
j = i + k - 1;
dp[i][j] = (dp[i][j] + (s[i] != '(' ? dp[i + 1][j] : 0)) % mod;
dp[i][j] = (dp[i][j] + (s[j] != ')' ? dp[i][j - 1] : 0)) % mod;
dp[i][j] = (dp[i][j] + mod -
(s[i] != '(' && s[j] != ')' ? dp[i + 1][j - 1] : 0)) %
mod;
dp[i][j] =
(dp[i][j] + (s[i] != ')' && s[j] != '('
? (dp[i + 1][j - 1] + fpow(2, a[j - 1] - a[i])) % mod
: 0)) %
mod;
}
cout << dp[1][n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
int n, A[2001];
long long F[2001][2001][2][2], res = 0, rev2;
string s;
void add(long long &x, long long y) { x = (x + y) % MOD; }
long long cal(long long x, long long y) {
if (y == 0) return 1;
if (y == 1) return x % MOD;
long long t = cal(x, y / 2);
t = (t * t) % MOD;
return y % 2 == 0 ? t : (t * x) % MOD;
}
void update(int l, int r, int i, int j) {
if (i == 1) {
if (A[l + 1] >= 0)
add(F[l + 1][r][A[l + 1]][j], F[l][r][i][j]);
else {
add(F[l + 1][r][0][j], (F[l][r][i][j] * rev2) % MOD);
add(F[l + 1][r][1][j], (F[l][r][i][j] * rev2) % MOD);
}
} else if (j == 0) {
if (A[r - 1] >= 0)
add(F[l][r - 1][i][A[r - 1]], F[l][r][i][j]);
else {
add(F[l][r - 1][i][0], (F[l][r][i][j] * rev2) % MOD);
add(F[l][r - 1][i][1], (F[l][r][i][j] * rev2) % MOD);
}
} else {
add(res, F[l][r][i][j]);
if (l + 1 >= r) return;
long long z =
((A[l + 1] == -1 ? rev2 : 1) * (A[r - 1] == -1 ? rev2 : 1)) % MOD;
for (int x = 0; x <= 1; ++x)
if (A[l + 1] == x || A[l + 1] == -1)
for (int y = 0; y <= 1; ++y)
if (A[r - 1] == y || A[r - 1] == -1) {
add(F[l + 1][r - 1][x][y], (F[l][r][i][j] * z) % MOD);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
cin >> s;
n = s.size();
rev2 = cal(2, MOD - 2);
long long total = 1;
for (int i = 1; i <= n; ++i) {
if (s[i - 1] == '?') {
A[i] = -1;
total = (total * 2) % MOD;
} else if (s[i - 1] == '(')
A[i] = 0;
else
A[i] = 1;
}
long long t = ((A[1] == -1 ? rev2 : 1) * (A[n] == -1 ? rev2 : 1)) % MOD;
for (int i = 0; i <= 1; ++i)
if (A[1] == i || A[1] == -1)
for (int j = 0; j <= 1; ++j)
if (A[n] == j || A[n] == -1) {
F[1][n][i][j] = (total * t) % MOD;
}
for (int l = 1; l <= n; ++l)
for (int r = n; r > l; --r)
for (int i = 0; i <= 1; ++i)
for (int j = 0; j <= 1; ++j) update(l, r, i, j);
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
const int mod = 998244353;
long long dp[N][N];
char s[N];
int sum[N];
long long quick_pow(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y >>= 1;
}
return res;
}
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + (s[i] == '?');
}
for (int len = 1; len < n; len++) {
for (int i = 1; i <= n; i++) {
int j = i + len;
if (j > n) break;
long long &v = dp[i][j];
if (s[i] != '(') v += dp[i + 1][j];
if (s[j] != ')') v += dp[i][j - 1];
if (s[i] != '(' && s[j] != ')') v = (v - dp[i + 1][j - 1] + mod) % mod;
if (s[i] != ')' && s[j] != '(')
v += dp[i + 1][j - 1] + quick_pow(2, sum[j - 1] - sum[i]);
v %= mod;
}
}
printf("%lld\n", dp[1][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353;
const int N = 2003;
long long dp[N][N], fre[N];
long long power(long long b, long long p) {
if (p == 0) return 1;
if (p & 1) return (b * power((b * b) % M, p / 2)) % M;
return (power((b * b) % M, p / 2)) % M;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.length();
for (int i = 0; i < n; i++) {
if (i) fre[i] += fre[i - 1];
fre[i] += (s[i] == '?');
}
for (int len = 2; len <= n; len++) {
for (int i = 0; i + len - 1 < n; i++) {
int j = i + len - 1;
if (s[i] != '(') dp[i][j] = (dp[i][j] + dp[i + 1][j]) % M;
if (s[j] != ')') dp[i][j] = (dp[i][j] + dp[i][j - 1]) % M;
if (s[i] != '(' && s[j] != ')')
dp[i][j] = (dp[i][j] + M - dp[i + 1][j - 1]) % M;
if (s[i] != ')' && s[j] != '(') {
dp[i][j] = (dp[i][j] + dp[i + 1][j - 1]) % M;
long long val = power(2, fre[j - 1] - fre[i]);
dp[i][j] = (dp[i][j] + val) % M;
}
}
}
cout << dp[0][n - 1];
}
|
#include <bits/stdc++.h>
const int XN = 2e3 + 11, P = 998244353;
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
static char s[XN];
static int c[XN][XN];
std::cin >> (s + 1);
int n = strlen(s + 1);
c[0][0] = 1;
for (int i = 1; i <= n; ++i) {
c[i][0] = 1;
for (int j = 1; j <= i; ++j) c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % P;
}
int Ans = 0;
for (int i = 1; i < n; ++i) {
int cl = 0, cr = 0, q1 = 0, q2 = 0;
for (int j = 1; j <= i; ++j)
if (s[j] == '(') {
cl++;
} else if (s[j] == '?')
q1++;
for (int j = i + 1; j <= n; ++j)
if (s[j] == ')') {
cr++;
} else if (s[j] == '?')
q2++;
for (int cnt = std::max(cl, cr); cnt <= std::min(i, n - i); ++cnt)
if (cnt - cl <= q1 && cnt - cr <= q2) {
(Ans += 1LL * cnt * c[q1][cnt - cl] % P * c[q2][cnt - cr] % P) %= P;
}
}
std::cout << Ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
const int M = 998244353;
char str[N];
long long l_k[N];
long long r_k[N];
long long l_w[N];
long long r_w[N];
long long f[N][N];
long long ans = 0;
long long get_ans(long long u, long long a, long long b, long long c,
long long d) {
if (u - c > d || u < c) return 0;
int h = u - c;
return u * f[d][h] % M * f[b][a] % M;
}
int main() {
f[0][0] = 1;
for (int i = 1; i < N; i++) {
for (int j = 0; j < N; j++) {
f[i][j] = (f[i - 1][j - 1] + f[i - 1][j]) % M;
}
}
cin >> (str + 1);
int len = strlen(str + 1);
for (int i = 1; i <= len; i++) {
if (str[i] == '(') {
l_k[i] = l_k[i - 1] + 1;
} else {
l_k[i] = l_k[i - 1];
}
if (str[i] == '?') {
l_w[i] = l_w[i - 1] + 1;
} else {
l_w[i] = l_w[i - 1];
}
}
for (int i = len; i >= 1; i--) {
if (str[i] == ')') {
r_k[i] = r_k[i + 1] + 1;
} else {
r_k[i] = r_k[i + 1];
}
if (str[i] == '?') {
r_w[i] = r_w[i + 1] + 1;
} else {
r_w[i] = r_w[i + 1];
}
}
for (int i = 1; i <= len; i++) {
if (str[i] == '(') {
for (int j = l_k[i]; j <= (l_k[i] + l_w[i]); j++) {
ans = (ans + get_ans(j, j - l_k[i], l_w[i], r_k[i], r_w[i])) % M;
}
} else if (str[i] == ')') {
for (int j = l_k[i]; j <= (l_k[i] + l_w[i]); j++) {
ans =
(ans + get_ans(j, j - l_k[i], l_w[i], r_k[i + 1], r_w[i + 1])) % M;
}
} else {
for (int j = l_k[i] + 1; j <= (l_k[i] + l_w[i - 1] + 1); j++) {
ans = (ans +
get_ans(j, j - (l_k[i] + 1), l_w[i - 1], r_k[i], r_w[i + 1])) %
M;
}
for (int j = l_k[i]; j <= (l_k[i] + l_w[i - 1]); j++) {
ans = (ans + get_ans(j, j - (l_k[i]), l_w[i - 1], r_k[i], r_w[i + 1])) %
M;
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2006;
const int mod = 998244353;
int add(int a, int b) {
a += b;
if (a >= mod) a -= mod;
return a;
}
int mul(int a, int b) {
a = 1ll * a * b % mod;
return a;
}
int sub(int a, int b) {
a -= b;
if (a < 0) a += mod;
return a;
}
int f[maxn][maxn], g[maxn][maxn];
char s[maxn];
int n;
int C[maxn][maxn];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 0; i <= n; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) C[i][j] = add(C[i - 1][j], C[i - 1][j - 1]);
}
int cnt = 0, p = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '?')
cnt++;
else if (s[i] == '(')
p++;
for (int j = p; j <= cnt + p; j++) f[i][j] = C[cnt][j - p];
}
cnt = 0;
p = 0;
for (int i = n; i > 0; i--) {
if (s[i] == '?')
cnt++;
else if (s[i] == ')')
p++;
for (int j = p; j <= cnt + p; j++) g[i][j] = C[cnt][j - p];
}
int ans = 0;
for (int i = 1; i < n; i++) {
for (int j = 1; j <= n; j++)
ans = add(ans, mul(j, mul(f[i][j], g[i + 1][j])));
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 5;
const long long mod = 998244353;
long long dp[maxn][maxn], pfx[maxn], pow2[maxn] = {1};
char s[maxn];
int main() {
cin >> (s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++)
pfx[i] = pfx[i - 1] + (s[i] == '?'), pow2[i] = (pow2[i - 1] << 1) % mod;
for (int i = 2; i <= n; i++)
for (int l = 1, r = l + i - 1; r <= n; l++, r++) {
long long &x = dp[l][r], p = pow2[pfx[r - 1] - pfx[l]];
x = dp[l + 1][r - 1];
if (s[l] == ')') x = dp[l + 1][r];
if (s[r] == '(') x = dp[l][r - 1];
if (s[l] == '(' && s[r] == ')') x = dp[l + 1][r - 1] + p;
if (s[l] == '?' && s[r] == ')') x = dp[l + 1][r] + dp[l + 1][r - 1] + p;
if (s[l] == '(' && s[r] == '?') x = dp[l][r - 1] + dp[l + 1][r - 1] + p;
if (s[l] == '?' && s[r] == '?') x = dp[l][r - 1] + dp[l + 1][r] + p;
x %= mod;
}
cout << dp[1][n] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 10;
const int mod = 998244353;
long long dp[N][N];
int sum[N];
char s[N];
int js(int l, int r) { return sum[r] - sum[l - 1]; }
long long p[N];
int main() {
p[0] = 1;
for (int i = 1; i < N; i++) p[i] = (p[i - 1] * 2) % mod;
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
if (s[i] == '?')
sum[i] = sum[i - 1] + 1;
else
sum[i] = sum[i - 1];
}
for (int i = 1; i <= n; i++) dp[i][i] = 0;
for (int len = 2; len <= n; len++) {
for (int l = 1; l <= n + 1 - len; l++) {
int r = len + l - 1;
if (s[l] != '(') dp[l][r] = (dp[l][r] + dp[l + 1][r]) % mod;
if (s[r] != ')') dp[l][r] = (dp[l][r] + dp[l][r - 1]) % mod;
if (s[l] != '(' && s[r] != ')')
dp[l][r] = (dp[l][r] - dp[l + 1][r - 1] + mod) % mod;
if (s[l] != ')' && s[r] != '(')
dp[l][r] = (dp[l][r] + dp[l + 1][r - 1] + p[js(l + 1, r - 1)]) % mod;
}
}
printf("%lld\n", dp[1][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n;
int mypow[2005];
char s[2005];
int sum[2005];
int dp[2005][2005];
int dfs(int nl, int nr) {
if (nl >= nr) return dp[nl][nr] = 0;
if (dp[nl][nr] != -1) return dp[nl][nr];
dp[nl][nr] = 0;
if (s[nl] != '(') dp[nl][nr] = (dp[nl][nr] + dfs(nl + 1, nr)) % mod;
if (s[nr] != ')') dp[nl][nr] = (dp[nl][nr] + dfs(nl, nr - 1)) % mod;
if (s[nl] != '(' && s[nr] != ')')
dp[nl][nr] = (dp[nl][nr] + mod - dfs(nl + 1, nr - 1)) % mod;
if (s[nl] != ')' && s[nr] != '(')
dp[nl][nr] =
(dp[nl][nr] +
((dfs(nl + 1, nr - 1) + (mypow[sum[nr - 1] - sum[nl]])) % mod)) %
mod;
return dp[nl][nr];
}
int main() {
mypow[0] = 1;
for (int i = 1; i <= 2000; i++) mypow[i] = (2ll * mypow[i - 1]) % mod;
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) sum[i] = (sum[i - 1] + (s[i] == '?'));
memset(dp, -1, sizeof(dp));
printf("%d\n", dfs(1, n));
}
|
#include <bits/stdc++.h>
using namespace std;
const long MOD = 998244353;
string s;
long n, cnt[2005], f[2005][2005];
long long power(long long x, long long n) {
if (n == 0) return 1;
if (n == 1) return x;
long long t = power(x, n >> 1);
t = (t * t) % MOD;
if (n & 1) t = (t * x) % MOD;
return t;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.size();
s = ' ' + s;
for (long i = 1; i <= n; i++) {
cnt[i] = cnt[i - 1] + (s[i] == '?');
}
for (long kc = 1; kc < n; kc++) {
for (long i = 1; i <= n - kc; i++) {
long j = i + kc;
if (s[i] != '(') {
f[i][j] = (f[i][j] + f[i + 1][j]) % MOD;
}
if (s[j] != ')') {
f[i][j] = (f[i][j] + f[i][j - 1]) % MOD;
}
if (s[i] != '(' && s[j] != ')') {
f[i][j] = (f[i][j] - f[i + 1][j - 1] + MOD) % MOD;
}
if (s[i] != ')' && s[j] != '(') {
f[i][j] = (f[i][j] + f[i + 1][j - 1]) % MOD;
f[i][j] = (f[i][j] + power(2, cnt[j - 1] - cnt[i])) % MOD;
}
}
}
cout << f[1][n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool *Seive(long long n, bool *p) {
memset(p, 1, sizeof(p));
long long i, j;
for (i = 2; i <= n; i++) {
if (p[i] == 1)
for (j = i * i; j <= n; j += i) {
p[j] = 0;
}
}
p[1] = 0;
return p;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long modexp(long long x, long long y) {
if (y == 0)
return 1;
else if (y % 2 == 0) {
return modexp((x * x) % (long long)998244353, y / 2);
} else {
return (x * modexp((x * x) % (long long)998244353, (y - 1) / 2)) %
(long long)998244353;
}
}
long long fact(long long n) {
long long f = 1;
for (long long i = 2; i <= n; i++) {
f = (i % (long long)998244353 * f % (long long)998244353) %
(long long)998244353;
}
return f;
}
long long nCr(long long n, long long r) {
return (fact(n) * modexp((fact(n - r) * fact(r)) % (long long)998244353,
(long long)998244353 - 2)) %
(long long)998244353;
}
void showlist(list<int64_t> g) {
list<int64_t>::iterator it;
for (it = g.begin(); it != g.end(); ++it) cout << *it << " ";
cout << '\n';
}
void swap(int64_t &a, int64_t &b) {
int64_t t;
t = a;
a = b;
b = t;
}
void build(int64_t l, int64_t r, int64_t i) {
if (l == r) {
} else {
int64_t mid = (l + r) / 2;
build(l, mid, 2 * i);
build(mid + 1, r, 2 * i + 1);
}
}
void update(int64_t p, int64_t l, int64_t r, int64_t i) {
if (l == r) {
} else {
int64_t mid = (l + r) / 2;
if (p <= mid) {
update(p, l, mid, 2 * i);
} else {
update(p, mid + 1, r, 2 * i + 1);
}
}
}
void query(int64_t y, int64_t z, int64_t l, int64_t r, int64_t i) {
if (y <= l && z >= r) {
} else {
int64_t mid = (l + r) / 2;
if (z <= mid) {
query(y, z, l, mid, 2 * i);
} else if (y > mid) {
query(y, z, mid + 1, r, 2 * i + 1);
} else {
query(y, z, l, mid, 2 * i);
query(y, z, mid + 1, r, 2 * i + 1);
}
}
}
void make_set(int64_t v) {}
int64_t find_set(int64_t v) {}
void union_sets(int64_t a, int64_t b) {}
int64_t dfs(int64_t r, int64_t *d, int64_t &e, int64_t l,
vector<vector<int64_t>> &adj, int64_t *v, int64_t a[][2]) {
a[r][1] = e + d[r];
e = a[r][1];
l = e;
int64_t j = 0;
for (int64_t i = 0; i < adj[r].size(); i++) {
if (v[adj[r][i]] == 0) {
v[adj[r][i]] = 1;
a[adj[r][i]][0] = l - (j + 1);
dfs(adj[r][i], d, e, l, adj, v, a);
j++;
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int64_t n, k, i, j, w;
cin >> n >> k;
string s;
set<string> g;
for (i = 0; i < n; i++) {
cin >> s;
g.insert(s);
}
vector<string> v;
for (auto it = g.begin(); it != g.end(); it++) {
v.push_back(*it);
}
int64_t sum = 0;
for (i = 0; i < n - 2; i++) {
string q;
q = v[i];
set<string> t;
for (j = i + 1; j < n; j++) {
t.insert(v[j]);
}
for (j = i + 1; j < n; j++) {
string z;
z = v[j];
string d;
for (w = 0; w < k; w++) {
if (q[w] == z[w]) {
d += q[w];
} else {
char a;
if (q[w] == 'S' && z[w] == 'T' || z[w] == 'S' && q[w] == 'T') {
a = 'E';
} else if (q[w] == 'E' && z[w] == 'T' || z[w] == 'E' && q[w] == 'T') {
a = 'S';
} else if (q[w] == 'E' && z[w] == 'S' || z[w] == 'E' && q[w] == 'S') {
a = 'T';
}
d += a;
}
}
if (t.find(d) != t.end()) {
sum++;
t.erase(d);
t.erase(z);
} else {
t.erase(z);
}
}
}
cout << sum << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long powp[35];
set<long long> s;
vector<int> mas[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
powp[0] = 1;
for (int i = 1; i < 32; i++) {
powp[i] = powp[i - 1] * 3;
}
long long n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
long long mask = 0;
for (int j = 0; j < k; j++) {
char a;
cin >> a;
long long gg = 0;
if (a == 'E') {
gg = 1;
}
if (a == 'T') {
gg = 2;
}
mask += gg * powp[j];
mas[i].push_back(gg);
}
s.insert(mask);
}
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
long long mask = 0;
for (int u = 0; u < k; u++) {
if (mas[i][u] == mas[j][u]) {
mask += mas[i][u] * powp[u];
} else {
mask += (3 - mas[i][u] - mas[j][u]) * powp[u];
}
}
ans += (s.count(mask));
}
}
cout << ans / 3;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int t, n;
cin >> t >> n;
int temp = t;
vector<string> A;
map<string, int> keep;
while (t--) {
string s;
cin >> s;
keep[s]++;
A.push_back(s);
}
int ans = 0;
for (int i = 1; i < temp; i++) {
for (int j = 0; j < i; j++) {
string one = A[i];
string two = A[j];
string newstring = "";
for (int k = 0; k < n; k++) {
if (one[k] == two[k]) {
newstring += one[k];
} else {
if ((one[k] == 'S' && two[k] == 'T') ||
(two[k] == 'S' && one[k] == 'T')) {
newstring += 'E';
} else if ((one[k] == 'E' && two[k] == 'T') ||
(two[k] == 'E' && one[k] == 'T')) {
newstring += 'S';
} else
newstring += 'T';
}
}
if (keep.find(newstring) != keep.end()) {
ans++;
}
}
}
cout << ans / 3 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char left(char a, char b) {
if (a > b) swap(a, b);
pair<char, char> s = make_pair(a, b);
if (s == make_pair('E', 'S')) return 'T';
if (s == make_pair('E', 'T')) return 'S';
if (s == make_pair('S', 'T')) return 'E';
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
map<string, long long> cnt;
long long n, k;
cin >> n >> k;
string arr[n];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
for (long long i = 1; i < n; i++) {
cnt[arr[i]]++;
}
long long ans = 0;
for (long long i = 1; i < n; i++) {
cnt[arr[i]]--;
for (long long j = 0; j < i; j++) {
string f = "";
for (long long l = 0; l < k; l++) {
if (arr[i][l] == arr[j][l])
f += arr[i][l];
else
f += left(arr[i][l], arr[j][l]);
}
ans += cnt[f];
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
void solve() {
int n, k;
cin >> n >> k;
string A[n];
map<string, int> m;
for (int i = (0); i < (n); i++) {
cin >> A[i];
m[A[i]]++;
}
long long ans = 0;
sort(A, A + n);
set<string> st;
for (int i = (0); i < (n - 2); i++) {
for (int j = (i + 1); j < (n - 1); j++) {
string s(k, '.');
for (int z = (0); z < (k); z++) {
if (A[i][z] == A[j][z]) {
s[z] = A[i][z];
} else {
int tmp = A[i][z] + A[j][z];
if (tmp == 152) {
s[z] = 'T';
} else if (tmp == 153) {
s[z] = 'S';
} else {
s[z] = 'E';
}
}
}
string tmp = A[i] + A[j] + s;
if (s.compare(A[i]) >= 0 && s.compare(A[j]) >= 0 &&
st.find(tmp) == st.end()) {
ans += m[s];
if (s.compare(A[i]) == 0) {
ans--;
}
if (s.compare(A[j]) == 0) {
ans--;
}
st.insert(tmp);
}
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1501;
string S[maxn];
set<string> T;
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> S[i];
T.insert(S[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string s = "";
for (int l = 0; l < k; l++) {
if (S[i][l] == S[j][l])
s += S[i][l];
else if (S[i][l] != 'S' && S[j][l] != 'S')
s += 'S';
else if (S[i][l] != 'E' && S[j][l] != 'E')
s += 'E';
else
s += 'T';
}
if (T.find(s) != T.end()) ans++;
}
}
cout << ans / 3;
}
|
#include <bits/stdc++.h>
using namespace std;
char c[3] = {'S', 'E', 'T'};
string a[1505];
long long aa[1505];
map<long long, long long> s;
int main() {
ios::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
long long ans = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
long long tt = 1, temp = 0;
;
for (long long j = m - 1; j >= 0; j--) {
if (a[i][j] == 'E') {
temp += tt;
} else if (a[i][j] == 'T') {
temp += tt * 2;
}
tt *= 3;
}
aa[i] = temp;
s[temp] += 1;
}
for (long long i = 0; i < n - 2; i++) {
s[aa[i]] -= 1;
for (long long j = i + 1; j < n - 1; j++) {
s[aa[j]] -= 1;
char temp[m + 5];
for (long long t = 0; t < m; t++) {
if (a[i][t] == a[j][t]) {
temp[t] = a[i][t];
} else {
for (long long k = 0; k < 3; k++) {
if (c[k] != a[i][t] && c[k] != a[j][t]) {
temp[t] = c[k];
break;
}
}
}
}
long long tt = 1, tp = 0;
for (long long t = m - 1; t >= 0; t--) {
if (temp[t] == 'E') {
tp += tt;
} else if (temp[t] == 'T') {
tp += tt * 2;
}
tt *= 3;
}
ans += s[tp];
}
for (long long j = i + 1; j < n - 1; j++) {
s[aa[j]] += 1;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<string> s(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
}
sort(s.begin(), s.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string st = "";
for (int m = 0; m < k; m++) {
if (s[i][m] == s[j][m]) {
st = st + s[i][m];
} else if (s[i][m] == 'S' && s[j][m] == 'E') {
st += 'T';
} else if (s[i][m] == 'S' && s[j][m] == 'T') {
st += 'E';
} else if (s[i][m] == 'E' && s[j][m] == 'S') {
st += 'T';
} else if (s[i][m] == 'E' && s[j][m] == 'T') {
st += 'S';
} else if (s[i][m] == 'T' && s[j][m] == 'S') {
st += 'E';
} else if (s[i][m] == 'T' && s[j][m] == 'E') {
st += 'S';
}
}
if (binary_search(s.begin(), s.end(), st)) ans++;
}
}
cout << ans / 3;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
long long max(long long a, long long b) {
if (a < b) return b;
return a;
}
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
long long X[] = {-1, 1, 0, 0};
long long Y[] = {0, 0, -1, 1};
long long XX[] = {-1, 1, 0, 0, -1, 1, -1, 1};
long long YY[] = {0, 0, -1, 1, -1, 1, 1, -1};
void solve() {
unordered_map<string, vector<long long> > m;
long long n, k;
cin >> n >> k;
string s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
m[s[i]].push_back(i);
}
if (n <= 2) {
cout << 0;
return;
}
long long ans = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
string req = "";
for (int q = 0; q < k; q++) {
if (s[i][q] == s[j][q]) {
req.insert(req.end(), s[i][q]);
} else {
char a = s[i][q], b = s[j][q];
if (a != 'S' && b != 'S')
req.insert(req.end(), 'S');
else if (a != 'E' && b != 'E')
req.insert(req.end(), 'E');
else if (a != 'T' && b != 'T')
req.insert(req.end(), 'T');
}
}
vector<long long> vec = m[req];
for (int q = 0; q < vec.size(); q++) {
long long ind = vec[q];
if (ind > j) ans++;
}
}
}
cout << ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<string> v(n);
map<string, int> M;
for (int i = 0; i < n; i++) {
cin >> v[i];
M[v[i]]++;
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string s;
for (int p = 0; p < k; p++) {
bool f = v[i][p] == v[j][p] ? 1 : 0;
if (f == 1) {
s.push_back(v[i][p]);
} else {
if (v[i][p] != 'S' and v[j][p] != 'S')
s.push_back('S');
else if (v[i][p] != 'E' and v[j][p] != 'E')
s.push_back('E');
else
s.push_back('T');
}
}
ans += M[s];
}
}
cout << ans / 3 << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
template <typename first, typename second>
ostream &operator<<(ostream &os, const pair<first, second> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const map<first, second> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
clock_t tStart = clock();
void faltu() { cerr << endl; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << endl;
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
long long factorial(long long n) {
long long value = 1;
for (long long i = 2; i <= n; i++) value *= i;
return value;
}
long long ncr(long long n, long long r) {
long long m = r, value = 1;
for (int i = n; m >= 1; i--, m--) value *= i;
return (value / factorial(r));
}
long long npr(long long n, long long p) {
return factorial(n) / factorial(n - p);
}
string to_upper(string a) {
for (int i = 0; i < (int)a.size(); ++i)
if (a[i] >= 'a' && a[i] <= 'z') a[i] -= 'a' - 'A';
return a;
}
string to_lower(string a) {
for (int i = 0; i < (int)a.size(); ++i)
if (a[i] >= 'A' && a[i] <= 'Z') a[i] += 'a' - 'A';
return a;
}
long long sti(string a, int base = 10) {
long long k = 0;
for (int i = 0; i < (int)a.size(); ++i) {
k *= base;
k += a[i] - '0';
}
return k;
}
string toString(long long k, int base = 10) {
if (k == 0) return "0";
string a;
while (k) {
a.push_back((k % base) + '0');
k /= base;
}
reverse(a.begin(), a.end());
return a;
}
vector<string> v;
map<string, long long> mp;
void solve() {
long long n, l;
cin >> n >> l;
string s;
for (long long i = 0; i < n; i++) {
cin >> s;
v.push_back(s);
mp[s]++;
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
string s;
for (long long k = 0; k < l; k++) {
if (v[i][k] == v[j][k]) {
s.push_back(v[i][k]);
} else {
if ((v[i][k] == 'E' && v[j][k] == 'T') ||
(v[j][k] == 'E' && v[i][k] == 'T'))
s.push_back('S');
if ((v[i][k] == 'S' && v[j][k] == 'T') ||
(v[j][k] == 'S' && v[i][k] == 'T'))
s.push_back('E');
if ((v[i][k] == 'E' && v[j][k] == 'S') ||
(v[j][k] == 'E' && v[i][k] == 'S'))
s.push_back('T');
}
}
ans += mp[s];
if (s == v[i]) ans--;
if (s == v[j]) ans--;
}
}
ans /= 3;
cout << ans << "\n";
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 500;
const long long mod = 1e9 + 7;
const long long cmod = 998244353;
const long long inf = 1LL << 61;
const int M = 1e6 + 500;
const long long int ths = 1LL << 40;
const int NN = 5e3 + 6;
void pre() { return; }
long long int dp[1505][1505];
void solve() {
long long int n, k;
cin >> n >> k;
string s[n];
unordered_map<string, long long int> ma;
long long int ans = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
ma[s[i]] = i;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string t = "";
if (dp[i][j] || dp[j][i]) continue;
for (int x = 0; x < k; x++) {
if (s[i][x] == s[j][x]) {
t += s[i][x];
} else {
set<char> ini;
if (s[i][x] == 'S' && s[j][x] == 'E')
t += 'T';
else if (s[i][x] == 'E' && s[j][x] == 'S')
t += 'T';
else if (s[i][x] == 'S' && s[j][x] == 'T')
t += 'E';
else if (s[i][x] == 'T' && s[j][x] == 'S')
t += 'E';
else if (s[i][x] == 'E' && s[j][x] == 'T')
t += 'S';
else if (s[i][x] == 'T' && s[j][x] == 'E')
t += 'S';
}
}
long long int x = -1;
if (ma.count(t)) x = ma[t];
if (x != i && x != j && x != -1) {
dp[i][j] = 1;
dp[j][i] = 1;
dp[i][x] = 1;
dp[x][i] = 1;
dp[j][x] = dp[x][j] = 1;
ans++;
}
}
}
cout << ans;
cout << '\n';
return;
}
int 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;
int n, m;
array<int, 31> a[1569];
map<array<int, 31>, int> fq;
map<char, int> yk;
array<int, 31> tmp;
int main() {
int i, j, r, ii, z = 0;
string s;
yk['S'] = 0;
yk['E'] = 1;
yk['T'] = 2;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
cin >> s;
for (j = 1; j <= m; j++) {
a[i][j] = yk[s[j - 1]];
}
}
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
for (r = 1; r <= m; r++) {
if (a[i][r] == a[j][r]) {
tmp[r] = a[i][r];
} else {
for (ii = 0; ii == a[i][r] || ii == a[j][r]; ii++)
;
tmp[r] = ii;
}
}
z += fq[tmp];
}
fq[a[i]]++;
}
printf("%d\n", z);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int get_identical(int n) { return (n * (n - 1) * (n - 2)) / 6; }
char get_third(char a, char b) {
if ((a == 'S' && b == 'E') || (a == 'E' && b == 'S'))
return 'T';
else if ((a == 'E' && b == 'T') || (a == 'T' && b == 'E'))
return 'S';
else
return 'E';
}
string get_string(string s1, string s2) {
string mystring;
for (int i = 0; i < s1.length(); i++) {
if (s1[i] == s2[i])
mystring += s1[i];
else {
mystring += get_third(s1[i], s2[i]);
}
}
return mystring;
}
int main() {
int n, k, i;
cin >> n >> k;
map<string, int> card;
vector<string> feature(n);
for (i = 0; i < n; i++) {
cin >> feature[i];
card[feature[i]]++;
}
long long int identical_set = 0, non_identical_set = 0, total_set = 0;
for (auto itr = card.begin(); itr != card.end(); ++itr) {
identical_set += get_identical(itr->second);
}
for (i = 0; i < feature.size(); i++) {
for (int j = i + 1; j < feature.size(); j++) {
if (feature[i] == feature[j]) {
continue;
} else {
string mystring = get_string(feature[i], feature[j]);
non_identical_set += card[mystring];
}
}
}
non_identical_set /= 3;
total_set = identical_set + non_identical_set;
cout << total_set;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
map<string, bool> mp;
vector<string> s(n);
string t = "SET";
map<char, long long> inv;
inv['S'] = 0;
inv['E'] = 1;
inv['T'] = 2;
for (long long i = 0; i < n; i++) {
cin >> s[i];
mp[s[i]] = true;
}
long long ans = 0;
for (long long i = 0; i < n; i++)
for (long long j = i + 1; j < n; j++) {
string u(k, '?');
for (long long l = 0; l < k; l++) {
if (s[i][l] == s[j][l]) {
u[l] = s[i][l];
} else {
u[l] = t[3 - inv[s[i][l]] - inv[s[j][l]]];
}
}
if (u != s[i] && u != s[j] && mp[u]) {
ans++;
}
}
ans /= 3;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
string s[1510];
int main() {
int n, m;
cin >> n >> m;
int ans = 0;
for (int i = 1; i <= n; i++) {
cin >> s[i];
mp[s[i]]++;
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
string aim;
for (int k = 0; k < m; k++) {
if (s[i][k] == s[j][k])
aim += s[i][k];
else
aim += 'S' + 'E' + 'T' - s[i][k] - s[j][k];
}
if (s[i] == s[j])
ans += mp[aim] - 2;
else if (mp.count(aim))
ans += mp[aim];
}
}
ans /= 3;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1515;
string s[N];
int f;
map<string, int> vis;
char Str(char x, char y) {
if (x == y)
return x;
else
return 'S' + 'E' + 'T' - x - y;
}
int judge(int x, int y) {
int i;
string a;
for (i = 0; i < f; i++) {
a += Str(s[x][i], s[y][i]);
}
return vis[a];
}
int main() {
int n, i, j, k, ans;
cin >> n >> f;
for (i = 1; i <= n; i++) {
cin >> s[i];
vis[s[i]] = i;
}
ans = 0;
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
if (judge(i, j) > j) ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long mod = 1e9 + 7;
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T> v) {
os << "(" << v.first << ", " << v.second << ")";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T> v) {
for (int i = 0; i < (int)v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<vector<T>> v) {
for (int i = 0; i < (int)v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
vector<string> s(n);
for (int i = 0; i < (int)n; ++i) cin >> s[i];
unordered_map<string, long long> mp;
for (int i = 0; i < (int)n; ++i) mp[s[i]]++;
long long res1 = 0;
for (auto x : mp) {
long long val = x.second;
res1 += val * (val - 1) * (val - 2) / 6;
}
long long res2 = 0;
for (int i = 0; i < (int)n; ++i) {
for (int j = 0; j < (int)n; ++j) {
if (i > j) continue;
if (s[i] == s[j]) continue;
string t = "";
for (int l = 0; l < (int)k; ++l) {
if (s[i][l] == 'E' && s[j][l] == 'T') t += 'S';
if (s[i][l] == 'T' && s[j][l] == 'E') t += 'S';
if (s[i][l] == 'S' && s[j][l] == 'T') t += 'E';
if (s[i][l] == 'T' && s[j][l] == 'S') t += 'E';
if (s[i][l] == 'E' && s[j][l] == 'S') t += 'T';
if (s[i][l] == 'S' && s[j][l] == 'E') t += 'T';
if (s[i][l] == 'S' && s[j][l] == 'S') t += 'S';
if (s[i][l] == 'T' && s[j][l] == 'T') t += 'T';
if (s[i][l] == 'E' && s[j][l] == 'E') t += 'E';
}
res2 += mp[t];
}
}
res2 /= 3;
cout << res1 + res2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1505;
string str[maxn];
unordered_map<string, int> ma;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> str[i];
ma[str[i]] = i;
}
long long ans = 0;
for (int i = 0; i < n - 2; i++) {
for (int j = i + 1; j < n - 1; j++) {
string temp = "";
for (int x = 0; x < k; x++) {
if (str[i][x] == str[j][x])
temp += str[i][x];
else if ((str[i][x] == 'S' && str[j][x] == 'E') ||
(str[i][x] == 'E' && str[j][x] == 'S'))
temp += 'T';
else if ((str[i][x] == 'S' && str[j][x] == 'T') ||
(str[i][x] == 'T' && str[j][x] == 'S'))
temp += 'E';
else if ((str[i][x] == 'T' && str[j][x] == 'E') ||
(str[i][x] == 'E' && str[j][x] == 'T'))
temp += 'S';
}
if (ma.find(temp) != ma.end() && ma[temp] > j) ans++;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
char combine(char a, char b) {
if (a == b) return a;
for (auto x : {'S', 'E', 'T'}) {
if (x != a and x != b) return x;
}
assert(false);
}
int32_t main() {
int n, k;
cin >> n >> k;
vector<string> a(n);
for (auto &s : a) cin >> s;
sort(begin(a), end(a));
int cnt = 0;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - (((0) > (n)) << 1)) {
for (__typeof(n) j = (i + 1) - ((i + 1) > (n)); j != (n) - ((i + 1) > (n));
j += 1 - (((i + 1) > (n)) << 1)) {
string s = "";
for (__typeof(k) z = (0) - ((0) > (k)); z != (k) - ((0) > (k));
z += 1 - (((0) > (k)) << 1))
s += combine(a[i][z], a[j][z]);
if (binary_search(a.begin() + j + 1, a.end(), s)) cnt++;
}
}
cout << cnt << "\n";
return 0;
}
|
#include <bits/stdc++.h>
long long mod = 1000000007;
long long mod2 = 998244353;
long long OO = 1e18;
long long david_villa_pow(long long x, long long n) {
if (n == 0) return 1;
long long u = david_villa_pow(x, n / 2);
u = ((u) * (u));
if (n % 2 == 1) u = ((u) * (x));
return u;
}
long long up(long long x, long long y) {
if (x % y == 0) return x / y;
return x / y + 1;
}
using namespace std;
map<string, long long> mp[2000];
map<string, long long>::iterator it;
string s[2000];
int main() {
long long i, j;
;
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
for (i = 0; i < n; i++) cin >> s[i];
for (i = n - 1; i >= 0; i--) {
for (it = mp[i + 1].begin(); it != mp[i + 1].end(); it++)
mp[i][it->first] = it->second;
mp[i][s[i]]++;
}
long long res = 0;
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
string x;
for (int k = 0; k < m; k++) {
if (s[i][k] == s[j][k])
x.push_back(s[i][k]);
else {
bool S = 0, T = 0, E = 0;
if (s[i][k] == 'S' || s[j][k] == 'S') S = 1;
if (s[i][k] == 'T' || s[j][k] == 'T') T = 1;
if (s[i][k] == 'E' || s[j][k] == 'E') E = 1;
if (!E) x.push_back('E');
if (!T) x.push_back('T');
if (!S) x.push_back('S');
}
}
if (j + 1 < n) res += mp[j + 1][x];
x.clear();
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string solve(string a, string b) {
int i;
string ans;
for (i = 0; i < a.size(); ++i) {
if (a[i] == b[i]) {
ans.push_back(a[i]);
} else {
if (a[i] == 'S') {
if (b[i] == 'E') {
ans.push_back('T');
} else {
ans.push_back('E');
}
}
if (a[i] == 'E') {
if (b[i] == 'S') {
ans.push_back('T');
} else {
ans.push_back('S');
}
}
if (a[i] == 'T') {
if (b[i] == 'S') {
ans.push_back('E');
} else {
ans.push_back('S');
}
}
}
}
return ans;
}
int main() {
vector<string> v;
map<string, int> m;
int n, k, i, j, ans = 0;
cin >> n >> k;
for (i = 0; i < n; ++i) {
string s;
cin >> s;
v.push_back(s);
m[s] = 1;
}
for (i = 0; i < n; ++i) {
for (j = i + 1; j < n; ++j) {
string a = v[i];
string b = v[j];
string c = solve(a, b);
if (m.find(c) != m.end()) {
ans++;
}
}
}
cout << ans / 3;
}
|
#include <bits/stdc++.h>
int main() {
const std::string valid = "SET";
std::ios_base::sync_with_stdio();
std::cin.tie(0);
int N, K;
std::cin >> N >> K;
std::map<std::string, int> dp;
for (int i = 0; i < N; i += 1) {
std::string s;
std::cin >> s;
dp[s] += 1;
}
long long int ans = 0;
std::vector<std::pair<std::string, int>> v;
for (const auto &i : dp) {
const int size = i.second;
if (size > 2) {
ans += (1LL * size * (size - 1) * (size - 2)) / 6;
}
v.push_back(i);
}
long long int other = 0;
for (int i = 0; i < int(v.size()); i += 1) {
for (int j = i + 1; j < int(v.size()); j += 1) {
std::string kappaloiro;
for (int k = 0; k < K; k += 1) {
if (v[i].first[k] == v[j].first[k]) {
kappaloiro.push_back(v[i].first[k]);
} else {
for (const auto &c : valid) {
if (c != v[i].first[k] and c != v[j].first[k]) {
kappaloiro.push_back(c);
break;
}
}
}
}
other += (1LL * v[i].second * v[j].second * dp[kappaloiro]);
}
}
std::cout << ans + (other / 3) << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[1505];
char d[4] = {'S', 'E', 'T'};
string f(string a, string b) {
string ans;
for (int i = 0; i < a.length(); i++) {
if (a[i] == b[i])
ans += a[i];
else {
for (int j = 0; j < 3; j++) {
if (d[j] != a[i] && d[j] != b[i]) {
ans += d[j];
break;
}
}
}
}
return ans;
}
map<string, bool> mp;
int main() {
int cnt = 0;
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> s[i], mp[s[i]] = 1;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
string t = f(s[i], s[j]);
if (t != s[i] && t != s[j] && mp[t]) {
cnt++;
}
}
}
cout << cnt / 3;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
string s[n];
unordered_map<string, int> freq;
for (int i = 0; i < n; i++) {
cin >> s[i];
freq[s[i]]++;
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
unordered_map<string, int> freq1 = freq;
for (int j = i + 1; j < n; j++) {
string check = "";
if (s[i] == s[j]) {
ans += (freq[s[i]] - 2);
} else {
for (int i1 = 0; i1 < k; i1++) {
if (s[i][i1] == s[j][i1]) {
check += s[i][i1];
} else {
if (s[i][i1] != 'S' && s[j][i1] != 'S') {
check += "S";
} else if (s[i][i1] != 'E' && s[j][i1] != 'E') {
check += "E";
} else {
check += "T";
}
}
}
if (freq1[check] >= 0) {
ans += freq1[check];
}
freq1[s[j]]--;
}
}
freq[s[i]]--;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long mod = 1e9 + 7;
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T> v) {
os << "(" << v.first << ", " << v.second << ")";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T> v) {
for (int i = 0; i < (int)v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<vector<T>> v) {
for (int i = 0; i < (int)v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
vector<string> s(n);
for (int i = 0; i < (int)n; ++i) cin >> s[i];
unordered_map<string, long long> mp;
for (int i = 0; i < (int)n; ++i) mp[s[i]]++;
long long res1 = 0;
for (auto x : mp) {
long long val = x.second;
res1 += val * (val - 1) * (val - 2) / 6;
}
long long res2 = 0;
for (int i = 0; i < (int)n; ++i) {
for (int j = 0; j < (int)n; ++j) {
if (i > j) continue;
if (s[i] == s[j]) continue;
string t = "";
for (int l = 0; l < (int)k; ++l) {
vector<char> moji(2);
moji[0] = s[i][l];
moji[1] = s[j][l];
if (moji[0] > moji[1]) swap(moji[0], moji[1]);
if (moji[0] == 'E' && moji[1] == 'S')
t += 'T';
else if (moji[0] == 'E' && moji[1] == 'T')
t += 'S';
else if (moji[0] == 'S' && moji[1] == 'T')
t += 'E';
else if (moji[0] == 'S' && moji[1] == 'S')
t += 'S';
else if (moji[0] == 'E' && moji[1] == 'E')
t += 'E';
else if (moji[0] == 'T' && moji[1] == 'T')
t += 'T';
}
res2 += mp[t];
}
}
res2 /= 3;
cout << res1 + res2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace fastio {
template <class T>
istream &operator>>(istream &os, vector<T> &vec) {
for (auto &u : vec) os >> u;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
for (auto &u : vec) os << u << " ";
return os;
}
template <class T1, class T2>
inline istream &operator>>(istream &os, pair<T1, T2> &p) {
return os >> p.first >> p.second;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << p.first << " " << p.second;
}
template <class T>
ostream &operator<<(ostream &os, set<T> &con) {
for (auto &u : con) os << u << " ";
return os;
}
void re() {}
template <typename T, typename... args>
void re(T &x, args &...tail) {
cin >> x;
re(tail...);
}
void pr() {}
template <typename T>
void pr(const T &x) {
cout << x;
}
template <typename T, typename... args>
void pr(const T &x, const args &...tail) {
cout << x << " ";
pr(tail...);
}
template <typename... args>
void prln(const args &...tail) {
pr(tail...);
cout << "\n";
}
} // namespace fastio
using namespace fastio;
const long long int mod = 1e9 + 7;
const long long int mod1 = 998244353;
int main() {
cin.sync_with_stdio(false);
cin.exceptions(cin.failbit);
cin.tie(0);
long long int n, k;
re(n, k);
string s[n], s1;
map<string, long long int> mp1;
vector<pair<string, string>> vec;
for (int i = 0; i < n; i++) {
cin >> s[i];
if (mp1.find(s[i]) == mp1.end()) mp1[s[i]] = 0;
mp1[s[i]]++;
}
for (int i = 0; i + 1 < n; i++)
for (int j = i + 1; j < n; j++) vec.push_back({s[i], s[j]});
long long int cnt = 0;
for (int i = 0; i < vec.size(); i++) {
s1 = "";
for (int j = 0; j < k; j++) {
if (vec[i].first[j] == vec[i].second[j])
s1 += vec[i].first[j];
else
s1 += char(106 - (vec[i].first[j] - 65) - (vec[i].second[j] - 65));
}
if (mp1.find(s1) == mp1.end()) continue;
cnt += mp1[s1];
if (s1 == vec[i].first) cnt -= 2;
}
prln(cnt / 3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, res;
string a[2000];
char x[2000][2000];
unordered_map<string, int> mp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i], mp[a[i]]++;
x['E']['S'] = 'T';
x['E']['T'] = 'S';
x['S']['T'] = 'E';
x['E']['E'] = 'E';
x['S']['S'] = 'S';
x['T']['T'] = 'T';
for (int i = 1; i <= n; i++) {
mp[a[i]]--;
for (int j = i + 1; j <= n; j++) {
mp[a[j]]--;
string b;
for (int z = 0; z < k; z++)
b += x[min(a[i][z], a[j][z])][max(a[i][z], a[j][z])];
res += mp[b];
}
for (int j = i + 1; j <= n; j++) mp[a[j]]++;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, A, i, j;
int main() {
scanf("%d%d", &n, &m);
vector<string> v(n);
for (i = 0; i < n; i++) cin >> v[i];
unordered_set<string> s(v.begin(), v.end());
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i == j) continue;
string a;
for (int k = 0; k < m; k++)
if (v[i][k] == v[j][k])
a += v[i][k];
else
a += 'S' + 'E' + 'T' - v[i][k] - v[j][k];
A += s.count(a);
}
}
printf("%d", A / 6);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unordered_map<string, int> num;
set<string> st;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string temp;
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> temp;
num[temp]++;
st.insert(temp);
}
long long ans = 0;
for (set<string>::iterator it1 = st.begin(); it1 != st.end(); it1++) {
it1++;
for (set<string>::iterator it2 = it1; it2 != st.end(); it2++) {
it1--;
string temp = *it1;
for (int i = 0; i < k; i++) {
if ((*it1)[i] != (*it2)[i]) {
if ((*it1)[i] != 'S' && (*it2)[i] != 'S') temp[i] = 'S';
if ((*it1)[i] != 'E' && (*it2)[i] != 'E') temp[i] = 'E';
if ((*it1)[i] != 'T' && (*it2)[i] != 'T') temp[i] = 'T';
}
}
ans = ans +
(long long)num[*it1] * (long long)num[*it2] * (long long)num[temp];
it1++;
}
it1--;
}
if (st.size() == 1) {
cout << (long long)k * (long long)(k - 1) * (long long)(k - 2) / 6ll;
return 0;
}
cout << ans / 3 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int base = 1e9 + 7;
const int oo = 1e6 + 10;
const int gh = 1e3 + 3;
int n, m, k, q;
int a[oo];
string s[1505];
map<string, int> cnt;
void input() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= n; i++) {
cnt[s[i]]++;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
string t = "";
for (int k = 0; k < m; k++) {
if (s[i][k] == s[j][k])
t += s[i][k];
else
t += char('S' + 'E' + 'T' - s[i][k] - s[j][k]);
}
ans += cnt[t];
}
}
cout << ans / 3;
}
void cre() {}
void solve() { cre(); }
void ouput() {}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (ifstream("test.txt")) {
freopen("test.txt", "r", stdin);
} else if (ifstream(""
".inp")) {
freopen(
""
".inp",
"r", stdin);
freopen(
""
".out",
"w", stdout);
}
int t = 1;
while (t--) {
input();
solve();
ouput();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n >> m;
map<string, long> ma;
vector<string> v;
for (long i = 0; i < n; i++) {
string a;
cin >> a;
v.push_back(a);
ma[a] = 1;
}
long k = 0;
long count = 0;
for (long i = 0; i < n - 1; i++) {
for (long j = i + 1; j < n; j++) {
long ck = 0;
string c = "";
for (long h = 0; h < m; h++) {
if (v[i][h] == v[j][h]) {
c += v[i][h];
} else {
c += char('S' + 'E' + 'T' - v[i][h] - v[j][h]);
}
}
if (ck == 0) {
if (ma[c] == 1) count++;
}
}
}
cout << count / 3 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long int n, k;
cin >> n >> k;
string s[n];
for (long long int i = 0; i < n; i++) cin >> s[i];
long long int c = 0;
unordered_map<string, long long int> m;
for (long long int i = 0; i < n; i++) m[s[i]]++;
for (long long int i = 0; i < n; i++) {
for (long long int j = i + 1; j < n; j++) {
string h = "";
for (long long int l = 0; l < k; l++) {
if (s[i][l] == s[j][l])
h += s[i][l];
else {
if (s[i][l] == 'S' && s[j][l] == 'E')
h += 'T';
else if (s[i][l] == 'E' && s[j][l] == 'S')
h += 'T';
else if (s[i][l] == 'S' && s[j][l] == 'T')
h += 'E';
else if (s[i][l] == 'T' && s[j][l] == 'S')
h += 'E';
else
h += 'S';
}
}
if (m.count(h) != 0) c += m[h];
}
}
c = c / 3;
cout << c << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool checkBit(int n, int i) { return n & ((int)1 << i); }
inline int setBit(int n, int i) {
return n | ((int)1 << i);
;
}
inline int resetBit(int n, int i) { return n & (~((int)1 << i)); }
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(int year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long int &a) { a = (a + 1000000007) % 1000000007; }
inline int modMul(long long int a, long long int b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline int modAdd(long long int a, long long int b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline int modSub(long long int a, long long int b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline int modPow(long long int b, long long int p) {
int r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline int modInv(int a) { return modPow(a, 1000000007 - 2); }
inline int modDiv(int a, int b) { return modMul(a, modInv(b)); }
inline int fact(int r) {
int ans = 1;
while (r) ans = modMul(ans, r), r--;
return ans;
}
inline int invfact(int r) {
int ans = 1;
while (r) ans = modMul(ans, modInv(r)), r--;
return ans;
}
inline double dgcd(double a, double b) {
if (a < b) return dgcd(b, a);
if (b < .0001) return a;
return dgcd(b, fmod(a, b));
}
const int N = 5e3 + 1;
long long int power(long long int base, long long int exp) {
long long int res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % 1000000007;
base = (base * base) / 1000000007;
exp /= 2;
}
return res % 1000000007;
}
void hacked() {
long long int n, k;
cin >> n >> k;
string s[n];
for (long long int i = 0; i < n; i++) cin >> s[i];
sort(s, s + n);
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
for (long long int j = i + 1; j < n; j++) {
string t = "";
for (long long int l = 0; l < k; l++) {
if (s[i][l] == s[j][l])
t += s[i][l];
else {
if ((s[i][l] == 'S' || s[i][l] == 'E') &&
(s[j][l] == 'S' || s[j][l] == 'E'))
t += 'T';
else if ((s[i][l] == 'S' || s[i][l] == 'T') &&
(s[j][l] == 'S' || s[j][l] == 'T'))
t += 'E';
else
t += 'S';
}
}
long long int l = j + 1;
long long int u = n - 1;
while (l <= u) {
long long int d = (l + u) / 2;
if (s[d] > t) {
u = d - 1;
} else if (s[d] == t) {
ans++;
break;
} else
l = d + 1;
}
}
}
cout << ans;
}
signed main() {
int test = 1;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
while (test--) hacked();
return 0;
}
|
#include <bits/stdc++.h>
int TN = 1;
int main() {
long long n, k, c, cur = 0;
std::cin >> n >> k;
char s;
std::vector<long long> a;
std::vector<std::string> check;
std::string sss = "";
std::map<char, long long> ch;
ch['T'] = 1;
ch['E'] = 2;
ch['S'] = 0;
long long e = 1;
for (int i = 0; i < n; i++) {
cur = 0;
e = 1;
sss = "";
for (int j = 0; j < k; ++j) {
std::cin >> s;
sss += s;
c = ch[s];
cur += c * e;
e *= 3;
}
a.push_back(cur);
check.push_back(sss);
}
long long ans = 0;
long long pro;
std::sort(a.begin(), a.end());
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
e = 1;
cur = 0;
for (int K = 0; K < k; K++) {
long long c1 = ch[check[i][K]];
long long c2 = ch[check[j][K]];
if (c2 == c1)
cur += e * c2;
else
cur += e * (3 - c1 - c2);
e *= 3;
}
pro = binary_search(a.begin(), a.end(), cur);
if (pro != 0) {
ans += 1;
}
}
}
std::cout << ans / 3;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[1505];
map<char, int> mp1;
map<int, char> mp;
map<string, int> m;
int main() {
ios::sync_with_stdio(0);
int n, k;
cin >> n >> k;
mp1['S'] = 1;
mp1['T'] = 2;
mp1['E'] = 3;
mp[1] = 'S';
mp[2] = 'T';
mp[3] = 'E';
for (int i = 0; i < n; i++) {
cin >> s[i];
m[s[i]] = i;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string str = "";
for (int r = 0; r < k; r++) {
if (s[i][r] == s[j][r]) {
str += s[i][r];
continue;
}
str += mp[6 - mp1[s[i][r]] - mp1[s[j][r]]];
}
if (m[str] > j) ans++;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s[n];
map<string, int> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
m[s[i]] = 1;
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string tmp = "";
for (int kk = 0; kk < k; kk++) {
if (s[i][kk] == s[j][kk]) tmp += s[i][kk];
if ((s[i][kk] == 'S' && s[j][kk] == 'T') ||
(s[i][kk] == 'T' && s[j][kk] == 'S'))
tmp += 'E';
if ((s[i][kk] == 'T' && s[j][kk] == 'E') ||
(s[i][kk] == 'E' && s[j][kk] == 'T'))
tmp += 'S';
if ((s[i][kk] == 'E' && s[j][kk] == 'S') ||
(s[i][kk] == 'S' && s[j][kk] == 'E'))
tmp += 'T';
}
if (m[tmp]) ans++;
}
}
cout << ans / 3;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> prime;
void sieve(long long int n) {
bool p[n + 1];
memset(p, true, sizeof(p));
for (long long int i = 2; i * i <= n; i++) {
if (p[i]) {
for (int j = i * i; j <= n; j += i) {
p[j] = false;
}
}
}
for (long long int i = 2; i <= n; i++) {
if (p[i]) {
prime.push_back(i);
}
}
}
bool cmp(pair<long long int, pair<long long int, long long int> > v1,
pair<long long int, pair<long long int, long long int> > v2) {
if (v1.second.second < v2.second.second) {
return false;
} else if (v1.second.second == v2.second.second) {
if (v1.first > v2.first) {
return false;
} else {
return true;
}
} else {
return true;
}
}
void solve() {
long long int n, k;
cin >> n >> k;
int S = 'S' + 'T' + 'E';
vector<string> str(n);
map<string, long long int> m;
for (int i = 0; i < n; i++) {
cin >> str[i];
m[str[i]]++;
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string temp;
for (int x = 0; x < k; x++) {
if (str[i][x] == str[j][x]) {
temp += str[i][x];
} else {
temp += (S - str[i][x] - str[j][x]);
}
}
ans += m[temp];
}
}
cout << ans / 3 << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string str[n];
map<string, int> mp;
for (int i = 0; i < n; i++) {
cin >> str[i];
mp[str[i]]++;
}
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (i == j) continue;
string x = "";
for (int l = 0; l < k; l++) {
char a = str[i][l], b = str[j][l];
if (a == 'S') {
if (b == 'S')
x += 'S';
else if (b == 'E')
x += 'T';
else
x += 'E';
} else if (a == 'E') {
if (b == 'E')
x += 'E';
else if (b == 'S')
x += 'T';
else
x += 'S';
} else {
if (b == 'T')
x += 'T';
else if (b == 'E')
x += 'S';
else
x += 'E';
}
}
int m = 0;
if (x == str[i]) m++;
if (x == str[j]) m++;
if (mp[x]) cnt += (mp[x] - m);
}
}
cout << cnt / 3 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, ans, powth[40];
char a[2000][40];
set<long long> s;
int main() {
scanf("%lld%lld", &n, &k);
powth[0] = 1ll;
for (int i = 1; i < k; i++) {
powth[i] = powth[i - 1] * 3;
}
for (int i = 0; i < n; i++) {
scanf("%s", a[i]);
long long ret = 0;
for (int j = 0; j < k; j++) {
long long num;
if (a[i][j] == 'E') {
num = 0;
} else if (a[i][j] == 'S') {
num = 1;
} else {
num = 2;
}
ret += powth[j] * num;
}
s.insert(ret);
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
char b[40];
long long ret = 0;
for (int l = 0; l < k; l++) {
if (a[i][l] == a[j][l]) {
b[l] = a[i][l];
} else {
b[l] = 'S' + 'T' + 'E' - a[i][l] - a[j][l];
}
long long num;
if (b[l] == 'E') {
num = 0;
} else if (b[l] == 'S') {
num = 1;
} else {
num = 2;
}
ret += powth[l] * num;
}
if (s.count(ret)) {
ans++;
}
}
}
ans /= 3;
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf(" %d %d", &n, &k);
unordered_map<string, int> st;
string vals[n];
for (int i = 0; i < n; ++i) cin >> vals[i], st[vals[i]] = i;
int ans = 0;
set<pair<int, pair<int, int>>> uni;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
string look = "";
for (int l = 0; l < k; ++l) {
if (vals[i][l] == vals[j][l])
look += vals[i][l];
else if (vals[i][l] == 'S' && vals[j][l] == 'T')
look += 'E';
else if (vals[i][l] == 'T' && vals[j][l] == 'S')
look += 'E';
else if (vals[i][l] == 'E' && vals[j][l] == 'T')
look += 'S';
else if (vals[i][l] == 'T' && vals[j][l] == 'E')
look += 'S';
else if (vals[i][l] == 'E' && vals[j][l] == 'S')
look += 'T';
else
look += 'T';
}
if (st.count(look)) {
int temp[3];
temp[0] = i, temp[1] = j, temp[2] = st[look];
sort(temp, temp + 3);
uni.insert({temp[0], {temp[1], temp[2]}});
}
}
}
printf("%d\n", (int)uni.size());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[2005];
map<string, int> m;
int main() {
ios::sync_with_stdio(0);
int n, k, ans = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> s[i];
m[s[i]]++;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string t;
for (int x = 0; x < k; x++) {
if (s[i][x] == s[j][x])
t += s[i][x];
else if ((s[i][x] == 'S' && s[j][x] == 'E') ||
(s[i][x] == 'E' && s[j][x] == 'S'))
t += "T";
else if ((s[i][x] == 'E' && s[j][x] == 'T') ||
(s[i][x] == 'T' && s[j][x] == 'E'))
t += "S";
else if ((s[i][x] == 'T' && s[j][x] == 'S') ||
(s[i][x] == 'S' && s[j][x] == 'T'))
t += "E";
}
ans += m[t];
}
}
cout << ans / 3 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
set<string> srt;
long long n, kk, ans = 0;
cin >> n >> kk;
string s[1550];
for (int i = 0; i < n; i++) {
cin >> s[i];
srt.insert(s[i]);
}
sort(s, s + n);
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string tr = "";
for (int k = 0; k < kk; k++) {
if (s[i][k] == s[j][k])
tr += s[i][k];
else if ((s[i][k] == 'S' && s[j][k] == 'T') ||
(s[i][k] == 'T' && s[j][k] == 'S'))
tr += 'E';
else if ((s[i][k] == 'S' && s[j][k] == 'E') ||
(s[i][k] == 'E' && s[j][k] == 'S'))
tr += 'T';
else if ((s[i][k] == 'E' && s[j][k] == 'T') ||
(s[i][k] == 'T' && s[j][k] == 'E'))
tr += 'S';
}
if (srt.find(tr) != srt.end()) ans++;
}
}
cout << ans / 3;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 44;
const int P = (1 << 18);
const long long MD = 998244353;
long long n, m, k, t;
string s[N];
long long a[N], b[N], c[N];
map<string, bool> mp;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> s[i];
mp[s[i]] = 1;
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string c = "";
for (int z = 0; z < k; z++) {
if (s[i][z] == s[j][z])
c += s[i][z];
else if (s[i][z] == 'S' && s[j][z] == 'E')
c += 'T';
else if (s[i][z] == 'E' && s[j][z] == 'S')
c += 'T';
else if (s[i][z] == 'E' && s[j][z] == 'T')
c += 'S';
else if (s[i][z] == 'T' && s[j][z] == 'E')
c += 'S';
else if (s[i][z] == 'T' && s[j][z] == 'S')
c += 'E';
else if (s[i][z] == 'S' && s[j][z] == 'T')
c += 'E';
}
if (mp[c] == 1) ans++;
}
}
cout << ans / 3;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 3e5 + 5;
const long double pi = 3.141592653;
const long long mod = 1e9 + 9;
const long long MOD = 998244353;
const long long INF = 9223372036854775807LL;
using namespace std;
int dx[9] = {1, -1, 0, 0, 1, 1, -1, -1, 0};
int dy[9] = {0, 0, 1, -1, 1, -1, 1, -1, 0};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) {
int n, k, ans = 0;
cin >> n >> k;
vector<string> v(n);
unordered_map<long long, long long> q;
vector<int> ch(26);
ch['S' - 'A'] = 0;
ch['E' - 'A'] = 1;
ch['T' - 'A'] = 2;
for (int i = 0; i < n; i++) {
cin >> v[i];
long long hash = 0, val;
for (int j = 0; j < k; j++) hash = hash * 3 + ch[v[i][j] - 'A'];
if (q.find(hash) != q.end())
q[hash]++;
else
q.insert({hash, 1});
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string s;
long long hash = 0;
for (int l = 0; l < k; l++) {
if (v[i][l] == v[j][l])
s.push_back(v[i][l]);
else {
if (v[i][l] == 'S' && v[j][l] == 'E')
s.push_back('T');
else if (v[i][l] == 'S' && v[j][l] == 'T')
s.push_back('E');
else if (v[i][l] == 'E' && v[j][l] == 'T')
s.push_back('S');
else if (v[i][l] == 'E' && v[j][l] == 'S')
s.push_back('T');
else if (v[i][l] == 'T' && v[j][l] == 'S')
s.push_back('E');
else if (v[i][l] == 'T' && v[j][l] == 'E')
s.push_back('S');
}
hash = hash * 3 + ch[s.back() - 'A'];
}
if (q.find(hash) != q.end()) ans += q[hash];
}
}
cout << ans / 3;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char diff(char a, char b) {
if (a > b) swap(a, b);
if (a == 'E' && b == 'T') return 'S';
if (a == 'E' && b == 'S')
return 'T';
else
return 'E';
}
int main(int argc, char* argv[]) {
int n, K;
scanf("%d%d", &n, &K);
map<string, int> freq;
string arr[2000];
for (int i = 0; i < n; i++) {
string s;
cin >> s;
++freq[s];
arr[i] = s;
}
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
string tmp;
for (int k = 0; k < K; k++) {
if (arr[i][k] == arr[j][k])
tmp.push_back(arr[i][k]);
else
tmp.push_back(diff(arr[i][k], arr[j][k]));
}
ans += freq[tmp];
}
printf("%d\n", ans / 3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
map<string, long long> s;
string a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
s[a[i]] = i + 1;
}
long long ans = 0;
string p;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
p.clear();
for (long long l = 0; l < k; l++) {
if (a[i][l] == a[j][l]) {
p += a[i][l];
continue;
}
if (a[i][l] == 'S' || a[j][l] == 'S') {
if (a[i][l] == 'E' || a[j][l] == 'E')
p += 'T';
else
p += 'E';
} else
p += 'S';
}
if (s[p] > j + 1) {
ans++;
}
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long T = 1;
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
long long co = 0;
string *arr = new string[n];
set<string> se;
for (int i = 0; i < n; i++) {
cin >> arr[i];
se.insert(arr[i]);
}
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
string s = "";
for (int l = 0; l < k; l++) {
if ((arr[i][l] == arr[j][l] && arr[j][l] == 'S') ||
(arr[i][l] != arr[j][l] && arr[i][l] != 'S' && arr[j][l] != 'S')) {
s += "S";
}
if ((arr[i][l] == arr[j][l] && arr[j][l] == 'E') ||
(arr[i][l] != arr[j][l] && arr[i][l] != 'E' && arr[j][l] != 'E')) {
s += "E";
}
if ((arr[i][l] == arr[j][l] && arr[j][l] == 'T') ||
(arr[i][l] != arr[j][l] && arr[i][l] != 'T' && arr[j][l] != 'T')) {
s += "T";
}
}
if (se.find(s) != se.end()) co++;
}
}
cout << co / 3 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
string s[n];
unordered_map<string, int> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
m[s[i]]++;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
m[s[i]]--;
for (int j = i + 1; j < n; j++) {
m[s[j]]--;
string t = s[i];
for (int jj = 0; jj < k; jj++) {
if (s[i][jj] == s[j][jj]) {
t[jj] = s[i][jj];
} else {
if (s[i][jj] != 'S' && s[j][jj] != 'S')
t[jj] = 'S';
else if (s[i][jj] != 'E' && s[j][jj] != 'E')
t[jj] = 'E';
else if (s[i][jj] != 'T' && s[j][jj] != 'T')
t[jj] = 'T';
}
}
if (m[t]) {
ans++;
}
m[s[j]]++;
}
}
cout << ans / 2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s[1505];
unordered_set<string> st;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> s[i];
st.insert(s[i]);
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
string str = "";
for (int k = 0; k < m; ++k) {
char a = s[i][k];
char b = s[j][k];
if (a > b) swap(a, b);
if (a != b) {
if (a == 'E' && b == 'S')
str += "T";
else if (a == 'E' && b == 'T')
str += "S";
else if (a == 'S' && b == 'T')
str += "E";
} else if (a == b) {
str += a;
}
}
if (st.find(str) != st.end()) ++ans;
}
}
cout << ans / 3 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, u;
cin >> n >> k;
int i, j;
set<string> set;
vector<string> v(n);
for (i = 0; i < n; i++) {
cin >> v[i];
set.insert(v[i]);
}
int cnt = 0;
for (i = 0; i < n - 1; i++) {
for (j = i + 1; j < n; j++) {
string g = "";
for (u = 0; u < k; u++) {
if (v[i][u] == v[j][u]) {
g.push_back(v[i][u]);
} else {
if ((v[i][u] == 'S' && v[j][u] == 'E') ||
(v[i][u] == 'E' && v[j][u] == 'S'))
g = g + "T";
if ((v[i][u] == 'S' && v[j][u] == 'T') ||
(v[i][u] == 'T' && v[j][u] == 'S'))
g = g + "E";
if ((v[i][u] == 'T' && v[j][u] == 'E') ||
(v[i][u] == 'E' && v[j][u] == 'T'))
g = g + "S";
}
}
if (set.find(g) != set.end()) {
cnt++;
}
}
}
cout << cnt / 3;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
long long int count = 0;
map<string, long long int> mp;
vector<string> str(n);
for (long long int i = 0; i < n; i++) {
cin >> str[i];
mp[str[i]]++;
}
string set = "SET";
for (long long int i = 0; i < n; i++) {
for (long long int j = i + 1; j < n; j++) {
string out = "";
for (long long int q = 0; q < k; q++) {
if (str[i][q] == str[j][q]) {
out += str[i][q];
} else {
for (long long int a = 0; a < 3; a++) {
if (str[i][q] != set[a] && str[j][q] != set[a]) {
out += set[a];
}
}
}
}
count += mp[out];
}
}
cout << count / 3;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k, cnt = 0;
cin >> n >> k;
string s[n];
string ch;
map<string, long long> mp;
for (int i = 0; i < n; i++) {
cin >> s[i];
mp[s[i]] += 1;
}
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
string a = s[i], b = s[j], req;
for (int l = 0; l < k; l++) {
if (a[l] == b[l])
req += a[l];
else {
if (a[l] != 'S' && b[l] != 'S')
req += "S";
else if (a[l] != 'E' && b[l] != 'E')
req += "E";
else if (a[l] != 'T' && b[l] != 'T')
req += "T";
}
}
cnt += mp.count(req);
}
}
cout << cnt / 3 << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
map<vector<int>, int> ma;
signed main() {
int n, k;
cin >> n >> k;
vector<string> a;
for (int i = 0; i < n; ++i) {
string s;
vector<int> now;
cin >> s;
a.push_back(s);
for (int j = 0; j < k; ++j) {
if (s[j] == 'S')
now.push_back(0);
else if (s[j] == 'E')
now.push_back(1);
else
now.push_back(2);
}
ma[now]++;
}
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
vector<int> now;
for (int uk = 0; uk < k; ++uk) {
if (a[i][uk] == a[j][uk]) {
if (a[i][uk] == 'S')
now.push_back(0);
else if (a[i][uk] == 'E')
now.push_back(1);
else
now.push_back(2);
} else {
int summ = 0;
if (a[i][uk] == 'S')
summ += 0;
else if (a[i][uk] == 'E')
summ += 1;
else
summ += 2;
if (a[j][uk] == 'S')
summ += 0;
else if (a[j][uk] == 'E')
summ += 1;
else
summ += 2;
now.push_back(3 - summ);
}
}
if (ma.find(now) != ma.end()) ans += ma[now];
}
}
cout << ans / 3 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<string> v(n);
map<string, long long> ktt;
for (long long i = 0; i < n; i++) {
cin >> v[i];
ktt[v[i]] = i + 1;
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
string find;
for (long long x = 0; x < k; x++) {
if (v[i][x] == v[j][x]) {
find += v[i][x];
} else {
if (v[i][x] == 'S' && v[j][x] == 'E' ||
v[i][x] == 'E' && v[j][x] == 'S') {
find += "T";
}
if (v[i][x] == 'T' && v[j][x] == 'E' ||
v[i][x] == 'E' && v[j][x] == 'T') {
find += "S";
}
if (v[i][x] == 'S' && v[j][x] == 'T' ||
v[i][x] == 'T' && v[j][x] == 'S') {
find += "E";
}
}
}
if (ktt[find] != 0 && ktt[find] > ktt[v[j]]) {
ans++;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool fun(string s1, string s2, string s3) {
int i;
for (i = 0; i < s1.size(); i++) {
if (s1[i] == s2[i] && s2[i] == s3[i] && s1[i] == s3[i]) continue;
if (s1[i] != s2[i] && s2[i] != s3[i] && s1[i] != s3[i])
continue;
else
return false;
}
return true;
}
int main() {
int n, k, i, j, cnt = 0, l;
cin >> n >> k;
vector<string> v(n);
for (i = 0; i < n; i++) cin >> v[i];
if (n < 3) {
cout << 0;
return 0;
}
unordered_map<string, int> m;
string set = "SET";
for (i = 0; i < n; i++) m[v[i]] = i;
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
string s;
for (l = 0; l < k; l++) {
if (v[i][l] == v[j][l])
s += v[i][l];
else {
string st = set;
st.erase(find(st.begin(), st.end(), v[i][l]));
st.erase(find(st.begin(), st.end(), v[j][l]));
s += st[0];
}
}
if (m.find(s) != m.end()) cnt++;
}
}
cout << cnt / 3;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
t = 1;
while (t--) {
long long n, k;
cin >> n >> k;
map<string, long long> mpp;
string s[n];
for (long long i = 0; i <= n - 1; i++) {
cin >> s[i];
mpp[s[i]]++;
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
string s1 = s[i], s2 = s[j];
string s3;
long long ck = 0;
for (long long r = 0; r <= k - 1; r++)
if (s1[r] == s2[r])
s3.push_back(s1[r]);
else {
if (s2[r] != 'S' and s1[r] != 'S')
s3.push_back('S');
else if (s2[r] != 'E' and s1[r] != 'E')
s3.push_back('E');
else if (s2[r] != 'T' and s1[r] != 'T')
s3.push_back('T');
}
if (mpp.find(s3) != mpp.end()) {
ans++;
}
}
}
cout << ans / 3 << "\n";
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.