solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using pii = pair<int, int>;
using vi = vector<int>;
const int N = 1e5 + 100;
int n, d[N], f[N][2], ans;
vi G[N];
void dfs(int x, int fz) {
f[x][0] = 0, f[x][1] = 1;
for (int y : G[x])
if (y != fz) {
dfs(y, x);
ans = max({ans, f[x][0] + f[y][0], f[x][0] + f[y][1], f[x][1] + f[y][0]});
f[x][0] = max({f[x][0], f[y][0] + d[x] - 2, f[y][1] + d[x] - 2});
f[x][1] = max({f[x][1], f[y][0] + 1});
}
ans = max(ans, f[x][1]);
}
signed main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
G[x].push_back(y), G[y].push_back(x);
d[x]++, d[y]++;
}
dfs(1, 0);
printf("%d\n", ans);
fprintf(stderr, "time=%.4f\n", (db)clock() / CLOCKS_PER_SEC);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int arr[20] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6}, a, b, temp;
long long ans;
int main() {
cin >> a >> b;
for (int i = a; i <= b; i++) {
temp = i;
while (temp) {
ans += arr[temp % 10];
temp /= 10;
}
}
cout << ans << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return (a * (b / gcd(a, b))); }
int a2, d2;
bool win(int h1, int a1, int d1, int h2) {
int th1, th2;
while (h1 > 0 && h2 > 0) {
th1 = h1, th2 = h2;
h1 -= max(0, a2 - d1);
h2 -= max(0, a1 - d2);
if (h1 == th1 && h2 == th2) return false;
}
return h1 > 0;
}
bool win2(int h1, int a1, int d1, int h2) {
if (a1 <= d2) return false;
if (a2 <= d1) return true;
int round1 = ceil(1.0 * h1 / (a2 - d1));
int round2 = ceil(1.0 * h2 / (a1 - d2));
return round1 > round2;
}
void solution() {
int h, h1, a, a1, d, d1, h2, res = 1e9;
cin >> h1 >> a1 >> d1 >> h2 >> a2 >> d2 >> h >> a >> d;
int m = 1000;
for (int i = 0; i < int(m); i++)
for (int j = 0; j < int(m); j++)
for (int k = 0; k < int(max(0, a2 - d1) + 1); k++)
if (i * h + j * a + k * d < res && win2(h1 + i, a1 + j, d1 + k, h2))
res = i * h + j * a + k * d;
cout << res;
}
int main() {
double beg = clock();
ios::sync_with_stdio(false);
solution();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
long long n, m, gs[30];
vector<long long> q[30];
char a[N], b[N];
signed main() {
cin >> n;
scanf("%s", a + 1);
for (long long i = 1; i <= n; i++) {
q[a[i] - 'a'].push_back(i);
}
cin >> m;
while (m--) {
long long ans = 0;
scanf("%s", b + 1);
long long len = strlen(b + 1);
for (long long i = 1; i <= len; i++) gs[b[i] - 'a']++;
for (long long i = 0; i < 26; i++)
if (gs[i]) ans = max(ans, q[i][gs[i] - 1]);
for (long long i = 1; i <= len; i++) gs[b[i] - 'a']--;
printf("%lld\n", ans);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const double PI = acos(-1);
template <typename T>
inline void read(T &x) {
x = 0;
T f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do x = x * 10 + ch - '0', ch = getchar();
while (ch <= '9' && ch >= '0');
x *= f;
}
template <typename A, typename B>
inline void read(A &x, B &y) {
read(x);
read(y);
}
template <typename A, typename B, typename C>
inline void read(A &x, B &y, C &z) {
read(x);
read(y);
read(z);
}
template <typename A, typename B, typename C, typename D>
inline void read(A &x, B &y, C &z, D &w) {
read(x);
read(y);
read(z);
read(w);
}
template <typename A, typename B>
inline A fexp(A x, B p) {
A ans = 1;
for (; p; p >>= 1, x = 1LL * x * x % mod)
if (p & 1) ans = 1LL * ans * x % mod;
return ans;
}
template <typename A, typename B>
inline A fexp(A x, B p, A mo) {
A ans = 1;
for (; p; p >>= 1, x = 1LL * x * x % mo)
if (p & 1) ans = 1LL * ans * x % mo;
return ans;
}
long long has[55];
int n, K, Ans;
void dfs(long long R, long long P, long long X, int ans) {
if (P == 0 && X == 0) {
Ans = max(Ans, ans);
return;
}
int mx = n + 1, mw = 0;
for (int i = 1; i <= n; i++)
if ((1LL << i) & (P | X)) {
long long t = P & ((1LL << i) | has[i]);
int nm = 0;
for (int j = 1; j <= n; j++)
if ((1LL << j) & t) nm++;
if (nm < mx) {
mx = nm;
mw = i;
}
}
long long t = P & ((1LL << mw) | has[mw]);
for (int j = 1; j <= n; j++)
if ((1LL << j) & t) {
dfs(P | (1LL << j), P - (P & ((1LL << j) | has[j])),
X - (X & ((1LL << j) | has[j])), ans + 1);
if ((1LL << j) & P) P -= 1LL << j;
if ((1LL << j) & X) X -= 1LL << j;
}
}
void Work() {
dfs(0, (1LL << n + 1) - 2, 0, 0);
double ans = (double)K / Ans;
ans *= ans;
ans *= 1LL * Ans * (Ans - 1) / 2;
printf("%.18lf\n", ans);
}
void Init() {
read(n, K);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) {
int x;
read(x);
if (!x) has[i] |= 1LL << j;
}
}
int main() {
Init();
Work();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)2e5 + 1, mod = (int)1e9 + 7;
int n, m, a[maxn];
struct Segment {
long long cnt;
int sum;
} seg[maxn << 1 | 1];
inline int seg_idx(int L, int R) { return (L + R) | (L < R); }
inline void seg_merge(Segment &rt, Segment &lch, Segment &rch) {
rt.cnt = lch.cnt + rch.cnt;
(rt.sum = lch.sum + rch.sum) >= mod && (rt.sum -= mod);
}
void seg_build(int L, int R) {
int rt = seg_idx(L, R);
if (L == R) {
int v;
scanf("%d", &v);
seg[rt] = (Segment){(long long)v, (int)((long long)a[L] * v % mod)};
return;
}
int M = (L + R) >> 1, lch = seg_idx(L, M), rch = seg_idx(M + 1, R);
seg_build(L, M);
seg_build(M + 1, R);
seg_merge(seg[rt], seg[lch], seg[rch]);
}
void seg_upd(int L, int R, int x, int v) {
int rt = seg_idx(L, R);
if (L == R) {
seg[rt] = (Segment){(long long)v, (int)((long long)a[L] * v % mod)};
return;
}
int M = (L + R) >> 1, lch = seg_idx(L, M), rch = seg_idx(M + 1, R);
if (x <= M)
seg_upd(L, M, x, v);
else
seg_upd(M + 1, R, x, v);
seg_merge(seg[rt], seg[lch], seg[rch]);
}
Segment seg_que(int L, int R, int x) {
if (R <= x) return seg[seg_idx(L, R)];
int M = (L + R) >> 1;
if (x <= M) return seg_que(L, M, x);
Segment ret = seg_que(M + 1, R, x);
seg_merge(ret, seg[seg_idx(L, M)], ret);
return ret;
}
int seg_find(int L, int R, long long v) {
while (L < R) {
int M = (L + R) >> 1;
if (seg[seg_idx(L, M)].cnt >= v) {
R = M;
} else {
v -= seg[seg_idx(L, M)].cnt;
L = M + 1;
}
}
return L;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
a[i] -= i;
}
seg_build(1, n);
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
seg_upd(1, n, -x, y);
} else {
Segment lft = x > 1 ? seg_que(1, n, x - 1) : (Segment){0LL, 0};
Segment rht = seg_que(1, n, y);
int M = seg_find(1, n, (lft.cnt + rht.cnt + 1) >> 1);
Segment mid = seg_que(1, n, M);
int res =
((mid.cnt - lft.cnt) % mod * a[M] - (long long)(mid.sum - lft.sum) +
(long long)(rht.sum - mid.sum) - (rht.cnt - mid.cnt) % mod * a[M]) %
mod;
printf("%d\n", res < 0 ? res + mod : res);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, c, mir[1000005], mar[1000005], ls[1000005];
int mil[1000005], mal[1000005], cnt, flag, rs[1000005];
void dfs(int u, int low) {
if (flag) return;
if (mal[u]) {
ls[u] = ++cnt;
dfs(ls[u], mal[u]);
mal[u] = 0;
if (cnt >= mir[u]) flag = 1;
}
if (mar[u]) {
rs[u] = ++cnt;
dfs(rs[u], max(low, mar[u]));
mar[u] = 0;
}
if (cnt >= low) return;
if (!rs[u]) rs[u] = ++cnt;
dfs(rs[u], low);
}
void out(int u) {
if (!u) return;
out(ls[u]);
printf("%d ", u);
out(rs[u]);
}
char s[10];
int main() {
scanf("%d%d", &n, &c);
for (int i = 1; i <= n; i++) mil[i] = mir[i] = 1000005;
for (int i = 1; i <= c; i++) {
int rt, son;
scanf("%d%d%s", &rt, &son, s + 1);
if (rt >= son) flag = 1;
if (s[1] == 'L') {
mil[rt] = min(mil[rt], son);
mal[rt] = max(mal[rt], son);
} else {
mir[rt] = min(mir[rt], son);
mar[rt] = max(mar[rt], son);
}
}
for (int i = 1; i <= n; i++)
if (mir[i] != 1000005 && mal[i] != 0 && mal[i] >= mir[i]) {
printf("IMPOSSIBLE\n");
return 0;
}
cnt = 1;
dfs(1, n);
if (flag)
puts("IMPOSSIBLE");
else
out(1);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
int prevOcc[100010];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
for (long long i = (1); i < (n + 1); ++i) {
long long x, y;
cin >> x >> y;
long long root = sqrt(x), cnt = 0;
for (long long j = (1); j < (root + 1); ++j)
if (x % j == 0) {
if (prevOcc[j] < i - y) ++cnt;
if (j * j != x && prevOcc[x / j] < i - y) ++cnt;
prevOcc[j] = prevOcc[x / j] = i;
}
cout << cnt << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
void clock_out() {
cerr << "\nTime Elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " s\n";
}
void fileio() {
freopen("/home/dwai/Desktop/cp/input.txt", "r", stdin);
freopen("/home/dwai/Desktop/cp/output.txt", "w", stdout);
freopen("/home/dwai/Desktop/cp/debug.txt", "w", stderr);
}
void ofileio() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << H;
debug_out(T...);
}
int IT_MAX = 1 << 20;
const long long MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double ERR = 1e-10;
void solve() {
long long n, m;
cin >> n >> m;
long long arr[n][m];
long long i, j;
long long cnt = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
char temp;
cin >> temp;
if (temp == '*') {
arr[i][j] = 1;
cnt++;
} else
arr[i][j] = 0;
}
}
set<long long> r, c;
for (i = 0; i < n; i++) {
for (j = 1; j <= m - 1; j++) {
if (arr[i][j] == 1 && arr[i][j - 1] == 1) {
r.insert(i);
}
}
}
for (j = 0; j < m; j++) {
for (i = 1; i <= n - 1; i++) {
if (arr[i][j] == 1 && arr[i - 1][j] == 1) {
c.insert(j);
}
}
}
if (r.size() != 1 || c.size() != 1) {
cout << "NO";
return;
}
long long x = *r.begin();
long long y = *c.begin();
long long curcnt = 0;
for (i = x - 1; i >= 0; i--) {
if (arr[i][y])
curcnt++;
else
break;
}
for (i = y - 1; i >= 0; i--) {
if (arr[x][i])
curcnt++;
else
break;
}
for (i = x + 1; i <= n - 1; i++) {
if (arr[i][y])
curcnt++;
else
break;
}
for (i = y + 1; i <= m - 1; i++) {
if (arr[x][i])
curcnt++;
else
break;
}
curcnt++;
if (arr[x][y] == 1 && cnt == curcnt) {
if (x == 0 || y == 0 || x == n - 1 || y == m - 1) {
cout << "NO";
return;
}
if (arr[x - 1][y] == 1 && arr[x + 1][y] == 1 && arr[x][y - 1] == 1 &&
arr[x][y + 1] == 1) {
cout << "YES";
return;
}
}
cout << "NO";
}
int main() {
42;
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200006;
int n, ans = 1;
vector<int> p[N], c[N], e[N];
bool flag = 1, v[N];
inline void update(int x, int y) {
for (unsigned int i = 0; i < p[x].size(); i++)
for (unsigned int j = 0; j < p[y].size(); j++)
if (p[x][i] == p[y][j]) {
ans = max(ans, c[x][i] + c[y][j]);
c[x][i] = max(c[x][i], c[y][j] + 1);
}
}
void dp(int x) {
v[x] = 1;
for (unsigned int i = 0; i < e[x].size(); i++) {
int y = e[x][i];
if (v[y]) continue;
dp(y);
update(x, y);
}
}
inline void divide(int x, int t) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
p[t].push_back(i);
c[t].push_back(1);
while (x % i == 0) x /= i;
}
if (x > 1) {
p[t].push_back(x);
c[t].push_back(1);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
divide(x, i);
if (x != 1) flag = 0;
}
if (flag) {
puts("0");
return 0;
}
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
dp(1);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s, t, p;
cin >> s >> t;
int sum = 0;
bool one = false;
for (int i = 0; i < s.length(); i++) {
if (s[i] == t[i]) {
p += s[i];
sum++;
} else {
if (one) {
p += s[i];
one = !one;
} else {
p += t[i];
one = !one;
}
}
}
if ((s.length() - sum) & 1)
cout << "impossible";
else
cout << p;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool mark[100];
int main() {
int n, A[100][100];
cin >> n;
int k = n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> A[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (A[i][j] == 1 or A[i][j] == 3) {
mark[i] = true;
k--;
j = n;
}
}
cout << k << endl;
for (int i = 0; i < n; i++)
if (!mark[i]) cout << i + 1 << ' ';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, l = 1;
cin >> n >> k;
int arr[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < k - 1; j++) {
arr[i][j] = l;
l++;
}
}
for (int i = 0; i < n; i++) {
for (int j = k - 1; j < n; j++) {
arr[i][j] = l;
l++;
}
}
int sum = 0;
for (int i = 0; i < n; i++) sum += arr[i][k - 1];
cout << sum << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << arr[i][j] << " ";
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int pi[2022022];
int n;
bool KMP(string x) {
int q = 0;
for (int i = 2; i < x.length(); i++) {
while (q > 0 && x[q + 1] != x[i]) q = pi[q];
if (x[q + 1] == x[i]) q++;
pi[i] = q;
}
if (pi[2 * n - 1] > 0) return 1;
return 0;
}
string s1, s2;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
cin >> s1;
cin >> s2;
reverse(s1.begin(), s1.end());
for (int i = 0; i < s1.length(); i++) {
if (s1[i] == 'N')
s1[i] = 'S';
else if (s1[i] == 'S')
s1[i] = 'N';
else if (s1[i] == 'E')
s1[i] = 'W';
else if (s1[i] == 'W')
s1[i] = 'E';
}
s1 += '#';
s1 += s2;
s1 = '0' + s1;
if (KMP(s1))
cout << "NO\n";
else
cout << "YES\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
const int INF = 1e9;
int n, k, c[N];
int main() {
while (scanf("%d%d", &n, &k) == 2) {
for (int i = 0; i < n; i++) scanf("%d", &c[i]);
int l = 1, r = INF;
int mi, mx;
while (l < r) {
int m = (l + r + 1) >> 1;
long long take = 0, give = 0;
for (int i = 0; i < n; i++) {
if (m < c[i])
give += c[i] - m;
else
take += m - c[i];
}
if (give >= take && take <= k)
l = m;
else
r = m - 1;
}
mi = l;
l = 1;
r = INF;
while (l < r) {
int m = (l + r) >> 1;
long long take = 0, give = 0;
for (int i = 0; i < n; i++) {
if (m < c[i])
give += c[i] - m;
else
take += m - c[i];
}
if (take >= give && give <= k)
r = m;
else
l = m + 1;
}
mx = l;
printf("%d\n", mx - mi);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int n;
class bit {
public:
int s[200005];
void up(int p, int x) {
while (p <= n) {
s[p] += x;
p += p & -p;
}
}
int get(int p) {
int re = 0;
while (p) {
re = re + s[p];
p -= p & -p;
}
return re;
}
void clear() { memset(s, 0, sizeof(s)); }
} tree;
int a[200005], m, it[200005], c[200005], cnt[26];
set<int> s[26][26];
set<int> tot;
vector<pair<int, int> > tv;
void erase(int maxi, int i) {
cnt[maxi]--;
cnt[i]--;
int it = *s[maxi][i].begin();
s[maxi][i].erase(it);
auto iter = tot.find(it);
int tl = *iter;
iter--;
tv.emplace_back(make_pair(*iter, tl));
iter++;
iter++;
if (iter != tot.end()) {
int r = *iter;
if (i != c[r]) s[i][c[r]].erase(r);
iter--;
iter--;
if (iter != tot.begin()) {
iter--;
int l = *iter;
iter++;
if (c[l] != maxi) s[c[l]][maxi].erase(*iter);
iter--;
if (c[l] != c[r]) s[c[l]][c[r]].emplace(r);
}
} else {
iter--;
iter--;
if (iter != tot.begin()) {
iter--;
if (c[*iter] != maxi) {
s[c[*iter]][maxi].erase(*(++iter));
}
}
}
iter = tot.find(it);
auto t1 = iter;
t1--;
tot.erase(iter);
tot.erase(t1);
}
vector<pair<int, int> > solve(int gg) {
tv.clear();
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i <= 25; i++) {
for (int j = 0; j <= 25; j++) s[i][j].clear();
}
tot.clear();
for (int i = 1; i <= m; i++) cnt[c[i]]++;
for (int i = 2; i <= m; i++)
if (c[i - 1] != c[i]) s[c[i - 1]][c[i]].emplace(i);
for (int i = 1; i <= m; i++) tot.emplace(i);
while (1) {
int maxi = 0;
for (int i = 1; i <= 25; i++) {
if (cnt[maxi] < cnt[i]) maxi = i;
}
bool ff = 0;
for (int i = 0; i < 26; i++) {
if (!s[maxi][i].empty()) {
erase(maxi, i);
ff = 1;
break;
}
if (!s[i][maxi].empty()) {
erase(i, maxi);
ff = 1;
break;
}
}
if (!ff) {
while (!tot.empty()) {
tv.emplace_back(make_pair(*tot.begin(), 0));
tot.erase(tot.begin());
}
break;
}
}
return tv;
}
void solve() {
string s;
cin >> s;
n = s.size();
for (int i = 1; i <= n; i++) a[i] = s[i - 1] - 'a';
m = 0;
for (int i = 2; i <= n; i++) {
if (a[i] == a[i - 1]) {
c[++m] = a[i];
it[m] = i - 1;
}
}
it[m + 1] = n + 1;
vector<pair<int, int> > v = solve(m);
cout << v.size() + 1 << '\n';
for (int i = 1; i <= n; i++) tree.s[i] = 0;
for (auto u : v) {
if (u.second) {
int t1, t2;
t1 = it[u.first] + 1 - tree.get(it[u.first]);
t2 = it[u.second] - tree.get(it[u.second]);
cout << t1 << ' ' << t2 << '\n';
tree.up(it[u.second], t2 - t1 + 1);
} else {
int t1, t2;
t1 = 1;
t2 = it[u.first] - tree.get(it[u.first]);
cout << t1 << ' ' << t2 << '\n';
tree.up(it[u.first], t2 - t1 + 1);
}
}
cout << 1 << ' ' << n - tree.get(n) << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long N = 1000000007;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long binpow(long long a, int n) {
if (!n) return 1;
if (n % 2) return binpow(a, n - 1) * a % N;
long long bp = binpow(a, n / 2);
return bp * bp % N;
}
vector<pair<long long, long long> > segtree;
long long segt(int v, long long a, int l, int r, int tl, int tr) {
if (l > r) return N;
if (l == tl && r == tr) {
segtree[v].second += a;
return segtree[v].first + segtree[v].second;
}
int tm = (tl + tr) / 2;
segtree[2 * v + 1].second += segtree[v].second;
segtree[2 * v + 2].second += segtree[v].second;
long long lef = segt(2 * v + 1, a, l, min(r, tm), tl, tm);
long long rig = segt(2 * v + 2, a, max(l, tm + 1), r, tm + 1, tr);
segtree[v].first = min(segtree[2 * v + 1].first + segtree[2 * v + 1].second,
segtree[2 * v + 2].first + segtree[2 * v + 2].second);
segtree[v].second = 0;
return min(lef, rig);
}
void solve() {
int n;
cin >> n;
set<int> b, f, sb, sf;
long long ans = 0;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
ans += y;
if (x == 0) {
if (y > 0) {
f.insert(y);
} else {
y = -y;
if (sf.count(y)) {
sf.erase(y);
ans -= y;
} else {
f.erase(y);
}
}
} else {
if (y > 0) {
b.insert(y);
} else {
y = -y;
if (sb.count(y)) {
sb.erase(y);
ans -= y;
} else {
b.erase(y);
if (b.empty()) {
if (!sb.empty()) {
ans -= *sb.begin();
b.insert(*sb.begin());
sb.erase(sb.begin());
} else if (!sf.empty()) {
ans -= *sf.begin();
f.insert(*sf.begin());
sf.erase(sf.begin());
}
} else if (!sf.empty() || !sb.empty()) {
int val1 = sf.empty() ? N : *sf.begin(),
val2 = sb.empty() ? N : *sb.begin();
if (val1 < val2) {
sf.erase(val1);
ans -= val1;
f.insert(val1);
} else {
sb.erase(val2);
ans -= val2;
b.insert(val2);
}
}
}
}
}
if (sf.size() < b.size()) {
if (b.size() == 1) {
if (!f.empty()) {
int val = *--f.end();
sf.insert(val);
ans += val;
f.erase(val);
}
} else {
int val1 = *--b.end(), val2 = f.empty() ? -1 : *--f.end();
ans += max(val1, val2);
if (val1 > val2) {
b.erase(val1);
sb.insert(val1);
} else {
f.erase(val2);
sf.insert(val2);
}
}
}
for (int j = 0; j < 2; ++j) {
if (!f.empty() && !sb.empty() && *--f.end() > *sb.begin()) {
ans -= *sb.begin();
b.insert(*sb.begin());
sb.erase(sb.begin());
int val = *--f.end();
ans += val;
f.erase(val);
sf.insert(val);
}
if (!f.empty() && !sf.empty() && *--f.end() > *sf.begin()) {
ans -= *sf.begin();
f.insert(*sf.begin());
sf.erase(sf.begin());
int val = *--f.end();
ans += val;
f.erase(val);
sf.insert(val);
}
if (b.size() > 1 && !sb.empty() && *--b.end() > *sb.begin()) {
ans -= *sb.begin();
b.insert(*sb.begin());
sb.erase(sb.begin());
int val = *--b.end();
ans += val;
b.erase(val);
sb.insert(val);
}
if (b.size() > 1 && !sf.empty() && *--b.end() > *sf.begin()) {
ans -= *sf.begin();
f.insert(*sf.begin());
sf.erase(sf.begin());
int val = *--b.end();
ans += val;
b.erase(val);
sb.insert(val);
}
}
cout << ans << endl;
}
}
int main() {
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct NODE {
double x, y;
};
NODE pillar[3];
double dis(NODE a, NODE b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
double Heron(double a, double b, double c) {
double p = (a + b + c) / 2;
return sqrt(p * (p - a) * (p - b) * (p - c));
}
double Radius(double a, double b, double c) {
double S = Heron(a, b, c);
return a * b * c / (4 * S);
}
double fgcd(double a, double b) {
if (fabs(b - 0) <= (1e-4)) return a;
if (fabs(a - 0) <= (1e-4)) return b;
return fgcd(b, fmod(a, b));
}
void gao() {
double a, b, c;
double p, S, R, A, B, C;
double ansS;
a = dis(pillar[0], pillar[1]);
b = dis(pillar[1], pillar[2]);
c = dis(pillar[2], pillar[0]);
R = Radius(a, b, c);
A = acos(1 - a * a / (2 * R * R));
B = acos(1 - b * b / (2 * R * R));
C = 2 * acos(-1.0) - A - B;
double angle_fgcd = fgcd(A, fgcd(B, C));
ansS = acos(-1.0) / angle_fgcd * R * R * sin(angle_fgcd);
printf("%.8lf\n", ansS);
}
void READ() {
int i;
for (i = 0; i < 3; ++i) {
scanf("%lf%lf", &pillar[i].x, &pillar[i].y);
}
gao();
}
int main() {
READ();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1100;
const int M = 256;
const int K = 26;
const int INF = 2000000000;
const double eps = 1e-12;
int k, m, n, d[K], a[N];
char s[N];
bool ok;
int F();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
k = 1;
for (int i = 0; i < 26; i++) d[i] = k, k <<= 1;
for (int i = 0; i < n; i++) {
cin >> s;
m = 0;
for (int j = 0; s[j]; j++) m = m | d[s[j] - 'a'];
a[i] = m;
}
sort(a, a + n);
m = 1;
for (int i = 1; i < n; i++)
if (a[i] != a[i - 1]) m++;
cout << m;
return 0;
}
int F() { return 0; }
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[111], sum[111];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int x, y;
cin >> x >> y;
int ans = 0;
sum[0] = 0;
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
for (int i = 1; i <= n; i++)
if (sum[i] >= x && sum[n] - sum[i] >= x && sum[i] <= y &&
sum[n] - sum[i] <= y) {
cout << i + 1 << endl;
return 0;
}
cout << 0 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 1e5 + 1000;
vector<int> ans;
long long sum, n, d[maxn];
int main() {
ios::sync_with_stdio(false);
ans.push_back(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int t;
cin >> t;
if (t == 1) {
int x, y;
cin >> x >> y;
sum += (long long)x * y;
d[x - 1] += y;
}
if (t == 2) {
int x;
cin >> x;
sum += x;
ans.push_back(x);
}
if (t == 3)
if (ans.size() > 1) {
sum -= ans.back();
sum -= d[ans.size() - 1];
d[ans.size() - 2] += d[ans.size() - 1];
d[ans.size() - 1] = 0;
ans.pop_back();
}
if (ans.size() == 0)
cout << 0 << endl;
else
cout << fixed << setprecision(6) << (double)sum / ans.size() << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char a[200004], b[200004], alpha[26];
long long n, m, i, j;
string s;
int main() {
cin >> n >> m >> s;
for (i = 0; i < m; i++) cin >> a[i] >> b[i];
for (i = 0; i < 26; i++) alpha[i] = i + 'a';
for (i = 0; i < m; i++) {
for (j = 0; j < 26; j++) {
if (alpha[j] == a[i])
alpha[j] = b[i];
else if (alpha[j] == b[i])
alpha[j] = a[i];
}
}
for (i = 0; i < n; i++) s[i] = alpha[s[i] - 'a'];
cout << s << endl;
return 0;
}
| 2 |
// After Seeing Editorial
#include <iostream>
#include <iomanip>
#include <cmath>
#include <string>
#include <algorithm>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <vector>
typedef long long ll;
typedef unsigned long long int ull;
typedef long double ldb;
#define PB push_back
#define Fas ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
using namespace std;
ll power(ll a,ll b){
int result=1;
while(b>0){
if(b%2 == 1){
result *= a;
}
a *= a;
b /= 2;
}
return result;
}
//ll gcd(ll x,ll y){
// if(x==1||y==1){
// return 1;
// }else if(x==0){
// return y;
// }else if(y==0){
// return x;
// }else if(( x >= y ) && (( x % y ) != 0)){
// return gcd(x-y,y);
// }else if(x>=y &&(x%y ==0)){
// return y;
// }else if(( y >= x ) && (( y % x ) != 0)){
// return gcd(y-x,x);
// }else if(y>=x &&((y%x)==0)){
// return x;
// }
//}
ll gcd(ll x,ll y){
ll r;
while(y!=0&&(r=x%y)!=0){
x=y;
y=r;
}
return y==0?x:y;
}
void solve(){
ll a,b,g;
cin>>a>>b;
vector<ll> A(a);
vector<ll> B(b);
vector<ll> ans(b);
if(a>1){
cin>>A[0];
for(ll i=1;i<a;i++){
cin>>A[i];
A[i]= abs(A[i]-A[0]);
if(i==1){
g=A[1];
}else{
g=gcd(g,A[i]);
}
}
for(ll i=0;i<b;i++){
cin>>B[i];
ll c=abs(A[0]+B[i]);
ans[i]=gcd(c,g);
}
for(auto vec:ans){
cout<<vec<<" ";
}
}else{
cin>>A[0];
for(ll i=0;i<b;i++){
cin>>B[i];
cout<<A[0]+B[i]<<" ";
}
}
}
int main(){
Fas;
// ll t{};
// cin>>t;
//
// while(t--){
solve();
// }
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXC = 30;
const int MAXN = 1001000;
int trie[MAXN][MAXC];
vector<int> A[2][MAXN];
int match[MAXN];
int matched[MAXN];
char str[MAXN];
int main() {
int n;
int cnt = 0;
scanf("%d", &n);
for (int j = 0; j < 2; ++j) {
for (int i = 1; i <= n; ++i) {
scanf("%s", str);
int cur = 0;
A[j][cur].push_back(i);
for (int c = 0; str[c]; ++c) {
int ch = str[c] - 'A';
int &nxt = trie[cur][ch];
if (!nxt) {
nxt = ++cnt;
}
cur = nxt;
A[j][cur].push_back(i);
}
}
}
int ans = 0;
for (int i = cnt; i >= 0; --i) {
int a = 0, b = 0;
vector<int> &x = A[0][i], &y = A[1][i];
if (i) ans += min((int((x).size())), (int((y).size())));
while (a < (int((x).size())) && b < (int((y).size()))) {
if (match[x[a]])
++a;
else if (matched[y[b]])
++b;
else {
match[x[a]] = y[b];
matched[y[b]] = x[a];
++a;
++b;
}
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; ++i) {
printf("%d %d\n", i, match[i]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 1;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
if (a * c % b == 0)
cout << a * c / b - c;
else
cout << a * c / b + 1 - c;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
int n;
cin >> n;
int t;
int speed = 0;
int ans = 0;
int c = 0;
int bs;
stack<int> s;
cin >> t >> speed;
for (int i = 1; i < n; i++) {
cin >> t;
if (t == 1) {
cin >> speed;
while (!s.empty() && speed > s.top()) {
s.pop();
ans++;
}
} else if (t == 2) {
ans += c;
c = 0;
} else if (t == 3) {
cin >> bs;
s.push(bs);
if (bs < speed) {
s.pop();
ans++;
}
} else if (t == 4) {
c = 0;
} else if (t == 5) {
while (!s.empty()) s.pop();
} else {
c++;
}
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct point {
long long x, w;
};
const int MAXN = 200005;
int N, ord[MAXN], dp[MAXN];
point A[MAXN];
bool comp1(point a, point b) { return a.x + a.w < b.x + b.w; }
int main() {
ios::sync_with_stdio(0);
cin >> N;
for (int i = 0; i < N; i++) {
cin >> A[i].x >> A[i].w;
ord[i] = A[i].x + A[i].w;
}
sort(A, A + N, comp1);
sort(ord, ord + N);
for (int i = 0; i < N; i++) {
int j = upper_bound(ord, ord + N, A[i].x - A[i].w) - ord - 1;
dp[i] = (j < 0 ? 1 : dp[j] + 1);
if (i > 0) dp[i] = max(dp[i], dp[i - 1]);
}
cout << dp[N - 1] << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void outarr(Tp _begin, Tp _end, const char* _delim = " ") {
for (Tp current = _begin; current != _end; ++current) {
std::cout << *current << _delim;
}
std::cout << '\n';
}
using ll = long long;
using pii = std::pair<int, int>;
constexpr int INF = 0x3f3f3f3f;
constexpr int MOD = static_cast<const int>(1e9 + 7);
const pii BLACK = {3, 2};
const pii WHITE = {2, 2};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int q;
cin >> q;
while (q--) {
int b, w;
cin >> b >> w;
pii start = WHITE;
if (w > b) {
w ^= b;
b ^= w;
w ^= b;
start = BLACK;
}
if (w + w + w + 1 < b) {
cout << "NO"
"\n";
continue;
}
cout << "YES"
"\n";
for (int i = 0; i < (w + w); ++i) {
cout << start.first << ' ' << start.second + i << "\n";
}
b -= w;
if (b > 0) {
--b;
cout << start.first << ' ' << start.second - 1 << "\n";
}
for (int i = 0; i < w + w && b > 0; i += 2) {
cout << start.first - 1 << ' ' << start.second + i << "\n";
--b;
}
for (int i = 0; i < w + w && b > 0; i += 2) {
cout << start.first + 1 << ' ' << start.second + i << "\n";
--b;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int f[MAXN], n, m, a[MAXN];
set<int> S;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i], S.insert(i);
cin >> m;
for (int i = 0; i < m; i++) {
int t, p, x;
cin >> t >> p;
p--;
if (t == 1) {
cin >> x;
while (S.lower_bound(p) != S.end()) {
int ind = *S.lower_bound(p), tmp = min(f[ind] + x, a[ind]);
x -= tmp - f[ind];
f[ind] = tmp;
if (f[ind] == a[ind])
S.erase(S.lower_bound(p));
else
break;
}
} else
cout << f[p] << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int c[1010], r[1010];
int s[1010][1010];
int main(void) {
int n, m, k;
while (~scanf("%d%d%d", &n, &m, &k)) {
int i, j;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
scanf("%d", &s[i][j]);
}
}
for (i = 1; i <= max(m, n); i++) r[i] = c[i] = i;
while (k--) {
char e[4];
int a, b;
scanf("%s %d %d", e, &a, &b);
if (e[0] == 'g')
printf("%d\n", s[r[a]][c[b]]);
else if (e[0] == 'c') {
swap(c[a], c[b]);
} else if (e[0] == 'r') {
swap(r[a], r[b]);
}
}
}
}
| 2 |
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
void solve()
{
ll n;
cin>>n;
if(n%2==0)
{
cout<<(n/2+1)*(n/2+1)<<endl;
}
else
{
cout<<((n+2)*(n+2))/2<<endl;
}
}
int main()
{
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif
int t;
/* cin>>t;
while(t--)*/
solve();
} | 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 5004;
int pal[N][N], cnt[N][N];
char S[N];
int main() {
int q;
scanf("%s %d", S, &q);
int n = strlen(S);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == 1)
pal[j][j] = 1;
else if (i == 2) {
pal[j][j + 1] = (S[j] == S[j + 1]);
cnt[j][j + 1] = cnt[j][j] + cnt[j + 1][j + 1];
} else {
pal[j][j + i - 1] = (S[j] == S[j + i - 1] && pal[j + 1][j + i - 2]);
cnt[j][j + i - 1] =
cnt[j][j + i - 2] + cnt[j + 1][j + i - 1] - cnt[j + 1][j + i - 2];
}
if (pal[j][j + i - 1]) cnt[j][j + i - 1]++;
}
}
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
--l;
--r;
printf("%d\n", cnt[l][r]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b;
int c = 0;
scanf("%d%d%d%d", &n, &m, &a, &b);
int t = b % m;
int k = (a - 1) % m;
if (m != 1) {
for (int i = a; i <= b; i++) {
if (i % m == 0) c++;
}
if (b != n) {
if (t != 0 && k != 0) {
if (c == 0)
printf("1\n");
else if (c == 1)
printf("2\n");
else if (a + c * m - 1 == b)
printf("2\n");
else
printf("3\n");
} else if (k == 0 && t != 0) {
if (c == 0)
printf("1\n");
else
printf("2\n");
} else if (t == 0 && k != 0) {
if (b - a + 1 < m)
printf("1\n");
else if (c == 0)
printf("1\n");
else
printf("2\n");
} else if (t == 0 && k == 0)
printf("1\n");
} else {
if (c == 0)
printf("1\n");
else if (k == 0)
printf("1\n");
else
printf("2\n");
}
} else
printf("1\n");
return 0;
}
| 4 |
/*
* author: zhaoyiping
* time: 2021-06-04 23:08:02
*/
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
// vector<int> g[MAXN];
long long a[MAXN];
long long c[MAXN];
int fa[MAXN][20];
int deep[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int q;
cin >> q >> a[0] >> c[0];
for (int i = 1; i <= q; i++) {
int op;
cin >> op;
if (op == 1) {
int p, aa, cc;
cin >> p >> aa >> cc;
a[i] = aa;
c[i] = cc;
fa[i][0] = p;
deep[i] = deep[p] + 1;
for (int j = 1; j < 20; j++) {
fa[i][j] = fa[fa[i][j - 1]][j - 1];
}
} else {
int v;
long long w;
cin >> v >> w;
int beg = v;
for (int i = 19; i >= 0; i--)
if (a[fa[beg][i]])
beg = fa[beg][i];
long long tt = 0;
long long ans = 0;
for (int i = deep[v] - deep[beg]; i >= 0; i--) {
int now = v;
for (int j = 0; j < 20; j++) {
if ((1 << j) & i)
now = fa[now][j];
}
if (a[now] >= w) {
tt += w;
ans += c[now] * w;
a[now] -= w;
w = 0;
break;
} else {
tt += a[now];
ans += c[now] * a[now];
w -= a[now];
a[now] = 0;
}
}
cout << tt << " " << ans << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, j = 0, prev = 0, peak = 0;
bool decreasing = true, increasing = true, mountain = true, test = false;
cin >> n;
if (n == 200000) {
test = true;
}
int* pillars = new int[n];
for (int i = 0; i < n; i++) cin >> pillars[i];
prev = pillars[0];
for (int i = 1; i < n; i++) {
if (pillars[i] > prev) {
decreasing = false;
break;
}
prev = pillars[i];
}
if (!decreasing) {
prev = pillars[0];
for (int i = 1; i < n; i++) {
if (pillars[i] < prev) {
increasing = false;
break;
}
prev = pillars[i];
}
if (!increasing) {
prev = pillars[0];
for (int i = 1; i < n; i++) {
if (pillars[i] < prev) {
peak = i - 1;
break;
}
prev = pillars[i];
}
prev = pillars[peak];
for (int i = peak + 1; i < n; i++) {
if (pillars[i] > prev) {
mountain = false;
break;
}
prev = pillars[i];
}
if (!mountain)
cout << "NO" << endl;
else
cout << "YES" << endl;
} else
cout << "YES" << endl;
} else
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename... T>
void read(T&... args) {
((cin >> args), ...);
}
template <typename... T>
void write(T... args) {
((cout << args), ...);
}
using vcl = vector<long>;
using vcc = vector<char>;
using vcs = vector<string>;
using vcd = vector<double>;
using vcll = vector<long long>;
using vc = vector<int>;
bool isPrime(long long n) {
if (n == 2) {
return true;
} else {
bool p = true;
if (n % 2 == 0) {
p = false;
} else {
for (long long i = 3; i * i <= n; i += 2) {
if (n % i == 0) p = false;
}
}
return p;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n;
read(n);
if (isPrime(n))
write(1);
else if (n % 2 == 0)
write(2);
else {
if (isPrime(n - 2))
write(2);
else
write(3);
}
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, m, a;
long long int x, y;
scanf("%d %d %d", &n, &m, &a);
x = n / a;
y = m / a;
if (x * a != n) x++;
if (y * a != m) y++;
printf("%lld", x * y);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
int input;
while (cin >> input) {
v.push_back(input);
}
sort(v.begin(), v.end());
int k = v.at(0);
int l = v.at(n - 1);
int m = v.size();
int t = (l - k + 1) - m;
cout << t;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *x) -> decltype(std::cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug &operator<<(const c &) {
return *this;
}
};
const int mod1 = 1e5 + 7;
const int mod2 = 1e9 + 7;
const long long mod3 = 1e12 + 7;
const int si = 4e5 + 7;
int n, m, M, p, choose[2][2 * si], x, y, ans[si], cnt, ans_cnt;
vector<int> son[4 * si];
int belong[4 * si], tin[4 * si], low[4 * si], now_time, scc_cnt, num;
stack<int> s;
void dfs(int o) {
tin[o] = low[o] = ++now_time;
s.push(o);
for (auto v : son[o]) {
if (!tin[v]) dfs(v);
if (!belong[v]) low[o] = min(low[o], low[v]);
}
if (tin[o] == low[o]) {
scc_cnt++;
int now;
while (true) {
now = s.top();
s.pop();
belong[now] = scc_cnt;
num++;
if (now == o) break;
}
}
}
int main() {
scanf("%d%d%d%d", &n, &p, &M, &m);
for (int i = 1; i <= p; i++) {
choose[0][i] = ++cnt;
choose[1][i] = ++cnt;
}
for (int i = 0; i <= M; i++) {
choose[0][1 + i + p] = ++cnt;
choose[1][1 + i + p] = ++cnt;
}
son[choose[1][p + 1]].push_back(choose[0][p + 1]);
son[choose[0][p + M + 1]].push_back(choose[1][p + M + 1]);
for (int i = 1; i <= M; i++) {
x = i + 1 + p;
son[choose[0][x]].push_back(choose[0][x - 1]);
son[choose[1][x - 1]].push_back(choose[1][x]);
}
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
son[choose[0][x]].push_back(choose[1][y]);
son[choose[0][y]].push_back(choose[1][x]);
}
int li, ri;
for (int i = 1; i <= p; i++) {
scanf("%d%d", &x, &y);
if (x > M) continue;
li = x + p;
ri = min(y, M) + p + 1;
son[choose[1][i]].push_back(choose[0][li]);
son[choose[1][li]].push_back(choose[0][i]);
son[choose[0][ri]].push_back(choose[0][i]);
son[choose[1][i]].push_back(choose[1][ri]);
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
son[choose[1][x]].push_back(choose[0][y]);
son[choose[1][y]].push_back(choose[0][x]);
}
for (int i = 2; i <= cnt; i += 2)
if (!tin[i]) dfs(i);
for (int i = 1; i <= cnt; i += 2)
if (!tin[i]) dfs(i);
for (int i = 1; i <= 1 + p + M; i++)
if (belong[choose[0][i]] == belong[choose[1][i]]) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= p; i++) {
if (belong[choose[1][i]] < belong[choose[0][i]]) ans[++ans_cnt] = i;
}
for (int i = 1; i <= M; i++) {
if (belong[choose[1][1 + i + p]] < belong[choose[0][1 + i + p]]) {
printf("%d %d\n", ans_cnt, i);
for (int j = 1; j <= ans_cnt; j++) printf("%d ", ans[j]);
break;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, i, j, count1 = 0, count2 = 0, a = 0, b = 0;
cin >> n;
int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] == 0)
count1++;
else
count2++;
}
for (i = 0; i < n; i++) {
if (arr[i] == 0) {
a++;
if (a == count1) {
cout << i + 1;
break;
}
} else {
b++;
if (b == count2) {
cout << i + 1;
break;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e14;
const long long N = (long long)1e5 + 77;
const long long mod = (long long)1e9 + 7;
int n, m, k;
int a[N], first[N], second[N];
int mxfirst, mxsecond;
int findfirst[N], findsecond[N];
vector<pair<int, int> > ans;
int possible(int t) {
int servefirst = 0, servesecond = 0;
int scorefirst = 0, scoresecond = 0;
int i = 0, p = 0, x, y;
while (true) {
if (servefirst + t > mxfirst and servesecond + t > mxsecond) return -1;
if (servefirst + t <= mxfirst)
x = findfirst[servefirst + t];
else
x = INT_MAX;
if (servesecond + t <= mxsecond)
y = findsecond[servesecond + t];
else
y = INT_MAX;
if (x < y) {
scorefirst++;
i = findfirst[servefirst + t];
servefirst += first[i] - first[p];
servesecond += second[i] - second[p];
} else {
scoresecond++;
i = findsecond[servesecond + t];
servefirst += first[i] - first[p];
servesecond += second[i] - second[p];
}
p = i;
if (servefirst == mxfirst and a[n] == 1) break;
if (servesecond == mxsecond and a[n] == 2) break;
}
if (scorefirst == scoresecond) return -1;
if (scorefirst > scoresecond) {
if (a[n] == 1) return scorefirst;
}
if (scoresecond > scorefirst) {
if (a[n] == 2) return scoresecond;
}
return -1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= (int)(n); ++i) {
cin >> a[i];
if (a[i] == 1) {
first[i] = first[i - 1] + 1;
second[i] = second[i - 1];
} else {
first[i] = first[i - 1];
second[i] = second[i - 1] + 1;
}
mxfirst = max(mxfirst, first[i]);
mxsecond = max(mxsecond, second[i]);
if (findfirst[first[i]] == 0) findfirst[first[i]] = i;
if (findsecond[second[i]] == 0) findsecond[second[i]] = i;
}
for (int t = 1; t <= (int)(n); ++t) {
int s = possible(t);
if (s != -1) ans.push_back({s, t});
}
sort(ans.begin(), ans.end());
cout << (int)ans.size() << endl;
for (auto x : ans) {
cout << x.first << " " << x.second << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e3 + 5;
const long long mod = 1e9 + 7;
const long long p = 31;
void c_p_c() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void solve() {
long long n;
cin >> n;
std::map<long long, long long> mp, mp2;
for (long long i = (0); i < (n); i++) {
std::map<long long, long long> map;
for (long long j = (0); j < (n); j++) {
long long x;
cin >> x;
map[x]++;
if (map[x] > 1) mp[i + 1] = x, mp2[x]++;
}
}
std::vector<long long> v;
for (long long i = 1; i <= n; i++)
if (mp2[i] == 0) v.push_back(i);
for (long long i = 1; i <= n; i++) {
if (mp[i] == 0) {
cout << v[v.size() - 1] << ' ';
v.pop_back();
} else
cout << mp[i] << ' ';
}
}
int32_t main() {
c_p_c();
solve();
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
namespace io {
const int L = (1 << 21) + 1;
char ibuf[L], *iS, *iT, obuf[L], *oS = obuf, *oT = obuf + L - 1, c, st[55];
int f, tp;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <class I>
inline void gi(I& x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = -x;
while (x) st[++tp] = x % 10 + '0', x /= 10;
while (tp) putc(st[tp--]);
}
inline void gs(char* s, int& l) {
for (c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c != '_' && (c < 'a' || c > 'z');
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
;
for (l = 0; c == '_' || c <= 'z' && c >= 'a';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
s[l++] = c;
}
}; // namespace io
using io::gi;
using io::gs;
using io::print;
using io::putc;
const int N = 200005, M = 32, L = 525005;
int n, q, a[N], mx;
struct LinearBase {
int a[M], m;
int find(int k) {
for (int i = 1; i <= m; i++)
if ((k ^ a[i]) < k) k ^= a[i];
return k;
}
void ext(int k) {
if (k = find(k)) {
int j = 1;
while (k <= a[j]) j++;
++m;
for (int i = m; i > j; i--) a[i] = a[i - 1];
a[j] = k;
for (int i = 1; i < j; i++)
if ((k ^ a[i]) < a[i]) a[i] ^= k;
}
}
friend LinearBase operator+(const LinearBase& a, const LinearBase& b) {
if ((1ll << a.m) > mx) return a;
if ((1ll << b.m) > mx) return b;
LinearBase ret = a;
for (int i = 1; i <= b.m; i++) ret.ext(b.a[i]);
return ret;
}
void clear() {
while (m) a[m--] = 0;
}
} seg[L], ans;
void build(int x, int l, int r) {
if (l == r) {
seg[x].ext(a[l]);
return;
}
int mid = (l + r) >> 1, ls = x << 1, rs = ls | 1;
build(ls, l, mid);
build(rs, mid + 1, r);
seg[x] = seg[ls] + seg[rs];
}
void modify(int x, int l, int r, int p, int k) {
if (l == r) {
seg[x].a[1] ^= k;
mx = max(mx, seg[x].a[1]);
if (!seg[x].a[1])
seg[x].m = 0;
else
seg[x].m = 1;
return;
}
int mid = (l + r) >> 1, ls = x << 1, rs = ls | 1;
if (p <= mid)
modify(ls, l, mid, p, k);
else
modify(rs, mid + 1, r, p, k);
seg[x] = seg[ls] + seg[rs];
}
LinearBase query(int x, int l, int r, int s, int t) {
if (l == s && r == t) return seg[x];
int mid = (l + r) >> 1, ls = x << 1, rs = ls | 1;
if (t <= mid) return query(ls, l, mid, s, t);
if (s > mid) return query(rs, mid + 1, r, s, t);
LinearBase w = query(ls, l, mid, s, mid);
if ((1ll << w.m) > mx) return w;
return w + query(rs, mid + 1, r, mid + 1, t);
}
int sum[N];
void add(int x, int u) {
while (x <= n) sum[x] ^= u, x += ((x) & -(x));
}
int ask(int x) {
int r = 0;
while (x) r ^= sum[x], x -= ((x) & -(x));
return r;
}
int main() {
gi(n), gi(q);
for (int i = 1, s = 0; i <= n; i++) gi(a[i]), add(i, a[i]), add(i + 1, a[i]);
for (int i = n; i >= 1; i--) mx = max(mx, a[i] ^= a[i - 1]);
build(1, 1, n);
for (int i = 1, op, l, r, k; i <= q; i++) {
gi(op);
gi(l);
gi(r);
if (op == 1) {
gi(k);
modify(1, 1, n, l, k);
if (r < n) modify(1, 1, n, r + 1, k);
add(l, k);
add(r + 1, k);
} else {
if (l < r)
ans = query(1, 1, n, l + 1, r);
else
ans.clear();
ans.ext(ask(l));
print(1 << ans.m);
putc('\n');
}
}
io::flush();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> a, b;
long long int n, c;
int check(long long int x) {
long long int s = 0, i;
for (i = 0; i < n; i++) {
if (x / b[i] > c / a[i]) return c + 1;
s += a[i] * x / b[i] + 1;
}
if (s < 0) cout << "dfhgiu\n";
return s;
}
int main() {
long long int k = 0;
cin >> n >> c;
a.resize(n), b.resize(n);
for (long long int i = 0; i < n; i++) cin >> a[i] >> b[i], k += a[i];
long long int l = 0, r = 1e18, f = 0, m, m1;
if (!k && n == c)
return cout << "-1\n", 0;
else if (!k)
return cout << "0\n", 0;
while (f++ < 60) {
m = (l + r) / 2;
if (check(m) < c)
l = m;
else
r = m;
}
m = l;
f = l = 0, r = 1e18;
while (f++ < 60) {
m1 = (l + r) / 2;
if (check(m1) <= c)
l = m1;
else
r = m1;
}
cout << max(l - m, (long long int)0) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double oo = 1e5 + 3;
const long double mod = 1e9 + 7;
const long double pi = 3.1415926535897932384;
long double x1, y_1, r1;
long double x2, y_2, r2;
long double d, u, v, m, n;
long double dis(long double x1, long double y1, long double x2,
long double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
int main() {
cin >> x1 >> y_1 >> r1;
cin >> x2 >> y_2 >> r2;
cout.precision(22);
d = dis(x1, y_1, x2, y_2);
if (d >= (r1 + r2))
cout << 0;
else if (abs(r2 - r1) > d || d == 0) {
cout << pi * min(r1, r2) * min(r1, r2);
} else {
long double u = 2 * acosl((d * d + r1 * r1 - r2 * r2) / (2 * d * r1));
long double v = 2 * acosl((d * d + r2 * r2 - r1 * r1) / (2 * d * r2));
long double m = u * r1 * r1 * 0.5 - 0.5 * r1 * r1 * sinl(u);
long double n = v * r2 * r2 / 2 - 0.5 * r2 * r2 * sinl(v);
cout << m + n;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:640000000")
using namespace std;
const double EPS = 1e-9;
const int INF = 0x7f7f7f7f;
const double PI = acos(-1.0);
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int t, n, m;
int arr[4][15];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
while (cin >> n) {
string s;
cin >> s;
memset(arr, 0, sizeof(arr));
for (int i = 0; i < (s.size()); i++) {
int val = s[i] - '0';
arr[0][val]++;
}
cin >> s;
for (int i = 0; i < (s.size()); i++) {
int val = s[i] - '0';
arr[1][val]++;
}
for (int i = 0; i < (10); i++) arr[2][i] = arr[1][i];
int ans1 = 0;
for (int i = 0; i < (10); i++) {
int val = arr[0][i];
if (val) {
for (int j = 0; j < (10); j++) {
if (j >= i) {
int v = min(val, arr[1][j]);
arr[1][j] -= v;
val -= v;
}
}
}
ans1 += val;
}
cout << ans1 << endl;
int ans2 = 0;
for (int i = 0; i < (10); i++) {
int val = arr[0][i];
if (val) {
for (int j = 0; j < (10); j++) {
if (j > i) {
int v = min(val, arr[2][j]);
arr[2][j] -= v;
val -= v;
ans2 += v;
}
}
}
}
cout << ans2 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2147483647;
const long long INFL = 9223372036854775807LL;
const double EPSILON = 0.00000001;
const long long MOD = 1000000007;
long long a[100000 + 5];
bool seen[100000 + 5];
struct item {
long long val, pos;
long long cnt;
};
bool check_same(vector<item>& seq) {
for (long long i = 0; i < (long long)(seq).size(); i++) {
if (seq[i].val != seq[0].val) return false;
}
return true;
}
vector<item> reduce(vector<item>& seq, long long k) {
memset(seen, false, sizeof(seen));
;
stack<item> s;
for (auto it = seq.begin(); it != seq.end(); it++) {
if (s.empty() or it->val != s.top().val) {
it->cnt = 1;
} else
it->cnt = s.top().cnt + 1;
s.push(*it);
if (it->cnt == k) {
vector<item> deleted;
bool ok = true;
for (long long i = 0; i < k; i++) {
if (seen[s.top().pos]) {
ok = false;
break;
}
seen[s.top().pos] = true;
deleted.push_back(s.top());
s.pop();
}
if (not ok) {
reverse(deleted.begin(), deleted.end());
for (auto it : deleted) s.push(it);
}
}
}
vector<item> ret;
while (!s.empty()) {
ret.push_back(s.top());
s.pop();
}
reverse(ret.begin(), ret.end());
return ret;
}
void print(vector<item>& seq) {
for (long long i = 0; i < (long long)(seq).size(); i++) {
}
}
int32_t main() {
long long n, k, m;
cin >> n >> k >> m;
long long total = m * n;
vector<item> seq;
for (long long i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
;
seq.push_back((item){a[i], i, 1});
}
if (check_same(seq)) {
cout << total % k << endl;
return 0;
}
seq = reduce(seq, k);
print(seq);
n = (long long)(seq).size();
for (long long i = 0; i < n; i++) {
seq[i].pos = i;
seq.push_back(seq[i]);
}
seq = reduce(seq, k);
print(seq);
vector<item> left, mid, right;
memset(seen, false, sizeof(seen));
;
bool start_mid = false;
for (long long i = 0; i < (long long)(seq).size(); i++) {
if (seen[seq[i].pos]) {
mid.push_back(seq[i]);
start_mid = true;
} else if (start_mid)
right.push_back(seq[i]);
else
left.push_back(seq[i]);
seen[seq[i].pos] = true;
}
for (long long i = 0; i < (long long)(mid).size(); i++) left.pop_back();
print(left);
print(mid);
print(right);
if (not check_same(mid)) {
long long ans = (long long)(left).size() + (long long)(right).size() +
m * (long long)(mid).size();
cout << ans << endl;
return 0;
}
long long total_mid = (long long)(mid).size() * m;
if (total_mid % k != 0) {
long long ans =
(long long)(left).size() + (long long)(right).size() + (total_mid % k);
cout << ans << endl;
} else {
for (auto it : right) left.push_back(it);
vector<item> res = reduce(left, k);
print(res);
cout << (long long)(res).size() << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, s, ans, arr[100100], cost[100100];
bool ok(long long m) {
for (int i = 1; i <= n; i++) cost[i] = arr[i] + i * m;
sort(cost + 1, cost + n + 1);
long long xans = 0;
for (int i = 1; i <= m; i++) {
xans += cost[i];
}
if (xans <= s) ans = xans;
return (xans <= s);
}
int main() {
cin >> n >> s;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
long long l = 0, r = n, mid;
while (l < r) {
mid = (l + r + 1) / 2;
if (ok(mid))
l = mid;
else
r = mid - 1;
}
cout << l << " " << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:256000000")
using namespace std;
vector<int> get(int n) {
vector<int> res;
if (n == 1) {
res.push_back(1);
} else if (n == 2) {
res.push_back(3);
res.push_back(4);
} else {
for (int(i) = 0; (i) < (n - 1); (i)++) res.push_back(2);
res.push_back(n - 2);
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> r = get(n), c = get(m);
for (int(i) = 0; (i) < (n); (i)++) {
for (int(j) = 0; (j) < (m); (j)++) printf("%d ", r[i] * c[j]);
printf("\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int f, r, a, m, v;
cin >> f >> r >> a >> m >> v;
cout << min(f, min(r, min(a / 2, min(m / 7, v / 4))));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N, M, z[300001], one[300001], two[300001], sz[300001], last[300001], res[6],
dist = 5;
vector<int> v[300001];
void out(int n) {
cout << n << "\n";
for (int i = 0; i <= n - 1; ++i) cout << res[i] << " ";
cout << N << endl;
}
void dfs(int s, int c) {
if (z[s]) return;
z[s] = c;
sz[c]++;
for (int i : v[s]) dfs(i, c);
}
int main() {
cin >> N >> M;
res[0] = 1;
while (M--) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
if (a + b == 1 + N && (a == 1 || b == 1)) {
out(1);
return 0;
}
}
for (int i : v[N]) last[i] = 1;
for (int i : v[1]) one[i] = 1;
one[1] = 1;
for (int x : v[1]) {
for (int u : v[x]) {
if (u == N) {
res[1] = x;
dist = 2;
}
if (last[u] && dist > 3) {
res[1] = x;
res[2] = u;
dist = 3;
}
if (!one[u] && dist > 4) {
res[1] = x;
res[2] = u;
res[3] = 1;
dist = 4;
}
}
}
if (dist != 5) {
out(dist);
return 0;
}
z[1] = N + 1;
int c = 0;
for (int i : v[1]) {
if (!z[i]) {
dfs(i, ++c);
}
}
for (int i : v[1]) {
if (sz[z[i]] != v[i].size()) {
for (int u : v[i]) two[u] = 1;
two[i] = 1;
two[1] = 1;
for (int j : v[i]) {
for (int u : v[j]) {
if (!two[u] && j != 1) {
res[1] = i;
res[2] = j;
res[3] = u;
res[4] = i;
out(5);
return 0;
}
}
}
}
}
cout << -1 << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, bool> > > graph;
vector<int> nodeToComponent, dfs_num, dfs_low, visited;
int dfsCounter;
const int UNVISITED = -1;
stack<int> S;
int BC;
void biconnected(int u, int parent) {
dfs_low[u] = dfs_num[u] = dfsCounter++;
visited[u] = 1;
S.push(u);
for (auto &edge : graph[u]) {
int v = edge.first;
if (v == parent) continue;
if (dfs_num[v] == UNVISITED) biconnected(v, u);
if (visited[v]) dfs_low[u] = min(dfs_low[u], dfs_low[v]);
}
if (dfs_low[u] == dfs_num[u]) {
while (true) {
int v = S.top();
S.pop();
visited[v] = 0;
nodeToComponent[v] = BC;
if (v == u) break;
}
BC++;
}
}
vector<vector<pair<int, bool> > > bGraph;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, u, v, johny, dealer;
bool art;
cin >> n >> m;
graph.assign(n, vector<pair<int, bool> >());
for (int i = 0; i < m; i++) {
cin >> u >> v >> art;
u--;
v--;
graph[u].push_back({v, art});
graph[v].push_back({u, art});
}
cin >> johny >> dealer;
johny--;
dealer--;
if (m == 0) {
cout << "NO";
return 0;
}
dfsCounter = 0;
nodeToComponent.assign(n, -1);
dfs_num.assign(n, UNVISITED);
dfs_low.assign(n, 0);
visited.assign(n, 0);
S = stack<int>();
BC = 0;
for (int i = 0; i < n; i++) {
if (dfs_num[i] == UNVISITED) biconnected(i, -1);
}
bGraph.assign(BC, vector<pair<int, bool> >());
vector<bool> bNode(BC, false);
set<pair<int, int> > edges;
for (u = 0; u < n; u++) {
int cU = nodeToComponent[u];
for (auto &edge : graph[u]) {
v = edge.first;
art = edge.second;
int cV = nodeToComponent[v];
if (cU != cV) {
bGraph[cU].push_back({cV, art});
bGraph[cV].push_back({cU, art});
}
if (art) {
if (cU == cV)
bNode[cU] = true;
else
edges.insert({min(cU, cV), max(cU, cV)});
}
}
}
queue<int> q;
q.push(nodeToComponent[johny]);
visited.assign(BC, false);
visited[nodeToComponent[johny]] = true;
vector<int> parent(BC, -1);
while (!q.empty()) {
u = q.front();
if (u == nodeToComponent[dealer]) break;
q.pop();
for (auto &edge : bGraph[u]) {
v = edge.first;
art = edge.second;
if (!visited[v]) {
parent[v] = u;
q.push(v);
visited[v] = true;
}
}
}
int target = nodeToComponent[dealer];
vector<int> path;
while (target != -1) {
path.push_back(target);
target = parent[target];
}
bool ans = bNode[path[0]];
for (int i = path.size() - 1; i >= 1 && !ans; i--) {
ans |= bNode[path[i]];
ans |= edges.count(
{min(path[i], path[i - 1]), max(path[i], path[i - 1])}) != 0;
}
printf(ans ? "YES" : "NO");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int bound = 400;
struct qq {
int id, vl;
bool operator<(const qq &temp) const { return vl < temp.vl; }
};
qq bk[210000 / bound][bound], ns;
int nk[210000 / bound];
struct pp {
int vl, id, min_value, value;
int flag;
bool operator<(const pp &temp) const { return vl < temp.vl; }
};
pp bl[210000 / bound][2 * bound], now;
int num[210000 / bound], num_bl, cnt_list, np[2 * bound];
int m, n, a[220000], num_q, ans, nw;
int lower_bound(int left, int right, qq bl[], int x) {
int mid;
while (left <= right) {
mid = (left + right) >> 1;
if (bl[mid].vl < x)
left = mid + 1;
else
right = mid - 1;
}
return right;
}
int lower_bound(int left, int right, pp bl[], int x) {
int mid;
while (left <= right) {
mid = (left + right) >> 1;
if (bl[mid].vl < x)
left = mid + 1;
else
right = mid - 1;
}
return right;
}
int main() {
int i, j, s, p, q, ip, id, l, r, x, fir;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
memset(num, 0, sizeof(num));
memset(nk, 0, sizeof(nk));
num_bl = 0;
for (i = 0; i < n; i++) {
if (i % bound == 0) {
for (j = i; j < min(n, i + bound); j++) {
if (j + m < n) {
now.id = j;
now.vl = a[j];
now.flag = -1;
bl[num_bl][num[num_bl]++] = now;
now.id = j + m;
now.vl = a[j + m];
now.flag = 1;
bl[num_bl][num[num_bl]++] = now;
}
ns.id = j;
ns.vl = a[j];
bk[num_bl][nk[num_bl]++] = ns;
}
num_bl++;
}
}
for (i = 0; i < num_bl; i++) {
sort(bl[i], bl[i] + num[i]);
sort(bk[i], bk[i] + nk[i]);
for (j = i * bound; j < min((i + 1) * bound, n); j++) np[j - i * bound] = 0;
for (j = 0; j < num[i]; j++) {
bl[i][j].value = bl[i][j].flag;
ip = bl[i][j].id;
if (bl[i][j].flag > 0) ip -= m;
np[ip - i * bound] += bl[i][j].flag;
if (bl[i][j].flag < 0) {
if (bl[i][j].id + m >= n) {
bl[i][j].value = 0;
np[ip - i * bound]++;
}
}
if (j) {
bl[i][j].value += bl[i][j - 1].value;
}
bl[i][j].min_value = 0;
nw = 0;
for (s = i * bound; s < min((i + 1) * bound, n); s++) {
nw += np[s - i * bound];
if (bl[i][j].min_value > nw) bl[i][j].min_value = nw;
}
}
}
scanf("%d", &num_q);
ans = 0;
while (num_q--) {
scanf("%d%d%d", &l, &r, &x);
l--;
r--;
x ^= ans;
ans = 0;
id = l / bound;
nw = fir = 0;
for (i = l; i <= min(l + m - 1, (l / bound + 1) * bound - 1); i++) {
if (a[i] < x) fir++;
}
if (l + m - 1 >= (l / bound + 1) * bound) {
for (i = (l + m - 1) / bound * bound; i <= l + m - 1; i++) {
if (a[i] < x) fir++;
}
for (i = l / bound + 1; i < (l + m - 1) / bound; i++) {
id = lower_bound(0, nk[i] - 1, bk[i], x);
fir += (id + 1);
}
}
for (i = l; i <= min(r - 1, (l / bound + 1) * bound - 1); i++) {
if (i + m < n) {
if (a[i] < x) nw--;
if (a[i + m] < x) nw++;
if (ans > nw) ans = nw;
}
}
if (r - 1 >= (l / bound + 1) * bound) {
for (i = l / bound + 1; i < (r - 1) / bound; i++) {
id = lower_bound(0, num[i] - 1, bl[i], x);
if (id >= 0) {
if (nw + bl[i][id].min_value < ans) ans = nw + bl[i][id].min_value;
nw += bl[i][id].value;
}
}
for (i = ((r - 1) / bound) * bound; i <= r - 1; i++) {
if (i + m < n) {
if (a[i] < x) nw--;
if (a[i + m] < x) nw++;
if (ans > nw) ans = nw;
}
}
}
ans += fir;
printf("%d\n", ans);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
constexpr int DEBUG = 0;
template <class T>
inline bool UpdateMin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool UpdateMax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T>
vector<vector<T>> Make2DVector(int d1, int d2, T default_value) {
return vector<vector<T>>(d1, vector<T>(d2, default_value));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
vector<int> xs(n + 1);
int x_min = 0;
for (int i = 0; i < n; i++) {
xs[i + 1] = xs[i] + ((s[i] == '(') ? 1 : -1);
UpdateMin(x_min, xs[i + 1]);
}
if (xs[n] != 0) {
cout << 0 << endl;
cout << 1 << " " << 1 << endl;
return 0;
}
int max_score = 0;
for (int i = 1; i <= n; i++) {
if (xs[i] == x_min) max_score++;
}
int max_score_l = 0;
int max_score_r = 0;
for (int pattern = 0; pattern < 2; pattern++) {
int x_delta = vector<int>({-2, 2})[pattern];
char l_char = string("()")[pattern];
char r_char = string(")(")[pattern];
for (int new_min = x_min - 2; new_min <= x_min + 2; new_min++) {
auto dp1 = Make2DVector(n + 1, 3, -1);
auto dp2 = Make2DVector(n + 1, 3, -1);
dp1[0][0] = 0;
vector<int> next_states;
for (int i = 0; i < n; i++) {
for (int k = 0; k < 3; k++) {
if (dp1[i][k] < 0) continue;
next_states.clear();
next_states.push_back(k);
if (k == 0 && s[i] == l_char) next_states.push_back(1);
if (k == 1 && s[i] == r_char) next_states.push_back(2);
for (int next_state : next_states) {
int new_x = xs[i + 1] + ((next_state == 1) ? x_delta : 0);
if (new_x < new_min) continue;
int score_delta = (new_x == new_min) ? 1 : 0;
if (UpdateMax(dp1[i + 1][next_state], dp1[i][k] + score_delta)) {
dp2[i + 1][next_state] = k;
}
}
}
}
if (UpdateMax(max_score, dp1[n][2])) {
int cur_k = 2;
int l = -1;
int r = -1;
for (int i = n; i >= 0; i--) {
if (cur_k == 2 && dp2[i][cur_k] == 1) r = i - 1;
if (cur_k == 1 && dp2[i][cur_k] == 0) l = i - 1;
cur_k = dp2[i][cur_k];
if (cur_k == 0) break;
}
max_score_l = l;
max_score_r = r;
}
}
}
cout << max_score << endl;
cout << max_score_l + 1 << " " << max_score_r + 1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int t, m, hc[1000], ac[1000];
int main() {
string n1, n2;
char c, h;
cin >> n1 >> n2;
int x;
cin >> x;
for (unsigned int(i) = 0; (i) < (x); (i)++) {
cin >> t >> h >> m >> c;
if (h == 'h') {
if (hc[m] == 1 || (c == 'r' && hc[m] != -1)) {
cout << n1 << " " << m << " " << t << endl;
hc[m] = -1;
} else if (hc[m] >= 0)
hc[m]++;
} else {
if (ac[m] == 1 || (c == 'r' && ac[m] != -1)) {
cout << n2 << " " << m << " " << t << endl;
ac[m] = -1;
} else if (ac[m] >= 0)
ac[m]++;
}
}
}
| 2 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>
#include <map>
#include <set>
#include <unordered_map>
#include <numeric>
#include <iomanip>
#include <queue>
using namespace std;
#define int long long
#define all(v) v.begin(), v.end()
#define F first
#define S second
const int mod = 1e9 + 7;
const int N = 1e6 + 5;
vector<vector<int>> g;
vector<int> color;
vector<int> h;
void dfs(int v, int c) {
color[v] = 1;
for (auto& to : g[v]) {
if (!color[to]) {
h[to] = h[v] + 1;
dfs(to, c);
}
}
return;
}
void cl(int n) {
g.clear();
color.clear();
h.clear();
g.resize(n);
color.resize(n);
h.resize(n);
}
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
cl(n);
for (int i = 0; i < m; ++i) {
int v, u;
cin >> v >> u;
--v, --u;
g[v].push_back(u);
g[u].push_back(v);
}
dfs(0, 1);
if (*min_element(all(color)) == 0) {
cout << "NO\n";
continue;
}
queue<int> q;
q.push(0);
vector<int>d(n, n + 1);
d[0] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto& to : g[v]) {
if (d[to] > d[v] + 1) {
d[to] = d[v] + 1;
q.push(to);
}
}
}
vector<int> vs(n);
iota(all(vs), 0);
sort(all(vs), [&](int x, int y) {
return d[x] < d[y];
});
vector<int> ans;
vector<bool> used(n);
for (int i = 0; i < n; ++i) {
int v = vs[i];
if (!used[v]) {
ans.push_back(v);
for (auto& it : g[v]) {
used[it] = true;
}
}
}
cout << "YES\n";
cout << ans.size() << '\n';
for (auto& it : ans) {
cout << it + 1 << ' ';
}
cout << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 100;
const long long INF = 3e18 + 1191;
const long long mod = 1e9 + 7;
long long n, k, a[maxn];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
if (k == n)
cout << a[n - 1] << "\n";
else {
if (k == 0) {
if (a[0] > 1)
cout << "1\n";
else
cout << "-1\n";
} else {
if (a[k - 1] != a[k])
cout << a[k - 1] << "\n";
else
cout << "-1\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, e, head[100010], r[100005], f1[100005], f2[100005], len;
vector<int> vec;
struct Edge {
int to, cost, next;
} edge[200010];
void addedge(int a, int b, int c) {
edge[e].to = b;
edge[e].cost = c;
edge[e].next = head[a];
head[a] = e++;
}
void dfs1(int u, int fa) {
r[u] = u;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (v == fa) continue;
dfs1(v, u);
if (f1[u] < f1[v] + edge[i].cost) {
f1[u] = f1[v] + edge[i].cost;
r[u] = r[v];
}
}
}
void dfs2(int u, int fa) {
r[u] = u;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (v == fa) continue;
dfs2(v, u);
if (f1[u] <= f1[v] + edge[i].cost) {
f2[u] = f1[u];
f1[u] = f1[v] + edge[i].cost;
r[u] = v;
} else if (f2[u] < f1[v] + edge[i].cost) {
f2[u] = f1[v] + edge[i].cost;
}
}
}
bool fun(int d) {
bool tag = false;
int num = 0;
for (int i = 0; i < vec.size(); i++) {
if (!tag) {
if (len - f1[vec[i]] <= d) continue;
tag = true;
num = 2;
if (k == 1) {
if (f1[vec[i - 1]] > d || f2[vec[i - 1]] > d) return false;
return true;
} else {
if (f2[vec[i]] > d || f2[vec[i - 1]] > d) return false;
if (k == 2 && f1[vec[i]] > d) return false;
if (k == 2) return true;
}
} else {
num++;
if (f2[vec[i]] > d) return false;
if (num == k) {
if (f1[vec[i]] > d) return false;
return true;
}
}
}
return true;
}
long long solve() {
long long l = 0;
long long r = 1e9;
long long ans = -1;
while (l <= r) {
long long mid = (l + r) / 2;
if (fun(mid)) {
r = mid - 1;
ans = mid;
} else {
l = mid + 1;
}
}
return ans;
}
int main() {
scanf("%d%d", &n, &k);
memset(head, -1, sizeof(head));
e = 0;
for (int i = 1; i < n; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
addedge(a, b, c);
addedge(b, a, c);
}
memset(f1, 0, sizeof(f1));
memset(f2, 0, sizeof(f2));
dfs1(1, 0);
int tmp = r[1];
memset(f1, 0, sizeof(f1));
dfs2(tmp, 0);
len = f1[tmp];
vec.push_back(tmp);
while (tmp != r[tmp]) {
tmp = r[tmp];
vec.push_back(tmp);
}
if (k > vec.size()) {
int ans = 0;
for (int i = 0; i < vec.size(); i++) {
ans = max(ans, f2[vec[i]]);
}
cout << ans << endl;
return 0;
}
cout << solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a[210], m;
priority_queue<int> q;
priority_queue<int, vector<int>, greater<int> > q2;
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int ans = a[0];
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
for (int k = 0; k < n; ++k) {
if (k >= i && k <= j)
q2.push(a[k]);
else
q.push(a[k]);
}
for (int k = 0; k < m; ++k) {
if (q.empty() || q2.empty()) break;
int s = q2.top();
q2.pop();
int l = q.top();
q.pop();
q2.push(l);
q.push(s);
}
int sum = 0;
while (!q2.empty()) {
sum += q2.top();
q2.pop();
}
ans = max(ans, sum);
while (!q.empty()) {
q.pop();
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v[11];
long long pre[259], inp[11], ans;
bool rt[11];
long long calc(long long x) {
long long ret, i;
ret = 0;
for (i = 2; i * i <= x; i++) {
while (x % i == 0) {
x /= i;
ret++;
}
}
if (x > 1) ret++;
return ret;
}
void btrack(long long x, long long n) {
long long cnt, r, i, sz, bt, j, k;
if (x == n) {
cnt = r = 0;
for (i = 0; i < n; i++) {
sz = v[i].size();
bt = (1 << i);
for (j = 0; j < sz; j++) {
k = v[i][j];
bt = (bt | (1 << k));
}
if (pre[bt] == -1) break;
cnt += pre[bt];
if (rt[i]) r++;
}
if (i == n) {
if (r > 1) cnt++;
ans = min(ans, cnt);
}
return;
}
for (i = 0; i < n; i++) {
if (i != x && inp[i] > inp[x]) {
v[i].push_back(x);
btrack(x + 1, n);
v[i].pop_back();
}
}
rt[x] = 1;
btrack(x + 1, n);
rt[x] = 0;
}
int main() {
long long n, i, max1, j, pro;
cin >> n;
for (i = 0; i < n; i++) cin >> inp[i];
pre[0] = -1;
for (i = 1; i < (1 << n); i++) {
max1 = 0;
for (j = 0; j < n; j++) {
if (i & (1 << j)) max1 = max(max1, inp[j]);
}
pro = max1;
for (j = 0; j < n; j++) {
if ((i & (1 << j)) && inp[j] != max1) {
if (pro % inp[j]) break;
pro /= inp[j];
}
}
if (j == n) {
pre[i] = 1 + calc(pro);
if (max1 == pro && pre[i] == 2) pre[i] = 1;
} else
pre[i] = -1;
}
ans = 1000000000000000LL;
btrack(0, n);
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 1e6 + 5;
int t, n;
string s;
void solve() {
for (int i = 1; i <= n; ++i) {
int a = 0, b = 0;
for (int j = i; j <= n; ++j) {
a += (s[j] == 'a');
b += (s[j] == 'b');
if (a == b) {
cout << i << ' ' << j << '\n';
return;
}
}
}
cout << -1 << ' ' << -1 << '\n';
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n;
cin >> s;
s = ' ' + s;
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int c = 1;
int count = 0;
if (n == 1)
cout << 1 << "\n";
else {
while (true) {
if (!(c % 3 == 0 || c % 10 == 3)) count++;
if (count == n) break;
c++;
}
cout << c << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
int gcd(int a, int b) {
while (b) {
a %= b;
if (b > a) swap(a, b);
}
return a;
}
int main() {
string s, ans;
int k;
cin >> k >> s;
map<char, int> m;
for (int i = 0; i < s.length(); i++) m[s[i]]++;
for (map<char, int>::iterator it = m.begin(); it != m.end(); it++)
if (it->second % k != 0) {
cout << "-1";
return 0;
}
for (int ki = 0; ki < k; ki++) {
for (map<char, int>::iterator it = m.begin(); it != m.end(); it++)
for (int i = 0; i < it->second / k; i++) cout << it->first;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const long long INF = 1e18;
const string nl = "\n";
template <long long MD>
struct modint {
static const long long mod = MD;
long long v;
explicit operator long long() const { return v; }
modint() { v = 0; }
modint(long long _v) {
v = (-MD < _v && _v < MD) ? _v : _v % MD;
if (v < 0) {
v += MD;
}
}
friend bool operator==(const modint& a, const modint& b) {
return a.v == b.v;
}
friend bool operator!=(const modint& a, const modint& b) { return !(a == b); }
friend bool operator<(const modint& a, const modint& b) { return a.v < b.v; }
friend ostream& operator<<(ostream& os, const modint& m) {
os << m.v;
return os;
}
friend istream& operator>>(istream& is, modint& m) {
long long x;
is >> x;
m.v = x;
return is;
}
modint& operator+=(const modint& m) {
if ((v += m.v) >= MD) {
v -= MD;
}
return *this;
}
modint& operator-=(const modint& m) {
if ((v -= m.v) < 0) {
v += MD;
}
return *this;
}
modint& operator*=(const modint& m) {
v = v * m.v % MD;
return *this;
}
modint& operator/=(const modint& m) { return (*this) *= inv(m); }
friend modint power(modint a, long long p) {
modint ans = 1;
assert(p >= 0);
while (p > 0) {
if (p & 1) {
ans *= a;
}
a *= a;
p >>= 1;
}
return ans;
}
friend modint inv(const modint& a) {
assert(a.v != 0);
return power(a, MD - 2);
}
modint operator-() const { return modint(-v); }
modint& operator++() { return *this += 1; }
modint& operator--() { return *this -= 1; }
friend modint operator+(modint a, const modint& b) { return a += b; }
friend modint operator-(modint a, const modint& b) { return a -= b; }
friend modint operator*(modint a, const modint& b) { return a *= b; }
friend modint operator/(modint a, const modint& b) { return a /= b; }
};
using mint = modint<MOD>;
const long long N = 1e6 + 10;
vector<mint> fac(N + 10);
mint C(long long n, long long k) {
if (k == 0 || n == k) {
return 1;
}
return fac[n] * inv(fac[n - k] * fac[k]);
}
void precomp() {
fac[0] = 0;
fac[1] = 1;
for (long long i = 2; i < N; ++i) {
fac[i] = i * fac[i - 1];
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
precomp();
long long n, m, k;
cin >> n >> m >> k;
mint ans = 1;
ans *= C(n - 1, k);
for (long long i = 0; i <= k; ++i) {
if (i == 0) {
ans *= m;
} else {
ans *= (m - 1);
}
}
cout << ans << nl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, q;
int main() {
ios::sync_with_stdio(false);
cin >> q;
while (q--) {
cin >> n >> m >> k;
if (k < max(m, n)) {
cout << "-1" << endl;
continue;
}
if ((n + m) & 1) {
cout << k - 1 << endl;
continue;
}
cout << k - 2 * ((n & 1) != (k & 1)) << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long i;
cin >> n;
for (i = 1000000 - n; i < 1000000; i++) cout << i << " ";
return (0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long pos(vector<long long> v, long long a) {
long long low = 0, high = v.size();
while (high - low > 1) {
long long mig = (high + low) / 2;
if (v[mig] <= a)
low = mig;
else
high = mig;
}
return low;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
vector<long long> v;
for (long long t = 1; t <= 62; t++) {
long long S = (1LL << (t)) - 1LL;
for (long long p = 0; p < t - 1; p++) {
v.push_back(S ^ (1LL << p));
}
}
v.push_back(0);
sort(v.begin(), v.end());
long long a, b;
cin >> a >> b;
--a;
cout << pos(v, b) - pos(v, a) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) { return (x) ? gcd(y % x, x) : y; }
int main() {
int n, x, y;
cin >> n;
int d;
set<pair<int, int> > second;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
if (x == 0) continue;
d = gcd(x, y);
second.insert(make_pair(x / d, y / d));
}
cout << second.size() << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
const int inf = 1e9;
const long long mod = 998244353;
int n;
int a[N];
int hav[N];
void sol() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) hav[i] = 0;
vector<int> can;
int res = n;
for (int i = 1; i <= n; i++) {
int x = a[i];
if (x >= 1 && x <= n) {
if (!hav[x]) {
hav[x] = 1;
res--;
} else
can.push_back((x - 1) / 2);
} else
can.push_back((x - 1) / 2);
}
sort((can).begin(), (can).end());
int nw = n;
while (nw >= 1) {
while (nw >= 1 && hav[nw]) --nw;
if (nw == 0) break;
if (can.back() < nw) return (void)(cout << -1 << '\n');
can.pop_back();
hav[nw] = 1;
}
cout << res << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) sol();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int x, y;
int dx[] = {1, 1, 1, 0, 0, 0, -1, -1, -1};
int dy[] = {0, 1, -1, 0, 1, -1, 0, 1, -1};
int p, q;
void go(int i, int j) {
for (int k = 0; k < 9; k++) {
int xx = dx[k] + i;
int yy = dy[k] + j;
if (xx == x && yy == y) {
p = 1 + dx[k];
q = 1 + dy[k];
return;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string ss[15];
string s[19];
for (int i = 0; i < 11; i++) {
getline(cin, ss[i]);
}
for (int i = 0, k = 0; i < 11; i++) {
int f = 0;
for (int j = 0; j < 11; j++) {
if (ss[i].size() > 0 && ss[i][j] != ' ') s[k] += ss[i][j], f = 1;
}
if (f) k++;
}
cin >> x >> y;
x--, y--;
go(1, 1);
go(1, 4);
go(1, 7);
go(4, 1);
go(4, 4);
go(4, 7);
go(7, 1);
go(7, 4);
go(7, 7);
int f = 0;
for (int i = 3 * p; i <= 3 * p + 2; i++) {
for (int j = 3 * q; j <= 3 * q + 2; j++) {
if (s[i][j] == '.') {
s[i][j] = '!';
f = 1;
}
}
}
if (f == 0) {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
if (s[i][j] == '.') s[i][j] = '!';
}
}
}
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
cout << s[i][j];
if (j == 2 || j == 5) cout << ' ';
}
cout << endl;
if (i == 2 || i == 5) cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d;
int main() {
cin >> a >> b >> c >> d;
int first = max(3 * a / 10, a - ((a / 250) * c));
int second = max(3 * b / 10, b - ((b / 250) * d));
if (first > second) {
cout << "Misha" << endl;
} else if (first < second) {
cout << "Vasya" << endl;
} else {
cout << "Tie" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 1000 + 10;
int n, dp[N], mx, cnt;
string s;
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
fill(dp, dp + N, -1);
cin >> s, n = s.size();
for (int i = 1; i < n; i++) {
if (s[i - 1] == '(' && s[i] == ')') dp[i] = i - 1;
if (dp[i - 1] ^ -1 && s[dp[i - 1] - 1] == '(' && s[i] == ')')
dp[i] = dp[i - 1] - 1;
if (dp[i] > 0 && dp[dp[i] - 1] ^ -1) dp[i] = dp[dp[i] - 1];
}
for (int i = 0; i < n; i++) {
if (i - dp[i] + 1 > mx && dp[i] ^ -1)
mx = i - dp[i] + 1, cnt = 1;
else if (i - dp[i] + 1 == mx && dp[i] ^ -1)
cnt++;
}
if (!mx)
cout << "0 1\n";
else
cout << mx << ' ' << cnt << '\n';
}
| 5 |
#include <bits/stdc++.h>
int setBit(int N, int pos) { return N = N | (1 << pos); }
int resetBit(int N, int pos) { return N = N & ~(1 << pos); }
bool checkBit(int N, int pos) { return (bool)(N & (1 << pos)); }
using namespace std;
const int MAXN = 65536;
int n, deg[MAXN + 5], xr[MAXN + 5];
bool visit[MAXN + 5];
vector<int> graph[MAXN + 5];
set<pair<int, int> > sol;
void solve() {
queue<int> q;
int i, siz, u, v;
for (i = 0; i < n; i++) {
if (deg[i] == 1) q.push(i);
}
while (!q.empty()) {
u = q.front();
q.pop();
if (visit[u]) continue;
visit[u] = true;
siz = (int)graph[u].size();
if (siz > 0) {
int x = 0;
for (i = 0; i < siz; i++) {
x ^= graph[u][i];
}
v = x ^ xr[u];
} else
v = xr[u];
if (u == v) continue;
graph[v].push_back(u);
sol.insert(pair<int, int>(min(u, v), max(u, v)));
deg[u]--;
deg[v]--;
if (deg[v] == 1)
q.push(v);
else if (deg[v] <= 0)
visit[v] = true;
}
for (auto i : sol) {
printf("%d %d\n", i.first, i.second);
}
}
int main() {
int m = 0, i;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d %d", °[i], &xr[i]);
m += deg[i];
}
printf("%d\n", m / 2);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int fa[500010], ans = 1;
int gf(int x) {
if (fa[x] == x) return x;
return fa[x] = gf(fa[x]);
}
namespace fastIO {
bool IOerror = 0;
inline char nc() {
static char buf[1000000], *p1 = buf + 1000000, *pend = buf + 1000000;
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, 1000000, stdin);
if (pend == p1) {
IOerror = 1;
return -1;
}
}
return *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline void read(int &x) {
bool sign = 0;
char ch = nc();
x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return;
if (ch == '-') sign = 1, ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
if (sign) x = -x;
}
struct Ostream_fwrite {
char *buf, *p1, *pend;
Ostream_fwrite() {
buf = new char[1000000];
p1 = buf;
pend = buf + 1000000;
}
void out(char ch) {
if (p1 == pend) {
fwrite(buf, 1, 1000000, stdout);
p1 = buf;
}
*p1++ = ch;
}
void println(int x) {
static char s[15], *s1;
s1 = s;
if (!x) *s1++ = '0';
if (x < 0) out('-'), x = -x;
while (x) *s1++ = x % 10 + '0', x /= 10;
while (s1-- != s) out(*s1);
out('\n');
}
void println(char *s) {
while (*s) out(*s++);
out('\n');
}
void flush() {
if (p1 != buf) {
fwrite(buf, 1, p1 - buf, stdout);
p1 = buf;
}
}
~Ostream_fwrite() { flush(); }
} Ostream;
inline void println(int x) { Ostream.println(x); }
inline void flush() { Ostream.flush(); }
}; // namespace fastIO
using namespace fastIO;
int main() {
int n, m, x, y;
read(n);
read(m);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
read(x);
read(y);
if (gf(x) == gf(y)) {
ans = (ans << 1);
if (ans >= 1000000009) ans -= 1000000009;
} else
fa[gf(y)] = fa[gf(x)];
println(ans - 1);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct node {
node *next, *oth, *prev;
int x, y;
bool type;
node(int x, int y, bool type) : x(x), y(y), type(type) {
next = oth = prev = 0;
}
node() {
x = y = -1;
next = oth = prev = 0;
}
};
node* xs[5100];
node* ys[5100];
vector<char> s[5100];
vector<node*> xnode[5100];
vector<node*> ynode[5100];
int n, m;
void del(node* x) {
x->prev->next = x->next;
x->next->prev = x->prev;
}
void init() {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] != '.') {
node* tmp = new node(i, j, 0);
node* tmp2 = new node(i, j, 1);
(tmp->oth = tmp2)->oth = tmp;
xnode[i].push_back(tmp);
ynode[j].push_back(tmp2);
}
}
node mem[30000];
int memptr;
node* getnode() {
mem[memptr] = node();
return &mem[memptr++];
}
void build() {
memptr = 0;
for (int i = 0; i < n; i++) {
xs[i] = getnode();
node* t = xs[i];
for (int j = 0; j < xnode[i].size(); j++) {
t->next = xnode[i][j];
xnode[i][j]->prev = t;
t = xnode[i][j];
}
t->next = getnode();
t->next->prev = t;
}
for (int i = 0; i < m; i++) {
ys[i] = getnode();
node* t = ys[i];
for (int j = 0; j < ynode[i].size(); j++) {
t->next = ynode[i][j];
ynode[i][j]->prev = t;
t = ynode[i][j];
}
t->next = getnode();
t->next->prev = t;
}
}
void read() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
s[i].resize(m);
for (int j = 0; j < m; j++) scanf(" %c ", &s[i][j]);
}
}
int calc(int x, int y) {
build();
node* cur = xs[x];
for (; cur->y != y; cur = cur->next)
;
int cnt = 0;
for (; cur->x != -1;) {
cnt++;
int x = cur->x;
int y = cur->y;
node* next;
if (s[x][y] == 'L' || s[x][y] == 'R')
if (cur->type) cur = cur->oth;
if (s[x][y] == 'U' || s[x][y] == 'D')
if (!cur->type) cur = cur->oth;
if (s[x][y] == 'L' || s[x][y] == 'U')
next = cur->prev;
else
next = cur->next;
del(cur->oth);
del(cur);
cur = next;
}
return cnt;
}
int main() {
read();
init();
int best = 0, bcnt = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] != '.') {
int tmp = calc(i, j);
if (tmp > best)
best = tmp, bcnt = 1;
else if (tmp == best)
bcnt++;
}
cout << best << " " << bcnt << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 3e5 + 100;
long long n, m, k, t;
char a[maxn];
int b[maxn];
bool f[maxn];
queue<int> q, q1;
int main() {
scanf("%lld%lld%s", &n, &m, a + 1);
a[0] = a[n];
a[n + 1] = a[1];
for (int i = 1; i <= n; i++) {
b[i] = -1;
if (a[i] == a[i - 1] || a[i] == a[i + 1]) q.push(i), q1.push(0), f[i] = 1;
}
while (!q.empty()) {
int now = q.front(), now2 = q1.front();
b[now] = now2;
q.pop();
q1.pop();
if (!f[now - 1] && now > 1) {
q.push(now - 1);
q1.push(now2 + 1);
f[now - 1] = 1;
} else if (now == 1 && !f[n]) {
q.push(n);
q1.push(now2 + 1);
f[n] = 1;
}
if (!f[now + 1] && now < n) {
q.push(now + 1);
q1.push(now2 + 1);
f[now + 1] = 1;
} else if (now == n && !f[1]) {
q.push(1);
q1.push(now2 + 1);
f[1] = 1;
}
}
for (int i = 1; i <= n; i++) {
if (b[i] == -1 || b[i] >= m) {
if (m & 1) {
if (a[i] == 'W')
printf("B");
else
printf("W");
} else
printf("%c", a[i]);
} else {
if (b[i] & 1) {
if (a[i] == 'W')
printf("B");
else
printf("W");
} else
printf("%c", a[i]);
}
}
cout << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mn = 100005;
char s[mn], t[5], c[5];
int nxt[mn][26], f[300][300][300];
int ss[4][mn];
int main() {
int n, m;
scanf("%d%d%s", &n, &m, s + 1);
memset(nxt, 0x3f, sizeof nxt);
for (int i = 0; i < 26; i++) nxt[n + 1][i] = n + 1;
for (int i = n; i >= 0; i--) {
for (int j = 0; j < 26; j++) nxt[i][j] = nxt[i + 1][j];
if (i < n) nxt[i][s[i + 1] - 'a'] = i + 1;
}
int x = 0, y = 0, z = 0;
while (m--) {
int num;
scanf("%s%d", t, &num);
if (t[0] == '+') {
scanf("%s", c);
if (num == 1) {
ss[1][++x] = c[0];
for (int i = x; i <= x; i++)
for (int j = 0; j <= y; j++)
for (int k = 0; k <= z; k++) {
if (i + j + k) f[i][j][k] = n + 1;
if (i)
f[i][j][k] =
min(f[i][j][k], nxt[f[i - 1][j][k]][ss[1][i] - 'a']);
if (j)
f[i][j][k] =
min(f[i][j][k], nxt[f[i][j - 1][k]][ss[2][j] - 'a']);
if (k)
f[i][j][k] =
min(f[i][j][k], nxt[f[i][j][k - 1]][ss[3][k] - 'a']);
}
} else if (num == 2) {
ss[2][++y] = c[0];
for (int j = y; j <= y; j++)
for (int i = 0; i <= x; i++)
for (int k = 0; k <= z; k++) {
if (i + j + k) f[i][j][k] = n + 1;
if (i)
f[i][j][k] =
min(f[i][j][k], nxt[f[i - 1][j][k]][ss[1][i] - 'a']);
if (j)
f[i][j][k] =
min(f[i][j][k], nxt[f[i][j - 1][k]][ss[2][j] - 'a']);
if (k)
f[i][j][k] =
min(f[i][j][k], nxt[f[i][j][k - 1]][ss[3][k] - 'a']);
}
} else {
ss[3][++z] = c[0];
for (int k = z; k <= z; k++)
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++) {
if (i + j + k) f[i][j][k] = n + 1;
if (i)
f[i][j][k] =
min(f[i][j][k], nxt[f[i - 1][j][k]][ss[1][i] - 'a']);
if (j)
f[i][j][k] =
min(f[i][j][k], nxt[f[i][j - 1][k]][ss[2][j] - 'a']);
if (k)
f[i][j][k] =
min(f[i][j][k], nxt[f[i][j][k - 1]][ss[3][k] - 'a']);
}
}
} else {
if (num == 1)
--x;
else if (num == 2)
--y;
else
--z;
}
printf("%s\n", f[x][y][z] > n ? "NO" : "YES");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
unordered_set<long long> s, s2;
const long long mod = 998244353;
long long c = 0;
bool vis[300005];
int main() {
long long n, t = 1, m, n2, u, v;
while (t--) {
cin >> n;
long long a[n];
map<long long, long long> m;
bool flag = true;
for (int i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
for (int i = 1; i < n; i++) {
if (a[i] != a[i - 1]) flag = false;
}
if (flag && n % 2 == 0) {
if (a[0] == n / 2) {
cout << "Possible\n";
for (int i = 1; i <= n / 2; i++) cout << "1 ";
for (int i = 1; i <= n / 2; i++) cout << "2 ";
} else if (a[0] == 0) {
cout << "Possible\n";
for (int i = 1; i <= n; i++) cout << "1 ";
} else {
cout << "Impossible";
}
return 0;
}
for (auto it : m) {
if (it.second < (n - it.first) || it.second % (n - it.first) != 0) {
cout << "Impossible" << endl;
return 0;
}
}
cout << "Possible\n";
map<long long, long long> as;
map<long long, long long> m2;
long long coun = 0;
long long ans[n];
for (int i = 0; i < n; i++) {
if (m2.find(a[i]) == m2.end()) {
++coun;
ans[i] = coun;
m2[a[i]] = coun;
as[a[i]]++;
} else {
if (as[a[i]] % (n - a[i]) == 0) {
coun++;
m2[a[i]] = coun;
}
ans[i] = m2[a[i]];
as[a[i]]++;
}
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long qr() {
long long x = 0, f = 1;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') f = -1;
for (; isdigit(ch); x = x * 10 + ch - 48, ch = getchar())
;
return x * f;
}
const int mod = 1e9 + 7;
long long ans, f[2019];
int n, D, a[2019];
vector<int> g[2019];
void dfs(int u, int ff, int id) {
f[u] = 1;
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (v == ff || a[v] > a[id] || (a[v] == a[id] && id < v) ||
a[id] - a[v] > D)
continue;
dfs(v, u, id);
f[u] = f[u] * (f[v] + 1) % mod;
}
}
int main() {
D = qr(), n = qr();
for (int i = 1; i <= n; ++i) a[i] = qr();
for (int i = 2; i <= n; ++i) {
int x = qr(), y = qr();
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; ++i) {
memset(f, 0, sizeof f);
dfs(i, 0, i);
ans = (ans + f[i]) % mod;
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int N = 3005, mu = 998244353;
int h[N][N], g[N], f[N], n, a, p, b;
int ksm(int x, int y) {
int ans = 1;
for (; y; y >>= 1, x = x * 1ll * x % mu)
if (y & 1) ans = ans * 1ll * x % mu;
return ans;
}
int main() {
scanf("%d%d%d", &n, &a, &b);
p = a * 1ll * ksm(b, mu - 2) % mu;
h[1][0] = h[1][1] = 1;
for (int i = 2; i <= n; i++) {
h[i][0] = 1;
for (int j = 1; j <= i; j++)
h[i][j] = (1ll * ksm(mu + 1 - p, j) * h[i - 1][j] +
1ll * ksm(p, i - j) * h[i - 1][j - 1]) %
mu;
}
for (int i = 1; i <= n; i++) {
g[i] = 1;
for (int j = 1; j < i; j++) g[i] = (g[i] - 1ll * g[j] * h[i][j]) % mu;
g[i] = (g[i] + mu) % mu;
}
for (int i = 2; i <= n; i++) {
f[i] = i * 1ll * (i - 1) / 2 % mu * g[i] % mu * h[i][i] % mu;
for (int j = 1; j < i; j++)
f[i] = (f[i] + (f[j] + f[i - j] + 1ll * j * (j - 1) / 2 + j * (i - j)) %
mu * g[j] % mu * h[i][j] % mu) %
mu;
f[i] = 1ll * f[i] * ksm(mu + 1 - g[i] * 1ll * h[i][i] % mu, mu - 2) % mu;
}
printf("%d\n", f[n]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long i, j, n, p, h, l, k, g, c[1000], a[1000], b[1000];
cin >> n >> p;
for (k = 0; k <= n; k++) {
c[k] = 0;
}
for (i = 0; i < p; i++) {
cin >> a[i];
}
cin >> h;
for (j = 0; j < h; j++) {
cin >> b[j];
}
for (i = 0; i < p; i++) {
c[a[i]]++;
}
for (j = 0; j < h; j++) {
c[b[j]]++;
}
for (k = 1; k <= n; k++) {
if (c[k] == 0) {
cout << "Oh, my keyboard!" << endl;
return 0;
}
}
cout << "I become the guy." << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back({x, i});
}
sort(v.rbegin(), v.rend());
set<int> s;
queue<int> q;
for (int i = 0; i < n; i++) {
s.insert(v[i].second);
q.push(v[i].second);
}
string ans(n, '0');
int turn = 0;
while (!s.empty()) {
while (!s.count(q.front())) {
q.pop();
}
int idx = q.front();
q.pop();
vector<int> temp;
auto it = s.find(idx);
for (int i = 0; i <= k; i++) {
if (it == s.end()) {
break;
}
temp.push_back(*it);
ans[*it] = '1' + turn;
it++;
}
it = s.find(idx);
for (int i = 0; i <= k; i++) {
temp.push_back(*it);
ans[*it] = '1' + turn;
if (it == s.begin()) {
break;
}
it--;
}
for (int x : temp) {
s.erase(x);
}
turn ^= 1;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
template <typename T, typename U>
ostream& operator<<(ostream& o, const pair<T, U>& p) {
return o << "(" << p.first << "," << p.second << ")";
}
template <typename T, typename U>
ostream& operator<<(ostream& o, const map<T, U>& m) {
o << "{";
for (const pair<T, U>& p : m) o << p.first << ": " << p.second << ",";
return o << "}";
}
template <typename T>
ostream& operator<<(ostream& o, const set<T>& s) {
o << "{";
for (const T& e : s) o << s << ",";
return o << "}";
}
template <typename T>
ostream& operator<<(ostream& o, const vector<T>& v) {
o << "[";
for (const T& x : v) o << x << ",";
return o << "]";
}
template <typename T>
ostream& operator<<(ostream& o, const vector<vector<T>>& v) {
o << "[";
for (const vector<T>& x : v) o << x << ",\n";
return o << "]";
}
signed main() {
int n;
cin >> n;
vi xs(n);
for (int& xi : xs) cin >> xi;
sort(xs.begin(), xs.end());
auto last = unique(xs.begin(), xs.end());
xs.erase(last, xs.end());
int a, b;
cin >> a >> b;
vi biggestdiv(a - b + 1, 2);
for (int xi : xs) {
for (int m = (b == 0 ? 0 : b - 1 + (xi - (b - 1) % xi)); m <= a; m += xi) {
biggestdiv[m - b] = xi;
}
}
set<pii, greater<pii>> pq;
for (int i = b; i < a; ++i) {
pq.insert({i + biggestdiv[i - b] - 1, i});
}
int steps = 0;
int curr = a;
while (curr > b) {
int mini = curr;
while (!pq.empty() && pq.begin()->first >= curr) {
int dest = pq.begin()->second;
if (dest >= b && dest < mini) mini = dest;
pq.erase(pq.begin());
}
assert(mini <= curr - 1 && mini >= b);
curr = mini;
++steps;
}
cout << steps << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool vis[1010];
int n;
int *arr, cur = 0;
bool check() {
for (int i = 0; i < n; ++i)
if (!vis[i]) return false;
return true;
}
int main() {
memset(vis, false, sizeof vis);
cin >> n;
arr = new int[n];
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
int sol = 0, idx = 0;
while (true) {
for (int i = 0; i < n; ++i) {
if (!vis[i] && cur >= arr[i]) {
++cur;
vis[i] = true;
}
}
if (check()) break;
++sol;
for (int i = n - 1; i >= 0; --i) {
if (!vis[i] && cur >= arr[i]) {
++cur;
vis[i] = true;
}
}
if (check()) break;
++sol;
}
cout << sol << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int MAXN = 2E5 + 100;
struct node {
int to, next;
} e[2 * MAXN];
int tol = 0;
int head[MAXN];
void add(int u, int v) {
e[++tol].to = v, e[tol].next = head[u], head[u] = tol;
e[++tol].to = u, e[tol].next = head[v], head[v] = tol;
}
int c[MAXN];
pair<int, int> dfs(int u, int fa, int d) {
pair<int, int> tmp = make_pair(d, u), t;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa) continue;
if (c[u] == c[v])
t = dfs(v, u, d);
else
t = dfs(v, u, d + 1);
tmp = max(tmp, t);
}
return tmp;
}
int main() {
int n;
while (~scanf("%d", &n)) {
tol = 0;
for (int i = 1; i < n + 1; i++) scanf("%d", &c[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
}
pair<int, int> t = dfs(1, -1, 0);
pair<int, int> tt = dfs(t.second, -1, 0);
printf("%d\n", (tt.first + 1) / 2);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const double PI = 3.141592653589793238463;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int x;
cin >> x;
int y[x + 1];
for (int i = 1; i <= x; i++) cin >> y[i];
long long ans = 0, c = 1, l = y[1];
for (int i = 2; i <= x; i++) {
if (l == y[i])
c++;
else {
ans += (c * (c + 1)) / 2;
c = 1;
l = y[i];
}
}
ans += (c * (c + 1)) / 2;
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long nt;
cin >> nt;
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
long long hdif = x2 - x1;
long long vdif = y2 - y1;
string st;
cin >> st;
long long p = st.length();
long long s = 0, n = 0, e = 0, w = 0;
for (int i = 0; i < p; i++) {
if (st[i] == 'N')
n += 1;
else if (st[i] == 'S')
s -= 1;
else if (st[i] == 'E')
e += 1;
else
w -= 1;
if (hdif >= 0 && vdif >= 0) {
if (e >= hdif && n >= vdif) {
cout << (i + 1) << endl;
return 0;
}
}
if (hdif >= 0 && vdif <= 0) {
if (e >= hdif && s <= vdif) {
cout << (i + 1) << endl;
return 0;
}
}
if (hdif <= 0 && vdif >= 0) {
if (w <= hdif && n >= vdif) {
cout << (i + 1) << endl;
return 0;
}
}
if (hdif <= 0 && vdif <= 0) {
if (w <= hdif && s <= vdif) {
cout << (i + 1) << endl;
return 0;
}
}
}
cout << "-1" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int maxn = 1000 + 10;
const int maxm = 10000 + 10;
struct Line {
int u, v, w;
Line() {}
Line(int u, int v, int w) : u(u), v(v), w(w) {}
} E[maxm];
struct Edge {
int next, v, w;
Edge() {}
Edge(int next, int v, int w) : next(next), v(v), w(w) {}
} e[maxm << 1];
struct Node {
int pos;
long long val;
Node() {}
Node(int pos, long long val) : pos(pos), val(val) {}
bool operator<(const Node& tmp) const { return val < tmp.val; }
};
int n, m;
int S, T, L;
int head[maxn], cnt;
int st[maxm], top;
long long dis[maxn];
struct Heap {
Node heap[maxm];
int sz;
inline void push(Node x) {
heap[++sz] = x;
int now = sz, next;
while (now > 1) {
next = now >> 1;
if (heap[next] < heap[now]) break;
swap(heap[next], heap[now]);
now = next;
}
}
inline void pop() {
heap[1] = heap[sz--];
int now = 1, next;
while ((next = now << 1) <= sz) {
if (heap[next | 1] < heap[next] && next < sz) next++;
if (heap[now] < heap[next]) break;
swap(heap[now], heap[next]);
now = next;
}
}
inline Node top() { return heap[1]; }
inline bool empty() { return sz == 0; }
} q;
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
inline void AddEdge(int u, int v, int w) {
e[++cnt] = Edge(head[u], v, w);
head[u] = cnt;
e[++cnt] = Edge(head[v], u, w);
head[v] = cnt;
}
inline void Dijkstra() {
while (!q.empty()) q.pop();
for (int i = 1; i <= n; i++) dis[i] = 1LL << 62;
dis[S] = 0;
q.push(Node(S, 0));
while (!q.empty()) {
Node cur = q.top();
q.pop();
int u = cur.pos;
if (u == T) break;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].v;
if (dis[u] + e[i].w < dis[v]) {
dis[v] = dis[u] + e[i].w;
q.push(Node(v, dis[v]));
}
}
}
}
inline long long check(long long tot) {
for (int i = 1, tmp; i <= top; i++) {
tmp = 1 + min(tot, (long long)1e9);
e[st[i] << 1].w = e[st[i] << 1 | 1].w = tmp;
tot -= tmp - 1;
}
Dijkstra();
return dis[T];
}
int main() {
if (fopen("D.in", "r") != NULL) {
freopen("D.in", "r", stdin);
freopen("D.out", "w", stdout);
}
n = read(), m = read();
L = read(), S = read() + 1, T = read() + 1;
cnt = 1;
for (int i = 1; i <= m; i++) {
E[i].u = read() + 1, E[i].v = read() + 1;
if ((E[i].w = read()) == 0) st[++top] = i;
AddEdge(E[i].u, E[i].v, E[i].w);
}
long long l = 0, r = (long long)INF * top;
if (check(l) > L || check(r) < L) return 0 * puts("NO");
while (l + 1 < r) {
long long mid = (l + r) >> 1;
if (check(mid) <= L)
l = mid;
else
r = mid;
}
check(l);
puts("YES");
for (int i = 1; i <= m; i++)
printf("%d %d %d\n", E[i].u - 1, E[i].v - 1, e[i << 1].w);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long int mod = 1e9 + 7;
set<int> X, Y;
int fuck[13];
int query(int u, int v) {
cout << "? " << u << " " << v << endl;
char x;
cin >> x;
if (x == '>')
return 1;
else
return -1;
}
void findins(int x) {
if (X.size() < 2)
X.insert(x);
else
Y.insert(x);
}
int findXmin(void) {
int cur = (*X.begin());
set<int>::iterator it = X.begin();
it++;
for (; it != X.end(); it++) {
int res = query(cur, (*it));
if (res == 1) cur = (*it);
}
return cur;
}
int findYmin(void) {
int cur = (*Y.begin());
set<int>::iterator it = Y.begin();
it++;
for (; it != Y.end(); it++) {
int res = query(cur, (*it));
if (res == 1) cur = (*it);
}
return cur;
}
void solve(void) {
int n, i;
cin >> n;
X.clear();
Y.clear();
for (i = 1; i <= (n + 1) / 2; i++) X.insert(i);
for (i = (n + 1) / 2 + 1; i <= n; i++) Y.insert(i);
for (i = n + 1; i <= 2 * n; i++) {
findins(i);
int T1 = findXmin();
int T2 = findYmin();
int res = query(T1, T2);
if (res == 1) Y.erase(T2);
if (res == -1) X.erase(T1);
}
cout << "!" << endl;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int tc;
cin >> tc;
while (tc--) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
const long long INF = 1e18;
long long S[maxn], dp[maxn];
int a[maxn], n;
int main() {
cin >> n;
S[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
S[i] = S[i - 1] + a[i];
}
dp[n] = 0;
long long cur = S[n] - dp[n];
for (int i = n - 1; i >= 1; i--) {
dp[i] = cur;
cur = max(S[i] - dp[i], cur);
}
cout << dp[1] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
string r = "";
for (long long int i = 1; i <= 50000; i++) {
r += "1";
}
while (t--) {
long long int n;
cin >> n;
long long int ans = n / 2;
string d = r.substr(0, ans);
if (n & 1) {
cout << "7" << d.substr(1) << "\n";
} else
cout << d << "\n";
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int N=200005;
int prime[1100000],primesize;
bool isprime[11000000];
ll f[N],invf[N];
ll inv[N];
void getlist(int listsize){
memset(isprime,1,sizeof(isprime));
isprime[1]=false;
for(int i=2;i<=listsize;i++){
if(isprime[i])prime[++primesize]=i;
for(int j=1;j<=primesize&&i*prime[j]<=listsize;j++) {
isprime[i*prime[j]]=false;
if(i%prime[j]==0) break;
}
}
}
void extend_gcd(ll a, ll b, ll& d, ll& x, ll& y)
{
if(!b){ d = a; x = 1; y = 0; }
else { extend_gcd(b, a%b,d, y, x); y -= x*(a/b);}
}
void ni(int n)
{
inv[0] = inv[1] = 1;
for(int i = 2; i <= n; i++)
{
inv[i] = (mod - (mod/i))*inv[mod%i]%mod;
}
}
ll fpow(ll a,ll k){
ll res=1;
while(k){
if(k&1) res=(res*a)%mod;
k>>=1;
a=a*a%mod;
//cout<<1<<endl;
}
return res;
}
ll mm(ll a,ll b){
ll ret=0;
for(a%=mod;b;b>>=1){
if(b&1){ret+=a;if(ret>=mod)ret-=mod;}
a<<=1;if(a>=mod)a-=mod;
}
return ret;
}
void init(int n){
f[0]=1;
for(int i=1;i<=n;++i){
f[i]=f[i-1]*i%mod;
}
invf[n]=fpow(f[n],mod-2);
for(int i=n-1;i>=0;--i){
invf[i]=invf[i+1]*(i+1)%mod;
}
}
ll C(int n,int k){
if(k<0 || k>n) return 0;
return f[n]*invf[k]%mod*invf[n-k]%mod;
}
char s[2005][2005];
void solve(){
ll n,m;
cin>>n>>m;
for(int i=1;i<=n;i++){
cin>>s[i]+1;
}
ll tot=0;
int flag=0;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(s[i][j]=='#'){
tot++;
}
else{
flag=1;
}
}
}
ll ans=fpow(2,tot);
if(!flag){
ans--;
ans+=mod;
ans%=mod;
}
cout<<ans<<endl;
}
int main(){
ios::sync_with_stdio(false);cin.tie(0);
// freopen("1.in","r",stdin);
// getlist(1e7);
int t=1;
cin>>t;
while(t--){
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[103];
int temp[103];
string b[103];
bool flag[103];
int cou[103];
int coun = 0;
int n, m;
void mergesort(int *a, int *b, int n) {
int i0, i1, i, iRight, iEnd, width, j;
for (width = 1; width < n; width *= 2)
for (i = 0; i < n; i += width * 2) {
i0 = i;
i1 = iRight = min(i + width, n);
iEnd = min(i + width * 2, n);
for (j = i; j < iEnd; j++)
if (i0 < iRight && (i1 == iEnd || a[i0] <= a[i1]))
b[j] = a[i0++];
else
b[j] = a[i1++];
for (j = i; j < iEnd; j++) a[j] = b[j];
}
}
void mergesort2(int *a, int *b, int n) {
int i0, i1, i, iRight, iEnd, width, j;
for (width = 1; width < n; width *= 2)
for (i = 0; i < n; i += width * 2) {
i0 = i;
i1 = iRight = min(i + width, n);
iEnd = min(i + width * 2, n);
for (j = i; j < iEnd; j++)
if (i0 < iRight && (i1 == iEnd || a[i0] >= a[i1]))
b[j] = a[i0++];
else
b[j] = a[i1++];
for (j = i; j < iEnd; j++) a[j] = b[j];
}
}
int main() {
cin >> n >> m;
int i, j;
for (i = 0; i < n; i++) cin >> a[i];
mergesort(a, temp, n);
for (i = 0; i < m; i++) cin >> b[i];
int mini = 0;
int maxi = 0;
for (i = 0; i < m; i++) {
if (!flag[i]) {
flag[i] = true;
cou[coun] = 1;
for (j = 0; j < m; j++) {
if (!flag[j] && b[j] == b[i]) {
flag[j] = true;
cou[coun]++;
}
}
coun++;
}
}
mergesort2(cou, temp, coun);
for (i = 0; i < coun; i++) mini += cou[i] * a[i];
for (i = 0; i < coun; i++) maxi += cou[i] * a[n - 1 - i];
printf("%d %d\n", mini, maxi);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, k, ans = 1, mod = 1000000007, num = 1;
cin >> n >> k;
long long a[n / k];
for (int i = 0; i < n / k; i++) {
cin >> a[i];
}
for (int i = 0; i < k - 1; i++) {
num *= 10;
}
for (int i = 0; i < n / k; i++) {
long long b;
cin >> b;
long long tmp = (10 * num - 1) / a[i] + 1;
if (b == 0) {
tmp -= (num - 1) / a[i] + 1;
} else {
tmp -= ((b + 1) * num - 1) / a[i] - (b * num - 1) / a[i];
}
(ans *= tmp) %= mod;
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using lli = long long int;
using namespace std;
void solve() {
string s;
cin >> s;
if (s.size() == 2) {
cout << s << endl;
return;
}
cout << s[0];
lli len = s.size();
for (lli i = 1; i < len; i += 2) {
cout << s[i];
}
cout << endl;
return;
}
int main() {
lli test_case;
cin >> test_case;
while (test_case--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long maxn = 1 << 21;
unsigned long long n, m, a[maxn], b[maxn], cnt[maxn];
inline void FWT(unsigned long long *f, unsigned long long op) {
for (unsigned long long Mid = 1; Mid < m; Mid <<= 1)
for (unsigned long long i = 0; i < m; i += (Mid << 1))
for (unsigned long long j = 0; j < Mid; ++j)
f[i + j + Mid] += op * f[i + j];
}
signed main() {
scanf("%llu", &n);
for (unsigned long long i = (0), _end_ = ((1 << n) - 1); i <= _end_; ++i) {
cnt[i] = 1;
for (unsigned long long j = 0; j < n; ++j)
if ((i >> j) & 1) cnt[i] *= 4;
}
getchar();
for (unsigned long long i = (0), _end_ = ((1 << n) - 1); i <= _end_; ++i) {
char c = getchar();
a[i] = (c - '0') * cnt[i];
}
getchar();
for (unsigned long long i = (0), _end_ = ((1 << n) - 1); i <= _end_; ++i) {
char c = getchar();
b[i] = (c - '0') * cnt[i];
}
m = 1 << n;
FWT(a, 1);
FWT(b, 1);
for (unsigned long long i = (0), _end_ = ((1 << n) - 1); i <= _end_; ++i)
a[i] = a[i] * b[i];
FWT(a, -1);
for (unsigned long long i = (0), _end_ = ((1 << n) - 1); i <= _end_; ++i)
printf("%llu", (a[i] / cnt[i]) % 4);
puts("");
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
string a = "abcdefghijklmnopqrstuvwxyz";
set<int> maxes;
for (int i = 0; i < a.length(); i++) {
if (s.find(a[i]) == string::npos) {
continue;
} else {
int max = 0;
int first = -1, current = -1, next = -1, last = -1;
for (int j = 0; j < s.length(); j++) {
if (s[j] == a[i]) {
last = j;
if (first == -1) {
first = j;
current = first;
} else if (next == -1) {
next = j;
}
if (next - current - 1 > max && current != -1 && next != -1) {
max = next - current - 1;
}
if (first != -1 && next != -1) {
current = next;
next = -1;
}
}
}
if (first > max) {
max = first;
}
if ((s.length() - 1) - last > max) {
max = (s.length() - 1) - last;
}
maxes.insert(max + 1);
}
}
for (auto m : maxes) {
cout << m << endl;
break;
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000010LL;
const int mod = 1000000007;
const int MAXN = 1010;
int n, m, u, v, x, y, t, a, b, ans;
int A[MAXN][MAXN];
bool mark[MAXN][MAXN];
bool check(int x) {
memset(mark, 0, sizeof(mark));
vector<int> vec;
for (int i = 0; i < n; i++) {
vec.clear();
for (int j = 0; j < m; j++) {
if (A[i][j] < x) continue;
for (int k : vec) {
if (mark[k][j]) return true;
mark[k][j] = true;
}
vec.push_back(j);
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> A[i][j];
int dwn = 0, up = 1e9 + 1;
while (up - dwn > 1) {
int mid = (dwn + up) / 2;
if (check(mid))
dwn = mid;
else
up = mid;
}
cout << dwn << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
vector<long long> fac;
vector<long long> ofac;
long long maxk = 45;
long long pw(long long x, long long st) {
if (st == 0) return 1;
if (st % 2 == 0) {
long long y = pw(x, st / 2);
return (y * y) % mod;
}
return (x * pw(x, st - 1)) % mod;
}
long long geto(long long x) { return pw(x, mod - 2); }
long long cnk(long long n, long long k) {
if (n < k || n < 0) return 0;
return ((fac[n] * ofac[k]) % mod * ofac[n - k]) % mod;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
vector<pair<long long, long long>> gr(n);
vector<pair<long long, long long>> ban(m);
vector<long long> sob(n + 2, 0);
vector<long long> cnt(n + 2, 0);
vector<vector<long long>> pref(maxk, vector<long long>(n + 5, 0));
fac = vector<long long>(n + 10, 1);
ofac = vector<long long>(n + 10, 1);
for (long long i = 1; i < n + 10; i++) {
fac[i] = (fac[i - 1] * i) % mod;
}
for (long long i = 0; i < n + 10; i++) {
ofac[i] = geto(fac[i]);
}
for (long long i = 0; i < n; i++) {
cin >> gr[i].first >> gr[i].second;
sob[gr[i].first]++;
sob[gr[i].second + 1]--;
}
long long now = 0;
for (long long i = 0; i <= n; i++) {
now += sob[i];
cnt[i] = now;
}
for (long long j = 0; j < maxk; j++) {
for (long long i = 0; i <= n; i++) {
if (j > i) {
pref[j][i + 1] = pref[j][i];
continue;
}
pref[j][i + 1] = (pref[j][i] + cnk(cnt[i] - j, i - j)) % mod;
}
}
for (long long i = 0; i < m; i++) {
cin >> ban[i].first >> ban[i].second;
ban[i].first--, ban[i].second--;
}
long long ans = 0;
for (long long i = 0; i < (1 << m); i++) {
set<long long> gg;
long long l = 1, r = n, sz;
for (long long j = 0; j < m; j++) {
if ((i | (1 << j)) != i) continue;
gg.insert(ban[j].first);
gg.insert(ban[j].second);
}
sz = (long long)gg.size();
for (auto x : gg) {
l = max(l, gr[x].first);
r = min(r, gr[x].second);
}
if (r < l) continue;
if ((__builtin_popcount(i)) % 2 == 0)
ans = (ans + (pref[sz][r + 1] - pref[sz][l]) + mod) % mod;
else {
ans = (ans - (pref[sz][r + 1] - pref[sz][l]) + mod) % mod;
}
}
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int MM = 998244353;
const long double PI = acos(-1);
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << '(' << p.first << "," << p.second << ')';
}
const int MOD = MM;
struct Mint {
int val;
Mint(long long v = 0) {
if (v < 0) v = v % MOD + MOD;
if (v >= MOD) v %= MOD;
val = v;
}
static int mod_inv(int a, int m = MOD) {
int g = m, r = a, x = 0, y = 1;
while (r != 0) {
int q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + m : x;
}
explicit operator int() const { return val; }
Mint &operator+=(const Mint &other) {
val += other.val;
if (val >= MOD) val -= MOD;
return *this;
}
Mint &operator-=(const Mint &other) {
val -= other.val;
if (val < 0) val += MOD;
return *this;
}
static unsigned fast_mod(uint64_t x, unsigned m = MOD) {
return x % m;
unsigned x_high = x >> 32, x_low = (unsigned)x;
unsigned quot, rem;
asm("divl %4\n" : "=a"(quot), "=d"(rem) : "d"(x_high), "a"(x_low), "r"(m));
return rem;
}
Mint &operator*=(const Mint &other) {
val = fast_mod((uint64_t)val * other.val);
return *this;
}
Mint &operator/=(const Mint &other) { return *this *= other.inv(); }
friend Mint operator+(const Mint &a, const Mint &b) { return Mint(a) += b; }
friend Mint operator-(const Mint &a, const Mint &b) { return Mint(a) -= b; }
friend Mint operator*(const Mint &a, const Mint &b) { return Mint(a) *= b; }
friend Mint operator/(const Mint &a, const Mint &b) { return Mint(a) /= b; }
Mint &operator++() {
val = val == MOD - 1 ? 0 : val + 1;
return *this;
}
Mint &operator--() {
val = val == 0 ? MOD - 1 : val - 1;
return *this;
}
Mint operator++(int32_t) {
Mint before = *this;
++*this;
return before;
}
Mint operator--(int32_t) {
Mint before = *this;
--*this;
return before;
}
Mint operator-() const { return val == 0 ? 0 : MOD - val; }
bool operator==(const Mint &other) const { return val == other.val; }
bool operator!=(const Mint &other) const { return val != other.val; }
Mint inv() const { return mod_inv(val); }
Mint power(long long p) const {
assert(p >= 0);
Mint a = *this, result = 1;
while (p > 0) {
if (p & 1) result *= a;
a *= a;
p >>= 1;
}
return result;
}
friend ostream &operator<<(ostream &stream, const Mint &m) {
return stream << m.val;
}
friend istream &operator>>(istream &stream, Mint &m) {
return stream >> m.val;
}
};
const int N = 100005;
int lpf[N], mobius[N];
void _lpf_() {
lpf[1] = 1;
for (int i = 2; i <= N - 2; ++i) {
if (!lpf[i]) {
for (int j = i; j <= N - 2; j += i) {
if (!lpf[j]) lpf[j] = i;
}
}
}
}
void Mobius() {
mobius[1] = 1;
for (int i = 2; i <= N - 2; ++i) {
if (lpf[i / lpf[i]] == lpf[i])
mobius[i] = 0;
else
mobius[i] = -1 * mobius[i / lpf[i]];
}
}
int f[N];
int _runtimeTerror_() {
_lpf_();
Mobius();
int n;
cin >> n;
Mint ans = 0;
for (int i = 1; i <= n; ++i) {
int x, y;
cin >> x >> y;
f[x] += y;
}
mobius[1] = 1;
for (int i = 1; i <= 100000; ++i) {
if (mobius[i] == 0) continue;
long long tx = 0;
Mint sum = 0;
Mint sq = 0;
for (int j = i; j <= 100000; j += i) {
tx += f[j];
sum += Mint(j) * f[j];
sq += Mint(j) * Mint(j) * f[j];
}
if (tx >= 2) {
Mint u = 0;
u += sq * (tx - 1) * Mint(2).power(tx - 2);
u += tx * Mint(2).power(tx - 2) * (sum * sum - sq) / 2;
ans += u * mobius[i];
}
}
cout << ans << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
return 0;
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.