solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, d[1010];
int s, t;
int main() {
scanf("%d", &n);
int sum(0);
for (int i = 1; i <= n; i++) scanf("%d", &d[i]), sum += d[i];
scanf("%d%d", &s, &t);
if (s > t) swap(s, t);
int ans(0);
for (int i = s; i < t; i++) ans += d[i];
printf("%d\n", min(ans, sum - ans));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<long long, pair<int, int> > a;
long long sum;
int n, tmp, cur;
int b[200000 + 5];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> tmp, sum = 0;
for (int j = 1; j <= tmp; j++) {
cin >> cur;
sum += cur;
b[j] = cur;
}
for (int j = 1; j <= tmp; j++) {
pair<int, int> h = a[sum - b[j]];
if (h == make_pair(0, 0))
a[sum - b[j]] = make_pair(i, j);
else if (i != h.first)
return !(cout << "YES" << endl
<< h.first << " " << h.second << endl
<< i << " " << j);
}
}
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > M;
int A[100010];
vector<int> B;
vector<pair<pair<int, int>, int> > W;
int pp(int l, int r, const pair<int, int>& q) {
int m = (l + r) / 2;
if (W[m].first == q) return W[m].second;
if (W[m].first > q) return pp(l, m - 1, q);
if (W[m].first < q) return pp(m + 1, r, q);
}
int main() {
int i, j, m, n, k;
scanf("%d%d", &n, &m);
M.assign(n, vector<int>());
W.clear();
memset(A, 0, sizeof(A));
for (i = 0; i < m; i++) {
scanf("%d%d", &j, &k);
W.push_back(make_pair(make_pair(k - 1, j - 1), i + 1));
M[k - 1].push_back(j - 1);
A[j - 1]++;
}
j = -1;
sort(W.begin(), W.end());
for (i = 0; i < n; i++)
if (A[i] == 0) {
if (j != -1) {
printf("-1\n");
return 0;
}
j = i;
}
B.clear();
for (i = 0; i < n; i++) {
B.push_back(j);
int j1 = -1;
for (k = 0; k < M[j].size(); k++) {
A[M[j][k]]--;
if (A[M[j][k]] == 0) {
if (j1 != -1) {
printf("-1\n");
return 0;
}
j1 = M[j][k];
}
}
j = j1;
}
int ans = 0;
for (i = 0; i < B.size() - 1; i++) {
ans = max(ans, pp(0, W.size() - 1, make_pair(B[i], B[i + 1])));
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct vec {
long double x, y;
bool operator==(const vec &a) const { return x == a.x && y == a.y; }
bool operator<(const vec &a) const {
if (a.x != x) return x < a.x;
return y < a.y;
}
vec operator+(const vec &a) const { return {x + a.x, y + a.y}; }
vec operator*(const long double &a) const { return {x * a, y * a}; }
vec operator-(const vec &a) const { return {x - a.x, y - a.y}; }
vec operator/(const long double &a) const { return {x / a, y / a}; }
long double len() const { return sqrt(x * x + y * y); }
long double dot(const vec &a) const { return x * a.x + y * a.y; }
long double crs(const vec &a) const { return x * a.y - y * a.x; }
vec proj(const vec &a) const {
return (a / a.len()) * (*this).dot(a) / a.len();
}
};
struct P {
int x, y;
};
long long x, y, z, mod = 998244353;
vector<int> v;
int i, n, m, k, a, d, b, c;
int e;
int o[1111111];
int l[1111114];
int j[1];
multiset<int> s;
P u[1];
char r[1];
queue<P> q;
map<int, int> p1;
bool as(P a, P b) { return a.x < b.x; }
int f(int n, int m) {
int k = 0;
for (; n < m;) {
if (n % 2)
k = max(l[n], k), n++;
else if (m % 2 == 0)
k = max(l[m], k), m--;
else
n /= 2, m /= 2;
}
return max(l[n], k);
}
int main() {
scanf("%d %d %d", &a, &b, &c);
for (int t = 1; t <= a; t++) scanf("%d", &o[t]);
sort(o + 1, o + a + 1);
for (i = 1; i < a + 1; i *= 2)
;
for (int h = i + a; h; h /= 2) l[h] = 1;
for (int t = a - b + 1; t > 0; t--)
if (o[t + b - 1] <= o[t] + c) {
int n = t + b - 1, m = a;
for (; n < m;) {
int h = (n + m) / 2 + 1;
if (o[h] <= o[t] + c)
n = h;
else
m = h - 1;
}
l[i + t - 1] = f(t + b - 1 + i, n + i);
for (int h = (i + t - 1) / 2; h; h /= 2)
l[h] = max(l[h * 2], l[h * 2 + 1]);
}
if (l[i])
puts("YES");
else
puts("NO");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<long long, long long>> coll(n);
for (int i = 0; i < n; i++) cin >> coll[i].first >> coll[i].second;
long long ans = 0;
for (int i = 0; i < n; i++) {
if (i == 0)
ans++;
else if (i == n - 1)
ans++;
else if (coll[i].first - coll[i].second > coll[i - 1].first)
ans++;
else if (coll[i].first + coll[i].second < coll[i + 1].first) {
ans++;
coll[i].first += coll[i].second;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int sign[200010], td = 0, tin[200010];
struct tarejan {
int low[200010], disc[200010], n, m;
vector<int> adj[200010];
unordered_set<int> StrongSet;
stack<int> st;
bool stackm[200010];
int tim, num;
void dfs(int node) {
low[node] = disc[node] = ++tim;
st.push(node);
stackm[node] = true;
for (auto ch : adj[node]) {
if (disc[ch] == -1) {
dfs(ch);
low[node] = min(low[ch], low[node]);
} else if (stackm[ch] == true) {
low[node] = min(disc[ch], low[node]);
}
}
if (low[node] == disc[node]) {
while (st.top() != node) {
StrongSet.insert(st.top());
stackm[st.top()] = false;
st.pop();
}
StrongSet.insert(st.top());
if (StrongSet.size() > 1) {
td++;
for (auto v : StrongSet) {
sign[v] = 1;
tin[v + 1] = 1;
}
}
StrongSet.clear();
stackm[st.top()] = false;
st.pop();
num++;
}
}
void SCC() {
tim = 0;
num = 0;
for (int i = 0; i <= n; i++) {
disc[i] = -1;
low[i] = -1;
stackm[i] = false;
}
for (int i = 0; i < n; i++) {
if (disc[i] == -1) {
dfs(i);
}
}
}
} tarj;
vector<int> adg[200010], pdg[200010], dpadj[2][200010];
int vis[200010], sis[200010], ris[200010];
vector<int> path, all;
bool fk = false;
int rim = 1;
bool check_cycle_DAG(int node) {
if (sis[node] == false) {
sis[node] = 1;
ris[node] = 1;
for (auto v : pdg[node]) {
if (!sis[v] && check_cycle_DAG(v)) {
return true;
} else if (ris[v]) {
return true;
}
}
}
ris[node] = false;
return false;
}
void dfs(int node) {
if (all.size()) {
return;
}
for (auto v : adg[node]) {
if (all.size()) {
return;
}
if (!vis[v]) {
vis[v] = 1;
path.push_back(v);
dfs(v);
if (path.size()) {
path.pop_back();
}
} else {
while (path.size() && path.back() != v) {
all.push_back(path.back());
path.pop_back();
}
all.push_back(v);
reverse(all.begin(), all.end());
path.clear();
}
}
}
int nn;
struct point {
int mn, mx;
point() : mn(1000000007), mx(-1000000007) {}
point(int x) : mn(x), mx(x) {}
point(int mn, int mx) : mn(mn), mx(mx) {}
void add(point b) {
mn = min(mn, b.mn);
mx = max(mx, b.mx);
}
};
point twoway[2][200010];
void dp(int tp, int node) {
if (sis[node]) {
return;
}
sis[node] = true;
for (auto v : dpadj[tp][node]) {
if (!vis[v]) {
dp(tp, v);
twoway[tp][node].add(twoway[tp][v]);
} else {
twoway[tp][node].add(vis[v]);
}
}
}
int presum[200010];
void update(int l, int r) {
if (l <= r) {
presum[l]++;
presum[r + 1]--;
}
}
int main() {
cin >> tarj.n >> tarj.m;
for (int i = 1; i <= tarj.m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
tarj.adj[a].push_back(b);
}
td = 0;
tarj.SCC();
if (td == 0) {
cout << -1 << endl;
} else if (td > 1) {
cout << -1 << endl;
} else {
int wc = 0;
for (int i = 0; i < tarj.n; i++) {
if (sign[i]) {
wc = i + 1;
for (auto v : tarj.adj[i]) {
if (sign[v]) {
adg[i + 1].push_back(v + 1);
dpadj[0][i + 1].push_back(v + 1);
dpadj[1][v + 1].push_back(i + 1);
}
}
tarj.adj[i].clear();
}
}
if (wc != 0) {
vis[wc] = 1;
dfs(wc);
}
path.clear();
memset(vis, 0, sizeof vis);
for (int z = 0; z < all.size(); z++) {
auto v = all[z];
tin[v] = 0;
vis[v] = z + 1;
}
nn = all.size();
vector<int> pol;
pol.resize(all.size(), 0);
for (int i = 1; i <= tarj.n; i++) {
if (tin[i]) {
for (auto v : adg[i]) {
if (tin[v]) {
pdg[i].push_back(v);
}
}
}
}
for (int i = 1; i <= tarj.n; i++) {
if (tin[i] && !sis[i]) {
if (check_cycle_DAG(i)) {
fk = true;
break;
}
}
}
if (fk) {
cout << -1 << endl;
return 0;
}
memset(sis, 0, sizeof sis);
for (int i = 1; i <= tarj.n; i++) {
if (!sis[i]) {
dp(0, i);
}
}
memset(sis, 0, sizeof sis);
for (int i = 1; i <= tarj.n; i++) {
if (!sis[i]) {
dp(1, i);
}
}
for (int i = 1; i <= nn; ++i) {
int v = all[i - 1];
if (twoway[0][v].mx >= i) update(i + 1, twoway[0][v].mx - 1);
if (twoway[0][v].mn <= i) update(i + 1, nn);
if (twoway[1][v].mx >= i) update(1, i - 1);
}
for (int i = 1; i <= nn; i++) {
presum[i] = presum[i] + presum[i - 1];
}
int rss = -1;
for (int i = 1; i <= nn; i++) {
if (!presum[i]) {
rss = all[i - 1];
break;
}
}
cout << rss << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int L[20][20], H[20][20], N, A[20][20];
int res1 = 1 << 29, res2, flow, cost;
int P[20];
void dfs(int v, int u) {
if (P[N - 1] > res1) return;
if (v == N - 1 && (u > 1) && P[u - 1]) return;
if (v == N) {
bool valid = 1;
for (int i = (1); i < (N - 1) && (valid); ++i) valid = P[i] == 0;
if (!valid) return;
flow = P[N - 1];
if (flow < res1)
res1 = flow, res2 = cost;
else if (res1 == flow)
res2 = max(res2, cost);
return;
}
for (int i = (max(0, L[u][v])); i < (1 + min(H[u][v], P[u])); ++i) {
P[v] += i;
P[u] -= i;
cost += i * i + (i > 0) * A[u][v];
if (u == v - 1)
dfs(v + 1, 0);
else
dfs(v, u + 1);
cost -= i * i + (i > 0) * A[u][v];
P[v] -= i;
P[u] += i;
}
}
int main(int argc, char **argv) {
cin >> N;
for (int i = (0); i < (N); ++i)
for (int j = (i + 1); j < (N); ++j) {
int first, second, l, r, a;
cin >> first >> second >> l >> r >> a;
--first, --second;
L[first][second] = l, H[first][second] = r, A[first][second] = a;
}
P[0] = 1 << 29;
dfs(1, 0);
if (res1 == 1 << 29)
puts("-1 -1");
else
cout << res1 << " " << res2 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& x) {
int f = 1;
x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
const int N = 200000 + 5;
int n;
int s[N], d[N];
int main() {
read(n);
for (int i = 1; i <= n; i++) read(s[i]), read(d[i]);
for (int i = 1; i <= n; i++) s[i] += s[i - 1];
int d1 = -0x7FFFFFFF, d2 = 0x7FFFFFFF;
for (int i = 1; i <= n; i++) {
if (d[i] == 1) d1 = max(d1, 1900 - s[i - 1]);
if (d[i] == 2) d2 = min(d2, 1899 - s[i - 1]);
}
if (d2 == 0x7FFFFFFF) {
printf("Infinity\n");
return 0;
}
if (d1 <= d2) {
printf("%d\n", d2 + s[n]);
return 0;
}
if (d1 > d2) {
printf("Impossible\n");
return 0;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, t, s[100100], id[100100];
int read() {
int h, m, s;
scanf("%d:%d:%d", &h, &m, &s);
return h * 3600 + m * 60 + s;
}
int main() {
scanf("%d %d %d", &n, &m, &t);
for (int i = 0; i < n; i++) s[i] = read();
int ans = 0, fg = 1;
deque<int> dq;
for (int i = 0; i < n; i++) {
while (!dq.empty() && s[dq.front()] + t <= s[i]) dq.pop_front();
if (dq.size() == m)
id[i] = id[dq.back()], dq.pop_back(), dq.push_back(i);
else {
dq.push_back(i), id[i] = ++ans;
if (dq.size() == m) fg = 0;
}
}
if (fg)
puts("No solution");
else {
printf("%d\n", ans);
for (int i = 0; i < n; i++) printf("%d\n", id[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n;
vector<pair<int, int> > A;
scanf("%d", &n);
scanf("%d", &k);
for (i = 0; i < n; i++) {
scanf("%d", &j);
A.push_back(pair<int, int>(j, i));
}
sort(A.begin(), A.end());
int c = 0;
for (i = 0; i < A.size(); i++) {
if (k >= A.at(i).first) {
k = k - A.at(i).first;
c++;
}
}
printf("%d\n", c);
int ii = 0;
for (i = 0; i < c; i++) {
printf("%d ", A.at(ii).second + 1);
ii++;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int f(long long int mid) {
long long int kk = 2, way = 0;
while (1) {
if (kk * kk * kk > mid) break;
way += mid / (kk * kk * kk);
kk++;
}
return way;
}
int main() {
ios_base::sync_with_stdio(false);
long long int m;
cin >> m;
long long int lo = 1, hi = 1e18, mid;
while (lo < hi) {
mid = (lo + hi) / 2;
if (f(mid) >= m)
hi = mid;
else
lo = mid + 1;
}
if (f(lo) == m)
cout << lo;
else
cout << "-1";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, v;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> v;
if (v == 2)
cout << "2"
<< "\n";
else {
if (v % 2)
cout << "1"
<< "\n";
else
cout << "0"
<< "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
char a[1000];
int main() {
while (gets(a)) {
if (a[0] == '+') {
n++;
} else if (a[0] == '-') {
n--;
} else {
int j = 0;
while (a[j] != ':') {
j++;
}
j++;
int ylen = strlen(a);
x += (ylen - j) * n;
}
}
cout << x;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d = 0, i;
cin >> a >> b;
c = abs(a - b);
for (i = 1; i <= c / 2; i++) {
d += i * 2;
}
if (c % 2 == 1) {
d += i;
}
cout << d;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
vector<int> cnt(26), perSuit(26);
int qcnt = 0;
for (int i = 0; i < (((int)(s).size())); i++) {
if (s[i] == '?')
qcnt++;
else
cnt[s[i] - 'a']++;
}
for (int i = 0; i < (((int)(t).size())); i++) {
perSuit[t[i] - 'a']++;
}
vector<int> accUseQFor(26);
while (1) {
vector<int> useqfor(26);
for (int i = 0; i < (26); i++) {
cnt[i] -= perSuit[i];
if (cnt[i] < 0) {
if (cnt[i] < -qcnt) {
goto out;
}
qcnt += cnt[i];
useqfor[i] -= cnt[i];
cnt[i] = 0;
}
}
for (int i = 0; i < (26); i++) accUseQFor[i] += useqfor[i];
}
out:;
int useqforptr = 0;
for (int i = 0; i < (((int)(s).size())); i++) {
if (s[i] == '?') {
while (useqforptr < 26 && accUseQFor[useqforptr] <= 0) useqforptr++;
if (useqforptr == 26)
cout << "z";
else {
cout << (char)(useqforptr + 'a');
accUseQFor[useqforptr]--;
}
} else
cout << s[i];
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
void solve() {
cin >> n >> m;
vector<int> a(n);
vector<int> p(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
int x;
cin >> x;
p[--x] = 1;
}
while (true) {
bool ok = false;
for (int i = 0; i < n; i++) {
if (p[i] && a[i] > a[i + 1]) {
ok = true;
swap(a[i], a[i + 1]);
}
}
if (!ok) break;
}
for (int i = 0; i + 1 < n; i++) {
if (a[i] > a[i + 1]) {
cout << "NO\n";
return;
}
}
cout << "YES\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, sx, sy, x[N], y[N], nx, ny, ans, ax, ay, cnt;
void calc() {
cnt = 0;
for (int i = 1; i <= n; i++)
if ((sx <= nx && nx <= x[i] || x[i] <= nx && nx <= sx) &&
(sy <= ny && ny <= y[i] || y[i] <= ny && ny <= sy))
cnt++;
}
int main() {
cin >> n >> sx >> sy;
for (int i = 1; i <= n; i++) cin >> x[i] >> y[i];
nx = sx + 1, ny = sy;
calc();
if (cnt >= ans) ans = cnt, ax = nx, ay = ny;
nx = sx - 1, ny = sy;
calc();
if (cnt >= ans) ans = cnt, ax = nx, ay = ny;
nx = sx, ny = sy + 1;
calc();
if (cnt >= ans) ans = cnt, ax = nx, ay = ny;
nx = sx, ny = sy - 1;
calc();
if (cnt >= ans) ans = cnt, ax = nx, ay = ny;
cout << ans << endl << ax << " " << ay << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int dp[k + 1][n + 1];
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) dp[1][i] = 1;
for (int i = 2; i <= k; i++) {
for (int j = 1; j <= n; j++) {
for (int l = j; l <= n; l += j)
dp[i][l] = ((dp[i][l] % 1000000007) + (dp[i - 1][j]) % 1000000007) %
1000000007;
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
ans = ((ans % 1000000007) + (dp[k][i]) % 1000000007) % 1000000007;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1E6 + 5;
long long n, d, r1, r2, r3, a[MAXN], dp[MAXN][2];
template <class T>
void read(T& x, T f = 1, char ch = getchar()) {
x = 0;
while (ch < '0' || ch > '9') f = (ch == '-' ? -1 : 1), ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - 48, ch = getchar();
x *= f;
}
signed main() {
read(n), read(r1), read(r2), read(r3), read(d);
for (int i = 1; i <= n; i++) read(a[i]);
dp[1][0] = min(a[1] * r1 + r1, r2), dp[1][1] = a[1] * r1 + r3;
for (int i = 2; i <= n; i++) {
dp[i][0] = min(dp[i - 1][0] + 3 * d + min(a[i] * r1 + r1, r2) + r1,
dp[i - 1][1] + d + min(a[i] * r1 + r1, r2));
dp[i][1] = min(dp[i - 1][1] + d + a[i] * r1 + r3,
dp[i - 1][0] + 3 * d + min(a[i] * r1 + r1, r2) + 2 * r1);
if (i == n)
dp[i][1] = min(dp[i][1], dp[i - 1][0] + 2 * d + a[i] * r1 + r3 + r1);
}
cout << dp[n][1] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
long long n, i, j, h, k, t, d, m;
long double f[200005], a[200005], c[200005];
using namespace std;
vector<int> x[200005];
long double fg(long long n) {
if (f[n] != 0) return f[n];
long double res = 0, x = 1, m;
for (int i = n; i >= 2; i--) {
m = i;
res += 1 / m * x;
x *= (m - 2) / m;
}
f[n] = res;
return res;
}
void xl(long long i) {
long double j, k = fg(x[i].size()), d = a[i] + 1;
for (j = 0; j < x[i].size(); j++) d += k * c[x[i][j]];
for (j = 0; j < x[i].size(); j++) {
a[x[i][j]] = d - k * c[x[i][j]];
xl(x[i][j]);
}
}
void dfs(long long i) {
c[i] = 1;
for (int j = 0; j < x[i].size(); j++) {
dfs(x[i][j]);
c[i] += c[x[i][j]];
}
}
int main() {
cin >> n;
for (i = 2; i <= n; i++) {
cin >> h;
x[h].push_back(i);
}
a[1] = 1;
dfs(1);
xl(1);
cout << fixed;
for (i = 1; i <= n; i++) cout << setprecision(9) << a[i] << ' ';
}
| 4 |
#include <bits/stdc++.h>
const int M = 5010;
const long long inf = 0x3f3f3f3f3f3f3f3f;
int n, k, x;
template <typename T>
inline void read(T &x) {
x = 0;
char ch = getchar();
int f = 1;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
x *= f;
}
long long dp[2][M], ans = -inf;
int a[M], q[M], tail = 1, top = 1, now = 1;
int main() {
read(n);
read(k);
read(x);
if (n > k - 1 + k * x) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; i++) read(a[i]);
memset(dp[0], -inf, sizeof(dp[0]));
dp[0][0] = 0;
for (int i = 1; i <= x; i++) {
tail = top = 1;
q[1] = 0;
for (int pos = 1; pos <= n; pos++) {
while (tail <= top && q[tail] + k < pos) tail++;
dp[now][pos] = dp[now ^ 1][q[tail]] + a[pos];
while (tail <= top && dp[now ^ 1][q[top]] <= dp[now ^ 1][pos]) top--;
q[++top] = pos;
}
now ^= 1;
}
for (int i = std::max(1, n - k + 1); i <= n; i++)
ans = std::max(ans, dp[now ^ 1][i]);
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int accux[210000];
int accuy[210000];
int raccux[210000];
int raccuy[210000];
int bb(int inicio, int n, int x, int y) {
int l = inicio, r = n - 1;
int m, tam, dist;
int tx = 0, ty = 0;
if (inicio > 0) {
tx = accux[inicio - 1];
ty = accuy[inicio - 1];
}
while (l <= r) {
m = (l + r) / 2;
tam = m - inicio + 1;
if (m == n - 1) {
dist = abs(tx - x) + abs(ty - y);
} else {
dist = abs((raccux[m + 1] + tx) - x) + abs((raccuy[m + 1] + ty) - y);
}
if (tam == dist) {
if (tam - 1 < abs((raccux[m] + tx) - x) + abs((raccuy[m] + ty) - y)) {
return tam;
} else {
r = m - 1;
}
} else if (tam > dist)
r = m - 1;
else if (tam < dist)
l = m + 1;
}
return n + 1;
}
int main() {
int n, x, y;
cin >> n;
char c;
int vx[n];
int vy[n];
int tx = 0, ty = 0;
for (int i = 0; i < n; ++i) {
scanf(" %c", &c);
switch (c) {
case 'U':
vx[i] = 0;
vy[i] = 1;
break;
case 'D':
vx[i] = 0;
vy[i] = -1;
break;
case 'L':
vx[i] = -1;
vy[i] = 0;
break;
case 'R':
vx[i] = +1;
vy[i] = 0;
break;
}
}
scanf("%d %d", &x, &y);
for (int i = 0; i < n; ++i) {
if (i != 0) {
accux[i] = accux[i - 1] + vx[i];
accuy[i] = accuy[i - 1] + vy[i];
raccux[n - 1 - i] = raccux[n - i] + vx[n - 1 - i];
raccuy[n - 1 - i] = raccuy[n - i] + vy[n - 1 - i];
} else {
accux[i] = vx[i];
accuy[i] = vy[i];
raccux[n - 1 - i] = vx[n - 1 - i];
raccuy[n - 1 - i] = vy[n - 1 - i];
}
}
if (accux[n - 1] == x && accuy[n - 1] == y) {
printf("0\n");
return 0;
}
int ans = n + 1;
for (int i = 0; i < n; ++i) {
ans = min(bb(i, n, x, y), ans);
}
if (ans == n + 1)
printf("-1\n");
else
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char a[50][50];
bool exist[500];
long long D[500];
bool Cap(char c) {
if (c >= 'A' && c <= 'Z') return true;
return false;
}
int main() {
long long n, m, x;
cin >> n >> m >> x;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> a[j][i];
D[a[j][i]] = -1;
exist[a[j][i]] = true;
}
long long ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[j][i] == 'S') {
for (int k = 0; k < n; k++)
for (int l = 0; l < m; l++) {
int dx = abs(j - l), dy = abs(i - k);
if (D[a[l][k]] == -1 || dx * dx + dy * dy < D[a[l][k]])
D[a[l][k]] = dx * dx + dy * dy;
}
}
int q;
cin >> q;
string s;
cin >> s;
for (int i = 0; i < q; i++) {
if ((!Cap(s[i]) && !exist[s[i]]) ||
(Cap(s[i]) && (!exist[s[i] - 'A' + 'a'] || !exist['S']))) {
cout << -1 << endl;
return 0;
} else {
if (Cap(s[i]) && D[s[i] - 'A' + 'a'] > x * x) ans++;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 6666666;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-7;
const int mod = 1e9 + 7;
int a[105][105];
int main() {
int n, a, b, c;
scanf("%d%d%d%d", &n, &a, &b, &c);
int ans = 0;
n--;
if (n == 0) {
printf("0\n");
return 0;
}
if (a <= c && a <= b) {
printf("%d\n", n * a);
} else if (b <= c && b <= a) {
printf("%d\n", n * b);
} else {
ans += min(a, b);
printf("%d\n", (n - 1) * c + ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int R[1010];
int main() {
int n, aux, sum;
scanf("%d", &n);
for (int i = 0; i < 7; i++) scanf("%d", R + i);
int day = -1;
sum = 0;
while (sum < n) {
day++;
sum += R[day % 7];
}
printf("%d\n", (day % 7) + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 305;
string s[MX][MX];
vector<pair<pair<int, int>, pair<int, int>>> ans;
void Move(int i1, int j1, int i2, int j2) {
ans.emplace_back(make_pair(i1, j1), make_pair(i2, j2));
}
string needed[MX][MX];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> s[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> needed[i][j];
}
}
for (int j = 1; j <= m - 1; j++) {
for (int t = 0; t < (int)s[1][j].size(); t++) {
Move(1, j, 1, m);
}
s[1][m] = s[1][j] + s[1][m];
}
for (int i = 2; i <= n; i++) {
for (int t = 0; t < (int)s[i][m].size(); t++) {
Move(i, m, 1, m);
}
s[1][m] = s[i][m] + s[1][m];
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= m - 1; j++) {
if (i == 1 && j == 1) continue;
if (i == n && j == m) continue;
for (int t = (int)s[i][j].size() - 1; t >= 0; t--) {
char front = s[i][j][t];
if (front == '0') {
Move(i, j, 1, j);
if (j != 1) {
Move(1, j, 1, 1);
}
} else {
Move(i, j, i, m);
if (i != n) {
Move(i, m, n, m);
}
}
}
}
}
for (int t = (int)s[1][m].size() - 1; t >= 0; t--) {
char front = s[1][m][t];
if (front == '0') {
Move(1, m, 1, 1);
} else {
Move(1, m, n, m);
}
}
for (int i = 2; i <= n - 1; i++) {
for (int j = 2; j <= m - 1; j++) {
for (int t = (int)needed[i][j].size() - 1; t >= 0; t--) {
char c = needed[i][j][t];
if (c == '0') {
Move(1, 1, i, 1);
Move(i, 1, i, j);
} else {
Move(n, m, i, m);
Move(i, m, i, j);
}
}
}
}
for (int j = 2; j <= m - 1; j++) {
for (int t = (int)needed[1][j].size() - 1; t >= 0; t--) {
char c = needed[1][j][t];
if (c == '0') {
Move(1, 1, 1, j);
} else {
Move(n, m, 1, m);
Move(1, m, 1, j);
}
}
}
for (int j = 2; j <= m - 1; j++) {
for (int t = (int)needed[n][j].size() - 1; t >= 0; t--) {
char c = needed[n][j][t];
if (c == '0') {
Move(1, 1, n, 1);
Move(n, 1, n, j);
} else {
Move(n, m, n, j);
}
}
}
for (int i = 2; i <= n - 1; i++) {
for (int t = (int)needed[i][1].size() - 1; t >= 0; t--) {
char c = needed[i][1][t];
if (c == '0') {
Move(1, 1, i, 1);
} else {
Move(n, m, n, 1);
Move(n, 1, i, 1);
}
}
}
for (int i = 2; i <= n - 1; i++) {
for (int t = (int)needed[i][m].size() - 1; t >= 0; t--) {
char c = needed[i][m][t];
if (c == '0') {
Move(1, 1, 1, m);
Move(1, m, i, m);
} else {
Move(n, m, i, m);
}
}
}
for (int t = (int)needed[n][1].size() - 1; t >= 0; t--) {
char c = needed[n][1][t];
if (c == '0') {
Move(1, 1, n, 1);
} else {
Move(n, m, n, 1);
}
}
for (int t = (int)needed[1][1].size() - 1; t >= 0; t--) {
char c = needed[1][1][t];
if (c == '0') {
Move(1, 1, 1, m);
} else {
Move(n, m, 1, m);
}
}
for (int t = (int)needed[n][m].size() - 1; t >= 0; t--) {
char c = needed[n][m][t];
if (c == '0') {
Move(1, 1, 1, m);
} else {
Move(n, m, 1, m);
}
}
for (int t = (int)needed[1][m].size() - 1; t >= 0; t--) {
char c = needed[1][m][t];
if (c == '0') {
Move(1, 1, 1, m);
} else {
Move(n, m, 1, m);
}
}
for (unsigned int t = 0; t < needed[1][1].size(); t++) {
Move(1, m, 1, 1);
}
for (unsigned int t = 0; t < needed[n][m].size(); t++) {
Move(1, m, n, m);
}
printf("%d\n", (int)ans.size());
for (auto p : ans) {
printf("%d %d %d %d\n", p.first.first, p.first.second, p.second.first,
p.second.second);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], ans;
vector<int> g[200005], t[200005];
map<int, int> dp[200005], mx[200005], mx2[200005];
map<int, int>::iterator it;
void dfs(int node, int par) {
for (int i = 0; i < g[node].size(); i++) {
if (g[node][i] == par) continue;
dfs(g[node][i], node);
}
for (int i = 0; i < t[a[node]].size(); i++) dp[node][t[a[node]][i]] = 1;
for (int i = 0; i < g[node].size(); i++) {
if (g[node][i] == par) continue;
for (it = dp[g[node][i]].begin(); it != dp[g[node][i]].end(); it++) {
if (a[node] % it->first == 0) {
dp[node][it->first] = max(dp[node][it->first], it->second + 1);
mx2[node][it->first] = max(mx2[node][it->first], it->second);
if (mx2[node][it->first] > mx[node][it->first])
swap(mx2[node][it->first], mx[node][it->first]);
ans = max(ans, mx[node][it->first] + mx2[node][it->first] + 1);
} else {
ans = max(ans, it->second);
}
}
dp[g[node][i]].clear();
}
}
int main() {
for (int i = 2; i < 200005; i++)
if (t[i].empty())
for (int j = i; j < 200005; j += i) t[j].push_back(i);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
if (n == 1) {
printf("%d\n", a[1] > 1);
return 0;
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[2005], b[2005];
int dp[2005][10000];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i], &b[i]);
a[0] = 1;
for (int i = 0; i < 10000; i++) {
dp[n + 1][i] = 0;
if (!i) continue;
int ns[4], nn = i;
for (int k = 0; k < 4; k++) ns[k] = nn % 10, nn /= 10;
int npl = a[n];
int mns = 9, mxs = 1;
for (int k = 0; k < 4; k++)
if (ns[k]) mns = min(mns, ns[k]), mxs = max(mxs, ns[k]);
if (npl >= mxs)
dp[n + 1][i] = npl - mns;
else if (npl < mns)
dp[n + 1][i] = mxs - npl;
else
dp[n + 1][i] = min(npl - mns, mxs - npl) + mxs - mns;
}
for (int i = n; i >= 1; i--)
for (int j = 0; j < 10000; j++) {
int ns[4], nn = j;
for (int k = 0; k < 4; k++) ns[k] = nn % 10, nn /= 10;
dp[i][j] = 2005 * 1000;
bool flag = 0;
for (int k = 0; k < 3; k++)
if (ns[k] > ns[k + 1]) flag = 1;
if (flag) continue;
for (int ed = 1; ed <= 9; ed++) {
int nns[4];
for (int k = 0; k < 4; k++) {
nns[k] = ns[k];
if ((nns[k] - ed) * (nns[k] - a[i]) <= 0 ||
(nns[k] - a[i]) * (nns[k] - a[i - 1]) <= 0)
nns[k] = 0;
}
sort(nns, nns + 4);
if (nns[0] != 0) continue;
nns[0] = b[i];
sort(nns, nns + 4);
int nnum = 0;
for (int k = 3; k >= 0; k--) nnum = nnum * 10 + nns[k];
dp[i][j] = min(dp[i][j],
dp[i + 1][nnum] + abs(ed - a[i - 1]) + abs(ed - a[i]));
}
}
printf("%d\n", dp[1][0] + 2 * n);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma G++ optimize(2)
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
long long rd() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int inf = 0x3f;
const int maxn = 4e5 + 10;
int a[maxn];
long long f[1 << 20];
long long cost[21][21], sum[21];
int n, mx;
int main() {
while (cin >> n) {
memset(cost, 0, sizeof(cost));
memset(sum, 0, sizeof(sum));
memset(f, inf, sizeof(f));
f[0] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
for (int j = 1; j <= 20; ++j) {
cost[a[i]][j] += sum[j];
}
sum[a[i]]++;
}
mx = (1 << 20) - 1;
for (int i = 1; i <= mx; i++) {
for (int j = 0; j < 20; j++) {
if (!((i >> j) & 1)) continue;
long long t = 0;
for (int k = 0; k < 20; k++) {
if ((i >> k) & 1) continue;
t += cost[j + 1][k + 1];
}
f[i] = min(f[i], f[i ^ (1 << j)] + t);
}
}
cout << f[mx] << endl;
}
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double EPS = 0.001;
const long double EPS2 = 1e-6;
const long double PI = acos(-1);
const int MOD7 = 1000000007;
const int MOD9 = 1000000009;
const int a228 = 18;
const int inf = 1e9;
const long long kekmod = 1791791791;
const long long bestmod = 1148822869;
const long long INF = 4e18;
const int mod = 1000000007;
const int MAXN = 228228;
vector<int> a;
int n;
int add(int a, int b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
return a;
}
int mul(int a, int b) { return (1ll * a * b) % mod; }
int binpow(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = mul(res, a);
a = mul(a, a);
b >>= 1;
}
return res;
}
signed main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
srand(time(NULL));
cin >> n;
a.resize(n);
for (long long i = 0; i < a.size(); ++i) cin >> a[i];
;
int ans = 0;
sort((a).begin(), (a).end());
int xxa = *max_element((a).begin(), (a).end());
for (int num = 1; num <= xxa; ++num) {
vector<int> divs;
for (int j = 1; j * j <= num; ++j) {
if (num % j == 0) {
divs.push_back(j);
if (j * j != num) divs.push_back(num / j);
}
}
sort((divs).begin(), (divs).end());
int now = 1;
for (int i = 0; i < divs.size() - 1; ++i) {
int xx = upper_bound((a).begin(), (a).end(), divs[i + 1] - 1) -
lower_bound((a).begin(), (a).end(), divs[i]);
now = mul(now, binpow(i + 1, xx));
}
int lol = upper_bound((a).begin(), (a).end(), inf) -
lower_bound((a).begin(), (a).end(), num);
if (lol) {
now = mul(now,
add(binpow(divs.size(), lol), -binpow(divs.size() - 1, lol)));
}
ans = add(ans, now);
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, k, i;
cin >> n >> k;
map<long long, vector<long long>> m;
long long a[n];
vector<long long> vis(n, -1);
for (i = 0; i < n; i++) {
cin >> a[i];
m[a[i]].push_back(i);
}
for (auto it = m.begin(); it != m.end(); it++) {
vector<long long> v = it->second;
long long x = it->first;
long long y = k - x;
if (x == y) {
for (long long j = 0; j < v.size() / 2; j++) {
if (vis[v[j]] == -1) {
vis[v[j]] = 0;
}
}
for (long long j = v.size() / 2; j < v.size(); j++) {
if (vis[v[j]] == -1) {
vis[v[j]] = 1;
}
}
} else {
for (auto z : v) {
if (vis[z] == -1) {
vis[z] = 0;
}
}
if (m.find(y) != m.end()) {
for (auto z : m[y]) {
if (vis[z] == -1) {
vis[z] = 1;
}
}
}
}
}
for (auto x : vis) cout << x << " ";
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int const N = 2e5 + 41;
int const B = 441;
int const L = 17;
int n, f[N];
unordered_map<int, int> hm;
int t[N];
long long ans[N];
vector<int> e[N];
int tin[N], tout[N];
int cn;
int ev[N];
vector<int> qu[N];
int qf[N], qs[N];
int nl[N], nr[N];
int m;
int lca[N][L];
bool isa(int a, int b) { return (tin[a] <= tin[b] && tout[a] >= tout[b]); }
int getlca(int a, int b) {
if (isa(a, b)) return a;
if (isa(b, a)) return b;
for (int i = L - 1; i >= 0; --i) {
if (lca[a][i] == -1 || isa(lca[a][i], b)) continue;
a = lca[a][i];
}
return lca[a][0];
}
void dfs(int u, int p) {
for (int i = 0; i < L; ++i) lca[u][i] = -1;
lca[u][0] = p;
for (int i = 1; i < L; ++i) {
int l = lca[u][i - 1];
if (l == -1) break;
lca[u][i] = lca[l][i - 1];
}
tin[u] = cn;
++cn;
for (int i = 0; i < (int)(e[u].size()); ++i) {
int to = e[u][i];
if (to == p) continue;
dfs(to, u);
}
tout[u] = cn;
++cn;
}
bool cmp(int i, int j) { return nr[i] < nr[j]; }
int cnt[N][2];
int w[N];
long long cur;
void clear() {
for (int i = 0; i < N; ++i)
for (int j = 0; j < 2; ++j) cnt[i][j] = 0;
for (int i = 0; i < N; ++i) w[i] = 0;
cur = 0;
}
void pushline(int l, int r) {
for (int i = l; i < r + 1; ++i) {
int id = ev[i];
++w[id];
assert(w[id] >= 1 && w[id] <= 2);
if (w[id] == 1) {
int c = t[id];
cur += cnt[f[id]][1 - c];
++cnt[f[id]][c];
} else if (w[id] == 2) {
int c = t[id];
cur -= cnt[f[id]][1 - c];
--cnt[f[id]][c];
}
}
}
void popline(int l, int r) {
for (int i = l; i < r + 1; ++i) {
int id = ev[i];
--w[id];
assert(w[id] >= 0 && w[id] <= 1);
if (w[id] == 1) {
int c = t[id];
cur += cnt[f[id]][1 - c];
++cnt[f[id]][c];
} else if (w[id] == 0) {
int c = t[id];
cur -= cnt[f[id]][1 - c];
--cnt[f[id]][c];
}
}
}
void solve() {
vector<int> b;
for (int i = 0; i < n; ++i) b.push_back(f[i]);
sort(b.begin(), b.end());
for (int i = 0; i < (int)(b.size()); ++i) {
if (i == 0 || b[i] != b[i - 1]) {
int v = (int)(hm.size());
hm[b[i]] = v;
}
}
for (int i = 0; i < n; ++i) f[i] = hm[f[i]];
dfs(0, -1);
for (int i = 0; i < n; ++i) {
ev[tin[i]] = i;
ev[tout[i]] = i;
}
for (int i = 0; i < m; ++i) {
if (isa(qf[i], qs[i])) {
nl[i] = tin[qf[i]];
nr[i] = tin[qs[i]];
} else if (isa(qs[i], qf[i])) {
nl[i] = tin[qs[i]];
nr[i] = tin[qf[i]];
} else {
nl[i] = min(tout[qf[i]], tout[qs[i]]);
nr[i] = max(tin[qf[i]], tin[qs[i]]);
}
}
for (int i = 0; i < m; ++i) {
int id = nl[i] / B;
qu[id].push_back(i);
}
for (int i = 0; i < N; ++i) {
sort(qu[i].begin(), qu[i].end(), cmp);
}
for (int i = 0; i < N; ++i)
if ((int)(qu[i].size())) {
clear();
for (int j = 0; j < (int)(qu[i].size()); ++j) {
int id = qu[i][j];
int l = nl[id];
int r = nr[id];
if (!j) {
pushline(l, r);
} else {
int bid = qu[i][j - 1];
int bl = nl[bid];
int br = nr[bid];
assert(r >= br);
pushline(br + 1, r);
if (bl <= l) {
popline(bl, l - 1);
} else {
pushline(l, bl - 1);
}
}
ans[id] = cur;
int clca = getlca(qf[id], qs[id]);
if (clca != qf[id] && clca != qs[id]) {
int c = t[clca];
int v = f[clca];
ans[id] += cnt[v][1 - c];
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &t[i]);
for (int i = 0; i < n; ++i) scanf("%d", &f[i]);
for (int i = 0; i < n - 1; ++i) {
int u, v;
scanf("%d %d", &u, &v);
--u;
--v;
e[u].push_back(v);
e[v].push_back(u);
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
scanf("%d %d", &qf[i], &qs[i]);
--qf[i];
--qs[i];
}
solve();
for (int i = 0; i < m; ++i) printf("%lld\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_SIZE = 1e6 + 10, INF = 2 * 1e9, MAX_N = 7e3 + 5, MAX_K = 3e4 + 5;
const long long SuperINF = 1e18;
const double eps = 0.5, PI = 20 / 7;
void files() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int tests;
int main() {
std::ios::sync_with_stdio(0);
cin >> tests;
for (int tt = 0; tt < tests; tt++) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
set<int> open, close;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(')
open.insert(i);
else
close.insert(i);
}
vector<pair<int, int> > indexes;
bool need_open = false;
int cnt = 2 * (k - 1);
int ost = (n - 2 * (k - 1)) / 2;
int now_ost = 0;
bool flag = false;
for (int i = 0; i < s.size(); i++) {
if (cnt > 0)
need_open ^= true;
else {
flag = true;
if (ost > 0) {
need_open = true;
} else
break;
}
if (need_open) {
if (s[i] != '(') {
if (open.size() == 0) return 1;
int f = *open.begin();
close.insert(f);
close.erase(i);
if (open.find(f) == open.end()) return 1;
open.erase(f);
indexes.push_back(make_pair(i + 1, f + 1));
swap(s[i], s[f]);
} else {
if (open.find(i) == open.end()) return 1;
open.erase(i);
}
} else {
if (s[i] != ')') {
if (close.size() == 0) return 1;
int f = *close.begin();
open.insert(f);
open.erase(i);
if (close.find(f) == close.end()) return 1;
close.erase(f);
indexes.push_back(make_pair(i + 1, f + 1));
swap(s[i], s[f]);
} else {
if (close.find(i) == close.end()) return 1;
close.erase(i);
}
}
cnt--;
if (flag) ost--;
}
cout << indexes.size() << "\n";
for (auto x : indexes) cout << x.first << " " << x.second << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void display(vector<int> v1) {
for (int i = 0; i < v1.size(); i++) {
cout << v1[i] << " ";
}
cout << endl;
}
int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[8] = {1, 0, -1, 0, 1, -1, 1, -1};
using namespace std;
const int MAXN = (int)2e6 + 1000;
long long int fact[MAXN];
int prime[MAXN];
long long int twopower[MAXN];
long long int binexpo(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b & 1) {
ans *= a;
ans %= (long long int)1000000007;
}
a *= a;
a %= (long long int)1000000007;
b /= 2;
}
return ans;
}
long long int nCr(long long int n, long long int r) {
long long int numerator = fact[n];
long long int denominator =
(fact[r] * fact[n - r]) % (long long int)1000000007;
denominator = binexpo(denominator, (long long int)1000000007 - 2);
return (numerator * denominator) % (long long int)1000000007;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
fact[0] = twopower[0] = 1;
for (int i = 1; i < MAXN; i += 1) {
fact[i] = (fact[i - 1] * i) % (long long int)1000000007;
twopower[i] = (twopower[i - 1] * 2LL) % (long long int)1000000007;
}
for (int i = 2; i < MAXN; i += 1) {
if (prime[i] == 0) {
for (int j = i; j < MAXN; j += i) {
prime[j] = i;
}
}
}
while (t--) {
long long int x, y;
cin >> x >> y;
long long int ans = 1;
while (true) {
if (x == 1) {
break;
}
long long int counter = 0;
long long int pri = prime[x];
while (x % pri == 0) {
x /= pri;
counter += 1;
}
long long int waystofuck = nCr(counter + y - 1, y - 1);
ans *= waystofuck;
ans %= (long long int)1000000007;
}
ans %= (long long int)1000000007;
ans *= twopower[y - 1];
ans %= (long long int)1000000007;
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long modexp(long long x, long long n) {
if (n == 0) return 1;
if (n % 2 == 0) {
long long y = modexp(x, n / 2) % mod;
return (y * y) % mod;
}
return (x * modexp(x, n - 1) % mod) % mod;
}
int main() {
int n, a, b, h = 0, ans = 0, x;
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
cin >> x;
if (x == 2) {
if (b == 0)
ans += 2;
else
b--;
}
if (x == 1) {
if (a == 0) {
if (b) {
b--;
h++;
} else if (h) {
h--;
} else {
ans++;
}
} else
a--;
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline int size(const T& c) {
return (int)c.size();
}
inline long long two(int x) { return (1LL << (x)); }
int readInt() {
int N = -1;
scanf("%d", &N);
return N;
}
double readDouble() {
double D;
scanf("%lf", &D);
return D;
}
string readString() {
char buffer[1 << 20];
scanf("%s", buffer);
return buffer;
}
template <class A, class B>
ostream& operator<<(ostream& o, const pair<A, B>& p);
template <class T>
ostream& operator<<(ostream& o, const vector<T>& v);
template <class A, class B>
ostream& operator<<(ostream& o, const map<A, B>& m);
template <class T>
ostream& operator<<(ostream& o, const set<T>& s);
template <class T>
ostream& operator<<(ostream& o, const queue<T>& q);
template <class T>
ostream& operator<<(ostream& o, const stack<T>& s);
template <class A, class B>
ostream& operator<<(ostream& o, const pair<A, B>& p) {
o << "(" << p.first << "," << p.second << ")";
return o;
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& v) {
o << "{";
bool first = true;
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it) {
if (!first) o << ",";
first = false;
o << *it;
}
return o << "}";
}
template <class A, class B>
ostream& operator<<(ostream& o, const map<A, B>& m) {
o << "{";
bool first = true;
for (__typeof((m).begin()) it = (m).begin(); it != (m).end(); ++it) {
if (!first) o << ",";
first = false;
o << *it;
}
return o << "}";
}
template <class T>
ostream& operator<<(ostream& o, const set<T>& s) {
o << "{";
bool first = true;
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); ++it) {
if (!first) o << ",";
first = false;
o << *it;
}
return o << "}";
}
template <class T>
ostream& operator<<(ostream& o, const queue<T>& q) {
o << "{";
bool first = true;
queue<T> p = q;
while (!p.empty()) {
if (!first) o << ",";
first = false;
o << p.front();
p.pop();
}
return o << "}";
}
template <class T>
ostream& operator<<(ostream& o, const stack<T>& s) {
o << "{";
bool first = true;
stack<T> r = s;
while (!r.empty()) {
if (!first) o << ",";
first = false;
o << r.top();
r.pop();
}
return o << "}";
}
const bool debug = true;
const double epsilon = 1e-8;
const int infinite = 1000000000;
const long long infiniteLL = 1000000000000000000LL;
const long long modulo = 1000000007;
struct Graph {
int N, K;
vector<vector<int> > adj;
vector<vector<long long> > ways;
void initialize(int _N, int _K) {
N = _N, K = _K;
adj.resize(N);
ways.resize(N, vector<long long>(2 * K + 2, 0));
}
void addEdge(int u, int v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
void dfs(int u, int p) {
vector<long long> nways(2 * K + 2, 0);
ways[u][0] = 1;
ways[u][K + 1] = 1;
for (int i = 0; i < size(adj[u]); ++i) {
int v = adj[u][i];
if (p == v) {
continue;
}
dfs(v, u);
for (int f = 0; f <= 2 * K; ++f) {
for (int g = 0; g <= 2 * K; ++g) {
long long totalWays = (ways[u][f] * ways[v][g]);
if (f <= K && g <= K) {
nways[min(f, g + 1)] += totalWays;
nways[min(f, g + 1)] %= modulo;
} else if (f > K && g > K) {
nways[max(f, g + 1)] += totalWays;
nways[max(f, g + 1)] %= modulo;
} else if (f <= K && g > K) {
int dist = 1 + (g - K - 1) + f;
if (dist <= K) {
nways[f] += totalWays;
nways[f] %= modulo;
} else {
nways[g + 1] += totalWays;
nways[g + 1] %= modulo;
}
} else if (f > K && g <= K) {
int dist = 1 + g + (f - K - 1);
if (dist <= K) {
nways[g + 1] += totalWays;
nways[g + 1] %= modulo;
} else {
nways[f] += totalWays;
nways[f] %= modulo;
}
}
}
}
ways[u] = nways;
nways.clear();
nways.resize(2 * K + 2, 0);
}
}
long long solve() {
dfs(0, -1);
long long result = 0;
for (int i = 0; i <= K; ++i) {
result = (result + ways[0][i]) % modulo;
}
return result;
}
};
int main() {
int N = readInt(), K = readInt();
Graph graph;
graph.initialize(N, K);
for (int i = 0; i < N - 1; ++i) {
int u = readInt() - 1, v = readInt() - 1;
graph.addEdge(u, v);
}
long long result = graph.solve();
cout << result << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1000006;
int n, m;
pair<string, int> mess[MAX_N];
string s;
vector<string> level[MAX_N];
int maxl = 0;
int u;
int process(int x, int lv) {
maxl = max(maxl, lv);
level[lv].push_back(mess[x].first);
u = x;
for (int i = 1; i <= mess[x].second; i++) {
u = process(u + 1, lv + 1);
}
return u;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> s;
int count = 0;
int i = 0;
while (i < s.size()) {
string ts = "";
while (1) {
if (s[i] == ',') break;
ts += s[i];
i++;
}
i++;
string u = "";
while (i < s.size()) {
if (s[i] == ',' || s[i] == ' ') break;
u += s[i];
i++;
}
mess[count] = make_pair(ts, stod(u));
count++;
i++;
}
i = 0;
while (i < count) i = process(i, 1) + 1;
cout << maxl << endl;
for (int i = 1; i <= maxl; i++) {
for (int j = 0; j < level[i].size(); j++) cout << level[i][j] << " ";
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 7;
const int base = (int)1e9 + 7;
const int oo = (int)1e9;
int n, scc = 0, top = 0, cou = 0;
bool avail[N];
int low[N], num[N], st[N];
vector<int> a[N];
long long res = 1;
void Enter() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int cur;
scanf("%d", &cur);
a[i].push_back(cur);
}
}
long long power(int a, int n) {
if (n == 0) return 1 % base;
if (n == 1) return a % base;
long long tmp = power(a, n / 2) % base;
tmp = (tmp * tmp) % base;
if (n % 2 == 1) tmp = (tmp * a) % base;
return tmp % base;
}
void Dfs(int u) {
num[u] = ++cou;
low[u] = oo;
st[++top] = u;
if (a[u].size())
for (int i = 0; i <= a[u].size() - 1; i++) {
int v = a[u][i];
if (avail[v])
if (num[v] > 0)
low[u] = min(low[u], num[v]);
else {
Dfs(v);
low[u] = min(low[u], low[v]);
}
}
if (low[u] >= num[u]) {
++scc;
int v, count = 0;
do {
v = st[top];
++count;
avail[v] = false;
--top;
} while (v != u && top > 0);
if (count > 1) res = (res * (power(2, count - 1) - 1)) % base;
}
}
void Process() {
memset(avail, true, sizeof(avail));
for (int i = 1; i <= n; i++)
if (avail[i]) Dfs(i);
res = (res * power(2, scc)) % base;
printf("%I64d\n", res);
}
int main() {
Enter();
Process();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, cnt;
int a[110][110];
cin >> n;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cin >> a[i][j];
}
}
set<int> res;
for (i = 0; i < n; i++) {
cnt = 0;
for (j = 0; j < n; j++) {
if (a[i][j] != 1 && a[j][i] != 2 && a[i][j] != 3 && i != j) cnt++;
}
if (cnt == n - 1) {
res.insert(i + 1);
}
}
cout << res.size() << '\n';
set<int>::iterator it;
for (it = res.begin(); it != res.end(); it++) cout << (*it) << ' ';
cout << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
const int INF = 1e9 + 7;
int dist[N][N];
void minimize(int& x, int y) {
if (x > y) {
x = y;
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= n; y++) {
dist[x][y] = (x == y ? 0 : INF);
}
}
vector<int> X(m), Y(m), W(m);
for (int i = 0; i < m; i++) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
X[i] = x, Y[i] = y, W[i] = w;
minimize(dist[x][y], w);
minimize(dist[y][x], w);
}
vector<int> a(k), b(k);
for (int i = 0; i < k; i++) {
scanf("%d%d", &a[i], &b[i]);
}
for (int z = 1; z <= n; z++) {
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= n; y++) {
minimize(dist[x][y], dist[x][z] + dist[z][y]);
}
}
}
int answer = 0;
for (int j = 0; j < k; j++) {
answer += dist[a[j]][b[j]];
}
for (int i = 0; i < m; i++) {
int current = 0;
for (int j = 0; j < k; j++) {
current += min({dist[a[j]][b[j]], dist[a[j]][X[i]] + dist[Y[i]][b[j]],
dist[a[j]][Y[i]] + dist[X[i]][b[j]]});
}
minimize(answer, current);
}
cout << answer << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, l, r, b, a, t, j;
cin >> t;
l = 0;
while (t--) {
cin >> a >> b;
if (a <= (b / 2))
cout << b - (b / 2) - 1 << '\n';
else
cout << (b - a) << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 505;
long long n, m;
char a[N][N];
long long ans[N][N];
long long dx[4] = {0, 0, -1, +1};
long long dy[4] = {+1, -1, 0, 0};
long long get(long long x, long long y) { return (x - 1) * m + y; }
vector<long long> g[N * N];
long long col[N * N];
bool vis[N * N];
void dfs(long long u, long long c) {
if (vis[u]) {
if (col[u] != c) {
cout << "NO"
<< "\n";
exit(0);
}
return;
}
vis[u] = 1;
col[u] = c;
for (auto &it : g[u]) dfs(it, c ^ 1);
}
bool check() {
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (a[i][j] == 'X') {
long long ct = 0;
vector<pair<long long, long long> > v;
for (long long dir = 0; dir < 4; dir++) {
long long nx = i + dx[dir];
long long ny = j + dy[dir];
if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
if (a[nx][ny] == 'X')
ct++;
else
v.push_back({nx, ny});
}
if (v.size() >= 2) {
long long idx = v.size() == 2 ? 1 : 2;
long long uu = get(v[0].first, v[0].second);
long long vv = get(v[idx].first, v[idx].second);
g[uu].push_back(vv);
g[vv].push_back(uu);
}
if (v.size() == 4) {
long long uu = get(v[1].first, v[1].second);
long long vv = get(v[3].first, v[3].second);
g[uu].push_back(vv);
g[vv].push_back(uu);
}
if (ct == 3 || ct == 1) {
cout << "NO"
<< "\n";
exit(0);
} else if (ct == 4)
ans[i][j] = 0;
else if (ct == 0)
ans[i][j] = 10;
else
ans[i][j] = 5;
}
}
}
for (long long i = 1; i <= n * m; i++) {
if (vis[i]) continue;
if (g[i].size()) dfs(i, 0);
}
}
void print() {
cout << "YES"
<< "\n";
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (!ans[i][j] && a[i][j] != 'X') ans[i][j] = 1;
cout << ans[i][j] << " ";
}
cout << "\n";
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) cin >> a[i][j];
}
check();
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (vis[get(i, j)]) {
ans[i][j] = col[get(i, j)] ? 4 : 1;
}
}
}
print();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, long long> mp;
long long anc(long long x, long long y) {
if (x == y) return x;
if (x > y)
return anc(x / 2, y);
else
return anc(x, y / 2);
}
void upd(long long b, long long x, long long c) {
while (b != x) {
mp[{b / 2, b}] += c;
b /= 2;
}
}
long long cost(long long a, long long b) {
long long x = anc(a, b);
long long ret = 0;
while (a != x) {
if (mp.count({a / 2, a})) ret += mp[{a / 2, a}];
a /= 2;
}
while (b != x) {
if (mp.count({b / 2, b})) ret += mp[{b / 2, b}];
b /= 2;
}
return ret;
}
void solve() {
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t == 1) {
long long a, b, c;
cin >> a >> b >> c;
long long x = anc(a, b);
upd(a, x, c);
upd(b, x, c);
} else {
long long a, b;
cin >> a >> b;
cout << cost(a, b) << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int m, n, a, b, x, y, total = 0, mod, mid;
cin >> n >> m >> a >> b;
if (n % m == 0)
cout << total << endl;
else {
mod = n % m;
mid = m - mod;
x = mid * a;
y = mod * b;
total = min(x, y);
cout << total << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MaxX = 1e5;
const int MaxN = 2e5 + 15;
const int MaxK = 300;
const int INF = 1e9 + 1e8;
int q;
int upper[MaxN], lower[MaxN];
long long ans[MaxN];
map<int, int> low[MaxN], up[MaxN];
map<int, int> notUp[MaxN], notLow[MaxN];
int notBoth[MaxN];
int minUp[MaxN], minDown[MaxN];
void upPosUp(int pos, int val) {
int k = pos / MaxK;
if (upper[k] > val && minUp[pos] > val) {
if (upper[k] == INF && lower[k] == INF && minUp[pos] == INF &&
minDown[pos] == INF) {
--notBoth[k];
++notLow[k][val];
} else if (upper[k] == INF && minUp[pos] == INF) {
int temp = min(lower[k], minDown[pos]);
ans[k] += val + temp;
--notUp[k][temp];
if (notUp[k][temp] == 0) notUp[k].erase(temp);
++low[k][temp];
++up[k][val];
} else if (lower[k] == INF && minDown[pos] == INF) {
int temp = min(upper[k], minUp[pos]);
--notLow[k][temp];
if (notLow[k][temp] == 0) notLow[k].erase(temp);
++notLow[k][val];
} else {
ans[k] += val - min(upper[k], minUp[pos]);
--up[k][min(upper[k], minUp[pos])];
++up[k][val];
}
minUp[pos] = val;
}
}
void fullUp(int k, int val) {
if (upper[k] > val) {
for (map<int, int>::iterator it = notUp[k].begin(); it != notUp[k].end();
++it) {
ans[k] += (val + it->first) * 1ll * it->second;
low[k][it->first] += (it->second);
up[k][val] += (it->second);
}
notUp[k].clear();
map<int, int>::iterator it = notLow[k].upper_bound(val);
int cnt = 0;
long long sum = 0;
for (; it != notLow[k].end(); ++it) cnt += it->second;
it = notLow[k].upper_bound(val);
notLow[k].erase(it, notLow[k].end());
notLow[k][val] += cnt + notBoth[k];
notBoth[k] = 0;
cnt = 0;
for (it = up[k].upper_bound(val); it != up[k].end(); ++it) {
cnt += it->second;
sum += it->second * 1ll * it->first;
}
it = up[k].upper_bound(val);
up[k].erase(it, up[k].end());
up[k][val] += cnt;
ans[k] += cnt * 1ll * val - sum;
upper[k] = val;
}
}
void upUp(int l, int r, int val) {
int L = l / MaxK;
int R = r / MaxK;
if (L == R) {
for (int i = l; i <= r; ++i) upPosUp(i, val);
} else {
for (int i = l; i < (L + 1) * MaxK; ++i) upPosUp(i, val);
++L;
while (L < R) {
fullUp(L, val);
++L;
}
for (int i = L * MaxK; i <= r; ++i) upPosUp(i, val);
}
}
void upPosDown(int pos, int val) {
int k = pos / MaxK;
if (lower[k] > val && minDown[pos] > val) {
if (lower[k] == INF && minDown[pos] == INF && upper[k] == INF &&
minUp[pos] == INF) {
--notBoth[k];
++notUp[k][val];
} else if (lower[k] == INF && minDown[pos] == INF) {
int temp = min(upper[k], minUp[pos]);
--notLow[k][temp];
if (notLow[k][temp] == 0) notLow[k].erase(temp);
++up[k][temp];
++low[k][val];
ans[k] += val + temp;
} else if (upper[k] == INF && minUp[pos] == INF) {
int temp = min(lower[k], minDown[pos]);
--notUp[k][temp];
if (notUp[k][temp] == 0) notUp[k].erase(temp);
++notUp[k][val];
} else {
int temp = min(lower[k], minDown[pos]);
ans[k] += val - temp;
--low[k][temp];
++low[k][val];
}
minDown[pos] = val;
}
}
void fullDown(int k, int val) {
if (lower[k] > val) {
for (map<int, int>::iterator it = notLow[k].begin(); it != notLow[k].end();
++it) {
ans[k] += (it->first + val) * 1ll * it->second;
up[k][it->first] += it->second;
low[k][val] += it->second;
}
notLow[k].clear();
map<int, int>::iterator it;
int cnt = 0;
for (it = notUp[k].upper_bound(val); it != notUp[k].end(); ++it)
cnt += it->second;
it = notUp[k].upper_bound(val);
notUp[k].erase(it, notUp[k].end());
notUp[k][val] += cnt + notBoth[k];
notBoth[k] = 0;
cnt = 0;
long long sum = 0;
for (it = low[k].upper_bound(val); it != low[k].end(); ++it) {
cnt += it->second;
sum += it->first * 1ll * it->second;
}
it = low[k].upper_bound(val);
low[k].erase(it, low[k].end());
low[k][val] += cnt;
ans[k] += cnt * 1ll * val - sum;
lower[k] = val;
}
}
void upDown(int l, int r, int val) {
int L = l / MaxK;
int R = r / MaxK;
if (L == R) {
for (int i = l; i <= r; ++i) upPosDown(i, val);
} else {
for (int i = l; i < (L + 1) * MaxK; ++i) upPosDown(i, val);
++L;
while (L < R) {
fullDown(L, val);
++L;
}
for (int i = L * MaxK; i <= r; ++i) upPosDown(i, val);
}
}
int getPos(int pos) {
int k = pos / MaxK;
if (minUp[pos] < INF || upper[k] < INF)
if (minDown[pos] < INF || lower[k] < INF)
return min(minUp[pos], upper[k]) + min(minDown[pos], lower[k]);
return 0;
}
long long get(int l, int r) {
int L = l / MaxK;
int R = r / MaxK;
long long res = 0;
if (L == R) {
for (int i = l; i <= r; ++i) res += getPos(i);
} else {
for (int i = l; i < (L + 1) * MaxK; ++i) res += getPos(i);
++L;
while (L < R) {
res += ans[L];
++L;
}
for (int i = L * MaxK; i <= r; ++i) res += getPos(i);
}
return res;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
srand(time(NULL));
for (int i = 0; i * MaxK <= MaxX; ++i) {
upper[i] = lower[i] = INF;
ans[i] = 0;
notBoth[i] = MaxK;
for (int j = i * MaxK; j < (i + 1) * MaxK; ++j) minUp[j] = minDown[j] = INF;
}
int q;
cin >> q;
while (q-- > 0) {
int t;
cin >> t;
if (t == 2) {
int l, r;
cin >> l >> r;
--l;
--r, --r;
cout << get(l, r) << '\n';
} else {
int l, r, x;
cin >> l >> r >> x;
--l;
r -= 2;
if (x > 0)
upUp(l, r, x);
else
upDown(l, r, -x);
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a[2000], b[2000];
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
long long ans = -1;
for (int i = 0; i < n; i++) {
long long aux1 = 0;
for (int j = i; j < n; j++) {
aux1 |= a[j];
}
long long aux2 = 0;
for (int j = i; j < n; j++) {
aux2 |= b[j];
}
ans = max(ans, aux1 + aux2);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
long long f[1000005], hashh[1000005];
long long p[5] = {31, 37, 41, 43, 47};
int a, b, n;
int main() {
cin >> s >> t;
n = t.size();
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0')
a++;
else
b++;
}
srand((unsigned)time(NULL));
int k = rand() % 5;
long long pr = p[k];
long long cur = pr;
for (int i = 0; i < n; i++) {
f[i] = cur;
hashh[i] = f[i] * (t[i] - 'a' + 1) % 1000000007;
if (i) hashh[i] = (hashh[i] + hashh[i - 1]) % 1000000007;
cur = cur * pr % 1000000007;
}
int ans = 0;
for (int A = 1; A <= n / a; A++) {
int zan = n - A * a;
if (zan <= 0 || zan % b != 0) continue;
long long B = zan / b;
long long valA = -1, valB = -1;
int nxt = 0;
bool fail = 0;
for (int j = 0; j < s.size(); j++) {
if (s[j] == '0') {
long long hs = hashh[nxt + A - 1];
if (nxt) hs -= hashh[nxt - 1];
hs = (hs % 1000000007 * f[n - 1 - nxt] % 1000000007 + 1000000007) %
1000000007;
nxt += A;
if (valA == -1)
valA = hs;
else if (valA != hs)
fail = 1;
} else {
long long hs = hashh[nxt + B - 1];
if (nxt) hs -= hashh[nxt - 1];
hs = (hs % 1000000007 * f[n - 1 - nxt] % 1000000007 + 1000000007) %
1000000007;
nxt += B;
if (valB == -1)
valB = hs;
else if (valB != hs)
fail = 1;
}
}
assert(nxt == n);
if (A == B && valA == valB) continue;
if (!fail) ans++;
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct ww {
int x, y, z;
inline ww operator-(const ww &A) { return (ww){x - A.x, y - A.y}; }
} v[310 * 310 * 2], O;
int i, j, k, n, m, t, qi, l;
int a[310][310], b[310][310], c[310 * 310 * 2], f[310 * 310 * 2],
g[310 * 310 * 2];
vector<ww> d[310 * 310 * 2], dui;
long long an;
inline bool cc1(const ww &a, const ww &b) { return a.z < b.z; }
int get(int x) { return f[x] == x ? x : f[x] = get(f[x]); }
inline int gets(ww A) {
swap(A.x, A.y);
A.y *= -1;
int l = max(abs(A.x), abs(A.y));
if (!l) return 1;
int w = (l - 1) * 2 + 1, an = w * w;
if (A.y == l && A.x > -l) return an + A.x - (-l);
an += l * 2;
if (A.x == l && A.y < l) return an + l - A.y;
an += l * 2;
if (A.y == -l && A.x < l) return an + l - A.x;
an += l * 2;
return an + A.y - (-l);
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
c[++t] = a[i][j];
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &b[i][j]);
c[++t] = b[i][j];
}
sort(c + 1, c + t + 1);
{
scanf("%d%d", &O.x, &O.y);
dui.push_back(O);
}
for (i = 1; i <= t; i++) f[i] = i;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
a[i][j] = lower_bound(c + 1, c + t + 1, a[i][j]) - c;
b[i][j] = lower_bound(c + 1, c + t + 1, b[i][j]) - c;
if (c[b[i][j]] >= 0 && c[a[i][j]] > 0 && (i != O.x || j != O.y))
d[a[i][j]].push_back((ww){i, j});
g[a[i][j]]++;
}
for (l = 0; l < dui.size(); l++) {
ww A = dui[l];
int co = a[A.x][A.y], col = b[A.x][A.y], w = get(co);
if (c[w] == 0 || w == col) continue;
an += g[w];
int nn = d[w].size();
for (j = 0; j < nn; j++) {
v[j] = d[w][j];
v[j].z = gets(v[j] - A);
}
sort(v, v + nn, cc1);
for (j = 0; j < nn; j++) dui.push_back(v[j]);
d[w].clear();
g[col] += g[w];
g[w] = 0;
if (get(w) != get(col)) f[get(w)] = col;
f[get(col)] = col;
f[col] = col;
}
printf("%I64d\n", an);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int a[N];
struct node {
int id, x;
} b[N];
bool cmp(struct node &u, struct node &v) { return u.x < v.x; }
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int maxx = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
maxx = max(maxx, a[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i].x);
b[i].id = i;
maxx = max(maxx, b[i].x);
}
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + m, cmp);
int cnta, cntb;
cnta = cntb = 1;
int pre = 0;
long long sum = 0;
for (int i = 0; i <= maxx; i++) {
sum += k;
int tmp = 0;
while (a[cnta] == i && cnta <= n) {
tmp++;
cnta++;
}
while (b[cntb].x == i && cntb <= m) {
tmp++;
cntb++;
}
if (sum < tmp) {
long long xx = tmp - sum;
if (xx > cntb - 1 - pre) {
printf("-1\n");
return 0;
}
pre += xx;
sum = 0;
} else {
sum -= tmp;
}
}
printf("%d\n", cntb - 1 - pre);
for (int i = pre + 1; i < cntb; i++) {
printf("%d%c", b[i].id, i == cntb - 1 ? '\n' : ' ');
}
}
| 6 |
#include <bits/stdc++.h>
const long long Infll = 0x7fffffffffffffff;
const int MN = 100005;
inline void chkmx(long long &x, long long y) { x = x > y ? x : y; }
inline void chkmn(long long &x, long long y) { x = x < y ? x : y; }
int N;
long long x[MN], y[MN], z[MN];
long long Ansx, Ansy, Ansz;
inline bool check(long long r) {
static long long Mx0, Mxx, Mxy, Mxz;
Mx0 = Mxx = Mxy = Mxz = Infll;
static long long Mn0, Mnx, Mny, Mnz;
Mn0 = Mnx = Mny = Mnz = -Infll;
for (int i = 1; i <= N; ++i) {
chkmn(Mx0, +r + x[i] + y[i] + z[i]);
chkmn(Mxx, +r - x[i] + y[i] + z[i]);
chkmn(Mxy, +r + x[i] - y[i] + z[i]);
chkmn(Mxz, +r + x[i] + y[i] - z[i]);
chkmx(Mn0, -r + x[i] + y[i] + z[i]);
chkmx(Mnx, -r - x[i] + y[i] + z[i]);
chkmx(Mny, -r + x[i] - y[i] + z[i]);
chkmx(Mnz, -r + x[i] + y[i] - z[i]);
}
for (long long o = 0; o < 2; ++o) {
long long l0 = Mn0 + ((Mn0 & 1) ^ o), r0 = Mx0 - ((Mx0 & 1) ^ o);
long long lx = Mnx + ((Mnx & 1) ^ o), rx = Mxx - ((Mxx & 1) ^ o);
long long ly = Mny + ((Mny & 1) ^ o), ry = Mxy - ((Mxy & 1) ^ o);
long long lz = Mnz + ((Mnz & 1) ^ o), rz = Mxz - ((Mxz & 1) ^ o);
if (l0 > r0 || lx > rx || ly > ry || lz > rz) continue;
long long a = lx, b = ly, c = lz;
if (a + b + c > r0) continue;
if (a + b + c < l0) a = rx < l0 - b - c ? rx : l0 - b - c;
if (a + b + c < l0) b = ry < l0 - a - c ? ry : l0 - a - c;
if (a + b + c < l0) c = rz < l0 - a - b ? rz : l0 - a - b;
if (a + b + c < l0) continue;
Ansx = (b + c) / 2, Ansy = (a + c) / 2, Ansz = (a + b) / 2;
return 1;
}
return 0;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) scanf("%lld%lld%lld", &x[i], &y[i], &z[i]);
long long l = 0, r = 3000000000000000000, mid;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
printf("%lld %lld %lld\n", Ansx, Ansy, Ansz);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
struct modint {
long long x;
modint(long long o = 0) { x = o; }
modint &operator=(long long o) { return x = o, *this; }
modint &operator+=(modint o) {
return x = x + o.x >= 1000000007 ? x + o.x - 1000000007 : x + o.x, *this;
}
modint &operator-=(modint o) {
return x = x - o.x < 0 ? x - o.x + 1000000007 : x - o.x, *this;
}
modint &operator*=(modint o) { return x = 1ll * x * o.x % 1000000007, *this; }
modint &operator^=(long long b) {
modint a = *this, c = 1;
for (; b; b >>= 1, a *= a)
if (b & 1) c *= a;
return x = c.x, *this;
}
modint &operator/=(modint o) { return *this *= o ^= 1000000007 - 2; }
modint &operator+=(long long o) {
return x = x + o >= 1000000007 ? x + o - 1000000007 : x + o, *this;
}
modint &operator-=(long long o) {
return x = x - o < 0 ? x - o + 1000000007 : x - o, *this;
}
modint &operator*=(long long o) {
return x = 1ll * x * o % 1000000007, *this;
}
modint &operator/=(long long o) {
return *this *= ((modint(o)) ^= 1000000007 - 2);
}
template <class I>
friend modint operator+(modint a, I b) {
return a += b;
}
template <class I>
friend modint operator-(modint a, I b) {
return a -= b;
}
template <class I>
friend modint operator*(modint a, I b) {
return a *= b;
}
template <class I>
friend modint operator/(modint a, I b) {
return a /= b;
}
friend modint operator^(modint a, long long b) { return a ^= b; }
friend bool operator==(modint a, long long b) { return a.x == b; }
friend bool operator!=(modint a, long long b) { return a.x != b; }
bool operator!() { return !x; }
modint operator-() { return x ? 1000000007 - x : 0; }
};
modint fac[1000005], inv[1000005];
void prework(long long n) {
fac[0] = 1;
for (register long long i = (1); i <= (n); ++i) fac[i] = fac[i - 1] * i;
inv[n] = modint(1) / fac[n];
for (register long long i = (n - 1); i >= (0); --i)
inv[i] = inv[i + 1] * (i + 1);
}
inline modint C(long long n, long long m) {
return m > n ? modint(0) : fac[n] * inv[m] * inv[n - m];
}
long long n, t, m, a[1000005];
modint inv2 = 1, res, val = 1;
signed main() {
prework(1000000);
n = read(), t = read();
for (register long long i = (1); i <= (n); ++i) a[i] = a[i - 1] + read();
m = n;
for (register long long i = (1); i <= (n); ++i) {
inv2 /= 2;
long long s = min(n, t - a[i]);
if (s < 0) continue;
val = val * 2 - C(i - 1, m);
while (m > s) val -= C(i, m), m--;
res += val * inv2;
}
cout << res.x;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N, T, L, R, X, H;
unordered_map<int, int> siz;
unordered_map<int, pair<int, int> > par;
pair<int, int> find(int now) {
if (par.count(now)) {
pair<int, int> a, b;
a = par[now];
b = find(a.first);
return {b.first, a.second ^ b.second};
}
return {now, 0};
}
int getsize(int now) {
if (!siz.count(now)) {
siz[now] = 1;
}
return siz[now];
}
void merge(int x, int y, int z) {
pair<int, int> a, b;
a = find(x);
b = find(y);
if (a.first == b.first) {
return;
}
if (getsize(a.first) > getsize(b.first)) {
par[b.first] = {a.first, z ^ a.second ^ b.second};
siz[a.first] += siz[b.first];
} else {
par[a.first] = {b.first, z ^ a.second ^ b.second};
siz[b.first] += siz[a.first];
}
return;
}
int ans(int x, int y) {
pair<int, int> a, b;
a = find(x);
b = find(y);
if (a.first != b.first) {
return -1;
}
return a.second ^ b.second;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N;
for (int i = 0; i < N; i++) {
cin >> T >> L >> R;
L ^= H;
R ^= H;
if (L > R) {
swap(L, R);
}
if (T == 1) {
cin >> X;
X ^= H;
merge(L - 1, R, X);
} else {
H = ans(L - 1, R);
cout << H << '\n';
if (H == -1) {
H = 1;
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
class trio {
public:
long long first, second, third;
};
class quad {
public:
long long first, second, third, fourth;
};
int32_t main() {
long long n, x, y;
cin >> n >> x >> y;
long long arr[n + 1];
for (long long i = 1; i < n + 1; ++i) {
cin >> arr[i];
}
bool f1, f2;
for (long long i = 1; i < n + 1; ++i) {
f1 = 1, f2 = 1;
for (long long j = i + 1; j < min(i + y + 1, n + 1); ++j) {
if (arr[j] < arr[i]) f2 = 0;
}
for (long long j = i - 1; j >= max((long long)1, i - x); --j) {
if (arr[j] < arr[i]) f1 = 0;
}
if (f1 && f2) {
cout << i;
return 0;
}
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
const int maxn = 110;
int r[maxn],b[maxn];
int main(){
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t,n,m;
cin>>t;
while(t--){
cin>>n;
for(int i=0;i<n;i++)cin>>r[i];
cin>>m;
for(int i=0;i<m;i++)cin>>b[i];
int ans = 0, sum = 0;
for(int i=0;i<n;i++){
sum+=r[i];ans=max(ans,sum);
}
sum=0;
int res=0;
for(int i=0;i<m;i++){
sum+=b[i];
res=max(res,sum);
}
cout<<ans+res<<'\n';
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long test;
cin >> test;
while (test--) {
long long n, ans = 0;
cin >> n;
while (n > 0) {
if (n % 2 == 0) break;
n--;
}
cout << n / 2 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, k, cal;
string solve() {
for (int i = 0; i < s.size(); i++) {
int m4x = min(s[i] + k, (int)'z');
int m1n = max(s[i] - k, (int)'a');
if (s[i] - m1n >= m4x - s[i]) {
k -= s[i] - m1n;
s[i] = m1n;
} else {
k -= m4x - s[i];
s[i] = m4x;
}
}
if (k == 0) return s;
return "-1";
}
int main() {
cin >> n >> k >> s;
cout << solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 222222, inf = 1111111111;
int n, k;
long long sum0[max_n];
double ans, a[2][max_n], sum1[max_n], dp[2][max_n];
vector<pair<long long, double> > v;
double get(pair<long long, double> a, pair<long long, double> b) {
return (b.second - a.second) / (a.first - b.first);
}
void add(long long k, double x) {
while (v.size()) {
pair<long long, double> p = v[v.size() - 1];
if (p.first == k) {
if (x > p.second) {
v.pop_back();
} else {
break;
}
}
pair<long long, double> p2 = v[v.size() - 2];
double x1 = get(p, p2);
double x2 = get(p, make_pair(k, x));
if (x1 >= x2) {
v.pop_back();
} else {
break;
}
}
v.push_back(make_pair(k, x));
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
a[0][i] = sum0[i] = x;
a[1][i] = sum1[i] = 1.0 / x;
if (i) {
sum0[i] += sum0[i - 1];
sum1[i] += sum1[i - 1];
}
ans += 1.0 * sum0[i] / x;
}
int q1 = 0, q2 = 1;
for (int i = 0; i < n; ++i) {
dp[q1][i] = 0;
}
for (int i = 1; i < k; ++i) {
v.clear();
for (int j = 0; j < i; ++j) {
add(sum0[j], dp[q1][j] - sum1[j] * sum0[j]);
}
int poz = 0;
for (int j = i; j < n; ++j) {
poz = min(poz, (int)v.size() - 1);
while (poz + 1 < v.size()) {
double x = get(v[poz], v[poz + 1]);
if (sum1[j] > x) {
++poz;
} else {
break;
}
}
dp[q2][j] = v[poz].first * sum1[j] + v[poz].second;
add(sum0[j], dp[q1][j] - sum1[j] * sum0[j]);
}
swap(q1, q2);
}
printf("%.10f\n", ans - dp[q1][n - 1]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long int len = s.length();
long long int count = 0;
for (long long int i = 0; i < len; i++) {
if (s[i] >= '0' && s[i] <= '9') {
if ((s[i] - '0') % 2 == 1) count++;
} else if (s[i] >= 'a' && s[i] <= 'z') {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u')
count++;
}
}
cout << count << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100005;
int test, n, a, b, da, db;
vector<int> Adj[MaxN];
int depth[MaxN], dis;
int DFS(int u, int p) {
int Len = 0;
for (auto v : Adj[u]) {
if (v != p) {
depth[v] = depth[u] + 1;
int tmp = DFS(v, u) + 1;
dis = max(dis, tmp + Len);
Len = max(Len, tmp);
}
}
return Len;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> test;
while (test--) {
cin >> n >> a >> b >> da >> db;
for (int i = 1; i <= n; i++) {
Adj[i].clear();
}
int u, v;
for (int i = 1; i < n; i++) {
cin >> u >> v;
Adj[u].push_back(v);
Adj[v].push_back(u);
}
dis = 0;
depth[a] = 0;
DFS(a, -1);
cout << (2 * da >= min(db, dis) || da >= depth[b] ? "Alice\n" : "Bob\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, i, j, k = 0, sum = 0, temp;
cin >> n;
long long diff;
string s;
vector<long long> v;
for (i = max(1, (int)n - 90); i < n; i++) {
diff = n - i;
s = to_string(i);
sum = 0;
for (j = 0; j < s.length(); j++) {
sum += (s[j] - 48);
}
if (sum == diff) {
++k;
v.push_back(i);
}
}
cout << k << endl;
for (auto itr : v) {
cout << itr << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
namespace chtholly {
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return f ? x : -x;
}
template <typename mitsuha>
inline bool read(mitsuha &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c) && ~c; c = getchar()) f ^= c == '-';
if (!~c) return 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return x = f ? x : -x, 1;
}
template <typename mitsuha>
inline int write(mitsuha x) {
if (!x) return 0 & putchar(48);
if (x < 0) x = -x, putchar('-');
int bit[20], i, p = 0;
for (; x; x /= 10) bit[++p] = x % 10;
for (i = p; i; --i) putchar(bit[i] + 48);
return 0;
}
inline char fuhao() {
char c = getchar();
for (; isspace(c); c = getchar())
;
return c;
}
} // namespace chtholly
using namespace chtholly;
using namespace std;
int f(long long x) { return x < 0 ? -1 : x > 0; }
int main() {
int x1, x2, y1, y2;
cin >> x1 >> x2 >> y1 >> y2;
int n = read(), llx = 0;
for (; n--;) {
int a = read(), b = read(), c = read();
llx += f(1ll * x1 * a + 1ll * x2 * b + c) *
f(1ll * y1 * a + 1ll * y2 * b + c) <
0;
}
cout << llx;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int tinf = (int)1e9 + 7;
const long long inf = (long long)1e18 + 7;
const int N = 2e5 + 5;
int main() {
{
ios ::sync_with_stdio(false);
cin.tie(0);
}
long long n, t, g;
vector<vector<long long> > ans;
string second;
cin >> second;
n = second.length();
long long x = 0;
t = -1, g = 0;
for (int i = 0; i < n; i++)
if (second[i] == '1') {
if (t == -1) {
cout << t;
return 0;
}
ans[t].push_back(i), t--, g++;
} else {
if (!g) {
t++;
vector<long long> a;
a.push_back(i);
ans.push_back(a);
} else
t++, ans[t].push_back(i), g--;
}
if (g) {
cout << -1;
return 0;
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].size() << " ";
for (int j = 0; j < ans[i].size(); j++) cout << ans[i][j] + 1 << " ";
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int c;
int a, b;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> a >> b >> c;
for (int i = 0; i <= 10000; i++) {
for (int j = 0; j <= 10000; j++) {
if (a * i + b * j == c) {
cout << "Yes";
return 0;
}
}
}
cout << "No";
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
int neok[300];
vector<int> ind;
int mtx[300][300];
int main() {
int n;
string t, s;
cin >> n;
cin >> t >> s;
int len = 0;
for (int(i) = (0); (i) < int(n); ++(i)) {
if (t[i] != s[i]) {
len++;
mtx[t[i]][s[i]] = i + 1;
ind.push_back(i);
neok[s[i]] = i + 1;
}
}
int g = 0;
int tt1 = 0;
int tt2 = 0;
for (int(i) = (0); (i) < int(ind.size()); ++(i)) {
if (neok[t[ind[i]]] != 0) {
g = 1;
tt1 = ind[i] + 1;
tt2 = neok[t[ind[i]]];
break;
}
}
for (int(i) = (0); (i) < int(ind.size()); ++(i)) {
if (mtx[s[ind[i]]][t[ind[i]]] != 0) {
cout << len - 2 << endl;
cout << ind[i] + 1 << " " << mtx[s[ind[i]]][t[ind[i]]] << endl;
cin.sync();
cin.get();
return 0;
}
}
if (g == 1) {
cout << len - 1 << endl;
cout << tt1 << " " << tt2 << endl;
} else {
cout << len << endl;
cout << -1 << " " << -1 << endl;
}
cin.sync();
cin.get();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, d, maxx = 1;
cin >> n >> m >> d;
for (int i = 0; i < d; i++) {
maxx *= m;
if (maxx >= n) break;
}
if (maxx < n) {
cout << -1 << endl;
} else {
long long cnt = 1;
for (int i = 1; i <= d; i++) {
int k;
int num = 0;
for (int j = 0; j < n; j++) {
for (k = j; k < j + cnt && k < n; k++) {
cout << num % m + 1 << " ";
}
num++;
j = k - 1;
}
cnt *= m;
if (cnt > n) cnt = n;
cout << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, ans;
int a[N], head[N], size[N], dp[N];
bool v[N];
struct edge {
int to, next;
} e[2 * N];
void push(int k, int x, int y) {
e[k].to = y;
e[k].next = head[x];
head[x] = k;
}
void dfs1(int k, int x) {
int p = head[k], ma = 0;
dp[k] = size[k] = v[k] = 1;
while (p) {
if (!v[e[p].to]) {
dfs1(e[p].to, x);
size[k] += size[e[p].to];
if (size[e[p].to] == dp[e[p].to])
dp[k] += dp[e[p].to];
else
ma = max(ma, dp[e[p].to]);
}
p = e[p].next;
}
dp[k] += ma;
if (a[k] < x) dp[k] = 0;
}
void update(int &x, int &y, int z) {
if (z > x) {
y = x;
x = z;
} else
y = max(y, z);
}
void dfs2(int k, int x, int t) {
v[k] = 1;
int p = head[k], s = 1, ma1 = 0, ma2 = 0;
if (t == n - size[k])
s += t;
else
update(ma1, ma2, t);
while (p) {
if (!v[e[p].to]) {
if (dp[e[p].to] == size[e[p].to])
s += dp[e[p].to];
else
update(ma1, ma2, dp[e[p].to]);
}
p = e[p].next;
}
if (a[k] >= x) ans = max(ans, s + ma1);
p = head[k];
while (p) {
if (!v[e[p].to]) {
if (a[k] < x)
dfs2(e[p].to, x, 0);
else if (dp[e[p].to] == size[e[p].to])
dfs2(e[p].to, x, s + ma1 - dp[e[p].to]);
else if (dp[e[p].to] == ma1)
dfs2(e[p].to, x, s + ma2);
else
dfs2(e[p].to, x, s + ma1);
}
p = e[p].next;
}
}
int solve(int x) {
memset(v + 1, 0, n * sizeof(bool));
dfs1(1, x);
ans = 0;
memset(v + 1, 0, n * sizeof(bool));
dfs2(1, x, 0);
return ans;
}
int main() {
int k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
push(2 * i - 1, x, y);
push(2 * i, y, x);
}
int l = 1, r = 1000000;
while (l <= r) {
int mid = (l + r) >> 1;
if (solve(mid) >= k)
l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", r);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int numa[5000], numb[5000];
int main() {
int res = 0;
string t;
cin >> t;
int l = t.length();
numa[0] = (t[0] == 'a');
numb[0] = (t[0] == 'b');
for (int i = 1; i < l; ++i) {
numa[i] = numa[i - 1] + (t[i] == 'a');
numb[i] = numb[i - 1] + (t[i] == 'b');
}
for (int i = 0; i < l; ++i)
for (int j = i; j < l; ++j)
res = max(res,
numa[i] + numb[j] - (i != 0) * numb[i] + numa[l - 1] - numa[j]);
cout << res;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = int(2e5) + 10;
const int M = int(1e5) + 5;
const int INF = int(1e9);
int U[N], V[N], W[N], vis[N], D[N], comp[N], val[N], ans[N], parent;
vector<int> g[N], rg[N], G[N], nodes;
int n, m;
int adj(int u, int e) { return U[e] ^ V[e] ^ u; }
void get(int u) {
nodes.push_back(u);
nodes.push_back(u + M);
vis[u] = 1;
for (auto e : G[u]) {
int w = adj(u, e);
if (vis[w]) continue;
get(w);
}
}
int NOT(int u) {
if (u < M)
return u + M;
else
return u - M;
}
void addEdge(int u, int v) {
u = NOT(u);
g[u].push_back(v);
rg[v].push_back(u);
u = NOT(u);
v = NOT(v);
swap(u, v);
g[u].push_back(v);
rg[v].push_back(u);
}
void clear(int u) {
g[u].clear(), rg[u].clear(), vis[u] = 0, val[u] = 0, comp[u] = 0;
for (auto e : G[u]) D[e] = 0;
}
vector<int> order, component;
void dfs1(int u) {
vis[u] = 1;
for (auto w : g[u])
if (!vis[w]) dfs1(w);
order.push_back(u);
}
void dfs2(int u) {
vis[u] = 1;
comp[u] = parent;
for (auto w : rg[u])
if (!vis[w]) dfs2(w);
}
int go(int t) {
for (auto u : nodes) clear(u);
for (auto u : nodes)
for (auto e : G[u])
if (!D[e]) {
D[e] = 1;
if (W[e] == t)
addEdge(U[e], V[e]), addEdge(NOT(U[e]), NOT(V[e]));
else
addEdge(U[e], NOT(V[e])), addEdge(NOT(U[e]), V[e]);
}
order.clear();
for (auto i : nodes)
if (!vis[i]) dfs1(i);
for (auto u : nodes) vis[u] = 0;
reverse(order.begin(), order.end());
vector<int> Cmp;
for (auto i : order) {
if (!vis[i]) parent = i, Cmp.push_back(i), dfs2(i);
}
for (auto u : nodes) {
if (comp[u] == comp[NOT(u)]) return INF;
}
reverse(Cmp.begin(), Cmp.end());
int a = 0, b = 0;
for (auto u : Cmp) {
if (!val[u]) {
val[u] = 1;
val[comp[NOT(u)]] = -1;
}
}
for (auto u : nodes)
if (u < M) (val[comp[u]] == 1) ? a++ : b++;
int V = (a > b ? 0 : 1);
for (auto u : nodes)
if (u < M && val[comp[u]] == 1)
ans[u] = V;
else if (u < M)
ans[u] = 1 - V;
return min(a, b);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
char x;
scanf("%d %d %c", U + i, V + i, &x);
G[U[i]].push_back(i);
G[V[i]].push_back(i);
W[i] = (x == 'R' ? 1 : 0);
}
long long int Ans1 = 0, Ans2 = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) {
nodes.clear();
get(i);
Ans1 += go(0);
Ans2 += go(1);
}
long long int Ans = min(Ans1, Ans2);
if (Ans >= INF)
puts("-1");
else {
printf("%lld\n", Ans);
int t = (Ans == Ans1 ? 0 : 1);
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++)
if (!vis[i]) {
nodes.clear();
get(i);
go(t);
}
for (int i = 1; i <= n; i++)
if (ans[i]) printf("%d ", i);
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int w, h, n, startx, starty, finalx, finaly, walls[300][300] = {0}, tempans,
ans[10010] = {0};
void dfs(int x, int y) {
if (x < 0 || y < 0 || x > h + h || y > w + w) return;
if (walls[x][y] == 1 || walls[x][y] == 3) return;
if (walls[x][y] == 0) tempans++;
walls[x][y] = 3;
dfs(x + 1, y);
dfs(x, y + 1);
dfs(x - 1, y);
dfs(x, y - 1);
return;
}
int main() {
scanf("%d %d %d", &h, &w, &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d %d %d", &startx, &starty, &finalx, &finaly);
startx += startx;
starty += starty;
finalx += finalx;
finaly += finaly;
if (startx == finalx) {
for (int i = starty; i <= finaly; i++) walls[startx][i] = 1;
} else {
for (int i = startx; i <= finalx; i++) {
walls[i][starty] = 1;
}
}
}
for (int i = 0; i <= h + h; i++) {
if (i % 2 == 0) {
for (int j = 0; j <= w + w; j++)
if (walls[i][j] == 0) walls[i][j] = 2;
} else {
for (int j = 0; j <= w + w; j++)
if (walls[i][j] == 0 && j % 2 == 0) walls[i][j] = 2;
}
}
for (int i = 0; i <= h + h; i++)
for (int j = 0; j <= w + w; j++) {
tempans = 0;
dfs(i, j);
ans[tempans]++;
}
for (int i = 1; i <= w * h; i++)
for (int j = 1; j <= ans[i]; j++) printf("%d ", i);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
stack<long long> nums;
stack<char> ops;
inline void relax() {
char op = ops.top();
ops.pop();
long long a = nums.top();
nums.pop();
long long b = nums.top();
nums.pop();
if (op == '*')
nums.push(a * b);
else if (op == '+')
nums.push(a + b);
}
long long eval(string& s) {
for (char c : s) {
if (c >= '0' && c <= '9')
nums.push(c - '0');
else if (c == ')') {
while (ops.top() != '(') relax();
ops.pop();
} else {
while (!ops.empty() && ops.top() < c && ops.top() != '(') relax();
ops.push(c);
}
}
while (!ops.empty()) relax();
long long ret = nums.top();
nums.pop();
return ret;
}
int main() {
string s;
cin >> s;
vector<int> loc;
loc.push_back(-1);
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '*') loc.push_back(i);
}
loc.push_back(s.size());
long long ans = eval(s);
for (int i = 0; i < loc.size(); ++i)
for (int j = i + 1; j < loc.size(); ++j) {
string a, b, c;
a = s.substr(0, loc[i] + 1);
b = s.substr(loc[i] + 1, loc[j] - loc[i] - 1);
if (loc[j] == s.size())
c = "";
else
c = s.substr(loc[j]);
string res = (a + "(" + b + ")" + c);
ans = max(ans, eval(res));
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int inf = 1e9 + 1;
const double eps = 1e-15;
const double EPS = 1e-9;
const double PI = acos(-1.0);
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
string s;
int k;
vector<long long int> v(26, 0);
cin >> s >> k;
for (int i = 0; i < 26; i++) {
cin >> v[i];
}
long long int sum = 0, cur = 1;
for (auto ch : s) {
sum += (v[ch - 'a'] * cur);
cur++;
}
sort(v.rbegin(), v.rend());
;
while (k--) {
sum += (v[0] * cur);
cur++;
}
cout << sum << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int n, d;
while (scanf("%d %d", &n, &d) != EOF) {
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int m;
scanf("%d", &m);
sort(a, a + n);
int sum = 0;
int g = (n) < (m) ? (n) : (m);
for (int i = 0; i < g; i++) sum += a[i];
if (m > n) sum -= d * (m - n);
printf("%d\n", sum);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int a[n], b[n];
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
sort(a, a + n);
sort(b, b + n);
for (int i = 0; i < k; ++i) {
if (a[i] < b[n - 1 - i])
swap(a[i], b[n - 1 - i]);
else
break;
}
int sum = 0;
for (int i = 0; i < n; ++i) sum += a[i];
cout << sum << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3010;
const int mod = 998244353;
int dp[N][N];
char s[N];
char t[N];
int n, m;
int main() {
cin >> s + 1 >> t + 1;
n = strlen(s + 1);
m = strlen(t + 1);
for (int i = 1; i <= n + 1; i++) dp[i][i - 1] = 1;
for (int len = 1; len <= n; len++)
for (int l = 1; l + len - 1 <= n; l++) {
int i = len;
int r = l + len - 1;
if (l > m || s[i] == t[l]) dp[l][r] += dp[l + 1][r] % mod;
if (r > m || s[i] == t[r]) dp[l][r] += dp[l][r - 1] % mod;
}
long long ans = 0;
for (int i = m; i <= n; i++) ans += dp[1][i], ans %= mod;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
cout << n << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool check[2005][2005];
int main() {
int n;
cin >> n;
int x;
int y;
for (int i = 0; i < 2005; i++)
for (int j = 0; j < 2005; j++) check[i][j] = false;
vector<pair<int, int> > points;
for (int i = 0; i < n; i++) {
cin >> x >> y;
points.push_back(make_pair(x + 1000, y + 1000));
check[x + 1000][y + 1000] = true;
}
int ans = 0;
for (int i = 0; i < (int)points.size() - 1; i++) {
for (int j = i + 1; j < (int)points.size(); j++) {
int xb = points[i].first + points[j].first;
int yb = points[i].second + points[j].second;
if (xb % 2 == 0 && yb % 2 == 0 && check[xb / 2][yb / 2]) {
ans++;
}
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
int N;
double P[133][133];
int64 fact[10];
double dp[133][133];
int main() {
fact[0] = 1;
for (int i = 1; i < 10; i++) fact[i] = fact[i - 1] * 2;
cin >> N;
for (int i = 0; i < fact[N]; i++) {
for (int j = 0; j < fact[N]; j++) {
cin >> P[i][j];
P[i][j] /= 100.0;
}
}
for (int i = 0; i < fact[N]; i++) {
dp[0][i] = 1.0;
}
for (int i = 1; i <= N; i++) {
for (int j = 0; j < fact[N]; j++) {
for (int k = 0; k < fact[N]; k++) {
if (j / fact[i] == k / fact[i] && j / fact[i - 1] != k / fact[i - 1]) {
dp[i][j] += dp[i - 1][j] * dp[i - 1][k] * P[j][k];
}
}
}
}
double ret = 0.0;
for (int i = 2; i <= N; i++) {
for (int j = 0; j < fact[N]; j++) {
dp[i][j] *= fact[i - 1];
double beet = 0;
for (int k = 0; k < fact[N]; k++) {
if (j / fact[i] == k / fact[i] && j / fact[i - 1] != k / fact[i - 1]) {
beet = max(beet, dp[i - 1][j] + dp[i - 1][k]);
}
}
dp[i][j] += beet;
ret = max(ret, dp[i][j]);
}
}
cout << fixed << setprecision(20) << ret << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:255000000")
bool firstout = 1;
template <class T>
T &minn(T &a, T b) {
if (b < a) a = b;
return a;
}
template <class T>
T &maxx(T &a, T b) {
if (a < b) a = b;
return a;
}
int &madd(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
return a;
}
int &msub(int &a, int b) {
a -= b;
if (a < 0) a += 1000000007;
return a;
}
int &mmult(int &a, int b) { return a = (long long)a * b % 1000000007; }
int mdiv(long long a, long long b, long long m) {
a = (a % m + m) % m;
b = (b % m + m) % m;
if (a % b == 0) return a / b;
return (a + m * mdiv(-a, m, b)) / b;
}
int n, m, q, na, nr;
double X[2 * 1012], Y[2 * 1012];
pair<double, double> A[2 * 1012];
pair<pair<double, double>, int> R[2 * 1012];
int main() {
int i, j, k;
char c;
int a, d;
int ts;
for (ts = 1; scanf("%"
"d",
&(n)) > 0;
++ts) {
scanf(
"%"
"d",
&(q));
for (i = (0); i < (n); ++i)
scanf(
"%"
"lf",
&(X[i])),
scanf(
"%"
"lf",
&(Y[i]));
for (i = (n); i < (n + n); ++i) X[i] = X[i - n], Y[i] = Y[i - n];
for (; q--;) {
na = nr = 0;
double x, y, xx, yy, a, b, c;
scanf(
"%"
"lf",
&(x));
scanf(
"%"
"lf",
&(y));
scanf(
"%"
"lf",
&(xx));
scanf(
"%"
"lf",
&(yy));
a = yy - y;
b = x - xx;
c = +y * xx - x * yy;
for (i = (0); i < (n); ++i) {
double p1 = a * X[i] + b * Y[i] + c;
double p2 = a * X[i + 1] + b * Y[i + 1] + c;
if (p1 * p2 < 0 && fabs(p1) > 1e-9 && fabs(p2) > 1e-9) {
x = X[i + 1] - X[i];
y = Y[i + 1] - Y[i];
p1 = fabs(p1);
p2 = fabs(p2);
p1 /= p1 + p2;
A[na++] = make_pair(X[i] + p1 * x, Y[i] + p1 * y);
}
if (fabs(p1) < 1e-9 && fabs(p2) < 1e-9) {
pair<double, double> r1, r2;
r1 = make_pair(X[i], Y[i]);
r2 = make_pair(X[i + 1], Y[i + 1]);
if (r2 < r1) swap(r1, r2);
R[nr++] = make_pair(r1, 1);
R[nr++] = make_pair(r2, -1);
}
}
for (i = (1); i < (n + 1); ++i) {
if (fabs(a * X[i - 1] + b * Y[i - 1] + c) > 1e-9 &&
fabs(a * X[i] + b * Y[i] + c) <= 1e-9) {
double p1 = a * X[i - 1] + b * Y[i - 1] + c;
for (j = i + 1; fabs(a * X[j] + b * Y[j] + c) <= 1e-9; ++j)
;
double p2 = a * X[j] + b * Y[j] + c;
if (p1 * p2 < 0 && fabs(p1) > 1e-9 && fabs(p2) > 1e-9) {
A[na++] = make_pair(X[i], Y[i]);
}
}
}
sort(A, A + na);
for (i = (0); i < (na); i += (2)) {
R[nr++] = make_pair(A[i], 1);
R[nr++] = make_pair(A[i + 1], -1);
}
sort(R, R + nr);
double res = 0.;
int r = 0;
for (i = (0); i < (nr); ++i) {
if (r > 0)
res += hypot(R[i].first.first - R[i - 1].first.first,
R[i].first.second - R[i - 1].first.second);
r += R[i].second;
}
printf(
"%"
".7lf",
(res));
printf("\n"), firstout = 1;
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int y, b, r;
cin >> y >> b >> r;
int blue = y + 1;
int red = y + 2;
if (b >= blue && r >= red) {
cout << 3 * y + 3;
} else if (b >= blue && r < red) {
cout << 3 * r - 3;
} else if (b < blue && r >= red) {
cout << 3 * b;
} else if (b < blue && r < red) {
if (b < r) {
cout << 3 * b;
} else {
cout << 3 * r - 3;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
int a[n], b[n], i;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) cin >> b[i];
int k = 0, d = 0, c = 0;
i = 0;
while ((k == 0) && (i < n)) {
k = b[i] - a[i];
i++;
}
if (k < 0)
cout << "NO\n";
else {
d = k;
while ((k == d) && (i < n)) {
d = b[i] - a[i];
if (d == 0) k = 0;
i++;
}
if (k == d)
cout << "YES\n";
else
cout << "NO\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
string x;
vector<int> res;
cin >> n >> x;
int k = 0;
while (x[k] == '0') k++;
for (int i = k; i < n; i++) {
if (x[i] == '1') continue;
if (x[i] == '7' || x[i] == '5' || x[i] == '2' || x[i] == '3')
res.push_back(x[i] - '0');
else {
if (x[i] == '4') {
res.push_back(2), res.push_back(2), res.push_back(3);
} else if (x[i] == '6') {
res.push_back(3), res.push_back(5);
} else if (x[i] == '8') {
res.push_back(2), res.push_back(2), res.push_back(2);
res.push_back(7);
} else if (x[i] == '9') {
res.push_back(7);
res.push_back(2), res.push_back(3), res.push_back(3);
}
}
}
sort(res.begin(), res.end());
for (int i = res.size() - 1; i >= 0; i--) {
cout << res[i];
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int i, j;
int a[11111111], d[1111][1111];
int b[111];
int m, n, k, l, r, z, x, y, xx, yy, x1, y_1;
long long t, tp, ans;
int main() {
cin >> n >> k;
for (i = 1; i * i < n + k; i++) {
z = i * i;
for (j = z; j < n + k; j += z) a[j] = z;
}
for (i = n; i < n + k; i++) {
ans += i / a[i];
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a, b;
map<string, string> d, all;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string a, b;
cin >> a >> b;
if (!all.count(b)) {
all[a] = all[b] = 1;
if (!d.count(a)) {
d[b] = a;
} else {
d[b] = d[a];
d.erase(a);
}
}
}
cout << d.size() << "\n";
for (map<string, string>::iterator it = d.begin(); it != d.end(); it++) {
cout << it->second << " " << it->first << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6;
long long a[maxn + 50], sum[maxn + 50];
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + a[n - i + 1];
long long ans = 0;
for (int i = 1; i <= n; i *= 4) ans += sum[i];
printf("%lld", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 50;
const unsigned long long sed = 1e9 + 7;
int a[maxn], n;
int s[maxn], tp;
unsigned long long ha[maxn];
long long ans;
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
}
map<long long, int> mp;
void sol(int l, int r) {
if (l >= r) return;
sol(l, ((l + r) >> 1));
sol(((l + r) >> 1) + 1, r);
mp.clear();
tp = 0;
ha[0] = 0;
for (int i = ((l + r) >> 1) + 1; i <= r; ++i) {
if (tp && s[tp] == a[i])
tp--;
else
s[++tp] = a[i], ha[tp] = ha[tp - 1] * sed + a[i];
mp[ha[tp]]++;
}
tp = 0;
ha[0] = 0;
for (int i = ((l + r) >> 1); i >= l; --i) {
if (tp && s[tp] == a[i])
tp--;
else
s[++tp] = a[i], ha[tp] = ha[tp - 1] * sed + a[i];
ans += mp[ha[tp]];
}
return;
}
int main() {
int T;
cin >> T;
while (T--) {
init();
ans = 0;
sol(1, n);
printf("%I64d\n", ans);
}
}
| 9 |
#include <bits/stdc++.h>
int m, n;
int a[100050];
int main() {
int i, j, k, x, y, z;
scanf("%d", &n);
if (n % 4 == 2 || n % 4 == 3)
puts("-1");
else {
j = n;
i = 1;
while (j >= i) {
if (j == i)
a[i] = i;
else {
a[i] = i + 1;
a[i + 1] = j;
a[j] = n - i;
a[j - 1] = n + 1 - j;
}
i += 2;
j -= 2;
}
for (i = 1; i <= n; i++) {
printf("%d ", a[i]);
}
}
getchar();
getchar();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned q;
cin >> q;
while (q--) {
unsigned n;
cin >> n;
vector<unsigned> t(n);
for (int i = 0; i < n; i++) {
cin >> t[i];
}
vector<unsigned> c(n);
vector<unsigned> c2(n);
c[0] = 1;
c2[0] = 1;
unsigned k = 1;
for (int i = 1; i < n; i++) {
if (t[i] != t[i - 1]) {
k = 2;
if (c[i - 1] == 1) {
c[i] = 2;
} else if (c[i - 1] == 2) {
c[i] = 1;
}
if (c2[i - 1] == 1) {
c2[i] = 2;
} else if (c2[i - 1] == 2) {
c2[i] = 1;
}
} else {
c[i] = 1;
c2[i] = 2;
}
}
if (t[n - 1] == t[0]) {
cout << k << endl;
for (int i = 0; i < n; i++) {
cout << c[i] << " ";
}
cout << endl;
} else {
if (c[n - 1] != c[0]) {
cout << k << endl;
for (int i = 0; i < n; i++) {
cout << c[i] << " ";
}
cout << endl;
} else {
if (c2[n - 1] != c2[0]) {
cout << k << endl;
for (int i = 0; i < n; i++) {
cout << c2[i] << " ";
}
cout << endl;
} else {
k = 3;
c[n - 1] = 3;
cout << k << endl;
for (int i = 0; i < n; i++) {
cout << c[i] << " ";
}
cout << endl;
}
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<tuple<int, int, int, int>> vis;
struct El {
int dist, wechsel, fig, feld, y, x;
bool operator<(const El& e) const {
return dist > e.dist || (dist == e.dist && wechsel > e.wechsel);
}
bool isVis() { return vis.count(make_tuple(fig, feld, y, x)) > 0; }
};
const int n = 20;
int N;
int A[n][n];
priority_queue<El> Q;
int X[8] = {-2, -1, 1, 2, 2, 1, -1, -2};
int Y[8] = {1, 2, 2, 1, -1, -2, -2, -1};
int main() {
cin >> N;
for (int i = 2; i < N + 2; i++) {
for (int j = 2; j < N + 2; j++) {
cin >> A[i][j];
if (A[i][j] == 1) {
for (int x = 0; x < 3; x++) {
Q.push({0, 0, x, 1, i, j});
}
}
}
}
while (!Q.empty()) {
El cur = Q.top();
Q.pop();
if (cur.isVis()) {
continue;
}
vis.insert(make_tuple(cur.fig, cur.feld, cur.y, cur.x));
int y = cur.y, x = cur.x;
if (cur.feld == N * N + 1) {
cout << cur.dist << " " << cur.wechsel << endl;
return 0;
}
if (A[y][x] == cur.feld) {
Q.push({cur.dist, cur.wechsel, cur.fig, cur.feld + 1, y, x});
continue;
}
for (int x = 0; x < 3; x++) {
Q.push({cur.dist + 1, cur.wechsel + 1, x, cur.feld, cur.y, cur.x});
}
if (cur.fig == 0) {
for (int cury = y, curx = x; A[cury][curx] != 0; cury++, curx++) {
El nel = {cur.dist + 1, cur.wechsel, cur.fig, cur.feld, cury, curx};
Q.push(nel);
}
for (int cury = y, curx = x; A[cury][curx] != 0; cury--, curx++) {
El nel = {cur.dist + 1, cur.wechsel, cur.fig, cur.feld, cury, curx};
Q.push(nel);
}
for (int cury = y, curx = x; A[cury][curx] != 0; cury--, curx--) {
El nel = {cur.dist + 1, cur.wechsel, cur.fig, cur.feld, cury, curx};
Q.push(nel);
}
for (int cury = y, curx = x; A[cury][curx] != 0; cury++, curx--) {
El nel = {cur.dist + 1, cur.wechsel, cur.fig, cur.feld, cury, curx};
Q.push(nel);
}
} else if (cur.fig == 1) {
for (int cury = y, curx = x; A[cury][curx] != 0; cury++) {
El nel = {cur.dist + 1, cur.wechsel, cur.fig, cur.feld, cury, curx};
Q.push(nel);
}
for (int cury = y, curx = x; A[cury][curx] != 0; cury--) {
El nel = {cur.dist + 1, cur.wechsel, cur.fig, cur.feld, cury, curx};
Q.push(nel);
}
for (int cury = y, curx = x; A[cury][curx] != 0; curx--) {
El nel = {cur.dist + 1, cur.wechsel, cur.fig, cur.feld, cury, curx};
Q.push(nel);
}
for (int cury = y, curx = x; A[cury][curx] != 0; curx++) {
El nel = {cur.dist + 1, cur.wechsel, cur.fig, cur.feld, cury, curx};
Q.push(nel);
}
} else {
for (int i = 0; i < 8; i++) {
int curx = x + X[i];
int cury = y + Y[i];
El nel = {cur.dist + 1, cur.wechsel, cur.fig, cur.feld, cury, curx};
if (A[cury][curx] != 0 && !nel.isVis()) Q.push(nel);
}
}
}
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define ld long double
#define inf 2000000000
#define infLL 2000000000000000000
#define MAX5 100005
#define MAX6 1000006
#define MAX7 10000007
#define sf(a) scanf("%d", &a)
#define sfl(a) scanf("%lld", &a)
#define sfs(a) scanf("%s", a)
#define sline(a) scanf("%[^\n]%*c", a);
#define pf(a) printf("%d\n", a)
#define pfl(a) printf("%lld\n", a)
#define pfs(a) printf("%s\n", a)
#define Case(t) printf("Case %d: ", t)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define mod 1000000007
#define Mod 998244353
#define PI acos(-1.0)
#define eps 1e-9
#define mem(a, b) memset(a, b, sizeof(a))
#define FASTIO ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
inline int Set(ll N, ll pos){return N=N | (1LL<<pos);}
inline int Reset(ll N, ll pos){return N=N & ~(1LL<<pos);}
inline bool Check(ll N, ll pos){return (bool)(N & (1LL<<pos));}
const int N = MAX5;
int main()
{
//#ifndef ONLINE_JUDGE
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
//#endif
FASTIO;
int T;
cin>>T;
while(T--) {
int u, v;
cin>>u>>v;
if(u > v) {
cout<<"NO"<<endl;
}
else {
int cnt = 0;
bool flag = true;
for(int i = 0; i < 30; i++) {
if(Check(u, i)) cnt++;
if(Check(v, i)) cnt--;
if(cnt < 0) flag = false;
}
if(flag) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 + 10;
int X[] = {0, 1, 0, -1};
int Y[] = {1, 0, -1, 0};
char C[] = {'D', 'R', 'U', 'L'};
string s;
int n, x_, y_;
int D[maxn], U[maxn], L[maxn], R[maxn];
bool Light[maxn][maxn];
bool mark[maxn][maxn];
bool mark2[maxn][maxn];
char c[maxn][maxn];
void on(int x, int y) {
L[x] = min(L[x], y);
R[x] = max(R[x], y);
U[y] = min(U[y], x);
D[y] = max(D[y], x);
if (Light[x][y] != 1) s += '1';
Light[x][y] = 1;
}
void of(int x, int y) {
if (Light[x][y] != 0) s += '0';
Light[x][y] = 0;
}
bool is_good(int x2, int y2) {
if (x2 < 0 || x2 >= n || y2 < 0 || y2 >= n) return 0;
return 1;
}
void go(int x) {
x %= 4;
s += C[x];
}
bool can(int x1, int y1, int x2, int y2) {
if (!is_good(x2, y2)) return 0;
if (y1 < y2) {
if (R[x1] >= y2) return 1;
}
if (y1 > y2) {
if (L[x1] <= y2) return 1;
}
if (x1 < x2) {
if (D[y1] >= x2) return 1;
}
if (x1 > x2) {
if (U[y1] <= x2) return 1;
}
return 0;
}
void dfs_on(int i, int j) {
mark[i][j] = 1;
on(i, j);
for (int k = 0; k < 4; k++) {
int x = i + Y[k], y = j + X[k];
if (!can(i, j, x, y)) continue;
if (mark[x][y]) continue;
go(k);
dfs_on(x, y);
go(k + 2);
}
}
void dfs_off(int i, int j) {
Light[i][j] = 0;
mark2[i][j] = 1;
for (int k = 0; k < 4; k++) {
int x = i + Y[k], y = j + X[k];
if (!is_good(x, y)) continue;
if (mark2[x][y] || !Light[x][y]) continue;
go(k);
dfs_off(x, y);
s += '2';
go(k + 2);
}
of(i, j);
}
void init() {
fill(D, D + maxn - 1, -1);
fill(R, R + maxn - 1, -1);
fill(U, U + maxn - 1, n);
fill(L, L + maxn - 1, n);
}
int main() {
cin >> n >> x_ >> y_;
x_--;
y_--;
init();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> c[i][j];
if (c[i][j] == '1') {
Light[i][j] = 1;
on(i, j);
}
}
}
dfs_on(x_, y_);
dfs_off(x_, y_);
s += '2';
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (Light[i][j] == 1) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
cout << s << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
class TSolver {
public:
int n, k;
vector<int> v;
unordered_map<int, int> cnt;
explicit TSolver(std::istream& in) {
in >> n >> k;
v.resize(n);
for (int i = 0; i < n; ++i) {
in >> v[i];
}
}
long long ans = 0;
void Solve() {
int last = 0;
int i = 0;
cnt[0] = 1;
for (auto o : v) {
auto cn = cnt[last ^ o];
auto fl = o ^ ((1 << k) - 1);
auto cnf = cnt[last ^ fl];
if (-cn >= -cnf) {
last ^= o;
ans += i + 1 - cn;
do {
} while (false);
} else {
last ^= fl;
ans += i + 1 - cnf;
do {
} while (false);
}
++cnt[last];
++i;
}
}
void PrintAnswer(std::ostream& out) const { out << ans << '\n'; }
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
{
auto solver = std::make_shared<TSolver>(std::cin);
solver->Solve();
solver->PrintAnswer(std::cout);
}
do {
} while (false);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 5;
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= a / b * x;
}
int n, P;
long long Inv(int m) {
long long x, y;
exgcd(m, P, x, y);
return (x % P + P) % P;
}
long long pows[M], Pows[M];
void Init() {
Pows[0] = pows[0] = 1;
for (int i = 1; i <= n; i++) Pows[i] = Pows[i - 1] * 10 % P;
for (int i = 1; i <= n; i++) pows[i] = Inv(Pows[i]);
}
int tot, E[M << 1], to[M << 1], co[M << 1], head[M];
void link(int u, int v, int c) {
E[++tot] = v;
to[tot] = head[u];
co[tot] = c;
head[u] = tot;
}
int dep[M], sz[M], son[M], fa[M];
int Dfnc, dfn[M], post[M], Id[M];
long long T[M], H[M];
map<long long, int> MpH, MpT;
void dfs(int u) {
dfn[u] = ++Dfnc;
Id[Dfnc] = u;
sz[u] = 1, son[u] = 0;
for (int i = head[u]; i != 0; i = to[i]) {
int v = E[i];
if (v == fa[u]) continue;
fa[v] = u;
dep[v] = dep[u] + 1;
H[v] = (H[u] * 10 + co[i]) % P;
T[v] = (T[u] + co[i] * Pows[dep[u]]) % P;
dfs(v);
if (sz[v] > sz[son[u]]) son[u] = v;
sz[u] += sz[v];
}
post[u] = Dfnc;
}
long long T2H(long long t, long long r, long long s, long long d) {
return (((s - (t - r) * pows[d]) * pows[d]) % P + P) % P;
}
long long H2T(long long h, long long r, long long s, long long d) {
return (((s - h * Pows[d]) % P * Pows[d] + r) % P + P) % P;
}
long long Ans;
void check_node(int u, long long r, long long s, long long d) {
long long Hx = H[u] * pows[dep[u]] % P, t = H2T(Hx, r, s, d);
if (MpT.find(t) != MpT.end()) Ans += MpT[t];
long long Tx = T[u], h = T2H(Tx, r, s, d);
if (MpH.find(h) != MpH.end()) Ans += MpH[h];
}
void add_node(int u, long long r, long long s, long long d, int a) {
long long Hx = H[u] * pows[dep[u]] % P, t = H2T(Hx, r, s, d);
long long Tx = T[u], h = T2H(Tx, r, s, d);
MpT[Tx] += a;
MpH[Hx] += a;
}
void check_tree(int u, long long r, long long s, long long d) {
for (int i = dfn[u]; i <= post[u]; i++) check_node(Id[i], r, s, d);
}
void add_tree(int u, long long r, long long s, long long d, int a) {
for (int i = dfn[u]; i <= post[u]; i++) add_node(Id[i], r, s, d, a);
}
void dsu(int u) {
long long r = T[u], s = H[u], d = dep[u];
for (int i = head[u]; i != 0; i = to[i]) {
int v = E[i];
if (v == fa[u] || v == son[u]) continue;
dsu(v);
add_tree(v, r, s, d, -1);
}
if (son[u] != 0) dsu(son[u]);
for (int i = head[u]; i != 0; i = to[i]) {
int v = E[i];
if (v == fa[u] || v == son[u]) continue;
check_tree(v, r, s, d);
add_tree(v, r, s, d, 1);
}
check_node(u, r, s, d);
add_node(u, r, s, d, 1);
}
int main() {
scanf("%d%d", &n, &P);
Init();
for (int i = 1; i < n; i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
link(u, v, c), link(v, u, c);
}
dfs(0), dsu(0);
printf("%lld\n", Ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
int dp[30 + 1][30 + 1][50 + 1];
int Min(int a, int b) { return a < b ? a : b; }
void SubDP(int i, int j, int s) {
int halfi = i >> 1;
int halfj = j >> 1;
int totSize = 0;
int tmp;
for (int subi = 1, tots = j; subi <= halfi; ++subi, tots += j) {
for (int subs = 0; subs <= tots && subs <= s; ++subs) {
tmp = dp[subi][j][subs] + dp[i - subi][j][s - subs] + j * j;
dp[i][j][s] = Min(dp[i][j][s], tmp);
}
}
for (int subj = 1, tots = i; subj <= halfj; ++subj, tots += i) {
for (int subs = 0; subs <= tots && subs <= s; ++subs) {
tmp = dp[i][subj][subs] + dp[i][j - subj][s - subs] + i * i;
dp[i][j][s] = Min(dp[i][j][s], tmp);
}
}
}
void DP() {
for (int i = 1; i <= 30; ++i) {
for (int j = 1; j <= 30; ++j) {
dp[i][j][0] = 0;
for (int k = 1; k <= 50; ++k) {
dp[i][j][k] = 0xfffffff;
}
}
}
dp[1][1][1] = 0;
dp[1][1][0] = 0;
for (int i = 2; i <= 30; ++i) {
dp[i][1][0] = 0;
dp[1][i][0] = 0;
dp[i][1][i] = 0;
dp[1][i][i] = 0;
for (int s = 1; s < i; ++s) {
dp[i][1][s] = 1;
dp[1][i][s] = 1;
}
}
for (int i = 2; i <= 30; ++i) {
for (int j = 2; j <= i; ++j) {
int totSize = i * j;
if (totSize <= 50) {
dp[i][j][i * j] = 0;
dp[j][i][i * j] = 0;
}
dp[i][j][0] = 0;
dp[j][i][0] = 0;
for (int s = 1; s < totSize && s <= 50; ++s) {
SubDP(i, j, s);
dp[j][i][s] = dp[i][j][s];
}
}
}
}
void PrintDp() {
for (int i = 1; i <= 30; ++i) {
for (int j = 1; j <= 30; ++j) {
for (int k = 1; k <= 50 && k <= i * j; ++k) {
printf("%d %d %d %d\n", i, j, k, dp[i][j][k]);
}
}
}
}
int main() {
DP();
int ncase, n, m, k;
scanf("%d%*c", &ncase);
while (ncase--) {
scanf("%d%*c%d%*c%d%*c", &n, &m, &k);
printf("%d\n", dp[n][m][k]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (a == b) return cout << "infinity", 0;
int n = a - b, res = 0;
vector<int> rs;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
rs.push_back(i);
if (i != n / i) rs.push_back(n / i);
}
}
if (a > 1) rs.push_back(1);
rs.push_back(n);
for (int i = 0; i < rs.size(); i++) res += (rs[i] > b);
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
double avarg = 0.0, ans = 0, sum = 0;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
if (n == 1)
cout << fixed << setprecision(9) << sum << '\n';
else {
sort(arr, arr + n);
sum = sum - arr[n - 1];
ans = arr[n - 1] + (sum / double(n - 1));
cout << fixed << setprecision(9) << ans << '\n';
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 105;
const long long INF = 1e18;
long long n, m, k, x, y, cnt[N][N];
int main() {
scanf("%I64d %I64d %I64d %I64d %I64d", &n, &m, &k, &x, &y);
long long Min, Max, Tim;
if (n == 1) {
Min = k / m;
Max = Min;
if (k % m != 0) Max++;
Tim = Min;
if (k - k / m * m >= y) Tim++;
} else {
long long xhj = 2 * (n - 1) * m;
long long wz = k / xhj;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (i == 1 || i == n) {
cnt[i][j] = wz;
} else {
cnt[i][j] = 2 * wz;
}
}
}
long long c = 1, r = 1, fx = 0;
for (long long i = wz * xhj + 1; i <= k; i++) {
if (r == m + 1) {
r = 1;
if (fx == 0) {
if (c == n) {
c = n - 1;
fx = 1;
} else
c++;
} else {
if (c == 1) {
c = 2;
fx = 0;
} else
c--;
}
}
cnt[c][r]++;
r++;
}
Min = INF, Max = -INF;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
Min = min(Min, cnt[i][j]);
Max = max(Max, cnt[i][j]);
if (i == x && j == y) {
Tim = cnt[i][j];
}
}
}
}
printf("%I64d %I64d %I64d\n", Max, Min, Tim);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
namespace fastio {
char rbuf[1 << 23], *p1 = rbuf, *p2 = rbuf, wbuf[1 << 23], *p3 = wbuf;
inline char getc() {
return p1 == p2 &&
(p2 = (p1 = rbuf) + fread(rbuf, 1, 1 << 23, stdin), p1 == p2)
? -1
: *p1++;
}
inline void putc(char x) { (*p3++ = x); }
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
T neg = 0;
while (!isdigit(c)) neg |= !(c ^ '-'), c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (neg) x = (~x) + 1;
}
template <typename T>
void recursive_print(T x) {
return (!x) ? void() : (recursive_print(x / 10), putc(x % 10 ^ 48), void());
}
template <typename T>
void print(T x) {
(!x) && (putc('0'), 0);
(x < 0) && (putc('-'), x = ~x + 1);
recursive_print(x);
}
template <typename T>
void print(T x, char c) {
(!x) && (putc('0'), 0);
(x < 0) && (putc('-'), x = ~x + 1);
recursive_print(x);
putc(c);
}
void print_final() { fwrite(wbuf, 1, p3 - wbuf, stdout); }
} // namespace fastio
const int MAXN = 1e5;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int qpow(int x, int e = MOD - 2) {
int ret = 1;
for (; e; e >>= 1, x = 1ll * x * x % MOD)
if (e & 1) ret = 1ll * ret * x % MOD;
return ret;
}
int n, hd[MAXN + 5], to[MAXN * 2 + 5], nxt[MAXN * 2 + 5], col[MAXN * 2 + 5],
val[MAXN * 2 + 5], ec = 0;
void adde(int u, int v, int w, int c) {
to[++ec] = v;
col[ec] = c;
val[ec] = w;
nxt[ec] = hd[u];
hd[u] = ec;
}
int siz[MAXN + 5], mx[MAXN + 5], cent = 0, subsiz[MAXN + 5];
bool vis[MAXN + 5];
void findcent(int x, int f, int tot) {
siz[x] = 1;
mx[x] = 0;
for (int e = hd[x]; e; e = nxt[e]) {
int y = to[e];
if (y == f || vis[y]) continue;
findcent(y, x, tot);
siz[x] += siz[y];
chkmax(mx[x], siz[y]);
}
chkmax(mx[x], tot - siz[x]);
if (mx[x] < mx[cent]) cent = x;
}
int c0[MAXN + 5], c1[MAXN + 5], mul[MAXN + 5], ans = 1;
vector<int> pts;
void getpath(int x, int f) {
pts.push_back(x);
for (int e = hd[x]; e; e = nxt[e]) {
int y = to[e], z = val[e], c = col[e];
if (y == f || vis[y]) continue;
mul[y] = 1ll * mul[x] * z % MOD;
c0[y] = c0[x];
c1[y] = c1[x];
(c) ? (c1[y]++) : (c0[y]++);
getpath(y, x);
}
}
struct data {
int x, y;
data(int _x = 1, int _y = 0) : x(_x), y(_y) {}
};
data merge(data x, data y) { return data(1ll * x.x * y.x % MOD, x.y + y.y); }
struct fenwick_tree {
data t[MAXN * 4 + 5];
void add(int x, data v) {
x += (n << 1);
for (int i = x; i <= n << 2; i += (i & -i)) t[i] = merge(t[i], v);
}
data query(int x) {
x += (n << 1);
data ret;
for (int i = x; i; i &= (i - 1)) ret = merge(ret, t[i]);
return ret;
}
} t1, t2;
void clearmark(int x, int f) {
int iv = qpow(mul[x]);
t1.add(c1[x] - 2 * c0[x], data(iv, -1));
t2.add(2 * c1[x] - c0[x], data(iv, -1));
for (int e = hd[x]; e; e = nxt[e]) {
int y = to[e];
if (y == f || vis[y]) continue;
clearmark(y, x);
}
}
void divcent(int x) {
t1.add(0, data(1, 1));
t2.add(0, data(1, 1));
mul[x] = 1;
c1[x] = c0[x] = 0;
vis[x] = 1;
for (int e = hd[x]; e; e = nxt[e]) {
int y = to[e], z = val[e], c = col[e];
if (vis[y]) continue;
mul[y] = z;
c0[y] = (!c);
c1[y] = (!!c);
pts.clear();
getpath(y, x);
subsiz[y] = pts.size();
for (int p : pts) {
data d1 = t1.query(c0[p] * 2 - c1[p]),
d2 = t2.query(c0[p] - c1[p] * 2 - 1);
int res = 1ll * d1.x * qpow(d2.x) % MOD * qpow(mul[p], d1.y - d2.y) % MOD;
ans = 1ll * ans * res % MOD;
}
for (int p : pts) {
t1.add(c1[p] - 2 * c0[p], data(mul[p], 1));
t2.add(2 * c1[p] - c0[p], data(mul[p], 1));
}
}
clearmark(x, 0);
for (int e = hd[x]; e; e = nxt[e]) {
int y = to[e];
if (vis[y]) continue;
cent = 0;
findcent(y, x, subsiz[y]);
divcent(cent);
}
}
int main() {
scanf("%d", &n);
mx[0] = INF;
for (int i = 1, u, v, w, c; i < n; i++) {
scanf("%d%d%d%d", &u, &v, &w, &c);
adde(u, v, w, c);
adde(v, u, w, c);
}
findcent(1, 0, n);
divcent(cent);
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
std ::string s;
int main() {
int cnt = 0;
std ::cin >> s;
for (int i = 0; i < s.size(); i++)
if (s[i] >= 'A' && s[i] <= 'Z')
cnt += s[i] - 64;
else if (s[i] >= 'a' && s[i] <= 'z')
cnt -= s[i] - 96;
std ::cout << cnt << std ::endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAX = 1e6;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int a, b, f = 1;
cin >> a >> b;
while (b) {
if (b % a == 1 || b % a == 0) {
b /= a;
} else if (b % a == a - 1)
b = (b + 1) / a;
else {
f = 0;
break;
}
}
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long int dormitories, totalLetter;
cin >> dormitories >> totalLetter;
long long int noOfRooms[dormitories], roomNumbers[totalLetter],
sum[dormitories], roomNo;
long long int arr[200000];
for (int i = 0; i < dormitories; i++) {
cin >> noOfRooms[i];
if (i == 0)
sum[i] = noOfRooms[i];
else
sum[i] = sum[i - 1] + noOfRooms[i];
}
for (int i = 0; i < totalLetter; i++) cin >> roomNumbers[i];
int j = 0;
for (int i = 0; i < dormitories; i++) {
while (true) {
if (roomNumbers[j] > sum[i] || j >= totalLetter) break;
if (roomNumbers[j] <= sum[i]) {
if (i == 0) {
roomNo = roomNumbers[j];
cout << i + 1 << " " << roomNo << endl;
} else {
roomNo = roomNumbers[j] - sum[i - 1];
cout << i + 1 << " " << roomNo << endl;
}
j++;
}
}
}
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.