solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 998244353;
const ll root = 62;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll binpow(ll a, ll b) {
ll res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
ll modInv(ll a) { return binpow(a, MOD - 2); }
const double PI = atan(1);
const double eps = 1e-10;
const int INF = 0x3f3f3f3f;
const int NINF = 0xc0c0c0c0;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const ll NINFLL = 0xc0c0c0c0c0c0c0c0;
ll x;
vector<array<ll, 3>> ans;
ll add(ll a, ll b) {
ans.push_back({a, 1, b});
return a + b;
}
ll xorr(ll a, ll b) {
ans.push_back({a, 0, b});
return a ^ b;
}
int main() {
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
cin.tie(0)->sync_with_stdio(0);
cin >> x;
if (x % 4 == 3) {
add(x, add(x, x));
x *= 3;
}
int highbit = 0;
ll sv = x;
while (sv) {
sv /= 2;
highbit++;
}
ll curr = x;
for (auto i = (0); i < (highbit - 1); ++i) {
curr = add(curr, curr);
}
ll temp = curr;
temp = add(curr, x);
temp = xorr(temp, xorr(curr, x));
while (temp > 1) {
if (x > temp) {
x = xorr(x, temp);
}
sv = x;
for (auto i = (0); i < (highbit - 1); ++i) {
sv = add(sv, sv);
if (sv > temp) {
sv = xorr(sv, temp);
}
}
highbit--;
temp = sv;
}
cout << (ans.size()) << "\n";
for (auto p : ans) {
for (auto i = (0); i < (3); ++i) {
if (i == 1) {
cout << (p[i] == 1 ? " + " : " ^ ");
} else {
cout << p[i];
}
}
cout << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to;
long long u;
int next;
} e[300005];
int head[100005];
int ans;
void add(int x, int y, long long u) {
e[ans].to = y;
e[ans].u = u;
e[ans].next = head[x];
head[x] = ans++;
e[ans].to = x;
e[ans].u = u;
e[ans].next = head[y];
head[y] = ans++;
}
int n;
long long dp1[100005];
long long dp2[100005];
long long d[100005];
void dfs1(int x, int f) {
dp1[x] = 0;
for (int i = head[x]; i != 0; i = e[i].next) {
int y = e[i].to;
if (y == f) continue;
long long u = e[i].u;
dfs1(y, x);
dp1[x] = max(dp1[x], dp1[y] + u);
}
}
int sta[100005];
int top;
long long su[100005];
long long lm[100005];
long long rm[100005];
void dfs2(int x, int f) {
top = 0;
for (int i = head[x]; i != 0; i = e[i].next) {
int y = e[i].to;
if (y == f) continue;
sta[++top] = y;
su[top] = e[i].u;
}
lm[0] = 0;
for (int i = 1; i <= top; i++) {
int y = sta[i];
long long u = su[i];
lm[i] = max(lm[i - 1], u + dp1[y]);
}
rm[top + 1] = 0;
for (int i = top; i >= 1; i--) {
int y = sta[i];
long long u = su[i];
rm[i] = max(rm[i + 1], u + dp1[y]);
}
for (int i = 1; i <= top; i++) {
int y = sta[i];
long long u = su[i];
dp2[y] = max(max(lm[i - 1], rm[i + 1]), dp2[x]) + u;
}
for (int i = head[x]; i != 0; i = e[i].next) {
int y = e[i].to;
if (y == f) continue;
dfs2(y, x);
}
}
void gaod() {
dfs1(1, -1);
dp2[1] = 0;
dfs2(1, -1);
for (int i = 1; i <= n; i++) {
d[i] = max(dp1[i], dp2[i]);
}
}
int b[100005];
int c[100005];
int fin(long long p) {
int l = 1;
int r = top;
while (l < r) {
int mid = (l + r) / 2;
if (d[sta[mid]] >= p) {
r = mid;
} else {
l = mid + 1;
}
}
return l;
}
void dfs3(int x, int f, long long l) {
for (int i = head[x]; i != 0; i = e[i].next) {
int y = e[i].to;
if (f == y) continue;
sta[++top] = y;
int t = fin(d[y] - l);
c[top]++;
c[t - 1]--;
dfs3(y, x, l);
b[sta[top]] = c[top];
c[top - 1] += c[top];
c[top] = 0;
top--;
}
}
int main() {
ans = 1;
memset(head, 0, sizeof(head));
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
long long u;
cin >> x >> y >> u;
add(x, y, u);
}
gaod();
int s;
long long mi = (1LL << 60);
for (int i = 1; i <= n; i++) {
if (d[i] < mi) {
mi = d[i];
s = i;
}
}
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
memset(b, 0, sizeof(b));
memset(c, 0, sizeof(c));
top = 0;
long long l;
cin >> l;
sta[++top] = s;
dfs3(s, -1, l);
b[s] = c[1] + 1;
int ma = 0;
for (int i = 1; i <= n; i++) {
ma = max(ma, b[i]);
}
cout << ma << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10, mod = 1e9 + 7;
inline int ad(int x, int y) {
int ans = x + y;
if (ans > mod) ans -= mod;
return ans;
}
inline int mu(int x, int y) { return 1LL * x * y % mod; }
inline int wop(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = mu(ret, x);
y >>= 1;
x = mu(x, x);
}
return ret;
}
int fact[maxn], inv[maxn], lst[maxn], pr[maxn], cnt[maxn];
int num[maxn][20];
int pw[maxn], pww[maxn];
inline void prep() {
int n = maxn - 5;
fact[0] = 1;
for (int i = 1; i < n; i++) fact[i] = mu(fact[i - 1], i);
for (int i = 0; i < n; i++) inv[i] = wop(fact[i], mod - 2);
pr[0] = pr[1] = 1;
for (int i = 2; i < 300005; i++) {
if (pr[i] == 0) {
lst[i] = i;
for (int j = i * 2; j < 300005; j += i) lst[j] = i, pr[j] = 1;
}
}
for (int i = 1; i < n; i++) pw[i] = ad(mu(pw[i - 1], 2), 1);
pww[0] = 1;
for (int i = 1; i < n; i++) pww[i] = ad(pww[i - 1], pww[i - 1]);
}
inline int C(int r, int n) {
if (r < 0 || r > n) return 0;
return mu(mu(fact[n], inv[n - r]), inv[r]);
}
inline int cal(int x, int y) {
if (x < 0 || y < 1) return 0;
if (x == 0) return pw[y];
int ans = 0;
for (int i = 1; i <= y; i++)
ans = ad(ans, mu(pw[i], C(x - 1, x - 1 + y - i)));
return ans;
}
inline int f(int x, int y) {
if (y <= x) return cal(x, y);
int oth = cal(y, x);
int eq = 0;
for (int i = 0; i <= min(x, y); i++) eq = ad(eq, mu(C(i, x), C(i, y)));
oth = ad(oth, eq);
return ad(pww[x + y], mod - oth);
}
inline int ff(int x, int y) { return f(x + 1, y - 1); }
int ps[20], answer[20];
int solve(vector<int> a, bool rev) {
int n = a.size();
for (int i = 1; i <= n; i++) ps[i] = ps[i - 1] + a[i - 1];
int ans = 0;
for (int j = 1; j < n; j++) {
int tmp;
if (rev) tmp = f(ps[j] - 1, ps[n] - ps[j]);
if (!rev) tmp = ff(ps[j] - 1, ps[n] - ps[j]);
answer[j] = tmp;
}
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = i + 1; j < n; j++) sum = ad(sum, answer[j]);
ans = ad(ans, mu(sum, a[i]));
}
return ans;
}
int main() {
prep();
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
cnt[x]++;
}
for (int i = 1; i <= 1e6; i++) {
if (cnt[i] == 0) continue;
int cur = i;
while (cur != 1) {
int p = lst[cur], tav = 0;
while (cur % p == 0) cur /= p, tav++;
num[p][tav] += cnt[i];
}
}
int ans = 0;
for (int i = 2; i <= 300000; i++) {
if (pr[i]) continue;
vector<int> a;
int sum = 0;
for (int j = 1; j < 20; j++) sum += num[i][j];
if (sum == 0) continue;
a.push_back(n - sum);
for (int j = 1; j < 20; j++) a.push_back(num[i][j]);
ans = ad(ans, solve(a, 0));
reverse(a.begin(), a.end());
ans = ad(ans, solve(a, 1));
}
cout << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int num, pos, ans;
} r[2000000 + 5];
bool cmp(node s1, node s2) { return s1.num < s2.num; }
bool cmp2(node s1, node s2) { return s1.pos < s2.pos; }
int n, k, eq, u, v;
int cnt[2000000 + 5];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &r[i].num);
r[i].pos = i;
}
for (int i = 1; i <= k; i++) {
scanf("%d%d", &u, &v);
if (r[u].num > r[v].num) cnt[u]++;
if (r[v].num > r[u].num) cnt[v]++;
}
sort(r + 1, r + n + 1, cmp);
for (int i = 1; i <= n; i++) {
if (r[i].num == r[i - 1].num && i != 1)
eq++;
else
eq = 0;
r[i].ans = i - 1 - eq - cnt[r[i].pos];
}
sort(r + 1, r + n + 1, cmp2);
for (int i = 1; i <= n; i++) printf("%d ", r[i].ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize "trapv"
template <typename T>
void pop_front(std::vector<T> &v) {
if (v.size() > 0) {
v.erase(v.begin());
}
}
template <typename R>
void pop_back(std::vector<R> &v) {
if (v.size() > 0) {
v.erase(v.begin() + v.size() - 1);
}
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
long long int less_than_or_equal_to(vector<long long int> vec,
long long int k) {
sort(vec.begin(), vec.end());
if (vec[0] > k)
return -1;
else if (vec[vec.size() - 1] < k)
return vec[vec.size() - 1];
auto x = lower_bound(vec.begin(), vec.end(), k);
if (k == *x)
return *x;
else {
x--;
return *x;
}
}
bool isPerfectSquare(long double x) {
long double sr = sqrt(x);
return ((sr - floor(sr)) == 0);
}
bool isprime(long long int n) {
if (n <= 1) return false;
for (long long int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
void prime_factors(long long int n) {
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
long long int count = 0;
while (n % i == 0) {
count++;
n = n / i;
}
cout << i << " "
<< "^"
<< " " << count << "\n";
}
}
if (n > 1)
cout << n << " "
<< "^"
<< " " << 1 << "\n";
}
vector<long long int> divisors(long long int n) {
vector<long long int> v;
for (long long int i = 1; i * i <= n; i++) {
if (n % i == 0) {
v.push_back(i);
if ((n / i) != i) v.push_back(n / i);
}
}
return v;
}
long long int power(long long int a, long long int n, long long int m) {
long long int res = 1;
while (n) {
if (n % 2)
res = (res * a) % m, n--;
else
a = (a * a) % m, n /= 2;
}
return res;
}
long long int ts(long long int arr[], int l, int r, int x) {
while (l <= r) {
long long int mid1 = l + (r - l) / 3;
long long int mid2 = r - (r - l) / 3;
if (arr[mid1] == x || arr[mid2] == x) return 1;
if (x < arr[mid1])
r = mid1 - 1;
else if (x > arr[mid2])
l = mid2 + 1;
else {
l = mid1 + 1;
r = mid2 - 1;
}
}
return -1;
}
long long int modulo_inverse(long long int a, long long int m) {
long long int res = power(a, m - 2, m);
return res;
}
long long int crt(long long int num[], long long int rem[], long long int n) {
long long int pp[n];
long long int p = 1;
for (int i = 0; i < n; i++) p *= num[i];
for (int i = 0; i < n; i++) pp[i] = (p / num[i]);
long long int inv[n];
for (int i = 0; i < n; i++) inv[i] = modulo_inverse(pp[i], num[i]);
long long int ans = 0;
for (int i = 0; i < n; i++) ans += pp[i] * inv[i] * rem[i];
return ans;
}
long long int Extended_gcd(long long int a, long long int b, long long int &x,
long long int &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long int x1, y1;
long long int g = Extended_gcd(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return g;
}
long long int count_freq(string &str, string &substr) {
long long int count = 0;
size_t found = str.find(substr, 0);
while (found != string::npos) {
count++;
found = str.find(substr, found + 1);
}
return count;
}
int main() {
auto start = chrono::high_resolution_clock::now();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int t = 1;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int arr[n];
for (long long int i = 0; i < n; i++) cin >> arr[i];
multiset<long long int> odd, even;
for (auto x : arr) {
if (x % 2 == 0)
even.insert(x);
else
odd.insert(x);
}
if (even.size() % 2 == 0 && odd.size() % 2 == 0)
cout << "YES"
<< "\n";
else {
int flag = 0;
for (auto x : odd) {
long long int val = x;
if (even.count(val - 1) || even.count(val + 1)) {
flag = 1;
break;
}
}
if (flag)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
}
auto finish = chrono::high_resolution_clock::now();
cerr << "Time elapsed: "
<< (chrono::duration<long double>(finish - start)).count() << "s\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int nowx[1010], nowy[1010], tarx[1010], tary[1010], n;
int ansx[20 * 1010], ansy[20 * 1010], cnt = 0;
bool ok[1010][1010], tarok[1010][1010];
vector<int> t1, t2;
void sol(vector<int> &t) {
int d = t.size();
if (d <= 3) return;
int nbest = 0, dx = -1, dy = -1;
for (int i = 0; i < d; i++)
for (int j = i + 1; j < d; j++)
if (j != ((i + 1) % t.size()) && j != ((i - 1 + t.size()) % t.size()))
if (tarok[t[i]][t[j]] || tarok[t[j]][t[i]]) {
int tmp = (i - j + d) % d;
if (tmp > (d >> 1)) tmp = d - tmp;
if (tmp > nbest) {
dx = i;
dy = j;
nbest = tmp;
}
}
if (!ok[t[dx]][t[dy]]) {
int a = dy, b = dy;
while (!ok[t[dx]][t[a]] && ((a + 1) % t.size()) != dx)
a = ((a + 1) % t.size());
while (!ok[t[dx]][t[b]] && ((b - 1 + t.size()) % t.size()) != dx)
b = ((b - 1 + t.size()) % t.size());
int c = ((a - 1 + t.size()) % t.size());
bool dir = false;
if (!ok[t[b]][t[c]])
while ((!ok[t[b]][t[c]] || !ok[t[a]][t[c]]) &&
((c - 1 + t.size()) % t.size()) != b) {
if (c == dy) dir = true;
c = ((c - 1 + t.size()) % t.size());
}
if (!(ok[t[a]][t[b]] == true && ok[t[b]][t[a]] == true))
while (1)
;
if (!(dx != ((c - 1 + t.size()) % t.size()) &&
c != ((dx - 1 + t.size()) % t.size())))
while (1)
;
cnt++;
ansx[cnt] = t[a];
ansy[cnt] = t[b];
ok[t[a]][t[b]] = ok[t[b]][t[a]] = false;
ok[t[dx]][t[c]] = ok[t[c]][t[dx]] = true;
while (c != dy && b != dy) {
if (!dir)
a = c;
else
b = c;
c = ((a - 1 + t.size()) % t.size());
dir = false;
if (!ok[t[b]][t[c]])
while ((!ok[t[b]][t[c]] || !ok[t[a]][t[c]]) &&
((c - 1 + t.size()) % t.size()) != b) {
if (c == dy) dir = true;
c = ((c - 1 + t.size()) % t.size());
}
if (!(dx != ((c - 1 + t.size()) % t.size()) &&
c != ((dx - 1 + t.size()) % t.size())))
while (1)
;
if (!(ok[t[a]][t[b]] == true && ok[t[b]][t[a]] == true))
while (1)
;
cnt++;
ansx[cnt] = t[a];
ansy[cnt] = t[b];
ok[t[a]][t[b]] = ok[t[b]][t[a]] = false;
ok[t[dx]][t[c]] = ok[t[c]][t[dx]] = true;
}
}
bool o[n + 10];
for (int i = 0; i < t.size(); i++) o[t[i]] = false;
vector<int> t1, t2;
bool ins = false;
for (int i = 0; i < t.size(); i++) {
if (!ins)
t1.push_back(t[i]);
else
t2.push_back(t[i]);
if (i == dx || i == dy) {
ins ^= 1;
if (!ins)
t1.push_back(t[i]);
else
t2.push_back(t[i]);
}
}
sol(t1);
sol(t2);
}
void dfs(int s) {
if (s > 1000000) return;
dfs(s + 1);
}
int main() {
dfs(1);
scanf("%d", &n);
for (int i = 1; i <= n - 3; i++) {
scanf("%d%d", &nowx[i], &nowy[i]);
ok[nowx[i]][nowy[i]] = ok[nowy[i]][nowx[i]] = true;
}
for (int i = 1; i <= n - 3; i++) {
scanf("%d%d", &tarx[i], &tary[i]);
tarok[tarx[i]][tary[i]] = tarok[tary[i]][tarx[i]] = true;
if (tarx[i] > tary[i]) swap(tarx[i], tary[i]);
}
vector<int> a;
for (int i = 1; i <= n; i++) a.push_back(i);
sol(a);
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) printf("%d %d\n", ansx[i], ansy[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353ll;
const long long int P = 1000000007ll;
const long long int N = 100005ll;
bool cmp(long long int x, long long int y) { return x > y; }
vector<int> g[N], gg[N];
long long int c[N], cc, vis[N], a[N], p[N], cnt[N], w[N], n, m, h, tot, res;
void dfs(int x) {
vis[x] = 1;
for (auto v : g[x])
if (!vis[v]) dfs(v);
p[++tot] = x;
}
void dfss(int x) {
c[x] = cc;
cnt[cc]++;
for (auto v : gg[x])
if (!c[v]) dfss(v);
}
void solve() {
cin >> n >> m >> h;
for (long long int i = (1); i <= (n); ++i) cin >> a[i];
for (long long int i = (1); i <= (m); ++i) {
long long int x, y;
cin >> x >> y;
if ((a[x] + 1) % h == a[y]) g[x].push_back(y), gg[y].push_back(x);
if ((a[y] + 1) % h == a[x]) g[y].push_back(x), gg[x].push_back(y);
}
for (long long int i = (1); i <= (n); ++i)
if (!vis[i]) dfs(i);
for (int i = tot; i; --i)
if (!c[p[i]]) {
++cc;
dfss(p[i]);
}
for (long long int i = (1); i <= (n); ++i) {
for (auto v : g[i])
if (c[i] != c[v]) w[c[i]] = 1;
}
for (long long int i = (1); i <= (cc); ++i)
if (!w[i] && (!res | cnt[i] < cnt[res])) res = i;
cout << cnt[res] << "\n";
for (long long int i = (1); i <= (n); ++i)
if (c[i] == res) cout << i << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e17;
const int N = 10100;
int n;
long long x[N];
long long dp[2][N];
long long a[N][2];
long long S;
int m;
void read() {
scanf("%d%lld", &n, &S);
for (int i = 0; i < n; i++) scanf("%lld%lld", &a[i][0], &a[i][1]);
m = 0;
x[m++] = S;
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++) x[m++] = a[i][j];
sort(x, x + m);
m = unique(x, x + m) - x;
for (int i = 0; i < m; i++) dp[0][i] = INF;
for (int i = 0; i < m; i++)
if (x[i] == S) dp[0][i] = 0;
}
long long getDist(long long y, long long l, long long r) {
if (y < l) return l - y;
if (y > r) return y - r;
return 0;
}
int main() {
read();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) dp[1][j] = INF;
long long val = INF;
for (int j = 0; j < m; j++) {
if (dp[0][j] != INF) val = min(val, dp[0][j] - x[j]);
dp[1][j] = min(dp[1][j], val + x[j]);
}
val = INF;
for (int j = m - 1; j >= 0; j--) {
if (dp[0][j] != INF) val = min(val, dp[0][j] + x[j]);
dp[1][j] = min(dp[1][j], val - x[j]);
}
for (int j = 0; j < m; j++)
dp[0][j] = dp[1][j] + getDist(x[j], a[i][0], a[i][1]);
}
long long ans = INF;
for (int i = 0; i < m; i++) ans = min(ans, dp[0][i]);
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << fixed << setprecision(3);
ios ::sync_with_stdio(false);
;
map<string, int> m;
string s, aux;
cin >> s;
for (int i = 0; i < 10; i++) {
cin >> aux;
m.insert({aux, i});
}
for (int i = 0; i < 80; i += 10) {
cout << m[s.substr(i, 10)];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int max_(int a[], int n) {
int i, max = 0;
for (i = 1; i < n; i++) {
if (a[i] >= a[max]) max = i;
}
return max;
}
int main() {
int n, a[102], i, max = 0, k, count = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
max = max_(a, n);
while (a[max] >= a[0]) {
if (max == 0) break;
a[0]++;
a[max]--;
count++;
max = max_(a, n);
}
printf("%d\n", count);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename T_container, typename T = typename enable_if<
!is_same<T_container, string>::value,
typename T_container::value_type>::type>
ostream &operator<<(ostream &os, const T_container &v) {
os << '{';
string sep;
for (const T &x : v) os << sep << x, sep = ", ";
return os << '}';
}
void dbg_out() { cerr << "\n"; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
void solve() {
string second;
cin >> second;
long long n = second.length();
long long a[n + 1];
a[0] = 0;
for (long long i = 0; i < n; i++) {
a[i + 1] = (second[i] - '0');
a[i + 1] += a[i];
}
for (long long i = 0; i <= n; i++) {
a[i] %= 3;
}
long long fir[n + 1][3];
for (auto &c : fir) {
for (auto &d : c) {
d = -1;
}
}
for (long long i = 0; i <= n; i++) {
fir[i][a[i]] = i;
}
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < 3; j++) {
fir[i][j] = max(fir[i - 1][j], fir[i][j]);
}
}
long long dp[n + 1];
memset(dp, 0, sizeof dp);
for (long long i = 1; i <= n; i++) {
if (fir[i - 1][a[i]] != -1)
dp[i] = max(dp[i - 1], dp[fir[i - 1][a[i]]] + 1);
else
dp[i] = dp[i - 1];
}
cout << dp[n] << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
inline bool ls(double x, double y) { return x + eps < y; }
inline bool gr(double x, double y) { return x - eps > y; }
int main() {
int a, b, m;
while (cin >> a >> b >> m) {
int vx, vy, vz;
cin >> vx >> vy >> vz;
double time = (double)m / vy * -1.0;
double x = a / 2.0 + vx * time;
double z = vz * time;
while (ls(x, 0) || gr(x, a)) {
if (ls(x, 0))
x *= -1;
else
x = a * 2 - x;
}
while (ls(z, 0) || gr(z, b)) {
if (ls(z, 0))
z *= -1;
else
z = b * 2 - z;
}
printf("%.10lf %.10lf\n", x, z);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int k, n;
cin >> n >> k;
if (n == 2) return cout << 2 << ' ' << 1 << ' ' << 2 << endl, 0;
int ans1, ans2;
int l = 1, r = n;
while (l < r) {
int mid = (l + r) / 2;
cout << 1 << ' ' << mid << ' ' << mid + 1 << endl;
string s;
cin >> s;
if (s == "NIE")
l = mid + 1;
else
r = mid;
}
ans1 = l;
if (ans1 != n) {
l = ans1 + 1, r = n;
bool good = 0;
while (l < r) {
int mid = (l + r) / 2;
cout << 1 << ' ' << mid << ' ' << mid + 1 << endl;
string s;
cin >> s;
if (s == "NIE")
l = mid + 1;
else {
r = mid;
}
}
ans2 = r;
cout << 1 << ' ' << ans2 << ' ' << ans1 << endl;
string s;
cin >> s;
if (s != "NIE") return cout << 2 << ' ' << ans1 << ' ' << ans2 << endl, 0;
}
l = 1, r = ans1 - 1;
while (l < r) {
int mid = (l + r) / 2;
cout << 1 << ' ' << mid << ' ' << mid + 1 << endl;
string s;
cin >> s;
if (s == "NIE")
l = mid + 1;
else {
r = mid;
}
}
ans2 = r;
cout << 2 << ' ' << ans1 << ' ' << ans2 << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> s[200005];
int dis[200005];
int cnt;
struct P {
int x, y, z;
};
vector<P> ans;
int dfs(int u, int fa) {
int flag = 1;
dis[u] = ++cnt;
vector<int> arr;
for (auto v : s[u]) {
if (dis[v]) {
if (dis[v] > dis[u]) arr.push_back(v);
} else {
int tmp = dfs(v, u);
if (tmp) arr.push_back(v);
}
}
if (arr.size() % 2 == 0) {
for (int i = 0; i < arr.size(); i += 2) {
ans.push_back({arr[i], u, arr[i + 1]});
}
} else {
for (int i = 0; i < arr.size() - 1; i += 2) {
ans.push_back({arr[i], u, arr[i + 1]});
}
if (fa) ans.push_back({arr.back(), u, fa});
flag = 0;
}
return flag;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
s[x].push_back(y);
s[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (dis[i]) continue;
dfs(i, 0);
}
printf("%d\n", ans.size());
for (auto pr : ans) {
printf("%d %d %d\n", pr.x, pr.y, pr.z);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[310];
int b[310], c[310];
int to[310];
bool root[310];
bool used[310];
vector<int> v;
int dp[100010];
int main(void) {
int N, Q, T, i, j;
cin >> N >> Q >> T;
for ((i) = 0; (i) < (int)(N); (i)++) cin >> a[i];
for ((i) = 0; (i) < (int)(Q); (i)++) cin >> b[i] >> c[i];
for ((i) = 0; (i) < (int)(N); (i)++) to[i] = -1;
for ((i) = 0; (i) < (int)(N); (i)++) root[i] = true;
for ((i) = 0; (i) < (int)(Q); (i)++) {
b[i]--;
c[i]--;
to[b[i]] = c[i];
root[c[i]] = false;
}
long long tmp = 0;
for ((i) = 0; (i) < (int)(N); (i)++)
if (root[i]) {
int sum = 0;
int x = i;
while (1) {
used[x] = true;
sum += a[x];
v.push_back(sum);
if (to[x] != -1) tmp += sum;
if (to[x] == -1) break;
x = to[x];
}
}
for ((i) = 0; (i) < (int)(N); (i)++)
if (!used[i]) {
cout << 0 << endl;
return 0;
}
if (tmp > T) {
cout << 0 << endl;
return 0;
}
T -= tmp;
int M = v.size();
dp[0] = 1;
for ((i) = 0; (i) < (int)(M); (i)++)
for ((j) = 0; (j) < (int)(T + 1); (j)++) {
if (j >= v[i]) {
dp[j] += dp[j - v[i]];
if (dp[j] >= 1000000007) dp[j] -= 1000000007;
}
}
cout << dp[T] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O0")
#pragma GCC optimize("O1")
long long pw(int a, int b) {
long long ret = 1;
long long mul = a;
while (b > 0) {
if (b & 1) ret *= mul;
mul *= mul;
b /= 2;
}
return ret;
}
long long to_int(string s) {
long long ret = 0;
for (int(i) = (0); (i) < (s.size()); (i)++) {
ret += pw(10, s.size() - i - 1) * (long long)(s[i] - '0');
}
return ret;
}
struct ed {
long long e, l, r, sel;
};
int main() {
int n, m, k, s1, s2, f;
cin >> n >> m >> k >> s1 >> s2 >> f;
s1--, s2--, f--;
vector<ed> edges(m + k);
vector<vector<int> > adj(n);
for (int(i) = (0); (i) < (m); (i)++) {
int s, e, l;
cin >> s >> e >> l;
s--, e--;
adj[s].push_back(i);
edges[i] = {e, l, l};
}
for (int(i) = (0); (i) < (k); (i)++) {
int s, e, l, r;
cin >> s >> e >> l >> r;
s--, e--;
adj[s].push_back(m + i);
edges[m + i] = {e, l, r, r};
}
if (s1 == s2) {
cout << "DRAW\n";
for (int(i) = (m); (i) < (m + k); (i)++) cout << edges[i].sel << " ";
cout << "\n";
return 0;
}
vector<int> mark(n);
vector<long long> dis(n, 1e17);
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
Q;
Q.push({0ll, s1}), Q.push({0ll, s2}), mark[s2] = 2, mark[s1] = 1,
dis[s1] = 0ll, dis[s2] = 0ll;
while (Q.size()) {
int v = Q.top().second, dv = Q.top().first;
Q.pop();
if (dis[v] != dv) continue;
for (int(i) = (0); (i) < (adj[v].size()); (i)++) {
int to = edges[adj[v][i]].e;
long long l = edges[adj[v][i]].l, r = edges[adj[v][i]].r;
if (mark[v] == 1) {
edges[adj[v][i]].sel = l;
if (dis[to] > dis[v] + l) {
mark[to] = 1, dis[to] = dis[v] + l;
Q.push({dis[to], to});
}
} else {
edges[adj[v][i]].sel = r;
if (dis[to] >= dis[v] + r) {
mark[to] = 2, dis[to] = dis[v] + r;
Q.push({dis[to], to});
}
}
}
}
if (mark[f] == 1) {
cout << "WIN\n";
for (int(i) = (m); (i) < (m + k); (i)++) cout << edges[i].sel << " ";
cout << "\n";
return 0;
}
dis.assign(n, 1e9);
Q.push({0, s1}), Q.push({0, s2}), mark[s1] = 1, mark[s2] = 2, dis[s1] = 0,
dis[s2] = 0;
while (Q.size()) {
int v = Q.top().second, dv = Q.top().first;
Q.pop();
if (dis[v] != dv) continue;
for (int(i) = (0); (i) < (adj[v].size()); (i)++) {
int to = edges[adj[v][i]].e;
int l = edges[adj[v][i]].l, r = edges[adj[v][i]].r;
if (mark[v] == 1) {
edges[adj[v][i]].sel = l;
if (dis[to] >= dis[v] + l) {
mark[to] = 1, dis[to] = dis[v] + l;
Q.push({dis[to], to});
}
} else {
edges[adj[v][i]].sel = r;
if (dis[to] > dis[v] + r) {
mark[to] = 2, dis[to] = dis[v] + r;
Q.push({dis[to], to});
}
}
}
}
if (mark[f] == 1) {
cout << "DRAW\n";
for (int(i) = (m); (i) < (m + k); (i)++) cout << edges[i].sel << " ";
cout << "\n";
} else
cout << "LOSE\n";
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 210;
int m, tot;
long long val[Maxn], n;
long long ans;
int w[Maxn], c[Maxn][30], fail[Maxn];
char str[Maxn];
void insert(int now) {
int p = 0;
for (int i = 0; str[i]; i++) {
int idx = str[i] - 'a';
if (!c[p][idx]) {
c[p][idx] = ++tot;
}
p = c[p][idx];
}
val[p] += w[now];
}
queue<int> q;
void bfs() {
for (int i = 0; i < 26; i++) {
if (c[0][i]) {
q.push(c[0][i]);
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < 26; i++) {
int &v = c[u][i];
if (!v) {
v = c[fail[u]][i];
continue;
}
fail[v] = c[fail[u]][i];
val[v] += val[fail[v]];
q.push(v);
}
}
}
struct Matrix {
long long matrix[Maxn][Maxn];
Matrix() { memset(matrix, -1, sizeof(matrix)); }
friend Matrix operator*(const Matrix &a, const Matrix &b) {
Matrix c;
for (int k = 0; k <= tot; k++) {
for (int i = 0; i <= tot; i++) {
if (~a.matrix[i][k]) {
for (int j = 0; j <= tot; j++) {
if (~b.matrix[k][j]) {
c.matrix[i][j] =
max(c.matrix[i][j], a.matrix[i][k] + b.matrix[k][j]);
}
}
}
}
}
return c;
}
} a, ret;
int main() {
scanf("%d%lld", &m, &n);
for (int i = 0; i < m; i++) {
scanf("%d", &w[i]);
}
for (int i = 0; i < m; i++) {
scanf("%s", str);
insert(i);
}
bfs();
for (int i = 0; i <= tot; i++) {
for (int p = 0; p < 26; p++) {
a.matrix[i][c[i][p]] = val[c[i][p]];
}
}
ret = a;
n--;
while (n) {
if (n & 1) {
ret = ret * a;
}
a = a * a;
n >>= 1;
}
for (int i = 0; i <= tot; i++) {
ans = max(ans, ret.matrix[0][i]);
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
a = a + b;
if (a > 0) {
a = a % n;
if (a == 0) a = n;
cout << a;
} else {
while (a + n <= 0) a = a + n;
cout << n + a;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void canhazfast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) {
T x0 = 1, y0 = 0, x1 = 0, y1 = 1;
while (b) {
T q = a / b;
a %= b;
swap(a, b);
x0 -= q * x1;
swap(x0, x1);
y0 -= q * y1;
swap(y0, y1);
}
x = x0;
y = y0;
return a;
}
int ctz(unsigned x) { return __builtin_ctz(x); }
int ctzll(unsigned long long x) { return __builtin_ctzll(x); }
int clz(unsigned x) { return __builtin_clz(x); }
int clzll(unsigned long long x) { return __builtin_clzll(x); }
int popcnt(unsigned x) { return __builtin_popcount(x); }
int popcntll(unsigned long long x) { return __builtin_popcountll(x); }
int bsr(unsigned x) { return 31 ^ clz(x); }
int bsrll(unsigned long long x) { return 63 ^ clzll(x); }
int f[100016];
void solve() {
int n, ans, k = 0;
cin >> n;
fill_n(f, n, 0);
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
++f[a - 1];
}
sort(f, f + n, greater<int>());
while (f[k] == f[0]) ++k;
ans = (n - k * f[0]) / (f[0] - 1) + k - 1;
cout << ans << '\n';
}
int main() {
canhazfast();
int t;
cin >> t;
for (; t; --t) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx[8] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[8] = {1, -1, 0, 0, 1, -1, 1, -1};
int N, M;
char G[1010][1010];
int vis[1010][1010], color[1000010];
queue<int> q;
vector<int> adj[1000010], peri[1000010];
bool f(int x, vector<int> &a) {
int s = 0, e = (int)a.size() - 1;
while (s <= e) {
int m = (s + e) >> 1;
if (a[m] == x) return true;
if (a[m] < x)
s = m + 1;
else
e = m - 1;
}
return false;
}
bool chk(vector<int> &peri) {
sort(peri.begin(), peri.end());
for (int i = 0; i < peri.size(); i++) {
int y = peri[i] / M;
int x = peri[i] % M;
int cnt = 0;
for (int j = 0; j < 4; j++) {
int ny = y + dy[j];
int nx = x + dx[j];
if (ny < 0 || N <= ny || nx < 0 || M <= nx) continue;
if (f(ny * M + nx, peri)) cnt++;
}
if (cnt != 2) return false;
}
return true;
}
int main() {
scanf("%d %d", &N, &M);
N += 2;
M += 2;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
G[i][j] = '2';
}
}
for (int i = 1; i < N - 1; i++) {
scanf("\n");
for (int j = 1; j < M - 1; j++) {
scanf("%c", &G[i][j]);
}
}
memset(vis, -1, sizeof(vis));
int cnt = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (vis[i][j] != -1) continue;
color[cnt] = G[i][j] - '0';
q.push(i * M + j);
vis[i][j] = cnt;
while (!q.empty()) {
int u = q.front();
q.pop();
int y = u / M;
int x = u % M;
for (int k = 0; k < (G[y][x] == '0' ? 8 : 4); k++) {
int ny = y + dy[k];
int nx = x + dx[k];
if (ny < 0 || N <= ny || nx < 0 || M <= nx) continue;
if (vis[ny][nx] != -1) continue;
if (G[ny][nx] == G[y][x]) {
q.push(ny * M + nx);
vis[ny][nx] = cnt;
}
}
}
cnt++;
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
vector<int> tmp;
for (int k = 0; k < 8; k++) {
int ni = i + dy[k];
int nj = j + dx[k];
if (ni < 0 || N <= ni || nj < 0 || M <= nj) continue;
if (vis[i][j] == vis[ni][nj]) continue;
tmp.push_back(vis[ni][nj]);
adj[vis[i][j]].push_back(vis[ni][nj]);
}
sort(tmp.begin(), tmp.end());
tmp.resize(unique(tmp.begin(), tmp.end()) - tmp.begin());
for (int k = 0; k < tmp.size(); k++) {
peri[tmp[k]].push_back(i * M + j);
}
}
}
for (int i = 0; i < cnt; i++) {
sort(adj[i].begin(), adj[i].end());
adj[i].resize(unique(adj[i].begin(), adj[i].end()) - adj[i].begin());
}
int ans = 0;
for (int i = 0; i < cnt; i++) {
if (color[i] == 0 && adj[i].size() == 1 && color[adj[i][0]] == 1) {
if (chk(peri[i])) {
ans = max(ans, (int)peri[i].size());
}
}
}
for (int i = 0; i < N - 1; i++) {
if (ans >= 4) break;
for (int j = 0; j < M - 1; j++) {
if (ans >= 4) break;
bool ok = true;
for (int a = 0; a < 2; a++) {
for (int b = 0; b < 2; b++) {
if (G[i + a][j + b] != '1') {
ok = false;
break;
}
}
if (!ok) break;
}
if (ok) ans = max(ans, 4);
}
}
printf("%d", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& x) {
x = 0;
char temp = getchar();
bool f = false;
while (!isdigit(temp)) {
if (temp == '-') f = true;
temp = getchar();
}
while (isdigit(temp)) {
x = (x << 1) + (x << 3) + temp - '0';
temp = getchar();
}
if (f) x = -x;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
const int MAXN = 3e5 + 5;
int n, q;
long long a[MAXN];
struct Edge {
int to, next;
long long val;
} edge[MAXN << 1];
int head[MAXN], cnt, from[MAXN];
inline void AddEdge(int u, int v, long long w) {
edge[++cnt] = (Edge){v, head[u], w}, head[u] = cnt;
}
inline void Add(int u, int v, long long w) {
AddEdge(u, v, w), AddEdge(v, u, w);
}
int depth[MAXN], ancestor[MAXN][18];
long long fson[MAXN], fbro[MAXN], sumbro[MAXN], ffa[MAXN], sum[MAXN], dis[MAXN];
void Dfs1(int id, int fa) {
depth[id] = depth[fa] + 1, ancestor[id][0] = fa;
sum[id] = sum[fa] + a[id];
for (register int i = 0; i < 17; i++)
ancestor[id][i + 1] = ancestor[ancestor[id][i]][i];
for (register int i = head[id]; i; i = edge[i].next) {
int son = edge[i].to;
if (son != fa) {
dis[son] = dis[id] + edge[i].val;
from[son] = i, Dfs1(son, id);
fson[id] += max(0ll, fson[son] + a[son] - edge[i].val * 2);
}
}
for (register int i = head[id]; i; i = edge[i].next) {
int son = edge[i].to;
if (son != fa)
fbro[son] = fson[id] - max(fson[son] + a[son] - edge[i].val * 2, 0ll);
}
}
void Dfs2(int id, int fa) {
sumbro[id] = sumbro[fa] + fbro[id];
for (register int i = head[id]; i; i = edge[i].next) {
int son = edge[i].to;
if (son != fa) {
ffa[son] = max(0ll, ffa[id] + a[id] - edge[i].val * 2 + fbro[son]);
Dfs2(son, id);
}
}
}
inline int LCA(int id1, int id2) {
if (depth[id1] < depth[id2]) swap(id1, id2);
for (register int i = 17; i >= 0; i--) {
if (depth[ancestor[id1][i]] >= depth[id2]) id1 = ancestor[id1][i];
if (id1 == id2) return id1;
}
for (register int i = 17; i >= 0; i--)
if (ancestor[id1][i] != ancestor[id2][i])
id1 = ancestor[id1][i], id2 = ancestor[id2][i];
return ancestor[id1][0];
}
int main() {
read(n), read(q);
for (register int i = 1; i <= n; i++) read(a[i]);
for (register int i = 1, u, v, w; i < n; i++)
read(u), read(v), read(w), Add(u, v, w);
Dfs1(1, 0), Dfs2(1, 0);
while (q--) {
int u, v, lca;
read(u), read(v), lca = LCA(u, v);
long long ans = 0;
ans = sum[u] + sum[v] - sum[lca] - sum[ancestor[lca][0]] -
(dis[u] - dis[lca]) - (dis[v] - dis[lca]);
if (depth[u] > depth[v]) swap(u, v);
if (u == lca)
ans += ffa[u] + fson[v] + (sumbro[v] - sumbro[u]);
else {
ans += ffa[lca] + fson[u] + fson[v] + sumbro[u] + sumbro[v];
for (register int i = 17; i >= 0; i--) {
if (depth[ancestor[u][i]] > depth[lca]) u = ancestor[u][i];
if (depth[ancestor[v][i]] > depth[lca]) v = ancestor[v][i];
}
ans -= sumbro[u] + sumbro[v];
ans += fbro[u] - max(0ll, fson[v] + a[v] - edge[from[v]].val * 2);
}
print(ans), puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long A, B, P, X, pa, pb;
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return a;
}
long long r = exgcd(b, a % b, y, x);
y -= a / b * x;
return r;
}
long long getC(long long a, long long b) {
long long x, y, r;
r = exgcd(a, b, x, y);
x = (x % P + P) % P;
return x;
}
long long getN(long long u, long long v) {
long long N = 0;
N += (P - 1) * pa * u;
N += P * pb * v;
N %= P * (P - 1);
return N;
}
int main(int argc, char **argv) {
cin >> A >> B >> P >> X;
long long tmp = A, ans = 0;
pa = getC(P - 1, P);
pb = getC(P, P - 1);
for (int i = 1; i < P; i++) {
long long C = getC(tmp, P);
C = C * B % P;
long long N = getN(C, i);
if (X >= N) {
ans += (X - N) / (P * (P - 1)) + 1;
}
tmp *= A;
tmp %= P;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[10010];
int main() {
scanf("%[^\n]", s);
int len = strlen(s);
for (int i = 0; i < len; i++) {
int ii = i;
while (s[ii] == ' ') ii++;
if (ii < len)
if (s[ii] == '.' || s[ii] == ',' || s[ii] == '!' || s[ii] == '?') {
printf("%c ", s[ii]);
while (s[ii + 1] == ' ') ii++;
} else {
if (i < ii) printf(" ");
printf("%c", s[ii]);
}
i = ii;
}
puts("");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101000;
map<int, int> hs;
int n, a, b, f[N], vs[N], sta[N], p[N];
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int main() {
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i < n + 1; i++) scanf("%d", p + i), hs[p[i]] = i, f[i] = i;
for (int i = 1; i < n + 1; i++) {
if (hs.count(a - p[i])) f[find(hs[a - p[i]])] = find(i), vs[i] |= 1;
if (hs.count(b - p[i])) f[find(hs[b - p[i]])] = find(i), vs[i] |= 2;
}
for (int i = 1; i < n + 1; i++) sta[i] = 3;
for (int i = 1; i < n + 1; i++) sta[find(i)] &= vs[i];
for (int i = 1; i < n + 1; i++)
if (sta[i] == 0) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 1; i < n + 1; i++) {
int st = sta[find(i)];
putchar('0' + ((st & 1) == 0));
if (i != n) putchar(' ');
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int N = 1e5;
const int MOD = 1e9 + 7;
const double PI = acos(-1);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
int q[n - 1];
for (int& x : q) cin >> x;
int cur = 0;
for (int& x : q) {
cur += x;
x = cur;
}
bool allNeg = 1, allPos = 1;
int mx = *max_element(q, q + n - 1);
for (int x : q) {
if (x < 0) allPos = 0;
if (x > 0) allNeg = 0;
}
int k;
if (allNeg)
k = n;
else if (allPos)
k = 1;
else
k = n - mx;
vector<int> res, chk;
res.push_back(k);
chk.push_back(k);
for (int x : q) {
res.push_back(k + x);
chk.push_back(k + x);
}
sort(chk.begin(), chk.end());
for (int i = 1; i <= n; i++) {
if (chk[i - 1] != i) {
cout << -1;
exit(0);
}
}
for (int x : res) cout << x << ' ';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5010;
const int MOD = 1e9 + 7;
int N;
int col[MAXN];
int x[MAXN];
int y[MAXN];
int dist[MAXN][MAXN];
int dis(int x1, int y1, int x2, int y2) { return abs(x1 - x2) + abs(y1 - y2); }
int ans, ret = 1;
bool dfs(int x, const int mid) {
for (int i = 0; i < N; i++) {
if (dist[x][i] <= mid || i == x) {
continue;
}
if (col[i] == 0) {
col[i] = -col[x];
if (!dfs(i, mid)) {
return 0;
}
} else if (col[x] == col[i]) {
return 0;
}
}
return 1;
}
bool check(int mid) {
memset(col, 0, sizeof col);
ret = 1;
for (int i = 0; i < N; i++) {
if (col[i] == 0) {
col[i] = 1;
if (!dfs(i, mid)) {
return 0;
}
ret = ret * 2 % MOD;
}
}
return 1;
}
void solve() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> x[i] >> y[i];
}
int r = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
dist[i][j] = dis(x[i], y[i], x[j], y[j]);
r = max(r, dist[i][j]);
}
}
int l = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid)) {
r = mid - 1;
ans = ret;
ret = 1;
} else {
l = mid + 1;
}
}
cout << l << endl << ans << endl;
}
void Times(int T) {
while (T--) {
solve();
}
}
int main() {
int T = 1;
Times(T);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, pair<long long, long long>>> it;
long long A[200010], B[200010];
long long _count[200010], used[200010];
long long parent[200010], size[200010];
void init(long long n) {
for (long long i = 0; i < n; i++) {
parent[i] = i;
size[i] = 1;
}
}
long long root(long long x) {
if (x == parent[x]) return x;
return parent[x] = root(parent[x]);
}
bool join(long long x, long long y) {
x = root(x), y = root(y);
if (x == y) return false;
parent[y] = x;
size[x] += size[y];
return true;
}
void sub() {
long long n, m;
cin >> m >> n;
for (long long i = 0; i < m; i++) {
cin >> A[i];
}
for (long long i = 0; i < n; i++) {
cin >> B[i];
}
for (long long i = 0; i < m; i++) {
long long x;
cin >> x;
for (long long j = 0; j < x; j++) {
long long k;
cin >> k;
long long cost = A[i] + B[k - 1];
it.push_back({cost, {i, k - 1}});
}
}
sort(it.begin(), it.end(),
[](pair<long long, pair<long long, long long>> a,
pair<long long, pair<long long, long long>> b) {
return a.first > b.first;
});
init(n);
int64_t sum = 0;
for (auto i : it) {
sum += i.first;
}
int64_t ans = 0;
for (long long i = 0; i < (long long)it.size(); i++) {
long long val = it[i].first, x = it[i].second.first,
y = it[i].second.second;
if (_count[x] == 0) {
ans += val;
used[x] = y;
_count[x]++;
} else {
if (join(used[x], y)) {
ans += val;
}
}
}
cout << sum - ans << endl;
}
int32_t main() {
long long t = 1;
while (t--) {
sub();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<string> names;
vector<int> adj[27];
bool vis[26];
stack<int> st;
void toposort(int node, set<int> dup) {
vis[node] = 1;
dup.insert(node);
for (auto it : adj[node]) {
if (dup.count(it)) {
cout << "Impossible";
exit(0);
}
if (!vis[it]) {
toposort(it, dup);
}
}
st.push(node + 'a');
}
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
names.push_back(s);
}
for (int i = 1; i < names.size(); i++) {
string x = names[i - 1];
string y = names[i];
for (int j = 0; j < x.size(); j++) {
if (j == y.size()) {
cout << "Impossible";
return 0;
} else {
if (x[j] != y[j]) {
adj[x[j] - 'a'].push_back(y[j] - 'a');
break;
}
}
}
}
for (int i = 0; i < 26; i++) {
if (!vis[i]) {
set<int> dup;
toposort(i, dup);
}
}
while (!st.empty()) {
cout << (char)(st.top());
st.pop();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int N;
cin >> N;
vector<long long int> myarr1(N, 0);
vector<long long int> myarr2(N, 0);
for (int i = 0; i < N; ++i) {
cin >> myarr1[i];
}
for (int m = 0; m < (1 << N); m++) {
int cura = 0;
for (int i = 0; i < N; i++) {
if ((m >> i) & 1)
cura += myarr1[i];
else
cura -= myarr1[i];
cura += 360;
cura %= 360;
}
if (cura == 0) {
cout << "YES"
<< "\n";
return 0;
}
}
cout << "NO"
<< "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
int k = n;
int ans = 0;
int i = 1;
while (true) {
ans++;
if ((long long)k * i >= s) break;
i++;
}
cout << ans << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int MAXN = 105;
const int DR[4][2] = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};
const char CH[4] = {'<', '^', '>', 'v'};
int n;
char a[MAXN][MAXN];
void init() { scanf("%d%*d", &n); }
void add(int x, int y, int dir, int len) {
for (int i = 0; i < len; ++i) {
if (i < len / 2 - 1 || i % 2 == 0)
a[x][y] = CH[dir];
else
a[x][y] = '.';
x += DR[dir][0];
y += DR[dir][1];
}
}
void solve() {
add(0, 0, 3, n - 1);
for (int i = 0; i < n - 1; i += 2) {
add(n - 1, i, 2, 1);
add(n - 1, i + 1, 1, n - 1);
add(1, i + 1, 2, 1);
add(1, i + 2, 3, n - 2);
}
add(n - 2, n - 1, 2, 1);
add(n - 1, n - 1, 1, n - 1);
add(0, n - 1, 0, n - 1);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) printf("%c", a[i][j]);
printf("\n");
}
printf("1 1\n");
}
int main() {
init();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int MAXN = 100005;
using namespace std;
pair<int, int> a[MAXN];
int n;
int scan() {
int t = 0, m = 1;
char c;
c = getchar();
while ((c < '0' || c > '9') and c != '-') c = getchar();
if (c == '-') c = getchar(), m = -1;
while (c >= '0' && c <= '9') t = (t << 3) + (t << 1) + c - '0', c = getchar();
return (t * m);
}
int main() {
std::ios::sync_with_stdio(false);
n = scan();
int max, min;
max = 0;
min = 1e9;
for (int i = 1; i <= n; i++) {
a[i].first = scan();
a[i].second = scan();
if (a[i].first < min) min = a[i].first;
if (a[i].second > max) max = a[i].second;
}
bool f = false;
for (int i = 1; i <= n; i++) {
if (a[i].first == min && a[i].second == max) {
cout << i;
f = true;
break;
}
}
if (f == false) cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, m;
long long lb, ub, mid;
long long a[100024];
inline bool C(long long x) {
int index = n, k = 0;
long long cur = a[index], tee = x;
while (index > 0 && k < m) {
x = tee - index;
if (x <= 0) return 0;
while (x >= cur) {
x -= cur;
--index;
if (index < 1) return 1;
cur = a[index];
}
cur -= x;
++k;
}
if (index > 0) return false;
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1), __ = (n); i <= __; ++i) scanf("%I64d", a + i), ub += a[i];
for (int i = (n), __ = (1); i >= __; --i)
if (!a[i])
--n;
else
break;
lb = 0;
ub += n;
long long res = 0;
while (lb <= ub) {
mid = (lb + ub) >> 1;
if (C(mid))
res = mid, ub = mid - 1;
else
lb = mid + 1;
}
printf("%I64d\n", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int p[200009];
int b[200009];
bool vis[200009];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
vis[i] = false;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == false) {
ans++;
int x = i;
while (vis[x] == false) {
vis[x] = true;
x = p[x];
}
}
}
if (ans == 1) {
ans = 0;
}
int sum = 0;
for (int i = 1; i <= n; i++) {
cin >> b[i];
if (b[i] == 1) {
sum++;
}
}
cout << ans + ((sum % 2) + 1) % 2 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> g[111111];
long long val[111111];
long long add[111111];
long long mns[111111];
int f[111111];
void mtree(int x, int p = 0) {
f[x] = p;
for (int i = 0; i < g[x].size(); i++) {
int to = g[x][i];
if (to != p) {
mtree(to, x);
}
}
}
void dfs(int x) {
for (int i = 0; i < g[x].size(); i++) {
int to = g[x][i];
if (to == f[x]) continue;
dfs(to);
add[x] = max(add[x], add[to]);
mns[x] = max(mns[x], mns[to]);
}
val[x] += add[x];
val[x] -= mns[x];
if (val[x] > 0)
mns[x] += abs(val[x]);
else
add[x] += abs(val[x]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(f, -1, sizeof(f));
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; i++) {
cin >> val[i];
}
f[0] = 0;
mtree(0);
dfs(0);
cout << add[0] + mns[0] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int s, v1, v2, t1, t2;
int sum1, sum2;
scanf("%d %d %d %d %d", &s, &v1, &v2, &t1, &t2);
sum1 = s * v1 + t1 * 2;
sum2 = s * v2 + t2 * 2;
if (sum1 < sum2)
printf("First");
else if (sum1 > sum2)
printf("Second");
else
printf("Friendship");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string c;
char t;
int a[26];
for (int i = 0; i < 26; i++) a[i] = 0;
cin >> c;
sort(c.begin(), c.end());
t = c[c.size() - 1];
for (int i = c.size() - 1; i >= 0; i--)
if (c[i] != t)
break;
else
a[t - 'a']++;
for (int i = 0; i < a[t - 'a']; i++) cout << t;
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long OO = (long long)1e18 + 7;
using namespace std;
long long inv(long long a, long long b) {
return 1 < a ? b - inv(b % a, a) * b / a : 1;
}
long long Pow(long long B, long long P) {
long long R = 1;
while (P > 0) {
if (P & 1) R = (R * B);
P /= 2;
B = (B * B);
}
return R;
}
long long GCD(long long a, long long b) {
while (b) {
b ^= a ^= b ^= a %= b;
}
return a;
}
long long LCM(long long a, long long b) { return (a / GCD(a, b) * b); }
long long BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P & 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return (long long)R;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int nlp;
cin >> nlp;
while (nlp--) {
int n;
cin >> n;
vector<int> nms(n);
for (long long i = 0; i < n; ++i) cin >> nms[i];
map<int, int> cnt;
set<int> st, pq;
for (long long i = 0; i < n; ++i) cnt[nms[i]]++;
for (long long i = 0; i < n; ++i)
if (nms[i] != i) st.insert(i);
for (long long i = 0; i < 2 * n + 1; ++i)
if (!cnt[i]) pq.insert(i);
vector<int> ans;
while (st.size()) {
int x = *pq.begin();
if (st.count(x)) {
int y = nms[x];
--cnt[y];
++cnt[x];
if (!cnt[y]) {
pq.insert(y);
}
nms[x] = x;
st.erase(x);
pq.erase(x);
ans.push_back(x + 1);
} else {
int y = *st.begin();
for (long long i = 0; i < n; ++i)
if (nms[i] == y) {
--cnt[y];
if (!cnt[y]) pq.insert(y);
++cnt[x];
nms[i] = x;
pq.erase(x);
ans.push_back(i + 1);
break;
}
}
}
cout << ans.size() << "\n";
for (auto x : ans) cout << x << " ";
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
long double hh, mm;
cin >> hh >> mm;
int h, d, n;
long double c;
cin >> h >> d >> c >> n;
long double wynik;
wynik = h / n;
if (h % n != 0) wynik++;
if (hh >= 20) {
cout << fixed << setprecision(4) << wynik * c * 8 / 10;
return 0;
}
if (hh < 20) {
int ile;
if (mm == 0)
ile = (20 - hh) * 60;
else
ile = (20 - hh - 1) * 60 + 60 - mm;
ile *= d;
ile += h;
long double wynik2;
wynik2 = ile / n;
if (ile % n != 0) wynik2++;
cout << fixed << setprecision(4) << min(wynik * c, wynik2 * c * 8 / 10);
} else {
int ile;
if (mm == 0)
ile = (24 - hh) * 60;
else
ile = (24 - hh - 1) * 60 + 60 - mm;
ile += 20;
ile *= d;
ile += h;
long double wynik2;
wynik2 = ile / n;
if (ile % n != 0) wynik2++;
cout << fixed << setprecision(4) << min(wynik * c, wynik2 * c * 8 / 10);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Testcase {
double n;
Testcase(int n) : n(n){};
pair<double, double> solve(bool &status) {
pair<double, double> a = {0, n};
status = true;
double m = n / 2;
if (m * m < n) {
status = false;
return a;
}
if (m * m == n) {
return {m, m};
}
double lo = 0, hi = m;
for (int i = 0; i < 100; ++i) {
double mid = (lo + hi) / 2;
double res = mid * (n - mid);
if (res == n) {
return {mid, n - mid};
} else if (res < n) {
lo = mid;
} else if (res > n) {
hi = mid;
}
}
return {lo, n - lo};
}
};
int main() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
int n;
cin >> n;
bool status = true;
auto [a, b] = Testcase(n).solve(status);
if (not status) {
cout << "N" << endl;
} else {
cout << fixed << setprecision(15) << "Y " << a << " " << b << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
const long long mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long c, v0, v1, a, l, ans = 0;
cin >> c >> v0 >> v1 >> a >> l;
long long tot = 0;
while (tot < c) {
long long add = v0 - l * (ans > 0);
tot = tot + add;
v0 = min(v0 + a, v1);
ans++;
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[200][4];
map<int, int> mp;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, d;
cin >> n >> d;
set<int> st;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
arr[i][0] = x;
arr[i][1] = x - d + 1;
arr[i][2] = x + d - 1;
}
int cntr = 0;
for (int i = 0; i < n; i++) {
int l = arr[i][0] - d, r = arr[i][0] + d, c1 = 1, c2 = 1;
for (int j = 0; j < n; ++j) {
if (i == j) continue;
if (l >= arr[j][1] && l <= arr[j][2]) c1 = 0;
if (r >= arr[j][1] && r <= arr[j][2]) c2 = 0;
}
if (c1 && !mp[l]) {
cntr++;
mp[l] = 1;
}
if (c2 && !mp[r]) {
cntr++;
mp[r] = 1;
}
}
cout << cntr;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000 * 1000 * 1000 + 7;
const int N = 5005;
int n, s = 1;
int dis[N][N];
int color[N];
vector<pair<int, int> > dots;
bool dfs(int k, int v, int c) {
color[v] = c;
for (int i = 0; i < n; i++) {
if (v != i && dis[v][i] > k) {
if (color[i] == c) {
return false;
}
if (color[i] == 0) {
bool b = dfs(k, i, 3 - c);
if (b == false) {
return false;
}
}
}
}
return true;
}
bool isval(int k) {
s = 1;
for (int i = 0; i < n; i++) {
color[i] = 0;
}
for (int i = 0; i < n; i++) {
if (color[i] == 0) {
s *= 2;
s %= mod;
bool b = dfs(k, i, 1);
if (b == false) {
return false;
}
}
}
return true;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x;
cin >> y;
dots.push_back({x, y});
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dis[i][j] = abs(dots[i].first - dots[j].first) +
abs(dots[i].second - dots[j].second);
}
}
int dw = -1, up = 2 * N;
while (up - dw > 1) {
int md = (up + dw) / 2;
if (isval(md) == true) {
up = md;
} else {
dw = md;
}
}
bool b = isval(up);
cout << up << endl;
cout << s;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn], b[maxn];
int main() {
int n, y;
scanf("%d%d", &n, &y);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int m;
scanf("%d%d", &m, &y);
for (int i = 0; i < m; i++) scanf("%d", &b[i]);
int ans = 2;
for (int i = 1; i < (int)1e9; i *= 2) {
unordered_map<int, int> q;
int mod = 2 * i;
for (int j = 0; j < n; j++) q[a[j] & (mod - 1)]++;
for (int j = 0; j < m; j++) q[(b[j] + i) & (mod - 1)]++;
for (auto t : q) {
ans = max(ans, t.second);
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
vector<pair<long long, long long> > graph[10];
bool vis[10];
long long funck(long long x) {
vis[x] = 1;
long long temp = 0;
for (pair<long long, long long> i : graph[x]) {
if (vis[i.first])
temp += i.second;
else
temp += i.second + funck(i.first);
}
return temp;
}
int main() {
long long n, mn = LONG_MAX;
cin >> n;
for (int i = 1; i <= n; i++) {
long long u, v, w;
cin >> u >> w >> v;
graph[u].push_back({v, w});
graph[v].push_back({u, w});
if (u != v) mn = min(mn, w);
}
long long cmp = 0, ans = 0;
for (int i = 1; i <= 4; i++) {
if (!vis[i]) {
cmp++;
ans = max(ans, funck(i) / 2);
}
}
long long odd = 0;
for (int i = 1; i <= 4; i++) {
odd += (graph[i].size() & 1);
}
if (cmp == 1 and odd == 4) ans -= mn;
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
long long int power(long long int x, long long int b) {
long long int p = 1;
while (b > 0) {
if (b & 1) {
p = p * x;
p %= 1000000007;
}
b >>= 1;
x *= x;
x %= 1000000007;
}
return p % 1000000007;
}
using namespace std;
void dfs(long long int src, vector<vector<long long int> >& adj,
vector<bool>& vis, vector<pair<long long int, long long int> >& depth,
vector<long long int>& parent, long long int d = 1) {
vis[src] = true;
depth.push_back({d, src});
for (auto it : adj[src]) {
if (!vis[it]) {
parent[it] = src;
dfs(it, adj, vis, depth, parent, d + 1);
}
}
}
bool comp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return a.first > b.first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int n;
cin >> n;
vector<vector<long long int> > adj(n + 1);
for (long long int i = 0; i < n - 1; i++) {
long long int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
vector<pair<long long int, long long int> > depth;
vector<bool> vis(n + 1);
vector<long long int> parent(n + 1);
dfs(1, adj, vis, depth, parent);
sort(depth.begin(), depth.end(), comp);
for (long long int i = 0; i < n + 1; i++) vis[i] = false;
long long int ans = 0;
for (auto it : depth) {
if (it.first <= 3) break;
if (!vis[it.second]) {
ans++;
for (auto i : adj[parent[it.second]]) vis[i] = true;
vis[parent[it.second]] = true;
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
void swap(int *a, int *b) {
int t = *a;
*a = *b;
*b = t;
}
int main(void) {
int a1, a2, k1, k2, n, t, min, max;
scanf("%d %d %d %d %d", &a1, &a2, &k1, &k2, &n);
min = n - (a1 * (k1 - 1) + a2 * (k2 - 1));
if (min <= 0) min = 0;
if (k1 > k2) {
swap(&k1, &k2);
swap(&a1, &a2);
}
t = a1 * k1;
if (t <= n)
max = a1 + (n - t) / k2;
else
max = n / k1;
printf("%d %d", min, max);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 50005;
const int MAX_K = 55;
struct node {
int l, r;
int mx, add;
};
struct segtree {
node T[MAX_N << 2];
void pushup(int rt) { T[rt].mx = max(T[(rt << 1)].mx, T[(rt << 1 | 1)].mx); }
void pushdown(int rt) {
if (T[rt].l == T[rt].r || !T[rt].add) return;
T[(rt << 1)].mx += T[rt].add;
T[(rt << 1)].add += T[rt].add;
T[(rt << 1 | 1)].mx += T[rt].add;
T[(rt << 1 | 1)].add += T[rt].add;
T[rt].add = 0;
}
void build(int rt, int l, int r) {
T[rt].l = l;
T[rt].r = r;
if (l == r) {
T[rt].mx = 0;
T[rt].add = 0;
return;
}
int mid = (l + r) / 2;
build((rt << 1), l, mid);
build((rt << 1 | 1), mid + 1, r);
}
int query(int rt, int l, int r) {
pushdown(rt);
if (T[rt].l == l && T[rt].r == r) return T[rt].mx;
if (l >= T[(rt << 1 | 1)].l)
return query((rt << 1 | 1), l, r);
else if (r <= T[(rt << 1)].r)
return query((rt << 1), l, r);
else
return max(query((rt << 1), l, T[(rt << 1)].r),
query((rt << 1 | 1), T[(rt << 1 | 1)].l, r));
}
void modify(int rt, int l, int r, int add) {
pushdown(rt);
if (T[rt].l == l && T[rt].r == r) {
T[rt].mx += add;
T[rt].add += add;
return;
}
if (l >= T[(rt << 1 | 1)].l)
modify((rt << 1 | 1), l, r, add);
else if (r <= T[(rt << 1)].r)
modify((rt << 1), l, r, add);
else
modify((rt << 1), l, T[(rt << 1)].r, add),
modify((rt << 1 | 1), T[(rt << 1 | 1)].l, r, add);
pushup(rt);
}
} T[MAX_K];
int n, k, A[MAX_N], lst[MAX_N], pre[MAX_N];
int dp[MAX_N][MAX_K];
int main() {
cin >> n >> k;
for (int i = 0; i <= k; i++) T[i].build(1, 1, n);
for (int i = 1; i <= n; i++) cin >> A[i];
for (int i = 1; i <= n; i++) {
pre[i] = lst[A[i]];
lst[A[i]] = i;
}
for (int i = 1; i <= n; i++) {
T[1].modify(1, pre[i] + 1, i, 1);
dp[i][1] = T[1].query(1, 1, i);
}
for (int j = 2; j <= k; j++) {
for (int i = 1; i <= n; i++) {
T[j].modify(1, pre[i] + 1, i, 1);
T[j].modify(1, i, i, dp[i - 1][j - 1]);
if (i >= j) dp[i][j] = T[j].query(1, 1, i);
}
}
cout << dp[n][k] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3E4 + 5;
const int M = 500;
int n, d, a[N], x, ans, r, L, w, f[N][M * 2 + 5];
int main() {
cin >> n >> L;
for (int i = 1; i <= n; i++) scanf("%d", &r), a[r]++;
memset(f, -10, sizeof(f));
f[L][M] = a[L];
for (int i = 1; i <= r; i++)
for (int j = L - M; j <= L + M; j++)
if ((w = f[i][j - L + M]) >= 0) {
ans = max(ans, w);
for (int k = j - 1; k <= j + 1; k++)
if (k > 0 && (x = i + k) <= r) {
f[x][k - L + M] = max(f[x][k - L + M], w + a[x]);
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int n, num[MAX];
long long cnt[MAX * 10], dp[MAX * 10][5];
char ch[MAX][5];
set<int> S;
map<int, int> m_ii;
vector<int> val;
void ready() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", ch[i]);
if (ch[i][0] != 's') {
scanf("%d", &num[i]);
S.insert(num[i]);
}
}
val = vector<int>(S.begin(), S.end());
for (int i = 0; i < val.size(); i++) m_ii[val[i]] = i;
memset(cnt, 0, sizeof(cnt));
memset(dp, 0, sizeof(dp));
}
void update(int u, int L, int R, int x, int d) {
if (L == R) {
cnt[u] += d;
if (cnt[u])
dp[u][0] = val[x];
else
dp[u][0] = 0;
return;
} else {
int M = (L + R) / 2;
if (x <= M)
update(2 * u + 1, L, M, x, d);
else
update(2 * u + 2, M + 1, R, x, d);
cnt[u] = cnt[2 * u + 1] + cnt[2 * u + 2];
for (int i = 0; i < 5; i++)
dp[u][i] =
dp[2 * u + 1][i] + dp[2 * u + 2][((i - cnt[2 * u + 1]) % 5 + 5) % 5];
}
}
void out(int u, int L, int R) {
printf("cnt[%d] = %d, %d %d %d %d %d\n", u, cnt[u], dp[u][0], dp[u][1],
dp[u][2], dp[u][3], dp[u][4]);
if (L == R)
return;
else {
int M = (L + R) / 2;
if (L <= M) out(2 * u + 1, L, M);
if (M + 1 <= R) out(2 * u + 2, M + 1, R);
}
}
void go() {
for (int i = 0; i < n; i++) {
if (ch[i][0] == 'a')
update(0, 0, val.size() - 1, m_ii[num[i]], 1);
else if (ch[i][0] == 'd')
update(0, 0, val.size() - 1, m_ii[num[i]], -1);
else
printf("%I64d\n", dp[0][2]);
}
}
int main() {
ready();
go();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int p[300], a[300], num[300];
int find(int x) {
if (p[x] == 0)
return x;
else {
p[x] = find(p[x]);
return p[x];
}
}
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x != y) p[x] = y;
}
int main() {
int n, m, ans, i, x, j, k;
scanf("%d%d", &n, &m);
ans = 0;
for (i = 1; i <= n; ++i) {
scanf("%d", &x);
for (j = 1; j <= x; ++j) {
scanf("%d", &a[j]);
++num[a[j]];
}
if (x == 0) {
++ans;
continue;
}
for (k = 2; k <= x; ++k) merge(a[1], a[k]);
}
bool flag = false;
for (i = 1; i <= m; ++i) {
if (p[i] == 0 && num[i] > 0) {
++ans;
flag = true;
}
}
if (flag) --ans;
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define limit (300000 + 5)
#define INF 0x3f3f3f3f
#define inf 0x3f3f3f3f3f
#define lowbit(i) i&(-i)
#define EPS 1e-6
#define FASTIO ios::sync_with_stdio(false);cin.tie(0);
#define ff(a) printf("%lld\n",a );
#define pi(a,b) pair<a,b>
#define rep(i, a, b) for(int i = a ; i <= b ; ++i)
#define per(i, a, b) for(int i = b ; i >= a ; --i)
#define mint(a,b,c) min(min(a,b), c)
#define MOD 998244353
typedef long long ll;
typedef unsigned long long ull;
ll read(){
ll sign = 1, x = 0;char s = getchar();
while(s > '9' || s < '0' ){if(s == '-')sign = -1;s = getchar();}
while(s >= '0' && s <= '9'){x = x * 10 + s - '0';s = getchar();}
return x * sign;
}
void write(ll x){
if(x / 10) write(x / 10);
putchar(x % 10 + '0');
}
int n, m;
struct node{
int l, r, qid, blo;
int len(){
return r - l + 1;
}
bool operator<(const node &rhs)const{
if(blo ^ rhs.blo)return l < rhs.l;
return blo & 1 ? r < rhs.r : rhs.r < r;
}
}query[limit];
int cnt[limit],a[limit],sum[limit];
int res;
void add(int x){
--sum[cnt[a[x]]];
++cnt[a[x]];
res = max(res, cnt[a[x]]);
++sum[cnt[a[x]]];
}
void del(int x){
--sum[cnt[a[x]]];
if(res == cnt[a[x]] && !sum[cnt[a[x]]])--res;
--cnt[a[x]];
++sum[cnt[a[x]]];
}
int vis[limit];
int main(){
n = read(), m = read();
rep(i ,1, n){
int x=read();
a[i]=x;
}
int block = int(sqrt(n >= 3 ? n * (2.0 / 3) : n));
rep(i, 1, m){
query[i].l = read(), query[i].r = read(), query[i].qid = i;
query[i].blo = query[i].l / block;
}
sort(query + 1, query + 1 + m);
int l = 1 , r = 0;
res = 0;
rep(i ,1, m){
while(l > query[i].l)add(--l);
while(r < query[i].r)add(++r);
while(r > query[i].r)del(r--);
while(l < query[i].l)del(l++);
vis[query[i].qid] = max(res - (query[i].len() - res), 1);
}
rep(i ,1, m){
printf("%d\n", vis[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long int, vector<long long int>, greater<long long int> >
ti;
vector<long long int> p[200005], y[300005], f(2000005, 0), b(100005, 0);
long long int vis[100005];
map<pair<long long int, long long int>, long long int> mp;
set<pair<long long int, long long int> > s;
set<long long int> st;
map<long long int, long long int> np, v;
queue<long long int> qy;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int bpow(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return res % 1000000007;
}
void fact(long long int i) {
f[0] = 1;
for (long long int k = 1; k <= i; k++) {
(f[k] = f[k - 1] * k) %= 1000000007;
}
}
long long int isprime(long long int n) {
if (n == 1) return 0;
for (long long int i = 2; i <= sqrt(n); i++)
if (n % i == 0) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
string p, h;
cin >> p >> h;
vector<long long int> a(26, 0);
if (h.size() < p.size()) {
cout << "NO"
<< "\n";
continue;
}
for (long long int i = 0; i < p.size(); i++) {
a[p[i] - 'a']++;
}
long long int o = 0;
for (long long int i = 0; i <= h.size() - p.size(); i++) {
vector<long long int> b(26, 0);
for (long long int j = 0; j < p.size(); j++) {
b[h[i + j] - 'a']++;
}
long long int f = 0;
for (long long int k = 0; k < 26; k++) {
if (a[k] != b[k]) f = 1;
}
if (!f) {
o = 1;
}
}
if (o)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, x, y;
scanf("%d", &t);
while (t--) {
scanf("%d%d%d", &n, &x, &y);
if (x + y <= n)
printf("%d %d\n", 1, min(x + y - 1, n));
else
printf("%d %d\n", min(n, x + y - n + 1), min(x + y - 1, n));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC optimize("Ofast")
using namespace std;
using lint = long long;
vector<int> ds[8888];
int16_t lcp[8010][8010];
char lenxc[8888];
char lenx(int x) {
char res = 0;
do {
x /= 10;
res++;
} while (x);
return res;
}
int d[8888];
void solve(istream& cin, ostream& cout) {
for (int i = (1); i < int(8888); ++i) {
for (int j = i + i; j < 8888; j += i) {
ds[j].push_back(i);
}
lenxc[i] = lenx(i);
}
string s;
cin >> s;
int n = s.size();
for (int i = int(n) - 1; i >= (0); --i) {
for (int j = int(n) - 1; j >= (0); --j) {
if (s[i] == s[j]) {
lcp[i][j] = 1 + lcp[i + 1][j + 1];
}
}
}
for (int i = (0); i < int(n); ++i) {
d[i + 1] = 1 + i + 1;
for (int j = (1); j < int(i + 2); ++j) {
int dij1 = d[i - j + 1];
d[i + 1] = min(d[i + 1], dij1 + 1 + j);
int cs = 0;
for (int dv : ds[j]) {
if ((lcp[i - j + 1][i - j + 1 + dv] >= j - dv)) {
d[i + 1] = min(d[i + 1], dij1 + lenxc[j / dv] + dv);
cs++;
if (cs > 1) {
break;
}
}
}
}
}
cout << d[n];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve(cin, cout);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int const M = 100 + 10, M2 = 1e6 + 10, mod = 1e9 + 7, mod2 = 1e9 + 9,
inf = 1e9 + 30;
int a[5][M], n, ind;
pair<int, int> ma[M], ne;
pair<int, int> now;
pair<int, int> p[M][M], e;
int cnt = 0, t = 0, mark[M][M], flag = 0, head = 0, tail = 0;
pair<int, pair<int, int> > ans[M2];
pair<int, int> q[M];
void hlp(int x, int xx, int yy) {
ans[++cnt] = (make_pair(x, make_pair(xx, yy)));
}
bool check(int x, int y) {
if (x > 3 || x < 2 || y > n || y < 1) return 0;
if (mark[x][y] == t) return 0;
if (a[x][y] == ind) return 0;
q[head++] = make_pair(x, y);
mark[x][y] = t;
return 1;
}
void dfs(int x, int y) {
head = 0, tail = 0;
q[head++] = make_pair(x, y);
mark[x][y] = t;
while (head > tail) {
x = q[tail].first;
y = q[tail++].second;
mark[x][y] = t;
if (a[x][y] == 0 && !flag) {
pair<int, int> last = make_pair(x, y);
while (last.first != ne.first || last.second != ne.second) {
hlp(a[p[last.first][last.second].first]
[p[last.first][last.second].second],
last.first, last.second);
swap(a[p[last.first][last.second].first]
[p[last.first][last.second].second],
a[last.first][last.second]),
last = p[last.first][last.second];
}
flag = 1;
}
if (flag) return;
if (check(x + 1, y)) p[x + 1][y] = make_pair(x, y);
if (check(x, y + 1)) p[x][y + 1] = make_pair(x, y);
if (check(x, y - 1)) p[x][y - 1] = make_pair(x, y);
if (check(x - 1, y)) p[x - 1][y] = make_pair(x, y);
}
}
void fans(int x, int y) {
e;
now = make_pair(x, y);
for (int i = 2; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
if (a[i][j] == 0) e = make_pair(i, j);
}
}
if (x == ma[a[x][y]].first && y == ma[a[x][y]].second) {
a[x][y] = 0;
return;
}
int xx = ma[a[x][y]].first, yy = ma[a[x][y]].second;
if (x < xx)
ne = make_pair(x + 1, y);
else if (x > xx)
ne = make_pair(x - 1, y);
else if (y > yy)
ne = make_pair(x, y - 1);
else
ne = make_pair(x, y + 1);
++t;
flag = 0;
dfs(ne.first, ne.second);
swap(a[ne.first][ne.second], a[x][y]);
hlp(ind, ne.first, ne.second);
fans(ne.first, ne.second);
}
int32_t main() {
int k;
cin >> n >> k;
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
}
}
if (k == 2 * n) {
bool ok = 0;
for (int i = 1; i <= n; i++) {
if (a[2][i] == a[1][i])
hlp(a[1][i], 1, i), ok = 1, a[2][i] = 0, a[1][i] = 0;
}
for (int i = 1; i <= n; i++) {
if (a[3][i] == a[4][i])
hlp(a[3][i], 4, i), ok = 1, a[3][i] = 0, a[4][i] = 0;
}
if (!ok) return cout << -1, 0;
}
for (int i = 1; i <= 4; i += 3) {
for (int j = 1; j <= n; j++) {
if (a[i][j] == 0) continue;
if (i == 1)
ma[a[i][j]] = make_pair(2, j);
else
ma[a[i][j]] = make_pair(3, j);
}
}
while (true) {
bool vis = 0;
for (int i = 2; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
int tmp = a[i][j];
if (a[i][j]) {
ind = a[i][j];
fans(i, j);
int tm = a[i][j];
a[i][j] = tmp;
if (ma[a[i][j]].first == 2)
hlp(ind, 1, ma[a[i][j]].second);
else
hlp(ind, 4, ma[a[i][j]].second);
a[i][j] = tm;
vis = 1;
}
}
}
if (!vis) break;
}
cout << cnt << endl;
for (int i = 1; i <= cnt; i++)
cout << ans[i].first << " " << ans[i].second.first << " "
<< ans[i].second.second << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, tmp;
cin >> n;
int a[2 * n];
bool ss[2 * n + 1];
for (int i = (0); i < (2 * n); i++) a[i] = -1;
for (int i = (0); i < (2 * n + 1); i++) ss[i] = false;
for (int i = (0); i < (n); i++) {
cin >> a[i * 2];
ss[a[i * 2]] = true;
}
bool is = false;
for (int i = 0; i < 2 * n; i += 2) {
bool is1 = true;
for (int j = (a[i] + 1); j < (2 * n + 1); j++) {
if (!ss[j]) {
a[i + 1] = j;
ss[j] = true;
is1 = false;
break;
}
}
if (is1) {
is = true;
break;
}
}
if (!is) {
for (int i : a) cout << i << ' ';
cout << endl;
} else {
cout << -1 << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n, k;
cin >> n >> k;
long long int a[n], i;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long int mid = (n / 2);
long long int dp[n];
for (i = mid + 1; i < n; i++) dp[i] = a[i] - a[i - 1];
long long int med = a[mid], c = 1;
for (i = mid + 1; i < n; i++) {
if (k >= (dp[i] * c)) {
k -= (dp[i] * c);
med += dp[i];
} else {
med += (k / c);
k -= (k / c) * k;
break;
}
c++;
}
if (k >= c) {
long long int t = n - mid;
med += (long long int)k / t;
}
cout << med;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long MOD = 998244353;
const long long inf = 1e18;
const long long MAX = 2e5 + 1;
inline long long add(long long a, long long b) {
return ((a % mod) + (b % mod)) % mod;
}
inline long long sub(long long a, long long b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
inline long long mul(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
long long pwr(long long x, long long n) {
x = x % mod;
if (!n) return 1;
if (n & 1)
return mul(x, pwr(mul(x, x), (n - 1) / 2));
else
return pwr(mul(x, x), n / 2);
}
long long modinv(long long n) { return pwr(n, mod - 2); }
long long inv(long long i) {
if (i == 1) return 1;
return (MOD - (MOD / i) * inv(MOD % i) % MOD) % MOD;
}
bool f(int a, int b) { return a > b; }
struct cmp {
bool operator()(const int &k1, const int &k2) { return k1 > k2; }
};
int n;
vector<int> graph[200005];
vector<int> vis(200005, 0);
int w, b;
void dfs(int vertex, int val) {
if (val == 0)
w++;
else
b++;
vis[vertex] = 1;
for (int x : graph[vertex]) {
if (!vis[x]) dfs(x, val ^ 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tt = 1;
while (tt--) {
int n;
cin >> n;
int x, y;
for (long long i = 0; i < n - 1; i++) {
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
dfs(1, 0);
cout << min(w, b) - 1;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int oo = 2139063143;
const int N = 1010000;
const int P = 1000000007;
using namespace std;
char buf[1 << 24], *p1 = buf, *p2 = buf, obuf[1 << 23], *O = obuf;
inline void sc(int &x) {
x = 0;
static int p;
p = 1;
static char c;
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
while (!isdigit(c)) {
if (c == '-') p = -1;
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c - 48);
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
}
x *= p;
}
inline void print(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
inline void pr(int x) { print(x), putchar('\n'); }
int b[35];
int ins(int x) {
for (int i = 30; i >= 0; i--)
if (x >> i & 1) {
if (!b[i]) {
b[i] = x;
return i;
}
x ^= b[i];
}
return 33;
}
int query(int x) {
for (int i = 30; i >= 0; i--) x = min(x, x ^ b[i]);
return x;
}
int fa[N], dis[N], siz[N];
int getdis(int &x) {
int ans = 0;
while (x != fa[x]) ans ^= dis[x], x = fa[x];
return ans;
}
struct LY {
int x, y, w;
};
vector<LY> v[N << 2];
int vis[N];
int ax[N], ay[N];
void update(int p, int L, int R, int l, int r, LY x) {
if (l <= L && R <= r) {
v[p].push_back(x);
return;
}
int mid = (L + R) >> 1, ls = p << 1, rs = ls | 1;
if (l <= mid) update(ls, L, mid, l, r, x);
if (r > mid) update(rs, mid + 1, R, l, r, x);
}
int ans[N];
int st[N], z;
void del(int l) {
while (z >= l) b[st[z--]] = 0;
}
int xx[N], yy[N], zz;
void dell(int l) {
while (zz >= l)
siz[fa[xx[zz]]] -= siz[xx[zz]], fa[xx[zz]] = xx[zz], dis[xx[zz]] = 0, --zz;
}
void solve(int p, int l, int r) {
if (!(vis[r] - vis[l - 1])) return;
int he1 = z + 1, he2 = zz + 1;
for (int i = 0; i < (int)v[p].size(); i++) {
int x = v[p][i].x, y = v[p][i].y, w = v[p][i].w;
int dx = getdis(x), dy = getdis(y);
if (x == y) {
st[++z] = ins(dx ^ dy ^ w);
continue;
}
if (siz[x] > siz[y]) swap(x, y), swap(dx, dy);
fa[x] = y, dis[x] = dx ^ dy ^ w, siz[y] += siz[x];
xx[++zz] = x, yy[zz] = y;
}
if (l == r) {
int dx = getdis(ax[l]), dy = getdis(ay[l]);
ans[l] = query(dx ^ dy);
del(he1), dell(he2);
return;
}
int mid = (l + r) >> 1, ls = p << 1, rs = ls | 1;
solve(ls, l, mid);
solve(rs, mid + 1, r);
del(he1);
dell(he2);
}
map<pair<int, int>, int> mp;
int las[N], su[N], sv[N];
int w[N], totw = 0;
int main() {
int n, m;
sc(n), sc(m);
for (int i = 1; i <= n; i++) fa[i] = i, siz[i] = 1;
for (int i = 1; i <= m; i++) {
int u, v;
sc(u), sc(v), sc(w[i]);
mp[make_pair(u, v)] = i;
su[i] = u, sv[i] = v;
}
totw = m;
int q;
sc(q);
for (int i = 1; i <= q; i++) {
int op, u, v;
sc(op), sc(u), sc(v);
if (op == 1)
sc(w[++totw]), mp[make_pair(u, v)] = totw, las[totw] = i, su[totw] = u,
sv[totw] = v;
if (op == 2) {
int bh = mp[make_pair(u, v)];
update(1, 0, q, las[bh], i - 1, (LY){u, v, w[bh]}), las[bh] = -1;
}
if (op == 3) ++vis[i], ax[i] = u, ay[i] = v;
}
for (int i = 1; i <= totw; i++)
if (las[i] != -1) update(1, 0, q, las[i], q, (LY){su[i], sv[i], w[i]});
for (int i = 1; i <= q; i++) vis[i] += vis[i - 1];
memset(ans, -1, sizeof(int) * (q + 1));
solve(1, 0, q);
for (int i = 1; i <= q; i++)
if (ans[i] != -1) pr(ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 7;
const long long INF = 1e9 + 7;
long long n, q;
struct Tree {
long long l, r, mi, lz, sm;
} tr[N * 4];
long long realm(long long p) { return (~tr[p].lz) ? tr[p].lz : tr[p].mi; }
long long reals(long long p) {
return (~tr[p].lz) ? tr[p].lz * (tr[p].r - tr[p].l + 1) : tr[p].sm;
}
void upd(long long p) {
tr[p].mi = min(realm(p * 2), realm(p * 2 + 1));
tr[p].sm = reals(p * 2) + reals(p * 2 + 1);
}
void build(long long l, long long r, long long p) {
tr[p] = (Tree){l, r, 0, -1, 0};
if (l == r) {
scanf("%lld", &tr[p].sm);
tr[p].mi = tr[p].sm;
return;
}
long long mid = (l + r) >> 1;
build(l, mid, p * 2);
build(mid + 1, r, p * 2 + 1);
upd(p);
}
long long lzd(long long p) {
if (~tr[p].lz) {
tr[p].mi = realm(p);
tr[p].sm = reals(p);
tr[p * 2].lz = tr[p].lz;
tr[p * 2 + 1].lz = tr[p].lz;
tr[p].lz = -1;
}
}
long long query(long long p, long long x) {
if (tr[p].l == tr[p].r) return tr[p].l;
lzd(p);
if (realm(p * 2) < x)
return query(p * 2, x);
else
return query(p * 2 + 1, x);
}
void ins(long long p, long long L, long long R, long long v) {
long long l = tr[p].l, r = tr[p].r;
if (L <= l && R >= r) {
tr[p].lz = v;
return;
}
lzd(p);
long long mid = (l + r) >> 1;
if (L <= mid) ins(p * 2, L, R, v);
if (R > mid) ins(p * 2 + 1, L, R, v);
upd(p);
}
long long check(long long p, long long L, long long R) {
long long l = tr[p].l, r = tr[p].r;
if (L <= l && R >= r) return reals(p);
long long mid = (l + r) >> 1, ans = 0;
lzd(p);
if (L <= mid) ans += check(p * 2, L, R);
if (R > mid) ans += check(p * 2 + 1, L, R);
return ans;
}
long long query2(long long p, long long &v) {
long long l = tr[p].l, r = tr[p].r;
if (l == r) return l;
lzd(p);
long long q = reals(p * 2);
if (q > v) return query2(p * 2, v);
v -= q;
return query2(p * 2 + 1, v);
}
int main() {
scanf("%lld%lld", &n, &q);
build(1, n, 1);
while (q--) {
long long op, x, y;
scanf("%lld%lld%lld", &op, &x, &y);
if (op == 1) {
if (realm(1) >= y) continue;
long long t = query(1, y);
if (t > x) continue;
ins(1, t, x, y);
} else {
long long ans = 0;
while (1) {
if (realm(1) > y) break;
long long t = query(1, y + 1);
x = max(x, t);
long long s = (x > 1) ? check(1, 1, x - 1) : 0;
if (reals(1) - s <= y) {
ans += n - x + 1;
break;
}
y += s;
long long u = query2(1, y);
ans += u - x;
x = u;
}
printf("%lld\n", ans);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> in[200005];
int p[200005];
void solve() {
int n;
scanf("%d ", &n);
for (int i = 0; i < n; ++i) {
scanf("%d %d ", &in[i].first, &in[i].second);
}
sort(in, in + n);
int num = 0;
priority_queue<int, vector<int>, greater<int> > pq;
long long ret = 0;
for (int i = n - 1; i >= 0;) {
if (i + 1 + num < in[i].first) {
assert(i + 1 + num + pq.size() >= in[i].first);
while (i + 1 + num < in[i].first) {
++num;
ret += pq.top();
pq.pop();
}
}
int j;
for (j = i; j >= 0; --j) {
if (in[j].first != in[i].first) {
break;
}
pq.push(in[j].second);
}
while (j + 1 + num < in[i].first) {
ret += pq.top();
pq.pop();
++num;
}
i = j;
}
printf("%lld\n", ret);
}
int main() {
int T;
scanf("%d ", &T);
while (T--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, m;
cin >> x >> y >> m;
if (m >= (abs(x) + abs(y))) {
if ((m - (abs(x) + abs(y))) % 2 == 0)
cout << "Yes";
else
cout << "No";
} else
cout << "No";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
int n, k, cnt = 0;
cin >> n >> k;
while (n != 1) {
if (cnt == k - 1 && n > 1) {
v.push_back(n);
cnt++;
break;
}
for (int i = 2; i <= n; i++) {
if (n % i == 0) {
n /= i;
cnt++;
v.push_back(i);
break;
}
}
}
if (cnt == k) {
int ln = v.size();
for (int i = 0; i < ln; i++) {
cout << v[i] << " ";
}
cout << endl;
} else
cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long n, m, c, q, w;
double x[400000], cost[400000], p[400000];
struct data {
double sum, pref, suff, ans;
};
data t[1500000];
data combine(data l, data r) {
data res;
res.sum = l.sum + r.sum;
res.pref = max(l.pref, l.sum + r.pref);
res.suff = max(r.suff, r.sum + l.suff);
res.ans = max(max(l.ans, r.ans), l.suff + r.pref);
return res;
}
data make_data(double val) {
data res;
res.sum = val;
res.pref = res.suff = res.ans = max(double(0), val);
return res;
}
void build(double a[], int v, int tl, int tr) {
if (tl == tr)
t[v] = make_data(a[tl]);
else {
int tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
}
data query(int v, int tl, int tr, int l, int r) {
if (l == tl && tr == r) return t[v];
int tm = (tl + tr) / 2;
if (r <= tm) return query(v * 2, tl, tm, l, r);
if (l > tm) return query(v * 2 + 1, tm + 1, tr, l, r);
return combine(query(v * 2, tl, tm, l, tm),
query(v * 2 + 1, tm + 1, tr, tm + 1, r));
}
int main() {
cin >> n >> m >> c;
long tt;
for (int i = 1; i <= n; i++) {
scanf("%d", &tt);
x[i] = tt;
}
for (int i = 1; i < n; i++) {
scanf("%d", &tt);
p[i] = tt;
}
for (int i = 1; i < n; i++) {
cost[i - 1] = 0.01 * p[i] * (-c) + (x[i + 1] - x[i]) * 0.005 * 100;
}
build(cost, 1, 0, n - 2);
data p;
double answ = 0;
for (int i = 1; i <= m; i++) {
scanf("%d", &q);
scanf("%d", &w);
p = query(1, 0, n - 2, q - 1, w - 2);
answ += max(0.0, p.ans);
}
cout.precision(10);
cout << fixed << answ << endl;
cin.get();
cin.get();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
}
long long fast_pow(long long a, long long b, long long p) {
long long c = 1;
while (b) {
if (b & 1) c = c * a % p;
a = a * a % p;
b >>= 1;
}
return c;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return a;
}
long long gcd = exgcd(b, a % b, y, x);
y -= a / b * x;
return gcd;
}
int a[105];
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
bool flag = false;
for (int i = 1; i < n; i++)
if (a[i - 1] == a[i] - 1) flag = true;
if (flag)
cout << 2 << endl;
else
cout << 1 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
double i, j, n, k;
scanf("%lf%lf", &n, &k);
i = n * pow(1.000000011, k);
printf("%.20lf\n", i);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1111122;
const int M = 200005;
int a[N], v[N];
int main() {
int m, i, j, n, k, r, l, maxx = 0, s = 0, r1, l1;
cin >> n >> k;
memset(v, 0, sizeof(v));
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
r = 1;
l = 1;
while (1) {
if (r > n) break;
while (s < k) {
if (!v[a[r]]) {
s++;
v[a[r]]++;
r++;
} else {
v[a[r]]++;
r++;
}
if (r > n) break;
}
if (maxx < r - l) {
maxx = r - l;
l1 = l;
r1 = r - 1;
}
if (r > n) break;
if (s >= k) {
if (v[a[r]] > 0) {
v[a[r]]++;
r++;
if (maxx < r - l) {
maxx = r - l;
l1 = l;
r1 = r - 1;
}
} else {
if (v[a[l]] > 1) {
v[a[l]]--;
l++;
} else if (v[a[l]] == 1) {
s--;
v[a[l]]--;
l++;
}
}
}
}
cout << l1 << " " << r1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inft = 1000000009;
const int MAXN = 1000006;
const double eps = 1e-15;
inline bool iszero(double first) { return first <= eps && first >= -eps; }
int sgn(double first) { return iszero(first) ? 0 : (first < 0 ? -1 : 1); }
struct pt {
int first, second;
int nr;
pt(double xx = 0, double yy = 0, int nnrr = -1)
: first(xx), second(yy), nr(nnrr) {}
};
bool operator<(const pt &a, const pt &b) {
if (a.first != b.first) return a.first > b.first;
return a.second > b.second;
}
bool praword(pt a, pt b, pt c) {
return 1LL * a.second * b.first * c.first * c.second +
1LL * a.first * a.second * b.second * c.first +
1LL * a.first * b.first * b.second * c.second -
(1LL * a.first * a.second * b.first * c.second +
1LL * a.first * b.second * c.first * c.second +
1LL * a.second * b.first * b.second * c.first) <
0;
}
vector<pt> otoczka(vector<pt> ab) {
sort(ab.begin(), ab.end());
int l = ab.size(), i, j, k;
vector<pt> wyn(l + 1);
if (l < 3) return ab;
j = 0;
for (i = 0; i < l; i++) {
if (i && ab[i].second <= wyn[j - 1].second) continue;
while (j - 2 >= 0 && praword(wyn[j - 2], wyn[j - 1], ab[i])) j--;
wyn[j++] = ab[i];
}
return vector<pt>(wyn.begin(), wyn.begin() + j);
}
map<pair<int, int>, vector<int> > M;
int main() {
int n;
scanf("%d", &n);
vector<pt> A(n);
for (int i = 0; i < (n); ++i) {
int a, b;
scanf("%d%d", &a, &b);
A[i].nr = i;
A[i].first = a;
A[i].second = b;
M[pair<int, int>(A[i].first, A[i].second)].push_back(i);
}
vector<pt> B = otoczka(A);
vector<int> ANS;
for (typeof((B).begin()) it = (B).begin(); it != (B).end(); ++it)
for (typeof((M[pair<int, int>(it->first, it->second)]).begin()) i2 =
(M[pair<int, int>(it->first, it->second)]).begin();
i2 != (M[pair<int, int>(it->first, it->second)]).end(); ++i2)
ANS.push_back(*i2);
sort((ANS).begin(), (ANS).end());
ANS.resize(unique((ANS).begin(), (ANS).end()) - ANS.begin());
for (typeof((ANS).begin()) it = (ANS).begin(); it != (ANS).end(); ++it)
printf("%d ", *it + 1);
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, temp;
scanf("%d %d", &n, &p);
int arr[n];
for (int i = 0; i < n; i++) {
scanf("%d", &temp);
arr[i] = (i == 0) ? temp : (arr[i - 1] + temp) % p;
}
int clast = arr[n - 1];
int max = INT_MIN;
for (int i = 0; i < n; i++) {
int encrypt1 = (clast - arr[i]) % p;
int encrypt2 = (arr[i]) % p;
if (encrypt1 < 0) encrypt1 += p;
if (encrypt1 + encrypt2 > max) {
max = encrypt1 + encrypt2;
}
}
printf("%d\n", max);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
while (1 == 1) {
if (a == 0 || b == 0) {
break;
} else {
if (a >= 2 * b) {
a %= 2 * b;
continue;
} else {
if (b >= 2 * a) {
b %= 2 * a;
continue;
} else {
break;
}
}
}
}
cout << a << " " << b;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> m;
queue<pair<int, int> > q;
const int LAR = 1000000000;
int main() {
int x0, y0, x1, y1;
scanf("%d%d%d%d", &x0, &y0, &x1, &y1);
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int r, a, b;
scanf("%d%d%d", &r, &a, &b);
for (int j = a; j <= b; j++) m[make_pair(r, j)] = LAR;
}
m[make_pair(x0, y0)] = 0;
q.push(make_pair(x0, y0));
while (!q.empty()) {
pair<int, int> u = q.front();
q.pop();
int d = m[u];
if (u == make_pair(x1, y1)) {
printf("%d\n", d);
return 0;
}
for (int d1 = -1; d1 <= 1; d1++)
for (int d2 = -1; d2 <= 1; d2++) {
pair<int, int> v = make_pair(u.first + d1, u.second + d2);
if (m.find(v) != m.end() && d + 1 < m[v]) {
m[v] = d + 1;
q.push(v);
}
}
}
printf("-1\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int t, a, b, i, j;
long long sum;
int sqrtn;
scanf("%d", &t);
for (i=0; i<t; i++){
scanf("%d %d", &a, &b);
sum = 0;
sqrtn = (int)sqrt(a);
for (j=1; j<=sqrtn; j++){
sum += max(0, min(b, a/j-1) - j);
}
printf("%lld\n", sum);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void smain();
int main() {
smain();
return 0;
}
long long n, a, b, res[202][202];
void smain() {
for (; cin >> n >> a >> b;) {
if (a * b < n) {
cout << "-1\n";
continue;
}
for (long long i = 0; i < a; i++)
for (long long j = 0; j < b; j++) res[i][j] = i * b + j + 1;
for (long long i = 0; i < a; i++)
if (i & 1) reverse(res[i], res[i] + b);
for (long long i = 0; i < a; i++) {
for (long long j = 0; j < b; j++)
cout << (res[i][j] > n ? 0 : res[i][j]) << ' ';
cout << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int mod = 1e9 + 7;
const char nl = '\n';
void solve() {
int t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
if (a - b > 1) {
cout << "YES" << nl;
} else {
cout << "NO" << nl;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
;
int beauty[n];
for (int asdf = 0; asdf < n; asdf++) {
cin >> beauty[asdf];
};
map<int, long long int> occ;
long long int most = 0;
for (int i = 0; i < n; i++) {
int x = i - beauty[i];
if (!occ.count(x)) occ[x] = 0LL;
occ[x] = occ[x] + beauty[i];
if (occ[x] > most) most = occ[x];
}
cout << most;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int M = 1e9 + 7;
long long int n, k, m;
long long int z, q, u, a1, l, r, ax, cx, ay, by, cy, ql, qr, d, x, y;
vector<long long int> v[400000];
long long int vis[5000005];
long long int cd[5000005];
long long int a[400000];
unordered_map<long long int, long long int> ml, dp;
void dfs(long long int i, long long int cnt) {}
long long int me(long long int a, long long int b, long long int M) {
if (b == 0)
return 1;
else if (b % 2 == 0)
return me((a * a) % M, b / 2, M);
else
return (a % M * me((a * a) % M, (b - 1) / 2, M) % M) % M;
}
long long int mI(long long int a, long long int m) { return me(a, m - 2, m); }
long long int da[400000];
struct edge {
long long int a, x, y;
} e[400000];
bool cmp(edge ax, edge bx) {
if (ax.a == bx.a) {
if (ax.x == bx.x) return ax.y < bx.y;
return ax.x < bx.x;
}
return ax.a > bx.a;
}
unordered_map<long long int, long long int> fd, fg, w, fh;
pair<long long int, long long int> p[1000006];
int main() {
cin >> n;
string s;
cin >> s;
long long int d, d1;
d = d1 = -1;
for (int j = 0; j < s.length(); j++) {
if (s[j] == s[j - 1]) {
d = j;
break;
}
}
for (int j = n - 1; j >= 0; j--) {
if (s[j] == s[j - 1]) {
d1 = j;
break;
}
}
for (int j = 0; j < n; j++) {
if (s[j] == s[j - 1])
dp[j] = dp[j - 1];
else
dp[j] = dp[j - 1] + 1;
}
if (d != d1) {
dp[n - 1] += 2;
} else if (d >= 0)
dp[n - 1] += 1;
cout << dp[n - 1];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long x;
cin >> x;
if (x == 2)
cout << "1 1\n";
else if (x % 2 == 0) {
x -= 2;
x *= 2;
cout << "2 " << x / 2 << "\n";
} else
cout << "1 " << x - 1 << "\n";
}
signed main() {
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int PI = 3.14159265;
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
fast();
int t;
cin >> t;
while (t--) {
long long x, y, a, b;
cin >> x >> y >> a >> b;
if (x > y) {
swap(x, y);
}
long long ans1, ans2;
ans1 = (x + y) * a;
ans2 = (x * b) + ((y - x) * a);
cout << min(ans1, ans2) << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
int trp1[n + 1], trp2[n + 1], trp3[n + 1];
int k1 = 1, t1 = 1;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
trp1[a] = i;
trp2[i] = a;
trp3[a] = t1;
k1++;
if (k1 > k) {
k1 = 1;
t1++;
}
}
long long int rt = 0;
for (int i = 1; i <= m; i++) {
int a;
cin >> a;
rt += trp3[a];
int pos = trp1[a];
if (pos == 1)
continue;
else {
int e2 = trp2[pos - 1];
swap(trp3[a], trp3[e2]);
trp1[a] = pos - 1;
trp1[e2] = pos;
trp2[pos] = e2;
trp2[pos - 1] = a;
}
}
cout << rt << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100010], d[100010];
int n;
void reset() {
int i;
for (i = 1; i <= 100000; i++) d[i] = 0;
}
void solve() {
int i, x, h, w;
reset();
for (i = 0; i < n; i++) {
scanf("%d %d", &x, &a[i]);
d[x]++;
}
for (i = 0; i < n; i++) {
h = n - 1;
h += d[a[i]];
w = (n - 1) * 2 - h;
printf("%d %d\n", h, w);
}
}
int main() {
while (scanf("%d", &n) > 0) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int Q, q, max1, max2, n, k1, k2, i, nr;
cin >> Q;
for (q = 1; q <= Q; q++) {
cin >> n >> k1 >> k2;
max1 = max2 = 0;
for (i = 1; i <= k1; i++) {
cin >> nr;
if (max1 < nr) max1 = nr;
}
for (i = 1; i <= k2; i++) {
cin >> nr;
if (max2 < nr) max2 = nr;
}
if (max1 > max2)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void inp(T &any) {
cin >> any;
}
template <typename T, typename... U>
inline void inp(T &a, U &...b) {
cin >> a;
inp(b...);
}
template <typename T>
inline istream &operator>>(istream &in, vector<T> &a) {
for (auto &x : a) in >> x;
return in;
}
template <typename T, typename U>
inline istream &operator>>(istream &in, pair<T, U> &a) {
in >> a.first >> a.second;
return in;
}
vector<pair<long long int, long long int>> pos = {
{0, 0}, {0, 3}, {0, 6}, {3, 0}, {3, 3}, {3, 6}, {6, 0}, {6, 3}, {6, 6}};
void solve(long long int &T) {
vector<string> a(9);
for (long long int i = (0); i < (9); i++) {
string x;
for (long long int j = (0); j < (3); j++) {
std::cin >> x;
a[i] += x;
}
}
long long int x, y;
std::cin >> x >> y;
x--, y--;
long long int si = (x / 3) * 3;
long long int sj = (y / 3) * 3;
long long int nxt = 0;
for (long long int i = (si); i < (si + 3); i++) {
bool brk = false;
for (long long int j = (sj); j < (sj + 3); j++) {
if (i == x and j == y) {
brk = true;
break;
}
nxt++;
}
if (brk) break;
}
11;
si = pos[nxt].first;
sj = pos[nxt].second;
long long int add = 0;
for (long long int i = (si); i < (si + 3); i++) {
for (long long int j = (sj); j < (sj + 3); j++) {
if (a[i][j] == '.') {
add++;
a[i][j] = '!';
}
}
}
if (!add) {
for (long long int i = (0); i < (9); i++) {
for (long long int j = (0); j < (9); j++) {
if (a[i][j] == '.') {
a[i][j] = '!';
}
}
}
}
for (long long int i = (0); i < (9); i++) {
for (long long int j = (0); j < (9); j++) {
std::cout << a[i][j];
if (j % 3 == 2) {
std::cout << " ";
}
}
if (i % 3 == 2) {
cout << "\n";
}
cout << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int t = 1;
for (long long int i = (1); i < (t + 1); i++) {
cerr << "Case #" << i << "\n";
solve(i);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
const double eps = 1e-10;
const double pi = acos(-1.0);
inline int read() {
int x = 0, f = 1;
char ch;
ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch & 15);
ch = getchar();
}
if (f)
return x;
else
return -x;
}
int n, a[110], s[110];
int main() {
n = read();
for (int i = 1; i <= n; i++) scanf("%1d", &a[i]);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
for (int i = 1; i <= n; i++) {
int ls = s[n] % i, sh = s[n] / i;
int sum = 0, f = 0;
if ((ls == 0) && (sh != 0)) {
for (int j = 1; j <= n; j++) {
sum += a[j];
if (sum > s[n] / i) {
f = 1;
break;
} else {
sum %= (s[n] / i);
}
}
if (f)
continue;
else if ((sum % (s[n] / i) == 0) && (i > 1)) {
printf("YES\n");
return 0;
}
}
}
if ((n >= 2) && (s[n] == 0))
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 9;
int n;
inline void init() { scanf("%d", &n); }
int sum = 1;
inline void solve() {
for (int i = 3, last = -1, P = 1; i <= n; i++) {
if (i & 1) {
last = (2 * last + 3) % M;
P = (P * 1ll * last) % M;
}
sum = (sum + P) % M;
}
sum = (sum << 1) % M;
sum = (sum * 1ll * sum) % M;
sum = ((sum + 1) << 1) % M;
printf("%d", sum);
}
int main() {
init();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[111111];
int t[111111];
int n, maxbeauty, maxcnt, bestbit;
int V = (1 << 30) - 1;
void read_input() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
}
void write_output() {
printf("%d\n", maxcnt);
int cnt = 0;
for (int i = 0; i < n; i++) {
if ((a[i] / (1 << bestbit)) % 2 == 1) {
cnt++;
printf("%d%s", a[i], (cnt < maxcnt) ? " " : "\n");
}
}
}
void solve() {
for (int i = 0; i < n; i++) t[i] = a[i];
for (int bit = 0; 1 << bit <= a[n - 1]; bit++) {
int ad = V, cnt = 0;
;
for (int i = 0; i < n; i++) {
if (t[i] % 2 == 1) {
ad &= a[i];
cnt++;
}
t[i] /= 2;
}
int beauty = 0;
while (ad % 2 == 0) {
beauty++;
ad /= 2;
}
if (beauty > maxbeauty || (beauty == maxbeauty && cnt > maxcnt)) {
bestbit = bit;
maxbeauty = beauty;
maxcnt = cnt;
}
}
}
int main() {
read_input();
solve();
write_output();
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
bool is_prime(int n) {
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
inline long long getPow(long long a, long long b) {
long long res = 1, tp = a;
while (b) {
if (b & 1ll) {
res *= tp;
res %= 1000000007;
}
tp *= tp;
tp %= 1000000007;
b >>= 1ll;
}
return res;
}
inline long long nxt() {
long long x;
scanf("%lld", &x);
return x;
}
void ok() {
puts("YES");
exit(0);
}
void no() {
puts("NO");
exit(0);
}
long long xx[] = {-1, 1, 0, 0};
long long yy[] = {0, 0, -1, 1};
int main() {
long long l1 = nxt(), r1 = nxt(), l2 = nxt(), r2 = nxt(), k = nxt();
if (l1 >= l2 && l1 <= r2 || r1 >= l2 && r1 <= r2 || l2 >= l1 && l2 <= r1 ||
r2 >= l1 && r2 <= r1) {
long long a = max(l1, l2);
long long b = min(r1, r2);
long long ans = b - a + 1;
if (a <= k && b >= k) {
ans--;
}
cout << ans;
return 0;
}
cout << 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &first, T second) {
first < second ? first = second : T();
}
template <typename T>
void chkmin(T &first, T second) {
first > second ? first = second : T();
}
template <typename T>
void readint(T &first) {
first = 0;
int f = 1;
char c;
for (c = getchar(); !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) first = first * 10 + c - '0';
first *= f;
}
const int MAXN = 100015, DIR[4][2] = {0, 1, 1, 0, 0, -1, -1, 0},
INF = 0x3f3f3f3f;
const char NAME[4] = {'R', 'D', 'L', 'U'};
int n, m, src, sink, ss, tt;
int a[MAXN], ty[MAXN], num[MAXN];
inline int calc(int u, int v) {
int first = v / m - u / m, second = v % m - u % m;
for (int t = 0; t < 4; ++t)
if (DIR[t][0] == first && DIR[t][1] == second) return t;
return -1;
}
struct Edge {
int v, f;
Edge *next, *rev;
} * h[MAXN], pool[MAXN * 15];
int etot = 0;
void addEdge(int u, int v, int f) {
Edge *p = &pool[++etot], *q = &pool[++etot];
p->v = v, p->f = f, p->next = h[u], h[u] = p, p->rev = q;
q->v = u, q->f = 0, q->next = h[v], h[v] = q, q->rev = p;
}
int level[MAXN], q[MAXN];
bool bfs() {
int front = 1, rear = 0;
for (int i = 0; i <= n * m + 3; ++i) level[i] = INF;
level[src] = 1, q[++rear] = src;
while (front <= rear) {
int u = q[front++];
for (Edge *p = h[u]; p; p = p->next)
if (p->f && level[p->v] > level[u] + 1)
level[p->v] = level[u] + 1, q[++rear] = p->v;
if (level[sink] < INF) return 1;
}
return 0;
}
int dfs(int u, int key) {
if (u == sink) return key;
int ans = 0;
for (Edge *p = h[u]; p; p = p->next)
if (p->f && level[p->v] == level[u] + 1) {
int t = dfs(p->v, min(p->f, key));
p->f -= t, p->rev->f += t;
key -= t, ans += t;
if (!key) break;
}
if (!ans) level[u] = INF;
return ans;
}
int dinic() {
int ans = 0;
while (bfs()) ans += dfs(src, INF);
return ans;
}
void solve() {
memset(h, 0, sizeof(h));
memset(ty, -1, sizeof(ty));
memset(num, 0, sizeof(num));
readint(n), readint(m);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) readint(a[i * m + j]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
for (int t = 0; t < 4; ++t) {
int first = i + DIR[t][0], second = j + DIR[t][1];
if (first < 0 || first >= n || second < 0 || second >= m) continue;
if (a[i * m + j] > a[first * m + second]) ty[i * m + j] = t;
if (a[i * m + j] == a[first * m + second] && ((i + j) & 1))
addEdge(i * m + j, first * m + second, 1);
}
ss = n * m, tt = n * m + 1, src = n * m + 2, sink = n * m + 3;
int c1 = 0, c2 = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if ((i + j) & 1) {
if (ty[i * m + j] >= 0)
addEdge(ss, i * m + j, 1);
else
addEdge(src, i * m + j, 1), ++c1;
} else {
if (ty[i * m + j] >= 0)
addEdge(i * m + j, tt, 1);
else
addEdge(i * m + j, sink, 1), ++c2;
}
addEdge(ss, sink, c1), addEdge(src, tt, c2);
addEdge(tt, ss, INF);
int res = dinic();
if (res < c1 + c2) {
printf("NO\n");
return;
}
for (int i = 0; i < n * m; ++i) {
if (!(((i / m) + (i % m)) & 1)) continue;
for (Edge *p = h[i]; p; p = p->next)
if (p->v < n * m && p->rev->f) {
ty[i] = calc(i, p->v), ty[p->v] = ty[i] ^ 2;
num[i] = 1, num[p->v] = a[i] - 1;
break;
}
}
for (int i = 0; i < n * m; ++i)
if (!num[i]) num[i] = a[i] - a[i + DIR[ty[i]][0] * m + DIR[ty[i]][1]];
printf("YES\n");
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) printf("%d ", num[i * m + j]);
putchar('\n');
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) putchar(NAME[ty[i * m + j]]), putchar(' ');
putchar('\n');
}
}
int main() {
int T;
readint(T);
while (T--) solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long bin_exp(long long a, long long n, long long m) {
long long res = 1;
while (n) {
if (n % 2 == 0) {
a = ((a % m) * (a % m)) % m;
n /= 2;
} else {
res = ((res % m) * (a % m)) % m;
--n;
}
}
return res % m;
}
const int val = 105;
vector<int> gra[val];
int lvl1[val], lvl2[val], parent[val];
vector<pair<int, pair<int, int> > > p1(val);
bool visit[val];
int n, m;
void bfs(int root, int lvl[]) {
visit[root] = true;
queue<int> q1;
q1.push(root);
lvl[root] = 0;
parent[root] = -1;
while (!q1.empty()) {
int tar = q1.front();
q1.pop();
for (int i = 0; i < gra[tar].size(); ++i) {
if (visit[gra[tar][i]] != true) {
visit[gra[tar][i]] = true;
q1.push(gra[tar][i]);
lvl[gra[tar][i]] = lvl[tar] + 1;
parent[gra[tar][i]] = tar;
}
}
}
}
void work() {
cin >> n;
int i, x, y, j, k;
for (i = 0; i < n - 1; ++i) {
cin >> x >> y >> p1[i].first;
p1[i].second.first = x;
p1[i].second.second = y;
gra[x].push_back(y);
gra[y].push_back(x);
}
bfs(0, lvl1);
int maxi = -1, root1, root2;
long long max_cost = 0;
for (k = 0; k < n; ++k) {
root2 = k;
vector<int> temp;
x = root2;
temp.push_back(x);
while (parent[x] != -1) {
x = parent[x];
temp.push_back(x);
}
long long cost = 0;
for (i = 0; i < temp.size() - 1; ++i) {
int s = temp[i];
int r = temp[i + 1];
for (j = 0; j < n; ++j) {
if ((s == p1[j].second.first && r == p1[j].second.second) ||
(r == p1[j].second.first && s == p1[j].second.second)) {
cost += p1[j].first;
break;
}
}
}
if (cost > max_cost) max_cost = cost;
}
cout << max_cost;
}
int main() {
int test = 1;
work();
return 0;
}
| 3 |
#include <bits/stdc++.h>
int a[500010], b[500010], u[500010], v[500010], x, y, k, m, id[500010], tmp, n;
double wid[500010], st, en, mid, cur;
bool OK;
int main() {
scanf("%d", &n);
k = m = 1;
for (int i = 0; i < n; i++) {
scanf("%d %d", &x, &y);
if (y > 0) {
a[k] = x, u[k++] = y;
} else {
if (k > 1 and (!tmp)) tmp = m;
id[m] = k - 1;
b[m] = x;
v[m++] = y;
}
}
if (!tmp) {
puts("-1");
return 0;
}
st = 0;
en = 1.5 * (b[tmp] - a[id[tmp]]) / (u[id[tmp]] - v[tmp]);
for (int runs = 0; runs < 66; runs++) {
mid = (st + en) / 2;
for (int i = 1; i < k; i++) {
wid[i] = mid * u[i] + a[i];
if (i - 1 and wid[i] < wid[i - 1]) wid[i] = wid[i - 1];
}
OK = 0;
for (int j = 1; j < m; j++) {
cur = mid * v[j] + b[j];
if (!id[j]) continue;
if (cur < wid[id[j]]) {
OK = 1;
break;
}
}
if (OK)
en = mid;
else
st = mid;
}
printf("%.12lf", en);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int v[100005], mp[100005], p[100005];
int tp[100005];
bool in[100005];
int n, m;
string sa;
void Make() {
int i, j;
m = 0;
for (i = 2; i < 100005; i++) {
if (!v[i]) {
p[m++] = i;
v[i] = i;
}
for (j = 0; j < m && p[j] <= v[i] && i * p[j] < 100005; j++) {
v[i * p[j]] = p[j];
}
}
}
int main() {
int i, k, j;
int x;
cin >> n >> k;
Make();
while (k--) {
cin >> sa >> x;
if (sa[0] == '+') {
if (in[x])
cout << "Already on" << endl;
else {
j = 0;
for (i = x; i > 1; i /= v[i]) tp[j++] = v[i];
for (i = 0; i < j; i++)
if (mp[tp[i]]) {
cout << "Conflict with " << mp[tp[i]] << endl;
break;
}
if (i < j) continue;
cout << "Success" << endl;
for (i = 0; i < j; i++) mp[tp[i]] = x;
in[x] = 1;
}
} else {
if (!in[x])
cout << "Already off" << endl;
else {
j = 0;
for (i = x; i > 1; i /= v[i]) tp[j++] = v[i];
for (i = 0; i < j; i++) mp[tp[i]] = 0;
cout << "Success" << endl;
in[x] = 0;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int belong[100000];
int main() {
int N, A, B;
cin >> N >> A >> B;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
v.push_back(make_pair(a, i));
}
sort(v.begin(), v.end());
for (int i = 0; i < N; i++) belong[i] = -1;
bool ok = true;
for (int i = 0; i < N; i++)
if (belong[v[i].second] == -1) {
int index1 = -1;
int index2 = -1;
int x = lower_bound(v.begin(), v.end(), make_pair(A - v[i].first, 0)) -
v.begin();
if (x < N && v[x].first == A - v[i].first && belong[v[x].second] == -1)
index1 = x;
x = lower_bound(v.begin(), v.end(), make_pair(B - v[i].first, 0)) -
v.begin();
if (x < N && v[x].first == B - v[i].first && belong[v[x].second] == -1)
index2 = x;
if (index1 == -1 && index2 == -1) {
ok = false;
break;
}
int index, b;
if (index1 > index2) {
index = index1;
b = 0;
} else {
index = index2;
b = 1;
}
belong[v[i].second] = b;
belong[v[index].second] = b;
}
if (!ok)
cout << "NO\n";
else {
cout << "YES\n";
for (int i = 0; i < N; i++) cout << belong[i] << " ";
cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 mt_rnd_64(chrono::steady_clock::now().time_since_epoch().count());
long long rnd(long long l, long long r) {
return (mt_rnd_64() % (r - l + 1)) + l;
}
const int N = 5 * 1e5 + 5;
long long n, x, s;
long long a[N], b[N], c[N];
vector<long long> basis;
long long binpow(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res *= a;
a *= a;
n >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
s ^= a[i];
c[i] = a[i] ^ b[i];
}
for (int i = 0; i < n; i++) {
x = c[i];
for (int j = 0; j < basis.size(); j++)
if ((x ^ basis[j]) < x) x ^= basis[j];
for (int j = 0; j < basis.size(); j++)
if ((basis[j] ^ x) < basis[j]) basis[j] ^= x;
if (x != 0) {
basis.push_back(x);
sort(basis.rbegin(), basis.rend());
}
}
for (int i = 0; i < basis.size(); i++)
if ((s ^ basis[i]) < s) s ^= basis[i];
if (s != 0) return cout << "1/1", 0;
long long ans = binpow(2, basis.size());
cout << ans - 1 << '/' << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int maxi(long long int a, long long int b) { return (a > b) ? a : b; }
long long int mini(long long int a, long long int b) { return (a < b) ? a : b; }
int main(int argc, char const *argv[]) {
long long int n, maxx = -1000000000, minx = 1000000000, maxy = -1000000000,
miny = 1000000000, x, y;
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &x);
scanf("%lld", &y);
if (x > maxx) maxx = x;
if (x < minx) minx = x;
if (y > maxy) maxy = y;
if (y < miny) miny = y;
}
long long int area = maxi(abs(maxx - minx), abs(maxy - miny));
area *= area;
cout << area << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long c1, c2, c3, c4, c5;
cin >> c1 >> c2 >> c3 >> c4 >> c5;
long long x = (c1 + c2 + c3 + c4 + c5);
if (x % 5 == 0 && x != 0)
cout << x / 5;
else
cout << "-1";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int Maxn3 = 1e3 + 10;
const long long int Maxn4 = 1e4 + 10;
const long long int Maxn5 = 1e5 + 10;
const long long int Maxn6 = 1e6 + 10;
const long long int Maxn7 = 1e7 + 10;
const long long int Maxn8 = 1e8 + 10;
const long long int Maxn9 = 1e9 + 10;
const long long int Maxn18 = 1e18 + 10;
const long long int Mod1 = 1e7 + 7;
const long long int Mod2 = 1e9 + 7;
const long long int LLMax = LLONG_MAX;
const long long int LLMin = LLONG_MIN;
const long long int INTMax = INT_MAX;
const long long int INTMin = INT_MIN;
long long int mn = LLMax, mx = LLMin;
const int MX = 2e5 + 100;
long long int c[MX];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n, k = 0;
cin >> n;
for (long long int i = 0; i < n; i++) cin >> c[i];
bool m = 0;
for (long long int i = 1; i < n; i++) {
long long int p = abs(c[i] - c[i - 1]);
if (!p) return cout << "NO", 0;
if (p > 1) {
m = 1;
k = p;
break;
}
}
if (!m) {
cout << "YES" << '\n';
return cout << 1 << ' ' << 1000000000, 0;
}
for (long long int i = 1; i < n; i++) {
long long int p = abs(c[i] - c[i - 1]);
if (!p || (p != 1 and p != k) ||
(p == 1 and ((c[i] % k == 0 and c[i - 1] == c[i] + 1) ||
(c[i - 1] % k == 0 and c[i] == c[i - 1] + 1))))
return cout << "NO", 0;
}
cout << "YES" << endl;
cout << 1000000000 << ' ' << k;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> pos;
for (int iter = 0; iter < ((int)s.length()); ++iter)
if (s[iter] == '0') pos.push_back(iter);
int cnt = 0;
int bestans = 1e+9;
for (int l = 0, r = k; r < ((int)pos.size()); ++l, ++r) {
int L = l, R = r;
while (R - L > 3) {
int m1 = L + (R - L) / 3;
int m2 = R - (R - L) / 3;
int val1 = max(pos[m1] - pos[l], pos[r] - pos[m1]);
int val2 = max(pos[m2] - pos[l], pos[r] - pos[m2]);
if (val1 > val2)
L = m1;
else
R = m2;
}
for (int j = L; j <= R; ++j) {
int curans = max(pos[j] - pos[l], pos[r] - pos[j]);
bestans = min(curans, bestans);
}
}
cout << bestans << "\n";
}
int main() {
solve();
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;cin>>t;
while(t--)
{
long long n;
cin>>n;
long long int p,res=0;
for(p=1;p<=n;p=p*10+1)
{
for(int i=1;i<=9;i++)
{
if(i*p<=n)res++;
}
}
cout<<res<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k;
cin >> n >> m >> k;
long long int y = n / k - n + m;
if (y > 0) {
long long int a = 1, b = 2, y0 = max(0ll, y);
y++;
while (y > 0) {
if (y & 1) a = a * b % 1000000009;
b = b * b % 1000000009;
y >>= 1;
}
a -= 2;
if (a < 0) a += 1000000009;
a = a * k % 1000000009;
a += max(0ll, m - k * y0);
if (a >= 1000000009) a -= 1000000009;
cout << a;
} else
cout << m;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, temp, x = 0, min = 0, max = 0;
cin >> n >> m;
int a[m];
int b[m];
for (int i = 0; i < m; i++) {
cin >> a[i];
b[i] = a[i];
}
for (int i = 0; i < n; i++) {
sort(a, a + m);
max = max + a[m - 1];
a[m - 1] = a[m - 1] - 1;
}
sort(b, b + m);
for (int i = 0; i < n; i++) {
if (b[x] == 0) {
x++;
}
min = min + b[x];
b[x] = b[x] - 1;
}
cout << max << " " << min;
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.