text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
std::vector<uint_fast64_t> get_primes_linear(uint_fast64_t limit) {
std::vector<uint_fast64_t> lp(limit + 1);
std::vector<uint_fast64_t> pr;
for (uint_fast64_t i = 2; i <= limit; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back(i);
}
for (uint_fast64_t j = 0;
j < pr.size() && pr[j] <= lp[i] && i * pr[j] <= limit; ++j)
lp[i * pr[j]] = pr[j];
}
return pr;
}
uint_fast64_t binpow(uint_fast64_t a, uint_fast64_t n) {
uint_fast64_t res = 1;
while (n) {
if (n & 1) res *= a;
a *= a;
n >>= 1;
}
return res;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
uint_fast64_t n, k, t;
std::cin >> n >> k;
std::vector<uint_fast64_t> a(n, 0);
std::map<uint_fast64_t, uint_fast64_t> as;
std::map<uint_fast64_t, uint_fast64_t> comp;
for (uint_fast64_t i = 0; i < n; ++i) {
std::cin >> a[i];
}
auto ps = get_primes_linear(100000);
for (auto num : a) {
uint_fast64_t res = 1, comple = 1;
for (auto &p : ps) {
if (num < p) break;
uint_fast64_t pow = 0;
while (num % p == 0) {
num /= p;
++pow;
}
pow %= k;
res *= binpow(p, pow);
comple *= binpow(p, (k - pow) % k);
}
as[res]++;
comp[res] = comple;
}
uint_fast64_t tot = 0, tot2 = 0;
for (auto &num : as) {
if (comp[num.first] != num.first)
tot += num.second * as[comp[num.first]];
else
tot2 += num.second * (num.second - 1);
}
std::cout << tot / 2 + tot2 / 2 << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5;
int n, k, a, cnt[MAX + 1];
long long res;
vector<pair<int, int> > extractPrimes(int x) {
vector<pair<int, int> > res;
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) {
res.push_back(pair<int, int>(i, 0));
while (x % i == 0) {
++res.back().second;
x /= i;
}
}
if (x > 1) res.push_back(pair<int, int>(x, 1));
return res;
}
int main() {
scanf("%d %d", &n, &k);
while (n--) {
scanf("%d", &a);
vector<pair<int, int> > primes = extractPrimes(a);
long long x = 1LL;
for (pair<int, int>& prime : primes) {
prime.second %= k;
int need = k - prime.second;
if (need == k) need = 0;
for (int i = 0; i < need; ++i)
if ((x *= prime.first) > MAX) {
x = 0;
break;
}
}
if (x != 0) res += cnt[x];
x = 1LL;
for (const pair<int, int>& prime : primes)
for (int i = 0; i < prime.second; ++i)
if ((x *= prime.first) > MAX) {
x = 0;
break;
}
if (x != 0) ++cnt[x];
}
printf("%lld", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1 << 29;
const long long inf = 1ll << 60;
const long long mod = 1e9 + 7;
void GG() {
cout << "No\n";
exit(0);
}
long long mpow(long long a, long long n, long long mo = mod) {
long long re = 1;
while (n > 0) {
if (n & 1) re = re * a % mo;
a = a * a % mo;
n >>= 1;
}
return re;
}
long long inv(long long b, long long mo = mod) {
if (b == 1) return b;
return (mo - mo / b) * inv(mo % b) % mo;
}
const int maxn = 1e5 + 5;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
vector<int> ap(100005);
vector<int> other(100005);
int n;
cin >> n;
int k;
cin >> k;
bool tb = 0;
if (k >= 33) tb = 1;
k = min(k, 33);
vector<int> a(n);
vector<long long> out;
vector<long long> pl;
for (long long i = 2; i <= 10000000000; i++) {
long long mo = pow(i, k);
if (mo > 10000000000) break;
out.push_back(mo);
if (mo <= 100000) pl.push_back(mo);
}
for (int i = 0; i < (n); i++) {
cin >> a[i];
for (int j = ((int)pl.size() - 1); j >= 0; j--) {
if (a[i] % pl[j] == 0) a[i] /= pl[j];
}
ap[a[i]]++;
if (k == 3) {
if (other[a[i]]) continue;
other[a[i]] = 1;
long long tmp = a[i];
for (int j = (2); j < (1 + sqrt(a[i])); j++) {
int nat = 0;
while (tmp % j == 0) tmp /= j, nat++;
if (nat == 1) other[a[i]] *= (long long)j * j;
if (nat == 2) other[a[i]] *= j;
}
if (tmp) other[a[i]] *= tmp * tmp;
}
}
long long re = 0;
for (int i = (1); i < (100005); i++) {
if (ap[i] == 0) continue;
if (i == 1) {
re += (long long)ap[i] * (ap[i] - 1) / 2;
continue;
}
if (tb) break;
if (k > 3) {
for (int j = 0; j < ((int)out.size()); j++) {
if (out[j] % i == 0) {
long long oth = out[j] / i;
if (oth < i) re += (long long)ap[oth] * ap[i];
if (oth == i) re += (long long)ap[i] * (ap[i] - 1) / 2;
break;
}
}
} else if (k == 2) {
re += (long long)ap[i] * (ap[i] - 1) / 2;
} else {
long long oth = other[i];
if (oth < i) re += (long long)ap[oth] * ap[i];
if (oth == i) re += (long long)ap[i] * (ap[i] - 1) / 2;
}
}
cout << re << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long k;
long long trans(long long a) {
for (long long i = 2; i * i <= a; ++i) {
if ((a % i) == 0) {
long long cnt = 0, val = 1;
while ((a % i) == 0) {
++cnt;
val *= i;
if ((cnt % k) == 0) val = 1;
a /= i;
}
a *= val;
}
}
return a;
}
long long mp(long long a) {
long long ans = 1;
for (long long i = 2; i * i <= a; ++i) {
if ((a % i) == 0) {
long long cnt = 0, val = 1;
while ((a % i) == 0) {
++cnt;
val *= i;
a /= i;
}
while (cnt < k) {
++cnt;
ans *= i;
}
}
}
if (a > 1) {
long long cnt = 1;
while (cnt < k) {
++cnt;
ans *= a;
}
}
return ans;
}
void solve() {
long long n;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < n; ++i) a[i] = trans(a[i]);
long long ans = 0;
sort(a, a + n);
for (long long i = 0; i < n; ++i) {
long long l = -1, r = n;
long long cnst = mp(a[i]);
while (l < r - 1) {
long long m = (l + r) / 2;
if (a[m] <= cnst)
l = m;
else
r = m;
}
long long id1 = l;
l = -1;
r = n;
while (l < r - 1) {
long long m = (l + r) / 2;
if (a[m] >= cnst)
r = m;
else
l = m;
}
if (a[i] == cnst) --ans;
ans += abs(id1 - l);
}
cout << ans / 2;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e6 + 42;
int n, k, inp[nmax];
map<vector<pair<int, int> >, int> seen;
int main() {
long long output = 0;
scanf("%i%i", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%i", &inp[i]);
vector<pair<int, int> > now = {};
for (int j = 2; j * j <= inp[i]; j++)
if (inp[i] % j == 0) {
int t = 0;
while (inp[i] % j == 0) inp[i] = inp[i] / j, t++;
t = t % k;
if (t) now.push_back({j, t});
}
if (inp[i] != 1) {
now.push_back({inp[i], 1});
}
vector<pair<int, int> > rev = {};
for (auto p : now) rev.push_back({p.first, k - p.second});
output = output + seen[rev];
seen[now]++;
}
printf("%lld\n", output);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) {
if (a == 0 || b == 0) return a + b;
return a * (b / gcd(a, b));
}
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
int ddx[] = {2, 2, -2, -2, 1, 1, -1, -1}, ddy[] = {1, -1, 1, -1, 2, -2, 2, -2};
vector<int> t = {0};
map<vector<pair<int, int> >, int> M;
int n, k;
vector<pair<int, int> > op(vector<pair<int, int> > &v) {
vector<pair<int, int> > p;
for (auto P : v) p.push_back(make_pair(P.first, k - P.second));
return p;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1;; i++) {
long long c = 1;
for (int(j) = (1); (j) <= (k); (j) += (1)) {
c *= i;
if (c > 100000) {
c = -1;
break;
}
}
if (c == -1) break;
t.push_back(c);
}
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) {
long long x;
scanf("%lld", &x);
for (int(k) = (2); (k) <= ((int)t.size() - 1); (k) += (1))
while (x % t[k] == 0) x /= t[k];
vector<pair<int, int> > vv;
for (int k = 2; k * k <= x; k++) {
if (x % k == 0) {
int cc = 0;
while (x % k == 0) {
cc++;
x /= k;
}
vv.push_back(make_pair(k, cc));
}
}
if (x != 1) vv.push_back(make_pair(x, 1));
M[vv]++;
}
long long ans = 0;
for (auto it = M.begin(); it != M.end(); it++) {
auto t = it->first;
if (t.empty())
ans += 1LL * it->second * (it->second - 1);
else {
auto vp = op(t);
if (it->first == vp)
ans += 1LL * it->second * (it->second - 1);
else
ans += 1LL * it->second * M[vp];
}
}
printf("%lld", ans / 2);
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long n, k;
cin >> n >> k;
vector<long long> b(n);
for (long long i = 0; i < n; ++i) {
cin >> b[i];
}
map<vector<long long>, vector<vector<long long>>> nb;
for (long long i = 0; i < n; ++i) {
vector<long long> cur, push;
for (long long j = 2; j * j <= b[i]; ++j) {
if (b[i] % j == 0) {
cur.push_back(j);
push.push_back(0);
while (b[i] % j == 0) {
push.back()++, b[i] /= j;
}
push.back() %= k;
if (push.back() == 0) {
push.pop_back();
cur.pop_back();
}
}
}
if (b[i] != 1) {
cur.push_back(b[i]);
push.push_back(1);
}
nb[cur].push_back(push);
}
long long ans = 0;
for (auto &nnnn : nb) {
map<vector<long long>, long long> a;
for (long long i = 0; i < nnnn.second.size(); ++i) {
++a[nnnn.second[i]];
}
for (auto &now : a) {
vector<long long> f(nnnn.first.size());
for (long long i = 0; i < nnnn.first.size(); ++i)
f[i] = (k - now.first[i]) % k;
if (a.find(f) != a.end()) {
if (f == now.first)
ans += now.second * 1ll * (now.second - 1);
else
ans += a[f] * 1ll * now.second;
}
}
}
cout << ans / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
const int MAX = 100010;
vector<int> p(MAX);
iota(p.begin(), p.end(), 0);
for (int i = 2; i < MAX; i++) {
if (p[i] == i) {
for (int j = i + i; j < MAX; j += i) {
if (p[j] == j) {
p[j] = i;
}
}
}
}
int n, k;
cin >> n >> k;
vector<int> cnt(MAX);
long long ans = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
int res = 1;
long long ask = 1;
while (x > 1) {
int y = p[x];
int cc = 0;
while (x % y == 0) {
x /= y;
++cc;
}
cc %= k;
for (int j = 0; j < cc; j++) {
res *= y;
}
for (int j = 0; j < (k - cc) % k; j++) {
ask *= y;
ask = min(ask, MAX - 1LL);
}
}
ans += cnt[ask];
++cnt[res];
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
constexpr ll inf = 1000000000;
constexpr ll mod = 1000000007;
constexpr long double eps = 1e-9;
template <typename T1, typename T2>
ostream& operator<<(ostream& os, pair<T1, T2> p) {
os << to_string(p.first) << " " << to_string(p.second);
return os;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T>& v) {
for (ll i = 0; i < (int)v.size(); i++) {
if (i) os << " ";
os << to_string(v[i]);
}
return os;
}
struct modint {
ll n;
public:
modint(const ll n = 0) : n((n % mod + mod) % mod) {}
static modint pow(modint a, int m) {
modint r = 1;
while (m > 0) {
if (m & 1) {
r *= a;
}
a = (a * a);
m /= 2;
}
return r;
}
modint& operator++() {
*this += 1;
return *this;
}
modint& operator--() {
*this -= 1;
return *this;
}
modint operator++(int) {
modint ret = *this;
*this += 1;
return ret;
}
modint operator--(int) {
modint ret = *this;
*this -= 1;
return ret;
}
modint operator~() const { return (this->pow(n, mod - 2)); }
friend bool operator==(const modint& lhs, const modint& rhs) {
return lhs.n == rhs.n;
}
friend bool operator<(const modint& lhs, const modint& rhs) {
return lhs.n < rhs.n;
}
friend bool operator>(const modint& lhs, const modint& rhs) {
return lhs.n > rhs.n;
}
friend modint& operator+=(modint& lhs, const modint& rhs) {
lhs.n += rhs.n;
if (lhs.n >= mod) lhs.n -= mod;
return lhs;
}
friend modint& operator-=(modint& lhs, const modint& rhs) {
lhs.n -= rhs.n;
if (lhs.n < 0) lhs.n += mod;
return lhs;
}
friend modint& operator*=(modint& lhs, const modint& rhs) {
lhs.n = (lhs.n * rhs.n) % mod;
return lhs;
}
friend modint& operator/=(modint& lhs, const modint& rhs) {
lhs.n = (lhs.n * (~rhs).n) % mod;
return lhs;
}
friend modint operator+(const modint& lhs, const modint& rhs) {
return modint(lhs.n + rhs.n);
}
friend modint operator-(const modint& lhs, const modint& rhs) {
return modint(lhs.n - rhs.n);
}
friend modint operator*(const modint& lhs, const modint& rhs) {
return modint(lhs.n * rhs.n);
}
friend modint operator/(const modint& lhs, const modint& rhs) {
return modint(lhs.n * (~rhs).n);
}
};
istream& operator>>(istream& is, modint m) {
is >> m.n;
return is;
}
ostream& operator<<(ostream& os, modint m) {
os << m.n;
return os;
}
long long extgcd(long long a, long long b, long long& x, long long& y) {
long long d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
long long mod_inverse(long long a, long long m) {
long long x, y;
if (extgcd(a, m, x, y) == 1)
return (m + x % m) % m;
else
return -1;
}
vector<long long> fact(1010101 + 1, inf);
long long mod_fact(long long n, long long& e) {
if (fact[0] == inf) {
fact[0] = 1;
if (1010101 != 0) fact[1] = 1;
for (ll i = 2; i <= 1010101; ++i) {
fact[i] = (fact[i - 1] * i) % mod;
}
}
e = 0;
if (n == 0) return 1;
long long res = mod_fact(n / mod, e);
e += n / mod;
if ((n / mod) % 2 != 0) return (res * (mod - fact[n % mod])) % mod;
return (res * fact[n % mod]) % mod;
}
long long mod_comb(long long n, long long k) {
if (n < 0 || k < 0 || n < k) return 0;
long long e1, e2, e3;
long long a1 = mod_fact(n, e1), a2 = mod_fact(k, e2),
a3 = mod_fact(n - k, e3);
if (e1 > e2 + e3) return 0;
return (a1 * mod_inverse((a2 * a3) % mod, mod)) % mod;
}
using mi = modint;
mi mod_pow(mi a, ll n) {
mi ret = 1;
mi tmp = a;
while (n > 0) {
if (n % 2) ret *= tmp;
tmp = tmp * tmp;
n /= 2;
}
return ret;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (ll i = 0; i < (int)n; i++) cin >> a[i];
vector<vector<int>> prim(n);
for (ll i = 0; i < (int)n; i++) {
for (int j = 2; j * j <= a[i]; j++) {
while (a[i] % j == 0) {
prim[i].push_back(j);
a[i] /= j;
}
}
if (a[i] != 1) prim[i].push_back(a[i]);
}
ll ans = 0;
map<vector<pair<int, int>>, int> ma;
for (ll i = 0; i < (int)n; i++) {
if (prim[i].empty()) {
ans += ma[{}];
ma[{}]++;
continue;
}
int num = prim[i].front(), strk = 1;
vector<pair<int, int>> fp, tgt;
for (ll j = 1; j < (int)prim[i].size(); j++) {
if (prim[i][j] != num) {
if (strk % k) {
fp.push_back({num, strk % k});
tgt.push_back({num, k - (strk % k)});
}
num = prim[i][j];
strk = 1;
} else
strk++;
}
if (strk % k) {
fp.push_back({num, strk % k});
tgt.push_back({num, k - (strk % k)});
}
ans += ma[tgt];
ma[fp]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[101010], f[101010], num[101010];
inline long long power(long long a, int k) {
long long ans = 1;
for (; k; k >>= 1, a *= a)
if (k & 1) ans *= a;
return ans;
}
int main() {
for (int i = 2; i < 101010; i++)
if (!f[i]) {
f[i] = i;
if ((long long)i * i >= 101010) continue;
for (int j = i * i; j < 101010; j += i) f[j] = i;
}
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
if (k == 2) {
long long ans = 0;
for (int i = 1; i <= n; i++) {
int u = a[i], val = 1;
while (u > 1) {
int p = f[u], num = 0;
while (u % p == 0) u /= p, num ^= 1;
if (num) val *= p;
}
ans += num[val];
num[val]++;
}
cout << ans << endl;
return 0;
}
int mx = 0;
for (int i = 1; i <= n; i++) {
num[a[i]]++;
mx = max(mx, a[i]);
}
int ed = 1;
while (k * log(ed) < log((double)mx * mx + 1)) ed++;
ed++;
long long ans = 0;
for (int i = 1; i <= ed; i++) {
long long val = power((long long)i, k);
for (int j = 1; j <= mx; j++)
if (val % j == 0) {
long long x = val / j;
if (0 < x && x <= mx && x <= j) {
if (x < j)
ans += (long long)num[j] * num[x];
else
ans += (long long)num[j] * (num[j] - 1) >> 1;
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, k;
int a[maxn];
map<vector<pair<int, int> >, int> mp;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
long long ans = 0;
for (int i = 0; i < n; i++) {
vector<pair<int, int> > v1;
for (int cur = 2; cur * cur <= a[i]; cur++) {
int num = 0;
while (a[i] % cur == 0) {
a[i] /= cur;
num++;
}
if (num % k) v1.push_back(make_pair(cur, num % k));
}
if (a[i] > 1) v1.push_back(make_pair(a[i], 1 % k));
vector<pair<int, int> > v2;
for (int j = 0; j < v1.size(); j++) {
v2.push_back(make_pair(v1[j].first, k - v1[j].second));
}
ans += mp[v2];
mp[v1]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + c - 48;
c = getchar();
}
return x * f;
}
long long k, m, n;
long long a[100100], check[100100], tax[100005];
vector<long long> num[100005];
long long sum;
long long hh[100010][110];
signed main() {
n = read();
k = read();
for (register long long i = 1; i <= 100000; i++) {
hh[i][0] = 1;
for (register long long j = 1; j <= 100; j++) {
if (hh[i][j - 1] * i > 1e10) break;
hh[i][j] = hh[i][j - 1] * i;
}
}
for (register long long i = 1; i <= n; i++) {
a[i] = read();
for (register long long j = 2; j * j <= a[i]; j++) {
if (!hh[j][k]) continue;
while (a[i] % hh[j][k] == 0) a[i] /= hh[j][k];
}
}
long long ans = 0;
for (register long long i = 1; i <= n; i++) {
for (register long long j = 1; j * j <= a[i]; j++) {
if (a[i] % j == 0) {
if (hh[j][k] && hh[j][k] % a[i] == 0 && hh[j][k] / a[i] <= 100000) {
ans += check[hh[j][k] / a[i]];
}
if (j * j != a[i] && hh[a[i] / j][k] && hh[a[i] / j][k] % a[i] == 0 &&
hh[a[i] / j][k] / a[i] <= 100000) {
ans += check[hh[a[i] / j][k] / a[i]];
}
}
}
check[a[i]]++;
}
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 101000;
bool is_prime(int x) {
for (int i = 2; i * i <= x; ++i) {
if (x % i == 0) {
return false;
}
}
return true;
}
vector<int> primes;
vector<pair<int, int> > factorize(int x, int modk) {
vector<pair<int, int> > ret;
int y = x;
for (int i = 0; primes[i] * primes[i] <= x; ++i) {
if (y % primes[i] == 0) {
int cnt = 0;
while (y % primes[i] == 0) {
++cnt;
y /= primes[i];
}
if (cnt % modk != 0) {
ret.push_back(make_pair(primes[i], cnt % modk));
}
}
}
if (y > 1) {
ret.push_back(make_pair(y, 1));
}
return ret;
}
int find_equal(vector<pair<int, int> >& ret, int k) {
if (ret.empty()) {
return 1;
}
long long num = 1;
for (int i = 0; i < ret.size(); ++i) {
int pw = k - ret[i].second;
for (int j = 0; j < pw; ++j) {
num *= ret[i].first;
if (num > 1e6) {
return -1;
}
}
}
return num;
}
int comp(vector<pair<int, int> >& ret) {
int res = 1;
for (int i = 0; i < ret.size(); ++i) {
for (int j = 0; j < ret[i].second; ++j) {
res *= ret[i].first;
}
}
return res;
}
void solve() {
for (int i = 2; i < maxN; ++i) {
if (is_prime(i)) {
primes.push_back(i);
}
}
int n, k;
cin >> n >> k;
map<int, int> avail;
long long res = 0;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
auto fact = factorize(x, k);
int eq = find_equal(fact, k);
if (eq != -1) {
res += avail[eq];
}
++avail[comp(fact)];
}
cout << res << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
t = 1;
for (int tt = 0; tt < t; ++tt) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> fact;
vector<pair<int, int>> factcnt, ifactcnt;
map<vector<pair<int, int>>, int> fmap;
int sieve[100005];
void buildsieve() {
for (int i = 2; i < 100005; i++) {
if (!sieve[i]) {
for (int j = i; j < 100005; j += i) {
if (!sieve[j]) sieve[j] = i;
}
}
}
}
int main() {
ios::sync_with_stdio(0);
buildsieve();
fmap.clear();
int n, k;
cin >> n >> k;
long long ans = 0;
for (int i = 0; i < n; i++) {
int ai;
cin >> ai;
int ti = ai;
fact.clear();
while (sieve[ti]) {
fact.push_back(sieve[ti]);
ti /= sieve[ti];
}
factcnt.clear();
ifactcnt.clear();
int f = 0, cnt = 0;
for (auto it : fact) {
if (it != f) {
if (cnt % k) {
cnt %= k;
factcnt.push_back(make_pair(f, cnt));
ifactcnt.push_back(make_pair(f, k - cnt));
}
f = it;
cnt = 0;
}
cnt++;
}
if (cnt % k) {
cnt %= k;
factcnt.push_back(make_pair(f, cnt));
ifactcnt.push_back(make_pair(f, k - cnt));
}
if (fmap.find(ifactcnt) != fmap.end()) ans += fmap[ifactcnt];
fmap[factcnt]++;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void canhazfast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) {
T x0 = 1, y0 = 0, x1 = 0, y1 = 1;
while (b) {
T q = a / b;
a %= b;
swap(a, b);
x0 -= q * x1;
swap(x0, x1);
y0 -= q * y1;
swap(y0, y1);
}
x = x0;
y = y0;
return a;
}
int ctz(unsigned x) { return __builtin_ctz(x); }
int ctzll(unsigned long long x) { return __builtin_ctzll(x); }
int clz(unsigned x) { return __builtin_clz(x); }
int clzll(unsigned long long x) { return __builtin_clzll(x); }
int popcnt(unsigned x) { return __builtin_popcount(x); }
int popcntll(unsigned long long x) { return __builtin_popcountll(x); }
int bsr(unsigned x) { return 31 ^ clz(x); }
int bsrll(unsigned long long x) { return 63 ^ clzll(x); }
vector<pair<unsigned, unsigned> > factorize(unsigned n, unsigned k) {
vector<pair<unsigned, unsigned> > res;
if (int e2 = ctz(n)) {
if (e2 % k) res.emplace_back(2, e2 % k);
n >>= e2;
}
for (unsigned p = 3;; p += 2) {
unsigned q = n / p, r = n % p, e = 0;
if (q < p) break;
while (!r) {
n = q;
q = n / p;
r = n % p;
++e;
}
if (e % k) res.emplace_back(p, e % k);
}
if (n > 1) res.emplace_back(n, 1);
return res;
}
int main() {
canhazfast();
int n, k;
long long ans = 0;
map<vector<pair<unsigned, unsigned> >, int> mp;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
unsigned a;
cin >> a;
vector<pair<unsigned, unsigned> > fsa = factorize(a, k);
vector<pair<unsigned, unsigned> > fsb = fsa;
for (pair<unsigned, unsigned> &f : fsb) {
f.second = k - f.second;
}
int cnt = mp.count(fsb) ? mp[fsb] : 0;
ans += cnt;
++mp[fsa];
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int power(long long a, int b) {
long long f = 1;
for (; b; b >>= 1, a = a * a) {
if (a > 2e5) a = 2e5;
if (b & 1) {
f = f * a;
if (f > 2e5) f = 2e5;
}
}
return f;
}
const int N = 100050;
long long pk[N][102];
int mnp[N];
int p[70], q[70], top;
int c[N];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = (1); i <= (N - 1); ++i) {
pk[i][0] = 1;
for (int j = (1); j <= (k); ++j) {
pk[i][j] = pk[i][j - 1] * i;
if (pk[i][j] > 2e5) pk[i][j] = 2e5;
}
}
for (int i = (N - 1); i >= (2); --i)
for (int j = i; j < N; j += i) mnp[j] = i;
long long ans = 0;
while (n--) {
int x;
scanf("%d", &x);
top = 0;
while (x > 1) {
int i = mnp[x];
top++;
p[top] = i;
q[top] = 0;
while (x % i == 0) {
q[top]++;
x /= i;
}
}
for (int i = (1); i <= (top); ++i) q[i] %= k;
long long t = 1, need = 1;
for (int i = (1); i <= (top); ++i) {
t *= power(p[i], q[i]);
if (q[i]) {
need *= pk[p[i]][k - q[i]];
if (need > 2e5) need = 2e5;
}
}
if (need < N) ans += c[need];
c[t]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void START() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int gh = 1e5 + 6;
const long long mod = 1000000000100011;
int n, g[gh], k;
map<int, int> mp;
long long kq;
void sieve(int n) {
for (int i = 2; i <= n; i++)
if (!g[i])
for (int j = i; j <= n; j += i) g[j] = i;
}
inline int mu(long long a, int b) {
long long c = 1;
for (; b; a = (a * a) % mod, b >>= 1)
if (b & 1) c = (c * a) % mod;
return c;
}
int main() {
START();
sieve(1e5);
cin >> n >> k;
for (int x, i = 1; i <= n; i++) {
cin >> x;
long long tmp1 = 1, tmp2 = 1;
while (x > 1) {
int dem = 0, ga = g[x];
while (x % ga == 0) x /= ga, dem++;
tmp1 = (tmp1 * mu(ga, dem % k)) % mod;
tmp2 = (tmp2 * mu(ga, (k - (dem % k)) % k)) % mod;
}
kq += mp[tmp2];
mp[tmp1]++;
}
cout << kq;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
vector<int> a, B;
long long n, m, w[N], b[N], C[N], A;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= n; i++) {
a.clear(), B.clear();
for (int j = 2; j * j <= w[i]; j++)
if (w[i] % j == 0) {
a.push_back(j), B.push_back(0);
while (w[i] % j == 0) w[i] /= j, B[B.size() - 1]++;
B[B.size() - 1] %= m;
}
if (w[i] > 1) a.push_back(w[i]), B.push_back(1);
w[i] = b[i] = 1;
for (int j = 0; j < a.size(); j++)
for (int k = 1; k <= B[j]; k++) w[i] *= a[j];
for (int j = 0; j < a.size(); j++) {
for (int k = 1; k <= (m - B[j]) % m; k++) {
b[i] *= a[j];
if (b[i] >= N) break;
}
if (b[i] >= N) break;
}
C[w[i]]++;
}
for (int i = 1; i <= n; i++) {
if (b[i] >= N) continue;
if (w[i] == b[i])
A += C[b[i]] - 1;
else
A += C[b[i]];
}
cout << A / 2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5;
const long long M = 1e3;
long long n, k, s[N << 2], bo[N << 2], ann, an2, an1, ch1, ch2, m, ans, sum,
top, an, boo[N << 2];
map<pair<int, long long>, int> ma;
int main() {
scanf("%lld%lld", &n, &k);
for (int i = 2; i <= M; i++) {
if (!bo[i]) s[++top] = i;
for (int j = 1; j <= top; j++) {
if (i * s[j] > M) break;
bo[i * s[j]] = 1;
if (i % s[j] == 0) break;
}
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &m);
ann = 0;
an2 = 1;
an1 = 0;
for (int j = 1; j <= top; j++) {
if (m % s[j]) continue;
an = 0;
while (m % s[j] == 0) {
m /= s[j];
an++;
}
an %= k;
if (an > 0) {
ann = ann * k + an;
an2 = an2 * s[j];
an = k - an;
an1 = an1 * k + an;
}
}
if (m > 1) {
an = 1;
ann = ann * k + an;
an2 = an2 * m;
an = k - an;
an1 = an1 * k + an;
}
if (an2 == 1ll) {
sum++;
continue;
}
ans = ans + ma[make_pair((int)an2, an1)];
ma[make_pair((int)an2, ann)]++;
}
printf("%lld", ans + 1ll * sum * (sum - 1) / 2ll);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 3;
const long long MAXN = 1e5 + 10;
long long spf[MAXN + 3], store[N], _store[N], n, k;
map<long long, long long> K, _K;
long long power(long long base, long long exp) {
long long res = 1;
while (exp) {
if (exp & 1) {
res *= base;
}
exp >>= 1;
base *= base;
}
return res;
}
void sieve() {
spf[1] = 1;
for (long long i = 2; i <= MAXN; i++) spf[i] = i;
for (long long i = 4; i <= MAXN; i += 2) spf[i] = 2;
for (long long i = 3; i * i <= MAXN; i++) {
if (spf[i] == i) {
for (long long j = i * i; j <= MAXN; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
void work(long long x, long long idx) {
map<long long, long long> pfactors, _pfactors;
while (x != 1) {
pfactors[spf[x]]++;
pfactors[spf[x]] %= k;
x = x / spf[x];
}
long long res = 1, _res = 1;
for (auto it : pfactors) {
res *= power(it.first, it.second);
_res *= power(it.first, (k - it.second) % k);
}
K[res]++;
_K[res]++;
store[idx] = res;
_store[idx] = _res;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
sieve();
cin >> n >> k;
map<long long, long long> have;
for (long long i = 1; i <= n; ++i) {
long long a;
cin >> a;
work(a, i);
}
long long ans = 0;
for (long long i = 1; i <= n; ++i) {
long long freq = _K[_store[i]] - (store[i] == _store[i]);
ans += freq;
}
cout << ans / 2 << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, k;
int a[maxn];
map<vector<pair<int, int> >, int> mp;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
long long ans = 0;
for (int i = 0; i < n; i++) {
vector<pair<int, int> > v1;
for (int cur = 2; cur * cur <= a[i]; cur++) {
int num = 0;
while (a[i] % cur == 0) {
a[i] /= cur;
num++;
}
if (num % k) v1.push_back(make_pair(cur, num % k));
}
if (a[i] > 1) v1.push_back(make_pair(a[i], 1));
vector<pair<int, int> > v2;
for (int j = 0; j < v1.size(); j++) {
v2.push_back(make_pair(v1[j].first, k - v1[j].second));
}
ans += mp[v2];
mp[v1]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 102000;
long long n, k, a[maxn], pri[maxn], vis[maxn], pcnt, cnt[maxn], nd[maxn];
long long pkt[maxn][102];
long long bu(long long x, bool chk = false) {
long long ret = 1;
auto deal = [&](long long fac, long long deg) {
deg %= k;
if (deg == 0)
return 1ll;
else
return pkt[fac][k - deg];
};
while (x != 1) {
long long d = vis[x], deg = 0, so;
while (x % d == 0) x /= d, deg++;
if (chk) {
if (deg % k != 0) return -1;
} else {
so = deal(d, deg);
if (so == -1)
return -1;
else {
ret *= so;
if (ret >= maxn) return -1;
}
}
}
return ret;
}
long long yu(long long x) {
long long ret = 1;
auto deal = [&](long long fac, long long deg) {
deg %= k;
return pkt[fac][deg];
};
while (x != 1) {
long long d = vis[x], deg = 0, so;
while (x % d == 0) x /= d, deg++;
so = deal(d, deg);
if (so == -1)
return -1;
else {
ret *= so;
if (ret >= maxn) return -1;
}
}
return ret;
}
signed main() {
memset(pkt, -1, sizeof pkt);
for (long long i = 2; i < maxn; ++i) {
pkt[i][0] = 1;
for (long long j = 1; 1LL * pkt[i][j - 1] * i < maxn; ++j)
pkt[i][j] = pkt[i][j - 1] * i;
if (!vis[i]) pri[++pcnt] = i, vis[i] = i;
for (long long j = 1; j <= pcnt && i * pri[j] < maxn; ++j) {
vis[i * pri[j]] = pri[j];
if (i % pri[j] == 0) break;
}
}
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
cnt[yu(a[i])]++;
long long b = bu(a[i]);
if (b != -1) nd[b]++;
}
long long ans = 0;
for (long long i = 1; i <= 100000; ++i)
if (nd[i]) {
ans += 1LL * nd[i] * cnt[i];
}
for (long long i = 1; i <= 100000; ++i)
if (yu(i) == bu(i)) {
ans -= cnt[i];
}
ans /= 2;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
int sign(T a) {
if (a == 0) return 0;
return (a > 0 ? 1 : -1);
}
template <typename T1, typename T2>
T2 mod(T1 x, T2 MOD) {
if (x < 0) x += MOD;
if (x >= MOD) x -= MOD;
return x;
}
template <typename T>
T sqr(T a) {
return a * a;
}
template <typename T>
bool uax(T& a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool uin(T& a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& p) {
in >> p.first >> p.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2>& p) {
out << '(' << p.first << ' ' << p.second << ')';
return out;
}
mt19937_64 gen_rand;
const int N = (int)3e5 + 7;
const int LOG = 31;
const int N_ = (int)507;
const int MAXN = (int)8e5 + 7;
const int MOD = (int)1e9 + 7;
const int INF = (int)2e9 + 7;
const int CONST = 5000;
const long long LINF = (int64_t)1e10;
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 5e-1;
int n, k, a[N], cnt[N];
int main() {
cout << fixed << setprecision(20);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
gen_rand.seed(time(0));
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
if (k == 2) {
map<int, int> cnt;
for (int i = 0; i < n; i++) {
int val = 1;
for (int j = 2; j * j <= a[i]; j++) {
int x = 0;
while (a[i] % j == 0) x++, a[i] /= j;
if (x & 1) val *= j;
}
if (a[i] != 1) val *= a[i];
cnt[val]++;
}
long long ans = 0;
for (auto it : cnt) {
if (it.second == 1) continue;
ans += 1LL * it.second * (it.second - 1) / 2;
}
cout << ans;
} else {
vector<long long> pw;
bool fl = true;
for (int i = 1;; i++) {
long long x = 1;
for (int j = 0; j < k; j++) {
if (x * i > LINF) {
fl = false;
break;
}
x *= i;
}
if (!fl) break;
pw.push_back(x);
}
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
for (long long x : pw) {
if (x / a[i] > (int)1e5) break;
if (x % a[i] == 0) ans += cnt[x / a[i]];
}
cnt[a[i]]++;
}
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010, sq = 333;
inline long long read() {
char ch = getchar();
long long x = 0, f = 0;
while (ch < '0' || ch > '9') f |= ch == '-', ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
int n, k, a[maxn];
vector<pair<int, int> > d[maxn], tmp;
map<vector<pair<int, int> >, int> cnt;
long long ans;
int main() {
n = read();
k = read();
for (int i = (1); i <= (n); i++) a[i] = read();
for (int i = (1); i <= (n); i++) {
int x = a[i];
tmp.clear();
for (int j = (2); j <= (sqrt(x)); j++)
if (x % j == 0) {
int cnt = 0;
while (x % j == 0) x /= j, cnt = (cnt + 1) % k;
if (cnt)
d[i].push_back(make_pair(j, cnt)),
tmp.push_back(make_pair(j, k - cnt));
}
if (x > 1)
d[i].push_back(make_pair(x, 1)), tmp.push_back(make_pair(x, k - 1));
ans += cnt[tmp];
cnt[d[i]]++;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
long long pk[100005];
int A[100005], C[100005], vis[100005];
vector<int> vec[100005];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int N, K;
cin >> N >> K;
for (int i = 1; i <= N; ++i) cin >> A[i], C[A[i]]++;
for (int i = 1; i <= 100000; ++i) {
for (int j = 1; j * j <= i; ++j) {
if (i % j == 0) vec[i].push_back(j);
}
int t = 0;
if (vec[i].back() * vec[i].back() == i) {
t = vec[i].back();
vec[i].pop_back();
}
for (int j = (int)vec[i].size() - 1; j >= 0; --j)
vec[i].push_back(i / vec[i][j]);
if (t) vec[i].push_back(t);
}
int bar = 100001;
for (int i = 1; i <= 100000; ++i) {
long long a = 1;
int flag = 0;
for (int j = 1; j <= K; ++j) {
a *= i;
if (a > 1e10) {
flag = 1;
break;
}
}
if (flag) {
bar = i;
break;
}
pk[i] = a;
}
long long ans = 0;
sort(A + 1, A + N + 1);
if (K == 2) {
for (int i = 1; i < bar; ++i) {
for (auto j : vec[i]) {
for (auto k : vec[i]) {
if (j >= k) continue;
if (1ll * i * k / j > 100000 || vis[i / k * j] == i) continue;
vis[i / j * k] = i;
vis[i / k * j] = i;
ans += 1ll * C[i / j * k] * C[i / k * j];
}
}
ans += 1ll * C[i] * (C[i] - 1) / 2;
}
cout << ans;
return 0;
}
for (int i = 1; i <= N; ++i) {
for (int j = 1; j < bar; ++j) {
if (pk[j] % A[i]) continue;
if (pk[j] == 1ll * A[i] * A[i])
ans += C[A[i]] - 1;
else if (pk[j] / A[i] <= 100000)
ans += C[pk[j] / A[i]];
}
}
cout << ans / 2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
int n, k, cnt[111111], a[111111], mxx, prime[111111], ct, mx[111111], cnr;
long long cur, ans, ts, fuck, fk;
bool f, fl[111111];
void Init() {
for (int i = 2; i <= maxn; i++) {
if (!fl[i]) {
prime[++ct] = i;
}
for (int j = 1; j <= ct && i * prime[j] <= maxn; j++) {
fl[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
for (int i = 1; i <= ct; i++) {
for (int j = prime[i]; j <= maxn; j += prime[i]) {
mx[j] = i;
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) cnt[a[i]]++;
for (int i = 2; i <= maxn; i++) {
cur = 1;
for (int j = 1; j <= k; j++) {
if (cur > 100000) {
f = 1;
break;
}
cur = cur * i;
}
if (cur > 100000) {
mxx = i - 1;
break;
}
}
Init();
for (int i = 1; i <= n; i++) {
cur = a[i];
fuck = 1;
while (cur > 1) {
int x = mx[cur];
cnr = 0;
while (cur % prime[x] == 0) {
cnr++;
cur /= prime[x];
}
cnr = (cnr - 1) % k + 1;
for (int j = 1; fuck != -1 && j <= k - cnr; j++) {
fuck *= prime[x];
if (fuck > maxn) fuck = -1;
}
}
if (fuck == -1) continue;
for (int j = 1; j <= mxx; j++) {
fk = fuck;
for (int h = 1; fk != -1 && h <= k; h++) {
fk *= j;
if (fk > maxn) fk = -1;
}
if (~fk) {
if (fk == a[i])
ans += (cnt[fk] - 1);
else
ans += cnt[fk];
} else
break;
}
}
printf("%lld\n", ans / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, k;
long long a[N], sp[N];
map<vector<pair<int, int> >, int> f;
int main() {
for (int i = 2; i * i < N; ++i) {
if (sp[i]) continue;
sp[i] = i;
for (int j = i * i; j < N; j += i) {
if (!sp[j]) sp[j] = i;
}
}
for (int i = 2; i < N; ++i)
if (!sp[i]) sp[i] = i;
cin >> n >> k;
long long ans = 0;
for (int i = 1; i <= n; ++i) {
scanf("%lld", a + i);
int x = a[i];
vector<pair<int, int> > one, two;
while (x > 1) {
int p = sp[x], e = 0;
while (x % p == 0) x /= p, ++e;
e %= k;
if (e) {
one.emplace_back(p, e);
e = k - e;
two.emplace_back(p, e);
}
}
ans += f[two];
++f[one];
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200005];
map<long long, long long> mp;
vector<pair<int, int> > v;
int main() {
int n, k;
long long ans = 0;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
if (a[i] == 1) {
ans += mp[1];
mp[1]++;
continue;
}
long long now = 1;
for (int j = 2; j * j <= a[i]; j++) {
if (a[i] % j) continue;
int num = 0;
while (a[i] % j == 0) {
num++;
a[i] /= j;
}
v.push_back(pair<int, int>(j, num % k));
}
if (a[i] > 1) v.push_back(pair<int, int>(a[i], 1));
long long need = 1;
for (auto p : v) {
if (p.second == 0) continue;
for (int j = 1; j <= k - p.second; j++) need *= p.first;
for (int j = 1; j <= p.second; j++) now *= p.first;
if (need > 1e5) need = 0;
}
v.clear();
ans += mp[need];
mp[now]++;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, k;
int cnt[maxn];
int a[maxn];
int main() {
while (cin >> n >> k) {
memset(cnt, 0, sizeof cnt);
for (int i = 1; i <= n; i++) {
cin >> a[i];
cnt[a[i]]++;
}
long long ans = 0;
for (int i = 1; i <= 1e5; i++) {
if (!cnt[i]) continue;
vector<pair<int, int> > v;
int now = i;
for (int z = 2; z * z <= now; z++) {
if (now % z == 0) {
int c = 0;
while (now % z == 0) now /= z, c++;
v.push_back(make_pair(z, c));
}
}
if (now > 1) v.push_back(make_pair(now, 1));
long long mi = i;
long long mul = 1;
bool check = true;
bool wrong = false;
for (auto item : v) {
int mo = item.second % k;
if (mo != 0) {
for (int j = 0; j < k - mo; j++) {
mi *= item.first, mul *= item.first;
if (mul > 1e5) wrong = true;
}
}
if (mo > 0 && mo * 2 != k) check = false;
}
if (check) ans += (long long)cnt[i] * (cnt[i] - 1);
if (mul != i && !wrong) ans += (long long)cnt[i] * cnt[mul];
if (wrong) continue;
for (int j = 2;; j++) {
long long now = mul;
bool is_wrong = false;
for (int z = 0; z < k; z++) {
now *= j;
if (now > 1e5) {
is_wrong = true;
break;
}
}
if (is_wrong) break;
if (now != i && !is_wrong) ans += (long long)cnt[i] * cnt[now];
}
}
cout << ans / 2 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using PII = pair<int, int>;
const int MAX = 1e5;
int main() {
int n, k;
scanf("%d%d", &n, &k);
unordered_map<int, int> mp;
LL ans = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
assert(x >= 1 && x <= MAX);
int y = 1;
LL yy = 1;
for (int j = 2; j * j <= x; j++) {
int cnt = 0;
while (x % j == 0) {
cnt++;
x /= j;
}
if (cnt) {
cnt %= k;
for (int t = 1; t <= cnt; t++) y *= j;
cnt = k - cnt;
cnt %= k;
for (int t = 1; t <= cnt; t++) {
if (yy != -1) {
yy *= j;
if (yy > MAX) yy = -1;
} else {
break;
}
}
}
}
if (x != 1) {
y *= x;
for (int t = 1; t <= k - 1; t++) {
if (yy != -1) {
yy *= x;
if (yy > MAX) yy = -1;
} else {
break;
}
}
}
ans += mp[yy];
mp[y]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<vector<pair<int, int> >, int> cnt;
int main() {
int n, k;
cin >> n >> k;
long long ans = 0;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
vector<pair<int, int> > pcnt;
vector<pair<int, int> > temp;
for (int p = 2; p * p <= x; ++p) {
if (x % p == 0) {
int cc = 0;
while (x % p == 0) {
++cc;
x /= p;
}
if (cc % k != 0) {
pcnt.push_back(make_pair(p, cc % k));
}
}
}
if (x > 1) pcnt.push_back(make_pair(x, 1));
for (int j = 0; j < pcnt.size(); ++j) {
temp.push_back(make_pair(pcnt[j].first, k - pcnt[j].second));
}
ans += cnt[temp];
++cnt[pcnt];
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
cin >> n >> k;
const ll M = 1e5 + 1;
const ll B = M * M;
vector<ll> caps(M, 1);
for (int j = 2; j < M; ++j) {
for (int l = 0; l < k; ++l) {
caps[j] *= j;
if (caps[j] > B) {
caps[j] = -1;
break;
}
}
}
vector<int> count(M);
vector<vector<ll>> factors(M);
for (int p = 2; p < M; ++p) {
if (!factors[p].empty()) continue;
for (int j = p; j < M; j += p) {
factors[j].push_back(p);
}
}
ll ans = 0;
for (int i = 0; i < n; ++i) {
ll a;
cin >> a;
ll b = 1, c = a;
for (ll p : factors[a]) {
if (caps[p] == -1) {
b = -1;
break;
}
while (a % caps[p] == 0) {
a /= caps[p];
c /= caps[p];
}
if (a % p == 0) {
b *= caps[p];
}
while (a % p == 0) {
a /= p;
b /= p;
}
}
if (b == -1) continue;
if (b < M) {
ans += count[b];
}
++count[c];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 43;
const int maxm = 2e3 + 43;
const int maxlog = 22;
const int mod = 1e9 + 7;
const int sq = 340;
const int inf = 1e9;
const long double PI = 3.141592653589793238463;
long long cnt[10 * maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(15);
long long n, k;
cin >> n >> k;
if (k != 2) {
vector<long long> nums;
for (long long i = 1; i <= (long long)(1e5 + 3); i++) {
long long cur = 1;
for (long long j = 1; j <= k; j++) {
cur *= i;
if (cur > 1e10 + 34) break;
}
if (cur <= 1e10 + 34)
nums.push_back(cur);
else
break;
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
for (long long j = 0; j < nums.size(); j++) {
long long y = nums[j];
if (y % x == 0) {
if (y / x < maxn) {
ans += cnt[y / x];
}
}
}
cnt[x]++;
}
cout << ans << endl;
return 0;
} else {
long long ans = 0;
map<vector<long long>, long long> ma;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
vector<long long> v;
long long y = x;
for (long long i = 2; i * i <= x; i++) {
if (y % i == 0) {
bool flag = false;
while (y % i == 0) {
y /= i;
flag ^= 1;
}
if (flag) v.push_back(i);
}
}
if (y != 1) v.push_back(y);
sort(v.begin(), v.end());
ans += ma[v];
ma[v]++;
}
cout << ans << endl;
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long INF = 1e7;
long long p(long long n, long long k) {
if (k == 0) return 1;
if (k % 2 == 1)
return min(INF, n * p(min(INF, n * n), k / 2));
else
return p(min(INF, n * n), k / 2);
}
int main() {
ios_base::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
for (long long x = 2; p(x, k) <= a[i]; x++) {
while ((a[i] % p(x, k)) == 0) a[i] /= p(x, k);
}
}
long long ans = 0;
map<long long, long long> K;
for (long long i = 0; i < n; i++) {
long long x = a[i];
long long y = 1;
for (long long p_ = 2; p_ <= 320; p_++) {
long long alfa = 0;
while (x % p_ == 0) {
x /= p_;
alfa++;
}
if (alfa > 0) y *= p(p_, k - alfa);
y = min(y, INF);
}
if (x != 1) y *= p(x, k - 1);
y = min(y, INF);
ans += K[y];
K[a[i]]++;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, k;
long long a[N], b[N];
int ma[N];
long long qpow(long long a, long long n) {
if (n < 0) throw;
long long r = 1;
for (; n; a = a * a, n >>= 1)
if (n & 1) r = r * a;
return r;
}
int main() {
ma[1] = 1;
for (int i = 2; i < N; ++i)
if (!ma[i]) {
for (int j = i; j < N; j += i) ma[j] = max(ma[j], i);
}
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%lld", a + i);
for (int i = 1; i <= n; ++i) {
b[i] = 1;
int first = a[i], second = 1;
while (first != 1) {
int p = ma[first], cnt = 0;
while (first % p == 0) first /= p, ++cnt;
cnt %= k;
if (cnt) {
b[i] *= qpow(p, k - cnt);
second *= qpow(p, cnt);
}
}
a[i] = second;
}
long long ans = 0;
map<long long, int> vis;
for (int i = 1; i <= n; ++i) {
ans += vis[b[i]];
++vis[a[i]];
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> prime_division(int64_t n, int K) {
vector<int> ret;
for (int64_t i = 2; i * i <= n; i++) {
int cnt = 0;
while (n % i == 0) {
n /= i;
cnt++;
}
if (cnt % K) {
ret.push_back(i);
ret.push_back(cnt % K);
}
}
if (n > 1) {
ret.push_back(n);
ret.push_back(1);
}
return ret;
}
int main() {
int N, K, A[100000];
cin >> N >> K;
for (int i = 0; i < N; i++) cin >> A[i];
int64_t ans = 0;
map<vector<int>, int> mp;
for (int i = 0; i < N; i++) {
auto v = prime_division(A[i], K);
int sz = v.size();
auto v2 = v;
for (int i = 1; i < sz; i += 2) {
v2[i] = K - v[i];
}
if (mp.count(v2)) ans += mp[v2];
mp[v]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <ll i, class T>
void print_tuple(ostream&, const T&) {}
template <ll i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
if (i) os << ",";
os << get<i>(t);
print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
os << "{";
print_tuple<0, tuple<Args...>, Args...>(os, t);
return os << "}";
}
void print(ll x, ll suc = 1) {
cout << x;
if (suc == 1) cout << "\n";
if (suc == 2) cout << " ";
}
ll read() {
ll i;
cin >> i;
return i;
}
vi readvi(ll n, ll off = 0) {
vi v(n);
for (ll i = ll(0); i < ll(n); i++) v[i] = read() + off;
return v;
}
template <class T>
void print(const vector<T>& v, ll suc = 1) {
for (ll i = ll(0); i < ll(v.size()); i++)
print(v[i], i == ll(v.size()) - 1 ? suc : 2);
}
string readString() {
string s;
cin >> s;
return s;
}
template <class T>
T sq(const T& t) {
return t * t;
}
void yes(bool ex = true) {
cout << "Yes" << endl;
if (ex) exit(0);
}
void no(bool ex = true) {
cout << "No" << endl;
if (ex) exit(0);
}
constexpr ll ten(ll n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const ll inf = infLL;
ll topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
ll topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
ll botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
ll botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
ll popcount(signed t) { return __builtin_popcount(t); }
ll popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(ll i) { return i && (i & -i) == i; }
ll mask(ll i) { return (ll(1) << i) - 1; }
bool inc(ll first, ll second, ll c) { return first <= second && second <= c; }
template <class t>
void mkuni(vc<t>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
static random_device rd;
static mt19937_64 gen(rd());
return uniform_int_distribution<ll>(l, r)(gen);
}
const ll vmax = 100010;
bool pri[vmax];
void initprime() {
for (ll i = ll(2); i < ll(vmax); i++) pri[i] = 1;
for (ll i = ll(2); i < ll(vmax); i++)
if (pri[i])
for (ll j = i * 2; j < vmax; j += i) pri[j] = 0;
}
vi factors[vmax];
void initfactor() {
for (ll i = ll(2); i < ll(vmax); i++)
if (pri[i])
for (ll j = i; j < vmax; j += i) factors[j].push_back(i);
}
ll y[vmax], z[vmax];
void mult(ll& first, ll second) { first = min(first * second, vmax); }
ll mypow(ll first, ll n) {
ll res = 1;
while (n) {
if (n & 1) mult(res, first);
mult(first, first);
n >>= 1;
}
return res;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
initprime();
initfactor();
ll n, k;
cin >> n >> k;
for (ll i = ll(1); i < ll(vmax); i++) {
ll x = i;
ll p = 1, w = 1;
for (auto f : factors[i]) {
ll c = 0;
while (x % f == 0) {
c++;
x /= f;
}
c %= k;
mult(p, mypow(f, c));
c = (k - c % k) % k;
mult(w, mypow(f, c));
}
if (i < 10) {
void(0);
void(0);
}
y[i] = p;
z[i] = w;
}
vi cnt(vmax + 1);
ll ans = 0;
for (ll i = ll(0); i < ll(n); i++) {
ll first;
cin >> first;
first = y[first];
ans += cnt[z[first]];
cnt[first]++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int NMAX = 100010;
int pfac[NMAX];
ll byKFreePart[NMAX];
int kFreeConjugate[NMAX];
int kFreePart[NMAX];
void fillWithPFactors(int x, map<int, int> &m) {
if (x == 1) return;
++m[pfac[x]];
fillWithPFactors(x / pfac[x], m);
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 2; i < NMAX; ++i) pfac[i] = i;
for (int i = 2; i < NMAX; ++i) {
if (pfac[i] < i) continue;
for (int toMark = 2 * i; toMark < NMAX; toMark += i) pfac[toMark] = i;
}
for (int i = 1; i < NMAX; ++i) {
map<int, int> cpf;
fillWithPFactors(i, cpf);
for (auto &p_e : cpf) p_e.second %= k;
kFreePart[i] = 1;
for (auto p_e : cpf) {
for (int k = 0; k < p_e.second; ++k) kFreePart[i] *= p_e.first;
}
for (auto &p_e : cpf) p_e.second = (k - p_e.second) % k;
ll cprod = 1;
for (auto p_e : cpf) {
for (int k = 0; k < p_e.second && cprod < NMAX; ++k) cprod *= p_e.first;
}
if (cprod < NMAX)
kFreeConjugate[i] = cprod;
else
kFreeConjugate[i] = -1;
}
ll ans = 0;
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
if (kFreeConjugate[x] > -1) ans += byKFreePart[kFreeConjugate[x]];
++byKFreePart[kFreePart[x]];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, limit = 1e6;
long long pw[N][101], sv[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
for (int i = 1; i < N; i++) {
pw[i][0] = 1;
for (int j = 1; j < 101; j++) {
if (limit / i < pw[i][j - 1] || pw[i][j - 1] == 0)
pw[i][j] = 0;
else
pw[i][j] = pw[i][j - 1] * 1LL * i;
}
}
int n, k;
cin >> n >> k;
long long ans = 0;
for (int i = 0, x; i < n; i++) {
vector<pair<int, int> > pr;
cin >> x;
for (int j = 2; j * j <= x; j++) {
int cnt = 0;
while (x % j == 0) x /= j, cnt++;
if (cnt % k) pr.emplace_back(j, cnt % k);
}
if (x > 1) pr.emplace_back(x, 1);
long long num = 1;
int num2 = 1;
for (auto &y : pr) {
num = num * 1LL * pw[y.first][k - y.second];
num2 *= pw[y.first][y.second];
}
if (num < N) ans += sv[num];
sv[num2]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 220010, p = 179, mod = 17917917911791;
long long int predp[maxn];
map<long long int, long long int> mp;
int main() {
cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false);
long long int n, k;
cin >> n >> k;
predp[0] = 1;
for (int d = 1; d < maxn; d++) {
predp[d] = (predp[d - 1] * p) % mod;
}
vector<long long int> mas(n, 0);
for (int d = 0; d < n; d++) {
cin >> mas[d];
}
long long int ans = 0;
for (int d = 0; d < n; d++) {
vector<pair<long long int, long long int> > del;
long long int n1 = mas[d];
long long int hash1 = 0;
long long int hash2 = 0;
for (int i = 2; i * i <= mas[d] && i <= n1; i++) {
if (n1 % i == 0) {
long long int cnt = 0;
while (n1 % i == 0) {
n1 /= i;
cnt++;
}
cnt %= k;
hash1 += predp[i] * cnt;
hash1 %= mod;
hash2 += predp[i] * ((k - cnt) % k);
hash2 %= mod;
}
}
if (n1 != 1) {
hash1 += predp[n1];
hash1 %= mod;
hash2 += predp[n1] * (k - 1);
hash2 %= mod;
}
ans += mp[hash2];
mp[hash1]++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long INF = 1000000001;
const long long INF2 = 1000000000000000001LL;
const double PI = acos(-1);
const double ERR = 1e-10;
const int N = 100005;
long long n, k;
int a[N];
vector<pair<int, char> > v1[N];
vector<pair<int, char> > v[N];
const int PN = 100005;
bool isprime[PN];
void primechk() {
for (int i = 2; i < PN; i++) isprime[i] = true;
for (long long i = 2; i < PN; i++)
if (isprime[i]) {
v[i].push_back(pair<int, char>(i, 1));
for (long long j = i * i; j < PN; j += i) isprime[j] = false;
for (long long j = 2 * i; j < PN; j += i) {
v[j].push_back(pair<int, char>(i, 1));
long long j1 = j / i;
while (j1 != 0 && j1 % i == 0) {
j1 /= i;
v[j][(int)v[j].size() - 1].second++;
}
}
}
}
map<vector<pair<int, char> >, long long> m;
int main() {
primechk();
scanf("%lld", &n);
scanf("%lld", &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
vector<pair<int, char> > vv;
vv.push_back(pair<int, char>(0, 0));
unsigned long long m1 = 1;
for (int j = 0; j < v[a[i]].size(); j++) {
pair<int, char> now = v[a[i]][j];
if (now.second % k != 0) {
now.second = now.second % k;
vv.push_back(now);
}
}
if (m.find(vv) == m.end()) {
m[vv] = 1;
} else
m[vv]++;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
vector<pair<int, char> > vv;
vector<pair<int, char> > vv1;
vv.push_back(pair<int, char>(0, 0));
vv1.push_back(pair<int, char>(0, 0));
unsigned long long m1 = 1, m2 = 1;
for (int j = 0; j < v[a[i]].size(); j++) {
pair<int, char> now = v[a[i]][j];
if (now.second % k != 0) {
now.second = now.second % k;
vv.push_back(now);
vv1.push_back(now);
vv[(int)vv.size() - 1].second = k - vv[(int)vv.size() - 1].second;
}
}
m[vv1]--;
if (m.find(vv) != m.end()) {
ans += m[vv];
}
m[vv1]++;
}
printf("%lld", ans / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[600030], n, k;
int f(int x) {
int ret = 1;
for (int i = 2; i * i <= x; ++i) {
if (x % i) continue;
int t = 0;
while (x % i == 0) {
x /= i;
t += 1;
}
t %= k;
while (t--) ret *= i;
}
if (x > 1) {
ret *= x;
}
return ret;
}
bool check(int t, int x, int k) {
for (int i = 1; i <= k; ++i) {
if (1LL * t * x > 600030) {
return false;
}
t *= x;
}
return true;
}
int g(int x) {
int ret = 1;
for (int i = 2; i * i <= x; ++i) {
if (x % i) continue;
int t = 0;
while (x % i == 0) {
x /= i;
++t;
}
t = (k - t) % k;
if (!check(ret, i, t)) {
return -1;
}
while (t--) ret *= i;
}
if (x > 1) {
if (!check(ret, x, k - 1)) {
return -1;
}
for (int i = 1; i <= k - 1; ++i) ret *= x;
}
return ret;
}
int main() {
map<int, int> mp;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
a[i] = f(a[i]);
mp[a[i]]++;
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int v = g(a[i]);
ans += mp[v];
if (v == a[i]) ans--;
}
printf("%lld\n", ans / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
long long n, k, a[N];
map<vector<pair<int, int> >, int> cnt;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
long long ans = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
long long tmp = a[i];
vector<pair<int, int> > prDiv, findDiv;
for (int j = 2; j <= sqrt(tmp); j++) {
if (tmp % j == 0) {
int cnt = 0;
while (tmp % j == 0) {
tmp /= j;
cnt++;
}
if (cnt % k != 0) {
prDiv.push_back({j, cnt % k});
findDiv.push_back({j, k - (cnt % k)});
}
}
}
if (tmp > 1) {
prDiv.push_back({tmp, 1});
findDiv.push_back({tmp, k - 1});
}
ans += cnt[findDiv];
cnt[prDiv]++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000001;
const long long int INFLL = 10000000001;
const long double EPS = 1e-6;
const int MAXN = 100005;
const int FACTORS_THRESHOLD = 100005;
int A[MAXN];
int T[MAXN];
long long int Power(int x, int y) {
long long int r = 1;
for (int i = 0; i < y; i++) {
r = min(INFLL, r * x);
if (r >= INFLL) break;
}
return r;
}
void Sieve(int n, vector<int>* primes, vector<int>* factors) {
factors->resize(n + 1);
for (int i = 2; i * i <= n; i++) {
if ((*factors)[i] != 0) continue;
for (int j = 2 * i; j <= n; j += i)
if ((*factors)[j] == 0) (*factors)[j] = i;
}
(*factors)[1] = 1;
for (int i = 2; i <= n; i++)
if ((*factors)[i] == 0) {
(*factors)[i] = i;
primes->push_back(i);
}
}
int SmallestFactor(long long int n, const vector<int>& primes,
const vector<int>& factors) {
if (n <= FACTORS_THRESHOLD) {
if (factors[n] == n) return 1;
return factors[n];
} else {
for (int i = 0; i < primes.size(); i++)
if (n % primes[i] == 0) return primes[i];
return 1;
}
}
void Factorize(long long int n, const vector<int>& primes,
const vector<int>& factors,
unordered_map<long long int, int>* factorization) {
if (n == 1) return;
long long int d = SmallestFactor(n, primes, factors);
if (d == 1) {
(*factorization)[n]++;
return;
}
Factorize(d, primes, factors, factorization);
Factorize(n / d, primes, factors, factorization);
}
unordered_map<long long int, int> Factorize(long long int n,
const vector<int>& primes,
const vector<int>& factors) {
unordered_map<long long int, int> factorization;
Factorize(n, primes, factors, &factorization);
return factorization;
}
void Divisors(const unordered_map<long long int, int>& factorization,
unordered_map<long long int, int>::iterator it,
long long int divisor, vector<long long int>* result) {
if (it == factorization.end()) {
result->push_back(divisor);
return;
}
for (int i = 0; i <= it->second; i++) {
Divisors(factorization, next(it), divisor, result);
divisor *= it->first;
}
}
vector<long long int> Divisors(long long int n, const vector<int>& primes,
const vector<int>& factors) {
unordered_map<long long int, int> factorization =
Factorize(n, primes, factors);
vector<long long int> divisors;
Divisors(factorization, factorization.begin(), 1LL, &divisors);
return divisors;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
vector<int> primes, factors;
Sieve(FACTORS_THRESHOLD, &primes, &factors);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> T[i];
A[T[i]]++;
}
long long int result = 0;
for (int i = 1;; i++) {
long long int pwr = Power(i, k);
if (pwr >= INFLL) break;
vector<long long int> dvs = Divisors(pwr, primes, factors);
for (long long int x : dvs) {
long long int y = pwr / x;
if (x >= MAXN) continue;
if (y >= MAXN) continue;
if (x > y) continue;
if (x != y) result += (long long int)A[x] * A[y];
if (x == y) result += ((long long int)A[x] * (A[x] - 1)) / 2;
}
}
cout << result << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
class RangeCountExact {
map<T, int> mp;
vector<vector<int>> idxs;
int get(int r, T x) {
if (mp.count(x) == 0) return 0;
int a = mp[x];
return lower_bound(idxs[a].begin(), idxs[a].end(), r) - idxs[a].begin();
}
public:
RangeCountExact(const vector<T> &as) {
for (auto &a : as) mp[a];
int N = 0;
for (auto &p : mp) {
p.second = N++;
}
idxs.resize(N);
for (int i = 0; i < as.size(); i++) {
idxs[mp[as[i]]].push_back(i);
}
}
int get(int l, int r, T x) { return get(r, x) - get(l, x); }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<set<int>> as;
map<int, int> kesu;
for (int i = 0; i < n; i++) {
set<int> ps;
int a;
cin >> a;
for (int j = 2; j * j <= a; j++) {
if (a % j == 0) {
int cnt = 0;
while (a % j == 0) {
a /= j;
cnt++;
}
cnt %= k;
if (cnt) {
int b = 1;
for (int q = 0; q < cnt; q++) b *= j;
ps.insert(b);
long long c = 1;
bool ok = true;
for (int q = 0; q < k - cnt; q++) {
c *= j;
if (c > 1e5) {
ok = false;
break;
}
}
if (ok) {
kesu[b] = c;
kesu[c] = b;
}
}
}
}
if (a > 1) {
ps.insert(a);
long long c = 1;
bool ok = true;
for (int q = 0; q < k - 1; q++) {
c *= a;
if (c > 1e5) {
ok = false;
break;
}
}
if (ok) {
kesu[a] = c;
kesu[c] = a;
}
}
as.push_back(ps);
}
RangeCountExact<set<int>> cnt(as);
long long ans = 0;
for (int i = 0; i < n; i++) {
set<int> need;
bool ok = true;
for (auto &p : as[i]) {
if (kesu.count(p) == 0) {
ok = false;
break;
}
need.insert(kesu[p]);
}
if (ok) ans += cnt.get(i + 1, n, need);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[500005], tt[500005], t[500005];
signed main() {
long long n, k, ans = 0;
scanf("%lld%lld", &n, &k);
if (k == 2) {
for (long long i = 1; i <= n; i++) {
scanf("%lld", a + i);
for (long long j = 2; j * j <= a[i]; j++) {
while (a[i] % (j * j) == 0) a[i] /= (j * j);
}
t[a[i]]++;
}
for (long long i = 1; i <= 100000; i++) ans += t[i] * (t[i] - 1) / 2;
printf("%lld\n", ans);
} else {
long long tot = 0;
for (long long i = 1;; i++) {
long long now = 1, flag = 0;
for (long long j = 1; j <= k; j++) {
now *= i;
if (now > 10000000000ll) {
flag = 1;
break;
}
}
if (flag) break;
t[++tot] = now;
}
for (long long i = 1; i <= n; i++) {
scanf("%lld", a + i);
}
sort(a + 1, a + 1 + n);
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= tot; j++) {
if (t[j] % a[i] != 0) continue;
if (t[j] / a[i] > a[i]) continue;
ans += tt[t[j] / a[i]];
}
tt[a[i]]++;
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
vector<pair<T, int>> factorize(T x) {
vector<pair<T, int>> res;
for (T i = 2; i * i <= x; i++) {
if (x % i == 0) {
res.emplace_back(i, 0);
while (x % i == 0) {
res.back().second++;
x /= i;
}
}
}
if (x > 1) {
if (!res.empty() && res.back().first == x)
res.back().second++;
else
res.emplace_back(x, 1);
}
return res;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n, k;
cin >> n >> k;
map<vector<pair<int, int>>, int> cnt;
ll res = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
auto fs = factorize(a);
vector<pair<int, int>> tf;
for (auto p : fs) {
p.second %= k;
if (p.second != 0) tf.push_back(p);
}
res += cnt[tf];
for (auto& p : tf) {
p.second = k - p.second;
}
cnt[tf] += 1;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char ch[2010];
int i, j, n, g[2010][2010], f[2010][2010], ans;
int main() {
scanf("%s", ch + 1);
n = strlen(ch + 1);
for (i = 0; i <= n + 1; i++) {
if (ch[i] == '(') break;
f[i][0] = 1;
}
for (i = n + 1; i >= 1; i--) {
if (ch[i] == ')') break;
g[i][0] = 1;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= i; j++) {
if (ch[i] == '(')
f[i][j] = f[i - 1][j - 1];
else if (ch[i] == ')')
f[i][j] = f[i - 1][j];
else
f[i][j] = (f[i - 1][j] + f[i - 1][j - 1]) % 998244353;
}
for (i = n; i >= 1; i--)
for (j = 1; j <= n - i + 1; j++) {
if (ch[i] == ')')
g[i][j] = g[i + 1][j - 1];
else if (ch[i] == '(')
g[i][j] = g[i + 1][j];
else
g[i][j] = (g[i + 1][j] + g[i + 1][j - 1]) % 998244353;
}
for (i = 1; i < n; i++) {
for (j = 1; j <= min(i, n - i); j++) {
ans += 1ll * f[i][j] * g[i + 1][j] % 998244353 * j % 998244353;
ans %= 998244353;
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, t;
long long res, l[1000050][3], r[1000050][3], p[1005000];
char s[1005000];
long long jc[1005000], inv[1005000];
long long ksm(long long a, int p) {
long long res = 1;
while (p) {
if (p & 1) {
res = res * a % 998244353;
}
a = a * a % 998244353;
p >>= 1;
}
return res;
}
long long c(int n, int m) {
if (n < 0 || m < 0 || n < m) {
return 0;
}
return jc[n] * inv[m] % 998244353 * inv[n - m] % 998244353;
}
int main() {
jc[0] = inv[0] = 1;
for (i = 1; i <= 1000000; i++) {
jc[i] = jc[i - 1] * i % 998244353;
}
inv[1000000] = ksm(jc[1000000], 998244353 - 2);
for (i = 999999; i >= 1; i--) {
inv[i] = inv[i + 1] * (i + 1) % 998244353;
}
gets(s + 1);
n = strlen(s + 1);
for (i = n; i >= 1; i--) {
r[i][1] = r[i + 1][1];
r[i][2] = r[i + 1][2];
if (s[i] == ')') {
r[i][1]++;
}
if (s[i] == '?') {
r[i][2]++;
}
}
for (i = 1; i <= n; i++) {
l[i][1] = l[i - 1][1];
l[i][2] = l[i - 1][2];
if (s[i] == '(') {
l[i][1]++;
}
if (s[i] == '?') {
l[i][2]++;
}
for (j = max(l[i][1], r[i + 1][1]);
j <= min(l[i][1] + l[i][2], r[i + 1][1] + r[i + 1][2]); j++) {
res += c(l[i][2], j - l[i][1]) * c(r[i + 1][2], j - r[i + 1][1]) %
998244353 * j % 998244353;
}
}
printf("%lld", res % 998244353);
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const int mods[10] = {1000000007, 999999937, 999999929, 999999893, 999999883,
999999797, 999999761, 999999757, 999999751, 999999739};
const int mod = 998244353;
int rand_mods[2];
const long double eps = 1e-10;
const int siz = 2e3 + 5, siz2 = 3e5 + 5, lg = 20, block = 300, block2 = 1000,
mxv = 1e5 + 1, sqrt_mod = 31630;
const int alpha_sz = 26;
char arr[siz];
int dp[siz][siz][4], qcmu[siz];
int mul(long long a, long long b) { return (a * b) % mod; }
int powmod(int a, int b) {
if (b == 0) {
return 1;
}
int p = powmod(a, b / 2);
p = mul(p, p);
return b % 2 ? mul(p, a) : p;
}
int add(long long a, long long b) { return (a + b) % mod; }
int sum(int l, int r) {
int ret = 0;
for (int i = 0; i < 4; i++) {
ret = add(ret, dp[l][r][i]);
}
return ret;
}
int main() {
scanf("%s", arr + 1);
int sz = strlen(arr + 1);
for (int i = 1; i <= sz; i++) {
qcmu[i] = (arr[i] == '?') + qcmu[i - 1];
}
for (int i = 1; i < sz; i++) {
dp[i][i + 1][1] = arr[i] != ')' && arr[i + 1] != '(';
}
for (int len = 3; len <= sz; len++) {
for (int i = 1; i + len - 1 <= sz; i++) {
int l = i, r = i + len - 1;
if (arr[l] != ')' && arr[r] != '(') {
dp[l][r][1] = add(sum(l + 1, r - 1), powmod(2, qcmu[r - 1] - qcmu[l]));
}
if (arr[l] != '(' && arr[r] != '(') {
dp[l][r][3] = add(dp[l + 1][r][1], dp[l + 1][r][3]);
}
if (arr[l] != ')' && arr[r] != ')') {
dp[l][r][0] = add(dp[l][r - 1][0], dp[l][r - 1][1]);
}
if (arr[l] != '(' && arr[r] != ')') {
dp[l][r][2] = sum(l + 1, r - 1);
}
}
}
printf("%d\n", sum(1, sz));
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 2e3 + 10;
const int maxm = 1e5 + 10;
const long long int mod = 998244353;
const long long int INF = 1e18 + 100;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1.0);
const double eps = 1e-8;
using namespace std;
int n, m;
int cas, tol, T;
char ch[maxn];
long long int pow(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b /= 2;
}
return ans;
}
long long int dp[maxn][maxn], a[maxn];
int main() {
scanf("%s", ch + 1);
int len = strlen(ch + 1);
a[0] = 0;
for (int i = 1; i <= len; i++) {
a[i] = a[i - 1] + (ch[i] == '?' ? 1 : 0);
if (i != len && ch[i] != ')' && ch[i + 1] != '(') dp[i][i + 1] = 1;
}
for (int d = 3; d <= len; d++) {
for (int i = 1; i + d - 1 <= len; i++) {
int j = i + d - 1;
dp[i][j] = 0;
if (ch[i] != '(') dp[i][j] += dp[i + 1][j];
if (ch[j] != ')') dp[i][j] += dp[i][j - 1];
if (ch[i] != '(' && ch[j] != ')') dp[i][j] -= dp[i + 1][j - 1];
if (ch[i] != ')' && ch[j] != '(')
dp[i][j] += dp[i + 1][j - 1] + pow(2ll, a[j - 1] - a[i]);
dp[i][j] %= mod;
}
}
printf("%lld\n", dp[1][len]);
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] = (K + dp[l + 1][r - 1] + dp[l][r - 1] + f[l + 1][r]) % mod;
}
cout << dp[1][n];
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
const int mod = 998244353;
char str[N];
long long l[N], r[N], s[N];
long long q_pow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) (res *= a) %= mod;
(a *= a) %= mod;
b >>= 1;
}
return res;
}
long long c(long long a, long long b) {
if (a < b) return 0;
long long x = 1, y = 1;
for (long long i = a, j = 1; j <= b; i--, j++)
x = x * i % mod, y = y * j % mod;
return (x * q_pow(y, mod - 2)) % mod;
}
long long lu(long long a, long long b) {
if (a < mod && b < mod) return c(a, b);
return (long long)c(a % mod, b % mod) * lu(a / mod, b / mod) % mod;
}
long long cal[2][N];
void init(long long n, long long a[]) {
a[0] = 1;
for (long long i = 1; i <= n; i++) {
a[i] = (((a[i - 1] * (n - i + 1)) % mod) * q_pow(i, mod - 2)) % mod;
}
for (long long i = 1; i <= n; i++) {
(a[i] += a[i - 1]) %= mod;
}
}
int main() {
long long ans = 0;
scanf("%s", str + 1);
long long n = strlen(str + 1);
for (int i = 1; i <= n; i++) {
l[i] = l[i - 1];
r[i] = r[i - 1];
s[i] = s[i - 1];
if (str[i] == '(')
l[i]++;
else if (str[i] == ')')
r[i]++;
else if (str[i] == '?')
s[i]++;
}
init(s[n], cal[s[n] & 1]);
init(s[n] - 1, cal[(s[n] - 1) & 1]);
long long ss = s[n];
for (int i = 1; i <= n; i++) {
long long le = -l[i] + r[n] - r[i] + s[n] - s[i];
if (str[i] == '(') {
le = min(le, ss);
if (le < 0) continue;
(ans += (cal[ss & 1][le])) %= mod;
} else if (str[i] == '?') {
le = min(le - 1, ss - 1);
if (le < 0) continue;
(ans += (cal[(ss - 1) & 1][le])) %= mod;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n;
char s[2010];
int num[2010], sum[2010];
int dp[2010][2010];
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int i, j;
cin >> s + 1;
n = strlen(s + 1);
num[0] = 1;
for (i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + (s[i] == '?');
num[i] = (2LL * num[i - 1]) % mod;
}
for (i = 1; i <= n; i++)
for (j = i - 1; j > 0; j--) {
if (s[j] != '(') dp[j][i] = (dp[j][i] + dp[j + 1][i]) % mod;
if (s[i] != ')') dp[j][i] = (dp[j][i] + dp[j][i - 1]) % mod;
if (s[j] != '(' && s[i] != ')')
dp[j][i] = (dp[j][i] - dp[j + 1][i - 1]) % mod;
if (s[j] != ')' && s[i] != '(')
dp[j][i] =
((dp[j][i] + dp[j + 1][i - 1]) % mod + num[sum[i - 1] - sum[j]]) %
mod;
}
cout << (dp[1][n] + mod) % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 998244353;
long long int power(long long int x, long long int n, long long int &m) {
x %= m;
long long int ans = 1;
while (n > 0) {
if (n & 1) (ans *= x) %= m;
(x = x * x) %= m;
n >>= 1;
}
return ans;
}
const long long int mxn = 2000;
vector<vector<long long int>> dp(mxn + 1, vector<long long int>(mxn + 1, 0));
vector<long long int> prefix(mxn + 1, 0);
long long int len;
long long int getSum(vector<long long int> &prefix, long long int f,
long long int t) {
if (f == 0) return prefix[t];
return (prefix[t] - prefix[f - 1]);
}
void TESTCASE() {
string s;
cin >> s;
len = s.size();
prefix[0] = (s[0] == '?');
for (long long int i = 1; i < len; i++)
prefix[i] = prefix[i - 1] + (s[i] == '?');
for (long long int l = 2; l <= len; l++) {
for (long long int i = 0; i < len - l + 1; i++) {
long long int j = i + l - 1;
if (s[i] == ')' || s[i] == '?') {
dp[i][j] += dp[i + 1][j];
dp[i][j] %= MOD;
}
if (s[j] == '(' || s[j] == '?') {
dp[i][j] += dp[i][j - 1];
dp[i][j] %= MOD;
}
if ((s[i] == '?' && s[j] == '?') || (s[i] == ')' && s[j] == '(') ||
(s[i] == '?' && s[j] == '(') || (s[i] == ')' && s[j] == '?')) {
dp[i][j] -= dp[i + 1][j - 1];
dp[i][j] += MOD;
dp[i][j] %= MOD;
}
if ((s[i] == '?' && s[j] == '?') || (s[i] == '(' && s[j] == ')') ||
(s[i] == '(' && s[j] == '?') || (s[i] == '?' && s[j] == ')')) {
dp[i][j] +=
dp[i + 1][j - 1] + power(2, getSum(prefix, i + 1, j - 1), MOD);
dp[i][j] %= MOD;
}
}
}
cout << dp[0][len - 1] << "\n";
}
signed main() {
long long int TESTS = 1;
while (TESTS--) {
TESTCASE();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int dp[2005][2005], dp2[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[0][1] = 1;
if (s[0] == ')' || s[0] == '?') dp[0][0] = 1;
for (int i = 0; i + 1 < n; ++i)
for (int d = 0; d <= i + 1; ++d) {
if (s[i + 1] == '(' || s[i + 1] == '?') add(dp[i + 1][d + 1], dp[i][d]);
if (s[i + 1] == ')' || s[i + 1] == '?') add(dp[i + 1][d], dp[i][d]);
}
if (s.back() == '(' || s.back() == '?') dp2[n - 1][0] = 1;
if (s.back() == ')' || s.back() == '?') dp2[n - 1][1] = 1;
for (int i = n - 1; i - 1 >= 0; --i)
for (int d = 0; d <= n - i; ++d) {
if (s[i - 1] == '(' || s[i - 1] == '?') add(dp2[i - 1][d], dp2[i][d]);
if (s[i - 1] == ')' || s[i - 1] == '?') add(dp2[i - 1][d + 1], dp2[i][d]);
}
int ans = 0;
for (int i = 0; i + 1 < n; ++i)
for (int d = 1; d <= n; ++d)
add(ans, (long long)dp[i][d] * dp2[i + 1][d] % mod * d % mod);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 998244353;
using namespace std;
string s;
int dp1[3000][3000], dp2[3000][3000];
void sol() {
memset(dp2, 0, sizeof(dp2));
memset(dp1, 0, sizeof(dp1));
int n = s.size();
dp1[0][0] = 1;
dp2[n + 1][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= n; ++j) {
if (s[i - 1] == '(') {
if (j) dp1[i][j] = (dp1[i][j] + dp1[i - 1][j - 1]) % mod;
} else if (s[i - 1] == ')') {
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; ++j) {
if (s[i - 1] == ')') {
if (j) dp2[i][j] = (dp2[i][j] + dp2[i + 1][j - 1]) % mod;
} else if (s[i - 1] == '(') {
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 <= n; ++j) {
ans = (ans + ((1ll * j * dp1[i][j]) % mod) * dp2[i + 1][j]) % mod;
}
}
cout << ans << endl;
}
int main() {
cin >> s;
sol();
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 998244353;
int main() {
string s;
cin >> s;
int n = s.size();
vector<long long int> power_2(n + 1, 1);
for (int i = 1; i < n + 1; i++) {
power_2[i] = (2 * power_2[i - 1]) % mod;
}
vector<long long int> cnt(n + 1, 0);
for (int i = 0; i < n; i++) {
cnt[i + 1] = cnt[i];
if (s[i] == '?') cnt[i + 1]++;
}
vector<vector<long long int> > dp(n, vector<long long int>(n, 0));
for (int length = 2; length < n + 1; length++) {
for (int i = 0; i < n - length + 1; i++) {
int j = i + length - 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] = (dp[i][j] + dp[i + 1][j - 1]) % mod;
dp[i][j] = (dp[i][j] + power_2[cnt[j] - cnt[i + 1]]) % mod;
}
}
}
long long int ans = dp[0][n - 1];
while (ans < 0) ans += mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e3 + 10;
const int mod = 998244353;
char s[MAXN];
int n, bk[MAXN];
long long f[MAXN][MAXN];
long long qpow(long long x, long long k) {
long long res = 1;
while (k) {
if (k & 1) res = res * x % mod;
k >>= 1;
x = x * x % mod;
}
return res;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) bk[i] = bk[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] != '(') f[l][r] = (f[l][r] + f[l + 1][r]) % mod;
if (s[r] != ')') f[l][r] = (f[l][r] + f[l][r - 1]) % mod;
if (s[l] != '(' && s[r] != ')')
f[l][r] = (f[l][r] - f[l + 1][r - 1] + mod) % mod;
if (s[l] != ')' && s[r] != '(')
f[l][r] =
(f[l][r] + f[l + 1][r - 1] + qpow(2, bk[r - 1] - bk[l])) % mod;
}
printf("%lld\n", f[1][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 2005;
const int mod = 998244353;
int sum[nmax];
long long dp[nmax][nmax];
int pow2[nmax];
int main() {
string s;
cin >> s;
pow2[0] = 1;
for (int i = 1; i < nmax; ++i) pow2[i] = (2LL * pow2[i - 1]) % mod;
for (int i = 0; i < s.size(); ++i) {
if (i) sum[i] += sum[i - 1];
if (s[i] == '?') ++sum[i];
}
for (int l = 2; l <= s.size(); ++l)
for (int i = 0; i < s.size() - l + 1; ++i) {
int j = i + l - 1;
int add = sum[j - 1] - sum[i];
if (s[i] != '(') {
dp[i][j] += dp[i + 1][j];
dp[i][j] %= mod;
}
if (s[j] != ')') {
dp[i][j] += dp[i][j - 1];
dp[i][j] %= mod;
}
if (s[i] != '(' && s[j] != ')') {
dp[i][j] -= dp[i + 1][j - 1];
if (dp[i][j] < 0) dp[i][j] += mod;
dp[i][j] %= mod;
}
if (s[i] != ')' && s[j] != '(') {
dp[i][j] += dp[i + 1][j - 1] + pow2[add];
dp[i][j] %= mod;
}
}
cout << dp[0][s.size() - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod_pow(long long b, int x) {
if (!x) return 1;
if (x & 1) return (b * mod_pow(b, x - 1)) % 998244353;
long long tmp = mod_pow(b, x / 2);
return (tmp * tmp) % 998244353;
}
char s[2010];
int memo[2010][2010], acum[2010];
long long sum_depths(int l, int r) {
if (l >= r) return 0;
if (memo[l][r] != -1) return memo[l][r];
long long ret = 0;
if (s[l] != '(') {
ret = (ret + sum_depths(l + 1, r)) % 998244353;
}
if (s[r] != ')') {
ret = (ret + sum_depths(l, r - 1)) % 998244353;
}
if (s[l] != '(' and s[r] != ')') {
ret = (ret - sum_depths(l + 1, r - 1) + 998244353) % 998244353;
}
if (s[l] != ')' and s[r] != '(') {
int k = acum[r - 1] - acum[l];
ret = (ret + sum_depths(l + 1, r - 1) + mod_pow(2, k)) % 998244353;
}
return memo[l][r] = ret;
}
int main() {
while (scanf("%s", s) > 0) {
for (int i = 0; s[i]; i++) {
acum[i] = (s[i] == '?');
if (i) acum[i] += acum[i - 1];
}
memset(memo, -1, sizeof memo);
printf("%lld\n", sum_depths(0, strlen(s) - 1));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 998244353;
long long EXP(long long x, long long p) {
if (p == 0) return 1;
long long Ans = EXP(x, p / 2);
Ans = (Ans * Ans) % N;
if (p % 2 == 1) Ans *= x;
return Ans % N;
}
string s;
long long dp[2005][2005];
long long k[2005][2005];
long long F(int i, int j) {
if (i >= j) return 0;
if (dp[i][j] != -1) return dp[i][j];
long long ans = 0;
if (s[i] == ')') ans = F(i + 1, j);
if (s[j] == '(') ans = F(i, j - 1);
if (s[i] == '(' && s[j] == ')') {
ans = (F(i + 1, j - 1) + EXP(2, k[i + 1][j - 1])) % N;
}
if (s[i] == '(' && s[j] == '?')
ans = ((F(i + 1, j - 1) + EXP(2, k[i + 1][j - 1])) % N + F(i, j - 1)) % N;
if (s[i] == '?' && s[j] == ')')
ans = ((F(i + 1, j - 1) + EXP(2, k[i + 1][j - 1])) % N + F(i + 1, j)) % N;
if (s[i] == '?' && s[j] == '?') {
ans = ((F(i + 1, j - 1) + EXP(2, k[i + 1][j - 1])) % N +
(F(i + 1, j) + F(i, j - 1) - F(i + 1, j - 1)) % N) %
N;
}
return dp[i][j] = ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> s;
for (int i = 0; i < 2005; i++) {
for (int j = 0; j < 2005; j++) {
dp[i][j] = -1;
}
}
for (int i = 0; i < s.length(); i++) {
long long cons = 0;
for (int j = i; j < s.length(); j++) {
if (s[j] == '?') cons++;
k[i][j] = cons;
}
}
cout << (F(0, s.length() - 1) + N) % N << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2010;
const long long Mod = 998244353;
long long f[maxn][maxn], g[maxn][maxn], n;
char s[maxn];
inline long long power(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) r = r * a % Mod;
a = a * a % Mod;
b >>= 1;
}
return r;
}
signed main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (long long i = (1), _end_ = (n); i <= _end_; ++i)
for (long long j = (i), _end_ = (n); j <= _end_; ++j)
g[i][j] = g[i][j - 1] + (s[j] == '?');
for (long long len = (2), _end_ = (n); len <= _end_; ++len)
for (long long i = (1), _end_ = (n - len + 1); i <= _end_; ++i) {
long long j = i + len - 1;
if (s[i] != '(') f[i][j] += f[i + 1][j];
if (s[j] != ')') f[i][j] += f[i][j - 1];
if (s[i] != '(' && s[j] != ')') f[i][j] -= f[i + 1][j - 1];
if (s[i] != ')' && s[j] != '(')
f[i][j] += f[i + 1][j - 1] + power(2, g[i + 1][j - 1]);
f[i][j] %= Mod;
}
printf("%lld\n", (f[1][n] + Mod) % Mod);
return 0;
}
|
#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 <= n; ++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; ++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 <= n; ++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 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);
for (int i = 0; i <= n + 1; ++i) {
if (s[i] == '(') break;
dp1[i][0] = 1;
}
for (int i = n + 1; i > 0; --i) {
if (s[i] == ')') break;
dp2[i][0] = 1;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; 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 = 1; 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>
using namespace std;
const int maxn = 2e3 + 5;
const int mod = 998244353;
long long dp[maxn][maxn];
char s[maxn];
long long qpow(long long a, int b) {
long long res = 1;
for (int i = 0; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int cnt[maxn];
int main() {
int n;
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) cnt[i] = cnt[i - 1] + (s[i] == '?');
for (int len = 2; len <= n; ++len) {
for (int i = 1; i <= n; ++i) {
int j = i + len - 1;
if (j > n) break;
if (s[i] != '(') dp[i][j] += dp[i + 1][j], dp[i][j] %= mod;
if (s[j] != ')') dp[i][j] += dp[i][j - 1], dp[i][j] %= mod;
if (s[i] != '(' && s[j] != ')') {
dp[i][j] -= dp[i + 1][j - 1];
dp[i][j] += mod;
dp[i][j] %= mod;
}
if (s[i] != ')' && s[j] != '(')
dp[i][j] += dp[i + 1][j - 1] + qpow(2, cnt[j - 1] - cnt[i]);
dp[i][j] %= mod;
}
}
printf("%lld\n", dp[1][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 119 << 23 | 1;
int fpow(int a, int k) {
int r = 1, t = a;
while (k) {
if (k & 1) r = (long long)r * t % MOD;
t = (long long)t * t % MOD;
k >>= 1;
}
return r;
}
int main() {
string s;
cin >> s;
int n = s.size();
vector<vector<int>> dp(n, vector<int>(n));
vector<int> f(n + 1);
for (int i = 0; i < n; i++) {
f[i + 1] = f[i];
f[i + 1] += s[i] == '?';
}
for (int len = 2; len <= n; len++) {
for (int i = 0; i < n - len + 1; i++) {
int j = i + len - 1;
if (s[i] != '(') {
dp[i][j] += dp[i + 1][j];
dp[i][j] %= MOD;
}
if (s[j] != ')') {
dp[i][j] += dp[i][j - 1];
dp[i][j] %= MOD;
}
if (s[i] != '(' && s[j] != ')') {
dp[i][j] -= dp[i + 1][j - 1];
dp[i][j] += MOD;
dp[i][j] %= MOD;
}
if (s[i] != ')' && s[j] != '(') {
dp[i][j] += dp[i + 1][j - 1];
dp[i][j] %= MOD;
dp[i][j] += fpow(2, f[j] - f[i + 1]);
dp[i][j] %= MOD;
}
}
}
cout << dp[0][n - 1] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, *k;
int64_t** dp;
const int64_t M = 998244353;
string s;
int64_t modpow(int x) {
if (x == 0) return 1;
if (x == 1) return 2;
if (x % 2 == 0) {
int64_t val = modpow(x / 2);
return (val * val) % M;
} else {
int64_t val = modpow(x / 2);
return (((val * val) % M) * 2) % M;
}
}
int64_t get_dp(int i, int j) {
int pi = i, pj = j;
if (i >= j) return 0;
if (dp[i][j] != -1) return dp[i][j];
int64_t ans = 0;
int ki = k[j - 1] - k[i];
if (s[j] != ')') {
ans += get_dp(i, j - 1);
ans %= M;
}
if (s[i] != '(') {
ans += get_dp(i + 1, j);
ans %= M;
}
if (s[i] != '(' && s[j] != ')') {
ans -= get_dp(i + 1, j - 1);
ans = (M + ans) % M;
}
if (s[i] != ')' && s[j] != '(') {
ans += modpow(ki);
ans %= M;
ans += get_dp(i + 1, j - 1);
ans %= M;
}
dp[pi][pj] = ans;
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin >> s;
n = s.length();
dp = new int64_t*[n];
for (int i = 0; i < n; i++) {
dp[i] = new int64_t[n];
for (int j = 0; j < n; j++) {
dp[i][j] = -1;
}
}
k = new int[n];
for (int i = 0; i < n; i++) {
k[i] = (i > 0 ? k[i - 1] : 0) + (s[i] == '?' ? 1 : 0);
}
cout << get_dp(0, n - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string S;
long long int cnt[2020], dp[2020][2020];
long long int M = 998244353;
long long int fast(long long int a, long long int b) {
long long int ret = 1, t = a;
while (b) {
if (b & 1) ret = (ret * t) % M;
t = (t * t) % M;
b >>= 1;
}
return ret;
}
long long int get(int l, int r) {
long long int p = cnt[r] - (l == 0 ? 0 : cnt[l - 1]);
return fast(2, p);
}
long long int solve(int l, int r) {
if (l >= r) return 0;
if (dp[l][r] != -1) return dp[l][r];
dp[l][r] = 0;
if (S[l] != ')' && S[r] != '(') {
dp[l][r] += solve(l + 1, r - 1) + get(l + 1, r - 1);
}
if (S[l] != '(' && S[r] != ')') {
dp[l][r] += solve(l + 1, r - 1);
}
int reduce = 0;
if (S[l] != ')' && S[r] != ')') {
dp[l][r] += solve(l, r - 1);
if (S[l] == '?') reduce++;
}
if (S[l] != '(' && S[r] != '(') {
dp[l][r] += solve(l + 1, r);
if (S[r] == '?') reduce++;
}
dp[l][r] = dp[l][r] % M - (reduce * solve(l + 1, r - 1)) % M + M;
dp[l][r] %= M;
return dp[l][r];
}
int main() {
while (cin >> S) {
memset(dp, -1, sizeof(dp));
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < S.length(); ++i)
cnt[i] = i == 0 ? (S[i] == '?') : (S[i] == '?') + cnt[i - 1];
long long int ret = solve(0, S.length() - 1);
cout << ret << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, y = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') y = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * y;
}
const int N = 2005, mod = 998244353;
int n, f[N][N], num[N];
char s[N];
inline int qpow(long long x, int 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);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) f[i][i] = 0;
for (int i = 1; i <= n; i++)
if (s[i] == '?') num[i]++;
for (int i = 1; i <= n; i++) num[i] += num[i - 1];
for (int t = 1; t <= n; t++) {
for (int i = 1; i <= n - t; i++) {
int j = i + t;
if (s[i] != '(') f[i][j] = (1ll * f[i][j] + f[i + 1][j]) % mod;
if (s[j] != ')') f[i][j] = (1ll * f[i][j] + f[i][j - 1]) % mod;
if (s[i] != '(' && s[j] != ')')
f[i][j] = (1ll * f[i][j] + mod - f[i + 1][j - 1]) % mod;
if (s[i] != ')' && s[j] != '(')
f[i][j] =
(1ll * f[i][j] + f[i + 1][j - 1] + qpow(2, num[j - 1] - num[i])) %
mod;
}
}
printf("%d\n", f[1][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
char S[100005];
int N;
long long pow2[100005];
int prefixSum[100005];
int val[256];
int memo[2005][2005][3][3];
int cntQ(int i, int j) {
if (i > j) {
return 0;
}
return prefixSum[j + 1] - prefixSum[i];
}
long long dp(int i, int j, char chL, char chR) {
if (i >= j) {
return 0;
}
if (i + 1 == j) {
return chL != ')' && chR != '(';
}
int dirX = val[chL];
int dirY = val[chR];
if (memo[i][j][dirX][dirY] != -1) {
return memo[i][j][dirX][dirY];
} else {
long long ans = 0;
if (chL != ')' && chR != '(') {
ans += pow2[cntQ(i + 1, j - 1)] + dp(i + 1, j - 1, S[i + 1], S[j - 1]);
}
if (chL != ')' && chR != ')') {
ans += dp(i, j - 1, '(', S[j - 1]);
}
if (chL != '(' && chR != '(') {
ans += dp(i + 1, j, S[i + 1], ')');
}
if (chL != '(' && chR != ')') {
ans += dp(i + 1, j - 1, S[i + 1], S[j - 1]);
}
ans %= MOD;
memo[i][j][dirX][dirY] = ans;
return ans;
}
}
int main() {
scanf(" %s", S);
N = strlen(S);
val['('] = 0;
val[')'] = 1;
val['?'] = 2;
pow2[0] = 1;
for (int i = 1; i <= N; i++) {
pow2[i] = (pow2[i - 1] << 1) % MOD;
}
prefixSum[0] = 0;
for (int i = 1; i <= N; i++) {
prefixSum[i] = prefixSum[i - 1] + (S[i - 1] == '?');
}
memset(memo, -1, sizeof(memo));
printf("%lld\n", dp(0, N - 1, S[0], S[N - 1]));
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
const long long MOD = 998244353;
using namespace std;
long long mpow(long long x, long long n) {
long long ans = 1;
while (n != 0) {
if (n & 1) ans = ans * x % MOD;
x = x * x % MOD;
n = n >> 1;
}
return ans;
}
long long minv(long long x) { return mpow(x, MOD - 2); }
char str[2005];
long long a0[2005][2005];
long long a1[2005][2005];
int main(int argc, char* argv[]) {
scanf("%s", str);
int n = strlen(str);
int i, j;
a0[0][0] = 1;
for (i = 0; i < n; i++) {
for (j = 0; j <= i; j++) {
if (a0[i][j]) {
if (str[i] != ')')
a0[i + 1][j + 1] = (a0[i + 1][j + 1] + a0[i][j]) % MOD;
if (str[i] != '(') a0[i + 1][j] = (a0[i + 1][j] + a0[i][j]) % MOD;
}
}
}
a1[0][0] = 1;
for (i = 0; i < n; i++) {
for (j = 0; j <= i; j++) {
if (a1[i][j]) {
if (str[n - 1 - i] != '(')
a1[i + 1][j + 1] = (a1[i + 1][j + 1] + a1[i][j]) % MOD;
if (str[n - 1 - i] != ')')
a1[i + 1][j] = (a1[i + 1][j] + a1[i][j]) % MOD;
}
}
}
long long ans = 0;
for (i = 0; i < n; i++) {
int k;
for (k = 1; k <= n; k++) {
long long tmp = a0[i][k] * a1[n - i][k] % MOD;
ans = (ans + tmp * k) % MOD;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2123;
const long long mod = 998244353;
int n;
long long dp[maxn][maxn], sum[maxn], p2[maxn];
char s[maxn];
int main() {
p2[0] = 1;
for (int i = 1; i < maxn; ++i) p2[i] = (p2[i - 1] + p2[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] == '?');
for (int i = 2; i <= n; ++i)
for (int l = 1; l + i - 1 <= n; ++l) {
int r = l + i - 1;
if (s[l] == ')' || s[l] == '?')
dp[l][r] = (dp[l][r] + dp[l + 1][r]) % mod;
if (s[r] == '(' || s[r] == '?')
dp[l][r] = (dp[l][r] + dp[l][r - 1]) % mod;
if ((s[l] == ')' || s[l] == '?') && (s[r] == '(' || s[r] == '?'))
dp[l][r] = (dp[l][r] - dp[l + 1][r - 1]) % mod;
if ((s[l] == '(' || s[l] == '?') && (s[r] == ')' || s[r] == '?'))
dp[l][r] =
(dp[l][r] + dp[l + 1][r - 1] + p2[sum[r - 1] - sum[l]]) % mod;
dp[l][r] %= mod;
if (dp[l][r] < 0) dp[l][r] += mod;
}
cout << dp[1][n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const int MOD = 998244353;
const int N = 2e3 + 7;
int dp[N][N], bin[N], q[N];
string s;
int add(int x, int y) {
int res = ((long long)x + y) % MOD;
if (res < 0) res += MOD;
return res;
}
int mul(int x, int y) { return (long long)x * y % MOD; }
int get(int x, int y) {
if (x > y) return 0;
return q[y] - q[x - 1];
}
int solve(int l, int r) {
if (l >= r) return 0;
if (dp[l][r] != -1) return dp[l][r];
int& ans = dp[l][r] = 0;
if (s[l - 1] != '(') ans = add(ans, solve(l + 1, r));
if (s[r - 1] != ')') ans = add(ans, solve(l, r - 1));
auto k = get(l + 1, r - 1);
auto nxt = solve(l + 1, r - 1);
if (s[l - 1] != '(' && s[r - 1] != ')') ans = add(ans, -nxt);
if (s[l - 1] != ')' && s[r - 1] != '(') {
ans = add(ans, nxt);
ans = add(ans, bin[k]);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int tt = clock();
cin >> s;
bin[0] = 1;
for (int i = 1; i <= s.size(); ++i) {
bin[i] = mul(2, bin[i - 1]);
}
for (int i = 1; i <= s.size(); ++i) {
if (s[i - 1] == '?') {
q[i] = q[i - 1] + 1;
} else
q[i] = q[i - 1];
}
for (int i = 0; i <= s.size(); ++i) {
cerr << q[i] << " \n"[i == s.size()];
}
memset(dp, -1, sizeof dp);
cout << solve(1, s.size()) << '\n';
cerr << "TIME = " << (double)1.0 * (clock() - tt) / CLOCKS_PER_SEC
<< " seconds" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int expo(long long int a, long long int b) {
if (b == 0) return 1;
if (b % 2 == 0)
return expo((a % 998244353 * a % 998244353) % 998244353, b / 2);
return (expo(a, b - 1) % 998244353 * a % 998244353) % 998244353;
}
int main() {
string s;
cin >> s;
long long int n = s.length();
long long int fact[n + 1];
long long int inv_fact[n + 1];
fact[0] = 1;
inv_fact[0] = 1;
for (long long int i = 1; i <= n; i++) {
fact[i] = (fact[i - 1] % 998244353 * (i) % 998244353) % 998244353;
inv_fact[i] = expo(fact[i] % 998244353, 998244353 - 2) % 998244353;
}
long long int pre[n];
long long int pre1[n];
pre[0] = (s[0] == '?');
pre1[0] = (s[0] == '(');
for (long long int i = 1; i < n; i++) {
pre[i] = pre[i - 1] + (s[i] == '?');
pre1[i] = pre1[i - 1] + (s[i] == '(');
}
long long int post[n + 1];
long long int post1[n + 1];
post[n] = 0;
post1[n] = 0;
post1[n - 1] = (s[n - 1] == ')');
post[n - 1] = (s[n - 1] == '?');
for (long long int i = n - 2; i >= 0; i--) {
post[i] = post[i + 1] + (s[i] == '?');
post1[i] = post1[i + 1] + (s[i] == ')');
}
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
for (long long int c = 1; c <= n / 2; c++) {
if (max(pre1[i], post1[i + 1]) > c) continue;
if (pre[i] + pre1[i] < c) continue;
if (post[i + 1] + post1[i + 1] < c) continue;
long long int tmp = (fact[pre[i]] % 998244353 * inv_fact[c - pre1[i]] %
998244353 * inv_fact[pre[i] - c + pre1[i]]) %
998244353;
tmp = (tmp % 998244353 * fact[post[i + 1]] % 998244353 *
inv_fact[c - post1[i + 1]] % 998244353 *
inv_fact[post[i + 1] - c + post1[i + 1]] % 998244353) %
998244353;
tmp = (tmp % 998244353 * c % 998244353) % 998244353;
ans = (ans % 998244353 + tmp % 998244353) % 998244353;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 119 << 23 | 1;
int fpow(int a, int k) {
int r = 1, t = a;
while (k) {
if (k & 1) r = (long long)r * t % MOD;
t = (long long)t * t % MOD;
k >>= 1;
}
return r;
}
int main() {
string s;
cin >> s;
int n = s.size();
vector<vector<int>> dp(n, vector<int>(n));
vector<int> f(n + 1);
for (int i = 0; i < n; i++) f[i + 1] = f[i], f[i + 1] += s[i] == '?';
for (int len = 2; len <= n; len++) {
for (int i = 0; i < n - len + 1; i++) {
int j = i + len - 1;
if (s[i] != '(') dp[i][j] += dp[i + 1][j], dp[i][j] %= MOD;
if (s[j] != ')') dp[i][j] += dp[i][j - 1], dp[i][j] %= MOD;
if (s[i] != '(' && s[j] != ')')
dp[i][j] -= dp[i + 1][j - 1], dp[i][j] += MOD, dp[i][j] %= MOD;
if (s[i] != ')' && s[j] != '(') {
dp[i][j] += dp[i + 1][j - 1], dp[i][j] %= MOD;
dp[i][j] += fpow(2, f[j] - f[i + 1]), dp[i][j] %= MOD;
}
}
}
cout << dp[0][n - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 2005;
const long long MOD = 998244353;
int n;
char s[N];
long long dp[N][N][2][2], cnt[N][N];
long long mul(long long a, long long b) { return (a * b) % MOD; }
long long add(long long a, long long b) { return (a + b) % MOD; }
long long rek(int l, int r, int fl1, int fl2) {
if (l >= r) return 0;
long long &ret = dp[l][r][fl1][fl2];
if (ret != -1) return ret;
ret = 0;
if (s[l] == ')')
ret = rek(l + 1, r, 0, fl2);
else if (s[r] == '(')
ret = rek(l, r - 1, fl1, 0);
else if (s[l] == '(' || fl1) {
ret = add(rek(l + 1, r - 1, 0, 0), cnt[l + 1][r - 1]);
if (s[r] == '?' && !fl2) ret = add(ret, rek(l, r - 1, fl1, 0));
} else {
if (s[r] == ')' || fl2) {
ret = add(rek(l + 1, r - 1, 0, 0), cnt[l + 1][r - 1]);
ret = add(ret, rek(l + 1, r, 0, fl2));
} else {
ret = add(rek(l + 1, r - 1, 0, 0), cnt[l + 1][r - 1]);
ret = add(ret, rek(l + 1, r, 0, 1));
ret = add(ret, rek(l, r - 1, 1, 0));
ret = add(ret, rek(l + 1, r - 1, 0, 0));
}
}
return ret;
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; ++i) {
if (i != 0) cnt[i][i - 1] = 1;
for (int j = i; j < n; ++j) {
long long dod = 1LL + (s[j] == '?');
if (j == i)
cnt[i][j] = dod;
else
cnt[i][j] = mul(dod, cnt[i][j - 1]);
}
}
memset(dp, -1, sizeof dp);
printf("%lld\n", rek(0, n - 1, 0, 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const int mods[10] = {1000000007, 999999937, 999999929, 999999893, 999999883,
999999797, 999999761, 999999757, 999999751, 999999739};
const int mod = 998244353;
int rand_mods[2];
const long double eps = 1e-10;
const int siz = 2e3 + 5, siz2 = 3e5 + 5, lg = 20, block = 300, block2 = 1000,
mxv = 1e5 + 1, sqrt_mod = 31630;
const int alpha_sz = 26;
char arr[siz];
int dp[siz][siz], qcmu[siz];
int mul(long long a, long long b) { return (a * b) % mod; }
int sub(long long a, long long b) { return ((a - b) % mod + mod) % mod; }
int powmod(int a, int b) {
if (b == 0) {
return 1;
}
int p = powmod(a, b / 2);
p = mul(p, p);
return b % 2 ? mul(p, a) : p;
}
int add(long long a, long long b) { return (a + b) % mod; }
int main() {
scanf("%s", arr + 1);
int sz = strlen(arr + 1);
for (int i = 1; i <= sz; i++) {
qcmu[i] = (arr[i] == '?') + qcmu[i - 1];
}
for (int i = 1; i < sz; i++) {
dp[i][i + 1] = arr[i] != ')' && arr[i + 1] != '(';
}
for (int len = 3; len <= sz; len++) {
for (int i = 1; i + len - 1 <= sz; i++) {
int l = i, r = i + len - 1;
if (arr[l] != ')' && arr[r] != '(') {
dp[l][r] = add(dp[l + 1][r - 1], powmod(2, qcmu[r - 1] - qcmu[l]));
}
if (arr[l] != '(') {
dp[l][r] = add(dp[l][r], dp[l + 1][r]);
}
if (arr[r] != ')') {
dp[l][r] = add(dp[l][r], dp[l][r - 1]);
}
if (arr[l] != '(' && arr[r] != ')') {
dp[l][r] = sub(dp[l][r], dp[l + 1][r - 1]);
}
}
}
printf("%d\n", dp[1][sz]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 10;
const int P = 998244353;
const int INF = 0x3f3f3f3f;
int n, dp[N][N], f[N];
char s[N];
int qsm(int n, int q = P - 2) {
int ans = 1;
while (q) {
if (q & 1) {
ans = 1LL * ans * n % P;
}
n = 1LL * n * n % P;
q >>= 1;
}
return ans;
}
void solve() {
n = strlen(s);
for (int i = 0; i < n; ++i) {
f[i + 1] = f[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]) % P;
}
if (s[j] != ')') {
dp[i][j] = (dp[i][j] + dp[i][j - 1]) % P;
}
if (s[i] != '(' && s[j] != ')') {
dp[i][j] = (1LL * dp[i][j] - dp[i + 1][j - 1] + P) % P;
}
if (s[i] != ')' && s[j] != '(') {
dp[i][j] =
(1LL * dp[i][j] + dp[i + 1][j - 1] + qsm(2, f[j] - f[i + 1])) % P;
}
}
}
printf("%d\n", dp[0][n - 1]);
}
int main() {
scanf("%s", s);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long CONST = 998244353;
long long pow1(long long n) {
long long rez = 1, p = 2;
while (n) {
if (n % 2 == 1) {
rez = rez * p % CONST;
}
p = p * p % CONST;
n = n / 2;
}
return rez;
}
signed main() {
string s;
cin >> s;
long long n = s.size();
vector<vector<long long> > dp(n, vector<long long>(n));
vector<vector<long long> > ans(n, vector<long long>(n, 0));
for (long long len = 1; len <= n; len++) {
for (long long i = 0; i <= n - len; i++) {
if (s[i] == '?') {
if (len == 1) {
ans[i][i + len - 1] = 1;
} else {
ans[i][i + len - 1] = ans[i + 1][i + len - 1] + 1;
}
} else {
if (len == 1) {
ans[i][i + len - 1] = 0;
} else {
ans[i][i + len - 1] = ans[i + 1][i + len - 1];
}
}
if (s[i] != '(' && len >= 2 && i + len - 1 < n) {
dp[i][i + len - 1] += dp[i + 1][i + len - 1];
}
if (s[i + len - 1] != ')' && len >= 2) {
dp[i][i + len - 1] += dp[i][i + len - 2];
}
if (s[i] != '(' && s[i + len - 1] != ')' && len >= 2 && i + len - 1 < n) {
dp[i][i + len - 1] -= dp[i + 1][i + len - 2];
}
if (s[i] != ')' && s[i + len - 1] != '(' && len >= 2 && i + len - 1 < n) {
dp[i][i + len - 1] +=
dp[i + 1][i + len - 2] + pow1(ans[i + 1][i + len - 2]);
}
dp[i][i + len - 1] %= CONST;
}
}
cout << dp[0][n - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int p = 998244353;
template <typename T>
inline T read() {
register T sum = 0;
register char cc = getchar();
int sym = 1;
while (cc != '-' && (cc > '9' || cc < '0')) cc = getchar();
if (cc == '-') sym = -1, cc = getchar();
sum = sum * 10 + cc - '0';
cc = getchar();
while (cc >= '0' && cc <= '9') sum = sum * 10 + cc - '0', cc = getchar();
return sym * sum;
}
template <typename T>
inline T read(T& a) {
a = read<T>();
return a;
}
template <typename T, typename... Others>
inline void read(T& a, Others&... b) {
a = read(a);
read(b...);
}
int n, s[2010], f[2010][2010];
char str[2010];
int add(int x, int y) { return (x + y) % p; }
int sub(int x, int y) { return (x - y + p) % p; }
int mul(int x, int y) { return 1ll * x * y % p; }
int fpow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = mul(res, x);
x = mul(x, x);
y >>= 1;
}
return res;
}
int Get(int l, int r) {
if (l > r) return 0;
return s[r] - s[l - 1];
}
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + (str[i] == '?');
for (int len = 2; len <= n; len++)
for (int l = 1; l + len - 1 <= n; l++) {
int r = l + len - 1;
if (str[l] != '(') f[l][r] = add(f[l][r], f[l + 1][r]);
if (str[r] != ')') f[l][r] = add(f[l][r], f[l][r - 1]);
if (str[l] != '(' && str[r] != ')')
f[l][r] = sub(f[l][r], f[l + 1][r - 1]);
if (str[l] != ')' && str[r] != '(')
f[l][r] =
add(f[l][r], add(f[l + 1][r - 1], fpow(2, Get(l + 1, r - 1))));
}
printf("%d\n", f[1][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const int maxn = 2005;
const long long Mod = 998244353;
long long dp[maxn][maxn];
long long sum[maxn];
char s[maxn];
long long p[maxn];
int main() {
p[0] = 1;
for (int i = 1; i <= maxn; 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];
}
memset(dp, 0, sizeof(dp));
for (int len = 2; len <= n; len++) {
for (int l = 1; l <= n + 1 - len; l++) {
int r = l + len - 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[sum[r - 1] - sum[l]]) % Mod;
}
}
printf("%lld\n", dp[1][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 5;
const long long mod = 998244353;
long long f[maxn][maxn], sum[maxn];
char s[maxn];
long long fpow(long long a, long long b) {
long long ans = 1;
a %= mod;
while (b) {
if (b & 1) ans = ans * a % mod;
b >>= 1;
a = a * a % mod;
}
return ans;
}
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1];
if (s[i] == '?') sum[i]++;
}
for (int len = 2; len <= n; len++) {
for (int i = 1; i <= n; i++) {
int j = i + len - 1;
if (j > n) break;
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] + mod - f[i + 1][j - 1]) % mod;
if (s[i] != ')' && s[j] != '(')
f[i][j] =
(f[i][j] + f[i + 1][j - 1] + fpow(2, sum[j - 1] - sum[i])) % mod;
}
}
printf("%lld\n", f[1][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long a, long long p) {
a %= 998244353ll;
long long r = 1;
while (p) {
if ((p & 1)) {
r = (r * a) % 998244353ll;
}
a = (a * a) % 998244353ll;
p >>= 1;
}
return r;
}
struct Modulo {
long long value;
Modulo() { value = 0; }
Modulo(long long v) {
v %= 998244353ll;
if (v < 0) {
v += 998244353ll;
}
value = v;
}
Modulo operator+(Modulo x) { return Modulo(value + x.value); }
Modulo operator-(Modulo x) { return Modulo(value - x.value); }
Modulo operator*(Modulo x) { return Modulo(value * x.value); }
Modulo operator/(Modulo x) {
return Modulo(value * bigmod(x.value, 998244353ll - 2));
}
Modulo operator+(long long x) { return Modulo(value + x); }
Modulo operator-(long long x) { return Modulo(value - x); }
Modulo operator*(long long x) { return Modulo(value * x); }
Modulo operator/(long long x) {
return Modulo(value * bigmod(x, 998244353ll - 2));
}
bool operator==(long long x) { return value == x; }
bool operator!=(long long x) { return value != x; }
bool operator==(Modulo x) { return value == x.value; }
bool operator!=(Modulo x) { return value != x.value; }
void print() { printf("%lld\n", value); }
};
Modulo ONE = Modulo(1);
Modulo ZERO = Modulo(0);
Modulo dp[2009][2009];
int cnt[2009];
char str[2009];
int main() {
int n, i;
scanf("%s", str + 1);
n = strlen(str + 1);
for (i = 1; i <= n; i++) {
cnt[i] = cnt[i - 1] + (str[i] == '?');
}
for (int len = 2; len <= n; len++) {
for (int l = 1, r = len; r <= n; l++, r++) {
if (str[l] != '(') {
dp[l][r] = dp[l][r] + dp[l + 1][r];
}
if (str[r] != ')') {
dp[l][r] = dp[l][r] + dp[l][r - 1];
}
if (str[l] != '(' && str[r] != ')') {
dp[l][r] = dp[l][r] - dp[l + 1][r - 1];
}
if (str[l] != ')' && str[r] != '(') {
dp[l][r] = dp[l][r] + dp[l + 1][r - 1] + bigmod(2, cnt[r - 1] - cnt[l]);
}
}
}
Modulo ans = dp[1][n];
ans.print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char v[2010];
long long sp[2010], p[2010], dp[2010][2010];
int n, i, j, lg;
long long get_value(int i, int j) {
long long nr = sp[j] - sp[i - 1];
return p[nr];
}
int main() {
cin >> v + 1;
n = strlen(v + 1);
for (i = 1; i <= n; i++) {
sp[i] = sp[i - 1];
if (v[i] == '?') sp[i]++;
}
p[0] = 1;
for (i = 1; i <= n; i++) p[i] = (1LL * 2 * p[i - 1]) % 998244353;
for (i = 1; i < n; i++) {
if (v[i] == '(') {
if (v[i + 1] == ')' || v[i + 1] == '?')
dp[i][i + 1] = 1;
else
dp[i][i + 1] = 0;
} else {
if (v[i] == ')')
dp[i][i + 1] = 0;
else {
if (v[i + 1] == '?' || v[i + 1] == ')')
dp[i][i + 1] = 1;
else
dp[i][i + 1] = 0;
}
}
}
for (lg = 2; lg < n; lg++) {
for (i = 1; i + lg <= n; i++) {
j = i + lg;
if (v[i] == ')' || v[i] == '?')
dp[i][j] = (dp[i][j] + dp[i + 1][j]) % 998244353;
if (v[j] == '(' || v[j] == '?')
dp[i][j] = (dp[i][j] + dp[i][j - 1]) % 998244353;
if ((v[i] == ')' || v[i] == '?') && (v[j] == '(' || v[j] == '?')) {
dp[i][j] = (dp[i][j] - dp[i + 1][j - 1]) % 998244353;
if (dp[i][j] < 0) dp[i][j] += 998244353;
}
int ok = 1;
if (v[i] == ')' || v[j] == '(') ok = 0;
if (ok) {
dp[i][j] = (dp[i][j] + dp[i + 1][j - 1]) % 998244353;
dp[i][j] = (dp[i][j] + get_value(i + 1, j - 1)) % 998244353;
}
}
}
cout << dp[1][n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
void min_self(int& a, int b) {
if (a > b) a = b;
}
void max_self(int& a, int b) {
if (a < b) a = b;
}
const int mod = 998244353;
int mult(int a, int b) { return (int)(((ll)a * b) % mod); }
int add_self(int& a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int sub_self(int& a, int b) {
a -= b;
if (a < 0) a += mod;
}
int power(int a, int k) {
int answer = 1;
while (k >= 1) {
if (k & 1) {
answer = mult(answer, a);
}
a = mult(a, a);
k >>= 1;
}
return answer;
}
int inverse(int a) { return power(a, mod - 2); }
void solve() {
string s;
cin >> s;
const int n = (int)s.size();
vector<vector<int> > dp(n, vector<int>(n));
vector<int> count(n + 1);
for (int i = 0; i < n; i++) {
count[i + 1] = count[i] + (s[i] == '?');
}
for (int len = 2; len <= n; len++) {
for (int i = 0; i <= n - len; i++) {
int j = i + len - 1;
if (s[i] != '(') {
add_self(dp[i][j], dp[i + 1][j]);
}
if (s[j] != ')') {
add_self(dp[i][j], dp[i][j - 1]);
}
if (s[i] != '(' && s[j] != ')') {
sub_self(dp[i][j], dp[i + 1][j - 1]);
}
if (s[i] != ')' && s[j] != '(') {
int p = power(2, count[j] - count[i + 1]);
add_self(p, dp[i + 1][j - 1]);
add_self(dp[i][j], p);
}
}
}
printf("%d\n", dp[0][n - 1]);
}
int main() {
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long **num_of_substrs;
long long **dp;
void compute_substrs(string s, int n) {
for (int i = 0; i < n; i++) {
long long ans = 1;
for (int j = i; j < n; j++) {
if (s[j] == '?') ans = (ans * 2) % mod;
num_of_substrs[i][j] = ans;
}
}
}
long long dp_func(int i, int j, string &s) {
if (i == j) return 0;
if (i + 1 == j) {
if (s[i] == ')' || s[j] == '(') return 0;
return 1;
}
if (dp[i][j] != -1) return dp[i][j];
if (s[i] == ')') return dp[i][j] = dp_func(i + 1, j, s);
if (s[j] == '(') return dp[i][j] = dp_func(i, j - 1, s);
if (s[i] == '(' && s[j] == ')') {
return dp[i][j] =
(dp_func(i + 1, j - 1, s) + num_of_substrs[i + 1][j - 1]) % mod;
}
if (s[i] == '(' && s[j] == '?') {
return dp[i][j] = (dp_func(i + 1, j - 1, s) + num_of_substrs[i + 1][j - 1] +
dp_func(i, j - 1, s)) %
mod;
}
if (s[i] == '?' && s[j] == ')') {
return dp[i][j] = (dp_func(i + 1, j - 1, s) + num_of_substrs[i + 1][j - 1] +
dp_func(i + 1, j, s)) %
mod;
}
return dp[i][j] = (dp_func(i + 1, j, s) + dp_func(i, j - 1, s) +
num_of_substrs[i + 1][j - 1]) %
mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
string s;
cin >> s;
int n = s.length();
num_of_substrs = new long long *[n];
dp = new long long *[n];
for (int i = 0; i < n; i++) {
num_of_substrs[i] = new long long[n];
dp[i] = new long long[n];
for (int j = 0; j < n; j++) dp[i][j] = -1;
}
compute_substrs(s, n);
cout << dp_func(0, n - 1, s);
}
|
#include <bits/stdc++.h>
using ll = long long;
const int mod = 998244353;
int n, p[2005], p2[2005];
ll d[2005][2005];
char a[2005];
inline int conv(char c) { return c == '(' ? 0 : (c == '?' ? 1 : 2); }
int main() {
scanf("%s", a + 1);
n = strlen(a + 1);
for (int i = 1; i <= n; i++) p[i] = p[i - 1] + (a[i] == '?');
p2[0] = 1;
for (int i = 1; i <= n; i++) p2[i] = p2[i - 1] * 2 % mod;
for (int l = n - 1; l >= 1; l--)
for (int r = l + 1; r <= n; r++) {
int type = conv(a[l]) * 3 + conv(a[r]), k = p[r - 1] - p[l];
ll &f = d[l][r];
switch (type) {
case 0:
f = d[l][r - 1];
break;
case 1:
f = d[l][r - 1] + d[l + 1][r - 1] + p2[k];
break;
case 2:
f = d[l + 1][r - 1] + p2[k];
break;
case 3:
f = d[l][r - 1];
break;
case 4:
f = d[l][r - 1] + d[l + 1][r] + p2[k];
break;
case 5:
f = d[l + 1][r] + d[l + 1][r - 1] + p2[k];
break;
case 6:
f = d[l + 1][r - 1];
break;
case 7:
f = d[l + 1][r];
break;
case 8:
f = d[l + 1][r];
break;
}
f = ((f % mod) + mod) % mod;
}
printf("%lld", d[1][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int N = 200000 + 7;
string s;
long long dp[2007][2007];
long long pow2[2007];
int nq[2007];
long long solve(int l, int r) {
if (l >= r) return 0;
if (dp[l][r] != -1) return dp[l][r];
long long numq = pow2[nq[r - 1] - nq[l]];
if (s[l] == '(' && s[r] == ')') {
dp[l][r] = solve(l + 1, r - 1) + numq;
} else if (s[r] == '(') {
dp[l][r] = solve(l, r - 1);
} else if (s[l] == ')') {
dp[l][r] = solve(l + 1, r);
} else if (s[l] == '?' && s[r] == '?') {
dp[l][r] = solve(l + 1, r) + numq + solve(l, r - 1);
} else if (s[l] == '?') {
dp[l][r] = solve(l + 1, r) + solve(l + 1, r - 1) + numq;
} else if (s[r] == '?') {
dp[l][r] = solve(l + 1, r - 1) + numq + solve(l, r - 1);
}
dp[l][r] %= mod;
return dp[l][r];
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
pow2[0] = 1;
for (int i = 1; i < 2007; i++) {
pow2[i] = (pow2[i - 1] * 2) % mod;
}
for (int i = 0; i < 2007; i++) {
for (int j = 0; j < 2007; j++) dp[i][j] = -1;
}
cin >> s;
int n = s.length();
if (s[0] == '?') nq[0] = 1;
for (int i = 1; i < n; i++) {
nq[i] = nq[i - 1];
if (s[i] == '?') nq[i]++;
}
cout << solve(0, n - 1) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
const long long MOD = 998244353;
using namespace std;
long long mpow(long long x, long long n) {
long long ans = 1;
while (n != 0) {
if (n & 1) ans = ans * x % MOD;
x = x * x % MOD;
n = n >> 1;
}
return ans;
}
long long minv(long long x) { return mpow(x, MOD - 2); }
char str[2005];
long long a0[2005][2005];
long long a1[2005][2005];
int main(int argc, char* argv[]) {
scanf("%s", str);
int n = strlen(str);
int i, j;
a0[0][0] = 1;
for (i = 0; i < n; i++) {
for (j = 0; j <= i; j++) {
if (a0[i][j]) {
if (str[i] != ')')
a0[i + 1][j + 1] = (a0[i + 1][j + 1] + a0[i][j]) % MOD;
if (str[i] != '(') a0[i + 1][j] = (a0[i + 1][j] + a0[i][j]) % MOD;
}
}
}
a1[0][0] = 1;
for (i = 0; i < n; i++) {
for (j = 0; j <= i; j++) {
if (a1[i][j]) {
if (str[n - 1 - i] != '(')
a1[i + 1][j + 1] = (a1[i + 1][j + 1] + a1[i][j]) % MOD;
if (str[n - 1 - i] != ')')
a1[i + 1][j] = (a1[i + 1][j] + a1[i][j]) % MOD;
}
}
}
long long ans = 0;
for (i = 0; i < n; i++) {
int k;
for (k = 1; k <= n / 2; k++) {
long long tmp = a0[i][k] * a1[n - 1 - i][k] % MOD;
if (tmp) {
if (str[i] != ')') {
ans = (ans + tmp * k) % MOD;
}
if (str[i] != '(') {
ans = (ans + tmp * k) % MOD;
}
}
}
}
for (i = 0; i < n - 1; i++) {
if (str[i] != '(' && str[i + 1] != ')') {
int k;
for (k = 0; k <= n / 2; k++) {
long long tmp = a0[i][k] * a1[n - 2 - i][k] % MOD;
if (tmp) {
ans = (ans - tmp * k % MOD + MOD) % MOD;
}
}
}
if (str[i] != ')' && str[i + 1] != '(') {
int k;
for (k = 0; k <= n / 2; k++) {
long long tmp = a0[i][k] * a1[n - 2 - i][k] % MOD;
if (tmp) {
ans = (ans + tmp * (k + 1)) % MOD;
}
}
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const long long mod = 998244353;
const int maxn = 2013;
int n;
string s;
long long dpLeft[maxn][maxn];
long long dpRight[maxn][maxn];
void add(long long& x, long long y) {
x %= mod;
y %= mod;
x += y;
x %= mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.length();
dpLeft[0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (dpLeft[i][j] == 0) continue;
if (s[i] == '(') {
add(dpLeft[i + 1][j + 1], dpLeft[i][j]);
} else if (s[i] == ')') {
add(dpLeft[i + 1][j], dpLeft[i][j]);
} else {
assert(s[i] == '?');
add(dpLeft[i + 1][j + 1], dpLeft[i][j]);
add(dpLeft[i + 1][j], dpLeft[i][j]);
}
}
}
dpRight[n + 1][0] = 1;
for (int i = n; i > 0; i--) {
for (int j = 0; j < n; j++) {
if (dpRight[i + 1][j] == 0) continue;
if (s[i - 1] == ')') {
add(dpRight[i][j + 1], dpRight[i + 1][j]);
} else if (s[i - 1] == '(') {
add(dpRight[i][j], dpRight[i + 1][j]);
} else {
assert(s[i - 1] == '?');
add(dpRight[i][j + 1], dpRight[i + 1][j]);
add(dpRight[i][j], dpRight[i + 1][j]);
}
}
}
long long res = 0;
for (int i = 1; i <= n - 1; i++) {
for (long long j = 0; j <= n; j++) {
add(res, j * dpLeft[i][j] % mod * dpRight[i + 1][j] % mod);
}
}
res %= mod;
res += mod;
res %= mod;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long Getint() {
char ch = getchar();
long long x = 0, fh = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') fh = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
(x *= 10) += ch ^ 48;
ch = getchar();
}
return x * fh;
}
const long long mod = 998244353;
const int N = 2005;
int n, su[N];
char s[N];
bool vis[N][N][3][3];
int f[N][N][3][3], pw[N];
inline int Getsu(int l, int r) {
if (r < l) return 0;
return su[r] - su[l - 1];
}
inline long long Dfs(int l, int r, int l1, int l2) {
if (r <= l)
return 0;
else if (vis[l][r][l1][l2])
return f[l][r][l1][l2];
long long Ans = 0;
vis[l][r][l1][l2] = 1;
int li = l1 == 2 ? 0 : l1, ri = l1 == 2 ? 1 : l1;
int lj = l2 == 2 ? 0 : l2, rj = l2 == 2 ? 1 : l2;
for (int i = li; i <= ri; i++)
for (int j = lj; j <= rj; j++) {
if (i == 1 && j == 0)
Ans += Dfs(l + 1, r - 1, s[l + 1], s[r - 1]);
else if (i == 1)
Ans += Dfs(l + 1, r, l + 1 == r ? j : s[l + 1], j);
else if (j == 0)
Ans += Dfs(l, r - 1, i, r - 1 == l ? i : s[r - 1]);
else
Ans += Dfs(l + 1, r - 1, s[l + 1], s[r - 1]) + pw[Getsu(l + 1, r - 1)];
}
return f[l][r][l1][l2] = Ans % mod;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
pw[0] = 1;
for (int i = 1; i <= N - 1; i++) pw[i] = pw[i - 1] * 2ll % mod;
for (int i = 1; i <= n; i++) su[i] = su[i - 1] + (s[i] == '?');
for (int i = 1; i <= n; i++) s[i] = (s[i] == '(' ? 0 : (s[i] == ')' ? 1 : 2));
cout << Dfs(1, n, s[1], s[n]) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int maxn = 2e3 + 100;
string s;
long long dp[maxn][maxn] = {0};
int num[maxn] = {0};
long long qmod(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
b >>= 1;
a = a * a % mod;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
int len = s.length();
for (int i = 1; i <= len; ++i) {
num[i] = num[i - 1];
if (s[i - 1] == '?') {
++num[i];
}
}
for (int i = 1; i <= len; ++i) {
for (int j = 0; j + i < len; ++j) {
int l = j, r = i + j;
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] + qmod(2, num[r] - num[l + 1])) % mod;
}
}
}
cout << dp[0][len - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 2e3 + 5;
const int Mod = 998244353;
int n, dp[Max][Max];
string s;
int cnt[Max][Max];
int sum(int i, int j) {
if (i > j) return 1;
if (cnt[i][j]) return cnt[i][j];
return cnt[i][j] = (s[i] == '?' ? 2 : 1) * sum(i + 1, j) % Mod;
}
int Try(int l, int r) {
if (l >= r) return 0;
int& ret = dp[l][r];
if (~ret) return ret;
ret = 0;
if ((s[l] == '(' || s[l] == '?') && (s[r] == ')' || s[r] == '?'))
ret = (Try(l + 1, r - 1) + sum(l + 1, r - 1)) % Mod;
bool b1 = false, b2 = false;
if (s[l] != '(') ret = (ret + Try(l + 1, r)) % Mod, b1 = true;
if (s[r] != ')') ret = (ret + Try(l, r - 1)) % Mod, b2 = true;
if (b1 && b2) ret = (ret - Try(l + 1, r - 1) + Mod) % Mod;
return ret;
}
int main() {
cin >> s;
memset(dp, -1, sizeof(dp));
n = s.size();
cout << Try(0, n - 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
namespace _buff {
const size_t BUFF = 1 << 19;
char ibuf[BUFF], *ib = ibuf, *ie = ibuf;
char getc() {
if (ib == ie) {
ib = ibuf;
ie = ibuf + fread(ibuf, 1, BUFF, stdin);
}
return ib == ie ? -1 : *ib++;
}
} // namespace _buff
LL read() {
using namespace _buff;
LL ret = 0;
bool pos = true;
char c = getc();
for (; (c < '0' || c > '9') && c != '-'; c = getc()) {
assert(~c);
}
if (c == '-') {
pos = false;
c = getc();
}
for (; c >= '0' && c <= '9'; c = getc()) {
ret = (ret << 3) + (ret << 1) + (c ^ 48);
}
return pos ? ret : -ret;
}
const size_t N = 2e3 + 5;
const int MOD = 998244353;
void iadd(int &dp, int val) {
dp += val;
if (dp >= MOD) {
dp -= MOD;
}
}
char s[N];
int f[N][N][2], g[N][N];
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
f[0][0][0] = 1;
for (int i = 1; i <= n; ++i) {
if (s[i] == '(' || s[i] == '?') {
for (int j = 1; j <= i; ++j) {
iadd(f[i][j][1], f[i - 1][j - 1][0]);
iadd(f[i][j][1], f[i - 1][j - 1][1]);
}
}
if (s[i] == ')' || s[i] == '?') {
for (int j = 0; j <= i; ++j) {
iadd(f[i][j][0], f[i - 1][j][0]);
iadd(f[i][j][0], f[i - 1][j][1]);
}
}
}
g[n + 1][0] = 1;
for (int i = n; i >= 1; --i) {
if (s[i] == ')' || s[i] == '?') {
for (int j = 1; j <= n; ++j) {
iadd(g[i][j], g[i + 1][j - 1]);
}
}
if (s[i] == '(' || s[i] == '?') {
for (int j = 0; j <= n; ++j) {
iadd(g[i][j], g[i + 1][j]);
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = n; j >= 1; --j) {
iadd(g[i][j - 1], g[i][j]);
}
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= i; ++j) {
ans = (ans + (LL)f[i][j][1] * g[i + 1][j]) % MOD;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2000 + 5][2000 + 5];
long long ques[2000 + 5];
long long mod = 998244353;
long long poww(long long a, long long b) {
long long tmp = 1;
while (b) {
if (b & 1) tmp = (tmp * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return tmp;
}
int main(void) {
string str;
cin >> str;
str = " " + str;
int n = str.size() - 1;
for (int i = 1; i <= n; i++) {
ques[i] = ques[i - 1] + (str[i] == '?');
}
for (int len = 2; len <= n; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int j = i + len - 1;
if (str[i] != '(') dp[i][j] = (dp[i][j] + dp[i + 1][j]) % mod;
if (str[j] != ')') dp[i][j] = (dp[i][j] + dp[i][j - 1]) % mod;
if (str[i] != '(' && str[j] != ')')
dp[i][j] = (dp[i][j] - dp[i + 1][j - 1] + mod) % mod;
if (str[i] != ')' && str[j] != '(') {
dp[i][j] = ((dp[i][j] + dp[i + 1][j - 1]) % mod +
poww(2, ques[j - 1] - ques[i])) %
mod;
}
}
}
cout << dp[1][n] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long fast_exp(long long a, long long b) {
if (b == 0)
return 1;
else {
long long res = 1;
res = fast_exp(a, b / 2);
res = (res * res) % mod;
if (b % 2 == 1) res = (res * a) % mod;
return res;
}
}
const long long N = 1e5 + 10;
long long nCr[2500][2500];
long long vis[2500][2500] = {};
long long binom(long long n, long long r) {
if (r < 0 || r > n) return 0;
if (vis[n][r]) return nCr[n][r];
if (r == 0 || n == r)
return 1;
else {
vis[n][r] = 1;
nCr[n][r] = (binom(n - 1, r - 1) + binom(n - 1, r)) % mod;
return nCr[n][r];
}
}
int main() {
string s;
cin >> s;
long long n = s.size();
long long prefop[n], prefq[n], sufcl[n], sufq[n];
long long op = 0, q = 0, cl = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == '(') op++;
if (s[i] == '?') q++;
prefop[i] = op;
prefq[i] = q;
}
q = 0;
for (long long i = n - 1; i >= 0; i--) {
if (s[i] == ')') cl++;
if (s[i] == '?') q++;
sufcl[i] = cl;
sufq[i] = q;
}
long long ans = 0;
for (long long i = 1; i < n; i++) {
long long lop = prefop[i - 1], lq = prefq[i - 1], rq = sufq[i],
rcl = sufcl[i];
for (long long k = 0; k < n; k++) {
long long rk = lop + k - rcl;
ans = (ans + ((((lop + k) * binom(lq, k)) % mod) * binom(rq, rk)) % mod) %
mod;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <int MOD>
class ModInt {
long long x;
public:
ModInt(long long v = 0) : x(v % MOD) {
if (x < 0) x += MOD;
}
ModInt& operator+=(const ModInt& r) {
x += r.x;
if (x >= MOD) x -= MOD;
return *this;
}
ModInt& operator-=(const ModInt& r) {
x -= r.x;
if (x < 0) x += MOD;
return *this;
}
ModInt& operator*=(const ModInt& r) {
x = (x * r.x) % MOD;
return *this;
}
ModInt& operator/=(const ModInt& r) {
*this *= r.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt& r) const { return ModInt(*this) += r; }
ModInt operator-(const ModInt& r) const { return ModInt(*this) -= r; }
ModInt operator*(const ModInt& r) const { return ModInt(*this) *= r; }
ModInt operator/(const ModInt& r) const { return ModInt(*this) /= r; }
bool operator==(const ModInt& r) const { return x == r.x; }
bool operator!=(const ModInt& r) const { return x != r.x; }
ModInt inverse() const {
long long a = x, b = MOD, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt<MOD> pow(long long n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1) ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream& operator<<(ostream& os, const ModInt& x) { return os << x.x; }
friend istream& operator>>(istream& is, ModInt& x) { return is >> x.x; }
int getMod() { return MOD; }
};
using mint = ModInt<998244353>;
string S;
int main() {
cin >> S;
int N = S.size();
int M = 0;
for (int i = 0; i < (int)N; ++i) M += (S[i] == '?');
vector<int> L(N + 1, 0), R(N + 1, 0);
for (int i = 0; i < (int)N; ++i) {
L[i + 1] = L[i] + (S[i] != ')');
R[N - i - 1] = R[N - i] + (S[N - i - 1] == ')');
}
vector<mint> fact(M + 1), ifact(M + 1);
fact[0] = 1;
for (int i = 0; i < (int)M; ++i) fact[i + 1] = fact[i] * (i + 1);
for (int i = 0; i < (int)M + 1; ++i) ifact[i] = fact[i].inverse();
auto comb = [&](int n, int k) { return fact[n] * ifact[n - k] * ifact[k]; };
vector<mint> SB(M + 2, 0), SQ(M + 1, 0);
for (int i = 0; i < (int)M + 1; ++i) SB[i + 1] = SB[i] + comb(M, i);
for (int i = 0; i < (int)M; ++i) SQ[i + 1] = SQ[i] + comb(M - 1, i);
mint ans = 0;
for (int i = 0; i < (int)N; ++i) {
if (S[i] == ')') continue;
int k = L[i + 1] - R[i + 1];
if (S[i] == '(') ans += SB[M + 1] - SB[min(M + 1, max(k, 0))];
if (S[i] == '?') ans += SQ[M] - SQ[min(M, max(k, 0))];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 50;
const long long Mod = 998244353;
int n;
long long f[maxn][maxn], g[maxn][maxn], dp[maxn][maxn];
char s[maxn];
int main() {
cin >> s + 1;
n = strlen(s + 1);
f[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
if ((s[i] == '(' || s[i] == '?') && j - 1 >= 0)
f[i][j] = (f[i][j] + f[i - 1][j - 1]) % Mod;
if (s[i] == ')' || s[i] == '?') f[i][j] = (f[i][j] + f[i - 1][j]) % Mod;
}
}
g[n + 1][0] = 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= n - i + 1; j++) {
if ((s[i] == ')' || s[i] == '?') && j - 1 >= 0)
g[i][j] = (g[i][j] + g[i + 1][j - 1]) % Mod;
if (s[i] == '(' || s[i] == '?') g[i][j] = (g[i][j] + g[i + 1][j]) % Mod;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
ans = (ans + f[i][j] * g[i + 1][j] % Mod * j % Mod) % Mod;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using i64 = long long;
constexpr int P = 998244353;
int power(int a, int b) {
int res = 1;
for (; b > 0; a = i64(a) * a % P, b /= 2) {
if (b % 2 == 1) {
res = i64(res) * a % P;
}
}
return res;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::string s;
std::cin >> s;
int n = s.size();
std::vector<int> pr(n + 1);
for (int i = 0; i < n; i++) {
pr[i + 1] = pr[i] + (s[i] == '?');
}
std::vector<std::vector<int>> dp(n, std::vector<int>(n, -1));
std::function<int(int, int)> calc = [&](int l, int r) {
if (l >= r) {
return 0;
}
if (~dp[l][r]) {
return dp[l][r];
}
dp[l][r] = 0;
if (s[l] != '(') dp[l][r] = (dp[l][r] + calc(l + 1, r)) % P;
if (s[r] != ')') dp[l][r] = (dp[l][r] + calc(l, r - 1)) % P;
if (s[l] != '(' && s[r] != ')')
dp[l][r] = (dp[l][r] - calc(l + 1, r - 1) + P) % P;
if (s[l] != ')' && s[r] != '(')
dp[l][r] =
((dp[l][r] + calc(l + 1, r - 1)) % P + power(2, pr[r] - pr[l + 1])) %
P;
return dp[l][r];
};
std::cout << calc(0, n - 1) << "\n";
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.