solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> ans[11111];
int main() {
cin >> n;
int first = 1;
while (first * (first - 1) / 2 <= n) ++first;
--first;
cout << first << endl;
for (int(i) = 0; (i) < (first); ++(i))
for (int(j) = 0; (j) < (i); ++(j)) {
ans[i].push_back(n);
ans[j].push_back(n);
n--;
}
for (int(i) = 0; (i) < (first); ++(i)) {
for (int(j) = 0; (j) < ((int)(ans[i]).size()); ++(j)) {
if (j) cout << " ";
cout << ans[i][j];
}
cout << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (long long)(1e6) + 322;
const long long INF = (long long)(1e9);
const long long mod = (long long)(1e9) + 7;
const double eps = 1e-9;
vector<int> v, a, b, s;
int d[N], n, mx;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (long long i = 1; i <= n; ++i) {
int x;
cin >> x;
if (x != 0) v.push_back(x);
}
v.push_back(-1);
for (long long i = 1; i <= n; ++i) {
int x;
cin >> x;
if (x != 0) {
a.push_back(x);
v.push_back(x);
}
}
for (auto it : a) v.push_back(it);
for (int i = 1; i < (int)(v.size()); ++i) {
int j = d[i - 1];
while (j > 0 && v[i] != v[j]) {
j = d[j - 1];
}
d[i] += j + (v[i] == v[j]);
if (d[i] >= n - 1) mx = 1;
}
if (mx == 1)
cout << "YES";
else
cout << "NO";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 160010;
int T, r, f[maxn], lnk[1000010], mark[maxn], from[maxn];
long long ans[maxn];
string str;
vector<int> G[maxn];
int main() {
ios::sync_with_stdio(0);
cin >> T;
while (T--) {
cin >> r;
getline(cin, str);
stack<int> st;
for (int i = 0; i < str.size(); i++) {
if (str[i] == '(') st.push(i);
if (str[i] == ')') lnk[st.top()] = i, st.pop();
}
int cnt = count(str.begin(), str.end(), '*');
int tot = cnt, id = 0;
function<int(int, int)> solve = [&](int l, int r) {
while (str[l] == ' ') l++;
while (str[r] == ' ') r--;
if (l == r) {
f[++id] = 1;
return id;
}
int k = ++tot;
mark[k] = 0;
for (int i = l + 1; i < r; i++) {
if (str[i] == ' ' || str[i] == 'P') continue;
if (str[i] == 'S')
mark[k] = 1;
else if (str[i] == '*')
G[k].push_back(solve(i, i));
else
G[k].push_back(solve(i, lnk[i])), i = lnk[i];
}
if (!mark[k]) {
f[k] = 0;
for (int x : G[k]) f[k] += f[x];
} else {
f[k] = INT_MAX;
for (int x : G[k])
if (f[x] < f[k]) f[k] = f[x], from[k] = x;
}
return k;
};
int rt = solve(0, str.size() - 1);
function<void(int)> dfs = [&](int v) {
if (v <= cnt) {
ans[v] = 1LL * r * f[rt];
return;
}
if (!mark[v])
for (int x : G[v]) dfs(x);
else
dfs(from[v]);
};
fill(ans + 1, ans + cnt + 1, 0), dfs(rt);
cout << "REVOLTING";
for (int i = 1; i <= cnt; i++) cout << ' ' << ans[i];
cout << '\n';
for (int i = 1; i <= tot; i++) G[i].clear();
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int a[N];
set<int> s;
int f[N];
bool st[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
memset(f, 0x3f, sizeof f);
for (int i = 1; i <= n; i++) {
f[a[i]] = min(f[a[i]], a[i]);
for (int j = 0; j <= 512; j++) {
if (f[j] != 0x3f3f3f3f && f[j] <= a[i])
f[j ^ a[i]] = min(f[j ^ a[i]], a[i]);
}
}
for (int i = 0; i <= 511; i++)
if (f[i] != 0x3f3f3f3f) s.insert(i);
cout << s.size() << endl;
for (auto x : s) {
cout << x << " ";
}
cout << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, hz;
char a[101010];
string sb(long long aa, long long bb) {
string z;
long long ii;
for (ii = aa; ii <= bb; ii++) z += a[ii];
return z;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
hz = -1;
for (i = 1; i <= n / 2; i++) {
if (sb(1, i) == sb(i + 1, i + i)) {
hz = i;
}
}
if (hz == -1)
cout << n << "\n";
else
cout << n - hz + 1 << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 1e3 + 5;
const int mod = 1000000007;
const int inf = 1e9 + 10;
const long long INF = 1e18;
int n;
map<pair<int, int>, int> mp;
pair<int, int> points[maxn];
int primes[505];
int nprimes;
bool is_prime[505];
void sieve(int n) {
for (int i = 2; i <= n; ++i) is_prime[i] = true;
for (int i = 2; i <= n; ++i) {
if (is_prime[i]) {
primes[nprimes++] = i;
for (int j = i * 2; j <= n; j += i) is_prime[j] = false;
}
}
}
void deduce(int &x, int &y) {
for (int i = 0; i < nprimes; ++i) {
int t = primes[i];
while (x % t == 0 && y % t == 0) {
x /= t, y /= t;
}
}
}
int MAIN() {
scanf("%d", &n);
sieve(500);
for (int i = 0; i < n; ++i)
scanf("%d%d", &points[i].first, &points[i].second);
long long tot = 0;
for (int i = 0; i < n; ++i) {
mp.clear();
for (int j = 0; j < n; ++j) {
if (j == i) continue;
int x = points[j].first - points[i].first;
int y = points[j].second - points[i].second;
if (x == 0) {
y = 1;
} else if (y == 0) {
x = 1;
} else if (x < 0) {
x = -x;
y = -y;
}
deduce(x, y);
pair<int, int> dummy = make_pair(x, y);
if (!mp.count(dummy))
mp[dummy] = 1;
else
++mp[dummy];
}
long long sm = 0;
for (map<pair<int, int>, int>::iterator it = mp.begin(); it != mp.end();
++it) {
sm += it->second;
}
for (map<pair<int, int>, int>::iterator it = mp.begin(); it != mp.end();
++it) {
sm -= it->second;
tot += (sm * it->second);
}
}
tot /= 3;
printf("%I64d\n", tot);
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
cout << fixed << setprecision(16);
int ret = MAIN();
return ret;
}
| 11 |
/******** In the name of Allah, the most gracious, the most merciful ********/
#include <bits/stdc++.h>
using namespace std;
#define pril(a) printf("%d\n", a)
#define pri(a) printf("%d ", a)
#define line printf("\n")
#define space printf(" ")
#define see(a, b) \
{ \
cout << a << " : " << b << endl; \
}
const double pi = acos(-1.0);
typedef long int int32;
typedef long long int lli;
typedef unsigned long long int ulli;
#define fi first
#define se second
typedef pair<int, int> PII;
const double eps = 1e-9;
int MOD = 1e9 + 7;
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
/**************** TEMPLATE ********************/
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
int t;
cin >> t;
int n;
while (t--)
{
cin >> n;
vector<int> a(n + 1);
a[0] = 0;
int cnt[100002][2] = {0};
for (int i = 1; i <= n; i++)
{
cin >> a[i];
cnt[a[i]][i % 2]++;
}
sort(a.begin(), a.end());
for (int i = 1; i <= n; i++)
cnt[a[i]][i % 2]--;
bool flag = true;
for (int i = 1; i <= n; i++)
{
if (cnt[a[i]][0] != 0 || cnt[a[i]][1] != 0)
{
flag = false;
break;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int NN = 202020;
char s[NN], t[NN];
int rk[NN], sa[NN], ht[NN];
int mn[NN][22];
namespace SA {
using INT = long long;
using pii = pair<int, int>;
using ppi = pair<pii, int>;
int head[NN * 2];
ppi pos[NN * 2], buf[NN << 1], tbuf[NN << 1];
int nxt[NN * 2];
void bucket_sort(int ok, int n) {
int i, u, j, deg, E, K;
for (i = E = K = 0; i < max(222, n + 10); i++) head[i] = -1;
for (i = 0; i < n; i++) {
if (ok)
u = pos[i].first.first + 1;
else
u = pos[i].first.second + 1;
buf[E] = pos[i];
nxt[E] = head[u];
head[u] = E++;
}
for (int i = 0; i < max(n + 10, 222); i++) {
for (deg = 0, j = head[i]; ~j; j = nxt[j]) {
tbuf[deg++] = buf[j];
}
while (deg) pos[K++] = tbuf[--deg];
}
}
void LCP(int n) {
for (int i = 1; i <= n; i++) mn[i][0] = ht[i];
for (int j = 1; j < 22; j++) {
for (int i = 1; i <= n; i++) {
mn[i][j] = min(mn[i][j - 1], mn[min(n, i + (1 << j - 1))][j - 1]);
}
}
}
void height(int n) {
int h = 0, i;
for (i = 0; i < n; i++) sa[rk[i]] = i;
for (i = 0; i < n; i++) {
if (rk[i] == 1) continue;
h = max(0, h - 1);
for (int j = sa[rk[i] - 1]; s[i + h] == s[j + h]; h++)
;
ht[rk[i]] = h;
}
}
void buildSA(int n) {
int i, j, cnt, u;
for (i = 0; i < n; i++) rk[i] = s[i];
rk[n] = 0;
for (i = 0; i < 20; i++) {
for (j = 0; j < n; j++)
pos[j] = ppi(pii(rk[j], rk[min(n, j + (1 << i))]), j);
bucket_sort(0, n);
bucket_sort(1, n);
pos[n] = ppi(pii(-1, -1), -1);
for (cnt = j = 0; j < n; j++) {
rk[pos[j].second] = cnt + 1;
cnt += (pos[j].first != pos[j + 1].first);
}
if (cnt == n) break;
}
height(n);
LCP(n);
}
int calc(int u, int v) {
if (u == v) return 1e9;
u = rk[u], v = rk[v];
if (u > v) swap(u, v);
u++;
int l = 31 - __builtin_clz(v - u + 1);
return min(mn[u][l], mn[v - (1 << l) + 1][l]);
}
} // namespace SA
using namespace SA;
int cnt[NN], dp[NN];
int main() {
int n;
cin >> n;
scanf("%s %s", s, t);
reverse(s, s + n);
reverse(t, t + n);
buildSA(n);
for (int i = 0; i < n; i++)
if (t[i] == '0') cnt[rk[i]] = 1;
for (int i = 1; i <= n; i++) dp[i] = dp[i - 1] + cnt[i];
INT ans = 0;
for (int i = 1; i <= n; i++) {
if (!cnt[i]) continue;
ans = max(ans, (INT)n - sa[i]);
int st = -1, ed = i;
while (st + 1 < ed) {
int md = (st + ed) / 2;
if (calc(sa[md], sa[i]) >= ht[i])
ed = md;
else
st = md;
}
int L = ed;
st = i - 1, ed = n + 1;
while (st + 1 < ed) {
int md = (st + ed) / 2;
if (calc(sa[md], sa[i]) >= ht[i])
st = md;
else
ed = md;
}
int R = st;
ans = max(ans, 1LL * (dp[R] - dp[L - 1]) * ht[i]);
}
cout << ans;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h[2005][2005], v[2005][2005], tl;
char s[2005][2005], t[2005][2005];
long long ans;
void go(char s[][2005]) {
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) {
h[i][j] = h[i][j - 1] + (s[i][j] == '#');
v[i][j] = v[i - 1][j] + (s[i][j] == '#');
}
for (int i = (2); i < (m); i++) ans += !v[n][i];
for (int i = (2); i < (n); i++)
for (int j = (2); j < (m); j++) {
ans += !h[i][j] && !v[i][j];
ans += h[i][m] == h[i][j - 1] && v[n][j] == v[i - 1][j];
}
for (int i = (2); i < (n); i++) {
tl = 0;
for (int j = (2); j < (m); j++) {
if (v[n][j] == v[i - 1][j]) ans += tl;
if (s[i][j] == '#') tl = 0;
if (!v[i][j]) tl++;
}
tl = 0;
for (int j = (2); j < (m); j++) {
if (!v[i][j]) ans += tl;
if (s[i][j] == '#') tl = 0;
if (v[n][j] == v[i - 1][j]) tl++;
}
tl = 0;
for (int j = (3); j < (m); j++) {
if (v[n][j] == v[i - 1][j]) ans += tl;
if (v[n][j - 1] == v[i - 1][j - 1]) tl++;
if (s[i][j] == '#') tl = 0;
}
tl = 0;
for (int j = (3); j < (m); j++) {
if (!v[i][j]) ans += tl;
if (!v[i][j - 1]) tl++;
if (s[i][j] == '#') tl = 0;
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = (1); i <= (n); i++) scanf("%s", s[i] + 1);
go(s);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) t[m + 1 - j][i] = s[i][j];
swap(n, m);
go(t);
printf("%I64d\n", ans);
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500010;
struct Trie {
int ch[maxn][26];
int sz;
Trie() {
sz = 1;
memset(ch[0], 0, sizeof(ch[0]));
}
int idx(char c) { return c - 'a'; }
void insert(char *s) {
int u = 0, len = strlen(s);
for (int i = 0; i < len; i++) {
int c = idx(s[i]);
if (!ch[u][c]) {
memset(ch[sz], 0, sizeof(ch[sz]));
ch[u][c] = sz++;
}
u = ch[u][c];
}
}
int dfs(int u) {
bool flag = 0;
int ret = 0;
for (int i = 0; i < 26; i++) {
if (ch[u][i]) {
flag = 1;
ret |= dfs(ch[u][i]);
}
}
if (!flag)
ret = 2;
else
ret = 3 - ret;
return ret;
}
} tire;
char s[100010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%s", s);
tire.insert(s);
}
int ans = 3 - tire.dfs(0);
if (ans == 3) {
printf("First\n");
} else if (ans == 2) {
if (k & 1)
printf("First\n");
else
printf("Second\n");
} else
printf("Second\n");
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
char grid[1001][1001];
bool vis[1001][1001];
int n, m, nos;
struct point {
int x, y, how;
point() { x = 0, y = 0, how = 0; }
};
vector<point> result;
bool vaild(int x, int y) { return (x >= 0 && x < n && y >= 0 && y < m); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf(" %c", &grid[i][j]);
nos += (grid[i][j] == '*');
}
int have = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (grid[i][j] == '*') {
if (!vaild(i + 1, j) || !vaild(i - 1, j) || !vaild(i, j + 1) ||
!vaild(i, j - 1))
continue;
if ((grid[i + 1][j] != '*') || (grid[i - 1][j] != '*') ||
(grid[i][j + 1] != '*') || (grid[i][j - 1] != '*'))
continue;
point p;
int des = !vis[i][j];
vis[i][j] = 1;
int can = 0;
int lU = i, rU = j;
int lD = i, rD = j;
int lL = i, rL = j;
int lR = i, rR = j;
while (true) {
lU--, lD++, rL--, rR++;
if (!vaild(lU, rU) || !vaild(lD, rD) || !vaild(lL, rL) ||
!vaild(lR, rR))
break;
if (grid[lU][rU] != '*' || grid[lD][rD] != '*' ||
grid[lL][rL] != '*' || grid[lR][rR] != '*')
break;
can++;
des += ((!vis[lU][rU]) + (!vis[lD][rD]) + (!vis[lL][rL]) +
(!vis[lR][rR]));
vis[lU][rU] = 1, vis[lD][rD] = 1, vis[lL][rL] = 1, vis[lR][rR] = 1;
}
p.x = i + 1, p.y = j + 1, p.how = can;
result.push_back(p);
have += des;
}
}
if (have == nos) {
printf("%d\n", result.size());
for (int i = 0; i < result.size(); i++)
printf("%d %d %d\n", result[i].x, result[i].y, result[i].how);
return 0;
}
puts("-1");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double l, d, v1, v2;
cin >> d >> l >> v1 >> v2;
cout << fixed << setprecision(10) << ((l - d) / (1 + v2 / v1)) / v1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, z;
long long fs(long long s, long long ss, long long n) {
long long res = 1;
s %= n;
while (ss > 0) {
if (ss & 1) {
res = (res * s) % n;
}
ss >>= 1;
s = (s * s) % n;
}
return res % n;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> x >> y;
long long ans = 0;
for (int i = 1; i <= y; i++) {
cin >> z;
ans += (z * fs(x, y - i, 2));
ans %= 2;
}
(ans) ? cout << "odd" << endl : cout << "even" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
void pre() {}
void solve() {}
string s[3009], t[3009];
string ss, tt;
int l[3009], r[3009];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
pre();
int n;
cin >> n;
for (int i = 0; i < (n); ++i) cin >> s[i];
for (int i = 0; i < (n); ++i) cin >> t[i];
for (int i = 0; i < (n); ++i) {
if (s[i] != t[i]) {
for (int j = 0; j < ((int)(s[i]).size()); ++j) {
if (s[i][j] != t[i][j]) {
l[i] = j;
break;
}
}
for (int j = (int)(s[i]).size() - 1; j >= (0); --j) {
if (s[i][j] != t[i][j]) {
r[i] = j;
break;
}
}
if (ss == "") {
ss = s[i].substr(l[i], r[i] - l[i] + 1);
tt = t[i].substr(l[i], r[i] - l[i] + 1);
} else {
if (ss != s[i].substr(l[i], r[i] - l[i] + 1) ||
tt != t[i].substr(l[i], r[i] - l[i] + 1)) {
cout << "NO";
exit(0);
}
}
} else
l[i] = r[i] = -1;
}
while (1) {
char sx = '$', tx = '$';
bool fg = 0;
for (int i = 0; i < (n); ++i) {
if (l[i] != -1) {
if (l[i] == 0) {
fg = 1;
break;
}
if (sx == '$') {
sx = s[i][l[i] - 1];
tx = t[i][l[i] - 1];
} else {
if (sx != s[i][l[i] - 1] || tx != t[i][l[i] - 1]) {
fg = 1;
break;
}
}
}
}
if (fg) break;
for (int i = 0; i < (n); ++i)
if (l[i] != -1) l[i]--;
string tem2(1, tx);
tt = tem2 + tt;
string tem(1, sx);
ss = tem + ss;
}
while (1) {
char sx = '$', tx = '$';
bool fg = 0;
for (int i = 0; i < (n); ++i) {
if (r[i] != -1) {
if (r[i] == (int)(s[i]).size() - 1) {
fg = 1;
break;
}
if (sx == '$') {
sx = s[i][r[i] + 1];
tx = t[i][r[i] + 1];
} else {
if (sx != s[i][r[i] + 1] || tx != t[i][r[i] + 1]) {
fg = 1;
break;
}
}
}
}
if (fg) break;
for (int i = 0; i < (n); ++i)
if (r[i] != -1) r[i]++;
string tem2(1, tx);
tt = tt + tem2;
string tem(1, sx);
ss = ss + tem;
}
for (int i = 0; i < (n); ++i) {
if (l[i] == -1 && s[i].find(ss) != string::npos) {
cout << "NO";
exit(0);
}
}
for (int i = 0; i < (n); ++i) {
if (l[i] != -1 && r[i] > 0 &&
(s[i].substr(0, r[i])).find(ss) != string::npos) {
cout << "NO";
exit(0);
}
}
cout << "YES\n";
cout << ss << '\n';
cout << tt << '\n';
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e4 + 10;
const long double pi = acos(-1);
int gi() {
int x = 0, o = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
struct dat {
long double l, r;
int id;
bool operator<(const dat &A) const {
return l < A.l || (l == A.l && r < A.r);
}
} q[N];
struct dat2 {
long double r;
int id;
bool operator<(const dat2 &A) const {
return r < A.r || (r == A.r && id < A.id);
}
};
int n, m, c[N], tt;
long double x, y, k[N], b[N], ang[N], v[N], ans;
set<dat2> S;
void modify(int p, int v) {
while (p <= tt) c[p] += v, p += p & -p;
}
int query(int p) {
int ret = 0;
while (p) ret += c[p], p -= p & -p;
return ret;
}
void mdf(dat &l) {
if (l.l < -pi) l.l += pi * 2;
if (l.r > pi) l.r -= pi * 2;
if (l.l > l.r) swap(l.l, l.r);
}
long double sqr(long double x) { return x * x; }
long double dist(long double x1, long double y1, long double x2,
long double y2) {
return sqrt(sqr(x1 - x2) + sqr(y1 - y2));
}
int main() {
cin >> n >> x >> y >> m;
x *= 0.001;
y *= 0.001;
for (int i = 1; i <= n; i++) {
k[i] = gi() * 0.001, b[i] = gi() * 0.001;
ang[i] = atan(k[i]);
if (k[i] * x + b[i] > y)
ang[i] += 0.5 * pi;
else
ang[i] -= 0.5 * pi;
}
long double l = 0, r = 1e10;
for (int T = 1; T <= 100; T++) {
long double mid = (l + r) / 2;
tt = 0;
int sum = 0;
memset(c, 0, sizeof(c));
for (int i = 1; i <= n; i++) {
long double dis = fabs((k[i] * x - y + b[i]) / sqrt(k[i] * k[i] + 1));
if (dis > mid) continue;
dis = acos(dis / mid);
mdf(q[++tt] = (dat){ang[i] - dis, ang[i] + dis, i});
}
for (int i = 1; i <= tt; i++) v[i] = q[i].r;
sort(q + 1, q + tt + 1);
sort(v + 1, v + tt + 1);
for (int i = 1; i <= tt; i++) {
int L = lower_bound(v + 1, v + tt + 1, q[i].l) - v - 1;
int R = lower_bound(v + 1, v + tt + 1, q[i].r) - v;
sum += query(R) - query(L);
if (sum >= m) break;
modify(R, 1);
}
if (sum >= m)
r = mid;
else
l = mid;
}
tt = 0;
l = max((long double)1e-8, l * (1 + 1e-8));
for (int i = 1; i <= n; i++) {
long double dis = fabs((k[i] * x - y + b[i]) / sqrt(k[i] * k[i] + 1));
if (dis > l) continue;
dis = acos(dis / l);
mdf(q[++tt] = (dat){ang[i] - dis, ang[i] + dis, i});
}
sort(q + 1, q + tt + 1);
int cnt = 0;
for (int i = 1; i <= tt; i++) {
auto it = S.lower_bound((dat2){q[i].l, 0});
while (it != S.end() && it->r < q[i].r) {
int u = it->id, v = q[i].id;
long double X = (b[v] - b[u]) / (k[u] - k[v]), Y = k[u] * X + b[u];
ans += dist(x, y, X, Y), ++cnt, ++it;
if (cnt == m) return printf("%.10Lf\n", ans), 0;
}
S.insert((dat2){q[i].r, q[i].id});
}
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2010;
long long F[N][N];
long long n, m, k;
long long cal(long long i, long long w) {
if (i == n) {
return w == k;
}
if (w > k) return 0;
if (F[i][w] != -1) return F[i][w];
return F[i][w] = (cal(i + 1, w) + (m - 1) * cal(i + 1, w + 1)) % 998244353;
}
int32_t main() {
cin >> n >> m >> k;
memset(F, 255, sizeof(F));
long long ans = (m * cal(1, 0)) % 998244353;
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
struct point {
int x, y;
point() {}
point(int x, int y) : x(x), y(y) {}
bool operator<(const point &r) const {
if (x != r.x)
return x < r.x;
else
return y < r.y;
}
};
struct ASK {
int l, r, id;
} q[N];
int n, m, cnt = 0;
int sum[N], b[N], ans[N], pre[N], ts[N], t[N];
vector<point> a[N];
map<point, int> ma;
inline int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
inline void add(int x, int y) {
if (x == 0) return;
for (; x <= sum[n]; x += (x & (-x))) t[x] += y;
return;
}
inline int find(int x) {
int u = 0;
for (; x; x -= (x & (-x))) u += t[x];
return u;
}
inline bool cmp(ASK x, ASK y) { return x.r < y.r; }
int main() {
scanf("%d", &n);
for (int k = 1; k <= n; k++) {
int x;
scanf("%d", &x);
sum[k] = sum[k - 1] + x;
for (int i = 1; i <= x; i++) {
int u, v;
scanf("%d%d", &u, &v);
a[k].push_back(point(u, v));
}
a[k].push_back(a[k][0]);
for (int i = 0; i < a[k].size() - 1; i++) {
point u = point(a[k][i].x - a[k][i + 1].x, a[k][i].y - a[k][i + 1].y);
int v = gcd(abs(u.x), abs(u.y));
u.x /= v, u.y /= v;
if (ma.count(u))
b[sum[k - 1] + i + 1] = ma[u];
else
ma[u] = b[sum[k - 1] + i + 1] = ++cnt;
}
}
scanf("%d", &m);
for (int k = 1; k <= m; k++) {
scanf("%d%d", &q[k].l, &q[k].r);
q[k].l = sum[q[k].l - 1];
q[k].r = sum[q[k].r];
q[k].id = k;
}
sort(q + 1, q + 1 + m, cmp);
for (int k = 1; k <= sum[n]; k++) {
pre[k] = ts[b[k]];
ts[b[k]] = k;
}
int now = 1;
for (int k = 1; k <= sum[n]; k++) {
add(k, 1), add(pre[k], -1);
while (now <= m && q[now].r == k) {
ans[q[now].id] = find(q[now].r) - find(q[now].l);
now++;
}
}
for (int k = 1; k <= m; k++) printf("%d\n", ans[k]);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int t;
int n;
int a[300000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t > 0) {
cin >> n;
int i, j;
bool ok = false;
for (i = 1; i <= n; ++i) {
cin >> a[i];
}
for (i = 1; i < n; ++i) {
if (a[i] != a[i + 1]) {
ok = true;
break;
}
}
if (ok == true)
cout << 1 << '\n';
else
cout << n << '\n';
--t;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
int len, a[100035];
int dp[100035][105], sdp[100035], ps[100035][105];
bool full(int x, int l, int r) {
return ps[r][x] - ps[l - 1][x] + ps[r][0] - ps[l - 1][0] == r - l + 1;
}
void fmain(int tid) {
scanf("%d%d%d", &n, &k, &len);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", a + i);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int(j) = 0; (j) < (int)(k + 1); (j)++) ps[i][j] += ps[i - 1][j];
int t = a[i] == -1 ? 0 : a[i];
ps[i][t]++;
}
sdp[0] = 1;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
if (a[i] == -1) {
for (int(j) = 1; (j) <= (int)(k); (j)++) {
addmod(dp[i][j], sdp[i - 1]);
}
} else {
addmod(dp[i][a[i]], sdp[i - 1]);
}
if (i >= len) {
for (int(j) = 1; (j) <= (int)(k); (j)++)
if (full(j, i - len + 1, i)) {
addmod(dp[i][j],
(998244353 - sdp[i - len] + dp[i - len][j]) % 998244353);
}
}
for (int(j) = 1; (j) <= (int)(k); (j)++) addmod(sdp[i], dp[i][j]);
}
printf("%d\n", sdp[n]);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int pre[1050];
void init(int n) {
for (int i = 1; i <= n; i++) {
pre[i] = i;
}
}
int get_f(int x) {
if (pre[x] == x) return x;
int ans = x;
while (pre[ans] != ans) {
ans = pre[ans];
}
int b, tem = x;
while (pre[tem] != ans) {
b = pre[tem];
pre[tem] = ans;
tem = b;
}
return ans;
}
void get_union(int x, int y) {
int fx = get_f(x);
int fy = get_f(y);
if (fx != fy) {
pre[fx] = fy;
}
}
int check(int x, int y) {
int fx = get_f(x);
int fy = get_f(y);
if (fx == fy) {
return 1;
} else {
return 0;
}
}
int w[2050], b[2050];
int main() {
int n, m, W;
cin >> n >> m >> W;
for (int i = 1; i <= n; i++) {
cin >> w[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
}
init(n);
int x, y;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
get_union(x, y);
}
int vis[1050];
memset(vis, 0, sizeof(vis));
int cnt = 0;
vector<int> S[1050];
memset(S, 0, sizeof(S));
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
vis[i] = 0;
cnt++;
S[cnt].push_back(i);
int temw = w[i], temb = b[i];
for (int j = i + 1; j <= n; j++) {
if (vis[j] == 0) {
if (check(i, j)) {
vis[j] = 1;
temw += w[j];
temb += b[j];
S[cnt].push_back(j);
}
}
}
if (S[cnt].size() > 1) {
S[cnt].push_back(n + cnt);
w[n + cnt] = temw;
b[n + cnt] = temb;
}
}
}
int dp[1050];
memset(dp, 0, sizeof(0));
for (int i = 1; i <= cnt; i++) {
for (int j = W; j >= 0; j--) {
for (int k = 0; k < S[i].size(); k++) {
if (j >= w[S[i][k]]) {
dp[j] = max(dp[j], dp[j - w[S[i][k]]] + b[S[i][k]]);
}
}
}
}
cout << dp[W] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool check(string s, string t) {
for (int i = 0; i < 60; i++) {
if (s[i] == '0' && t[i] == '1') return false;
}
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int64_t a[n], b[n];
map<int64_t, int64_t> times;
for (int i = 0; i < n; i++) {
cin >> a[i];
times[a[i]]++;
}
for (int i = 0; i < n; i++) cin >> b[i];
vector<string> bin;
for (int i = 0; i < n; i++) {
int64_t x = a[i];
string s = "";
while (x) {
int64_t temp = x & 1;
x = x >> 1;
s += char(temp + '0');
}
int64_t sz = s.size();
for (int64_t i = sz; i < 60; i++) s += '0';
reverse(s.begin(), s.end());
bin.push_back(s);
}
int64_t ans = 0;
vector<int64_t> p;
for (int i = 0; i < n; i++) {
if (times[a[i]] > 1) {
p.push_back(i);
}
}
for (int i = 0; i < n; i++) {
if (times[a[i]] > 1) {
ans += b[i];
continue;
}
bool flag = 0;
for (int j = 0; j < p.size(); j++) {
if (check(bin[p[j]], bin[i])) {
flag = 1;
break;
}
}
if (flag) ans += b[i];
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long ara[300003];
unsigned long long ok[300003];
int main() {
ios::sync_with_stdio(false);
unsigned long long n;
scanf("%llu", &n);
unsigned long long m = n / 2;
for (unsigned long long i = 1; i <= m; i++) scanf("%llu", &ok[i]);
ara[1] = 0, ara[n] = ok[1];
for (unsigned long long i = 2; i <= m; i++) {
if (ok[i] <= ara[n - i + 2]) {
ara[i] = ara[i - 1];
ara[n - i + 1] = ok[i] - ara[i];
} else {
unsigned long long bad = ok[i] - ara[n - i + 2];
if (bad < ara[i - 1])
ara[i] = ara[i - 1];
else
ara[i] = bad;
ara[n - i + 1] = ok[i] - ara[i];
}
}
for (unsigned long long i = 1; i <= n; i++) printf("%llu ", ara[i]);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(0);
string s;
cin >> s;
string ss = s;
reverse(ss.begin(), ss.end());
cout << s << ss << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
istream& in = cin;
vector<long long> ll, lr, rl, rr;
long long n, L, mmax;
void input() {
in >> n >> L >> mmax;
for (int i = 1; i <= n; ++i) {
long long a, b, c;
in >> a >> b;
if (b == 1) {
c = a;
if (c < 0) {
lr.push_back(c);
} else {
rr.push_back(c);
}
} else {
c = a + L;
if (c > 0) {
rl.push_back(c);
} else {
ll.push_back(c);
}
}
}
}
int main() {
int TEST_CASE = 1;
while (TEST_CASE-- > 0) {
input();
sort(ll.begin(), ll.end(), greater<int>());
sort(lr.begin(), lr.end(), greater<int>());
sort(rl.begin(), rl.end());
sort(rr.begin(), rr.end());
long long ans = 0;
ans += ((long long)lr.size()) * ((long long)rl.size());
if (mmax > 1) {
int pos;
pos = -1;
for (auto k : lr) {
long long p1 = -k;
while (pos + 1 < ll.size()) {
long long p2 = -ll[pos + 1];
if (p1 * (mmax - 1) > p2 * (mmax + 1)) {
pos++;
} else {
break;
}
}
ans += pos + 1;
}
pos = -1;
for (auto k : rl) {
long long p1 = k;
while (pos + 1 < rr.size()) {
long long p2 = rr[pos + 1];
if (p1 * (mmax - 1) > p2 * (mmax + 1)) {
pos++;
} else {
break;
}
}
ans += pos + 1;
}
}
cout << ans << endl;
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long N, pw, ans;
long long K, T;
long long sc[35];
struct Matrix {
long long n, k[35][35];
Matrix Trans(long long x) {
long long i, j;
Matrix c;
c.n = n;
for (i = 0; i < K; i++) sc[i] = (i + x) % K;
sc[K] = K;
for (i = 0; i < n; i++)
for (j = 0; j <= K; j++) {
long long tx = sc[i], ty = sc[j];
c.k[tx][ty] = k[i][j];
}
return c;
}
Matrix operator*(Matrix b) const {
long long i, j, t;
Matrix c;
c.n = n;
for (i = 0; i < n; i++)
for (j = 0; j <= K; j++)
for (c.k[i][j] = 0, t = 0; t <= K; t++)
c.k[i][j] = (c.k[i][j] + (long long)k[i][t] * b.k[t][j]) % 1000000007;
return c;
}
} p[65][35], st, ts, ed;
int main() {
long long i, j, tmp, now;
scanf("%I64d %I64d", &N, &K);
st.n = 1, st.k[0][K] = 1;
p[0][0].n = K + 1;
for (i = 0; i < K; i++) p[0][0].k[i][0] = 1;
for (i = 1; i < K; i++) p[0][0].k[i][i] = 1;
p[0][0].k[K][0] = p[0][0].k[K][K] = 1;
for (T = 0, pw = 1;; pw *= K, T++) {
for (i = 1; i < K; i++) p[T][i] = p[T][i - 1] * (p[T][0].Trans(i));
p[T + 1][0] = p[T][K - 1];
if (N / K < pw) break;
}
for (T, now = 0; T >= 0; pw /= K, T--) {
tmp = N / pw;
if (tmp) st = st * p[T][tmp - 1].Trans(now);
N %= pw;
now = (now + tmp) % K;
}
for (i = 0; i <= K; i++) ans = (ans + st.k[0][i]) % 1000000007;
printf("%I64d\n", ans);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a, b;
long long int n;
cin >> a >> b >> n;
n = n % 4;
long long int first, second;
if (a == '^')
first = 0;
else if (a == '>')
first = 1;
else if (a == 'v')
first = 2;
else
first = 3;
if (b == '^')
second = 0;
else if (b == '>')
second = 1;
else if (b == 'v')
second = 2;
else
second = 3;
bool cw = false, ccw = false;
if ((first + n) % 4 == second) cw = true;
if ((first + 4 - n) % 4 == second) ccw = true;
if (cw && !ccw)
cout << "cw";
else if (ccw && !cw)
cout << "ccw";
else
cout << "undefined";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, m, k, t;
int a[maxn];
int p[maxn];
int f[2005];
int read() {
int x;
scanf("%d", &x);
return x;
}
int sum(int l, int r) { return a[r] - a[l + p[r - l + 1] - 1]; }
int main() {
int i, j;
int x, y;
n = read();
m = read();
k = read();
for (i = 1; i <= n; i++) {
a[i] = read();
}
for (i = 1; i <= m; i++) {
x = read();
y = read();
p[x] = max(p[x], y);
}
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++) {
a[i] += a[i - 1];
}
memset(f, 0x3f, sizeof(f));
f[0] = 0;
for (i = 1; i <= k; i++) {
for (j = 0; j < i; j++) {
f[i] = min(f[i], f[j] + sum(j + 1, i));
}
}
printf("%d\n", f[k]);
return 0;
}
| 13 |
#include<bits/stdc++.h>
#define mod 1000000007
using namespace std;
void subMain() {
int n;
cin >> n;
vector<int>odd, even;
int x;
for(int i=0;i<n;i++) {
cin >> x;
if(x%2!=0)
odd.push_back(x);
else
even.push_back(x);
}
for(int i=0;i<odd.size();i++)
cout << odd[i] << " ";
for(int i=0;i<even.size();i++)
cout << even[i] << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while(t--) {
subMain();
cout << "\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const int mod = 1e9 + 7;
const long long int LONGINF = 4e18;
const double eps = 1e-9;
const double PI = 3.1415926535897932384626433832795;
bool merge(string &a, string &b, string &dest) {
for (int i = 0; i < (a.size()); i++) {
if (a[i] == b[0]) {
if (i + b.size() > a.size()) {
dest = a.substr(0, i) + b;
return true;
}
dest = a;
return true;
}
}
for (int i = 0; i < (b.size()); i++) {
if (b[i] == a[0]) {
if (i + a.size() > b.size()) {
dest = b.substr(0, i) + a;
return true;
}
dest = b;
return true;
}
}
return false;
}
string v[111];
void solve() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
string ans = "";
for (int counter = 0; counter < 105; ++counter) {
for (int i = 0; i < n; ++i) {
if (v[i].size() > 0) {
for (int j = 0; j < n; ++j) {
if (i != j) {
if (merge(v[i], v[j], v[i])) v[j] = "";
}
}
}
}
}
for (int i = 0; i < (n); i++) {
printf("%s", v[i].c_str());
}
}
int main() {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
int t, n, i, j;
int main() {
for (scanf("%d", &t); t--;) {
scanf("%d", &n);
int B[26] = {};
for (i = 0; i++ < n;) {
char A[1010] = {};
scanf("%s", &A);
for (j = 0; j < strlen(A); j++) {
B[A[j] - 'a']++;
}
}
for (i = 0; i < 26; i++) {
if (B[i] % n) {
puts("NO");
goto w;
}
}
puts("YES");
w:
i;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
string s;
int x;
cin >> s >> x;
string w;
for (int i = 0; i < s.size(); i++) {
if ((i - x < 0 || s[i - x] == '1') &&
(i + x >= s.size() || s[i + x] == '1')) {
w += '1';
} else {
w += '0';
}
}
bool possible = true;
assert(w.size() == s.size());
for (int i = 0; i < s.size(); i++) {
if (i - x >= 0 && w[i - x] == '1' && s[i] != '1') {
possible = false;
}
if (i + x < w.size() && w[i + x] == '1' && s[i] != '1') {
possible = false;
}
if ((i + x >= w.size() || w[i + x] == '0') &&
(i - x < 0 || w[i - x] == '0') && s[i] != '0') {
possible = false;
}
}
if (possible) {
cout << w << '\n';
} else {
cout << "-1\n";
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n;
const int N = 1e5 + 5;
char a[N][2];
long long vis[N][2];
bool valid(long long x, long long y) {
return (x >= 1 && x <= n && y >= 0 && y <= 1 && a[x][y] == '-' &&
vis[x][y] == 0);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int k;
cin >> n >> k;
string s, t;
cin >> s >> t;
for (int i = 1; i <= n; i++) {
a[i][0] = s[i - 1];
a[i][1] = t[i - 1];
}
if (n == 1) {
cout << "YES";
return 0;
}
priority_queue<pair<long long, pair<long long, long long>>,
vector<pair<long long, pair<long long, long long>>>,
greater<pair<long long, pair<long long, long long>>>>
pq;
pq.push({1, {1, 0}});
int f = 0;
while (!pq.empty()) {
long long t = pq.top().first;
long long x = pq.top().second.first;
long long y = pq.top().second.second;
pq.pop();
if (vis[x][y]) continue;
if (t > x) {
vis[x][y] = 1;
continue;
}
vis[x][y] = 1;
if (x >= n) {
f = 1;
break;
}
if (t >= n) {
f = -1;
break;
}
if (valid(x - 1, y)) {
pq.push({t + 1, {x - 1, y}});
}
if (valid(x + 1, y)) {
pq.push({t + 1, {x + 1, y}});
}
if (x + k > n || x + 1 > n) {
cout << "YES";
return 0;
}
if (valid(x + k, !y)) {
pq.push({t + 1, {x + k, !y}});
}
}
if (f)
cout << "YES";
else
cout << "NO";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2101;
const int N = 111;
int a[N], b[N];
int color[M][M], w[M][M];
int vis[M];
long long val[M];
long long W[N][N][M];
int sto[M];
bool on[M];
int K;
void update(int x, int y, int sign, long long &ans) {
for (int i = 1; i <= K; i++) {
if (on[i]) {
ans += W[x][y][i] * sign;
}
}
}
int main() {
int n, m;
scanf("%d %d %d", &n, &m, &K);
for (int i = 1; i <= K; i++) {
int l;
scanf("%d", &l);
for (int j = 0; j < l; j++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
color[x][y] = i;
w[x][y] = z;
}
}
int nn = min(20, n), mm = min(20, m);
int num1 = 0, num2 = 0;
for (int i = 1; i <= n; i++)
if (i % nn == 0 || i == n) a[++num1] = i;
a[num1 + 1] = 10000;
for (int i = 1; i <= m; i++)
if (i % mm == 0 || i == m) b[++num2] = i;
b[num2 + 1] = 10000;
int TT = 0;
for (int i = 1; i <= num1; i++) {
for (int j = 1; j <= num2; j++) {
for (int k = 1; k <= K; k++) W[i][j][k] = 0;
for (int k = a[i - 1] + 1; k <= a[i]; k++) {
for (int r = b[j - 1] + 1; r <= b[j]; r++) {
W[i][j][color[k][r]] += w[k][r];
}
}
}
}
for (int i = 1; i <= num1; i++) {
for (int j = 1; j <= num2; j++) {
for (int k = 1; k <= K; k++) {
W[i][j][k] =
W[i][j][k] - W[i - 1][j - 1][k] + W[i][j - 1][k] + W[i - 1][j][k];
}
}
}
for (int i = 1; i <= K; i++) on[i] = 1;
int Q;
scanf("%d", &Q);
while (Q--) {
char s[101];
scanf("%s", s);
if (s[0] == 'S') {
int x;
scanf("%d", &x);
on[x] = 1 - on[x];
} else {
int x, y, xx, yy;
scanf("%d %d %d %d", &x, &y, &xx, &yy);
if (xx - x < nn * 2 || yy - y < mm * 2) {
long long ans = 0;
for (int i = x; i <= xx; i++) {
for (int j = y; j <= yy; j++) {
if (on[color[i][j]]) ans += w[i][j];
}
}
printf("%I64d\n", ans);
} else {
int X = lower_bound(a, a + num1 + 1, x - 1) - a + 1;
int Y = lower_bound(b, b + num2 + 1, y - 1) - b + 1;
int XX = upper_bound(a, a + num1 + 1, xx) - a - 1;
int YY = upper_bound(b, b + num2 + 1, yy) - b - 1;
long long ans = 0;
update(XX, YY, 1, ans);
update(X - 1, Y - 1, 1, ans);
update(XX, Y - 1, -1, ans);
update(X - 1, YY, -1, ans);
for (int i = x; i <= a[X - 1]; i++)
for (int j = y; j <= yy; j++) ans += on[color[i][j]] * w[i][j];
for (int i = a[XX] + 1; i <= xx; i++)
for (int j = y; j <= yy; j++) ans += on[color[i][j]] * w[i][j];
for (int i = a[X - 1] + 1; i <= a[XX]; i++)
for (int j = y; j <= b[Y - 1]; j++) ans += on[color[i][j]] * w[i][j];
for (int i = a[X - 1] + 1; i <= a[XX]; i++)
for (int j = b[YY] + 1; j <= yy; j++)
ans += on[color[i][j]] * w[i][j];
printf("%I64d\n", ans);
}
}
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, len;
string s;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> s;
len = s.length();
if (s[len - 2] == 'p' && s[len - 1] == 'o')
cout << "FILIPINO\n";
else if ((s[len - 4] == 'd' && s[len - 3] == 'e' && s[len - 2] == 's' &&
s[len - 1] == 'u') ||
(s[len - 4] == 'm' && s[len - 3] == 'a' && s[len - 2] == 's' &&
s[len - 1] == 'u'))
cout << "JAPANESE\n";
else if (s[len - 5] == 'm' && s[len - 4] == 'n' && s[len - 3] == 'i' &&
s[len - 2] == 'd' && s[len - 1] == 'a')
cout << "KOREAN\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long m = 1e9;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; ++i) cin >> a[i];
vector<long long> v;
for (long long i = 0; i < n; ++i) {
if (a[i] > 0)
v.emplace_back(a[i]);
else {
long long mx = -1e18;
while (i < n && a[i] < 0) {
mx = max(mx, a[i]);
++i;
}
v.emplace_back(mx);
--i;
}
}
long long sum = 0;
for (long long i = 0; i < v.size(); ++i) {
if (v[i] < 0)
sum += v[i];
else {
long long mx = -1e18;
while (i < v.size() && v[i] > 0) {
mx = max(mx, v[i]);
++i;
}
sum += mx;
--i;
}
}
cout << sum << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int md = 1e9 + 7;
const int MX = 2e5 + 5;
const int INF = 1e18;
const long double PI = 4 * atan((long double)1);
int power_md(int a, int n) {
int res = 1;
while (n) {
if (n % 2) res = (res % md * a % md) % md;
a = (a % md * a % md) % md;
n /= 2;
}
res %= md;
return res;
}
int power(int a, int n) {
int res = 1;
while (n) {
if (n % 2) res *= a;
a = a * a;
n /= 2;
}
return res;
}
int abst(int a) { return ((a < 0) ? (-1 * a) : (a)); }
class cmp_set {
public:
bool operator()(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) return (a.first > b.first);
return (a.second < b.second);
}
};
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
set<pair<int, int>, cmp_set> st;
st.insert({n, 1});
int res[n + 1];
int cnt = 1;
while (!st.empty()) {
pair<int, int> p = *(st.begin());
st.erase(p);
int l = p.second;
int r = p.second + p.first - 1;
int in = (l + r) / 2;
res[in] = cnt;
cnt++;
if ((in - 1) >= l) st.insert({in - l, l});
if ((in + 1) <= r) st.insert({r - in, in + 1});
}
for (int i = 1; i <= n; i++) cout << res[i] << " ";
cout << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128000000")
using namespace std;
const int MAXN = 2e5 + 200;
const int INF = int(1e9) + 7;
const long long LINF = 1ll * INF * INF;
const int md = int(1e9) + 7;
const long double eps = 1e-9;
const long double PI = 3.1415926535897932384626433832795l;
int n;
int na[MAXN], nb[MAXN];
int main() {
scanf("%d", &n);
int k = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
if (x > 0) {
na[k++] = x;
}
}
k = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
if (x > 0) {
nb[k++] = x;
}
}
int start = 0;
while (na[0] != nb[start]) {
start++;
}
int ok = 1;
for (int i = start; i < n - 1; i++) {
if (na[i - start] != nb[i]) {
ok = 0;
}
}
for (int i = 0; i < start; i++) {
if (na[n - 1 - start + i] != nb[i]) {
ok = 0;
}
}
if (ok) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i];
long long int max = -1;
for (long long int i = 1; i < n; i++) {
if (v[i] - v[i - 1] < 0) {
long long int d;
d = floor(log2(v[i - 1] - v[i]));
v[i] = v[i - 1];
if (d > max) max = d;
}
}
cout << max + 1 << endl;
}
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long MOD = 998244353;
double eps = 1e-12;
long long mpow(long long a, long long b) {
if (a == 0) return 0;
if (b >= (MOD - 1)) b %= (MOD - 1);
if (b == 0) return 1;
long long t1 = mpow(a, b / 2);
t1 *= t1;
t1 %= MOD;
if (b % 2) t1 *= a;
t1 %= MOD;
return t1;
}
long long mpow(long long a, long long b, long long p) {
if (a == 0) return 0;
if (b == 0) return 1;
long long t1 = mpow(a, b / 2, p);
t1 *= t1;
t1 %= p;
if (b % 2) t1 *= a;
t1 %= p;
return t1;
}
long long modinverse(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long range(long long l, long long r) { return l + rand() % (r - l + 1); }
long long rev(long long v) { return mpow(v, MOD - 2); }
void solve() {
long long n, k;
cin >> n >> k;
long long t = n - k;
if (t <= 0) {
cout << 0 << "\n";
return;
} else {
long long fact[n + 1], rfact[n + 1];
fact[0] = 1;
for (long long i = 1; i < n + 1; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
}
rfact[n] = rev(fact[n]);
for (long long i = n - 1; i >= 0; i--) {
rfact[i] = (rfact[i + 1] * (i + 1)) % MOD;
}
assert(rfact[0] == 1);
long long ans = 0;
for (long long i = 0; i < t; i++) {
long long term = (fact[t] * ((rfact[i] * rfact[t - i]) % MOD)) % MOD;
term *= mpow(t - i, n);
term %= MOD;
if (i % 2) {
ans = (ans - term + MOD) % MOD;
} else {
ans = (ans + term) % MOD;
}
}
ans *= (fact[n] * ((rfact[t] * rfact[n - t]) % MOD)) % MOD;
ans %= MOD;
if (t == n)
cout << ans << "\n";
else
cout << (2 * ans) % MOD << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
for (long long i = 0; i < t; i++) {
solve();
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
struct Node {
long long val;
int id;
bool operator<(const Node& b) const { return abs(val) > abs(b.val); }
} a[maxn];
priority_queue<Node> q;
int main() {
cin.sync_with_stdio(false);
int n, k, x, cnt = 0, minn = 0;
cin >> n >> k >> x;
for (int i = 0; i < n; i++) {
cin >> a[i].val;
a[i].id = i;
if (a[i].val < 0) cnt++;
q.push(a[i]);
}
while (k--) {
Node now = q.top();
q.pop();
if (now.val >= 0) {
if (cnt & 1)
a[now.id].val += x;
else
a[now.id].val -= x;
if (a[now.id].val < 0) cnt++;
q.push(a[now.id]);
} else {
if (cnt & 1)
a[now.id].val -= x;
else
a[now.id].val += x;
if (a[now.id].val >= 0) cnt--;
q.push(a[now.id]);
}
}
for (int i = 0; i < n; i++)
printf("%I64d%c", a[i].val, i == n - 1 ? '\n' : ' ');
return 0;
}
| 12 |
#include <bits/stdc++.h>
std::mt19937_64 rng(
std::chrono::steady_clock::now().time_since_epoch().count());
long long int myRand(long long int R) {
long long int val = rng() % R;
assert(val >= 0);
return val;
}
const long double PI = atan(1.0) * 4;
const int32_t INF32 = 2e9 + 7;
const int64_t INF64 = 3e18;
const int32_t LOG = 21;
const int32_t MOD = 1e9 + 7;
using namespace std;
void my_debugger(string second, long long int LINE_NUM) { cerr << '\n'; }
template <typename start, typename... end>
void my_debugger(string second, long long int LINE_NUM, start x, end... y) {
if (second.back() != ',') {
second += ',';
cerr << "LINE(" << LINE_NUM << "): ";
}
long long int i = second.find(',');
cerr << second.substr(0, i) << " = " << x;
second = second.substr(i + 1);
if (!second.empty()) cerr << ", ";
my_debugger(second, LINE_NUM, y...);
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
long long int tests = 1;
cin >> tests;
for (long long int ii = 0; ii < (long long int)tests; ii++) {
long long int n;
cin >> n;
string second;
cin >> second;
long long int ans = n * n;
{
long long int cnt = 0;
for (long long int i = 0; i < (long long int)n - 1; i++) {
if (second[i] == '1' && second[i + 1] == '0') cnt++;
}
ans = min(ans, (n / 2) - cnt);
}
{
long long int cnt = 0;
for (long long int i = 0; i < (long long int)n - 1; i++) {
if (second[i] == '0' && second[i + 1] == '1') cnt++;
}
ans = min(ans, (n / 2) - cnt);
}
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int mine(long long int a, long long int b) {
if (a < b) return a;
return b;
}
long long int helper(long long int x, long long int plus, long long int minus) {
if (x >= 0) return x * plus;
return minus * (-x);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
long long int x, y;
cin >> x >> y;
long long int cost[6];
for (int i = 0; i < 6; i++) cin >> cost[i];
long long int ans = 5e18 + 1;
ans = mine(ans, helper(x, cost[5], cost[2]) + helper(y, cost[1], cost[4]));
ans = mine(ans,
helper(y, cost[0], cost[3]) + helper(x - y, cost[5], cost[2]));
ans = mine(ans,
helper(x, cost[0], cost[3]) + helper(y - x, cost[1], cost[4]));
cout << ans << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int T;
scanf("%d",&T);
while(T--){
int a, b, c;
scanf("%d%d%d",&a,&b,&c);
int sum = a + b + c;
int p=min(b,c);
int minx = min(a, p);
if (sum % 9 == 0 && sum / 9 <= minx) printf("YES\n");
else puts("NO");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
long long int a[200010];
long long int last[200010];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, q;
cin >> n;
vector<long long int> pays;
for (long long int i = 0; i < n; ++i) cin >> a[i];
cin >> q;
while (q--) {
long long int t;
cin >> t;
if (t == 1) {
long long int p, x;
cin >> p >> x;
p--;
a[p] = x;
last[p] = pays.size();
} else {
long long int x;
cin >> x;
pays.push_back(x);
}
}
vector<long long int> ma;
ma.push_back(-1);
reverse(pays.begin(), pays.end());
for (auto b : pays) ma.push_back(max(ma.back(), b));
reverse(ma.begin(), ma.end());
for (long long int i = 0; i < n; ++i) {
cout << max(a[i], ma[last[i]]) << " ";
}
cout << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k[5];
int t[4];
for (int i = (1), ei = (4); i < ei; i++) cin >> k[i];
for (int i = (1), ei = (4); i < ei; i++) cin >> t[i];
int n;
cin >> n;
k[4] = n + 1;
int *A = new int[n];
char *S = new char[n];
memset(S, 0, n);
for (int i = (0), ei = (n); i < ei; i++) scanf("%d", A + i);
sort(A, A + n);
queue<long long> q[4];
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
ev;
for (int i = (0), ei = (n); i < ei; i++)
ev.push(pair<long long, long long>(A[i], i));
long long res = 0;
while (!ev.empty()) {
int v = ev.top().second;
long long tm = ev.top().first;
ev.pop();
if (S[v] > 0) {
k[S[v]]++;
if (!q[S[v]].empty()) {
int v2 = q[S[v]].front();
q[S[v]].pop();
k[S[v]]--;
S[v2]++;
ev.push(pair<long long, long long>(tm + t[S[v2]], v2));
}
}
if (k[S[v] + 1] > 0) {
k[S[v] + 1]--;
S[v]++;
if (S[v] == 4)
res = max(res, tm - A[v]);
else
ev.push(pair<long long, long long>(tm + t[S[v]], v));
} else
q[S[v] + 1].push(v);
}
cout << res << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1.01e9;
const long long infll = (long long)1.01e18;
const long double eps = 1e-9;
const long double pi = acos((long double)-1);
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int x) { return mrand() % x; }
void precalc() {}
const int maxn = (int)2e5 + 5;
int n;
int a[maxn];
bool read() {
if (scanf("%d", &n) < 1) {
return false;
}
for (int i = 0; i < 2 * n; i++) {
scanf("%d", &a[i]);
}
return true;
}
void solve() {
sort(a, a + 2 * n);
long long res = (long long)(a[n - 1] - a[0]) * (a[2 * n - 1] - a[n]);
for (int i = 1; i < n; i++) {
res = min(res, (long long)(a[i + n - 1] - a[i]) * (a[2 * n - 1] - a[0]));
}
printf("%lld\n", res);
}
int main() {
precalc();
while (read()) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,sse4.2,popcnt,abm,mmx,avx")
using namespace std;
template <class U, class V>
istream& operator>>(istream& is, pair<U, V>& p) {
is >> p.first >> p.second;
return is;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& x : v) {
is >> x;
}
return is;
}
template <class T>
ostream& operator<<(ostream& os, vector<T>& v) {
for (auto& x : v) {
os << x << " ";
}
return os;
}
static char buf[200 << 20];
static size_t last_size = 0;
static size_t buf_nxt = sizeof buf;
void* operator new(size_t s) {
last_size = s;
return (void*)&buf[buf_nxt -= s];
}
void operator delete(void* ptr) {
if (ptr == ((void*)&buf[buf_nxt])) {
buf_nxt += last_size;
}
}
const int N = 1e6 + 5;
int res[N];
int height[N];
vector<int> adj[N];
void build_info(int node, int parent) {
height[node] = 1;
for (int v : adj[node]) {
if (v == parent) continue;
build_info(v, node);
height[node] = max(height[node], 1 + height[v]);
}
}
void merge(const vector<int>& small, vector<int>& big, int node) {
for (int i = 0; i < ((int)(small.size())); ++i) {
int j = i + ((int)(big.size())) - ((int)(small.size()));
big[j] += small[i];
if (big[j] >= big[res[node]] &&
(big[j] > big[res[node]] || j > res[node])) {
res[node] = j;
}
}
}
vector<int> solve(int node, int parent) {
if (height[node] == 1) {
res[node] = 0;
return {1};
}
int big_child = -1;
vector<int> d;
for (int v : adj[node]) {
if (v == parent) continue;
if (height[v] == height[node] - 1) {
big_child = v;
d = solve(v, node);
res[node] = res[big_child];
break;
}
}
for (int v : adj[node]) {
if (v == parent) continue;
if (v == big_child) continue;
auto child_d = solve(v, node);
merge(child_d, d, node);
}
d.emplace_back(1);
if (d[res[node]] == 1) {
res[node] = ((int)(d.size())) - 1;
}
return d;
}
inline int read() {
int now = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); now = now * 10 + c - '0', c = getchar())
;
return now;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n = read();
for (int i = 1; i < n; ++i) {
int u = read(), v = read();
adj[u].emplace_back(v);
adj[v].emplace_back(u);
}
build_info(1, 0);
solve(1, 0);
for (int i = 1; i <= n; ++i) {
cout << height[i] - 1 - res[i] << '\n';
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 16) + 100;
int n, deg[MAXN], b[MAXN], cnt;
vector<int> v[MAXN];
bool bio[MAXN];
void rek(int cvor) {
bio[cvor] = 1;
b[b[cvor]] ^= cvor;
deg[b[cvor]]--;
cnt++;
v[cvor].push_back(b[cvor]);
if (deg[b[cvor]] == 1) rek(b[cvor]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d %d", °[i], &b[i]);
for (int i = 0; i <= n; i++)
if (!bio[i] && deg[i] == 1) rek(i);
printf("%d\n", cnt);
for (int i = 0; i < MAXN; i++)
for (int j = 0; j < (int)v[i].size(); j++) printf("%d %d\n", i, v[i][j]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
long long int x;
int n, count = 0, i, j;
cin >> n >> x;
for (i = 1; i <= n; i++) {
if (x % i == 0) {
v.push_back(i);
}
}
for (int i = 0; i < v.size(); i++) {
if (x / v[i] <= n) {
++count;
}
}
cout << count << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double dp[2005][2005];
int main() {
int n, t;
double p;
scanf("%d %lf %d", &n, &p, &t);
for (int nn = 0; nn < n; nn++) dp[nn][0] = 0.0;
dp[n][0] = 1.0;
for (int tt = 1; tt <= t; tt++) {
dp[n][tt] = dp[n][tt - 1] * (1 - p);
for (int nn = n - 1; nn > 0; nn--) {
dp[nn][tt] = (1 - p) * dp[nn][tt - 1] + p * dp[nn + 1][tt - 1];
}
dp[0][tt] = dp[0][tt - 1] + p * dp[1][tt - 1];
}
double res = 0.0;
for (int nn = 0; nn <= n; nn++) {
res += (dp[nn][t] * (n - nn));
}
printf("%.8f\n", res);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char s[100100], ss[100100];
int n, A, C, G, T, rep[100100];
int main() {
scanf("%d %s", &n, s);
int cnt = 0;
if (n % 4) {
puts("===");
return 0;
}
for (int i = 0; i < n; i++) {
if (s[i] == 'A')
A++;
else if (s[i] == 'C')
C++;
else if (s[i] == 'G')
G++;
else if (s[i] == 'T')
T++;
else
rep[cnt++] = i;
}
if (A > n / 4 || C > n / 4 || G > n / 4 || T > n / 4) {
puts("===");
return 0;
}
int runs = 0;
for (int i = A + 1; i <= n / 4; i++) ss[runs++] = 'A';
for (int i = C + 1; i <= n / 4; i++) ss[runs++] = 'C';
for (int i = G + 1; i <= n / 4; i++) ss[runs++] = 'G';
for (int i = T + 1; i <= n / 4; i++) ss[runs++] = 'T';
for (int i = 0; i < cnt; i++) s[rep[i]] = ss[i];
puts(s);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define ll long long
#define fi first
#define se second
#define pb push_back
#define me memset
#define rep(a,b,c) for(int a=b;a<=c;++a)
#define per(a,b,c) for(int a=b;a>=c;--a)
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
using namespace std;
typedef pair<int,int> PII;
typedef pair<ll,ll> PLL;
ll gcd(ll a,ll b) {return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b) {return a/gcd(a,b)*b;}
int main(){
ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int _;
cin>>_;
while(_--){
int n,l,r,s;
cin>>n>>l>>r>>s;
vector<int> a(n+1);
vector<bool> st(n+1,false);
int k=r-l+1;
int low=k*(k+1)/2;
int high=k*(n-k+1+n)/2;
if(s<low || s>high) {cout<<-1<<'\n';continue;}
int diff=s-low;
int block=diff/k;
int rest=diff%k;
rep(i,1,k){
a[i]=i+block;
}
per(i,k,1){
if(rest==0) break;
a[i]++;
rest--;
}
rep(i,1,k) st[a[i]]=true;
rep(i,1,l-1){
rep(j,1,n){
if(!st[j]){
st[j]=true;
cout<<j<<' ';
break;
}
}
}
rep(i,1,k){
cout<<a[i]<<' ';
}
rep(i,r+1,n){
rep(j,1,n){
if(!st[j]){
st[j]=true;
cout<<j<<' ';
break;
}
}
}
cout<<'\n';
}
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
long long arr[1000100];
signed main() {
long long costly = 0;
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
char ch;
cin >> ch;
arr[i] = (ch == '(' ? 1 : -1);
}
long long zoo = 0;
long long i = 0;
while (i < n) {
zoo += arr[i];
if (zoo < 0 or (zoo == 0 and arr[i] == 1)) costly++;
i++;
}
if (zoo != 0) costly = -1;
cout << costly << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int vis[3005] = {}, par[3005] = {}, dis[3005];
int flag = 0, parent = 0;
vector<int> adj[3005];
void dfs(int t) {
for (int i = 0; i < adj[t].size(); i++) {
if (!vis[adj[t][i]]) {
vis[adj[t][i]] = 1;
par[adj[t][i]] = t;
dfs(adj[t][i]);
} else if (flag == 0 && par[t] != adj[t][i]) {
flag = t;
parent = adj[t][i];
}
}
}
void dist(int t) {
for (int i = 0; i < adj[t].size(); i++) {
if (!vis[adj[t][i]]) {
vis[adj[t][i]] = 1;
if (dis[adj[t][i]] == -1) dis[adj[t][i]] = dis[t] + 1;
dist(adj[t][i]);
}
}
}
int main() {
int n, x, y;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
memset(dis, -1, sizeof(dis));
dfs(1);
dis[parent] = 0;
while (flag != parent) {
dis[flag] = 0;
flag = par[flag];
}
memset(vis, 0, sizeof(vis));
dist(parent);
for (int i = 1; i <= n; i++) cout << dis[i] << " ";
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, num[2001], dp[2001][2001], lts[10] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
bool pos[2001][10];
string db[10] = {"1110111", "0010010", "1011101", "1011011", "0111010",
"1101011", "1101111", "1010010", "1111111", "1111011"},
in;
bool ok(string x, int y) {
for (int i = 0; i < 7; i++)
if ((x[i] == '1') && (db[y][i] != '1')) return false;
return true;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> in;
for (int j = 0; j < 10; j++) pos[i][j] = ok(in, j);
for (int j = 0; j < in.length(); j++)
if (in[j] == '1') num[i]++;
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= k; j++) dp[i][j] = -1;
dp[n][0] = 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= k; j++) {
for (int dig = 0; dig < 10; dig++) {
int diff = lts[dig] - num[i];
if ((diff <= j) && (dp[i + 1][j - diff] != -1) && (pos[i][dig]))
dp[i][j] = dig;
}
}
}
if (dp[0][k] == -1)
cout << -1 << endl;
else {
int cur = k;
for (int i = 0; i < n; i++) {
cout << dp[i][cur];
int diff = lts[dp[i][cur]] - num[i];
cur -= diff;
}
cout << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool sortin(const pair<long long int, long long int> &e,
const pair<long long int, long long int> &f) {
return (e.first < f.first);
}
long long int a, b, c, i, j, k, l, m, n, p, q, r, x, y, z, ts, mn = 10e17,
mod = 10e8 + 7;
long long int ar[250002], br[250002], xr[250002];
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
cin >> ts;
while (ts--) {
cin >> n;
set<long long int> st, tt;
for (long long int i = 1; i <= n; i++) {
cin >> m;
st.insert(m);
}
set<long long int>::iterator it;
it = st.begin();
p = *it;
it = st.end();
it--;
q = *it;
p *= q;
for (long long int i = 2; i <= sqrt(p); i++) {
if (p % i == 0) tt.insert(i), tt.insert(p / i);
}
if (st == tt)
cout << p;
else
cout << -1;
cout << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5;
long long a[N], b[N];
long long hugs[N];
long long sum[N];
long long n, x;
long long get(long long a) { return a * (a + 1) / 2ll; }
long long f(long long p) {
long long w = b[p] + x;
long long where = lower_bound(b, b + N, w) - b;
long long passed = b[where - 1] - b[p];
long long resp = sum[where - 1] - sum[p];
long long can_extend = min(a[p] - 1, a[(where - 1) % n] - (x - passed));
resp -= get(can_extend);
resp += get(x - passed + can_extend);
return resp;
}
int main() {
cin >> n >> x;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) hugs[i] = get(a[i]);
for (int i = 0; i < N - 1; i++) sum[i + 1] = sum[i] + hugs[i % n];
for (int i = 0; i < N - 1; i++) b[i + 1] = b[i] + a[i % n];
long long der = 0;
long long mx = 0;
for (int i = 0; i < n; i++) {
mx = max(mx, f(i));
}
cout << mx << '\n';
return 0;
}
| 11 |
#include <iostream>
using namespace std;
int main(void){
int t;cin>>t;
while(t--){
long long n,m,x;
cin>>n>>m>>x;
x-=1;
int row=(x%n);
int col=x/n;
cout<<row*m+col+1<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char s[4][123];
int main(int argc, char const *argv[]) {
int n;
std::cin >> n;
if (n & 1) {
for (int i = 1, j = 0; i < n; i += 2, j++) {
if (j & 1) {
s[0][i] = s[0][i + 1] = 'b';
s[1][i] = s[1][i + 1] = 'c';
} else {
s[0][i] = s[0][i + 1] = 'd';
s[1][i] = s[1][i + 1] = 'e';
}
}
for (int i = 0, j = 0; i < n; i += 2, j++) {
if (j & 1) {
s[2][i] = s[2][i + 1] = 'f';
s[3][i] = s[3][i + 1] = 'g';
} else {
s[2][i] = s[2][i + 1] = 'h';
s[3][i] = s[3][i + 1] = 'i';
}
}
s[0][0] = s[1][0] = 'a';
s[2][n - 1] = s[3][n - 1] = 'z';
} else {
for (int i = 1, j = 0; i < n; i += 2, j++) {
if (j & 1) {
s[1][i] = s[1][i + 1] = 'b';
s[2][i] = s[2][i + 1] = 'c';
} else {
s[1][i] = s[1][i + 1] = 'd';
s[2][i] = s[2][i + 1] = 'e';
}
}
for (int i = 0, j = 0; i < n; i += 2, j++) {
if (j & 1) {
s[0][i] = s[0][i + 1] = 'f';
s[3][i] = s[3][i + 1] = 'g';
} else {
s[0][i] = s[0][i + 1] = 'h';
s[3][i] = s[3][i + 1] = 'i';
}
}
s[2][0] = s[1][0] = 'a';
s[2][n - 1] = s[1][n - 1] = 'z';
}
s[0][n] = s[1][n] = 0;
s[2][n] = s[3][n] = 0;
for (int i = 0; i < 4; i++) {
std::cout << s[i] << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ii = pair<int, int>;
int typeC, offerC;
int total_needs;
int needs[200000];
int bought[200000];
ii offers[200000];
bool trydone(int day) {
fill(bought, bought + typeC, 0);
int earned = day;
int cost_non_sale = total_needs * 2;
int needs_sale = cost_non_sale - earned;
if (needs_sale > total_needs) return false;
ii* last_sale = lower_bound(offers, offers + offerC, ii{day + 1, 0}) - 1;
int needAtLeast = 0;
int needAtLeastAt = day;
while (last_sale >= offers) {
int saleday = last_sale->first;
needAtLeast -= (needAtLeastAt - saleday);
needAtLeast = max(0, needAtLeast);
needAtLeastAt = saleday;
int saletype = last_sale->second;
int canBuy = needs[saletype] - bought[saletype];
int maxBuy = saleday - needAtLeast;
int buy = min(canBuy, maxBuy);
needAtLeast += buy;
bought[saletype] += buy;
needs_sale -= buy;
if (needs_sale <= 0) return true;
last_sale--;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> typeC >> offerC;
for (int i = 0; i < typeC; i++) {
cin >> needs[i];
total_needs += needs[i];
}
for (int i = 0; i < offerC; i++) {
int day, type;
cin >> day >> type;
type--;
offers[i] = {day, type};
}
sort(offers, offers + offerC);
int lo = 0;
int hi = 2 * total_needs;
while (lo + 1 < hi) {
int mid = (lo + hi) / 2;
if (trydone(mid)) {
hi = mid;
} else {
lo = mid;
}
}
cout << hi << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int k, n, m;
long long a[N];
int op[N];
struct assign {
long long num;
int id;
bool operator<(const assign& tmp) const { return num < tmp.num; }
} as[N];
struct add {
long long num;
int id;
};
vector<add> ad[N];
struct mul {
long double num;
int id;
};
vector<mul> mu;
int x;
long long y;
assign max(assign a, assign b) {
if (a < b)
return b;
else
return a;
}
bool cmp(add a, add b) { return a.num > b.num; }
bool cmp1(mul a, mul b) { return a.num > b.num; }
bool cmp2(mul a, mul b) { return op[a.id] < op[b.id]; }
int ans[N], cntt;
int main() {
cin >> k >> n >> m;
for (int i = 1; i <= k; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) {
scanf("%d %d %lld", &op[i], &x, &y);
if (op[i] == 1) {
as[x] = max(as[x], (assign){y, i});
}
if (op[i] == 2) {
ad[x].push_back((add){y, i});
}
if (op[i] == 3) {
mu.push_back((mul){1.0 * y, i});
}
}
for (int i = 1; i <= k; i++) {
if (as[i].num > a[i]) {
ad[i].push_back((add){as[i].num - a[i], as[i].id});
}
}
for (int i = 1; i <= k; i++) {
sort(ad[i].begin(), ad[i].end(), cmp);
long long tmp = a[i];
for (unsigned int j = 0; j < ad[i].size(); j++) {
mu.push_back((mul){1.0 * (tmp + ad[i][j].num) / tmp, ad[i][j].id});
tmp += ad[i][j].num;
}
}
sort(mu.begin(), mu.end(), cmp1);
int tmp = mu.size();
m = min(m, tmp);
cout << m << endl;
for (int i = 0; i < m; i++) {
if (op[mu[i].id] == 1) printf("%d ", mu[i].id);
}
for (int i = 0; i < m; i++) {
if (op[mu[i].id] == 2) printf("%d ", mu[i].id);
}
for (int i = 0; i < m; i++) {
if (op[mu[i].id] == 3) ans[++cntt] = mu[i].id;
}
sort(ans + 1, ans + cntt + 1);
for (int i = 1; i <= cntt; i++) cout << ans[i] << " ";
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int hp_y, atk_y, def_y, hp_m, atk_m, def_m, h, a, d;
int atk1, atk2, hp1, hp2, sum, temp, jiafa, A, B;
while (scanf("%d%d%d%d%d%d%d%d%d", &hp_y, &atk_y, &def_y, &hp_m, &atk_m,
&def_m, &h, &a, &d) != EOF) {
temp = 10e9;
jiafa = 0;
for (int i = atk_y; i <= 201; i++) {
for (int j = def_y; j <= 201; j++) {
sum = (i - atk_y) * a + (j - def_y) * d;
atk1 = i - def_m;
atk2 = atk_m - j;
hp1 = hp_y;
hp2 = hp_m;
if (atk1 <= 0) continue;
while (hp2 > 0 && atk2 >= 0) {
hp1 -= atk2;
hp2 -= atk1;
if (hp1 <= 0) {
sum += (1 - hp1) * h;
hp1 = 1;
}
}
if (sum < temp) {
temp = sum;
A = atk_y;
B = def_y;
}
}
}
printf("%d\n", temp);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int DX[] = {1, 0, -1, 0}, DY[] = {0, -1, 0, 1};
const int INF = INT_MAX / 2;
int n;
vector<pair<int, int> > p_ts, m_ts;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < (n); i++) {
pair<int, int> t;
cin >> t.first >> t.second;
if (t.first >= 0) {
p_ts.push_back(t);
} else {
m_ts.push_back(t);
}
}
sort(p_ts.begin(), p_ts.end());
sort(m_ts.rbegin(), m_ts.rend());
int ans = 0;
int p = p_ts.size(), m = m_ts.size();
if (p == m) {
for (int i = 0; i < (p); i++) {
ans += p_ts[i].second + m_ts[i].second;
}
} else if (p > m) {
int pc = 0, mc = 0;
for (int i = 0; i < (m * 2 + 1); i++) {
ans += (i % 2) ? m_ts[pc++].second : p_ts[mc++].second;
}
} else {
int pc = 0, mc = 0;
for (int i = 0; i < (p * 2 + 1); i++) {
ans += (i % 2) ? p_ts[pc++].second : m_ts[mc++].second;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
int a[40005], b[40005];
vector<long long> coo(int *ar, int ss) {
vector<long long> v(40005, 0);
int j = 0;
for (int i = 0; i < ss; i++) {
if (ar[i] == 0) continue;
j = i;
while (j + 1 < ss && ar[j + 1] == 1) j++;
int cnt = j - i + 1;
for (int p = 1; p <= cnt; p++) v[p] += (cnt - p + 1);
i = j;
}
return v;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
vector<long long> va = coo(a, n);
vector<long long> vb = coo(b, m);
long long ans = 0LL;
int i = 1;
while (k / i > 40000) i++;
for (; i * i <= k && i <= 40000; i++) {
if (k % i == 0) {
ans += va[i] * 1LL * vb[k / i];
if (i * 1LL * i != k) ans += vb[i] * 1LL * va[k / i];
}
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long gcd(long long a, long long b) {
if (a < b)
return gcd(b, a);
else if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long isPrime(long long n) {
long long p = (long long)sqrt(n);
for (long long i = 2; 2 < p + 1 ? i < p + 1 : i > p + 1;
2 < p + 1 ? i += 1 : i -= 1)
if (n % i == 0) return 0;
return 1;
}
long long pow(long long b, long long e) {
if (e == 0)
return 1;
else if (e % 2 == 0) {
long long a = pow(b, e / 2);
return a * a;
} else {
long long a = pow(b, e / 2);
return b * a * a;
}
}
long long pow_m(long long x, long long y, long long m = 1000000007) {
x = x % m;
long long res = 1;
while (y) {
if (y & 1) res = res * x;
res %= m;
y = y >> 1;
x = x * x;
x %= m;
}
return res;
}
long long modInverse(long long a, long long m) { return pow_m(a, m - 2, m); }
long long max(long long a, long long b) {
if (a >= b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a <= b)
return a;
else
return b;
}
long long dp[static_cast<int>(2e5 + 100)][3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, l, r;
cin >> n >> l >> r;
long long a = r / 3 - (l - 1) / 3;
long long b = (r + 2) / 3 - (l + 1) / 3;
long long c = (r + 1) / 3 - l / 3;
dp[1][0] = a;
dp[1][1] = b;
dp[1][2] = c;
for (long long i = 2; 2 < n + 1 ? i < n + 1 : i > n + 1;
2 < n + 1 ? i += 1 : i -= 1) {
dp[i][0] = (dp[i - 1][0] * a % 1000000007 + dp[i - 1][1] * c % 1000000007 +
dp[i - 1][2] * b % 1000000007) %
1000000007;
dp[i][1] = (dp[i - 1][0] * b % 1000000007 + dp[i - 1][1] * a % 1000000007 +
dp[i - 1][2] * c % 1000000007) %
1000000007;
dp[i][2] = (dp[i - 1][0] * c % 1000000007 + dp[i - 1][1] * b % 1000000007 +
dp[i - 1][2] * a % 1000000007) %
1000000007;
}
cout << dp[n][0] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j = 0;
cin >> n >> k;
if (n / k < 3) {
cout << "-1";
return 0;
}
for (i = 0; i < 2 * k; i++) {
cout << j % k + 1 << " ";
j++;
}
j++;
for (i = 2 * k; i < n; i++) {
cout << j % k + 1 << " ";
j++;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
class UnionFind {
private:
std::vector<int> m_uf;
std::vector<int> m_sz;
public:
UnionFind(const int size) {
m_uf.reserve(size + 1);
m_sz.reserve(size + 1);
for (int i = 0; i <= size; ++i) {
m_uf.push_back(i);
m_sz.push_back(1);
}
}
int find(const int x) {
if (m_uf[x] != x) m_uf[x] = find(m_uf[x]);
return m_uf[x];
}
void merge(const int a, const int b) {
const int gpa = find(a);
const int gpb = find(b);
if (gpa != gpb) {
if (m_sz[gpa] < m_sz[gpb]) {
m_uf[gpa] = gpb;
m_sz[gpb] += m_sz[gpa];
} else {
m_uf[gpb] = gpa;
m_sz[gpa] += m_sz[gpb];
}
}
}
bool same(const int a, const int b) { return find(a) == find(b); }
int size(const int a) {
const int gpa = find(a);
return m_sz[gpa];
}
};
template <typename T>
class Kruskal {
private:
struct Edge {
int u, v;
T w;
bool operator<(const Edge rhs) const { return w < rhs.w; }
};
int m_vertices;
UnionFind m_uf;
vector<Edge> m_edges;
public:
Kruskal(const int n) : m_vertices(n), m_uf(n + 1) {}
void add_edge(const int u, const int v, const T w) {
m_edges.push_back({u, v, w});
}
T compute_tree() {
T ans = 0;
int edges_added = 0;
sort(m_edges.begin(), m_edges.end());
for (const Edge e : m_edges) {
if (m_uf.find(e.u) != m_uf.find(e.v)) {
m_uf.merge(e.u, e.v);
ans += e.w;
if (++edges_added == m_vertices - 1) break;
}
}
return ans;
}
pair<T, int> compute_forest() {
pair<T, int> ans = make_pair(0, m_vertices);
sort(m_edges.begin(), m_edges.end());
for (const Edge e : m_edges) {
if (!m_uf.same(e.u, e.v)) {
m_uf.merge(e.u, e.v);
ans.first += e.w;
ans.second -= 1;
}
}
return ans;
}
};
long long solve(int n) {
Kruskal<long long> kruskal(n);
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
kruskal.add_edge(i, j, i ^ j);
}
}
long long val = kruskal.compute_tree();
return val;
}
long long solve2(long long n) {
if (n <= 1) {
return 0;
}
long long pot = 1;
while (pot * 2 <= n) pot *= 2;
long long ans_pot = 2 * solve2(pot / 2) + (pot / 2);
long long ans2 = solve2(n - pot);
if (pot != n) ans2 += pot;
return ans2 + ans_pot;
}
int32_t main() {
long long n;
cin >> n;
cout << solve2(n) << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char s[100];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
int g = strlen(s);
if (g > 10) {
cout << s[0] << g - 2 << s[g - 1] << endl;
} else {
cout << s << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int q;
long long a[500003];
long long sum[803][803];
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
bool f = false;
while (c < '0' || c > '9') {
if (c == '-') f = true;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (f) x = -x;
}
int main() {
read(q);
while (q--) {
int o, x, y;
read(o), read(x), read(y);
if (o == 1) {
a[x] += y;
for (int i = 1; i <= 800; i++) sum[i][x % i] += y;
} else {
if (x <= 800)
printf("%lld\n", sum[x][y]);
else {
long long ans = 0;
for (int i = y; i <= 500000; i += x) ans += a[i];
printf("%lld\n", ans);
}
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 3e3 + 69;
long long n;
vector<long long> a[MAXN];
long long par[MAXN][MAXN];
long long sz[MAXN][MAXN];
long long dp[MAXN][MAXN];
void dfs(long long u, long long p, long long root) {
par[root][u] = p;
sz[root][u] = 1;
for (long long v : a[u]) {
if (v == p) continue;
dfs(v, u, root);
sz[root][u] += sz[root][v];
}
}
void init() {
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++) dp[i][j] = -1;
}
long long solve(long long u, long long v) {
if (u == v) return 0;
if (u > v) swap(u, v);
if (dp[u][v] != -1) return dp[u][v];
long long put_u = solve(u, par[u][v]);
long long put_v = solve(v, par[v][u]);
long long res = sz[u][v] * sz[v][u] + max(put_u, put_v);
return dp[u][v] = res;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1, u, v; i <= n - 1; i++) {
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
for (long long i = 1; i <= n; i++) dfs(i, i, i);
init();
long long ans = 0;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++) ans = max(ans, solve(i, j));
cout << ans;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const long long NR = 1e5 + 10;
void Min(long long& x, long long y) { x = min(x, y); }
void Max(long long& x, long long y) { x = max(x, y); }
long long n, m;
long long ans;
char a[NR];
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
signed main() {
n = read(), m = read();
for (long long i = 1; i <= n; i++) scanf(" %c", &a[i]);
for (long long i = 1; i <= n; i++) ans += n * (m - 1) * (a[i] != a[i - 1]);
long long now = 0;
for (long long i = 2; i <= n; i++) {
if (!now)
now += (a[i] != a[i - 1]);
else if (a[i] == a[i - 2])
now++;
else if (a[i] != a[i - 1])
ans -= (now + 1) * now / 2, now = 1;
else
ans -= (now + 1) * now / 2, now = 0;
}
ans -= now * (now + 1) / 2;
printf("%lld\n", ans);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
n = (n - 2) * (n - 2);
cout << n;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const double eps = 1e-12;
const int step[8][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
template <class T>
inline T abs1(T a) {
return a < 0 ? -a : a;
}
template <class T>
inline T max1(T a, T b, T c = -1234567, T d = -1234567) {
T ans = a > b ? a : b;
if (c != -1234567) ans = max1(ans, c);
if (d != -1234567) ans = max1(ans, d);
return ans;
}
template <class T>
inline T min1(T a, T b, T c = -1234567, T d = -1234567) {
T ans = a < b ? a : b;
if (c != -1234567) ans = min(ans, c);
if (d != -1234567) ans = min(ans, d);
return ans;
}
template <class T>
inline T gcd1(T a, T b) {
if (a < b) swap(a, b);
if (a % b == 0) return b;
return gcd1(b, a % b);
}
template <class T>
inline T lb(T num) {
return num & (-num);
}
inline int jud(double a, double b) {
if (abs(a) < eps && abs(b) < eps)
return 0;
else if (abs1(a - b) / abs1(a) < eps)
return 0;
if (a < b) return -1;
return 1;
}
template <typename t>
inline int jud(t a, t b) {
if (a < b) return -1;
if (a == b) return 0;
return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
int be = 0, en = na - 1;
if (*a <= *(a + na - 1)) {
if (f_lb == 0)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != 1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != -1)
en = mid;
else
be = mid + 1;
}
if (f_small && jud(*(a + be), val) == 1) be--;
if (!f_small && jud(*(a + be), val) == -1) be++;
} else {
if (f_lb)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != -1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != 1)
en = mid;
else
be = mid + 1;
}
if (!f_small && jud(*(a + be), val) == -1) be--;
if (f_small && jud(*(a + be), val) == 1) be++;
}
return be;
}
inline int bitnum(unsigned long long nValue) {
nValue = ((0xaaaaaaaaaaaaaaaaull & nValue) >> 1) +
(0x5555555555555555ull & nValue);
nValue = ((0xccccccccccccccccull & nValue) >> 2) +
(0x3333333333333333ull & nValue);
nValue = ((0xf0f0f0f0f0f0f0f0ull & nValue) >> 4) +
(0x0f0f0f0f0f0f0f0full & nValue);
nValue = ((0xff00ff00ff00ff00ull & nValue) >> 8) +
(0x00ff00ff00ff00ffull & nValue);
nValue = ((0xffff0000ffff0000ull & nValue) >> 16) +
(0x0000ffff0000ffffull & nValue);
nValue = ((0xffffffff00000000ull & nValue) >> 32) +
(0x00000000ffffffffull & nValue);
return nValue;
}
long long pow(long long n, long long m, long long mod = 0) {
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
const int maxn = 50110;
char str[maxn];
vector<int> loc[26];
pair<int, string> dp[55];
int maxl = 1;
int main() {
ios_base::sync_with_stdio(0);
scanf("%s", str);
int l = strlen(str);
for (int i = 0; i < l; i++) {
loc[str[i] - 'a'].push_back(i);
}
dp[0] = make_pair(l, "");
dp[1].first = -1;
string ans = "";
for (int i = 0; i < l && ans.size() < 100; i++) {
for (int j = maxl - 1; j >= 0; j--) {
vector<int>::iterator loc1 = lower_bound(
loc[str[i] - 'a'].begin(), loc[str[i] - 'a'].end(), dp[j].first);
if (loc1 == loc[str[i] - 'a'].begin()) continue;
loc1--;
if (*loc1 > dp[j + 1].first && *loc1 >= i) {
dp[j + 1] = make_pair(*loc1, dp[j].second + str[i]);
if (j == maxl - 1 || (j == maxl - 2 && *loc1 > i)) {
if (j == maxl - 1) maxl++;
if (*loc1 > i) {
ans = dp[j + 1].second;
for (int k = ans.size() - 1; k >= 0; k--) ans += ans[k];
} else {
ans = dp[j + 1].second;
for (int k = ans.size() - 2; k >= 0; k--) ans += ans[k];
}
}
}
}
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 1000;
char s[maxn];
long long get(int f, long long up) {
int ls = strlen(s);
long long x = 0, y = 0;
long long maxx = 0, maxy = 0, minx = 0, miny = 0;
for (int i = 0; i < ls; i++) {
if (s[i] == 'W')
y++;
else if (s[i] == 'S')
y--;
else if (s[i] == 'A')
x--;
else
x++;
if (f == 1) {
if (up == x + 1 && s[i + 1] == 'D') {
x--;
f = 0;
}
} else if (f == 2) {
if (up == x - 1 && s[i + 1] == 'A') {
x++;
f = 0;
}
} else if (f == 3) {
if (up == y + 1 && s[i + 1] == 'W') {
f = 0;
y--;
}
} else if (f == 4) {
if (up == y - 1 && s[i + 1] == 'S') {
y++;
f = 0;
}
}
maxx = max(maxx, x);
maxy = max(maxy, y);
minx = min(minx, x);
miny = min(miny, y);
}
return 1ll * (maxx + 1 - minx) * (maxy + 1 - miny);
}
int main() {
int kase;
scanf("%d", &kase);
while (kase--) {
scanf("%s", s);
int x = 0, y = 0;
int maxx = 0, maxy = 0, minx = 0, miny = 0;
int ls = strlen(s);
for (int i = 0; i < ls; i++) {
if (s[i] == 'W')
y++;
else if (s[i] == 'S')
y--;
else if (s[i] == 'A')
x--;
else
x++;
maxx = max(maxx, x);
maxy = max(maxy, y);
minx = min(minx, x);
miny = min(miny, y);
}
long long ans = 0;
ans = 1ll * (maxx - minx + 1) * (maxy - miny + 1);
ans = min(ans, get(1, maxx));
ans = min(ans, get(2, minx));
ans = min(ans, get(3, maxy));
ans = min(ans, get(4, miny));
cout << ans << endl;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
char str[300005];
int trans[(300005 << 1)][26], tot = 1, link[(300005 << 1)],
mxlen[(300005 << 1)];
int n, cnt[(300005 << 1)][3], q[(300005 << 1)], t[(300005 << 1)], ans[300005];
int extend(int c, int id, int lst) {
if (trans[lst][c]) {
int p = lst, q = trans[p][c];
if (mxlen[p] + 1 == mxlen[q])
return ++cnt[q][id], q;
else {
int nq = ++tot;
mxlen[nq] = mxlen[p] + 1;
for (int i = 0; i < 26; ++i) trans[nq][i] = trans[q][i];
link[nq] = link[q], link[q] = nq;
for (; p && trans[p][c] == q; p = link[p]) trans[p][c] = nq;
return ++cnt[nq][id], nq;
}
}
int p = lst, np = ++tot;
mxlen[np] = mxlen[p] + 1;
for (; p && !trans[p][c]; p = link[p]) trans[p][c] = np;
if (!p)
link[np] = 1;
else {
int q = trans[p][c];
if (mxlen[p] + 1 == mxlen[q])
link[np] = q;
else {
int nq = ++tot;
mxlen[nq] = mxlen[p] + 1;
for (int i = 0; i < 26; ++i) trans[nq][i] = trans[q][i];
link[nq] = link[q], link[q] = link[np] = nq;
for (; p && trans[p][c] == q; p = link[p]) trans[p][c] = nq;
}
}
return ++cnt[np][id], np;
}
bool ckmax(int& x, int y) { return x < y ? x = y, 1 : 0; }
bool ckmin(int& x, int y) { return x > y ? x = y, 1 : 0; }
void fmod(int& x) {
x += x >> 31 & 1000000007, x -= 1000000007, x += x >> 31 & 1000000007;
}
signed main() {
scanf("%s", str), n = strlen(str);
for (int i = 0, lst = 1, len = strlen(str); i < len; ++i)
lst = extend(str[i] - 'a', 0, lst);
scanf("%s", str), ckmin(n, strlen(str));
for (int i = 0, lst = 1, len = strlen(str); i < len; ++i)
lst = extend(str[i] - 'a', 1, lst);
scanf("%s", str), ckmin(n, strlen(str));
for (int i = 0, lst = 1, len = strlen(str); i < len; ++i)
lst = extend(str[i] - 'a', 2, lst);
for (int i = 1; i <= tot; ++i) ++t[mxlen[i]];
for (int i = 1; i <= tot; ++i) t[i] += t[i - 1];
for (int i = 1; i <= tot; ++i) q[t[mxlen[i]]--] = i;
for (int i = tot; i >= 1; --i)
for (int j = 0; j < 3; ++j) fmod(cnt[link[q[i]]][j] += cnt[q[i]][j]);
for (int i = 2; i <= tot; ++i) {
int tmp = 1ll * cnt[i][0] * cnt[i][1] % 1000000007 * cnt[i][2] % 1000000007;
fmod(ans[mxlen[link[i]] + 1] += tmp), fmod(ans[mxlen[i] + 1] -= tmp);
}
for (int i = 1; i <= n; ++i) fmod(ans[i] += ans[i - 1]);
for (int i = 1; i <= n; ++i) printf("%d%c", ans[i], " \n"[i == n]);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long MOD = (long long)1e9 + 7;
long long add(long long x, long long y) {
x += y;
if (x >= MOD) return x - MOD;
return x;
}
long long sub(long long x, long long y) {
x -= y;
if (x < 0) return x + MOD;
return x;
}
long long mult(long long x, long long y) { return (x * y) % MOD; }
long long bin_pow(long long x, long long p) {
if (p == 0) return 1;
if (p & 1) return mult(x, bin_pow(x, p - 1));
return bin_pow(mult(x, x), p / 2);
}
long long rev(long long x) { return bin_pow(x, MOD - 2); }
const int N = 7;
const int M = (1 << N) + 1;
int ppc[M];
int idInPpc[M];
vector<int> maskForPpc[N + 1];
long long trans[N + 1][M][M];
int n;
unordered_map<long long, long long> dp[N + 1];
long long A[N][N];
void precalc() {
for (int mask = 1; mask < (1 << n); mask++)
ppc[mask] = ppc[mask >> 1] + (mask & 1);
for (int mask = 0; mask < (1 << n); mask++) {
int k = ppc[mask];
idInPpc[mask] = (int)maskForPpc[k].size();
maskForPpc[k].push_back(mask);
}
for (int k = 0; k <= n; k++)
for (int i = 0; i < (int)maskForPpc[k].size(); i++) {
int inM = maskForPpc[k][i];
for (int mask = 0; mask < (1 << n); mask++) {
long long res = 0;
if ((mask & inM) == mask) continue;
for (int v = 0; v < n; v++) {
if (((mask >> v) & 1) == 0) continue;
if ((inM >> v) & 1) continue;
int nmask = inM | (1 << v);
res |= 1LL << idInPpc[nmask];
}
trans[k][i][mask] = res;
}
}
}
void read() {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
scanf("%lld", &A[i][j]);
A[i][j] = mult(A[i][j], rev(100));
}
}
int main() {
scanf("%d", &n);
precalc();
read();
dp[0][1] = 1;
for (int k = 0; k < n; k++)
for (int mask = 0; mask < (1 << n); mask++) {
long long W = 1;
for (int i = 0; i < n; i++) {
if ((mask >> i) & 1)
W = mult(W, A[k][i]);
else
W = mult(W, sub(1, A[k][i]));
}
for (pair<long long, long long> s : dp[k]) {
long long zmask = s.first, val = s.second;
long long nmask = 0;
for (int i = 0; i < (int)maskForPpc[k].size(); i++) {
if ((zmask >> i) & 1) nmask |= trans[k][i][mask];
}
if (nmask == 0) continue;
val = mult(val, W);
dp[k + 1][nmask] = add(dp[k + 1][nmask], val);
}
}
printf("%lld\n", dp[n][1]);
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 20;
int n, t;
pair<int, int> mx[N << 2];
int sum[N << 2], add[N << 2];
void push_up(int rt) {
mx[rt] = max(mx[rt << 1], mx[rt << 1 | 1]);
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
void push_down(int rt, int len) {
if (add[rt]) {
add[rt << 1] = add[rt];
add[rt << 1 | 1] = add[rt];
sum[rt << 1] = 0;
sum[rt << 1 | 1] = 0;
add[rt] = 0;
}
}
void build(int l, int r, int rt) {
add[rt] = 0;
if (l == r) {
mx[rt] = make_pair(0, 0);
sum[rt] = 0;
return;
}
int m = l + r >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
push_up(rt);
}
void update(int p, pair<int, int> val, int l, int r, int rt) {
if (l == r) {
mx[rt] = val;
return;
}
push_down(rt, r - l + 1);
int m = l + r >> 1;
if (p <= m)
update(p, val, l, m, rt << 1);
else
update(p, val, m + 1, r, rt << 1 | 1);
push_up(rt);
}
void update2(int p, int val, int l, int r, int rt) {
if (l == r) {
if (sum[rt] == 0)
sum[rt] = val;
else
sum[rt] = max(sum[rt], val);
return;
}
push_down(rt, r - l + 1);
int m = l + r >> 1;
if (p <= m)
update2(p, val, l, m, rt << 1);
else
update2(p, val, m + 1, r, rt << 1 | 1);
push_up(rt);
}
void update(int L, int R, int val, int l, int r, int rt) {
if (L > R) return;
if (L <= l && r <= R) {
add[rt] = 1;
sum[rt] = 0;
return;
}
push_down(rt, r - l + 1);
int m = l + r >> 1;
if (L <= m) update(L, R, val, l, m, rt << 1);
if (m < R) update(L, R, val, m + 1, r, rt << 1 | 1);
push_up(rt);
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
return sum[rt];
}
push_down(rt, r - l + 1);
int m = l + r >> 1;
int ret = 0;
if (L <= m) ret += query(L, R, l, m, rt << 1);
if (m < R) ret += query(L, R, m + 1, r, rt << 1 | 1);
return ret;
}
pair<int, int> query2(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
return mx[rt];
}
push_down(rt, r - l + 1);
int m = l + r >> 1;
pair<int, int> ret = make_pair(0, 0);
if (L <= m) ret = max(ret, query2(L, R, l, m, rt << 1));
if (m < R) ret = max(ret, query2(L, R, m + 1, r, rt << 1 | 1));
return ret;
}
int p[N], l[N];
struct Q {
int x, y, id;
} q[N];
pair<int, int> node[N];
int out[N];
bool cmp(const Q &a, const Q &b) {
if (a.x == b.x) return a.y > b.y;
return a.x > b.x;
}
void solve() {
build(1, n, 1);
node[n] = make_pair(n, 0);
update(n, node[n], 1, n, 1);
for (int i = n - 1; i >= 1; i--) {
node[i] = make_pair(
lower_bound(p + 1, p + 1 + n, p[i] + l[i]) - p,
-(*lower_bound(p + 1, p + 1 + n, p[i] + l[i]) - (p[i] + l[i])));
if (node[i].first > n) {
node[i] = make_pair(n, 0);
}
int idx = upper_bound(p + 1, p + 1 + n, p[i] + l[i]) - p - 1;
node[i] = max(node[i], query2(1, idx, 1, n, 1));
update(i, node[i], 1, n, 1);
}
build(1, n, 1);
int cur = n;
sort(q, q + t, cmp);
for (int i = 0; i < t; i++) {
int x = q[i].x, y = q[i].y, idx = q[i].id;
int nxt;
while (cur >= x) {
nxt = node[cur].first;
update(1, nxt - 1, 0, 1, n, 1);
update2(nxt, node[cur].second, 1, n, 1);
cur--;
}
int ans = -query(1, y, 1, n, 1);
out[idx] = ans;
}
for (int i = 0; i < t; i++) {
cout << out[i] << endl;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i] >> l[i];
p[n + 1] = 0x3f3f3f3f;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> q[i].x >> q[i].y;
q[i].id = i;
}
solve();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t, n, cnt;
cin >> t;
while (t--) {
cnt = 0;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long min = a[n - 1];
for (long long j = n - 2; j >= 0; j--) {
if (a[j] > min)
cnt++;
else {
min = a[j];
}
}
cout << cnt << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int now = 0;
int i = 0;
for (; i < n && now < k / 2; ++i) {
if (s[i] == '(') ++now;
cout << s[i];
}
for (; i < k; ++i) {
cout << ')';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
int sg[N], v[N];
int sum[N];
void init() {
memset(v, 0x3f, sizeof(v));
memset(sg, 0, sizeof(sg));
memset(sum, 0, sizeof(sum));
sg[3] = 1;
v[3] = 2;
sum[3] = 1;
for (int i = 4; i < N; ++i) {
set<int> s;
for (int n = 2; n * n < i + i; ++n) {
if (i * 2 % n) continue;
int z = i * 2 / n - n;
if (z < 0) continue;
if ((z & 1) == 0) continue;
int a = (z + 1) / 2;
int b = a + n - 1;
int st = sum[a - 1] ^ sum[b];
s.insert(st);
if (st == 0) v[i] = min(v[i], n);
}
set<int>::iterator it = s.begin();
int tt = 0;
for (; it != s.end(); ++it, ++tt)
if (*it != tt) break;
sg[i] = tt;
sum[i] = sum[i - 1] ^ sg[i];
}
}
int main() {
init();
int n;
while (scanf("%d", &n) != EOF) {
if (sg[n] == 0)
puts("-1");
else
printf("%d\n", v[n]);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
double const PI = 4 * atan(1.0);
using namespace std;
void OPEN() {
freopen("A.in", "r", stdin);
freopen("A.out", "w", stdout);
}
int a;
int f[6] = {0, 2, 3, 1, 2, 1};
int main() {
scanf("%d", &a);
printf("%d", f[a]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void _print(bool t) { cerr << t; }
void _print(long long t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(double t) { cerr << t; }
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]\n";
}
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ", ";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]\n";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]\n";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]\n";
}
template <class T>
void _print(T v[], long long n) {
cerr << "[ ";
for (long long i = 0; i < n; i++) {
_print(v[i]);
cerr << " ";
}
cerr << "]\n";
}
void run() {
long long n, m;
cin >> n >> m;
string s;
cin >> s;
string p1, p2, p3, p4, p5, p6;
long long cur = 0;
for (long long i = 0; i < n; i++) {
p1 += (char)(cur + 'a');
cur = (cur + 1) % 3;
}
cur = 1;
for (long long i = 0; i < n; i++) {
p2 += (char)(cur + 'a');
cur = (cur + 1) % 3;
}
cur = 2;
for (long long i = 0; i < n; i++) {
p3 += (char)(cur + 'a');
cur = (cur + 1) % 3;
}
string cmp = "cba";
cur = 0;
for (long long i = 0; i < n; i++) {
p4 += cmp[cur];
cur = (cur + 1) % 3;
}
cmp = "bac";
cur = 0;
for (long long i = 0; i < n; i++) {
p5 += cmp[cur];
cur = (cur + 1) % 3;
}
cmp = "acb";
cur = 0;
for (long long i = 0; i < n; i++) {
p6 += cmp[cur];
cur = (cur + 1) % 3;
}
long long pref1[n], pref2[n], pref3[n], pref4[n], pref5[n], pref6[n];
pref1[0] = (p1[0] == s[0] ? 0 : 1);
for (long long i = 1; i < n; i++) {
pref1[i] = pref1[i - 1];
if (s[i] != p1[i]) pref1[i]++;
}
pref2[0] = (p2[0] == s[0] ? 0 : 1);
for (long long i = 1; i < n; i++) {
pref2[i] = pref2[i - 1];
if (s[i] != p2[i]) pref2[i]++;
}
pref3[0] = (p3[0] == s[0] ? 0 : 1);
for (long long i = 1; i < n; i++) {
pref3[i] = pref3[i - 1];
if (s[i] != p3[i]) pref3[i]++;
}
pref4[0] = (p4[0] == s[0] ? 0 : 1);
for (long long i = 1; i < n; i++) {
pref4[i] = pref4[i - 1];
if (s[i] != p4[i]) pref4[i]++;
}
pref5[0] = (p5[0] == s[0] ? 0 : 1);
for (long long i = 1; i < n; i++) {
pref5[i] = pref5[i - 1];
if (s[i] != p5[i]) pref5[i]++;
}
pref6[0] = (p6[0] == s[0] ? 0 : 1);
for (long long i = 1; i < n; i++) {
pref6[i] = pref6[i - 1];
if (s[i] != p6[i]) pref6[i]++;
}
while (m--) {
long long l, r;
cin >> l >> r;
l--, r--;
long long ans1 = pref1[r] - (l == 0 ? 0 : pref1[l - 1]);
long long ans2 = pref2[r] - (l == 0 ? 0 : pref2[l - 1]);
long long ans3 = pref3[r] - (l == 0 ? 0 : pref3[l - 1]);
long long ans4 = pref4[r] - (l == 0 ? 0 : pref4[l - 1]);
long long ans5 = pref5[r] - (l == 0 ? 0 : pref5[l - 1]);
long long ans6 = pref6[r] - (l == 0 ? 0 : pref6[l - 1]);
vector<long long> v = {ans1, ans2, ans3, ans4, ans5, ans6};
cout << *min_element(v.begin(), v.end()) << '\n';
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie();
long long t;
t = 1;
while (t--) {
run();
}
}
| 8 |
#include <bits/stdc++.h>
long long c(int n) {
if (n < 3) {
return 0;
}
return (long long)n * (n - 1) * (n - 2) / 6;
}
int main() {
int n, d;
std::cin >> n >> d;
int a[n];
for (int i = 0; i < n; i++) {
std::cin >> a[i];
}
int j = 0;
long long kq = 0;
int q = 0;
for (int i = 0; i < n - 2; i++) {
while (j < n - 1 & a[j + 1] - a[i] <= d) {
j++;
}
kq += c(j - i + 1);
if (q) {
kq -= c(q - i + 1);
}
q = j;
}
std::cout << kq;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INFTY = 1 << 29;
void build(vector<string>& ans, int bit, int i, vector<vector<int> >& flg,
vector<vector<int> >& path) {
int h = ans.size(), w = ans[0].size();
ans[i / w][i % w] = 'X';
if (flg[bit][i] == 1) {
build(ans, path[bit][i], i, flg, path);
build(ans, bit ^ path[bit][i], i, flg, path);
}
if (flg[bit][i] == 2) {
build(ans, bit, path[bit][i], flg, path);
}
}
int main() {
for (int h, w, c; cin >> h >> w >> c && h | w | c;) {
vector<vector<int> > grid(h, vector<int>(w));
vector<int> ps(c);
for (int i = int(0); i < int(h); i++)
for (int j = int(0); j < int(w); j++) cin >> grid[i][j];
for (int i = int(0); i < int(c); i++) {
int a, b;
cin >> a >> b;
ps[i] = (a - 1) * w + (b - 1);
}
int n = h * w;
vector<vector<int> > dist(n, vector<int>(n, INFTY));
vector<vector<int> > prev(n, vector<int>(n, -1));
for (int i = int(0); i < int(h); i++)
for (int j = int(0); j < int(w); j++) {
dist[i * w + j][i * w + j] = grid[i][j];
int di[] = {-1, 1, 0, 0}, dj[] = {0, 0, -1, 1};
for (int k = int(0); k < int(4); k++) {
int ii = i + di[k], jj = j + dj[k];
if (0 <= ii && ii < h && 0 <= jj && jj < w) {
dist[i * w + j][ii * w + jj] = grid[i][j] + grid[ii][jj];
prev[i * w + j][ii * w + jj] = i * w + j;
}
}
}
for (int k = int(0); k < int(n); k++)
for (int i = int(0); i < int(n); i++)
for (int j = int(0); j < int(n); j++) {
int temp = dist[i][k] + dist[k][j] - dist[k][k];
if (dist[i][j] > temp) {
dist[i][j] = temp;
prev[i][j] = prev[k][j];
}
}
vector<vector<int> > dp(1 << c, vector<int>(n, INFTY));
vector<vector<int> > flg(1 << c, vector<int>(n, 0));
vector<vector<int> > path(1 << c, vector<int>(n, 0));
for (int i = int(0); i < int(c); i++)
for (int j = int(0); j < int(n); j++) {
dp[1 << i][j] = dist[ps[i]][j];
if (j != ps[i]) {
flg[1 << i][j] = 2;
path[1 << i][j] = prev[ps[i]][j];
}
}
for (int bit = int(0); bit < int(1 << c); bit++) {
for (int i = int(0); i < int(n); i++)
for (int j = int(0); j < int(n); j++) {
for (int mask = bit; mask; mask = (mask - 1) & bit) {
int temp =
dp[mask][j] + dp[bit ^ mask][j] + dist[j][i] - dist[j][j] * 2;
if (dp[bit][i] > temp) {
dp[bit][i] = temp;
if (j == i) {
flg[bit][i] = 1;
path[bit][i] = mask;
} else {
flg[bit][i] = 2;
path[bit][i] = prev[j][i];
}
}
}
}
}
int res = INFTY;
for (int i = int(0); i < int(n); i++) res = min(res, dp[(1 << c) - 1][i]);
vector<string> ans(h, string(w, '.'));
for (int i = int(0); i < int(n); i++)
if (dp[(1 << c) - 1][i] == res) {
build(ans, (1 << c) - 1, i, flg, path);
break;
}
cout << res << endl;
for (int i = int(0); i < int(h); i++) cout << ans[i] << endl;
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int n, m, s, k, x;
cin >> n >> m >> k >> s;
vector<int> g[n + 1];
int ans[n + 1][k + 1];
int dist[n + 1];
vector<int> color[k + 1];
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
color[x].push_back(i);
}
int a, b;
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
for (int c = 1; c <= k; ++c) {
for (int i = 1; i <= n; ++i) dist[i] = INF;
int topQ = 0, q[n + 1];
for (int x : color[c]) {
dist[x] = 0;
q[topQ++] = x;
}
for (int i = 0; i < topQ; ++i) {
for (int v : g[q[i]]) {
if (dist[v] > dist[q[i]] + 1) {
dist[v] = dist[q[i]] + 1;
q[topQ++] = v;
}
}
}
for (int i = 1; i <= n; ++i) ans[i][c] = dist[i];
}
for (int i = 1; i <= n; ++i) {
nth_element(ans[i] + 1, ans[i] + s + 1, ans[i] + k + 1);
int res = 0;
for (int j = 1; j <= s; ++j) {
res += ans[i][j];
}
printf("%d\n", res);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, n, sumg = 0, suma = 0;
cin >> n;
int a[n][2];
for (i = 0; i < n; i++) cin >> a[i][0] >> a[i][1];
for (i = 0; i < n; i++) {
if (a[i][0] < a[i][1]) {
if ((suma - sumg + a[i][0]) <= 500) {
suma += a[i][0];
cout << "A";
} else {
sumg += a[i][1];
cout << "G";
}
} else {
if ((sumg - suma + a[i][1]) <= 500) {
sumg += a[i][1];
cout << "G";
} else {
suma += a[i][0];
cout << "A";
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200500;
int inp[MAX];
int out[MAX];
bool flag[MAX];
map<long long, int> ID;
map<long long, int> hasInp;
namespace hopcroftKarp {
int ptr[200011], next[400011], zu[400011];
int n, m, match[200011], D[200011], q[200011];
void init(int _n) {
n = _n;
m = 0;
memset(ptr, ~0, sizeof(int) * (n + 1));
}
void add_edge(int u, int v) {
next[m] = ptr[u];
ptr[u] = m;
zu[m] = v;
++m;
}
bool bfs() {
int u, v;
register int i;
int qh = 0, qt = 0;
for (i = 1; i <= n; i++) {
if (!match[i]) {
D[i] = 0;
q[qt++] = i;
} else
D[i] = (1 << 28);
}
D[0] = (1 << 28);
while (qh < qt) {
u = q[qh++];
if (u != 0) {
for (i = ptr[u]; ~i; i = next[i]) {
v = zu[i];
if (D[match[v]] == (1 << 28)) {
D[match[v]] = D[u] + 1;
q[qt++] = match[v];
}
}
}
}
return D[0] != (1 << 28);
}
bool dfs(int u) {
int v;
register int i;
if (u) {
for (i = ptr[u]; ~i; i = next[i]) {
v = zu[i];
if (D[match[v]] == D[u] + 1) {
if (dfs(match[v])) {
match[v] = u;
match[u] = v;
return true;
}
}
}
D[u] = (1 << 28);
return false;
}
return true;
}
int run() {
int matching = 0;
register int i;
while (bfs())
for (i = 1; i <= n; i++)
if (!match[i] && dfs(i)) matching++;
return matching;
}
void call(int N, long long a, long long b) {
int x, y;
long long vx, vy;
for (int i = 1; i <= N; i++) {
if (flag[i]) continue;
x = i;
y = match[x];
vx = inp[i];
vy = inp[y];
if (vx + vy == a) {
out[x] = out[y] = 0;
} else
out[x] = out[y] = 1;
flag[x] = flag[y] = true;
}
for (int i = 1; i <= N; i++) {
if (i != 1) cout << " ";
cout << out[i];
}
cout << "\n";
return;
}
}; // namespace hopcroftKarp
int main() {
long long a, b;
int n;
std::ios_base::sync_with_stdio(false);
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) {
cin >> inp[i];
hasInp[inp[i]] = i;
}
long long x, rx, tx;
int p = 0;
hopcroftKarp::init(n + n);
for (int i = 1; i <= n; i++) {
x = inp[i];
rx = a - x;
tx = b - x;
if (hasInp.find(rx) != hasInp.end()) {
hopcroftKarp::add_edge(i, hasInp[rx]);
}
if (hasInp.find(tx) != hasInp.end()) {
hopcroftKarp::add_edge(i, hasInp[tx]);
}
}
int cnt = hopcroftKarp::run();
if (2 * cnt >= (n)) {
cout << "YES\n";
hopcroftKarp::call(n, a, b);
} else
cout << "NO\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
if (s1.length() != s2.length()) {
cout << "NO" << endl;
return 0;
}
int i, pi, flag = 0;
for (i = 0; i < s1.length(); i++) {
if (s1[i] != s2[i]) {
pi = i;
break;
}
}
i++;
for (; i < s1.length(); i++) {
if (s1[i] != s2[i]) {
if (s1[pi] == s2[i] and s1[i] == s2[pi]) {
flag = 1;
}
break;
}
}
i++;
for (; i < s1.length(); i++) {
if (s1[i] != s2[i]) flag = 0;
}
if (flag == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
#define int long long
#define gmax(x,y) x=max(x,y)
#define gmin(x,y) x=min(x,y)
#define F first
#define S second
#define P pair
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define rep(i,a,b) for(int i=a;i<b;i++)
#define V vector
#define RE return
#define ALL(a) a.begin(),a.end()
#define MP make_pair
#define PB emplace_back
#define PF emplace_front
#define FILL(a,b) memset(a,b,sizeof(a))
#define lwb lower_bound
#define upb upper_bound
#define lc (x<<1)
#define rc ((x<<1)|1)
using namespace std;
int it[9][6];
int t[505][505],mod=998244353;
int f[54][54];
struct matrix{
int s[505][505],n,m;
void mul(matrix a){
FOR(i,1,n){
FOR(j,1,m){
FOR(k,1,m){
t[i][j]=(s[i][k]*a.s[k][j]+t[i][j])%mod;
}
}
}
FOR(i,1,n)FOR(j,1,m)s[i][j]=t[i][j],t[i][j]=0;
}
}tx,T;
int m,n,l[9];
char c[9][6];
P<int,int> p[54];
bool check(P<int,int> x,P<int,int> y){
for(int i=x.S,j=y.S;i<=l[x.F]&&j<=l[y.F];i++,j++){
if(c[x.F][i]!=c[y.F][j])RE 0;
}
RE 1;
}
int k;
int nxt(int i){
P<int,int> tp=p[i];
tp.S++;
if(tp.S==l[tp.F]){
RE k;
}else RE it[tp.F][tp.S];
}
signed main(){
ios::sync_with_stdio(0);
cin.tie(0);
cin>>n>>m;
int cnt=0;
FOR(i,1,n){
string s;
cin>>s;
l[i]=s.size();
FOR(j,1,l[i])c[i][j]=s[j-1];
rep(j,1,l[i])it[i][j]=++cnt,p[cnt]=MP(i,j);
}
it[0][0]=++cnt;p[cnt]=MP(0,0);
k=cnt;
cnt=0;
FOR(i,1,k){
FOR(j,i,k){
if(i==k||j==k||check(p[i],p[j]))f[i][j]=f[j][i]=++cnt;
}
}
rep(i,1,k){
rep(j,i,k){
if(f[i][j])tx.s[f[i][j]][f[nxt(i)][nxt(j)]]++;
}
}
tx.n=cnt;
tx.m=cnt;
rep(i,1,k){
FOR(j,1,n){
if(f[nxt(i)][it[j][1]?it[j][1]:k]&&c[j][1]==c[p[i].F][p[i].S+1]){
tx.s[f[i][k]][f[nxt(i)][it[j][1]?it[j][1]:k]]++;
}
}
}
FOR(i,1,n){
FOR(j,1,n){
if(c[i][1]==c[j][1]&&f[it[i][1]?it[i][1]:k][it[j][1]?it[j][1]:k]){
tx.s[f[k][k]][f[it[i][1]?it[i][1]:k][it[j][1]?it[j][1]:k]]++;
}
}
}
T.n=1;
T.m=cnt;
T.s[1][f[k][k]]=1;
while(m){
if(m&1)T.mul(tx);
tx.mul(tx);
m/=2;
}
cout<<T.s[1][f[k][k]];
RE 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
map<char, long long int> mp;
long long int n;
bool check(long long int k) {
long long int cnt = 0;
for (char x = 'a'; x <= 'z'; x++) cnt += ceil((double)mp[x] / (double)k);
if (cnt <= n) return 1;
return 0;
}
long long int solve(long long int low, long long int high) {
long long int ans = 1;
while (low <= high) {
long long int mid = (low + high) / 2;
if (check(mid)) {
high = mid - 1;
ans = mid;
} else
low = mid + 1;
}
return ans;
}
int main() {
string s;
cin >> s;
long long int i, j;
cin >> n;
for (i = 0; i < s.length(); i++) mp[s[i]]++;
if (mp.size() > n) {
cout << "-1\n";
return 0;
}
long long int ans = solve(1, s.length());
cout << ans << "\n";
vector<char> v;
for (char x = 'a'; x <= 'z'; x++) {
long long int cnt = ceil((double)mp[x] / (double)ans);
while (cnt != 0) {
v.push_back(x);
cnt--;
}
}
while (v.size() != n) v.push_back('a');
for (i = 0; i < v.size(); i++) cout << v[i];
cout << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
bool f = false;
cin >> n;
vector<string> s;
string st;
for (int i = 0; i < n; i++) {
cin >> st;
s.push_back(st);
}
for (int i = 0; i < n; i++) {
if (s.at(i)[0] == 'O' && s.at(i)[1] == 'O' ||
s.at(i)[3] == 'O' && s.at(i)[4] == 'O') {
if (s.at(i)[0] == 'O' && s.at(i)[1] == 'O') {
s.at(i)[0] = '+';
s.at(i)[1] = '+';
f = true;
break;
} else if (s.at(i)[3] == 'O' && s.at(i)[4] == 'O') {
s.at(i)[3] = '+';
s.at(i)[4] = '+';
f = true;
break;
}
}
}
if (f == false) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (string st : s) {
cout << st << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ans, a[310000];
int l = 1, r = 1;
int cnt, ls = 1, rs;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
while (r <= n) {
while (r <= n && cnt <= k) {
if (!a[r]) {
if (cnt == k)
break;
else
cnt++;
}
r++;
}
if (r - l > ans) ans = r - l, ls = l, rs = r - 1;
while (l <= n && a[l]) l++;
cnt--;
l++;
}
printf("%d\n", ans);
for (int i = 1; i < n; i++) {
if (ls <= i && i <= rs)
printf("1 ");
else
printf("%d ", a[i]);
}
if (n <= rs)
printf("1\n");
else
printf("%d\n", a[n]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d;
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int main() {
cin >> b >> a;
for (; d = gcd(a, b), d > 1; a /= d, ++c)
;
if (a == 1)
cout << "2-type\n" << c << endl;
else if ((b * b - 1) / (b & 1 ? 2 : 1) % a == 0) {
if (!c && (b - 1) % a == 0)
cout << "3-type" << endl;
else if (!c && (b + 1) % a == 0)
cout << "11-type" << endl;
else
cout << "6-type" << endl;
} else
cout << "7-type" << endl;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
class Tree {
public:
vector<vector<int> > next;
vector<vector<int> > prev2;
vector<int> depth;
int root;
Tree(const vector<vector<int> > &next, const vector<vector<int> > &prev2,
const vector<int> depth, const int root)
: next(next), prev2(prev2), depth(depth), root(root) {}
int lca(int a, int b) {
if (depth[a] > depth[b]) swap(a, b);
int ddiff = depth[b] - depth[a];
int dmax = prev2[0].size();
for (int i = 0; i < (int)(dmax); i++) {
if (ddiff & (1 << i)) b = prev2[b][i];
}
if (a == b) return a;
for (int i = dmax - 1; i >= 0; i--) {
if (prev2[a][i] != prev2[b][i]) {
a = prev2[a][i];
b = prev2[b][i];
}
}
return prev2[a][0];
}
};
Tree fromGraph(const vector<vector<int> > &g, int root = 0) {
const int n = g.size();
vector<vector<int> > next(n);
vector<vector<int> > prev2(n);
vector<int> depth(n, -1);
queue<pair<int, int> > q;
q.push(make_pair(root, -1));
depth[root] = 0;
prev2[root].push_back(root);
while (q.size()) {
const pair<int, int> d = q.front();
q.pop();
const int now = d.first;
const int prev = d.second;
for (int i = 0; i < (int)(g[now].size()); i++) {
int next = g[now][i];
if (next != prev) {
q.push(make_pair(next, now));
depth[next] = depth[now] + 1;
prev2[next].push_back(now);
}
}
}
bool flag = true;
while (flag) {
const int last = prev2[root].size() - 1;
flag = false;
for (int i = 0; i < (int)(n); i++) {
int data = prev2[prev2[i][last]][last];
prev2[i].push_back(data);
flag |= data != 0;
}
}
return Tree(next, prev2, depth, root);
}
int main() {
const int n = getInt();
vector<vector<int> > g(n);
vector<pair<int, int> > e;
for (int i = 0; i < (int)(n - 1); i++) {
const int a = getInt() - 1;
const int b = getInt() - 1;
g[a].push_back(b);
g[b].push_back(a);
e.push_back(make_pair(min(a, b), max(a, b)));
}
Tree t = fromGraph(g, 0);
vector<int> memo(n);
const int m = getInt();
for (int i = 0; i < (int)(m); i++) {
const int a = getInt() - 1;
const int b = getInt() - 1;
const int c = t.lca(a, b);
memo[a]++;
memo[b]++;
memo[c]--;
memo[c]--;
}
vector<pair<int, int> > d(n);
for (int i = 0; i < (int)(n); i++) d[i] = make_pair(t.depth[i], i);
sort(d.rbegin(), d.rend());
map<pair<int, int>, int> ans;
for (int i = 0; i < (int)(n); i++) {
int j = d[i].second;
int p = t.prev2[j][0];
ans[make_pair(min(j, p), max(j, p))] += memo[j];
memo[p] += memo[j];
}
for (int i = 0; i < (int)(n - 1); i++) {
printf("%d%c", ans[e[i]], i == n - 2 ? '\n' : ' ');
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300000 + 77, L = 19, Mod = 998244353;
int n, k, b[N], d[N], Par[N][L], dp[N][2];
vector<int> a[N], c[N];
inline int Pow(int x, long long y) {
int C = 1;
while (y) {
if (y & 1) C = C * 1ll * x % Mod;
x = x * 1ll * x % Mod;
y >>= 1;
}
return C;
}
inline int GetPar(int v, int k) {
for (int i = 0; i < L; ++i)
if ((1 << i) & k) v = Par[v][i];
return v;
}
inline int GetLca(int v, int u) {
if (d[v] < d[u]) swap(v, u);
v = GetPar(v, d[v] - d[u]);
if (v == u) return v;
for (int i = L - 1; i >= 0; --i)
if (Par[v][i] != Par[u][i]) v = Par[v][i], u = Par[u][i];
return Par[v][0];
}
void dfsPre(int v = 1, int prev = -1) {
for (int i = 1; i < L; ++i) Par[v][i] = Par[Par[v][i - 1]][i - 1];
for (int u : a[v]) {
if (u == prev) continue;
Par[u][0] = v;
d[u] = d[v] + 1;
dfsPre(u, v);
}
}
void dfs(int v = 1, int prev = -1) {
dp[v][1] = 1;
for (int u : a[v]) {
if (u == prev) continue;
dfs(u, v);
dp[v][1] = 1ll * dp[v][1] * (dp[u][0] + dp[u][1]) % Mod;
}
for (int u : a[v]) {
if (u == prev) continue;
int C = dp[v][1] * 1ll * Pow((dp[u][0] + dp[u][1]) % Mod, Mod - 2) % Mod *
1ll * dp[u][0] % Mod;
dp[v][0] = (dp[v][0] + C) % Mod;
}
if (b[v] > 0) dp[v][0] = dp[v][1], dp[v][1] = 0;
}
int main() {
k = 2;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", b + i), c[b[i]].push_back(i);
for (int v, u, i = 1; i < n; ++i) {
scanf("%d %d", &v, &u);
a[v].push_back(u);
a[u].push_back(v);
}
dfsPre();
for (int i = 1; i <= k; ++i) {
int Lca = c[i][0];
for (int x : c[i]) Lca = GetLca(Lca, x);
for (int x : c[i]) {
while (x != Lca) {
int p = Par[x][0];
if (b[p] == b[x]) break;
if (b[p] == 0)
b[p] = b[x];
else
return !printf("0\n");
x = p;
}
}
}
dfs();
printf("%d\n", dp[1][0]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int N = 100000 + 10;
inline void cmax(int &a, int b) {
if (a < b) a = b;
}
int n, y, k, x;
int64_t kpow[N], kinv[N], v[N];
std::vector<int> e[N];
int64_t in[N], out[N];
int size[N], ms[N];
bool flag[N];
std::vector<int> q;
inline int64_t pow(int64_t base, int64_t exp) {
int64_t res = 1;
for (; exp; exp >>= 1) {
if (exp & 1) (res *= base) %= y;
(base *= base) %= y;
}
return res;
}
void calsize(int a, int fa = 0) {
size[a] = 1, ms[a] = 0, q.push_back(a);
for (auto b : e[a]) {
if (!flag[b] && b != fa) {
calsize(b, a);
size[a] += size[b];
ms[a] = std::max(ms[a], size[b]);
}
}
}
int centroid(int root) {
q.clear();
calsize(root);
int res = root, best = ms[root];
for (auto it : q) {
int cur = std::max(size[root] - size[it], ms[it]);
if (cur < best) best = cur, res = it;
}
return res;
}
int dep[N];
int64_t df[N], dt[N], target[N];
void caldist(int a, int fa = 0) {
for (auto b : e[a]) {
if (!flag[b] && b != fa) {
dep[b] = dep[a] + 1;
dt[b] = (dt[a] + v[b] * kpow[dep[b]]) % y;
df[b] = (df[a] * k + v[b]) % y;
caldist(b, a);
}
}
}
std::vector<int> pool[N];
void dfs(int a, const int root, int fa = 0) {
pool[root].push_back(a);
for (auto b : e[a])
if (!flag[b] && b != fa) dfs(b, root, a);
}
inline void solve() {
static std::unordered_map<int64_t, int> from, to;
from.clear(), to.clear();
for (auto a : q)
for (auto it : pool[a]) from[target[it]]++, to[dt[it]]++;
for (auto a : q) {
for (auto it : pool[a]) from[target[it]]--, to[dt[it]]--;
for (auto it : pool[a]) in[it] += from[dt[it]], out[it] += to[target[it]];
for (auto it : pool[a]) from[target[it]]++, to[dt[it]]++;
}
}
void divide(int root) {
root = centroid(root);
flag[root] = true, dt[root] = df[root] = v[root], dep[root] = 0;
caldist(root);
if (dt[root] == x) in[root]++, out[root]++;
for (auto it : q) {
if (it != root) {
if (df[it] == x) in[root]++, out[it]++;
if (dt[it] == x) out[root]++, in[it]++;
}
}
q.clear();
for (auto next : e[root]) {
if (!flag[next]) {
q.push_back(next);
pool[next].clear();
dfs(next, next);
for (auto it : pool[next])
target[it] = (((x - df[it]) * kinv[dep[it]] + v[root]) % y + y) % y;
}
}
solve();
for (auto next : e[root])
if (!flag[next]) divide(next);
}
int main() {
std::ios::sync_with_stdio(false);
std::cin >> n >> y >> k >> x;
for (int i = 1; i <= n; ++i) std::cin >> v[i];
for (int tmp = n - 1; tmp--;) {
int u, v;
std::cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
}
kpow[0] = kinv[0] = 1;
for (int i = 1; i <= n; ++i)
kinv[i] = pow(kpow[i] = kpow[i - 1] * k % y, y - 2);
divide(1);
int64_t ans = 0;
for (int i = 1; i <= n; ++i) {
ans += (int64_t)in[i] * (n - in[i]) * 2;
ans += (int64_t)out[i] * (n - out[i]) * 2;
ans += (int64_t)out[i] * (n - in[i]) + (int64_t)in[i] * (n - out[i]);
}
ans = (int64_t)n * n * n - ans / 2;
std::cout << ans << std::endl;
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int A[500];
int main() {
long long x, k;
cin >> x >> k;
int q = 0;
while (x > 0) {
A[q] = x % 10;
x /= 10;
q++;
}
int in = 0;
while (k > 0 && in < q) {
int b_from = (q - in - k - 1 > 0 ? q - in - k - 1 : 0);
int mx = *max_element(A + b_from, A + q - in);
int ind = 0;
for (int i = 0; i < q - in; i++)
if (A[i] == mx) ind = i;
if (ind == q - in - 1) {
in++;
continue;
}
for (int i = ind; i < q - in - 1; i++) {
int r = A[i + 1];
A[i + 1] = A[i];
A[i] = r;
k--;
if (k <= 0) break;
}
in++;
}
for (int i = q - 1; i >= 0; i--) cout << A[i];
return 0;
}
| 6 |
#include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
#define FASTIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define PRECISION cout << fixed << setprecision(20);
using namespace std;
void solve() {
int n; cin >> n;
vector<int> ans(n + 1, -1);
vector<array<int, 3>> arr(n), arr2(n);
for (int i = 0; i < n; i++) {
int h, w; cin >> h >> w;
arr[i] = {h, w, i + 1};
arr2[i] = {w, h, i + 1};
}
sort(arr.begin(), arr.end());
sort(arr2.begin(), arr2.end());
// array<int, 3> keep = {1e9 + 10, 1e9 + 10, -1};
// for (int i = 0; i < n;) {
// int j = i;
// while (j < n && arr[i][0] == arr[j][0]) j++;
// for (int k = i; k < j; k++) {
// if (arr[k][1] > keep[1]) {
// ans[arr[i][2]] = keep[2];
// }
// }
// for (int k = i; k < j; j++) {
// if (arr[k][1] > keep[1]) {
// }
// }
// if (arr[i][1] > keep[1]) {
// ans[arr[i][2]] = keep[2];
// }
// if (arr[i][1] < keep[1]) keep = arr[i];
// }
vector<array<int, 3>> store1, store2;
int ptr1 = 0, ptr2 = 0;
for (int i = 0; i < n; i++) {
while (ptr1 < n && arr[ptr1][0] < arr[i][0]) store1.push_back(arr[ptr1]), ptr1++;
while (ptr2 < n && arr2[ptr2][0] < arr[i][0]) store2.push_back(arr2[ptr2]), ptr2++;
sort(store1.begin(), store1.end(), [&](array<int, 3> a, array<int, 3> b) { return a[1] < b[1];});
sort(store2.begin(), store2.end(), [&](array<int, 3> a, array<int, 3> b) { return a[1] < b[1];});
while (store1.size() > 2) store1.pop_back();
while (store2.size() > 2) store2.pop_back();
for (int j = 0; j < store1.size(); j++) {
if (arr[i][1] > store1[j][1] && arr[i][2] != store1[j][2]) {
ans[arr[i][2]] = store1[j][2];
}
}
for (int j = 0; j < store2.size(); j++) {
if (arr[i][1] > store2[j][1] && arr[i][2] != store2[j][2]) {
ans[arr[i][2]] = store2[j][2];
}
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << " \n"[i == n];
}
}
int main() {
FASTIO;
PRECISION;
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
} | 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
vector<int> d[maxn];
int a[maxn];
int f[maxn];
int tag[maxn];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
f[a[i]] = i;
}
for (int i = n; i >= 1; i--) {
int pos = f[i];
for (int j = pos + i; j <= n; j += i) {
if (i < a[j]) d[f[i]].push_back(j);
}
for (int j = pos - i; j >= 1; j -= i) {
if (i < a[j]) d[f[i]].push_back(j);
}
}
memset(tag, -1, sizeof(tag));
for (int i = n; i >= 1; i--) {
int sz = d[f[i]].size();
if (sz == 0) {
tag[f[i]] = 0;
} else {
for (int v : d[f[i]]) {
if (tag[v] == 0) {
tag[f[i]] = 1;
break;
}
}
}
}
for (int i = n; i >= 1; i--) {
int pos = f[i];
if (tag[pos] != -1) continue;
bool flag = false;
for (int v : d[pos]) {
if (tag[v] == 0) {
tag[pos] = 1;
flag = true;
break;
}
}
if (flag == false) tag[pos] = 0;
}
for (int i = 1; i <= n; i++) {
if (tag[i])
printf("A");
else
printf("B");
}
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
class wunionfind {
private:
int *id, *sz, *ans;
int cnt;
map<int, int> M;
vector<vector<int>> adj;
vector<vector<int>> cost;
public:
wunionfind(int n = 400010) {
cnt = 1;
id = new int[n + 1];
sz = new int[n + 1];
ans = new int[n + 1];
adj.resize(n + 1);
cost.resize(n + 1);
for (int i = 0; i <= n; i++) {
id[i] = i, sz[i] = 1;
ans[i] = 0;
}
}
int root(int idx) {
int i = idx;
while (i != id[i]) i = id[i];
return i;
}
void dfs(int cur, int par, int x) {
ans[cur] = ans[par] ^ x;
for (int i = 0; i < (int)adj[cur].size(); i++) {
if (adj[cur][i] == par) {
continue;
}
dfs(adj[cur][i], cur, cost[cur][i]);
}
return;
}
void uni(int a, int b, int x) {
int i = root(a), j = root(b);
cost[a].emplace_back(x);
adj[a].emplace_back(b);
cost[b].emplace_back(x);
adj[b].emplace_back(a);
if (i != j) {
if (sz[i] >= sz[j]) {
id[j] = i;
sz[i] += sz[j];
sz[j] = 0;
dfs(b, a, x);
} else {
id[i] = j;
sz[j] += sz[i];
sz[i] = 0;
dfs(a, b, x);
}
}
}
int get(int l, int r) {
int a = M[l];
int b = M[r];
if (!a || !b) {
return -1;
}
if (root(a) != root(b)) {
return -1;
}
return (ans[a] ^ ans[b]);
}
void add(int l, int r, int x) {
if (!M[l]) {
M[l] = cnt;
cnt++;
}
if (!M[r]) {
M[r] = cnt;
cnt++;
}
int a = M[l];
int b = M[r];
if (root(a) == root(b)) {
return;
}
uni(a, b, x);
}
} W;
int main() {
int q;
scanf("%d", &q);
int last = 0;
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int l, r, x;
scanf("%d %d %d", &l, &r, &x);
l ^= last;
r ^= last;
x ^= last;
if (l > r) {
swap(l, r);
}
r++;
W.add(l, r, x);
} else {
int l, r;
scanf("%d %d", &l, &r);
l ^= last;
r ^= last;
if (l > r) {
swap(l, r);
}
r++;
last = W.get(l, r);
printf("%d\n", last);
if (last == -1) {
last = 1;
}
}
}
return 0;
}
| 16 |
Subsets and Splits