solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
inline long long power(long long a, long long b) {
long long x = 1;
a = a % 1000000007ULL;
while (b) {
if (b & 1) x = (x * a) % 1000000007ULL;
a = (a * a) % 1000000007ULL;
b >>= 1;
}
return x;
}
inline long long inv(long long a) { return power(a, 1000000007ULL - 2); }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
const int N = 1e5 + 5;
int n, m, k;
vector<pair<int, pair<int, int> > > edge;
set<int> special;
int par[N], spcl[N], res[N];
int node[N];
int find(int a) { return a == par[a] ? a : par[a] = find(par[a]); }
void join(int a, int b) { par[find(b)] = find(a); }
map<int, int> mpp;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
int u, v, w;
for (int i = 0; i < k; i++) {
cin >> node[i];
spcl[node[i]] = node[i];
}
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
edge.push_back(make_pair(w, make_pair(u, v)));
}
sort(edge.begin(), edge.end());
for (int i = 1; i <= n; i++) par[i] = i;
for (int i = 0; i < m; i++) {
u = find(edge[i].second.first);
v = find(edge[i].second.second);
if (spcl[u] != 0 && spcl[v] != 0 && spcl[u] != spcl[v]) {
res[spcl[u]] = edge[i].first;
res[spcl[v]] = edge[i].first;
}
join(edge[i].second.first, edge[i].second.second);
if (spcl[u] != 0)
spcl[find(edge[i].second.first)] = spcl[u];
else if (spcl[v] != 0)
spcl[find(edge[i].second.first)] = spcl[v];
}
for (int i = 1; i <= n; i++) {
par[i] = find(i);
}
for (int i = 0; i < k; i++) {
if (mpp.find(par[node[i]]) == mpp.end()) mpp[par[node[i]]] = 0;
mpp[par[node[i]]] = max(mpp[par[node[i]]], res[node[i]]);
}
for (int i = 0; i < k; i++) cout << mpp[par[node[i]]] << " ";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, M = 998244353;
set<pair<int, int> > S[N];
int n, m, l, r, x, opt;
struct Tree {
int l, r, num, flag1, flag2;
} T[N * 4];
void split(int id, int x) {
set<pair<int, int> >::iterator iter = S[id].lower_bound(make_pair(x, 1e9));
if (iter == S[id].begin()) return;
iter--;
if ((*iter).second <= x) return;
pair<int, int> now = *iter;
S[id].erase(iter);
S[id].insert(make_pair(now.first, x));
S[id].insert(make_pair(x + 1, now.second));
}
void build(int x, int l, int r) {
T[x].l = l;
T[x].r = r;
T[x].flag1 = 1;
if (T[x].l == T[x].r) return;
int mid = (l + r) / 2;
build(x * 2, l, mid);
build(x * 2 + 1, mid + 1, r);
}
void down(int x) {
T[x * 2].num = ((long long)T[x * 2].num * T[x].flag1 +
(long long)T[x].flag2 * (T[x * 2].r - T[x * 2].l + 1)) %
M;
T[x * 2].flag1 = (long long)T[x * 2].flag1 * T[x].flag1 % M;
T[x * 2].flag2 = ((long long)T[x * 2].flag2 * T[x].flag1 + T[x].flag2) % M;
T[x * 2 + 1].num =
((long long)T[x * 2 + 1].num * T[x].flag1 +
(long long)T[x].flag2 * (T[x * 2 + 1].r - T[x * 2 + 1].l + 1)) %
M;
T[x * 2 + 1].flag1 = (long long)T[x * 2 + 1].flag1 * T[x].flag1 % M;
T[x * 2 + 1].flag2 =
((long long)T[x * 2 + 1].flag2 * T[x].flag1 + T[x].flag2) % M;
T[x].flag1 = 1;
T[x].flag2 = 0;
}
void insert1(int x, int l, int r, int z) {
if (T[x].l > r || l > T[x].r) return;
if (T[x].l >= l && T[x].r <= r) {
T[x].num = (long long)T[x].num * z % M;
T[x].flag1 = (long long)T[x].flag1 * z % M;
T[x].flag2 = (long long)T[x].flag2 * z % M;
return;
}
down(x);
insert1(x * 2, l, r, z);
insert1(x * 2 + 1, l, r, z);
T[x].num = (T[x * 2].num + T[x * 2 + 1].num) % M;
}
void insert2(int x, int l, int r) {
if (T[x].l > r || l > T[x].r) return;
if (T[x].l >= l && T[x].r <= r) {
(T[x].num += T[x].r - T[x].l + 1) %= M;
T[x].flag2++;
return;
}
down(x);
insert2(x * 2, l, r);
insert2(x * 2 + 1, l, r);
T[x].num = (T[x * 2].num + T[x * 2 + 1].num) % M;
}
int find(int x, int l, int r) {
if (T[x].l > r || l > T[x].r) return 0;
if (T[x].l >= l && T[x].r <= r) return T[x].num;
down(x);
return (find(x * 2, l, r) + find(x * 2 + 1, l, r)) % M;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) S[i].insert(make_pair(1, n));
build(1, 1, n);
while (m--) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%d%d%d", &l, &r, &x);
split(x, l - 1);
split(x, r);
insert1(1, l, r, 2);
while (1) {
set<pair<int, int> >::iterator iter = S[x].lower_bound(make_pair(l, 0));
if (iter == S[x].end() || (*iter).first > r) break;
insert1(1, (*iter).first, (*iter).second, M / 2 + 1);
insert2(1, (*iter).first, (*iter).second);
S[x].erase(iter);
}
} else {
scanf("%d%d", &l, &r);
printf("%d\n", find(1, l, r));
}
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double EPS = 1e-6;
const int MOD = (int)1e9 + 7;
bool Reverse(long long a, long long b) { return a > b; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, mx = 0, mn = 999999999999999999;
cin >> n;
vector<pair<pair<long long, long long>, long long> > v;
for (int i = 1; i <= sqrt(n); i++)
if (n % i == 0) v.push_back({{1, i}, n / i});
long long siz = v.size();
for (int j = 0; j < siz; j++) {
long long loop = v[j].first.second;
long long loop2 = v[j].second;
for (int i = 2; i <= sqrt(loop); i++)
if (loop % i == 0) v.push_back({{i, loop / i}, loop2});
for (int i = 2; i <= sqrt(loop2); i++)
if (loop2 % i == 0) v.push_back({{loop, i}, loop2 / i});
}
for (int i = 0; i < v.size(); i++) {
vector<long long> v2;
v2.push_back(v[i].first.first);
v2.push_back(v[i].first.second);
v2.push_back(v[i].second);
sort(v2.begin(), v2.end());
mx = max(mx, (v2[0] + 1) * (v2[1] + 2) * (v2[2] + 2));
mx = max(mx, (v2[1] + 1) * (v2[0] + 2) * (v2[2] + 2));
mx = max(mx, (v2[2] + 1) * (v2[0] + 2) * (v2[1] + 2));
mn = min(mn, (v2[0] + 1) * (v2[1] + 2) * (v2[2] + 2));
mn = min(mn, (v2[1] + 1) * (v2[0] + 2) * (v2[2] + 2));
mn = min(mn, (v2[2] + 1) * (v2[0] + 2) * (v2[1] + 2));
}
cout << mn - n << " " << mx - n << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, M = 12e5 + 5;
vector<int> adj[N];
void add(int a, int b) {
adj[a].push_back(b);
adj[b].push_back(a);
}
bitset<N> B;
char C[N];
int SZ[N], IND[N], CNT[M], n, a, b, TV[21];
long long ans[N], ANS[N];
int get(int x) { return (TV[x]); }
int getsize(int u, int p) {
int sm = 1;
for (auto x : adj[u])
if (x ^ p && !B[x]) sm += getsize(x, u);
return (SZ[u] = sm);
}
int findc(int u, int p, int sz) {
int rt = u;
for (auto x : adj[u])
if (x ^ p && !B[x] && SZ[x] * 2 >= sz) rt = findc(x, u, sz);
return (rt);
}
void Do(int u, int p, int d, bool f) {
d ^= get(IND[u]);
CNT[d] += f ? 1 : -1;
for (auto x : adj[u])
if (x ^ p && !B[x]) Do(x, u, d, f);
}
void updans(int u, int p, int d) {
d ^= get(IND[u]);
ANS[u] = CNT[d];
for (int i = 0; i < 20; i++) ANS[u] += CNT[d ^ get(i)];
for (auto x : adj[u])
if (x ^ p && !B[x]) updans(x, u, d), ANS[u] += ANS[x];
ans[u] += ANS[u];
}
void darkol(int u) {
int sz = getsize(u, 0);
u = findc(u, 0, sz);
B[u] = 1;
for (auto x : adj[u])
if (!B[x]) darkol(x);
B[u] = 0;
CNT[0] = 1;
for (auto x : adj[u])
if (!B[x]) {
updans(x, u, get(IND[u]));
ans[u] += ANS[x];
Do(x, u, 0, 1);
}
for (auto x : adj[u])
if (!B[x]) Do(x, u, 0, 0);
CNT[0]--;
reverse(adj[u].begin(), adj[u].end());
for (auto x : adj[u])
if (!B[x]) {
updans(x, u, get(IND[u]));
Do(x, u, 0, 1);
}
for (auto x : adj[u])
if (!B[x]) Do(x, u, 0, 0);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) scanf("%d %d", &a, &b), add(a, b);
scanf("%s", C);
for (int i = 1; i <= n; i++) IND[i] = C[i - 1] - 'a';
TV[0] = 1LL;
for (int i = 1; i < 20; i++) TV[i] = TV[i - 1] << 1;
darkol(1);
for (int i = 1; i <= n; i++) printf("%I64d ", ans[i] + 1);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t ;
while(t--)
{
int x ;
cin>>x ;
int sum = 0 ;
int k = 1 ;
while(sum<x)
{
sum += k ;
k++ ;
}
k-- ;
if(sum == x || sum-x >=2)
{
cout<<k<<endl;
continue ;
}
cout<<k+1<<endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
long long t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
long long p;
if (isPrime(a + b) && (a - b) == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int k, i;
cin >> k;
int a[k];
for (i = 0; i < k; i++) cin >> a[i];
sort(a, a + k);
int le = a[k - 1];
int ans = max(0, (le - 25));
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n, m;
struct point {
long long x, y;
int id;
};
point a[N], b[N];
int cmp1(point a, point b) { return a.x < b.x || (a.x == b.x && a.y < b.y); }
int cmp2(point a, point b) { return a.y < b.y || (a.y == b.y && a.x < b.x); }
int mark[N];
long long ans = 1e18;
void calc(int xl, int xr, int yl, int yr) {
while (mark[a[xl].id]) xl++;
while (mark[a[xr].id]) xr--;
long long x1, x2, y1, y2;
x1 = a[xl].x;
x2 = a[xr].x;
y1 = b[yl].y;
y2 = b[yr].y;
long long x, y;
x = (x2 - x1 + 1) / 2;
y = (y2 - y1 + 1) / 2;
x = x ? x : 1;
y = y ? y : 1;
long long tmp = x * y;
if (tmp < ans) ans = tmp;
}
void dfsy(int m, int xl, int xr) {
int l, r, i, j;
l = r = 0;
for (i = -1; i < n; i++) {
if (l > m) break;
if (i >= 0) l += 0 == mark[b[i].id]++;
if (l > m) break;
r = 0;
for (j = n; j >= 0; j--)
if (l + r > m)
break;
else {
if (j < n) r += 0 == mark[b[j].id]++;
if (l + r > m) break;
calc(xl, xr, i + 1, j - 1);
}
for (j; j < n; j++) mark[b[j].id]--;
}
for (i; i >= 0; i--) mark[b[i].id]--;
}
void dfsx() {
for (int i = -1; i < n; i++) {
if (i > m) break;
if (i >= 0) mark[a[i].id]++;
for (int j = n; j >= 0; j--)
if (i + 1 + n - j > m)
break;
else {
if (j < n) mark[a[j].id]++;
dfsy(m - i - 1 - (n - j), i + 1, j - 1);
}
for (int j = n - 1; j >= 0; j--)
if (i + 1 + n - j > m)
break;
else
mark[a[j].id]--;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
a[i] = b[i] = (point){x1 + x2, y1 + y2, i};
}
sort(a, a + n, cmp1);
sort(b, b + n, cmp2);
memset(mark, 0, sizeof(mark));
dfsx();
cout << ans;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50;
int n, k, m;
int A[maxn];
int main() {
while (scanf("%d %d %d", &n, &k, &m) == 3) {
for (int i = 0; i < k; ++i) scanf("%d", A + i);
sort(A, A + k);
int sum = 0;
for (int i = 0; i < k; ++i) sum += A[i];
int res = 0;
for (int i = 0; i <= n; ++i) {
int temp = 0;
if (i * sum > m) break;
temp += i * (k + 1);
int lm = m - sum * i, ln = n - i;
for (int j = 0; j < k; ++j) {
int d = lm / A[j];
if (d > ln)
lm -= A[j] * ln, temp += ln;
else {
temp += d;
break;
}
}
if (temp > res) res = temp;
}
printf("%d\n", res);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s, t = "<3", st;
for (int i = 0; i < n; i++) {
cin >> st;
t += st + "<3";
}
cin >> s;
int ptr = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == t[ptr]) {
ptr++;
if (ptr == t.length()) {
cout << "yes";
return 0;
}
}
}
cout << "no";
cin >> n;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d;
string s;
cin >> d >> s;
if (d == 1) {
cout << "Impossible" << endl;
exit(0);
}
vector<int> v;
v.push_back(-1);
for (int i = 0; i < int(s.size()); i++) {
v.push_back(int(s[i]) - 'a');
v.push_back(-1);
}
int cotapos, cotaneg;
if (d % 2 == 1) {
cotapos = d - 1;
cotaneg = d;
} else {
cotapos = d;
cotaneg = d - 1;
}
int n = int(v.size());
vector<int> cota(n);
for (int i = 0; i < n; i++)
if (v[i] >= 0)
cota[i] = cotapos;
else
cota[i] = cotaneg;
vector<int> r(n);
r[0] = 0;
int imax = 0;
for (int i = 1; i < n; i++) {
if (imax + r[imax] > i) {
if (i + r[imax - (i - imax)] < imax + r[imax]) {
r[i] = r[imax - (i - imax)];
} else {
r[i] = imax + r[imax] - i;
while (0 < i - r[i] and i + r[i] < n - 1 and
v[i - r[i] - 1] == v[i + r[i] + 1])
r[i]++;
imax = i;
}
} else {
r[i] = 0;
while (0 < i - r[i] and i + r[i] < n - 1 and
v[i - r[i] - 1] == v[i + r[i] + 1])
r[i]++;
imax = i;
}
}
vector<int> anular(n, 0);
vector<set<int> > prohibido(n);
for (int i = 0; i < n; i++)
if (cota[i] <= r[i])
anular[i + cota[i]] = 1;
else if (cota[i] == r[i] + 1 and i - r[i] - 1 >= 0 and i + r[i] + 1 < n)
prohibido[i + r[i] + 1].insert(v[i - r[i] - 1]);
int index = 0;
while (index < n and not anular[index]) index++;
if (index == n) index--;
int val;
while (index >= 0) {
if (v[index] < 0) {
index--;
continue;
}
val = v[index] + 1;
while (prohibido[index].count(val) > 0) val++;
if (val < 26) break;
index--;
}
if (index < 0) {
cout << "Impossible" << endl;
exit(0);
}
v[index] = val;
for (int i = index + 1; i < n; i++)
if (v[i] >= 0) v[i] = 0;
imax = 0;
for (int i = 1; i < n; i++) {
if (imax + r[imax] > i) {
if (i + r[imax - (i - imax)] < imax + r[imax]) {
r[i] = r[imax - (i - imax)];
} else {
r[i] = imax + r[imax] - i;
while (0 < i - r[i] and i + r[i] < n - 1 and
v[i - r[i] - 1] == v[i + r[i] + 1] and r[i] < cota[i])
r[i]++;
if (r[i] == cota[i]) {
v[i + r[i]]++;
int iant = i - 1;
if (iant + cota[iant] == i + r[i] and iant - cota[iant] >= 0 and
r[iant] == cota[iant] - 1 and
v[iant - cota[iant]] == v[iant + cota[iant]])
v[iant + cota[iant]]++;
r[i]--;
}
imax = i;
}
} else {
r[i] = 0;
while (0 < i - r[i] and i + r[i] < n - 1 and
v[i - r[i] - 1] == v[i + r[i] + 1] and r[i] < cota[i])
r[i]++;
if (r[i] == cota[i]) {
v[i + r[i]]++;
int iant = i - 1;
if (iant + cota[iant] == i + r[i] and iant - cota[iant] >= 0 and
r[iant] == cota[iant] - 1 and
v[iant - cota[iant]] == v[iant + cota[iant]])
v[iant + cota[iant]]++;
r[i]--;
}
imax = i;
}
}
for (int i = 0; i < n; i++)
if (v[i] >= 0) cout << char(v[i] + 'a');
cout << endl;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_ELEMENT = 100000;
int main() {
int i, j;
int N, M;
int s, e;
cin >> N >> M >> s >> e;
vector<int> a(N), b(M);
vector<int> indexes[MAX_ELEMENT + 2];
for (i = 0; i < N; i++) cin >> a[i];
for (i = 0; i < M; i++) {
cin >> b[i];
indexes[b[i]].push_back(i);
}
int lim = s / e + 1;
int ans = 0;
vector<int> d(lim + 1, 1E9);
d[0] = -1;
for (i = 0; i < N; i++) {
for (j = lim; j >= 1; j--) {
int k =
upper_bound(indexes[a[i]].begin(), indexes[a[i]].end(), d[j - 1]) -
indexes[a[i]].begin();
if (k < indexes[a[i]].size()) {
int num = indexes[a[i]][k];
d[j] = min(d[j], num);
if (e * j + d[j] + 1 + i + 1 <= s) ans = max(ans, j);
}
}
}
cout << ans << endl;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int max_digit(ll n) {
int max = 0;
do {
int a = n % 10;
if (a > max) max = a;
n /= 10;
} while (n != 0);
return max;
}
int main() {
ll n;
cin >> n;
int steps = 0;
while (n != 0) {
n -= max_digit(n);
steps++;
}
cout << steps;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &num) {
T x = 0, f = 1;
char ch = getchar();
for (; ch > '9' || ch < '0'; ch = getchar())
if (ch == '-') f = -1;
for (; ch <= '9' && ch >= '0'; ch = getchar())
x = (x << 3) + (x << 1) + (ch ^ '0');
num = x * f;
}
int n, m, Q, id[1005][1005], fa[1100005], siz[1100005], lst[1005][1005],
X[1005 * 10], Y[1005 * 10], cnt;
int chg[1005][2], tot;
int dx[] = {1, -1, 0, 0, 1, 1, -1, -1, 0},
dy[] = {0, 0, 1, -1, 1, -1, 1, -1, 0};
char s[1005][1005];
set<int> st[1100005];
inline bool ok(int x, int y) { return 0 <= x && x <= n && 0 <= y && y <= m; }
int find(int x) { return fa[x] == x ? x : find(fa[x]); }
inline void merge(int x, int y) {
int tx = find(x), ty = find(y);
if (tx == ty) return;
if (siz[tx] < siz[ty]) swap(tx, ty);
fa[ty] = tx;
siz[tx] += siz[ty];
chg[++tot][0] = tx;
chg[tot][1] = ty;
}
void dfs(int x, int y, int d, int dddd) {
if ((x == 1 && y == 1) || (x == n - 1 && y == m - 1)) return;
if (s[x][y] == '#') st[dddd].insert(find(id[x][y]));
if (d == 2) return;
for (int i = 0; i < 8; i++) {
int tx = x + dx[i], ty = y + dy[i];
if (!ok(tx, ty)) continue;
dfs(tx, ty, d + 1, dddd);
}
}
int solve() {
int S = find(id[0][m]), T = find(id[n][0]);
for (int i = 1; i <= cnt; i++) {
for (int k = 0; k < 9; k++) {
int tx = X[i] + dx[k], ty = Y[i] + dy[k];
if (!ok(tx, ty) || s[tx][ty] == '.') continue;
int pos = lst[tx][ty];
if (find(id[tx][ty]) == S) {
for (auto P : st[pos]) {
if (find(P) == T) return puts("NO"), P;
}
}
if (find(id[tx][ty]) == T) {
for (auto P : st[pos]) {
if (find(P) == S) return puts("NO"), 2;
}
}
}
}
for (int i = 1; i <= cnt; i++)
for (int j = i + 1; j <= cnt; j++) {
if (max(abs(X[i] - X[j]), abs(Y[i] - Y[j])) <= 2) {
if (find(id[X[i]][Y[i]]) == S && find(id[X[j]][Y[j]]) == T)
return puts("NO"), 3;
if (find(id[X[i]][Y[i]]) == T && find(id[X[j]][Y[j]]) == S)
return puts("NO"), 3;
}
}
puts("YES");
return 0;
}
int main() {
read(n);
read(m);
read(Q);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
++n;
++m;
for (int i = 0; i <= n; i++) s[i][0] = s[i][m] = '#';
for (int j = 0; j <= m; j++) s[0][j] = s[n][j] = '#';
s[0][0] = s[0][1] = s[1][0] = s[n][m] = s[n - 1][m] = s[n][m - 1] = '.';
int iid = 0;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) fa[id[i][j] = ++iid] = iid, siz[iid] = 1;
for (int x = 0; x <= n; x++)
for (int y = 0; y <= m; y++) {
if (s[x][y] == '.') continue;
for (int k = 0; k < 8; k++) {
int tx = x + dx[k], ty = y + dy[k];
if (!ok(tx, ty) || s[tx][ty] == '.') continue;
merge(id[x][y], id[tx][ty]);
}
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) dfs(i, j, 0, find(id[i][j]));
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) lst[i][j] = find(id[i][j]);
for (int ii = 1; ii <= Q; ii++) {
read(cnt);
tot = 0;
for (int i = 1; i <= cnt; i++) read(X[i]), read(Y[i]);
for (int i = 1; i <= cnt; i++) {
s[X[i]][Y[i]] = '#';
for (int k = 0; k < 8; k++) {
int tx = X[i] + dx[k], ty = Y[i] + dy[k];
if (!ok(tx, ty) || s[tx][ty] == '.') continue;
merge(id[X[i]][Y[i]], id[tx][ty]);
}
}
solve();
fflush(stdout);
for (int i = 1; i <= tot; i++) {
fa[chg[i][1]] = chg[i][1];
siz[chg[i][0]] -= siz[chg[i][1]];
}
for (int i = 1; i <= cnt; i++) s[X[i]][Y[i]] = '.';
}
return 0;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 4;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
cin >> s;
long long n = s.size();
long long sub = 0;
for (int k = 1; k <= 8; k++) {
for (int i = 0; i + k <= n; i++) {
bool flag = false;
for (int j = 1; 2 * j < k; j++) {
for (int st = i; st + 2 * j < i + k; st++) {
if (s[st] == s[st + j] && s[st] == s[st + 2 * j]) {
flag = true;
}
}
}
if (!flag) sub++;
}
}
cout << n * (n + 1) / 2 - sub << '\n';
}
| 11 |
#include <bits/stdc++.h>
int main() {
long long n, x, y, o, overplus, numb;
int I;
scanf("%lld", &n);
if (n == 0) {
printf("0 0\n");
return 0;
}
o = (1 + (int)sqrtl((long double)(1 + (n - 1) * 4 / 3))) / 2;
overplus = n - ((6 + 6 * (o - 1)) * (o - 1) / 2 + 1);
I = overplus / o;
numb = overplus % o;
switch (I) {
case 0:
x = 2 * o - 1 - numb;
y = 2 * numb + 2;
break;
case 1:
x = o - 2 - 2 * numb;
y = 2 * o;
break;
case 2:
x = -o - 1 - numb;
y = 2 * o - 2 - 2 * numb;
break;
case 3:
x = -(2 * o - 1 - numb);
y = -(2 * numb + 2);
break;
case 4:
x = -(o - 2 - 2 * numb);
y = -(2 * o);
break;
case 5:
x = -(-o - 1 - numb);
y = -(2 * o - 2 - 2 * numb);
break;
default:
break;
}
printf("%lld %lld\n", x, y);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1000000007;
long double EPS = 1e-9;
template <class second, class T>
ostream& operator<<(ostream& os, const pair<second, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const unordered_set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class second, class T>
ostream& operator<<(ostream& os, const unordered_map<second, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class second, class T>
ostream& operator<<(ostream& os, const map<second, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
void dbs(string str, T t) {
cerr << str << " : " << t << "\n";
}
template <class T, class... second>
void dbs(string str, T t, second... s) {
int idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
template <class T>
void prc(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
void pre() {}
vector<long long int> z_function(string& s) {
long long int n = s.length();
vector<long long int> z(n);
for (long long int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) {
z[i] = min(r - i + 1, z[i - l]);
}
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) {
++z[i];
}
if (i + z[i] - 1 > r) {
l = i, r = i + z[i] - 1;
}
}
return z;
}
void solve() {
string s;
cin >> s;
vector<long long int> zz = z_function(s);
zz[0] = s.length();
map<int, int> mp;
for (long long int i = 0; i < s.length(); ++i) {
if (zz[i]) mp[zz[i]]++;
}
vector<pair<long long int, long long int> > arr((mp).begin(), (mp).end());
reverse((arr).begin(), (arr).end());
for (int i = 1; i < arr.size(); i++) {
arr[i].second += arr[i - 1].second;
}
reverse((arr).begin(), (arr).end());
vector<pair<long long int, long long int> > fin;
for (auto v : arr) {
if (zz[s.length() - v.first] == v.first) fin.emplace_back(v);
}
cout << fin.size() << '\n';
for (long long int i = 0; i < fin.size(); ++i) {
cout << fin[i].first << " " << fin[i].second << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
pre();
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int64_t mod = 1e9 + 7;
const int N = 2e5 + 1;
int ar[N], n, per, av[N];
int main() {
int a, b, day = 0;
cin >> n >> per;
for (int i = 0; i < n; i++) {
cin >> a >> b;
day = max(day, a);
av[a] += b;
}
int x = 0, mn, rem;
for (int i = 1; i <= day + 1; i++) {
rem = per;
mn = min(rem, av[i - 1]);
rem -= mn, av[i - 1] -= mn;
x += mn;
mn = min(rem, av[i]);
rem -= mn, av[i] -= mn;
x += mn;
}
cout << x;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200005];
int vis[200005];
long long int v;
void dfs(int s, int t) {
v++;
vis[s]++;
for (auto x : g[s]) {
if (vis[x] == 0 and x != t) dfs(x, t);
}
}
int main() {
int t;
cin >> t;
while (t--) {
int n, m, a, b;
cin >> n >> m;
cin >> a >> b;
for (int i = 0; i <= n; i++) {
g[i].clear();
vis[i] = 0;
}
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
long long x, y;
v = 0;
dfs(a, b);
x = v;
x = n - x - 1;
v = 0;
for (int i = 0; i <= n; i++) {
vis[i] = 0;
}
dfs(b, a);
y = v;
y = n - y - 1;
cout << x * y << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, d;
cin >> n >> d;
int a[n], b[n], mx[n];
int temp = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
temp += a[i];
b[i] = temp;
}
mx[n - 1] = b[n - 1];
for (int i = n - 2; i >= 0; --i) {
mx[i] = max(mx[i + 1], b[i]);
}
int ans = 0;
temp = 0;
for (int i = 0; i < n; ++i) {
if (b[i] + temp > d) {
cout << -1 << '\n';
;
return 0;
}
if (a[i] == 0) {
if (b[i] + temp < 0) {
int curr = 0 - b[i] - temp;
if (curr > d - (mx[i] + temp)) {
cout << -1 << '\n';
;
return 0;
}
curr = d - mx[i] - temp;
temp += curr;
ans++;
}
}
}
cout << ans << '\n';
;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5, mod = 1e9 + 7, mod1 = 998242353, mod2 = 1e9 + 9,
inf = 1e9 + 7;
const long long infll = 1e18 + 7;
long long n;
pair<long long, long long> a[N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a + 1, a + 1 + n);
cout << a[n].second << ' ' << a[n - 1].first;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int base = 100003;
const int maxn = 300005;
struct data {
int u, v;
long long w;
} edge[maxn];
int n, m;
vector<pair<int, int> > ke[maxn];
int useless[maxn], par[maxn];
long long d[maxn], weight[maxn];
void DIJK(int s) {
for (int i = 1; i <= n; ++i) d[i] = weight[i] = 1e18;
d[s] = weight[s] = 0;
priority_queue<pair<long long, int> > PQ;
PQ.push({-d[s], s});
while (PQ.size()) {
int u = PQ.top().second;
long long l = -PQ.top().first;
PQ.pop();
if (l > d[u]) continue;
for (auto p : ke[u]) {
int v = p.first, id = p.second;
long long w = edge[id].w;
if (d[v] > d[u] + w) {
par[v] = id;
d[v] = d[u] + w;
PQ.push({-d[v], v});
} else if (d[v] == d[u] + w) {
par[v] = id;
}
}
}
}
void Solve() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int u, v, w;
cin >> u >> v >> w;
ke[u].push_back({v, i});
ke[v].push_back({u, i});
edge[i] = {u, v, w};
}
int s;
cin >> s;
DIJK(s);
long long ans = 0;
for (int i = 1; i <= n; ++i) ans += edge[par[i]].w;
cout << ans << "\n";
for (int i = 1; i <= n; ++i) {
if (i != s) cout << par[i] << " ";
}
}
void NumTime() {
cerr << "Toi Di Chep Code"
<< "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
if (fopen("CF"
".inp",
"r")) {
freopen(
"CF"
".inp",
"r", stdin);
freopen(
"CF"
".out",
"w", stdout);
}
int test = 1;
NumTime();
while (test--) {
Solve();
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct elem {
int l, p, t, ind;
elem() {}
elem(int inl, int inp, int intt, int inind) {
l = inl;
p = inp;
t = intt;
ind = inind;
}
};
int base = 315;
int n;
elem v[1000000];
int btmax[1000000];
int bttope[1000000];
int cuantos[1000000];
int bdesp[1000000];
void recalcula(int b) {
int ini = b * base;
int fin = ini + cuantos[b] - 1;
int &tmax = btmax[b];
int &ttope = bttope[b];
int &desp = bdesp[b];
for (int i = ini; i <= fin; i++) v[i].p -= desp;
tmax = 0;
ttope = 2000000000;
desp = 0;
for (int i = fin; i >= ini; i--) {
tmax = max(tmax, min(v[i].t, ttope));
ttope = min(ttope, v[i].p - v[i].l);
}
}
int ianterior(int b) {
for (; b >= 0; b--)
if (cuantos[b]) return base * b + cuantos[b] - 1;
return -1;
}
void elimina(int b, int ttope, int iultimo) {
recalcula(b);
int ini = b * base;
int fin = ini + cuantos[b] - 1;
int tmax = 0, imax;
for (int i = fin; i >= ini and tmax < ttope; i--) {
if (v[i].t > tmax) {
tmax = min(v[i].t, ttope);
imax = i;
}
ttope = min(ttope, v[i].p - v[i].l);
}
if (imax == iultimo)
cout << -1 << endl;
else
cout << v[imax].ind << endl;
for (int i = imax; i < fin; i++) {
v[i] = v[i + 1];
v[i].p -= tmax;
}
cuantos[b]--;
recalcula(b);
int bultimo = iultimo / base;
b++;
for (; b <= bultimo; b++) {
bdesp[b] += tmax;
if (btmax[b] >= bttope[b] - bdesp[b]) recalcula(b);
}
recalcula(bultimo);
}
void elimina(int iultimo) {
int b = iultimo / base;
int tmax = 0, ttope = 2000000000, bmax;
for (; b >= 0; b--) {
if (max(tmax, btmax[b]) >= min(ttope, bttope[b] - bdesp[b])) {
if (btmax[b] > tmax) {
elimina(b, ttope, iultimo);
return;
}
elimina(bmax, 2000000000, iultimo);
return;
}
if (btmax[b] > tmax) {
tmax = btmax[b];
bmax = b;
}
ttope = min(ttope, bttope[b] - bdesp[b]);
}
elimina(bmax, 2000000000, iultimo);
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
int l, r, t;
cin >> l >> r >> t;
if (i == 1) {
cout << 0 << endl;
v[0] = elem(l, l, t, i);
cuantos[0]++;
recalcula(0);
} else {
int b = (i - 1) / base;
int iultimo, iant;
if (cuantos[b]) {
iant = b * base + cuantos[b] - 1;
iultimo = iant + 1;
} else {
iant = ianterior(b - 1);
iultimo = b * base;
}
v[iultimo] =
elem(l, max(l, v[iant].p - bdesp[iant / base] + v[iant].t), t, i);
cuantos[b]++;
recalcula(b);
if (v[iultimo].p + t - 1 <= r) {
cout << 0 << endl;
} else {
elimina(iultimo);
}
}
}
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
char s[maxn], t[maxn];
int dp[maxn][maxn], pa[maxn][26], pb[maxn][26];
int main() {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
scanf("%s%s", s + 1, t + 1);
for (int i = 1; i <= n; ++i) s[i] -= 'a', t[i] -= 'a';
for (int i = 1; i <= n; ++i)
for (int j = 0; j < 26; ++j)
pa[i][j] = pa[i - 1][j] + (s[i] == j),
pb[i][j] = pb[i - 1][j] + (t[i] == j);
bool flag = 1;
for (int j = 0; j < 26; ++j)
if (pa[n][j] != pb[n][j]) flag = 0;
if (!flag)
puts("-1");
else {
for (int j = 0; j <= n; ++j) dp[0][j] = 0;
for (int i = 1; i <= n; ++i)
for (int j = i; j <= n; ++j) {
int res = 100000;
if (s[i] == t[j]) res = min(res, dp[i - 1][j - 1]);
res = min(res, dp[i - 1][j] + 1);
if (pa[i][t[j]] < pb[j][t[j]]) res = min(res, dp[i][j - 1]);
dp[i][j] = res;
}
cout << dp[n][n] << endl;
}
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
string a;
cin >> a;
long long s[n];
long long mx = 0, mn = 0;
for (long long i = 0; i < n; i++) s[i] = 0;
long long bal = 0;
for (long long i = 0; i < n; i++) {
bal = bal + (a[i] == '0') - (a[i] == '1');
s[i] = bal;
mx = max(bal, mx);
mn = min(bal, mn);
}
long long ats = x == 0;
if (bal == 0) {
if (mn <= x && x <= mx) {
cout << "-1";
} else
cout << ats;
cout << "\n";
continue;
}
for (long long i = 0; i < n; i++) {
if ((x - s[i]) % bal == 0 && (x - s[i]) / bal >= 0) {
ats++;
}
}
cout << ats << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long stoll(string target) {
stringstream s;
s << target;
long long w;
s >> w;
return w;
}
int stoi(string target) {
stringstream s;
s << target;
int w;
s >> w;
return w;
}
string itos(int i) {
stringstream s;
s << i;
return s.str();
}
string lltos(long long i) {
stringstream s;
s << i;
return s.str();
}
bool ok = true, final = false;
int i, j, k, n, m;
int t;
int br = 0, odgovor = 0, pom, mom, g, f, pamti;
int b[10000];
int a[10000];
void dfs(int x) {
if (x * 2 < (1 << (n + 1))) {
dfs(x * 2);
dfs(x * 2 + 1);
b[x] = max(b[x * 2] + a[x * 2 - 1], b[x * 2 + 1] + a[x * 2]);
}
}
void bfs(int x, int y) {
int f = x * 2;
int g = x * 2 + 1;
if (x * 2 * 2 >= (1 << (n + 1))) {
odgovor += y - min(a[f - 1], a[g - 1]);
return;
}
if (a[f - 1] + b[f] > a[g - 1] + b[g]) {
int br = y - a[g - 1] - b[g];
odgovor += y - a[g - 1] - b[g];
bfs(g, y - br - a[g - 1]);
bfs(f, y - a[f - 1]);
} else {
int br = y - a[f - 1] - b[f];
odgovor += y - a[f - 1] - b[f];
bfs(g, y - a[g - 1]);
bfs(f, y - br - a[f - 1]);
}
}
int main() {
ios::sync_with_stdio(false);
memset((b), (0), sizeof((b)));
memset((a), (0), sizeof((a)));
cin >> n;
for (i = 1; i <= (int)((1 << (n + 1)) - 2); i++) cin >> a[i];
for (i = (1 << n); i <= (int)((1 << (n + 1)) - 1); i++) {
f = 0;
j = i;
while (j > 0) {
f += a[j - 1];
br = max(br, f);
j /= 2;
}
}
dfs(1);
bfs(1, br);
cout << odgovor;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n;
const int bign = 200033;
int a[bign];
int main() {
long long minsize = 1e18;
scanf("%d", &n);
for (int i = 0; i < 2 * n; i++) scanf("%d", a + i);
sort(a, a + 2 * n);
minsize = 1ll * (a[n - 1] - a[0]) * (a[2 * n - 1] - a[n]);
long long x = a[2 * n - 1] - a[0];
for (int i = 1; i < n; i++) {
if (x * (a[i + n - 1] - a[i]) < minsize)
minsize = x * (a[i + n - 1] - a[i]);
}
printf("%I64d\n", minsize);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int inf = 1000000000;
int data[100005];
int ada[2005];
int n, k, x;
map<long long, int> dah;
long long mod = 999999999989LL;
void urut() {
memset(ada, 0, sizeof(ada));
for (int(i) = (0); (i) <= (n - 1); ++(i)) ++ada[data[i]];
int now = 0;
for (int(i) = (0); (i) <= (2000); ++(i)) {
while (ada[i]--) data[now++] = i;
}
}
int main() {
scanf("%d %d %d", &n, &k, &x);
for (int(i) = (0); (i) <= (n - 1); ++(i)) scanf("%d", &data[i]);
urut();
for (int(i) = (1); (i) <= (k); ++(i)) {
for (int j = 0; j < n; j += 2) data[j] ^= x;
urut();
long long hsh = 0;
for (int(j) = (0); (j) <= (n - 1); ++(j)) {
hsh = (hsh * n + data[j]) % mod;
}
if (dah.count(hsh)) {
int sisa = k - i;
int len = i - dah[hsh];
sisa %= len;
while (sisa--) {
for (int j = 0; j < n; j += 2) data[j] ^= x;
urut();
}
printf("%d %d\n", data[n - 1], data[0]);
return 0;
}
dah[hsh] = i;
}
printf("%d %d\n", data[n - 1], data[0]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x = 0, t, count = 1, max = 1;
cin >> n;
cin >> x;
t = x;
for (int i = 1; i < n; i++) {
cin >> x;
if (x >= t)
count++;
else {
if (count > max) max = count;
count = 1;
}
t = x;
}
if (count > max) max = count;
cout << max << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<char, int> ct;
set<char> torem;
struct c {
char x;
int ct;
};
c alpha[100];
bool cmp(c c1, c c2) { return c1.ct < c2.ct; }
char s[1000000];
int main() {
gets(s);
char s1[100];
gets(s1);
int k;
sscanf(s1, "%d", &k);
int l = strlen(s);
for (int i = 0; i < l; i++) {
ct[s[i]]++;
}
int idx = 0;
for (map<char, int>::iterator it = ct.begin(); it != ct.end(); it++) {
alpha[idx].ct = it->second;
alpha[idx].x = it->first;
idx++;
}
sort(alpha, alpha + idx, cmp);
int i = 0;
int answ = idx;
while (true) {
if (i < idx && alpha[i].ct <= k) {
k -= alpha[i].ct;
torem.insert(alpha[i].x);
i++;
answ--;
} else {
break;
}
}
printf("%d\n", answ);
for (int i = 0; i < l; i++) {
if (torem.find(s[i]) == torem.end()) {
printf("%c", s[i]);
}
}
printf("\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 4e5 + 5;
deque<int> dq;
int i, k, n, x;
long long sum[Nmax], best[Nmax], dp[Nmax], C;
int main() {
cin.sync_with_stdio(false);
cin >> n >> C;
for (i = 1; i < 2 * n; ++i) {
cin >> x;
sum[i] = x + sum[i - 1];
}
k = 0;
for (i = 1; i <= n; ++i) {
best[i] = dp[i - 1] - sum[2 * i - 2];
while (dq.size() && best[dq.back()] <= best[i]) dq.pop_back();
dq.push_back(i);
while (sum[2 * k] < sum[2 * i - 1] - C && k < i) ++k;
while (dq.size() && dq.front() <= k) dq.pop_front();
if (k) dp[i] = C + dp[k - 1];
if (dq.size()) dp[i] = max(dp[i], sum[2 * i - 1] + best[dq.front()]);
}
cout << dp[n] << '\n';
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1500 + 10;
const long long INF = 9e18;
const long double DINF = 1.79769e+308;
int n, m;
pair<int, int> pos, walk[MAXN][MAXN];
string s;
bool a[MAXN][MAXN], visited[MAXN][MAXN], b;
bool check(pair<int, int> v, pair<int, int> p, pair<int, int> u,
pair<int, int> go) {
if (a[u.first][u.second]) {
if (!visited[u.first][u.second]) {
return 1;
} else if (u != p && (walk[u.first][u.second].first !=
walk[v.first][v.second].first + go.first ||
walk[u.first][u.second].second !=
walk[v.first][v.second].second + go.second)) {
b = 1;
}
}
return 0;
}
void dfs(pair<int, int> v, pair<int, int> p, pair<int, int> status) {
walk[v.first][v.second] = status;
visited[v.first][v.second] = true;
if (check(v, p, {v.first, (v.second + 1) % m}, {0, 1})) {
dfs({v.first, (v.second + 1) % m}, v, {status.first, status.second + 1});
}
if (check(v, p, {(v.first + 1) % n, v.second}, {1, 0})) {
dfs({(v.first + 1) % n, v.second}, v, {status.first + 1, status.second});
}
if (v.second == 0 && check(v, p, {v.first, m - 1}, {0, -1})) {
dfs({v.first, m - 1}, v, {status.first, status.second - 1});
} else if (v.second != 0 && check(v, p, {v.first, v.second - 1}, {0, -1})) {
dfs({v.first, v.second - 1}, v, {status.first, status.second - 1});
}
if (v.first == 0 && check(v, p, {n - 1, v.second}, {-1, 0})) {
dfs({n - 1, v.second}, v, {status.first - 1, status.second});
} else if (v.first != 0 && check(v, p, {v.first - 1, v.second}, {-1, 0})) {
dfs({v.first - 1, v.second}, v, {status.first - 1, status.second});
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
int cnt = 1;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++) {
if (s[j] != '#') {
a[i][j] = 1;
}
if (s[j] == 'S') {
pos = {i, j};
}
}
}
dfs(pos, {-1, -1}, {0, 0});
cout << (b ? "YES" : "NO");
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = (long long)1e15;
void solve() {
long long n, w;
cin >> n >> w;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long sum = 0;
int flag = 0;
vector<int> v;
for (int i = 0; i < n; i++) {
if (a[i] < (w + 1) / 2 && sum < (w + 1) / 2) {
sum += a[i];
v.push_back(i + 1);
}
if (a[i] >= (w + 1) / 2 && a[i] <= w) flag = i + 1;
}
if (flag) {
cout << 1 << endl;
cout << flag << endl;
} else if (sum != 0 && sum >= (w + 1) / 2 && sum <= w) {
cout << v.size() << endl;
for (int x : v) cout << x << ' ';
cout << endl;
} else
cout << -1 << endl;
}
int main() {
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ans = -1;
scanf("%i %i", &n, &m);
int counts[n], arr[n];
memset(counts, 0, sizeof(counts));
for (int i = 0; i < m; i++) {
int x = -1, i1 = -1;
for (int j = 0; j < n; j++) {
scanf("%i", &arr[j]);
if (arr[j] > x) {
x = arr[j];
i1 = j;
}
}
counts[i1]++;
}
int x = -1, i1 = -1;
for (int i = 0; i < n; i++) {
if (counts[i] > x) {
x = counts[i];
i1 = i;
}
}
printf("%i\n", i1 + 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
string p[MAXN][2];
int pos[MAXN];
int N;
void get(int i) {
getline(cin, p[i][0]);
p[i][1] = "";
int l = p[i][0].length();
while (p[i][0][l - 1] != ' ') {
p[i][1] = p[i][0][l - 1] + p[i][1];
p[i][0].erase(l - 1);
l--;
}
p[i][0].erase(l - 1);
if (p[i][0] > p[i][1]) swap(p[i][0], p[i][1]);
}
int main() {
cin >> N;
getline(cin, p[0][0]);
for (int i = 1; i <= N; i++) {
get(i);
}
string curr = p[pos[1]][0];
for (int i = 1; i <= N; i++) {
int x;
cin >> x;
if (curr < p[x][0])
curr = p[x][0];
else {
if (curr < p[x][1])
curr = p[x][1];
else {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
int sgn(T val) {
return (T(0) < val) - (val < T(0));
}
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int ncr(int n, int k) {
int r = 1;
if (k > n - k) k = n - k;
for (int i = 0; i < k; i++) {
r *= n - i;
r /= i + 1;
}
return r;
}
template <typename T>
void printa(vector<T> arr) {
for (unsigned int i = 0; i < arr.size(); i++)
if (i != arr.size() - 1)
cout << arr[i] << ' ';
else
cout << arr[i] << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
vector<int> ls;
int stairs = 0;
int len = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) {
if (len > 0) {
ls.push_back(len);
len = 0;
}
stairs++;
}
len++;
}
if (len > 0) ls.push_back(len);
cout << stairs << "\n";
printa(ls);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double PI = acos(-1.0);
const long long int mod = 1e9 + 7;
const int MAXN = 1e6 + 5;
bool get(long long int l, long long int r) {
cout << l << " " << r << '\n';
cout.flush();
string res;
cin >> res;
if (l == r && res == "Yes") exit(0);
if (res == "Bad") exit(0);
return (res == "Yes");
}
void cp() {
long long int n, k;
cin >> n >> k;
long long int ops = 0;
long long int lo = 1, hi = n;
for (ops = 0; ops <= 4500;) {
while (hi - lo > 50) {
long long int mid = (lo + hi) / 2;
if (get(lo, mid)) {
lo = max(1LL, lo - k);
hi = min(n, mid + k);
} else {
lo = max(1LL, mid + 1 - k);
hi = min(n, hi + k);
}
ops++;
}
long long int len = hi - lo + 1;
long long int num = lo + rand() % len;
get(num, num);
ops++;
lo = max(1LL, lo - k);
hi = min(n, hi + k);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
srand(time(NULL));
while (t--) {
cp();
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int c1, c2, c3, c4, c5, s;
int main() {
cin >> c1 >> c2 >> c3 >> c4 >> c5;
s = c1 + c2 + c3 + c4 + c5;
if (s == 0)
cout << -1;
else if (s % 5 == 0)
cout << s / 5;
else
cout << -1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int N = 1e5 + 7;
const int M = 5e2 + 7;
int n, l, r;
vector<vector<int> > vec(N);
int d[N], sub[N];
char ra[N];
struct build {
inline void dfs(int v, int par) {
sub[v] = 1;
for (int i : vec[v]) {
if (d[i] || par == i) {
continue;
}
dfs(i, v);
sub[v] += sub[i];
}
}
inline int centroid(int v, int par, int sz) {
for (int i : vec[v]) {
if (d[i] || par == i) {
continue;
}
if (sub[i] > sz / 2) {
return centroid(i, v, sz);
}
}
return v;
}
inline void getrank(int v, int r) {
dfs(v, v);
int vr = centroid(v, v, sub[v]);
ra[vr] = char(r + 'A');
d[vr] = 1;
for (int i : vec[vr]) {
if (d[i]) {
continue;
}
getrank(i, r + 1);
}
}
} ans;
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d", &l);
scanf("%d", &r);
vec[l].push_back(r);
;
vec[r].push_back(l);
;
}
ans.getrank(1, 0);
for (int i = 1; i <= n; ++i) {
printf("%c ", ra[i]);
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
static inline 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 == 0 ? a : gcd(b, a % b);
}
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;
}
static inline int ctz(unsigned x) { return __builtin_ctz(x); }
static inline int ctzll(unsigned long long x) { return __builtin_ctzll(x); }
static inline int clz(unsigned x) { return __builtin_clz(x); }
static inline int clzll(unsigned long long x) { return __builtin_clzll(x); }
static inline int popcnt(unsigned x) { return __builtin_popcount(x); }
static inline int popcntll(unsigned long long x) {
return __builtin_popcountll(x);
}
static inline int bsr(unsigned x) { return 31 ^ clz(x); }
static inline int bsrll(unsigned long long x) { return 63 ^ clzll(x); }
int d[100016];
int trim(int n) { return n * (n - 1) / 2; }
int trip(int n) { return n * (n + 1) / 2; }
void solve() {
int a, b, c, ab, ac, bc, abc;
int eab, eac, ebc;
int ans = 0;
scanf("%d%d%d", &a, &b, &c);
ab = gcd(a, b);
ac = gcd(a, c);
bc = gcd(b, c);
abc = gcd(ab, c);
eab = d[ab] - d[abc];
eac = d[ac] - d[abc];
ebc = d[bc] - d[abc];
ans = d[a] * d[b] * d[c];
ans -= trim(eab) * d[c] + (trim(d[abc]) + eab * d[abc]) * (d[c] - d[abc]);
ans -= trim(eac) * d[b] + (trim(d[abc]) + eac * d[abc]) * (d[b] - d[abc]);
ans -= trim(ebc) * d[a] + (trim(d[abc]) + ebc * d[abc]) * (d[a] - d[abc]);
ans -= trip(d[abc]) * (eab + eac + ebc);
ans -= eab * eac * ebc;
ans -= d[abc] * d[abc] * d[abc] - d[abc] * (d[abc] + 1) * (d[abc] + 2) / 6;
printf("%d\n", ans);
}
int main() {
int t;
for (int i = 1; i <= 100000; ++i) {
for (int j = i; j <= 100000; j += i) ++d[j];
}
scanf("%d", &t);
for (; t; --t) solve();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
for (int i = 0; i < n; i++) {
int val;
cin >> val;
long long low, mid, high;
low = 0, high = 1e15;
long long ans = high;
while (low <= high) {
mid = (low + high) / 2;
long long dmg1, dmg2;
dmg1 = mid / x;
dmg2 = mid / y;
if (dmg1 + dmg2 >= val) {
ans = min(ans, mid);
high = mid - 1;
} else
low = mid + 1;
}
bool f1, f2;
f1 = f2 = 0;
if (ans % x == 0) {
f1 = 1;
}
if (ans % y == 0) {
f2 = 1;
}
if (f1 && f2) {
cout << "Both" << endl;
} else if (f2) {
cout << "Vanya" << endl;
} else {
cout << "Vova" << endl;
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
long long x1, y1, x2, y2;
scanf("%lld %lld %lld %lld", &x1, &y1, &x2, &y2);
long long vm, t;
scanf("%lld %lld", &vm, &t);
long long vx, vy, wx, wy;
scanf("%lld %lld %lld %lld", &vx, &vy, &wx, &wy);
long long tx = x2 - vx * t - x1;
long long ty = y2 - vy * t - y1;
double l = 0, r = 1e8;
int cnt = 0;
long long det = tx * tx + ty * ty - vm * vm * t * t;
if (det == 0) {
printf("%lld\n", t);
}
if (det > 0) {
x1 += vx * t;
y1 += vy * t;
vx = wx;
vy = wy;
}
while (cnt < 64) {
double m = (l + r) / 2;
double px1 = vx * (det > 0 ? m - t : m) + x1;
double py1 = vy * (det > 0 ? m - t : m) + y1;
double px = x2 - px1;
double py = y2 - py1;
if (px * px + py * py > vm * vm * m * m) {
l = m;
} else {
r = m;
}
cnt++;
}
printf("%.12f\n", l);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int check(string s) {
int n = s.size();
if (n < 5) return 0;
int c1 = 0, c2 = 0, c3 = 0;
for (int i = 0; i < n; i++) {
c1 += isupper(s[i]);
c2 += islower(s[i]);
c3 += isdigit(s[i]);
}
return (c1 > 0 && c2 > 0 && c3 > 0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int ans = check(s);
cout << (ans ? "Correct" : "Too weak") << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e14;
class min_cost_flow {
private:
int N;
struct edge {
int to;
long long cap, cost;
int rev;
};
vector<vector<edge>> G;
vector<long long> h, dist, prevv, preve;
public:
min_cost_flow(int n) {
N = n;
G = vector<vector<edge>>(N);
h = dist = prevv = preve = vector<long long>(N, 0);
}
void add_edge(int from, int to, long long cap, long long cost) {
G[from].push_back((edge){to, cap, cost, (int)G[to].size()});
G[to].push_back((edge){from, 0, -cost, (int)G[from].size() - 1});
}
long long answer(int s, int t, long long f) {
long long res = 0;
fill(h.begin(), h.end(), 0);
while (f > 0) {
priority_queue<pair<long long, long long>,
vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
Q;
fill(dist.begin(), dist.end(), inf);
dist[s] = 0;
Q.push(pair<long long, long long>(s, 0));
while (!Q.empty()) {
pair<long long, long long> p = Q.top();
Q.pop();
int v = p.second;
if (dist[v] < p.first) continue;
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
Q.push(pair<long long, long long>(dist[e.to], e.to));
}
}
}
if (dist[t] == inf) return -1;
for (int v = 0; v < N; v++) h[v] += dist[v];
long long d = f;
for (int v = t; v != s; v = prevv[v]) {
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
};
int node(int n, int t) { return 101 * (n - 1) + (t + 1); }
int main() {
int N, M, K, C, D;
cin >> N >> M >> K >> C >> D;
min_cost_flow flow(101 * N + 2);
vector<int> cnt(N + 1, 0);
for (int i = 1; i <= K; i++) {
int a;
cin >> a;
cnt[a]++;
}
for (int i = 1; i <= N; i++) {
flow.add_edge(0, node(i, 0), cnt[i], 0);
for (int t = 0; t < 100; t++)
flow.add_edge(node(i, t), node(i, t + 1), K, 0);
}
for (int t = 1; t <= 100; t++)
flow.add_edge(node(1, t), 101 * N + 1, K, C * t);
for (int i = 1; i <= M; i++) {
int a, b;
cin >> a >> b;
for (int t = 0; t < 100; t++) {
for (int j = 1; j <= K; j++) {
flow.add_edge(node(a, t), node(b, t + 1), 1, D * (2 * j - 1));
flow.add_edge(node(b, t), node(a, t + 1), 1, D * (2 * j - 1));
}
}
}
cout << flow.answer(0, 101 * N + 1, K) << endl;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
struct PMA {
PMA *next[0x100];
vector<int> accept;
PMA() { fill(next, next + 0x100, (PMA *)0); }
};
PMA *buildPMA(char p[10][11], int size) {
PMA *root = new PMA;
for (int i = 0; i < size; ++i) {
PMA *t = root;
for (int j = 0; p[i][j]; ++j) {
char c = p[i][j];
if (t->next[c] == NULL) t->next[c] = new PMA;
t = t->next[c];
}
t->accept.push_back(i);
}
queue<PMA *> Q;
for (int c = 'A'; c <= 'Z'; ++c) {
if (root->next[c]) {
root->next[c]->next[0] = root;
Q.push(root->next[c]);
} else
root->next[c] = root;
}
while (!Q.empty()) {
PMA *t = Q.front();
Q.pop();
for (int c = 'A'; c <= 'Z'; ++c) {
if (t->next[c]) {
Q.push(t->next[c]);
PMA *r = t->next[0];
while (!r->next[c]) r = r->next[0];
t->next[c]->next[0] = r->next[c];
for (__typeof(r->next[c]->accept.begin()) i =
r->next[c]->accept.begin();
i != r->next[c]->accept.end(); i++)
t->next[c]->accept.push_back(*i);
}
}
}
return root;
}
int match(char *t, PMA *v, int *result) {
int n = strlen(t);
int count = 0;
for (int i = 0; i < n; ++i) {
char c = t[i];
while (!v->next[c]) v = v->next[0];
v = v->next[c];
for (int j = 0; j < v->accept.size(); ++j) result[v->accept[j]]++;
}
}
const int mod = (int)1e9 + 9;
int n, m;
map<pair<int, PMA *>, int> dp[2];
int len[10];
char in[10][11];
const char *base = "ACGT";
void run() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> in[i];
len[i] = strlen(in[i]);
}
PMA *pma = buildPMA(in, m);
dp[0][make_pair(0, pma)] = 1;
int cur = 0, next = 1;
for (int i = 0; i < n; i++) {
dp[next].clear();
for (__typeof(dp[cur].begin()) it = dp[cur].begin(); it != dp[cur].end();
it++) {
for (int b = 0; b < 4; b++) {
PMA *v = it->first.second;
while (!v->next[base[b]]) v = v->next[0];
v = v->next[base[b]];
int mxlen = -1;
for (__typeof(v->accept.begin()) jt = v->accept.begin();
jt != v->accept.end(); jt++)
mxlen = max(mxlen, len[*jt]);
if (it->first.first < mxlen)
(dp[next][make_pair(0, v)] += it->second) %= mod;
else if (it->first.first + 1 < 12)
(dp[next][make_pair(it->first.first + 1, v)] += it->second) %= mod;
}
}
swap(cur, next);
}
int ans = 0;
for (__typeof(dp[cur].begin()) i = dp[cur].begin(); i != dp[cur].end(); i++)
if (i->first.first == 0) ans = (ans + i->second) % mod;
cout << ans << endl;
}
int main() {
run();
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
void fin(int a) {
if (a)
cout << "Yes";
else
cout << "No";
exit(0);
}
struct point {
long long x = 0, y = 0;
point() {
x = 0;
y = 0;
}
point(long long xx, long long yy) {
x = xx;
y = yy;
}
point operator+(point b) { return point(x + b.x, y + b.y); }
point operator-(point b) { return point(x - b.x, y - b.y); }
long long operator*(point b) { return x * b.x + y * b.y; }
long long operator^(point b) { return x * b.y - y * b.x; }
bool operator==(point b) { return x == b.x && y == b.y; }
} u[4], v[4];
long long L = 100, R = -100, T = -100, B = 100;
long long mind = 1111, maxd = -1111, mins = 1111, maxs = -1111;
int main() {
for (int i = 0; i < 4; i++) {
cin >> u[i].x >> u[i].y;
T = max(T, u[i].y);
B = min(B, u[i].y);
R = max(R, u[i].x);
L = min(L, u[i].x);
}
for (int i = 0; i < 4; i++) {
cin >> u[i].x >> u[i].y;
long long s = u[i].x + u[i].y;
long long d = u[i].x - u[i].y;
mind = min(mind, d);
maxd = max(maxd, d);
maxs = max(maxs, s);
mins = min(mins, s);
}
vector<point> a, b;
for (int x = -100; x <= 100; x++) {
for (int y = -100; y <= 100; y++) {
int a = 0, b = 0;
if (L <= x && x <= R && B <= y && y <= T) a = 1;
int s = x + y, d = x - y;
if (mins <= s && s <= maxs && mind <= d && d <= maxd) b = 1;
if (a & b) fin(1);
}
}
fin(0);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(1e5) + 100;
const int mod = int(1e6);
struct command {
int type, ti, num, nid;
};
struct hashs {
int num, next;
};
int n;
int now;
command a[maxn];
int ha[mod];
hashs t[maxn];
int ans[maxn], sum[maxn];
bool cmp(command x, command y) { return x.ti < y.ti; }
bool cmp1(command x, command y) { return x.nid < y.nid; }
void read() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d", &a[i].type, &a[i].ti, &a[i].num);
a[i].nid = i;
}
}
int getnum(int x) {
int nid = (((x * 23 % 10007) + 19) * 17 % mod + mod) % mod;
for (int i = ha[nid]; i > -1; i = t[i].next)
if (t[i].num == x) return i;
t[now].num = x;
t[now].next = ha[nid];
ha[nid] = now++;
return now - 1;
}
void cdq(int L, int R) {
if (L == R) return;
int mid = (L + R) >> 1;
cdq(L, mid);
cdq(mid + 1, R);
sort(a + L, a + mid + 1, cmp);
sort(a + mid + 1, a + R + 1, cmp);
for (int i = L, j = mid + 1; j <= R;) {
while (i <= mid && a[i].ti <= a[j].ti) {
if (a[i].type == 3) {
++i;
continue;
}
int nid = getnum(a[i].num);
if (a[i].type == 1)
++sum[nid];
else
--sum[nid];
++i;
}
while (j <= R && (i > mid || a[j].ti <= a[i].ti)) {
if (a[j].type < 3) {
++j;
continue;
}
int nid = getnum(a[j].num);
ans[a[j].nid] += sum[nid];
++j;
}
}
for (int i = L, j = mid + 1; j <= R;) {
while (i <= mid && a[i].ti <= a[j].ti) {
if (a[i].type == 3) {
++i;
continue;
}
int nid = getnum(a[i].num);
if (a[i].type == 1)
--sum[nid];
else
++sum[nid];
++i;
}
while (j <= R && (i > mid || a[j].ti <= a[i].ti)) ++j;
}
}
void print() {
sort(a + 1, a + 1 + n, cmp1);
for (int i = 1; i <= n; ++i)
if (a[i].type == 3) printf("%d\n", ans[i]);
}
int main() {
read();
for (int i = 0; i < mod; ++i) ha[i] = -1;
cdq(1, n);
print();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
cout << 9 * n << " " << 8 * n << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = 1000001000;
const long long INFLL = INF * 1LL * INF;
const int mod = 1000 * 1000 * 1000 + 7;
const int mod9 = 1000 * 1000 * 1000 + 9;
const int modr = 99990001;
const long double PI = 3.1415926535897932385;
template <class T>
void zero(T val, T& first) {
first = val;
}
template <class T, class... Targs>
void zero(T val, T& first, Targs&... Fargs) {
first = val;
zero(val, Fargs...);
}
template <class T, class T2>
std::istream& operator>>(std::istream& is, pair<T, T2>& p) {
return is >> p.first >> p.second;
}
template <class T>
std::istream& readN(T& first, int n, int st = 0) {
for (int i = st, iend = (st + n - 1); i <= iend; i++) cin >> first[i];
return cin;
}
template <class T>
std::istream& readS(set<T>& first, int n) {
T second = *first.rbegin();
for (int i = 0, iend = (n - 1); i <= iend; i++) {
cin >> second;
first.insert(second);
}
return cin;
}
template <class T>
std::istream& read(T& first) {
return cin >> first;
}
template <class T, class... Targs>
std::istream& read(T& first, Targs&... Fargs) {
return read(first), read(Fargs...);
}
template <class T, class T2>
std::ostream& operator<<(std::ostream& os, pair<T, T2> p) {
return os << p.first << " " << p.second;
}
template <class T>
std::ostream& operator<<(std::ostream& os, vector<T> v) {
bool f = true;
for (auto second : v) {
if (!f) os << ' ';
os << second;
f = false;
}
return os;
}
template <class T>
std::ostream& operator<<(std::ostream& os, set<T> v) {
bool f = true;
for (auto second : v) {
if (!f) os << ' ';
os << second;
f = false;
}
return os;
}
template <class T>
std::ostream& operator<<(std::ostream& os, multiset<T> v) {
bool f = true;
for (auto second : v) {
if (!f) os << ' ';
os << second;
f = false;
}
return os;
}
template <class T, class T2>
std::ostream& operator<<(std::ostream& os, map<T, T2> v) {
bool f = true;
for (pair<T, T2> second : v) {
if (!f) os << ' ';
os << second.first << "=>" << second.second;
f = false;
}
return os;
}
template <class T>
std::ostream& outV(T first, char del = ' ') {
bool f = true;
for (auto second : first) {
if (!f) cout << del;
cout << second;
f = false;
}
return cout;
}
template <class T>
std::ostream& outN(T first, int n = -1, int st = 0) {
for (int i = st, iend = (n == -1 ? (int)first.size() - 1 : st + n - 1);
i <= iend; i++) {
cout << first[i];
if (i < iend) cout << ' ';
}
return cout;
}
template <class T>
std::ostream& outAN(T first, int n = -1, int st = 0) {
for (int i = st, iend = (n - 1); i <= iend; i++) {
cout << first[i];
if (i < iend) cout << ' ';
}
return cout;
}
template <class T>
std::ostream& outA2(T first, int n, int m) {
for (int i = 0, iend = (n - 1); i <= iend; i++) {
for (int j = 0, jend = (m - 1); j <= jend; j++)
cout << first[i][j] << (j == m - 1 ? '\n' : ' ');
}
return cout;
}
template <class T>
std::ostream& out(T first) {
return cout << first;
}
template <class T, class... Targs>
std::ostream& out(T first, Targs... Fargs) {
return out(first) << " ", out(Fargs...);
}
template <typename T>
void srt(T& a, int st, int fn, bool isArr) {
sort(a + st, a + fn + 1);
}
template <class T>
void srt(T& a, int st = 0, int fn = 0) {
sort(a.begin() + st, fn ? a.begin() + fn + 1 : a.end());
}
template <typename T>
T rev_num(T a) {
T r = 0;
for (; a; a /= 10) r = r * 10 + a % 10;
return r;
}
template <typename T>
void rev(T& a, int st, int fn, bool isArr) {
reverse(a + st, a + fn + 1);
}
template <class T>
void rev(T& a, int st = 0, int fn = 0) {
reverse(a.begin() + st, fn ? a.begin() + fn + 1 : a.end());
}
long long sqr(long long a) { return a * a; };
long long sqr(int a) { return a * 1LL * a; };
long double sqr(long double a) { return a * a; };
long long phi(int n) {
int res = n;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) {
while (n % i == 0) n /= i;
res -= res / i;
}
if (n > 1) res -= res / n;
return res;
}
long long bpm(long long a, long long n = -2, long long m = mod) {
n = n < 0 ? n + m : n;
long long r = 1;
while (n) {
if (n & 1) r = (r * a) % m;
a = (a * a) % m;
n >>= 1;
}
return r;
}
unsigned long long gcd(unsigned long long a, unsigned long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
vector<int> ero_p, ero_l;
void ero(int n) {
ero_l.resize(n + 1);
ero_l[0] = -1;
for (int i = 2, iend = (n); i <= iend; i++)
if (!ero_l[i]) {
ero_p.push_back(i);
ero_l[i] = i;
for (long long j = i * 1LL * i; j <= n; j += i) {
ero_l[j] = i;
}
}
}
long long gcd_cb(long long a, long long b, long long& first,
long long& second) {
if (!b) {
first = 1;
second = 0;
return a;
}
long long x1, y1, g;
g = gcd_cb(b, a % b, x1, y1);
first = y1;
second = x1 - a / b * y1;
return g;
}
vector<long long> fact;
void fact_prec(int n = 20) {
fact.resize(n + 1);
fact[0] = 1;
for (int i = 1, iend = (n); i <= iend; i++) {
fact[i] = fact[i - 1] * i;
}
}
vector<long double> factd;
void fact_precd(int n = 146) {
factd.resize(n + 1);
factd[0] = 1;
for (int i = 1, iend = (n); i <= iend; i++) {
factd[i] = factd[i - 1] * i;
}
}
string str(long long a) {
string r = "";
for (; a; a /= 10) r += a % 10 + '0';
rev(r);
return r;
}
const int N = 400005;
int c[N], a[N];
int l[N], r[N];
int t[N];
void incT(int l, int r, int c, int v = 1) {
int md = (l + r) >> 1;
int lv = v << 1;
int rv = lv + 1;
if (l == r) {
t[v]++;
return;
}
if (c <= md) {
incT(l, md, c, lv);
} else {
incT(md + 1, r, c, rv);
}
t[v]++;
}
int getT(int l, int r, int ask_l, int ask_r, int v = 1) {
if (l == ask_l && r == ask_r) {
return t[v];
}
int md = (l + r) >> 1;
int lv = v << 1;
int rv = lv + 1;
if (ask_r <= md) {
return getT(l, md, ask_l, ask_r, lv);
} else if (ask_l > md) {
return getT(md + 1, r, ask_l, ask_r, rv);
} else {
return getT(l, md, ask_l, md, lv) + getT(md + 1, r, md + 1, ask_r, rv);
}
}
void solution() {
int n;
read(n);
readN(a, 2 * n);
for (int i = 0, iend = (2 * n - 1); i <= iend; i++) {
int first = a[i];
c[first]++;
if (c[first] == 2) {
r[first] = i;
} else {
l[first] = i;
}
}
int res = 0;
for (int i = 0, iend = (2 * n - 1); i <= iend; i++) {
int first = a[i];
c[first]--;
if (c[first]) {
incT(0, 2 * n, r[first]);
res += (r[first] - l[first] - getT(0, 2 * n, l[first], r[first]));
}
}
out(res) << "\n";
}
int main() {
ios::sync_with_stdio(false);
solution();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, cur;
scanf("%d", &n);
scanf("%d", &cur);
int mxVal = INT_MIN, mxDiff = INT_MIN;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d", &x);
scanf("%d", &y);
mxVal = max(mxVal, x);
mxDiff = max(mxDiff, x - y);
}
if (cur > mxVal and mxDiff <= 0) {
cout << "-1" << endl;
} else if (mxVal >= cur) {
cout << 1 << endl;
} else {
long long int a = ceil(1.0 * (cur - mxVal) / mxDiff);
cout << a + 1 << endl;
}
}
int main() {
int nt = 1;
scanf("%d", &nt);
while (nt--) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> brks;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int calc(vector<int> bead, bool sure);
int split(vector<int> bead, int div, bool sure) {
for (int i = (0); i <= (n - 1); i++) bead[i] /= div;
return div * calc(bead, sure);
}
int calc(vector<int> bead, bool sure) {
int G = bead[0];
for (int i = 1; i <= (n - 1); i++) G = gcd(G, bead[i]);
if (G == 1) {
int cnt = 0;
for (int i = 0; i < n; i++)
if (bead[i] % 2 == 1) cnt++;
return cnt == 1;
}
if (G == 2) {
if (sure) brks.push_back(2);
return 2;
} else {
int ret = split(bead, G, false), brk = G;
for (int j = 2; j * j <= G; j++)
if (G % j == 0) {
int tmp = split(bead, j, false);
if (tmp >= ret) ret = tmp, brk = j;
tmp = split(bead, G / j, false);
if (tmp >= ret) ret = tmp, brk = G / j;
}
if (sure) {
split(bead, brk, true);
brks.push_back(brk);
}
return ret;
}
}
vector<int> necklace(vector<int> bead, int cur) {
vector<int> ret;
if (cur < 0 || brks[cur] == 2) {
for (int i = 0; i < n; i++)
for (int j = 1; j <= (bead[i] / 2); j++) ret.push_back(i);
for (int i = 0; i < n; i++)
if (bead[i] % 2 == 1) ret.push_back(i);
for (int i = n - 1; i >= 0; i--)
for (int j = 1; j <= (bead[i] / 2); j++) ret.push_back(i);
return ret;
} else {
for (int i = (0); i <= (n - 1); i++) bead[i] /= brks[cur];
ret = necklace(bead, cur - 1);
int len = ret.size();
for (int i = 1; i <= (brks[cur] - 1); i++)
for (int j = 0; j < len; j++) ret.push_back(ret[j]);
return ret;
}
}
int main() {
scanf("%d", &n);
vector<int> bead;
for (int i = 1; i <= (n); i++) {
int a;
cin >> a;
bead.push_back(a);
}
printf("%d\n", calc(bead, true));
vector<int> sol = necklace(bead, brks.size() - 1);
for (int i = 0; i < sol.size(); i++) printf("%c", 'a' + sol[i]);
printf("\n");
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e+9 + 7ll;
const long long linf = (long long)1e+18 + 7ll;
const long double eps = (long double)1e-10;
const long double pi = acosl((long double)-1.0);
const int alph = 26;
static char buff[(int)2e6 + 17];
const int maxn = (int)1e6 + 17;
int nn;
int b[maxn];
struct segtree {
vector<pair<int, int> > T;
segtree(int n) { nn = n, T.resize(4 * n); }
segtree() {}
pair<int, int> build(int v = 1, int l = 0, int r = nn - 1) {
if (l == r) return T[v] = make_pair(b[l], l);
int m = (l + r) / 2;
return T[v] = max(build(2 * v, l, m), build(2 * v + 1, m + 1, r));
}
void upd(int i, int v = 1, int l = 0, int r = nn - 1) {
if (l == r)
T[v] = make_pair(-1, l);
else {
int m = (l + r) / 2;
i <= m ? upd(i, 2 * v, l, m) : upd(i, 2 * v + 1, m + 1, r);
T[v] = max(T[2 * v], T[2 * v + 1]);
}
}
pair<int, int> get(int lq, int rq, int v = 1, int l = 0, int r = nn - 1) {
if (r < lq || l > rq) return make_pair(-1, l);
if (lq <= l && r <= rq) return T[v];
int m = (l + r) / 2;
return max(get(lq, rq, 2 * v, l, m), get(lq, rq, 2 * v + 1, m + 1, r));
}
};
int n;
int a[maxn], c[maxn], ans[maxn];
bool used[maxn];
segtree T;
vector<int> res;
bool read() {
if (scanf("%d", &n) != 1) return false;
for (int i = 0; i < n; ++i) scanf("%d", a + i);
return true;
}
void check() {
memset(used, false, sizeof(used));
memset(c, -1, sizeof(c));
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (!used[j] && ans[j] > ans[i]) {
used[j] = true;
c[i] = j + 1;
break;
}
for (int i = 0; i < n; ++i) printf("%d ", c[i]);
printf("\n");
}
void dfs(int v) {
used[v] = true;
T.upd(v);
if (b[v] != n && !used[b[v]]) dfs(b[v]);
for (;;) {
auto p = T.get(0, a[v] - 1);
if (p.first > v)
dfs(p.second);
else
break;
}
res.push_back(v);
}
void solve() {
fill(b, b + n, n);
T = segtree(n);
for (int i = 0; i < n; ++i) {
a[i] == -1 ? a[i] = n : --a[i];
if (a[i] != n) b[a[i]] = i;
}
T.build();
for (int i = 0; i < n; ++i)
if (!used[i]) dfs(i);
for (int i = 0; i < n; ++i) ans[res[i]] = i + 1;
for (int i = 0; i < n; ++i) printf("%d ", ans[i]);
}
void gen() {}
void naive() {}
int main() {
if (1) {
while (read()) solve();
} else {
for (;;) {
gen();
solve();
naive();
}
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 3e5 + 6.66;
const int MaxLog = 20;
int up_ed[MaxN];
long long dp[MaxN];
long long dp_up[MaxN];
long long ret_dp[MaxN];
long long lca_sum[MaxLog][MaxN];
long long lca_rem[MaxLog][MaxN];
int lca[MaxLog][MaxN];
int arr[MaxN];
int h[MaxN];
vector<pair<int, int>> tree[MaxN];
long long dfs_up(int v, int par = 0, int up = 0, int hei = 0) {
lca[0][v] = par;
up_ed[v] = up;
h[v] = hei;
dp[v] = arr[v];
for (auto x : tree[v])
if (x.first != par) dp[v] += dfs_up(x.first, v, x.second, hei + 1);
return ret_dp[v] = max(0LL, dp[v] - 2 * up);
}
void dfs_down(int v, int par = 0, long long up_val = 0) {
dp_up[v] = up_val;
long long suf_sum = arr[v] + up_val;
for (auto u : tree[v])
if (u.first != par) suf_sum += ret_dp[u.first];
long long pre_sum = 0;
for (auto u : tree[v]) {
if (u.first == par) continue;
suf_sum -= ret_dp[u.first];
dfs_down(u.first, v, max(0LL, pre_sum + suf_sum - 2 * u.second));
pre_sum += ret_dp[u.first];
}
}
void init_lca(int n) {
for (int i = 1; i <= n; i++)
lca_sum[0][i] = dp[i] - up_ed[i], lca_rem[0][i] = ret_dp[i];
for (int i = 1; i < MaxLog; i++)
for (int j = 1; j <= n; j++) {
lca[i][j] = lca[i - 1][lca[i - 1][j]];
lca_sum[i][j] = lca_sum[i - 1][j] + lca_sum[i - 1][lca[i - 1][j]];
lca_rem[i][j] = lca_rem[i - 1][j] + lca_rem[i - 1][lca[i - 1][j]];
}
}
int get_par(int v, int x) {
for (int i = 0; i < MaxLog; i++)
if (x & (1 << i)) v = lca[i][v];
return v;
}
long long get(int u, int v) {
long long ans = 0;
if (h[v] > h[u]) swap(u, v);
for (int i = MaxLog - 1; i > -1; --i)
if (h[u] - h[v] >= (1 << i)) {
ans += lca_sum[i][u] - lca_rem[i][u];
u = lca[i][u];
}
if (u == v) return ans + dp[u] + dp_up[u];
int v0 = v;
for (int i = MaxLog - 1; i > -1; --i)
if ((1 << i) <= h[v] && lca[i][v] != lca[i][u]) {
ans += lca_sum[i][u] + lca_sum[i][v] - lca_rem[i][u] - lca_rem[i][v];
u = lca[i][u];
v = lca[i][v];
}
ans += lca_sum[0][u] + lca_sum[0][v] - lca_rem[0][u] - lca_rem[0][v];
int l = lca[0][v];
return ans + dp[l] + dp_up[l];
}
void init(int n) {
dfs_up(1);
dfs_down(1);
init_lca(n);
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", arr + i);
for (int rki = 1; rki < n; rki++) {
int i, j, v;
scanf("%d %d %d", &i, &j, &v);
tree[i].push_back({j, v});
tree[j].push_back({i, v});
}
init(n);
while (q--) {
int u, v;
scanf("%d %d", &u, &v);
printf("%lld\n", get(u, v));
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[1000] = {0};
int b = 0, maxi = 0;
int n;
cin >> n;
string s[n];
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (s[i] == s[j]) b++;
maxi = max(maxi, b);
b = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (s[i] == s[j]) b++;
if (b == maxi) {
cout << s[i];
return 0;
} else
b = 0;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int p = 1000000007;
int f[600][600], g[600][600], h[600][600];
int i, j, k, n;
int main() {
cin >> n;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) cin >> g[i][j];
for (i = 1; i <= n; i++) f[i][i] = 1;
for (i = 1; i < n; i++)
for (j = 1; i + j <= n; j++) {
for (k = j; k <= i + j; k++)
f[j][i + j] = (f[j][i + j] + 1LL * f[j][k] * h[k][i + j]) % p;
if (g[j][i + j])
for (k = j; k < i + j; k++)
h[j][i + j] = (h[j][i + j] + 1LL * f[j][k] * f[k + 1][i + j]) % p;
f[j][i + j] = (f[j][i + j] + h[j][i + j]) % p;
}
cout << f[1][n];
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int L[maxn << 2], R[maxn << 2];
double sum[maxn << 2], add[maxn << 2], mul[maxn << 2];
void pushup(int i) { sum[i] = sum[i * 2] + sum[i * 2 + 1]; }
void pushdown(int i) {
sum[i * 2] = sum[i * 2] * mul[i] + add[i] * (R[i * 2] - L[i * 2] + 1);
sum[i * 2 + 1] =
sum[i * 2 + 1] * mul[i] + add[i] * (R[i * 2 + 1] - L[i * 2 + 1] + 1);
add[i * 2] = add[i * 2] * mul[i] + add[i];
add[i * 2 + 1] = add[i * 2 + 1] * mul[i] + add[i];
mul[i * 2] = mul[i] * mul[i * 2];
mul[i * 2 + 1] = mul[i * 2 + 1] * mul[i];
mul[i] = 1;
add[i] = 0;
}
void build(int i, int l, int r) {
L[i] = l;
R[i] = r;
add[i] = 0;
mul[i] = 1;
if (l == r) {
cin >> sum[i];
return;
}
int mid = (l + r) >> 1;
build(i * 2, l, mid);
build(i * 2 + 1, mid + 1, r);
pushup(i);
}
double query(int i, int l, int r, int x, int y) {
if (x <= l && r <= y) {
return sum[i];
}
pushdown(i);
int mid = (l + r) >> 1;
double res = 0.0;
if (x <= mid) {
res += query(i * 2, l, mid, x, y);
}
if (y > mid) {
res += query(i * 2 + 1, mid + 1, r, x, y);
}
return res;
}
void update1(int i, int l, int r, int x, int y, double v) {
if (x <= l && r <= y) {
sum[i] += v * (r - l + 1);
add[i] += v;
return;
}
pushdown(i);
int mid = (l + r) >> 1;
if (x <= mid) update1(i * 2, l, mid, x, y, v);
if (y > mid) update1(i * 2 + 1, mid + 1, r, x, y, v);
pushup(i);
}
void update2(int i, int l, int r, int x, int y, double v) {
if (x <= l && r <= y) {
add[i] *= v;
sum[i] *= v;
mul[i] *= v;
return;
}
pushdown(i);
int mid = (l + r) >> 1;
if (x <= mid) update2(i * 2, l, mid, x, y, v);
if (y > mid) update2(i * 2 + 1, mid + 1, r, x, y, v);
pushup(i);
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
build(1, 1, n);
while (q--) {
int l1, r1, l2, r2;
int id;
scanf("%d", &id);
if (id == 1) {
scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
double sum1 = query(1, 1, n, l1, r1);
double sum2 = query(1, 1, n, l2, r2);
double len1 = r1 - l1 + 1, len2 = r2 - l2 + 1;
update2(1, 1, n, l1, r1, (len1 - 1) / len1);
update2(1, 1, n, l2, r2, (len2 - 1) / len2);
update1(1, 1, n, l1, r1, sum2 / (len1 * len2));
update1(1, 1, n, l2, r2, sum1 / (len1 * len2));
} else {
scanf("%d%d", &l1, &r1);
printf("%.7lf\n", query(1, 1, n, l1, r1));
}
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[100010];
long long int v[100010];
long long int c[100010];
bool vis[100010];
long long int maxPC[100010];
pair<long long, long long int> m1, m2;
long long int solve(int N, long long int A, long long int B) {
for (int i = 0; i < 100010; i++) vis[i] = false;
for (int i = 0; i < 100010; i++) maxPC[i] = 0;
dp[N - 1] = 0;
maxPC[c[N - 1]] = A * v[N - 1];
vis[c[N - 1]] = true;
m1 = make_pair(B * v[N - 1], c[N - 1]);
m2 = make_pair(-1, -1);
for (int i = N - 2; i >= 0; i--) {
dp[i] = 0;
if (vis[c[i]]) dp[i] = max(dp[i], maxPC[c[i]]);
if (m1.second != c[i])
dp[i] = max(dp[i], m1.first);
else
dp[i] = max(dp[i], m2.first);
pair<long long int, long long int> m3 = make_pair(B * v[i] + dp[i], c[i]);
if (m3.second == m1.second && m3 > m1) {
m1 = m3;
} else if (m3 > m1) {
m2 = m1;
m1 = m3;
} else if (m3 > m2 && m3.second != m1.second) {
m2 = m3;
}
maxPC[c[i]] = max(maxPC[c[i]], A * v[i] + dp[i]);
vis[c[i]] = true;
}
long long int maxVal = 0;
for (int i = 0; i < N; i++) maxVal = max(maxVal, B * v[i] + dp[i]);
return maxVal;
}
int main() {
int N, Q;
cin >> N >> Q;
for (int i = 0; i < N; i++) cin >> v[i];
for (int j = 0; j < N; j++) cin >> c[j];
for (int i = 0; i < Q; i++) {
int a, b;
cin >> a >> b;
cout << solve(N, a, b) << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int dp[1003][2003];
int main() {
int i, j, k, l, n, m, a[2003], b[2003], p;
for (i = 0; i < 1003; i++)
for (j = 0; j < 2003; j++) dp[i][j] = 2e9;
cin >> n >> k >> p;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < k; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + k);
for (i = 0; i < k; i++)
if (i)
dp[0][i] = min(dp[0][i - 1], abs(a[0] - b[i]) + abs(b[i] - p));
else
dp[0][i] = abs(a[0] - b[i]) + abs(b[i] - p);
for (i = 1; i < n; i++)
for (j = i; j < k; j++)
dp[i][j] = min(max(abs(a[i] - b[j]) + abs(b[j] - p), dp[i - 1][j - 1]),
dp[i][j - 1]);
cout << dp[n - 1][k - 1];
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int _arr[51];
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
int arr[n * 2];
for (int j = 0; j < n * 2; j++) cin >> arr[j];
_arr[0] = arr[0];
int flag = 1;
for (int j = 1; j < n * 2; j++) {
bool check = true;
for (int c = 0; c < flag; c++) {
if (arr[j] == _arr[c]) {
check = false;
break;
}
}
if (check) {
_arr[flag] = arr[j];
flag++;
}
}
for (int j = 0; j < flag; j++) {
cout << _arr[j] << " ";
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int BUFFER_SIZE = 1 << 15;
char input_buffer[BUFFER_SIZE];
int input_pos = 0, input_len = 0;
char output_buffer[BUFFER_SIZE];
int output_pos = 0;
char number_buffer[100];
uint8_t lookup[100];
void _update_input_buffer() {
input_len = fread(input_buffer, sizeof(char), BUFFER_SIZE, stdin);
input_pos = 0;
if (input_len == 0) input_buffer[0] = EOF;
}
inline char next_char(bool advance = true) {
if (input_pos >= input_len) _update_input_buffer();
return input_buffer[advance ? input_pos++ : input_pos];
}
template <typename T>
inline void read_int(T &number) {
bool negative = false;
number = 0;
while (!isdigit(next_char(false)))
if (next_char() == '-') negative = true;
do {
number = 10 * number + (next_char() - '0');
} while (isdigit(next_char(false)));
if (negative) number = -number;
}
template <typename T, typename... Args>
inline void read_int(T &number, Args &...args) {
read_int(number);
read_int(args...);
}
void _flush_output() {
fwrite(output_buffer, sizeof(char), output_pos, stdout);
output_pos = 0;
}
inline void write_char(char c) {
if (output_pos == BUFFER_SIZE) _flush_output();
output_buffer[output_pos++] = c;
}
template <typename T>
inline void write_int(T number, char after = '\0') {
if (number < 0) {
write_char('-');
number = -number;
}
int length = 0;
while (number >= 10) {
uint8_t lookup_value = lookup[number % 100];
number /= 100;
number_buffer[length++] = (lookup_value & 15) + '0';
number_buffer[length++] = (lookup_value >> 4) + '0';
}
if (number != 0 || length == 0) write_char(number + '0');
for (int i = length - 1; i >= 0; i--) write_char(number_buffer[i]);
if (after) write_char(after);
}
void init() {
bool exit_success = atexit(_flush_output) == 0;
assert(exit_success);
for (int i = 0; i < 100; i++) lookup[i] = (i / 10 << 4) + i % 10;
}
} // namespace IO
auto random_address = [] {
char *p = new char;
delete p;
return (uint64_t)p;
};
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count() *
(random_address() | 1));
double real_rng(double a = 0, double b = 1) {
assert(a <= b);
return uniform_real_distribution<double>(a, b)(rng);
}
int N;
vector<int> A;
vector<pair<long long, int>> sorted;
vector<pair<long long, int>> negatives, positives;
bool compare_first(const pair<long long, int> &x,
const pair<long long, int> &y) {
return x.first < y.first;
}
void output_negative_positive_solution(int neg_count, int pos_count) {
vector<int> solution;
if (neg_count > 0) {
for (int i = 0; i < neg_count; i++) solution.push_back(negatives[i].second);
} else {
for (int i = (int)negatives.size() + neg_count; i < (int)negatives.size();
i++)
solution.push_back(negatives[i].second);
}
if (pos_count > 0) {
for (int i = 0; i < pos_count; i++) solution.push_back(positives[i].second);
} else {
for (int i = (int)positives.size() + pos_count; i < (int)positives.size();
i++)
solution.push_back(positives[i].second);
}
IO::write_int(solution.size(), '\n');
for (int i = 0; i < (int)solution.size(); i++)
IO::write_int(solution[i], i < (int)solution.size() - 1 ? ' ' : '\n');
}
void run_case() {
IO::read_int(N);
A.resize(N);
sorted.resize(N);
for (int i = 0; i < N; i++) {
IO::read_int(A[i]);
sorted[i] = {A[i], i + 1};
}
sort(sorted.begin(), sorted.end(), compare_first);
for (int i = 0; i < N; i++)
if (sorted[i].first == 0) {
IO::write_int(1, '\n');
IO::write_int(sorted[i].second, '\n');
return;
}
vector<int> location(N + 1, -1);
for (int i = 0; i < N; i++)
if (sorted[i].first > 0) location[sorted[i].first] = sorted[i].second;
for (int i = 0; i < N; i++)
if (sorted[i].first < 0 && location[-sorted[i].first] >= 0) {
IO::write_int(2, '\n');
IO::write_int(sorted[i].second, ' ');
IO::write_int(location[-sorted[i].first], '\n');
return;
}
location.clear();
negatives = positives = {};
for (int i = 0; i < N; i++)
if (sorted[i].first < 0)
negatives.push_back(sorted[i]);
else
positives.push_back(sorted[i]);
int neg = negatives.size(), pos = positives.size();
vector<pair<long long, int>> negative_prefixes, negative_suffixes;
long long sum = 0;
for (int i = 0; i < neg; i++) {
sum += negatives[i].first;
negative_prefixes.emplace_back(sum, i + 1);
}
sum = 0;
for (int i = neg - 1; i >= 0; i--) {
sum += negatives[i].first;
negative_suffixes.emplace_back(sum, -(neg - i));
}
reverse(negative_prefixes.begin(), negative_prefixes.end());
reverse(negative_suffixes.begin(), negative_suffixes.end());
assert(is_sorted(negative_prefixes.begin(), negative_prefixes.end(),
compare_first));
assert(is_sorted(negative_suffixes.begin(), negative_suffixes.end(),
compare_first));
vector<pair<long long, int>> positive_prefixes, positive_suffixes;
sum = 0;
for (int i = 0; i < pos; i++) {
sum += positives[i].first;
positive_prefixes.emplace_back(sum, i + 1);
}
sum = 0;
for (int i = pos - 1; i >= 0; i--) {
sum += positives[i].first;
positive_suffixes.emplace_back(sum, -(pos - i));
}
assert(is_sorted(positive_prefixes.begin(), positive_prefixes.end(),
compare_first));
assert(is_sorted(positive_suffixes.begin(), positive_suffixes.end(),
compare_first));
vector<pair<long long, int>> negative_options(2 * neg),
positive_options(2 * pos);
merge(negative_prefixes.begin(), negative_prefixes.end(),
negative_suffixes.begin(), negative_suffixes.end(),
negative_options.begin(), compare_first);
merge(positive_prefixes.begin(), positive_prefixes.end(),
positive_suffixes.begin(), positive_suffixes.end(),
positive_options.begin(), compare_first);
assert(is_sorted(negative_options.begin(), negative_options.end(),
compare_first));
assert(is_sorted(positive_options.begin(), positive_options.end(),
compare_first));
int no = negative_options.size(), po = positive_options.size();
for (int i = 0, j = po - 1; i < no; i++) {
while (j >= 0 && negative_options[i].first + positive_options[j].first > 0)
j--;
if (j >= 0 && negative_options[i].first + positive_options[j].first == 0) {
output_negative_positive_solution(negative_options[i].second,
positive_options[j].second);
return;
}
}
vector<bool> included(N, false);
int current_count = 0;
long long current_sum = 0;
const int ITERATIONS = 30 * N;
const double INIT_TEMPERATURE = 100;
const double FINAL_TEMPERATURE = 0.1;
const int ITERATIONS_PER_TEMP = 100;
int current_iterations = 0;
while (true) {
double fraction = min((double)current_iterations / ITERATIONS, 1.0);
double temperature =
INIT_TEMPERATURE * pow(FINAL_TEMPERATURE / INIT_TEMPERATURE, fraction);
for (int iter = 0; iter < ITERATIONS_PER_TEMP; iter++) {
current_iterations++;
int index = rng() % N;
int new_count = current_count + (included[index] ? -1 : 1);
long long new_sum =
current_sum + (included[index] ? -A[index] : A[index]);
long long change = abs(new_sum) - abs(current_sum);
if (new_count == 0) continue;
if (change <= 0 || real_rng() < exp(-change / temperature)) {
included[index] = !included[index];
current_count = new_count;
current_sum = new_sum;
if (current_sum == 0) {
IO::write_int(current_count, '\n');
for (int i = 0; i < N; i++)
if (included[i])
IO::write_int(i + 1, --current_count > 0 ? ' ' : '\n');
cerr << current_iterations << " iterations" << '\n';
return;
}
}
}
}
}
int main() {
IO::init();
int T;
IO::read_int(T);
while (T-- > 0) run_case();
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
int g[maxn][maxn] = {0};
int main() {
ios_base ::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> g[i][j];
int row[maxn] = {0};
int col[maxn] = {0};
int cnt = 0;
if (n <= m) {
for (int i = 1; i <= n; ++i) {
int mx = 100000007;
for (int j = 1; j <= m; ++j) {
mx = min(mx, g[i][j]);
}
row[i] = mx;
cnt += mx;
for (int j = 1; j <= m; ++j) g[i][j] -= mx;
}
for (int i = 1; i <= m; ++i) {
int mx = 100000007;
for (int j = 1; j <= n; ++j) {
mx = min(mx, g[j][i]);
}
col[i] = mx;
cnt += mx;
for (int j = 1; j <= n; ++j) g[j][i] -= mx;
}
} else {
for (int i = 1; i <= m; ++i) {
int mx = 100000007;
for (int j = 1; j <= n; ++j) {
mx = min(mx, g[j][i]);
}
col[i] = mx;
cnt += mx;
for (int j = 1; j <= n; ++j) g[j][i] -= mx;
}
for (int i = 1; i <= n; ++i) {
int mx = 100000007;
for (int j = 1; j <= m; ++j) {
mx = min(mx, g[i][j]);
}
row[i] = mx;
cnt += mx;
for (int j = 1; j <= m; ++j) g[i][j] -= mx;
}
}
int ok = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (g[i][j]) {
ok = 0;
break;
}
}
}
if (!ok) {
cout << -1 << endl;
return 0;
}
cout << cnt << endl;
for (int i = 1; i <= n; ++i) {
if (row[i]) {
for (int j = 0; j < row[i]; ++j) {
cout << "row " << i << endl;
}
}
}
for (int i = 1; i <= m; ++i) {
if (col[i]) {
for (int j = 0; j < col[i]; ++j) {
cout << "col " << i << endl;
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int popcount(T n);
template <>
int popcount(unsigned int n) {
return __builtin_popcount(n);
}
template <>
int popcount(int n) {
return __builtin_popcount(n);
}
template <>
int popcount(unsigned long long n) {
return __builtin_popcountll(n);
}
template <>
int popcount(long long n) {
return __builtin_popcountll(n);
}
template <class T>
void max_swap(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void min_swap(T& a, const T& b) {
a = min(a, b);
}
template <class T>
void sort(vector<T>& c) {
sort(c.begin(), c.end());
}
template <class T>
void unique(vector<T>& c) {
sort(c.begin(), c.end());
c.erase(unique(c.begin(), c.end()), c.end());
}
template <class T, class U>
ostream& operator<<(ostream& os, pair<T, U>& p) {
os << "( " << p.first << ", " << p.second << " )";
return os;
}
template <class T>
string to_s(const T& a) {
ostringstream os;
os << a;
return os.str();
}
template <class T>
T to_T(const string& s) {
istringstream is(s);
T res;
is >> res;
return res;
}
bool valid(int x, int y, int w, int h) {
return 0 <= x && x < w && 0 <= y && y < h;
}
template <class T>
void print(T a, int n, const string& deli = " ", int br = 1) {
for (int i = 0; i < n; ++i) {
cout << a[i];
if (i + 1 != n) cout << deli;
}
while (br--) cout << endl;
}
template <class T>
void print(const T& c, const string& deli = " ", int br = 1) {
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it) {
cout << *it;
if (++it != c.end()) cout << deli;
--it;
}
while (br--) cout << endl;
}
template <class T>
void print2d(T a, int w, int h, int width = -1, int br = 1) {
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
if (width != -1) cout.width(width);
cout << a[i][j] << ' ';
}
cout << endl;
}
while (br--) cout << endl;
}
template <class T>
void input(T& a, int n) {
for (int i = 0; i < n; ++i) cin >> a[i];
}
template <class T, class U>
void input(T& a, U& b, int n) {
for (int i = 0; i < n; ++i) cin >> a[i] >> b[i];
}
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const double PI = acos(-1.0);
const int mod = 1000000007;
int main() {
int t[] = {2, 3, 5, 7, 13, 17, 19,
31, 61, 89, 107, 127, 521, 607,
1279, 2203, 2281, 3217, 4253, 4423, 9689,
9941, 11213, 19937, 21701, 23209, 44497, 86243,
110503, 132049, 216091, 756839, 859433, 1257787, 1398269,
2976221, 3021377, 6972593, 13466917, 20996011, 24036583};
int n;
cin >> n;
int e = t[n - 1] - 1;
int res = 1;
for (int i = 0; i < e; ++i) (res *= 2) %= mod;
res = (res - 1 + mod) % mod;
cout << res << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long a = 0;
char c = getchar();
while (c > '9' || c < '0') c = getchar();
while ('0' <= c && c <= '9') {
a = a * 10 + c - 48;
c = getchar();
}
return a;
}
long long N;
long long mu[200005], phi[200005], p[200005 / 10], cnt;
bool vis[200005];
void init(long long n) {
mu[1] = phi[1] = 1;
for (long long i = 2; i <= n; ++i) {
if (!vis[i]) {
p[++cnt] = i;
mu[i] = 1000000007 - 1;
phi[i] = i - 1;
}
for (long long j = 1; p[j] * i <= n; ++j) {
vis[p[j] * i] = 1;
if (i % p[j] == 0) {
mu[i * p[j]] = 0;
phi[i * p[j]] = phi[i] * p[j];
break;
}
phi[i * p[j]] = phi[i] * (p[j] - 1);
mu[i * p[j]] = 1000000007 - mu[i];
}
}
}
long long n, siz[200005], fa[200005], dep[200005], w[200005], tot, rt;
long long a[200005], inv[200005], val[200005], app[200005];
vector<long long> d[200005];
vector<long long> edge[200005];
void dfs(long long x) {
siz[x] = 1;
w[x] = 0;
for (long long i = 0; i < edge[x].size(); ++i) {
long long v = edge[x][i];
if (fa[x] == v || app[v]) continue;
fa[v] = x;
dep[v] = dep[x] + 1;
dfs(v);
siz[x] += siz[v];
if (siz[w[x]] < siz[v]) w[x] = v;
}
if (max(siz[w[x]], N - siz[x]) <= N / 2) rt = x;
}
long long sum[200005], sumv[200005], ans;
vector<long long> rub;
void DFS1(long long x) {
long long V = a[x];
for (long long i = 0; i < d[V].size(); ++i) {
long long t = d[V][i];
ans = (ans + val[t] * sum[t] % 1000000007 * phi[V] % 1000000007 * dep[x]) %
1000000007;
ans = (ans + val[t] * sumv[t] % 1000000007 * phi[V]) % 1000000007;
rub.push_back(t);
}
for (long long i = 0; i < edge[x].size(); ++i) {
long long v = edge[x][i];
if (fa[x] == v || app[v]) continue;
DFS1(v);
}
}
void DFS2(long long x) {
long long V = a[x];
for (long long i = 0; i < d[V].size(); ++i) {
long long t = d[V][i];
sum[t] = (sum[t] + phi[V]) % 1000000007;
sumv[t] = (sumv[t] + phi[V] * dep[x]) % 1000000007;
}
for (long long i = 0; i < edge[x].size(); ++i) {
long long v = edge[x][i];
if (fa[x] == v || app[v]) continue;
DFS2(v);
}
}
void work(long long x, long long tot) {
N = tot;
fa[x] = 0;
dep[x] = 0;
rt = 0;
dfs(x);
long long tmp = rt;
fa[rt] = 0;
dep[rt] = 0;
dfs(rt);
rt = tmp;
long long V = a[rt];
for (long long i = 0; i < d[V].size(); ++i) {
long long t = d[V][i];
rub.push_back(t);
sum[t] = (sum[t] + phi[V]) % 1000000007;
}
for (long long i = 0; i < edge[rt].size(); ++i) {
long long v = edge[rt][i];
if (app[v]) continue;
DFS1(v);
DFS2(v);
}
for (long long i = 0; i < rub.size(); ++i) sum[rub[i]] = sumv[rub[i]] = 0;
rub.clear();
app[rt] = 1;
for (long long i = 0; i < edge[tmp].size(); ++i) {
long long v = edge[tmp][i];
if (app[v]) continue;
work(v, siz[v]);
}
}
signed main() {
n = read();
init(n);
inv[1] = 1;
for (long long i = 2; i <= n; ++i)
inv[i] = (1000000007 - 1000000007 / i) * inv[1000000007 % i] % 1000000007;
for (long long i = 1; i <= n; ++i)
for (long long j = i; j <= n; j += i)
val[j] = (val[j] + i * inv[phi[i]] % 1000000007 * mu[j / i]) % 1000000007;
for (long long i = 1; i <= n; ++i) {
a[i] = read();
}
for (long long i = 1; i <= n; ++i)
for (long long j = i; j <= n; j += i) d[j].push_back(i);
for (long long i = 1; i < n; ++i) {
long long u = read(), v = read();
edge[u].push_back(v);
edge[v].push_back(u);
}
work(1, n);
printf("%lld\n", ans * 2 * inv[n] % 1000000007 * inv[n - 1] % 1000000007);
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int pre, val, suf;
bool full;
Node(int a = 0, int b = 0, int c = 0, bool d = false)
: pre(a), val(b), suf(c), full(d) {}
};
Node combine(Node n1, Node n2) {
Node ret =
Node(n1.pre, max(max(n1.val, n2.val), n1.suf + n2.pre), n2.suf, false);
if (n1.full && n2.full) ret.full = true;
if (n1.full) ret.pre += n2.pre;
if (n2.full) ret.suf += n1.suf;
return ret;
}
int n, lis[100005], q, ll, rr, w, cnt, root[3000006], nodel[3000006],
noder[3000006], high, low;
pair<int, int> p[100005];
Node node[3000006];
void init(int x, int l, int r) {
cnt = max(cnt, x);
if (l == r) {
return;
}
int mid = (l + r) / 2;
init(x * 2 + 1, l, mid);
init(x * 2 + 2, mid + 1, r);
nodel[x] = x * 2 + 1;
noder[x] = x * 2 + 2;
}
int update(int id, int x, int l, int r) {
int nx = ++cnt;
if (l == r) {
node[nx] = Node(1, 1, 1, true);
return nx;
}
nodel[nx] = nodel[x];
noder[nx] = noder[x];
int mid = (l + r) / 2;
if (id <= mid)
nodel[nx] = update(id, nodel[x], l, mid);
else
noder[nx] = update(id, noder[x], mid + 1, r);
ll = nodel[nx];
rr = noder[nx];
node[nx] = combine(node[ll], node[rr]);
return nx;
}
Node query(int x, int l, int r) {
if (r < ll || l > rr) return Node();
if (ll <= l && r <= rr) return node[x];
int mid = (l + r) / 2;
return combine(query(nodel[x], l, mid), query(noder[x], mid + 1, r));
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = (1); i <= (n); i++) cin >> lis[i], p[i] = {lis[i], i};
sort(p + 1, p + n + 1);
reverse(p + 1, p + n + 1);
for (int i = (1); i <= (n); i++) {
root[i] = update(p[i].second, root[i - 1], 1, n);
}
cin >> q;
while (q--) {
cin >> ll >> rr >> w;
high = n;
low = 1;
while (high > low) {
int chs = (high + low) / 2;
if (query(root[chs], 1, n).val >= w)
high = chs;
else
low = chs + 1;
}
cout << p[high].first << endl;
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, maxn = 4005;
int n, a[maxn][2], h[maxn], id[maxn][maxn], dp[maxn][maxn], vis[maxn][maxn];
vector<int> g[maxn];
int dfs(int l, int r) {
if (l >= r) return dp[l][r] = 0;
if (~dp[l][r]) return dp[l][r];
dp[l][r] = dfs(l + 1, r);
for (int i = 0; i < g[l].size(); i++) {
int j = g[l][i];
if (a[j][1] < r) {
if (dp[l][r] < dfs(l, a[j][1]) + dfs(a[j][1], r)) {
dp[l][r] = dp[l][a[j][1]] + dp[a[j][1]][r];
vis[l][r] = j;
}
}
}
return dp[l][r] += (id[l][r] ? 1 : 0);
}
void output(int l, int r) {
if (l >= r) return;
if (id[l][r]) printf("%d ", id[l][r]);
if (vis[l][r]) {
output(l, a[vis[l][r]][1]);
output(a[vis[l][r]][1], r);
} else
output(l + 1, r);
}
int main() {
scanf("%d", &n);
int m;
for (int i = 1; i <= n; i++) {
int x, r;
scanf("%d%d", &x, &r);
h[m++] = a[i][0] = x - r, h[m++] = a[i][1] = x + r;
}
sort(h, h + m);
m = unique(h, h + m) - h;
for (int i = 1; i <= n; i++) {
a[i][0] = lower_bound(h, h + m, a[i][0]) - h + 1;
a[i][1] = lower_bound(h, h + m, a[i][1]) - h + 1;
g[a[i][0]].push_back(i);
id[a[i][0]][a[i][1]] = i;
}
memset(dp, -1, sizeof(dp));
printf("%d\n", dfs(1, m));
output(1, m);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
bool prime[10000001];
long long P = 1000000007 - 2;
long long factorial[10000001] = {0};
long long powerFunction(long long x, long long y) {
long long res = 1;
long long p = 1000000007;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void sieveFunction(long long maxLimit) {
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for (long long i = 2; maxLimit >= i; i++) {
if (prime[i]) {
for (long long j = 2 * i; maxLimit >= j; j += i) prime[j] = false;
}
}
}
void factorialFunction(long long maxLimit) {
factorial[0] = 1;
for (long long i = 1; i <= maxLimit; i++)
factorial[i] = (factorial[i - 1] * i) % 1000000007;
return;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<pair<long long, long long>> tree[800001];
vector<long long> treesum[800001];
vector<pair<long long, long long>> v;
void build(long long node, long long start, long long end) {
if (start == end) {
vector<pair<long long, long long>> temp;
temp.push_back({v[start].second, v[start].first});
tree[node] = temp;
vector<long long> sum;
long long s = 0;
for (long long i = 0; tree[node].size() > i; i++) {
s += tree[node][i].second;
treesum[node].push_back(s);
}
return;
}
long long mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
long long i = 0, j = 0;
while (i < tree[2 * node].size() && j < tree[2 * node + 1].size()) {
if (tree[2 * node][i] <= tree[2 * node + 1][j]) {
tree[node].push_back(tree[2 * node][i]);
i++;
} else {
tree[node].push_back(tree[2 * node + 1][j]);
j++;
}
}
for (long long k = i; k < tree[2 * node].size(); k++)
tree[node].push_back(tree[2 * node][k]);
for (long long k = j; k < tree[2 * node + 1].size(); k++)
tree[node].push_back(tree[2 * node + 1][k]);
long long s = 0;
for (long long k = 0; tree[node].size() > k; k++) {
s += tree[node][k].second;
treesum[node].push_back(s);
}
}
long long n;
long long SEC;
long long query(long long node, long long start, long long end, long long x) {
if (start > x && end <= n) {
pair<long long, long long> tem = {v[x].second, INT64_MIN};
long long id = lower_bound(tree[node].begin(), tree[node].end(), tem) -
tree[node].begin();
if (id) {
SEC += (long long)tree[node].size() - id;
return treesum[node].back() - treesum[node][id - 1];
}
SEC += tree[node].size();
return treesum[node].back();
}
if (end <= x || start > n) {
return 0;
}
long long mid = (start + end) / 2;
return query(2 * node, start, mid, x) + query(2 * node + 1, mid + 1, end, x);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
long long x[n + 1], s[n + 1];
for (long long i = 1; n >= i; i++) {
cin >> x[i];
}
for (long long i = 1; n >= i; i++) {
cin >> s[i];
}
v.push_back({INT64_MIN, INT64_MIN});
for (long long i = 1; n >= i; i++) {
v.push_back({x[i], s[i]});
}
sort(v.begin(), v.end());
build(1, 1, n);
long long ans = 0;
for (long long i = 1; n >= i; i++) {
SEC = 0;
long long xx = v[i].first;
long long temp = query(1, 1, n, i);
temp -= xx * SEC;
ans += temp;
}
cout << ans << "\n";
}
| 11 |
#include <bits/stdc++.h>
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n;
std::cin >> n;
std::vector<int> x(n), y(n);
for (int i = 0; i < n; ++i) std::cin >> x[i] >> y[i];
long long eee = 0, eoo = 0;
for (int i = 0; i < n; ++i) {
int cnt[4][4][4] = {};
for (int j = 0; j < n; ++j) {
if (i != j) {
++cnt[x[j] % 4][y[j] % 4][gcd(abs(x[i] - x[j]), abs(y[i] - y[j])) % 4];
}
}
int x0 = x[i] % 4;
int y0 = y[i] % 4;
for (int x1 = 0; x1 < 4; ++x1) {
for (int y1 = 0; y1 < 4; ++y1) {
for (int b1 = 0; b1 < 4; ++b1) {
int c1 = cnt[x1][y1][b1];
if (!c1) continue;
--cnt[x1][y1][b1];
for (int x2 = x1 % 2; x2 < 4; x2 += 2) {
for (int y2 = y1 % 2; y2 < 4; y2 += 2) {
for (int b2 = b1 % 2; b2 < 4; b2 += 2) {
int c2 = cnt[x2][y2][b2];
if (!c2) continue;
int s = x0 * (y1 - y2) + x1 * (y2 - y0) + x2 * (y0 - y1);
s = (s % 4 + 4) % 4;
if (s % 2) continue;
int b3 = gcd(x1 - x2, y1 - y2);
int a = s / 2 - (b1 + b2 + b3) / 2 + 1;
if (a % 2) {
if (b1 % 2 == 1)
eoo += 1ll * c1 * c2;
else
eee += 1ll * c1 * c2;
}
}
}
}
++cnt[x1][y1][b1];
}
}
}
}
eee /= 6;
eoo /= 2;
std::cout << (eee + eoo) << '\n';
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (a == 0 && b == 0) {
cout << "NO" << endl;
return 0;
}
int x = abs(a - b);
if (x <= 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T bigmod(T b, T p, T m) {
if (p == 0) return 1;
T res = bigmod(b, p / 2, m);
res = (res * res) % m;
if (p % 2 == 1) res = (res * b) % m;
return res;
}
template <class T>
T gcd(T x, T y) {
if (y == 0) return x;
return gcd(y, x % y);
}
template <typename T>
T ModInv(T b, T m) {
return bigmod(b, m - 2, m);
}
int main() {
int i, j, k, n, m, d, x, y;
while (cin >> n >> x >> y) {
d = n / 2;
if ((x == d || x == d + 1) && (y == d || y == d + 1))
puts("NO");
else
puts("YES");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int maxval = -1;
int x;
while (n--) {
scanf("%d", &x);
maxval = max(maxval, x);
}
printf("%d\n", x ^ maxval);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, sum = 0, c = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
sum = sum + 5 * i;
}
while (sum + k > 240) {
sum = sum - 5 * n;
n--;
}
cout << n << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
char s1[1000005], s2[1000005];
long long f[1000005], rf[1000005];
int num[2][30], tmp[2][30];
long long poww(long long a, long long b) {
long long ans = 1;
while (b) {
if (b % 2) ans = (ans * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return ans;
}
int main() {
f[0] = 1;
for (int i = 1; i <= 1e6; i++) f[i] = (f[i - 1] * i) % mod;
for (int i = 0; i <= 1e6; i++) rf[i] = poww(f[i], mod - 2);
scanf("%s%s", s1 + 1, s2 + 1);
int l1 = strlen(s1 + 1), l2 = strlen(s2 + 1);
for (int i = 1; i <= l1; i++) {
num[0][s1[i] - 'a']++;
num[1][s2[i] - 'a']++;
}
long long ans = 0;
int g1 = 0;
for (int i = 1; i <= l1; i++) {
if (s1[i] == s2[i])
g1++;
else
break;
}
for (int i = 1; i <= g1; i++) {
num[0][s1[i]]--;
num[1][s2[i]]--;
}
if (g1 == l1 || (g1 != l1 && s1[g1 + 1] > s2[g1 + 1]))
printf("%lld\n", ans);
else {
g1++;
for (int j = 0; j < 26; j++) {
tmp[0][j] = num[0][j];
tmp[1][j] = num[1][j];
}
for (int i = g1; i <= l1; i++) {
int x = s1[i] - 'a';
int y = s2[i] - 'a';
int r = l1 - i;
long long ff = f[r];
for (int j = 0; j < 26; j++) ff = (ff * rf[tmp[0][j]]) % mod;
if (i != g1) y = 26;
for (int j = x + 1; j <= y - 1; j++) {
if (tmp[0][j] == 0) continue;
ff = (ff * f[tmp[0][j]]) % mod;
tmp[0][j]--;
ff = (ff * rf[tmp[0][j]]) % mod;
ans = (ans + ff) % mod;
ff = (ff * f[tmp[0][j]]) % mod;
tmp[0][j]++;
ff = (ff * rf[tmp[0][j]]) % mod;
}
tmp[0][s1[i] - 'a']--;
}
for (int j = 0; j < 26; j++) {
tmp[0][j] = num[0][j];
tmp[1][j] = num[1][j];
}
if (tmp[0][s2[g1] - 'a'] != 0) {
tmp[0][s2[g1] - 'a']--;
for (int i = g1 + 1; i <= l1; i++) {
int x = -1;
int y = s2[i] - 'a';
int r = l1 - i;
long long ff = f[r];
for (int j = 0; j < 26; j++) ff = (ff * rf[tmp[0][j]]) % mod;
for (int j = x + 1; j <= y - 1; j++) {
if (tmp[0][j] == 0) continue;
ff = (ff * f[tmp[0][j]]) % mod;
tmp[0][j]--;
ff = (ff * rf[tmp[0][j]]) % mod;
ans = (ans + ff) % mod;
ff = (ff * f[tmp[0][j]]) % mod;
tmp[0][j]++;
ff = (ff * rf[tmp[0][j]]) % mod;
}
if (tmp[0][s2[i] - 'a'] == 0) break;
tmp[0][s2[i] - 'a']--;
}
}
printf("%lld\n", ans);
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
string a;
int x;
int b;
int c;
int d;
int e;
int main() {
cin >> a;
x = a.length();
if (x >= 5) {
b = true;
}
for (int i = 0; i < x; i++) {
if ((a[i] >= 65) && (a[i] <= 90)) {
c++;
} else if ((a[i] >= 97) && (a[i] <= 122)) {
d++;
} else if ((a[i] >= 48) && (a[i] <= 57)) {
e++;
}
}
if ((b == true) && (c >= 1) && (d >= 1) && (e >= 1)) {
cout << "Correct";
} else {
cout << "Too weak";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int s, a, b, c;
int main() {
scanf("%d%d%d%d", &s, &a, &b, &c);
if (a == 0) {
if (b == 0) {
if (c != 0)
printf("%.14lf %.14lf %.14lf\n", 0.0, 0.0, s * 1.);
else
printf("%.14lf %.14lf %.14lf\n", 0.0, 0.0, 0.0);
} else if (c == 0)
printf("%.14lf %.14lf %.14lf\n", 0.0, s * 1., 0.0);
else
printf("%.14lf %.14lf %.14lf\n", 0.0, s * 1. * (b * 1. / (b + c)),
s * 1.0 * (c * 1.0 / (b + c)));
} else {
if (b == 0) {
if (c == 0)
printf("%.14lf %.14lf %.14lf\n", s * 1., 0.0, 0.0);
else
printf("%.14lf %.14lf %.14lf\n", s * 1. * (a * 1. / (a + c)), 0.0,
s * 1. * c * 1. / (a + c));
} else {
if (c == 0)
printf("%.14lf %.14lf %.14lf\n", s * 1. * (a * 1. / (a + b)),
s * 1. * (b * 1. / (a + b)), 0.0);
else
printf("%.14lf %.14lf %.14lf\n", s * 1. * (a * 1. / (a + b + c)),
s * 1. * (b * 1. / (a + b + c)),
s * 1. * (c * 1. / (a + b + c)));
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
int n, m, a[maxn];
double p[maxn][maxn];
int main() {
int u, v;
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) p[i][j] = (a[i] > a[j]) ? 1.0 : 0.0;
for (int i = 0; i != m; i++) {
scanf("%d%d", &u, &v);
p[u][v] = p[v][u] = 0.5;
for (int k = 1; k <= n; k++)
if (u != k && v != k) {
p[u][k] = p[v][k] = (p[u][k] + p[v][k]) * 0.5;
p[k][u] = p[k][v] = (p[k][u] + p[k][v]) * 0.5;
}
}
double ans = 0;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) ans += p[i][j];
printf("%.6lf\n", ans);
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int p[300000];
int a[300000];
int pos[300000];
int n;
long long seg[1500000];
long long lazy[1500000];
void propagate(int id, int l, int r) {
seg[id] += lazy[id];
if (l != r) {
lazy[id * 2 + 1] += lazy[id];
lazy[id * 2 + 2] += lazy[id];
}
lazy[id] = 0;
}
long long query() {
if (lazy[0] != 0) {
propagate(0, 1, n - 1);
}
return seg[0];
}
void update(int id, int l, int r, int x, int y, long long val) {
propagate(id, l, r);
if (x <= l && r <= y) {
lazy[id] += val;
propagate(id, l, r);
return;
}
if (y < l || r < x) return;
int m = (l + r) >> 1;
update(id * 2 + 1, l, m, x, y, val);
update(id * 2 + 2, m + 1, r, x, y, val);
seg[id] = min(seg[2 * id + 1], seg[2 * id + 2]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
pos[p[i]] = i;
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
long long ans = 0, tot = 0;
for (int i = n - 1; i >= 1; i--) {
tot += a[i];
update(0, 1, n - 1, i, i, tot);
}
ans = query();
for (int i = n - 1; i >= 0; i--) {
int t = pos[i + 1];
if (t != 0) update(0, 1, n - 1, 1, t, -a[t]);
if (t != n - 1) update(0, 1, n - 1, t + 1, n - 1, a[t]);
ans = min(ans, query());
}
printf("%lld", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int re = 0, flag = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
re = (re << 1) + (re << 3) + ch - '0', ch = getchar();
return re * flag;
}
int n, m, cnt, first[100010];
long long dis[100010];
struct edge {
int to, next, w;
} a[100010];
inline void add(int u, int v, int w) {
a[++cnt] = (edge){v, first[u], w};
first[u] = cnt;
}
struct node {
int x;
node() { x = 0; }
node(int xx) { x = xx; }
bool operator<(node r) const { return dis[x] > dis[r.x]; }
};
int delta[100010];
priority_queue<node> qq;
void spfa() {
int i, u, v;
for (i = 1; i <= n; i++) dis[i] = 1e15;
dis[1] = 0;
qq.push(node(1));
while (!qq.empty()) {
u = qq.top().x;
qq.pop();
for (i = first[u]; ~i; i = a[i].next) {
v = a[i].to;
if (dis[v] > dis[u] + (long long)a[i].w) {
dis[v] = dis[u] + (long long)a[i].w;
qq.push(node(v));
}
}
}
}
queue<int> q[100010];
void bfs() {
memset(delta, 0x3f, sizeof(delta));
int i, j, u, v, w, maxn, head = 0, tail = 1;
q[0].push(1);
delta[1] = maxn = 0;
for (i = 0; i <= maxn; i++) {
while (!q[i].empty()) {
u = q[i].front();
q[i].pop();
if (i > delta[u]) continue;
for (j = first[u]; ~j; j = a[j].next) {
v = a[j].to;
w = a[j].w;
if (delta[v] > delta[u] + dis[u] + w - dis[v]) {
delta[v] = delta[u] + dis[u] + w - dis[v];
if (delta[v] <= n) {
q[delta[v]].push(v);
maxn = max(maxn, delta[v]);
}
}
}
}
}
}
int main() {
memset(first, -1, sizeof(first));
int i, j, t1, t2, t3, Q;
n = read();
m = read();
Q = read();
for (i = 1; i <= m; i++) {
t1 = read();
t2 = read();
t3 = read();
add(t1, t2, t3);
}
spfa();
for (i = 1; i <= Q; i++) {
t1 = read();
if (t1 == 1)
t2 = read(), printf("%I64d\n", (dis[t2] >= 1e15) ? -1 : dis[t2]);
else {
t2 = read();
memset(delta, 0, sizeof(delta));
for (j = 1; j <= t2; j++) t3 = read(), a[t3].w++;
bfs();
for (j = 1; j <= n; j++) dis[j] += (long long)delta[j];
}
}
return 0;
}
| 26 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
int l, w, a[N];
int sum[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> w >> l;
for (int i = 1; i < w; i++) cin >> a[i];
for (int i = 1; i < w; i++) sum[i] = sum[i - 1] + a[i];
int ans = 1000000000;
for (int i = 0; i < w - l; i++) ans = min(ans, sum[i + l] - sum[i]);
cout << ans << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, p, a[100010];
int judge(int x) {
int now = 1, i;
for (i = 1; i <= n; i++) {
while (now <= n && a[now] <= x) now++;
if ((now - i) % p == 0) return 1;
x++;
}
return 0;
}
int main() {
int i, maxi, l, r, mid;
cin >> n >> p;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
maxi = -1;
for (i = 1; i <= n; i++) maxi = max(maxi, a[i] - i + 1);
l = maxi - 1, r = 1000000000;
while (l + 1 < r) {
mid = (l + r) / 2;
if (judge(mid))
r = mid;
else
l = mid;
}
cout << l - maxi + 1 << endl;
for (i = maxi; i <= l; i++) cout << i << " ";
cout << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
const double eps = 1e-11;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
using namespace std;
const int maxn = 100005;
int n, m, arr[maxn];
pair<int, int> q[maxn];
int rtop[maxn], ltop[maxn];
void solve() {
rtop[n - 1] = n - 1;
for (int i = n - 2; i >= 0; i--) {
if (arr[i] <= arr[i + 1])
rtop[i] = rtop[i + 1];
else
rtop[i] = i;
}
ltop[0] = 0;
for (int i = 1; i < n; i++) {
if (arr[i - 1] >= arr[i])
ltop[i] = ltop[i - 1];
else
ltop[i] = i;
}
for (int i = 0; i < m; i++) {
if (rtop[q[i].first - 1] < ltop[q[i].second - 1])
puts("No");
else
puts("Yes");
}
}
int main() {
while (scanf("%d%d", &n, &m) == 2) {
for (int i = 0; i < (n); i++) scanf("%d", &arr[i]);
for (int i = 0; i < (m); i++) scanf("%d%d", &q[i].first, &q[i].second);
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
struct drift {
int x, y;
bool v;
drift(int a, int b) : x(a), y(b), v(0){};
};
std::vector<drift> array;
void search(int start, int L) {
if (array[start].v == 1) {
return;
}
array[start].v = 1;
for (int p = 0; p < L; p++) {
if (array[p].x == array[start].x || array[p].y == array[start].y) {
search(p, L);
}
}
}
int main() {
int n;
scanf("%d", &n);
for (int p = 0; p < n; p++) {
int f, g;
scanf("%d %d", &f, &g);
array.push_back(drift(f, g));
}
int components = 0;
for (int p = 0; p < n; p++) {
if (array[p].v > 0) {
continue;
}
++components;
search(p, n);
}
printf("%d\n", components - 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5;
struct node {
int ls, rs, sum;
};
node tr[maxn * 10];
int mar[maxn], a[maxn], nxt[maxn];
int root[maxn];
int v, n;
void nw(int x) { tr[x] = (node){0, 0, 0}; }
void build(int x, int l, int r) {
if (l == r) {
tr[x].sum = 0;
if (mar[a[l]] == l && l != n + 1) tr[x].sum = 1;
return;
}
v++;
nw(v);
tr[x].ls = v;
int mid = (r + l) / 2;
build(v, l, mid);
v++;
nw(v);
tr[x].rs = v;
build(v, mid + 1, r);
tr[x].sum = tr[tr[x].ls].sum + tr[tr[x].rs].sum;
}
void md(int x, int xp, int l, int r, int ll, int y) {
if (l == r) {
tr[x].sum += y;
return;
}
int mid = (r + l) / 2;
if (ll <= mid) {
if (tr[x].ls == 0) {
v++;
nw(v);
tr[x].ls = v;
}
if (tr[x].rs == 0) tr[x].rs = tr[xp].rs;
md(tr[x].ls, tr[xp].ls, l, mid, ll, y);
} else {
if (tr[x].rs == 0) {
v++;
nw(v);
tr[x].rs = v;
}
if (tr[x].ls == 0) tr[x].ls = tr[xp].ls;
md(tr[x].rs, tr[xp].rs, mid + 1, r, ll, y);
}
tr[x].sum = tr[tr[x].ls].sum + tr[tr[x].rs].sum;
}
int get(int x, int l, int r, int k) {
if (l == r) return l;
if (tr[tr[x].ls].sum > k)
return get(tr[x].ls, l, (r + l) / 2, k);
else
return get(tr[x].rs, (r + l) / 2 + 1, r, k - tr[tr[x].ls].sum);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = n; i >= 1; i--) mar[i] = n + 1;
for (int i = n; i >= 1; i--) {
nxt[i] = mar[a[i]];
mar[a[i]] = i;
}
v = 1;
nw(1);
build(1, 1, n + 1);
root[1] = 1;
for (int i = 2; i <= n; i++) {
v++;
nw(v);
root[i] = v;
md(v, root[i - 1], 1, n + 1, i - 1, 0);
if (nxt[i - 1] != n + 1) {
v++;
nw(v);
int sv = root[i];
root[i] = v;
md(v, sv, 1, n + 1, nxt[i - 1], 1);
}
}
for (int k = 1; k <= n; k++) {
int l = 1;
int ans = 0;
while (l <= n) {
int q = get(root[l], 1, n + 1, k);
ans++;
l = q;
}
cout << ans << " ";
}
cout << "\n";
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
inline char ch() {
static char s[1 << 16], *S, *T;
return (S == T) && (T = (S = s) + fread(s, 1, 1 << 16, stdin), S == T) ? EOF
: *S++;
}
template <typename T>
void read(T &x) {
x = 0;
int f(1);
char c = ch();
for (; !isdigit(c); c = ch())
if (c == '-') f = -1;
for (; isdigit(c); c = ch()) x = x * 10 + c - '0';
x *= f;
}
} // namespace IO
using namespace IO;
const int maxn = 1000003;
const long long p = 1000000007;
const long long inv2 = (p + 1) / 2;
int n, m1, m2;
long long f[maxn];
int main() {
read(n);
for (int i(1); i <= n; ++i) {
int x;
read(x);
if (x == 1)
++m1;
else
++m2;
}
f[1] = f[0] = 1;
for (int i(2); i <= m1; ++i) f[i] = (f[i - 2] * (i - 1) % p + f[i - 1]) % p;
for (int i = m1 + 1; i <= n; ++i) f[m1] = f[m1] * i % p;
cout << f[m1] << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
struct DSU {
int n;
int* p;
DSU(int n) : n(n), p(new int[n]) {
for (int i = 0; i < n; i++) p[i] = i;
}
~DSU() { delete[] p; }
int get(int x) {
if (p[x] == x) return x;
return p[x] = get(p[x]);
}
void unite(int a, int b) {
a = get(a);
b = get(b);
p[a] = b;
}
};
vector<vector<pair<int, int> > > v;
vector<int> d;
vector<int> res;
int solve(int cur, int pid) {
int curdeg = 0;
for (int i = 0; i < v[cur].size(); i++) {
if (v[cur][i].second == pid) continue;
curdeg ^= solve(v[cur][i].first, v[cur][i].second);
}
if (d[cur] != -1 && curdeg != d[cur]) {
res.push_back(pid);
return 1;
}
return 0;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
DSU dsu(n);
v.resize(n);
d.resize(n);
for (int i = 0; i < n; i++) scanf("%d", &d[i]);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
if (dsu.get(a) != dsu.get(b)) {
v[a].push_back(make_pair(b, i + 1));
v[b].push_back(make_pair(a, i + 1));
dsu.unite(a, b);
}
}
vector<int>::iterator it = find(d.begin(), d.end(), -1);
int root = 0;
if (it != d.end())
root = it - d.begin();
else if (accumulate(d.begin(), d.end(), 0) % 2 != 0) {
puts("-1");
return 0;
}
int resv = solve(root, -1);
assert(resv == 0);
printf("%d\n", (int)res.size());
for (int i = 0; i < res.size(); i++) printf("%d\n", res[i]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> moves;
long long k;
long long a;
long long s;
bool cheat(int n) {
vector<long long> mv;
for (int i = 0; i < n; i++) mv.push_back(moves[i]);
sort(mv.begin(), mv.end());
long long l = 1;
long long sh = k;
for (int i = 0; i < n; i++) {
int cs = mv[i] - l;
while (cs >= a) {
cs -= a;
if (cs >= 0) sh--;
cs--;
}
l = mv[i];
l++;
}
int cs = s - l + 1;
while (cs >= a) {
cs -= a;
if (cs >= 0) sh--;
cs--;
}
if (sh > 0)
return true;
else
return false;
}
int main() {
cin.sync_with_stdio(false);
long long m;
cin >> s >> k >> a >> m;
moves.resize(m);
for (int(i) = int(0); i < int(m); i++) cin >> moves[i];
long long lo = 1, hi = m + 1;
if (!cheat(m)) {
cout << "-1" << endl;
return 0;
}
while (hi - lo > 0) {
long long mid = lo + floor((hi - lo) / 2);
if (cheat(mid)) {
hi = mid;
} else
lo = mid + 1;
}
cout << lo << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const long long mod = 1e9 + 7;
const long long ulim = 2e6 + 5;
long long coeff[ulim], powers[ulim], answers[ulim], sub[ulim];
long long fastexpo(long long n, long long p) {
n %= mod;
return (p == 0 ? 1 : fastexpo(n * n, p / 2) * (p & 1 ? n : 1)) % mod;
}
void pre(long long lim, long long n) {
coeff[1] = 1;
for (long long i = 1; i < lim + 1; i++)
for (long long j = i + i; j < lim + 1; j += i)
coeff[j] = (coeff[j] - coeff[i] + mod) % mod;
for (long long i = 1; i < ulim; i++) powers[i] = fastexpo(i, n);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
pre(k, n);
for (long long i = 1; i <= k; i++)
for (long long j = i; j <= k; j += i) {
(answers[j] += coeff[i] * powers[j / i]) %= mod;
(sub[j] += coeff[i] * powers[j / i - 1]) %= mod;
}
for (long long i = 2; i <= k; i++)
(answers[i] += answers[i - 1] + mod - sub[i]) %= mod;
long long ans = 0;
for (long long i = 1; i <= k; i++) (ans += (answers[i] ^ i)) %= mod;
cout << ans << endl;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pil = pair<int, ll>;
using pll = pair<ll, ll>;
template <typename T>
using vec = vector<T>;
using vi = vec<int>;
using vl = vec<ll>;
template <typename T>
using que = queue<T>;
template <typename T>
using deq = deque<T>;
template <typename T>
T id(T b) {
return b;
};
template <typename T>
void chmax(T &x, T y) {
if (x < y) x = y;
}
template <typename T>
void chmin(T &x, T y) {
if (x > y) x = y;
}
template <typename S, typename K>
bool contains(S &s, K k) {
return s.find(k) != s.end();
}
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
constexpr ll TEN(int n) {
if (n == 0)
return 1LL;
else
return 10LL * TEN(n - 1);
}
int n, m, c;
int main() {
fastio();
cin >> n >> m >> c;
vi s(n, 1000000);
int l = 0, r = n;
for (int i = 0; i < int(m); i++) {
int x;
cin >> x;
int k;
if (x <= c / 2) {
k = upper_bound(s.begin(), s.begin() + l + 1, x) - s.begin();
chmax(l, k + 1);
} else {
k = lower_bound(s.begin() + r, s.end(), x) - s.begin();
k--;
chmin(r, k);
}
assert(k < n);
s[k] = x;
cout << k + 1 << endl;
if (l >= r) {
return 0;
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n];
int c = 0;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
if (b[i] - a[i] >= 2) c++;
}
cout << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int len = s.length(), size = 0;
for (char c : s) {
if (c == '(') {
size++;
} else {
if (size == 0) {
len--;
} else {
size--;
}
}
}
if (size > 0) {
cout << len - size;
} else {
cout << len;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class A>
void pr(A a) {
cout << a;
cout << '\n';
}
template <class A, class B>
void pr(A a, B b) {
cout << a << ' ';
pr(b);
}
template <class A, class B, class C>
void pr(A a, B b, C c) {
cout << a << ' ';
pr(b, c);
}
template <class A, class B, class C, class D>
void pr(A a, B b, C c, D d) {
cout << a << ' ';
pr(b, c, d);
}
template <class A>
void PR(A a, long long n) {
for (long long i = (long long)(0); i < (long long)(n); i++) {
if (i) cout << ' ';
cout << a[i];
}
cout << '\n';
}
long long check(long long n, long long m, long long x, long long y) {
return x >= 0 && x < n && y >= 0 && y < m;
}
const long long MAX = 1e9 + 7, MAXL = 1LL << 61, dx[4] = {-1, 0, 1, 0},
dy[4] = {0, 1, 0, -1};
class BIT {
public:
long long n, bit[555555];
BIT() { fill(bit, bit + 555555, 0); }
void add(long long i, long long x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
long long sum(long long i) {
long long s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
};
BIT b = BIT();
void Main() {
long long n;
cin >> n;
long long a[n];
for (long long i = (long long)(0); i < (long long)(n); i++) cin >> a[i];
int m;
cin >> m;
pair<pair<long long, long long>, long long> p[m];
for (long long i = (long long)(0); i < (long long)(m); i++) {
cin >> p[i].first.first >> p[i].first.second;
p[i].second = i;
}
sort(p, p + m);
priority_queue<pair<long long, long long> > que;
for (long long i = (long long)(0); i < (long long)(n); i++)
que.push(pair<long long, long long>(a[i], -i));
b.n = n + 1;
long long k = 0, c = 0;
long long ans[m];
while (!que.empty()) {
pair<long long, long long> q = que.top();
que.pop();
c++;
b.add(-q.second + 1, 1);
while (k < m && p[k].first.first == c) {
int l = 0, r = n;
while (l + 1 < r) {
long long mm = (l + r) / 2;
if (b.sum(mm) < p[k].first.second)
l = mm;
else
r = mm;
}
ans[p[k].second] = a[l];
k++;
}
}
for (long long i = (long long)(0); i < (long long)(m); i++) pr(ans[i]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
Main();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T euclide(T a, T b, T& x, T& y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline void checkmin(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T& a, T b) {
if (b > a) a = b;
}
template <class T>
T Abs(T x) {
return x > 0 ? x : -x;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline bool isPrime(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
template <class T>
inline T Mod(T n, T m) {
return (n % m + m) % m;
}
template <class T>
string toString(T n) {
ostringstream oss;
oss << n;
oss.flush();
return oss.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long toLl(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
template <class T>
void debug(const T& e) {
cout << e << endl;
}
template <class T1, class T2>
void debug(const T1& e1, const T2& e2) {
cout << e1 << "\t" << e2 << endl;
}
template <class T1, class T2, class T3>
void debug(const T1& e1, const T2& e2, const T3& e3) {
cout << e1 << "\t" << e2 << "\t" << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void debug(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void debug(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
const T5& e5) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << "\t" << e5 << endl;
}
template <class T>
void debug(vector<T>& e) {
int i;
for (i = 0; i < (int)e.size(); i++) cout << e[i] << " ";
cout << endl;
}
template <class T>
void debug(vector<basic_string<T> >& e) {
int i, j;
for (i = 0; i < (int)e.size(); i++) {
for (j = 0; j < (int)e[i].size(); j++) cout << e[i][j];
cout << endl;
}
cout << endl;
}
template <class T>
void debug(vector<vector<T> >& e, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << "\t";
cout << endl;
}
cout << endl;
}
template <class T>
void debug(T e[100][100], int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << " ";
cout << endl;
}
}
long long Pow(int B, int P) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) R = (R * B);
P /= 2;
B = (B * B);
}
return R;
}
int BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return (int)R;
}
map<string, string> MAP;
map<string, bool> MAP1;
int main() {
int i, j, Case = 1, test, N, nd, str, op;
string A, B, type, s;
while (scanf("%d", &N) == 1) {
MAP.clear();
MAP1.clear();
MAP1["void"] = 1;
MAP1["errtype"] = 1;
MAP["void"] = "void";
MAP["errtype"] = "errtype";
while (N--) {
cin >> type;
if (type == "typedef") {
cin >> A >> B;
op = 1;
} else {
op = 2;
cin >> A;
}
if (op == 1) {
nd = str = 0;
s = "";
for (i = 0; i < A.size(); i++)
if (isalpha(A[i]))
s += A[i];
else if (A[i] == '*')
str++;
else
nd++;
if (s == "void") {
nd = str - nd;
if (nd >= 0) {
while (nd--) s += "*";
MAP[B] = s;
} else
MAP[B] = "errtype";
} else {
if (MAP1[s]) {
s = MAP[s];
if (s == "errtype") {
MAP[B] = "errtype";
} else {
for (i = 0; i < s.size(); i++)
if (s[i] == '*') str++;
nd = str - nd;
s = "void";
if (nd >= 0) {
while (nd--) s += "*";
MAP[B] = s;
} else
MAP[B] = "errtype";
}
} else
MAP[B] = "errtype";
}
MAP1[B] = 1;
} else {
nd = str = 0;
s = "";
for (i = 0; i < A.size(); i++)
if (isalpha(A[i]))
s += A[i];
else if (A[i] == '*')
str++;
else
nd++;
if (MAP1[s]) {
string ss = MAP[s];
s = ss;
ss = "";
for (i = 0; i < s.size(); i++)
if (isalpha(s[i]))
ss += s[i];
else if (s[i] == '*')
str++;
nd = str - nd;
s = ss;
if (nd >= 0 && s != "errtype") {
while (nd--) s += "*";
} else
s = "errtype";
cout << s << endl;
} else {
cout << "errtype" << endl;
}
}
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
int d[N];
int n;
long long sum, A;
int main() {
scanf("%d%I64d", &n, &A);
sum = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &d[i]);
sum += d[i];
}
for (int i = 0; i < n; ++i)
cout << max(d[i] - A + n - 1, 0ll) + max(A - sum + d[i] - 1, 0ll) << " ";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
cout << 25 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char c = getchar();
long long x = 1, s = 0;
while (c < '0' || c > '9') {
if (c == '-') x = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
s = s * 10 + c - '0';
c = getchar();
}
return s * x;
}
const int N = 3e5 + 5;
int n, m, a[N], l, r, ans[N], minn[N * 4];
vector<int> s[N];
vector<pair<int, int> > q[N];
void build(int u, int l, int r) {
for (int i = l; i <= r; i++) s[u].push_back(a[i]);
sort(s[u].begin(), s[u].end());
minn[u] = 2e9 + 7;
if (l == r) return;
build((u << 1), l, ((l + r) >> 1));
build((u << 1 | 1), ((l + r) >> 1) + 1, r);
}
int maxx = 0, ne;
void modify(int u, int l, int r, int x) {
int tmp = 2e9 + 7;
int pre = upper_bound(s[u].begin(), s[u].end(), ne) - s[u].begin() - 1;
int prv = upper_bound(s[u].begin(), s[u].end(), ne) - s[u].begin();
if (pre >= 0) tmp = min(tmp, abs(ne - s[u][pre]));
if (prv != s[u].size()) tmp = min(tmp, abs(ne - s[u][prv]));
if (tmp >= maxx) return;
if (l == r) {
minn[u] = min(minn[u], abs(a[l] - ne));
maxx = min(maxx, abs(a[l] - ne));
return;
}
if (x > ((l + r) >> 1)) modify((u << 1 | 1), ((l + r) >> 1) + 1, r, x);
modify((u << 1), l, ((l + r) >> 1), x);
minn[u] = min(minn[(u << 1)], minn[(u << 1 | 1)]);
}
int query(int u, int l, int r, int L, int R) {
if (L <= l and R >= r) {
return minn[u];
}
int maa = 2e9 + 7;
if (L <= ((l + r) >> 1))
maa = min(maa, query((u << 1), l, ((l + r) >> 1), L, R));
if (R > ((l + r) >> 1))
maa = min(maa, query((u << 1 | 1), ((l + r) >> 1) + 1, r, L, R));
return maa;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
build(1, 1, n);
m = read();
for (int i = 1; i <= m; i++) {
l = read();
r = read();
q[r].push_back(make_pair(l, i));
}
for (int i = 2; i <= n; i++) {
maxx = 2e9 + 7;
ne = a[i];
modify(1, 1, n, i - 1);
for (int k = 0; k < q[i].size(); k++) {
ans[q[i][k].second] = query(1, 1, n, q[i][k].first, i - 1);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const long double PI =
3.141592653589793238462643383279502884197169399375105820974944592307816;
struct compare {
bool operator()(pair<int, int> a, pair<int, int> b) const {
return abs(a.second) < abs(b.second);
}
};
int main() {
long long ans = 0;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
ans += (n - i) * i + 1;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
long long const N = 2 * 1e5 + 5;
long long x1, r, x2, c, ibibibibbibibibiibigbabypanfewewf, y2, d, q, mx, mx1,
ans, pos, a[N], aa[N], b, y3, k, pref[5005][4];
long long m, n;
string second;
char ch;
vector<long long> v;
vector<long long> v1;
vector<long long> v2;
bool pr, us[1004];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
aa[a[i]]++;
}
for (int i = 0; i < n; i++) {
if (aa[a[i]] > mx1) mx1 = aa[a[i]], pos = i, mx = a[i];
}
for (int i = pos - 1; i >= 0; i--) {
if (a[i] > mx)
v.push_back(2), v1.push_back(i + 1), v2.push_back(i + 2);
else if (a[i] < mx)
v.push_back(1), v1.push_back(i + 1), v2.push_back(i + 2);
}
for (int i = pos + 1; i < n; i++) {
if (a[i] > mx)
v.push_back(2), v1.push_back(i + 1), v2.push_back(i);
else if (a[i] < mx)
v.push_back(1), v1.push_back(i + 1), v2.push_back(i);
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " " << v1[i] << " " << v2[i] << endl;
}
}
| 6 |
#include <bits/stdc++.h>
int n, f[100010], g[100010], h[100010], w[100010], cnt, p[100010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", f + i);
for (int i = 1; i <= n; i++)
if (f[i] != f[f[i]]) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++)
if (!w[f[i]]) w[f[i]] = ++cnt, h[cnt] = f[i];
for (int i = 1; i <= n; i++) g[i] = w[f[i]];
printf("%d\n", cnt);
for (int i = 1; i <= n; i++) printf("%d ", g[i]);
puts("");
for (int i = 1; i <= cnt; i++) printf("%d ", h[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <class T>
ostream &prnt(ostream &out, T v) {
out << v.size() << '\n';
for (auto e : v) out << e << ' ';
return out;
}
template <class T>
ostream &operator<<(ostream &out, vector<T> v) {
return prnt(out, v);
}
template <class T>
ostream &operator<<(ostream &out, set<T> v) {
return prnt(out, v);
}
template <class T1, class T2>
ostream &operator<<(ostream &out, map<T1, T2> v) {
return prnt(out, v);
}
template <class T1, class T2>
ostream &operator<<(ostream &out, pair<T1, T2> p) {
return out << '(' << p.first << ' ' << p.second << ')';
}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << H;
debug_out(T...);
}
const long double PI = acos(-1);
class Point {
public:
long double x, y;
Point() : x(0), y(0) {}
Point(long double _x, long double _y) : x(_x), y(_y) {}
bool operator==(const Point &oth) const { return x == oth.x && y == oth.y; }
bool operator<(const Point &oth) const {
return x == oth.x ? y < oth.y : x < oth.x;
}
long double dist(Point B) const {
return sqrt((x - B.x) * (x - B.x) + (y - B.y) * (y - B.y));
}
void operator=(const Point &oth) {
this->x = oth.x;
this->y = oth.y;
}
Point operator+(const Point &oth) const { return {x + oth.x, y + oth.y}; }
Point operator-(const Point &oth) const { return {x - oth.x, y - oth.y}; }
Point operator/(const long double value) const {
return {x / value, y / value};
}
Point operator*(const long double value) const {
return {x * value, y * value};
}
friend ostream &operator<<(ostream &output, const Point &P) {
output << P.x << " " << P.y;
return output;
}
friend istream &operator>>(istream &input, Point &P) {
input >> P.x >> P.y;
return input;
}
};
class Geom {
public:
static long double det(Point A, Point B, Point C) {
return (B.x - A.x) * (C.y - A.y) - (C.x - A.x) * (B.y - A.y);
}
static void rotate(vector<Point> &points, long double angle = 0) {
if (abs(angle) < 0.000000001) {
unsigned seed1 = chrono::system_clock::now().time_since_epoch().count();
std::mt19937 generator(seed1);
std::uniform_real_distribution<long double> distribution(0.0, 3.14);
angle = distribution(generator);
}
for (auto &it : points) {
long double x = it.x * cos(angle) - it.y * sin(angle);
long double y = it.x * sin(angle) + it.y * cos(angle);
it = {x, y};
}
}
};
class ConvexHull {
private:
static Point bst;
static bool comp(Point &A, Point &B) {
if (B == bst) return false;
int x = Geom::det(bst, A, B);
if (abs(x) < 0.000000001) return bst.dist(A) < bst.dist(B);
return x < 0;
}
public:
vector<Point> getConvexHull(vector<Point> points) {
if (points.size() <= 1) return points;
bst = points[0];
for (auto &it : points) bst = min(bst, it);
sort(points.begin(), points.end(), comp);
vector<Point> H({points[0], points[1]});
for (int i = 2; i < (int)points.size(); i++) {
while (H.size() >= 2 &&
(Geom::det(H[H.size() - 2], H.back(), points[i]) > 0 ||
(Geom::det(H[H.size() - 2], H.back(), points[i]) == 0 &&
H[H.size() - 2].dist(H.back()) <
H[H.size() - 2].dist(points[i])))) {
H.pop_back();
}
H.push_back(points[i]);
}
return H;
}
};
Point ConvexHull::bst;
int n;
Point aux;
vector<Point> p;
bitset<3005> B[3005];
struct ceva {
long double v;
int a, b;
};
vector<ceva> v;
bool comp(ceva A, ceva B) { return A.v > B.v; }
int main() {
ios::sync_with_stdio(false);
ConvexHull ch = ConvexHull();
cin >> n;
for (int i = 1; i <= n; i++) cin >> aux, p.push_back(aux);
for (int i = 0; i < p.size(); i++) {
for (int j = i + 1; j < p.size(); j++) {
v.push_back({p[i].dist(p[j]), i, j});
}
}
sort(v.begin(), v.end(), comp);
for (auto it : v) {
if ((B[it.a] & B[it.b]).any()) {
cout << fixed << setprecision(10) << it.v / 2 << '\n';
return 0;
}
B[it.a].set(it.b);
B[it.b].set(it.a);
}
return 0;
}
| 17 |
#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;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long int i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (long long i = 1; i <= n; i++) {
if (v[i].size() == 2) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.