solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin >> t;
while (t--) {
int x, y, z, a, b, c, d, e;
cin >> x >> y >> z >> a >> b >> c >> d >> e;
if (x >= a && y >= b && z >= c) {
x -= a;
y -= b;
z -= c;
if (x + y + z >= d + e) {
if (x >= d && y >= e) {
cout << "yES\n";
}
else {
if (x < d) {
d -= x;
}
else {
d = 0;
}
if (y < e) {
e -= y;
}
else {
e = 0;
}
if (d + e <= z) {
cout << "YeS\n";
}
else {
cout << "No\n";
}
}
}
else {
cout << "no\n";
}
}
else {
cout << "nO\n";
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, b;
node(int a = 0, int b = 1e9) : a(a), b(b) {}
int get(int x) { return a * x + b; }
};
struct Eins {
vector<node> st;
int n;
Eins(int n) : n(n) { st.resize(n << 2 | 1); }
void modify(int id, int l, int r, node v) {
int mid = l + r >> 1;
if (st[id].get(mid) > v.get(mid)) {
swap(st[id], v);
}
if (l == r) return;
if (st[id].get(l) > v.get(l)) modify(id << 1, l, mid, v);
if (st[id].get(r) > v.get(r)) modify(id << 1 | 1, mid + 1, r, v);
}
int get(int id, int l, int r, int x) {
int ans = st[id].get(x);
if (l == r) return ans;
int mid = l + r >> 1;
if (x <= mid) return min(ans, get(id << 1, l, mid, x));
return min(ans, get(id << 1 | 1, mid + 1, r, x));
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<string> s(n + 1);
vector<Eins> Tree(m + 1, Eins(n + 1));
auto sqr = [&](int x) { return x * x; };
for (int i = 0; i <= n; i++) {
cin >> s[i];
int last = -1;
for (int j = 0; j <= m; j++) {
if (s[i][j] == '1') {
if (last == -1) {
for (int p = 0; p <= j; p++) {
Tree[p].modify(1, 0, n, node(-2 * i, sqr(i) + sqr(p - j)));
}
} else {
for (int p = last + 1; p <= j; p++) {
Tree[p].modify(
1, 0, n, node(-2 * i, sqr(i) + min(sqr(p - j), sqr(last - p))));
}
}
last = j;
} else if (j == m && last != -1) {
for (int p = last + 1; p <= m; p++) {
Tree[p].modify(1, 0, n, node(-2 * i, sqr(i) + sqr(p - last)));
}
}
}
}
long long ans = 0;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
ans += Tree[j].get(1, 0, n, i) + sqr(i);
}
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
int n, m, a[40][40], f[3], S, Now, Ans;
int F(int x, int s) { return s ? -x : x; }
int MAX(int a, int b) { return a > b ? a : b; }
int main() {
int i, j, k, l;
scanf("%d", &n);
m = (n + 1) / 2;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) scanf("%d", a[i] + j);
for (S = 0; S < (1 << m); S++) {
for (Now = i = 0; i < m; i++) {
for (k = 0; k < 2; k++)
for (f[k] = j = 0; j < m; j++) {
l = F(a[j][i], 0) + F(a[j + m][i], k) + F(a[j][i + m], S >> j & 1) +
F(a[j + m][i + m], (S >> m - 1) ^ (S >> j & 1) ^ k);
if (i == m - 1)
f[k] += F(l, S >> j & 1);
else if (j == m - 1)
f[k] += F(l, k);
else
f[k] += MAX(l, -l);
}
if (i != m - 1)
Now += MAX(f[0], f[1]);
else
Now += f[S >> m - 1];
}
if (Now > Ans) Ans = Now;
}
printf("%d\n", Ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class COMPARATOR>
ostream& operator<<(ostream& os, priority_queue<T, vector<T>, COMPARATOR> V) {
os << "[ ";
while (V.size() > 0) {
os << V.top() << " ";
V.pop();
}
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, priority_queue<T> V) {
os << "[ ";
while (V.size() > 0) {
os << V.top() << " ";
V.pop();
}
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, set<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class T, class R>
ostream& operator<<(ostream& os, map<T, R> V) {
os << "[ ";
for (auto v : V) os << "(" << v.first << ":" << v.second << ") ";
return os << "]";
}
template <class T, class R>
ostream& operator<<(ostream& os, unordered_map<T, R> V) {
os << "[ ";
for (auto v : V) os << "(" << v.first << ":" << v.second << ") ";
return os << "]";
}
template <class T, class R>
ostream& operator<<(ostream& os, pair<T, R> V) {
return os << "(" << V.first << "," << V.second << ")";
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << "T->";
cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
cout << "T->";
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
clock_t clk = clock();
const long long MOD = 1000 * 1000 * 1000 + 7;
const long long MOD1 = 998244353;
void solve() {
int n, k, d;
cin >> n >> k >> d;
vector<int> a(n);
for (int(i) = (0); (i) < (n); (i)++) cin >> a[i];
unordered_map<int, int> mp;
int c = 0;
int minc = 0;
for (int(i) = (0); (i) < (d); (i)++) {
if (mp[a[i]] == 0) c++;
mp[a[i]]++;
}
minc = c;
for (int(i) = (d); (i) < (n); (i)++) {
if (mp[a[i]] == 0) c++;
mp[a[i]]++;
if (mp[a[i - d]] == 1) c--;
mp[a[i - d]]--;
minc = min(minc, c);
}
cout << minc << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(25);
int nooftestcases;
cin >> nooftestcases;
for (int(i) = (0); (i) < (nooftestcases); (i)++) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void _read(T& x) {
cin >> x;
}
void R() {}
template <typename T, typename... U>
void R(T& head, U&... tail) {
_read(head);
R(tail...);
}
template <typename T>
inline void _write(const T& x) {
cout << x << ' ';
}
void W() { cout << endl; }
template <typename T, typename... U>
void W(const T& head, const U&... tail) {
_write(head);
W(tail...);
}
void go();
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed << setprecision(15);
go();
return 0;
}
const int MAXN = 2e5 + 10;
int a[MAXN];
void go() {
int n, d;
R(n, d);
for (int i = 1; i <= n; i++) {
R(a[i]);
}
int m;
R(m);
while (m--) {
int x;
R(x);
int r = lower_bound(a + 1, a + 1 + n, x) - a;
long double ans;
if (r == 1) {
ans = atan2(1, a[r] - x);
} else if (r == n + 1) {
ans = atan2(1, x - (a[r - 1] + 1));
} else {
int l = r - 1;
ans = atan2(1, min(a[r] - x, x - (a[l] + 1)));
for (int i = 1; i <= 3500; i++) {
int llen = x - (a[l] + 1);
int rlen = a[r] - x;
if (abs(llen - rlen) <= 1) {
ans = max(ans, (long double)2 * atan2(1, max(llen, rlen)));
break;
} else if (llen < rlen) {
if (l-- == 1) {
break;
}
} else {
if (r++ == n) {
break;
}
}
}
}
W(ans);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long int ccw(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
long long int r1 = (long long int)a.first, s1 = (long long int)a.second;
long long int r2 = (long long int)b.first, s2 = (long long int)b.second;
long long int r3 = (long long int)c.first, s3 = (long long int)c.second;
return (r1 - r2) * (s1 - s3) * s2 * r3 - (r1 - r3) * (s1 - s2) * r2 * s3;
}
int N;
pair<int, int> st;
vector<pair<int, int> > P;
vector<int> ch;
bool cmp(int x, int y) {
pair<int, int> a = P[x], b = P[y];
return ccw(st, a, b) > 0 || (ccw(st, a, b) == 0 && a.second > b.second) ||
(ccw(st, a, b) == 0 && a.second == b.second && a.first > b.first);
}
bool bad(int a, int b, int c) { return ccw(P[a], P[b], P[c]) <= 0; }
vector<int> I, tt;
void get_ch() {
I.resize(N);
for (int i = 0; i < N; i++) I[i] = i;
sort(I.begin(), I.end(), cmp);
for (int i = 0; i < N; i++) {
if (ch.size() < 2)
ch.push_back(I[i]);
else {
while (ch.size() >= 2 &&
bad(ch[ch.size() - 2], ch[ch.size() - 1], I[i])) {
ch.erase(ch.end() - 1);
}
ch.push_back(I[i]);
}
}
for (int i = 0; i < ch.size(); i++) tt.push_back(ch[i]);
ch.clear();
int pos = 0, sz = tt.size();
for (int i = 0; i < sz; i++) {
pair<int, int> p1 = P[tt[i]], p2 = P[tt[(i + 1) % sz]];
while (pos < N && ccw(st, p1, P[I[pos]]) >= 0 &&
ccw(st, p2, P[I[pos]]) <= 0) {
if (ccw(p1, p2, P[I[pos]]) == 0) {
ch.push_back(I[pos]);
}
pos++;
}
}
for (int i = N; i--;) {
if (I[i] == ch[0] || I[i] == ch.back()) continue;
pair<int, int> p1 = P[ch[0]], p2 = P[ch.back()];
if (ccw(p1, p2, P[I[i]]) == 0) ch.push_back(I[i]);
}
}
vector<int> ans;
void solve() {
ans.push_back(ch[0]);
int pos;
pair<int, int> ed = pair<int, int>(-1, -1);
int sz = ch.size();
for (int i = 1; i != sz + 1; i++) {
pair<int, int> p = P[ch[i % sz]];
if (ed.first < p.first) {
ed = p;
pos = i % sz;
} else if (ed.first == p.first && ed.second < p.second) {
ed = p;
pos = i % sz;
}
}
if (P[ch[pos]] != st) {
for (int i = pos; i < ch.size(); i++) {
ans.push_back(ch[i]);
}
} else {
for (int i = pos;; i++) {
if (i >= ch.size() || P[ch[i]] != st) break;
ans.push_back(ch[i]);
}
}
sort(ans.begin(), ans.end());
ans.resize(unique(ans.begin(), ans.end()) - ans.begin());
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i] + 1);
}
}
int main() {
scanf("%d", &N);
P.resize(N);
st = pair<int, int>(-1, -1);
for (int i = 0; i < N; i++) {
int r, s;
scanf("%d %d", &r, &s);
P[i] = pair<int, int>(r, s);
if (st.second < s) {
st = P[i];
} else if (st.second == s && st.first < r) {
st = P[i];
}
}
get_ch();
solve();
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int maxN = 3100;
vector<pair<int, int> > g[maxN];
int n;
int d[maxN][maxN];
int p[maxN][maxN];
int t[maxN];
int q[maxN];
void dfs(int v, int parent) {
t[v] = 0;
for (int i = 0; i < g[v].size(); ++i) {
if (g[v][i].first == parent) {
continue;
}
if (g[v][i].second != 1) {
++t[v];
}
dfs(g[v][i].first, v);
t[v] += t[g[v][i].first];
}
}
void dfs(int v, int parent, int current, int &score) {
score = min(score, current);
for (int i = 0; i < g[v].size(); ++i) {
if (g[v][i].first == parent) {
continue;
}
int buffer = current;
if (g[v][i].second != 1) {
--buffer;
}
if (g[v][i].second == 1) {
++buffer;
}
dfs(g[v][i].first, v, buffer, score);
}
}
void calculate(int v, int parent) {
memset(t, 0, sizeof(t));
dfs(v, parent);
memset(q, 0, sizeof(q));
int score = t[v];
dfs(v, parent, t[v], score);
d[v][parent] = t[v];
p[v][parent] = score;
}
bool used[maxN];
void dfs(int v) {
used[v] = true;
for (int i = 0; i < g[v].size(); ++i) {
if (!used[g[v][i].first] && g[v][i].second == 1) {
dfs(g[v][i].first);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(make_pair(v, 1));
g[v].push_back(make_pair(u, -1));
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < g[i].size(); ++j) {
calculate(i, g[i][j].first);
}
}
int res = n - 1;
for (int i = 1; i <= n; ++i) {
memset(used, 0, sizeof(used));
dfs(i);
vector<pair<int, int> > rem;
for (int j = 1; j <= n; ++j) {
if (!used[j]) {
continue;
}
for (int k = 0; k < g[j].size(); ++k) {
if (!used[g[j][k].first] && g[j][k].second == -1) {
rem.push_back(make_pair(g[j][k].first, j));
}
}
}
int added = 0;
for (int j = 0; j < rem.size(); ++j) {
added += d[rem[j].first][rem[j].second] + 1;
}
res = min(res, added);
for (int j = 0; j < rem.size(); ++j) {
int score = added;
score -= d[rem[j].first][rem[j].second] + 1;
score += p[rem[j].first][rem[j].second];
res = min(res, score);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < g[i].size(); ++j) {
res = min(res, p[i][g[i][j].first] + p[g[i][j].first][i]);
}
}
printf("%d\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 100;
struct T {
long long r, c;
int opr;
};
struct Node {
long long num;
int id;
Node(long long num, int id = 0) : num(num), id(id) {}
bool operator<(const Node& rhs) const { return num < rhs.num; }
};
T save[maxn];
int IDup[maxn], IDleft[maxn];
vector<Node> Vup, Vleft;
long long m;
int n;
struct SegTree {
int num[maxn << 2];
SegTree() { memset(num, 0, sizeof(num)); }
void pushdown(int u) {
int L = u << 1, R = u << 1 | 1;
num[L] = max(num[L], num[u]);
num[R] = max(num[R], num[u]);
}
void pushup(int u) { num[u] = max(num[u << 1], num[u << 1 | 1]); }
void update(int cL, int cR, int val, int L, int R, int u) {
if (cL <= L && R <= cR) {
num[u] = max(num[u], val);
} else {
pushdown(u);
int m = (L + R) / 2;
if (cL <= m) update(cL, cR, val, L, m, u << 1);
if (cR > m) update(cL, cR, val, m + 1, R, u << 1 | 1);
}
}
int query(int p, int L, int R, int u) {
if (L == R)
return num[u];
else {
int m = (L + R) / 2;
pushdown(u);
if (p <= m)
return query(p, L, m, u << 1);
else
return query(p, m + 1, R, u << 1 | 1);
}
}
};
SegTree Up, Left;
int Max;
long long Numup[maxn], Numleft[maxn];
void getID(int ID[], vector<Node>& V, long long Num[]) {
int idx = 0;
for (int i = 0; i < V.size(); ++i)
if (i == 0 || V[i].num != V[i - 1].num) {
Num[idx] = V[i].num;
ID[V[i].id] = idx++;
} else
ID[V[i].id] = idx - 1;
Max = idx;
}
int main() {
scanf("%lld %d", &m, &n);
for (int i = 1; i <= n; ++i) {
char buf[5];
scanf("%lld %lld %s", &save[i].c, &save[i].r, buf);
save[i].opr = buf[0] == 'L';
Vup.push_back(Node(save[i].r, i));
Vleft.push_back(Node(save[i].c, i));
}
Vup.push_back(Node(0, 0));
Vleft.push_back(Node(0, 0));
Vup.push_back(Node(m + 1, n + 1));
Vleft.push_back(Node(m + 1, n + 1));
sort(Vup.begin(), Vup.end());
sort(Vleft.begin(), Vleft.end());
getID(IDup, Vup, Numup);
getID(IDleft, Vleft, Numleft);
for (int i = 1; i <= n; ++i) {
if (save[i].opr == 0) {
int tR = IDup[i];
int tL = Up.query(tR, 0, Max - 1, 1);
int L = Max - 1 - tR;
int R = Max - 1 - tL;
Left.update(L, R, L, 0, Max - 1, 1);
Up.update(tR, tR, tR, 0, Max - 1, 1);
printf("%lld\n", Numup[tR] - Numup[tL]);
} else {
int tR = IDleft[i];
int tL = Left.query(tR, 0, Max - 1, 1);
int L = Max - 1 - tR;
int R = Max - 1 - tL;
Up.update(L, R, L, 0, Max - 1, 1);
Left.update(tR, tR, tR, 0, Max - 1, 1);
printf("%lld\n", Numleft[tR] - Numleft[tL]);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long dp[1 << 19][19];
vector<int> s[55];
int Log[1 << 20];
int v[55][55];
int main(void) {
srand(time(0));
cout << fixed << setprecision(7);
cerr << fixed << setprecision(7);
int n, m;
cin >> n >> m;
for (int qwerty = 1; qwerty <= m; ++qwerty) {
int a, b;
cin >> a >> b;
--a;
--b;
v[a][b] = v[b][a] = 1;
s[a].push_back(b);
s[b].push_back(a);
}
for (int i = 2; i <= 1e6; ++i) Log[i] = Log[i / 2] + 1;
for (int i = 0; i < n; ++i) dp[1 << i][i] = 1;
for (int mask = 1; mask < (1 << n); ++mask)
if (__builtin_popcount(mask) > 1) {
for (int i = 0; i < n; ++i)
if (((mask >> i) & 1) && i != Log[mask & (-mask)])
for (auto it : s[i])
if ((mask >> it) & 1) dp[mask][i] += dp[mask ^ (1 << i)][it];
}
long long ans = 0;
for (int mask = 1; mask < (1 << n); ++mask)
for (int i = 0; i < n; ++i)
if (__builtin_popcount(mask) >= 3 && (((mask >> i) & 1)) &&
v[Log[mask & (-mask)]][i])
ans += dp[mask][i];
ans /= 2;
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m;
cin >> n >> m;
map<int, string> mp;
map<string, int> mp2;
string ans = "";
string pol = "";
bool flag = false;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
bool polindrom = false;
for (int j = 0; !flag && j < (m + 1) / 2; j++) {
if (s[j] != s[m - j - 1]) {
polindrom = false;
break;
}
polindrom = true;
}
if (polindrom) {
flag = true;
pol = s;
} else {
string rev = s;
reverse(rev.begin(), rev.end());
if (mp2.find(rev) != mp2.end()) ans.push_back(i);
}
mp[i] = s;
mp2[s] = i;
}
if (ans.size() == 0 && !flag) {
cout << 0 << "\n";
return 0;
}
cout << ans.size() * 2 * m + pol.size() << "\n";
for (int i = 0; i < ans.size(); i++) cout << mp[ans[i]];
if (flag) cout << pol;
for (int i = ans.size() - 1; i >= 0; i--) {
string st = mp[ans[i]];
reverse(st.begin(), st.end());
cout << st;
}
cout << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int cnt[25], f[125];
string a, b;
vector<int> ans;
bool check(int x, int s) {
for (int i = 0; i <= 15; i++) {
f[i] = cnt[i];
}
int j;
for (int i = x; i <= b.length(); i++) {
for (j = 0; j < 10; j++) {
if (f[j]) {
if (s == 1 && j > (b[i - 1] - '0')) continue;
break;
}
}
if (j >= 10) return 0;
f[j]--;
if (s == 1)
if (j < (b[i - 1] - '0')) s = 0;
}
return 1;
}
int main() {
cin >> a >> b;
if (b.length() > a.length()) {
sort(a.begin(), a.end(), greater<char>());
cout << a << endl;
} else {
for (int i = 1; i <= a.length(); i++) cnt[a[i - 1] - '0']++;
int s;
for (int i = s = 1; i <= b.length(); i++) {
int x = 0;
for (x = 9; x >= 0; x--) {
if (cnt[x]) {
if (s == 1 && x > (b[i - 1] - '0')) continue;
cnt[x]--;
int ns = s;
if (ns == 1)
if (x < (b[i - 1] - '0')) ns = 0;
if (check(i + 1, ns)) break;
cnt[x]++;
}
}
cout << x;
if (s == 1)
if (x < b[i - 1] - '0') s = 0;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int solve(string& a, string& b, bool flag) {
map<int, int> mpb;
for (int i = 0; i < (a).size(); ++i) {
++mpb[b[i] - '0'];
}
int ans = 0;
for (int i = 0; i < (a).size(); ++i) {
bool ck = flag;
if (flag) {
if (mpb[a[i] - '0']) {
--mpb[a[i] - '0'];
continue;
}
}
for (int j = a[i] - '0' + 1; j < 10; ++j) {
if (mpb[j]) {
--mpb[j];
ck = !flag;
break;
}
}
ans += ck;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(0);
int n;
string a, b;
cin >> n >> a >> b;
cout << solve(a, b, 1) << '\n' << solve(a, b, 0);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s;
double a, b, c, x, y, z;
cin >> s >> a >> b >> c;
if (a) {
x = s / ((b + c) / a + 1);
y = (x * b) / a;
z = (x * c) / a;
} else {
if (b) {
y = s / ((a + c) / b + 1);
x = (y * a) / b;
z = (y * c) / b;
} else {
if (c) {
z = s / ((a + b) / c + 1);
x = (z * a) / c;
y = (z * b) / c;
} else {
x = y = z = 0;
}
}
}
cout.precision(15);
cout << x << " " << y << " " << z << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> mat[200010];
int n, lev[200010], baap[200010];
int dfs(int p, int pa) {
int ret = 0;
for (auto x : mat[p]) {
if (x == pa) continue;
lev[x] = lev[p] + 1;
baap[x] = p;
ret += dfs(x, p);
}
if (lev[p] > 2) {
ret++;
lev[pa] = 1;
lev[p] = 2;
lev[baap[pa]] = min(lev[baap[pa]], 2);
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
int a, b;
cin >> n;
for (int i = 1; i <= n - 1; i++) {
cin >> a >> b;
mat[a].push_back(b);
mat[b].push_back(a);
}
cout << dfs(1, 1) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> amap;
int a[400005], b[400005];
int occ[400005];
vector<pair<int, int>> avec;
int** ans;
bool compq(const pair<int, int>& a, const pair<int, int>& b) {
return a.first > b.first;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
amap[a[i]]++;
}
for (auto it : amap) avec.push_back({it.second, it.first});
sort(avec.begin(), avec.end(), compq);
int usz = (int)avec.size();
for (int i = 0; i < usz; i++) {
for (int j = 0; j < avec[i].first; j++) occ[j + 1]++;
}
avec.push_back({0, -1});
int amt = 0;
int bans = 0, br = 0, bc = 0;
for (int i = 1; i <= n; i++) {
amt += occ[i];
int c = i;
int r = amt / c;
if (r >= c && r * c > bans) {
bans = r * c;
br = r;
bc = c;
}
}
printf("%d\n%d %d\n", bans, br, bc);
int p = 0;
for (int i = 0; i < usz; i++) {
for (int j = 0; j < min(bc, avec[i].first); j++) b[p++] = avec[i].second;
}
int ir = 0, ic = 0;
ans = new int*[br];
for (int i = 0; i < br; i++) {
ans[i] = new int[bc];
for (int j = 0; j < bc; j++) ans[i][j] = -1;
}
for (int i = 0; i < bans; i++) {
ans[ir][ic] = b[i];
ir = (ir + 1) % br;
ic = (ic + 1) % bc;
if (ans[ir][ic] != -1) {
ic = (ic + 1) % bc;
}
}
for (int i = 0; i < br; i++) {
for (int j = 0; j < bc; j++) printf("%d ", ans[i][j]);
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& x) {
return os << "(" << x.first << "," << x.second << ")";
}
vector<int> cycle;
const int MAXN = 15005;
bool used[MAXN];
int head = -1;
vector<int> E[MAXN];
bool go(int x, int p = -1) {
used[x] = true;
for (int y : E[x]) {
if (y == p) continue;
if (used[y]) {
assert(head == -1);
head = y;
cycle.push_back(x);
return true;
}
if (go(y, x)) {
cycle.push_back(x);
if (head == x) return false;
return true;
}
}
return false;
}
int no1, no2;
long long F[MAXN], S[MAXN], G[MAXN];
int n;
void solve(int x, int p = -1) {
S[x] = 1;
long long maxg = LLONG_MIN;
for (int y : E[x]) {
if (y == no1 || y == no2 || y == p) continue;
solve(y, x);
S[x] += S[y];
F[x] += F[y];
maxg = max(maxg, G[y] - F[y] - S[y]);
}
G[x] = n + F[x] + (maxg == LLONG_MIN ? 0 : maxg);
F[x] += S[x];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
E[u].push_back(v);
E[v].push_back(u);
}
go(0);
long long sumF = 0;
int c = cycle.size();
for (int i = 0; i < c; ++i) {
no1 = cycle[(i - 1 + c) % c];
no2 = cycle[(i + 1) % c];
solve(cycle[i]);
F[cycle[i]] -= S[cycle[i]];
sumF += F[cycle[i]];
}
vector<int> prefixS(c + 1);
for (int i = 0; i < c; ++i) prefixS[i + 1] = prefixS[i] + S[cycle[i]];
vector<int> dp(c), ndp(c);
function<int(int, int)> calcSum = [&](int a, int b) {
if (b >= c) return n - prefixS[a] + prefixS[b - c + 1];
return prefixS[b + 1] - prefixS[a];
};
assert(prefixS[c] == n);
for (int l = c - 1; l >= 1; --l) {
for (int i = 0; i < c; ++i) {
ndp[i] = n - calcSum(i, i + l - 1);
ndp[i] += max(dp[i], dp[i ? i - 1 : c - 1]);
}
swap(dp, ndp);
}
long long ans = 0;
for (int i = 0; i < c; ++i) {
long long v = G[cycle[i]];
long long val = sumF + dp[i] - F[cycle[i]];
val += v;
ans = max(ans, val);
}
printf("%lld\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using V = vector<T>;
const int maxn = 1e5 + 5;
;
const int MOD = 1e9 + 7;
int n;
V<int> res;
bool check(int m) {
int tot = m;
while (m) {
tot += m % 10;
m /= 10;
}
if (tot == n) return true;
return false;
}
int main() {
cin >> n;
int m = n;
for (int i = 0; i < (int)(200); ++i) {
if (m == 0) break;
if (check(m)) res.push_back(m);
m--;
}
cout << (int)res.size() << endl;
sort((res).begin(), (res).end());
for (auto x : res) cout << x << ' ';
}
| 2 |
#include <bits/stdc++.h>
const int fh = 1023;
bool check(long long int a, long long int b) {
if (a < 0) return false;
long long int ans = a;
while (a > 0) {
ans += (a % 10);
a /= 10;
}
return ans == b;
}
long long int min(long long int a, long long int b) {
if (a < b) return a;
return b;
}
long long int max(long long int a, long long int b) {
if (a > b) return a;
return b;
}
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a;
for (int i = n - 83; i <= n; i++) {
if (check(i, n)) {
a.push_back(i);
}
}
cout << a.size() << endl;
for (int i = 0; i < a.size(); i++) {
cout << a[i] << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1ll << 62;
long long f, t, t0, a1, t1, p1, a2, t2, p2;
long long ff, tt, ans;
int main() {
scanf("%I64d%I64d%I64d", &f, &t, &t0);
scanf("%I64d%I64d%I64d", &a1, &t1, &p1);
scanf("%I64d%I64d%I64d", &a2, &t2, &p2);
if (t1 > t2) swap(t1, t2), swap(a1, a2), swap(p1, p2);
ans = INF;
for (long long i = 0; a1 * i < f; ++i) {
ff = f - i * a1;
tt = t - i * a1 * t1;
if (ff * t2 > tt && ff * t0 > tt) continue;
long long j;
if (t0 <= t2 || ff * t0 <= tt)
j = 0;
else
j = ((t0 * ff - tt + t0 - t2 - 1) / (t0 - t2) + a2 - 1) / a2;
if (p1 * i + p2 * j < ans) ans = p1 * i + p2 * j;
}
if (f * t1 <= t && (f + a1 - 1) / a1 * p1 < ans) ans = (f + a1 - 1) / a1 * p1;
if (ans != INF)
printf("%I64d\n", ans);
else
printf("-1\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 100 + 10, INF = 1e9 + 10;
vector<int> adj[MAXN];
pair<int, int> p[MAXN];
int mark[MAXN];
int mark2[MAXN];
int n, m, h, t;
void print(int v, int u, int a, int b) {
for (int i = 0; i < ((int)adj[v].size()); i++) {
int cur = adj[v][i];
if (cur == u) continue;
if (h == 0) break;
if (mark[cur] == 1) {
cout << cur << " ";
mark2[cur] = 1;
h--;
}
if (mark[cur] == 2 && a > 0) {
cout << cur << " ";
mark2[cur] = 1;
a--;
h--;
}
}
cout << endl;
for (int i = 0; i < ((int)adj[u].size()); i++) {
int cur = adj[u][i];
if (mark2[cur]) continue;
if (cur == v) continue;
if (t == 0) break;
if (mark[cur] == 1) {
cout << cur << " ";
t--;
}
if (mark[cur] == 2 && b > 0) {
cout << cur << " ";
b--;
t--;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> h >> t;
for (int i = 0; i < m; i++) {
cin >> p[i].first >> p[i].second;
if (((int)adj[p[i].first].size()) < 210)
adj[p[i].first].push_back(p[i].second);
if (((int)adj[p[i].second].size()) < 210)
adj[p[i].second].push_back(p[i].first);
}
for (int i = 0; i < m; i++) {
int v = p[i].first, u = p[i].second, a = 0, b = 0, mos = 0, MOS;
for (int j = 0; j < ((int)adj[v].size()); j++) {
a++;
mark[adj[v][j]]++;
}
for (int j = 0; j < ((int)adj[u].size()); j++) {
if (!mark[adj[u][j]])
b++;
else
mos++;
mark[adj[u][j]]++;
}
a -= mos;
MOS = mos;
a--, b--;
if (a < h) mos -= h - a;
if (mos >= 0 && t <= mos + b) {
cout << "YES\n";
cout << v << " " << u << endl;
print(v, u, MOS - mos, mos);
return 0;
}
mos = MOS;
if (a < t) mos = mos - (t - a);
if (mos >= 0 && h <= mos + b) {
cout << "YES\n";
cout << u << " " << v << endl;
print(u, v, mos, MOS - mos);
return 0;
}
for (int j = 0; j < ((int)adj[v].size()); j++) mark[adj[v][j]] = 0;
for (int j = 0; j < ((int)adj[u].size()); j++) mark[adj[u][j]] = 0;
}
cout << "NO\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.1415926535897932384626433832795;
const int inf = 1e9;
const long long inf2 = 1e18;
const int mod = 1e9 + 7;
void boost() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
const int N = 1e6 + 3;
vector<int> par(N, 0), val(N, 0), deg(N, 0);
vector<long long> pref[N], arr[N];
vector<pair<int, int>> adj[N];
void solve() {
int n, m;
cin >> n >> m;
int u, v, w, a, b, x, y;
for (int i = 1; i < n; i++) {
u = (i + 1) / 2;
v = i + 1;
cin >> w;
adj[u].push_back({v, w});
par[v] = u;
val[v] = w;
deg[u]++;
}
queue<int> qq;
for (int i = 1; i < n + 1; ++i) {
if (deg[i] == 0) {
qq.push(i);
arr[i] = vector<long long>(1, 0);
}
}
while (!qq.empty()) {
u = qq.front();
qq.pop();
if (adj[u].size() == 2) {
x = adj[u][0].first;
y = adj[u][1].first;
a = arr[x].size();
b = arr[y].size();
int i = 0, j = 0, k = 1;
arr[u] = vector<long long>(a + b + 1, 0);
while (i < a && j < b) {
if (arr[x][i] + adj[u][0].second < arr[y][j] + adj[u][1].second) {
arr[u][k++] = arr[x][i++] + adj[u][0].second;
} else {
arr[u][k++] = arr[y][j++] + adj[u][1].second;
}
}
while (i < a) arr[u][k++] = arr[x][i++] + adj[u][0].second;
while (j < b) arr[u][k++] = arr[y][j++] + adj[u][1].second;
} else if (adj[u].size() == 1) {
x = adj[u][0].first;
a = arr[x].size();
arr[u] = vector<long long>(a + 1, 0);
int i = 0;
while (i < a) {
arr[u][i + 1] = arr[x][i] + adj[u][0].second;
i++;
}
}
deg[par[u]]--;
if (par[u] != 0 && deg[par[u]] == 0) {
qq.push(par[u]);
}
}
for (int i = 1; i < n + 1; ++i) {
pref[i] = arr[i];
for (int j = 1; j < int(arr[i].size()); j++) {
pref[i][j] += pref[i][j - 1];
}
}
long long ans = 0, h;
while (m--) {
cin >> u >> h;
ans = 0;
x = upper_bound(arr[u].begin(), arr[u].end(), h) - arr[u].begin() - 1;
ans = (h * (x + 1LL)) - pref[u][x];
h -= val[u];
while (h >= 0 && par[u] != 0) {
ans += h;
v = par[u];
for (auto y : adj[v]) {
if (y.first == u || h - y.second < 0) continue;
x = upper_bound(arr[y.first].begin(), arr[y.first].end(),
h - y.second) -
arr[y.first].begin() - 1;
ans += (h - y.second) * (x + 1LL) - pref[y.first][x];
}
u = v;
h -= val[u];
}
cout << ans << '\n';
}
return;
}
int main() {
boost();
int tc = 1;
while (tc--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[50];
int main() {
string str;
int cnt = 0;
cin >> str;
for (int i = 0; i < str.size(); i++) {
if (str[i] == 'B')
a[0]++;
else if (str[i] == 'u')
a[1]++;
else if (str[i] == 'l')
a[2]++;
else if (str[i] == 'b')
a[6]++;
else if (str[i] == 'a')
a[3]++;
else if (str[i] == 's')
a[4]++;
else if (str[i] == 'r')
a[5]++;
}
a[3] /= 2;
a[1] /= 2;
sort(a, a + 7);
cout << a[0] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool good[1100];
bool was[1100];
pair<int, int> out[1100];
struct anss {
int a, b, c;
} ans[1100];
int ansC = 0;
void dfs(int v, int f, int mn) {
if (out[v].first == -1) {
if (v != f) {
ans[ansC].a = f + 1;
ans[ansC].b = v + 1;
ans[ansC].c = mn;
ansC++;
}
return;
}
dfs(out[v].first, f, min(mn, out[v].second));
}
int main() {
int n, p;
cin >> n >> p;
int a, b, c;
for (int i = 0; i < n; i++) {
good[i] = true;
out[i].first = -1;
}
for (int i = 0; i < p; i++) {
cin >> a >> b >> c;
a--, b--;
out[a] = make_pair(b, c);
good[b] = false;
}
for (int i = 0; i < n; i++) {
if (good[i]) {
dfs(i, i, 1100000);
}
}
cout << ansC << endl;
for (int i = 0; i < ansC; i++)
cout << ans[i].a << " " << ans[i].b << " " << ans[i].c << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000100, logN = 23;
inline long long int read() {
register long long int x = 0;
register char ch;
while (!isdigit(ch = getchar()))
;
x = (x << 3) + (x << 1) + (ch ^ 48);
while (isdigit(ch = getchar())) x = (x << 3) + (x << 1) + (ch ^ 48);
return x;
}
int f[N][logN + 1];
inline int query(int l, int r) {
long long int ans = 0;
for (int i = logN - 1; ~i; --i)
if (f[l][i] < r) l = f[l][i], ans += (1 << i);
if (f[l][0] < r) return -1;
return ans + 1;
}
int n, m;
int main() {
scanf("%d%d", &n, &m);
int mx = 0;
for (int i = 1; i <= n; ++i) {
int l = read() + 1, r = read() + 1;
f[l][0] = max(f[l][0], r);
mx = max(mx, r);
}
for (int i = 1; i <= mx; ++i) f[i][0] = max(f[i][0], max(i, f[i - 1][0]));
for (int j = 1; j < logN; ++j)
for (int i = 1; i <= mx; ++i) f[i][j] = f[f[i][j - 1]][j - 1];
while (m--) {
int l = read() + 1, r = read() + 1;
printf("%d\n", query(l, r));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int MAXN = 100010;
std::vector<std::pair<int, int> > add[MAXN], rem[MAXN];
int n, m;
int ss[MAXN], ms[MAXN], rs[MAXN];
const int UP = 1e5 + 5;
std::map<int, std::set<int> > S;
long long trm[MAXN], trv[MAXN];
void addmul(int x, int v) {
for (; x; x &= x - 1) trm[x] += v;
}
void addval(int x, long long v) {
for (; x <= UP; x += x & -x) trv[x] += v;
}
long long qrymul(int x) {
long long r = 0;
for (; x <= UP; x += x & -x) r += trm[x];
return r;
}
long long qryval(int x) {
long long r = 0;
for (; x; x &= x - 1) r += trv[x];
return r;
}
int at[MAXN];
long long bm[MAXN], bv[MAXN], ansl[MAXN];
void ins(int x, int L) {
at[x] = std::min(L, UP);
bm[x] = qrymul(at[x]);
bv[x] = qryval(at[x]);
}
void del(int x) {
if (!at[x]) return;
bm[x] = qrymul(at[x]) - bm[x];
bv[x] = qryval(at[x]) - bv[x];
ansl[x] += bv[x] + at[x] * bm[x];
at[x] = 0;
}
void _upd(std::map<int, std::set<int> >::iterator x, int v) {
if (x == S.begin()) return;
int id = *(x->second.begin());
if (v == -1)
del(id);
else
ins(id, x->first - std::prev(x)->first);
}
void update(int x, int v) {
auto it = S.lower_bound(x);
if (it == S.end()) return;
_upd(it, v);
if (it->first == x && ++it != S.end()) _upd(it, v);
}
void mdf(int x, int v, int id) {
update(x, -1);
if (v == 1)
S[x].insert(id);
else {
if (S[x].size() == 1)
S.erase(x);
else
S[x].erase(id);
}
update(x, 1);
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n;
for (int i = 1; i <= n; ++i) std::cin >> ss[i] >> ms[i] >> rs[i];
std::cin >> m;
for (int i = 1, t, l, r; i <= m; ++i) {
std::cin >> t >> l >> r;
add[l].emplace_back(t, i);
rem[r + 1].emplace_back(t, i);
}
for (int i = 1; i <= n; ++i) {
for (auto t : add[i]) mdf(t.first, 1, t.second);
for (auto t : rem[i]) mdf(t.first, -1, t.second);
if (S.empty()) continue;
int at = S.begin()->first, tar = *(S.begin()->second.begin());
ansl[tar] += std::min<long long>((long long)at * rs[i] + ss[i], ms[i]);
if (rs[i] && ms[i]) {
int br = (ms[i] + rs[i] - 1) / rs[i];
addmul(br - 1, rs[i]);
addval(br, ms[i]);
}
}
for (int i = 1; i <= m; ++i) del(i);
for (int i = 1; i <= m; ++i) std::cout << ansl[i] << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n;
double a, b, c, sum[200005];
char x;
map<double, long long> ans;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> x;
cin >> a;
cin >> x;
cin >> b;
cin >> x >> x;
cin >> c;
sum[i] = (a + b) / c;
ans[sum[i]]++;
}
for (long long i = 1; i <= n; i++) {
cout << ans[sum[i]] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
const int mod = 1e9 + 7;
int add(int a, int b) {
a += b;
if (a >= mod) a -= mod;
return a;
}
int sub(int a, int b) {
a -= b;
if (a < 0) a += mod;
return a;
}
int fR[N][N], sR[N][N];
int fD[N][N], sD[N][N];
int rR[N][N];
int rD[N][N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int m;
cin >> m;
if (n == 1 && m == 1) return 0 * puts("1");
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
char c;
cin >> c;
rR[i][j] = rR[i][j - 1] + (c == 'R');
rD[i][j] = rD[i - 1][j] + (c == 'R');
}
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= m; ++j)
rR[i][j] = rR[i][m] - rR[i][j], rD[i][j] = rD[n][j] - rD[i][j];
for (int i = 1; i <= m; ++i) rR[0][i] = m - i, sR[0][i] = 1;
for (int i = 0; i <= n; ++i) rD[i][0] = n - i;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
if (rR[i][j - 1] <= m - j) {
int l = 1;
int r = i + 1;
for (; l < r;) {
int M = (l + r) / 2;
if (rD[M - 1][j - 1] <= n - i)
r = M;
else
l = M + 1;
}
fR[i][j] = sub(sD[i][j - 1], sD[l - 1][j - 1]);
}
if (rD[i - 1][j] <= n - i) {
int l = 1;
int r = j + 1;
for (; l < r;) {
int M = (l + r) / 2;
if (rR[i - 1][M - 1] <= m - j)
r = M;
else
l = M + 1;
}
fD[i][j] = sub(sR[i - 1][j], sR[i - 1][l - 1]);
}
sR[i][j] = add(sR[i][j - 1], fR[i][j]);
sD[i][j] = add(sD[i - 1][j], fD[i][j]);
}
int ans = 0;
for (int i = 1; i <= n; ++i)
if (!rD[i - 1][m]) ans = add(ans, fD[i][m]);
for (int i = 1; i <= m; ++i)
if (!rR[n][i - 1]) ans = add(ans, fR[n][i]);
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[1005][1005];
int mark[1005];
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < n; i++) scanf("%s", s[i]);
int cnt = 0;
memset(mark, 0, sizeof(mark));
for (int i = 0; i < m; i++) {
int sign = 1;
for (int j = 1; j < n; j++) {
if (s[j][i] < s[j - 1][i] && mark[j] == 0) {
cnt++;
sign = 0;
break;
}
}
if (!sign) continue;
for (int j = 1; j < n; j++)
if (s[j][i] > s[j - 1][i]) mark[j] = 1;
}
printf("%d\n", cnt);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 4.0 * atan(1.0);
int main() {
int n, tmp;
cin >> n;
for (int i = 1; i <= n; i++) {
tmp = (i <= (n / 2 + 1) ? (i) : (1 + n - i));
for (int j = 1; j <= (n + 1 - 2 * tmp) / 2; j++) printf("*");
for (int j = 1; j <= (2 * tmp - 1); j++) printf("D");
for (int j = 1; j <= (n + 1 - 2 * tmp) / 2; j++) printf("*");
printf("\n");
}
return 0;
}
| 0 |
#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;
}
long long n, m, cnt;
struct edge {
long long to, nxt, w;
} e[4000005];
long long tot, head[4000005];
inline void adde(long long u, long long v, long long w) {
e[++tot] = (edge){v, head[u], w};
head[u] = tot;
}
void add(long long u, long long v, long long x) {
long long nxt = v;
while (x >= 10) {
long long t = ++cnt;
adde(t, nxt, x % 10), nxt = t;
x /= 10;
}
adde(u, nxt, x);
}
long long dis[4000005];
bool vis[4000005];
queue<vector<long long> > q;
vector<long long> o[10];
void work() {
vector<long long> v;
v.push_back(1), vis[1] = 1;
q.push(v);
while (!q.empty()) {
vector<long long> tmp = q.front();
q.pop();
for (register long long i = (0); i <= (9); ++i) {
o[i].clear();
for (auto u : tmp)
for (long long p = head[u]; p; p = e[p].nxt)
if (e[p].w == i && !vis[e[p].to])
dis[e[p].to] = (dis[u] * 10 + e[p].w) % 1000000007,
vis[e[p].to] = 1, o[i].push_back(e[p].to);
if (o[i].size()) q.push(o[i]);
}
}
}
signed main() {
n = read(), m = read(), cnt = n;
for (register long long i = (1); i <= (m); ++i) {
long long u = read(), v = read();
add(u, v, i);
add(v, u, i);
}
work();
for (register long long i = (2); i <= (n); ++i) cout << dis[i] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int com(char c1, char c2) {
if (c1 == '(' && c2 == ')' || c1 == '[' && c2 == ']' ||
c1 == '{' && c2 == '}' || c1 == '<' && c2 == '>')
return 0;
else if ((c1 == '<' || c1 == '[' || c1 == '{' || c1 == '(') &&
(c2 == '>' || c2 == ']' || c2 == '}' || c2 == ')'))
return 1;
else
return 2;
}
stack<char> sta;
string s;
int main() {
cin >> s;
int change = 0;
int is = true;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '(' || s[i] == '[' || s[i] == '<' || s[i] == '{')
sta.push(s[i]);
else {
if (sta.empty()) {
is = false;
break;
} else if (com(sta.top(), s[i]) == 0) {
sta.pop();
} else if (com(sta.top(), s[i]) == 1) {
change++;
sta.pop();
} else {
is = false;
break;
}
}
}
if (!sta.empty()) is = false;
if (!is)
cout << "Impossible";
else
cout << change;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const long double pi = acos(-1);
const int MOD = 1e9 + 7;
const int N = 1e6 + 10;
const int M = 20;
int L[N], R[N], val[N], op[N];
int p[N][M];
int muda[N][M];
void dfs(int u, int last) {
p[u][0] = last;
if (L[u]) dfs(L[u], u);
if (R[u]) dfs(R[u], u);
switch (op[u]) {
case 0:
val[u] = val[L[u]] & val[R[u]];
if (val[u] == 0) {
if (val[L[u]] | val[R[u]]) {
if (!val[L[u]]) muda[L[u]][0] = 1;
if (!val[R[u]]) muda[R[u]][0] = 1;
}
} else {
muda[L[u]][0] = 1;
muda[R[u]][0] = 1;
}
break;
case 1:
val[u] = val[L[u]] | val[R[u]];
if (val[u] == 0) {
muda[L[u]][0] = 1;
muda[R[u]][0] = 1;
} else if (val[L[u]] == 0) {
muda[R[u]][0] = 1;
} else if (val[R[u]] == 0) {
muda[L[u]][0] = 1;
}
break;
case 2:
val[u] = val[L[u]] ^ val[R[u]];
muda[L[u]][0] = 1;
muda[R[u]][0] = 1;
break;
case 3:
val[u] = !val[L[u]];
muda[L[u]][0] = 1;
break;
case 4:
break;
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
string o;
cin >> o;
if (o == "AND") {
op[i] = 0;
cin >> L[i] >> R[i];
} else if (o == "IN") {
op[i] = 4;
cin >> val[i];
} else if (o == "XOR") {
op[i] = 2;
cin >> L[i] >> R[i];
} else if (o == "OR") {
op[i] = 1;
cin >> L[i] >> R[i];
} else if (o == "NOT") {
op[i] = 3;
cin >> L[i];
}
}
muda[1][0] = 1;
dfs(1, 1);
for (int j = 1; j < M; j++) {
for (int i = 1; i <= n; i++) {
p[i][j] = p[p[i][j - 1]][j - 1];
muda[i][j] = (muda[i][j - 1] & muda[p[i][j - 1]][j - 1]);
}
}
for (int i = 1; i <= n; i++) {
if (op[i] != 4) continue;
if (muda[i][M - 1])
printf("%d", !val[1]);
else
printf("%d", val[1]);
}
puts("");
}
| 6 |
#include <iostream>
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
vector<ll>adj1[200001],adj2[200001],adj3[200001],vis(200001,0),ans(200001,INT_MAX),dis(200001,INT_MAX);
ll fun(ll nd){
if(vis[nd]==0){
vis[nd]=1;
ll tmp=INT_MAX;
for(ll i=0;i<adj2[nd].size();i++){
tmp=min(tmp,fun(adj2[nd][i]));
}
ans[nd]=min(tmp,ans[nd]);
// cout<<nd<<" "<<tmp<<" "<<ans[nd]<<" ;;";
}return ans[nd];
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll i,j,k,l=1,o,p,tc;
cin>>tc;
while(tc--){
// cout<<"l="<<l++<<"\n";
ll n,m,a,b;
cin>>n>>m;
for(i=0;i<=n;i++){
adj1[i].clear();
adj2[i].clear();
adj2[i].clear();
dis[i]=INT_MAX;
ans[i]=INT_MAX;
vis[i]=0;
}
// vector<ll>adj1[n+1],adj2[n+1],adj3[n+1],vis(n+1,0),dis1(n+1,INT_MAX),ans(n+1,INT_MAX),dis(n+1,INT_MAX);
for(i=0;i<m;i++){
cin>>a>>b;
adj1[a].push_back(b);
// adj2[b].push_back(a);
}
queue<ll>qq;
qq.push(1);
vis[1]=1;
dis[1]=0;
while(!qq.empty()){
ll nd=qq.front();
qq.pop();
for(i=0;i<adj1[nd].size();i++){
if(vis[adj1[nd][i]]==0){
dis[adj1[nd][i]]=dis[nd]+1;
vis[adj1[nd][i]]=1;
qq.push(adj1[nd][i]);
// mp[dis[adj1[nd][i]]].insert(adj1[nd][i]);
}
}
}
for(i=0;i<=n;i++){vis[i]=0;ans[i]=min(ans[i],dis[i]);}
for(i=1;i<=n;i++){
// cout<<"i="<<i<<" ;;";
for(j=0;j<adj1[i].size();j++){
if(dis[i]<dis[adj1[i][j]]){adj2[i].push_back(adj1[i][j]);}
else {
adj3[i].push_back(adj1[i][j]);ans[i]=min(ans[i],dis[adj1[i][j]]);
// cout<<adj1[i][j]<<" "<<dis[i]<<" "<<ans[i]<<" ; ";
}
}//cout<<"\n";
}
fun(1);
for(i=1;i<=n;i++)cout<<min(dis[i],ans[i])<<" ";
cout<<"\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
char seat[maxn];
int main() {
int n, a, b;
scanf("%d %d %d", &n, &a, &b);
scanf("%s", seat + 1);
seat[0] = '*';
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (a <= 0 && b <= 0) break;
if (seat[i] == '.') {
if (seat[i - 1] == '*' || seat[i - 1] == '.') {
if (a > b) {
seat[i] = 'a';
cnt++;
a--;
} else {
seat[i] = 'b';
cnt++;
b--;
}
} else if (seat[i - 1] == 'a') {
if (b > 0) {
seat[i] = 'b';
cnt++;
b--;
}
} else if (seat[i - 1] == 'b') {
if (a > 0) {
seat[i] = 'a';
cnt++;
a--;
}
}
}
}
printf("%d\n", cnt);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e15 + 7, maxn = 1e5 + 50;
int ans, n, m, x, y, q, w, k, cnt[maxn], a[maxn], tedad[maxn], s[maxn], f[maxn],
st, block = 400;
std::vector<int> adj[maxn];
vector<pair<pair<int, int>, pair<int, int> > > query;
std::vector<int> tim;
int stsort[maxn];
int ansv[maxn];
void dfs(int v, int p) {
s[v] = st;
stsort[st] = a[v];
for (int i : adj[v]) {
if (i != p) {
st++;
dfs(i, v);
}
}
f[v] = st;
}
int32_t main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; ++i) {
scanf("%d%d", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1, 0);
pair<pair<int, int>, int> QUERY[q];
for (int i = 0; i < q; i++) {
scanf("%d%d", &x, &y);
query.push_back(
{{s[x] / block, ((s[x] / block) & 1) ? -f[x] : +f[x]}, {y, i}});
QUERY[i] = {{s[x], f[x]}, y};
}
sort((query).begin(), (query).end());
int L = 0, R = 0;
cnt[a[1]]++;
tedad[1]++;
for (int i = 0; i < q; i++) {
int l = QUERY[query[i].second.second].first.first,
r = QUERY[query[i].second.second].first.second;
while (l < L) {
L--;
cnt[stsort[L]]++;
tedad[cnt[stsort[L]]]++;
}
while (r < R) {
tedad[cnt[stsort[R]]]--;
cnt[stsort[R]]--;
R--;
}
while (r > R) {
R++;
cnt[stsort[R]]++;
tedad[cnt[stsort[R]]]++;
}
while (l > L) {
tedad[cnt[stsort[L]]]--;
cnt[stsort[L]]--;
L++;
}
ansv[query[i].second.second] = tedad[query[i].second.first];
}
for (int i = 0; i < q; i++) printf("%d\n", ansv[i]);
;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
map<string, int> m;
int func(string& b) {
int amp = 0, st = 0;
while (b[b.size() - 1] == '*') {
st++;
b = b.substr(0, b.size() - 1);
}
while (b[0] == '&') {
amp++;
b = b.substr(1, b.size() - 1);
}
if (!m[b]) {
return 0;
}
int cnt = st - amp + m[b];
return max(cnt, (int)0);
}
int main() {
int n;
cin >> n;
m["void"] = 1;
for (int kkk = 0; kkk < (n); kkk++) {
string s;
cin >> s;
if (s == "typedef") {
string a, b;
cin >> b >> a;
int cnt = func(b);
m[a] = cnt;
} else {
string a;
cin >> a;
int cnt = func(a);
if (!cnt) {
cout << "errtype" << endl;
} else {
cout << "void";
for (int i = 0; i < (cnt - 1); i++) {
cout << '*';
}
cout << endl;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int IINF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const double DINF = numeric_limits<double>::infinity();
const double EPS = 1e-9;
const int DX[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int DY[] = {0, 1, 0, -1, 1, -1, -1, 1};
const int N = 100179;
const long long P = 257;
const long long MOD = 1000000009;
int n;
string s, t;
long long ppow[N], hs[N], ht[N];
unordered_set<long long> ans;
int spos;
char sc;
inline long long getPrefHashS(int x) {
if (x <= spos) return hs[x];
return ((((hs[spos] * P) % MOD + sc) * ppow[x - spos - 1]) % MOD +
(MOD + hs[x - 1] - (hs[spos] * ppow[x - spos - 1]) % MOD)) %
MOD;
}
inline long long getHashS(int pos, int len) {
return (MOD + getPrefHashS(pos + len) -
(getPrefHashS(pos) * ppow[len]) % MOD) %
MOD;
}
inline long long getHashT(int pos, int len) {
return (MOD + ht[pos + len] - (ht[pos] * ppow[len]) % MOD) % MOD;
}
int lcp() {
int l = 0, r = n;
while (l < r) {
int m = (l + r + 1) >> 1;
if (ht[m] == getPrefHashS(m))
l = m;
else
r = m - 1;
}
return l;
}
int main() {
ios::sync_with_stdio(false);
ppow[0] = 1;
for (int i = 1; i < N; ++i) ppow[i] = (ppow[i - 1] * P) % MOD;
cin >> n >> s >> t;
hs[0] = 0;
for (int i = 0; i < n; ++i) hs[i + 1] = (hs[i] * P + s[i]) % MOD;
ht[0] = 0;
for (int i = 0; i < n; ++i) ht[i + 1] = (ht[i] * P + t[i]) % MOD;
for (spos = 0; spos <= n; ++spos)
for (sc = 'a'; sc <= 'z'; ++sc) {
int a1 = lcp();
if (getHashS(n + 1 - (n - a1), n - a1) == getHashT(n - (n - a1), n - a1))
ans.insert(getPrefHashS(n + 1));
}
cout << ans.size() << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k, resmin = 1, resmax = 0, block, miss, ideal, temp;
int main() {
cin >> n >> k;
k -= (n % 3 == 1) * (k > n / 3);
n -= (n % 3 == 1) * (k >= n / 3);
block = n / 3 + (n % 3 != 0);
miss = (n % 3 != 0);
ideal = block * 2 - miss;
if (k < block)
resmax = max(0, 2 * k);
else
resmax = max(0, ideal - (k - block));
cout << resmin * (k != 0) * (k != n) << " " << resmax;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> mat;
mat.resize(n, vector<int>(n, 0));
for (int i = 0; i < m; i++) {
vector<int> v(n);
for (auto& i : v) {
cin >> i;
i--;
}
for (int j = 0; j < n; j++) {
for (int k = j + 1; k < n; k++) {
mat[v[j]][v[k]]++;
}
}
}
vector<vector<int>> adj(n);
vector<int> deg(n, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (mat[i][j] == m) {
adj[i].push_back(j);
deg[j]++;
}
}
}
vector<int> dist(n, 1);
queue<int> zeroin;
for (int i = 0; i < n; i++) {
if (deg[i] == 0) {
zeroin.push(i);
}
}
int best = 1;
while (!zeroin.empty()) {
int curr = zeroin.front();
zeroin.pop();
for (auto i : adj[curr]) {
deg[i]--;
if (deg[i] == 0) {
zeroin.push(i);
}
dist[i] = max(dist[i], dist[curr] + 1);
best = max(dist[i], best);
}
}
cout << best << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int MAXN = 1e5 + 10;
const long long int MINN = 1e5 + 10;
const long long int inf = 1e9 + 7;
int n, vis[210], col[210];
vector<int> dep[210], a[4], gr[210];
vector<pair<int, int> > tp;
stack<pair<int, int> > st;
void dfs(int x) {
vis[x] = 1;
for (int i = 0; i < (gr[x].size()); ++i)
if (!vis[gr[x][i]]) dfs(gr[x][i]);
st.push({x, col[x]});
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin.exceptions(cin.failbit);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
cin >> n;
for (int i = 1; i <= (n); ++i) {
int x;
cin >> x;
col[i] = x;
}
for (int i = 1; i <= (n); ++i) {
int x;
cin >> x;
for (int j = 0; j < (x); ++j) {
int y;
cin >> y;
dep[i].push_back(y);
gr[y].push_back(i);
}
}
for (int i = 1; i <= (n); ++i) {
if (!vis[i]) dfs(i);
}
while (!st.empty()) {
pair<int, int> x = st.top();
tp.push_back(x);
st.pop();
}
for (int i = 0; i < (tp.size()); ++i) {
pair<int, int> tmp = tp[i];
a[tmp.second].push_back(tmp.first);
}
memset(vis, 0, sizeof(vis));
int dcnt = 0, t = 0, ans = inf, curr = 1;
while (dcnt != n) {
for (int i = 0; i < (a[curr].size()); ++i)
if (!vis[a[curr][i]]) {
bool f = 1;
for (int j = 0; j < (dep[a[curr][i]].size()); ++j)
f &= vis[dep[a[curr][i]][j]];
if (f) {
vis[a[curr][i]] = 1;
++t;
++dcnt;
}
}
++t;
curr += 1;
if (curr > 3) curr = 1;
}
ans = min(ans, t);
dcnt = 0, t = 0, curr = 2;
memset(vis, 0, sizeof(vis));
while (dcnt != n) {
for (int i = 0; i < (a[curr].size()); ++i)
if (!vis[a[curr][i]]) {
bool f = 1;
for (int j = 0; j < (dep[a[curr][i]].size()); ++j)
f &= vis[dep[a[curr][i]][j]];
if (f) {
vis[a[curr][i]] = 1;
++t;
++dcnt;
}
}
++t;
curr += 1;
if (curr > 3) curr = 1;
}
ans = min(ans, t);
dcnt = 0, t = 0, curr = 3;
memset(vis, 0, sizeof(vis));
while (dcnt != n) {
for (int i = 0; i < (a[curr].size()); ++i)
if (!vis[a[curr][i]]) {
bool f = 1;
for (int j = 0; j < (dep[a[curr][i]].size()); ++j)
f &= vis[dep[a[curr][i]][j]];
if (f) {
vis[a[curr][i]] = 1;
++t;
++dcnt;
}
}
++t;
curr += 1;
if (curr > 3) curr = 1;
}
ans = min(ans, t);
cout << ans - 1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, m, e = 0;
cin >> n >> m;
long long a[n], b[m];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < m; i++) cin >> b[i];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (a[i] == b[j]) {
e = a[i];
break;
}
}
if (e) break;
}
if (e) {
cout << "YES\n";
cout << 1 << " " << e << "\n";
} else
cout << "NO\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
vector<string> v;
for (int i = 0; i < t; i++) {
int n, m;
cin >> n >> m;
if (n % m == 0)
v.push_back("YES");
else
v.push_back("NO");
}
for (int i = 0; i < v.size(); i++) {
cout << v[i] << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int T;
cin >> T;
while (T--) {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int res = 0, cur = INT_MAX;
for (int i = 0; i < n - k; i++) {
int tmp = (a[i + k] - a[i]);
if (cur > tmp) {
cur = tmp, res = a[i] + (cur / 2);
}
}
cout << res << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int M = 1e5 + 10;
using namespace std;
const int maxL = 18;
vector<int> vec[M];
int lca[M][maxL];
int h[M];
int t[M];
int n;
void dfs(int v, int par = 0) {
t[v] = 1;
lca[v][0] = par;
for (int i = 1; i < maxL; i++) lca[v][i] = lca[lca[v][i - 1]][i - 1];
for (int u : vec[v])
if (u != par) h[u] = h[v] + 1, dfs(u, v), t[v] += t[u];
}
int get_a(int v, int k) {
for (int i = 0; i < maxL; i++)
if ((k >> i) & 1) v = lca[v][i];
return v;
}
int LCA(int v, int u) {
if (h[v] < h[u]) swap(v, u);
v = get_a(v, h[v] - h[u]);
if (v == u) return v;
for (int i = maxL - 1; i >= 0; i--)
if (lca[v][i] != lca[u][i]) v = lca[v][i], u = lca[u][i];
return lca[v][0];
}
int w[M], num;
int ans[M];
map<pair<int, int>, int> mp;
void dfs2(int v, int p) {
int curr = num;
for (int u : vec[v])
if (u != p) {
num = 0;
dfs2(u, v);
curr += num;
}
num = curr;
num += w[v];
if (p) ans[mp[{v, p}]] = num;
}
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
vec[a].push_back(b);
vec[b].push_back(a);
mp[{a, b}] = mp[{b, a}] = i;
}
dfs(1);
int k;
cin >> k;
while (k--) {
int a, b;
cin >> a >> b;
int L = LCA(a, b);
w[L] -= 2;
w[a]++;
w[b]++;
}
dfs2(1, 0);
for (int i = 1; i < n; i++) cout << ans[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 1e6 + 30;
long long n, m, k;
long long dp[N], s[N];
signed main() {
cin >> n >> m;
dp[0] = 1;
for (long long i = 1; i <= n; i++) {
dp[i] = m * (dp[i - 1] * 2 - s[i - 1]) % mod;
s[i] = (s[i - 1] * (m - 1) + dp[i - 1]) % mod;
}
cout << (dp[n] + mod) % mod << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= k; ++i) {
if ((n + 1) % i != 0) {
cout << "No";
return 0;
}
}
cout << "Yes";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0), cout.precision(15);
vector<int> mirror(10, -1);
mirror[3] = 3;
mirror[4] = 6;
mirror[5] = 9;
mirror[6] = 4;
mirror[7] = 7;
mirror[8] = 0;
mirror[9] = 5;
mirror[0] = 8;
int64_t N;
cin >> N;
vector<int> a;
while (N > 0) {
a.push_back(N % 10);
N /= 10;
}
if (a.empty()) {
a.push_back(0);
}
int n = a.size();
for (int l = 0, r = n - 1; l <= r; l++, r--) {
if (mirror[a[l]] != a[r]) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node_ {
int v, next;
} node[6005];
int head[3005], e, fa[3005][14], gf[3005];
int bj[3005], bjj = 0;
bool b[3005];
void addnode(int u, int v) {
e++;
node[e].v = v;
node[e].next = head[u];
head[u] = e;
}
int flag = 0;
int n;
int dep[3005];
void dfs(int t, int u) {
b[t] = 1;
for (register int i = head[t]; i; i = node[i].next) {
if (u == node[i].v) continue;
if (b[node[i].v]) {
flag = node[i].v;
gf[t] = t;
bj[t] = bjj;
bjj++;
dep[t] = 1;
return;
}
dfs(node[i].v, t);
if (flag > 0) {
gf[t] = t;
bj[t] = bjj;
bjj++;
dep[t] = 1;
if (t == flag) flag = -flag;
return;
} else if (flag < 0)
return;
}
}
void dfs_(int t) {
for (register int i = head[t]; i; i = node[i].next) {
if (gf[node[i].v]) continue;
gf[node[i].v] = gf[t];
fa[node[i].v][0] = t;
for (register int j = 1; j <= 11; ++j)
fa[node[i].v][j] = fa[fa[node[i].v][j - 1]][j - 1];
dep[node[i].v] = dep[t] + 1;
dfs_(node[i].v);
}
}
int log_[3005];
int lca(int u, int v) {
if (dep[v] > dep[u]) swap(u, v);
while (dep[u] > dep[v]) {
u = fa[u][log_[dep[u] - dep[v]]];
}
if (u == v) return u;
for (register int i = 11; i >= 0; --i) {
if (fa[u][i] != fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
}
}
return fa[u][0];
}
double ans = 0;
int main() {
scanf("%d", &n);
for (register int i = 2; i <= n; ++i) {
log_[i] = log_[i / 2] + 1;
}
for (register int i = 1; i <= n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
u++;
v++;
addnode(u, v);
addnode(v, u);
}
dfs(1, 1);
for (register int i = 1; i <= n; ++i) {
if (gf[i] == i) {
dfs_(i);
}
}
for (register int i = 1; i <= n; ++i) {
for (register int j = 1; j <= n; ++j) {
if (gf[i] == gf[j]) {
ans += (1 / (double)(dep[i] + dep[j] - 2 * dep[lca(i, j)] + 1));
} else {
int x = dep[i] + dep[j], y = abs(bj[gf[i]] - bj[gf[j]]) - 1,
z = bjj - 1 - abs(bj[gf[i]] - bj[gf[j]]);
ans = ans + 1 / (double)(x + z) + 1 / (double)(x + y) -
1 / (double)(x + z + y);
}
}
}
printf("%.9lf", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 6205;
struct EDGE {
int v, next;
} edge[MAX_N << 1];
int head[MAX_N], E;
bool flag[MAX_N], dp[MAX_N][MAX_N];
int sum[MAX_N], n;
void Add_Edge(int u, int v) {
edge[E].v = v;
edge[E].next = head[u];
head[u] = E++;
}
void input() {
memset(head, -1, sizeof(head));
E = 0;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
Add_Edge(u, v);
Add_Edge(v, u);
}
}
void dfs(int u, int fa) {
dp[u][0] = 1;
sum[u] = 1;
for (int e = head[u]; e != -1; e = edge[e].next) {
int v = edge[e].v;
if (v == fa) continue;
dfs(v, u);
sum[u] += sum[v];
for (int i = n - 1; i >= 0; i--)
if (dp[u][i]) dp[u][i + sum[v]] = 1;
}
for (int i = n - 1; i >= 0; i--)
if (dp[u][i]) {
int tmp = n - sum[u] + i;
if (tmp > n || tmp < 1) continue;
dp[u][tmp] = 1;
}
for (int i = 1; i < n - 1; i++)
if (dp[u][i]) flag[i] = 1;
}
void output() {
int ans = 0;
for (int i = 1; i < n - 1; i++)
if (flag[i]) ans++;
printf("%d\n", ans);
for (int i = 1; i < n - 1; i++)
if (flag[i]) printf("%d %d\n", i, n - i - 1);
}
int main() {
input();
dfs(1, -1);
output();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int p;
int pow_mod(int base, int power) {
if (power <= 0) return 1;
if (power == 1) return base;
if (power & 1) return (base * pow_mod(base, power - 1) % p) % p;
return pow_mod((base * base) % p, power >> 1) % p;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> p;
int res = 0;
for (__typeof(p) i = (1) - ((1) > (p)); i != (p) - ((1) > (p));
i += 1 - 2 * ((1) > (p))) {
bool can = true;
for (__typeof(p - 1) j = (1) - ((1) > (p - 1));
j != (p - 1) - ((1) > (p - 1)); j += 1 - 2 * ((1) > (p - 1))) {
if (pow_mod(i, j) == 1) {
can = false;
break;
}
}
can &= pow_mod(i, p - 1) == 1;
res += can;
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void aps554(long long int n = 10) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(n) << fixed;
}
long long int M = 1e9 + 7;
long long int M1 = 998244353;
vector<long long int> v;
struct info {
long long int x, lazy;
info() {
x = 0;
lazy = 0;
}
};
struct SegTree {
long long int N;
vector<info> st;
void init(long long int n) {
N = n;
st.resize(4 * N + 5, info());
}
void merge(info &cur, info &l, info &r) { cur.x = l.x + r.x; }
void Build(long long int node, long long int L, long long int R) {
if (L == R) {
st[node].x = v[L - 1];
return;
}
long long int MM = (L + R) / 2;
Build(node * 2, L, MM);
Build(node * 2 + 1, MM + 1, R);
merge(st[node], st[node * 2], st[node * 2 + 1]);
}
info Query(long long int node, long long int L, long long int R,
long long int i, long long int j) {
if (j < L || i > R) return info();
if (i <= L && R <= j) return st[node];
long long int MM = (L + R) / 2;
info left = Query(node * 2, L, MM, i, j);
info right = Query(node * 2 + 1, MM + 1, R, i, j);
info cur;
merge(cur, left, right);
return cur;
}
void Update(long long int node, long long int L, long long int R,
long long int ind, long long int limit, long long int val) {
if (L > ind || R < ind) return;
if (L == ind && R == ind) {
st[node].x = min(val + st[node].x, limit);
return;
}
long long int MM = (L + R) / 2;
Update(node * 2, L, MM, ind, limit, val);
Update(node * 2 + 1, MM + 1, R, ind, limit, val);
merge(st[node], st[node * 2], st[node * 2 + 1]);
}
info query(long long int l, long long int r) { return Query(1, 1, N, l, r); }
void update(long long int ind, long long int val, long long int limit) {
Update(1, 1, N, ind, limit, val);
}
void build() { Build(1, 1, N); }
};
int32_t main() {
aps554();
long long int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
SegTree segm, segM;
v.resize(n);
segm.init(n);
segM.init(n);
while (q--) {
long long int t;
cin >> t;
if (t == 1) {
long long int aa, bb;
cin >> aa >> bb;
segm.update(aa, bb, a);
segM.update(aa, bb, b);
} else {
long long int ind;
cin >> ind;
cout << segM.query(1, ind - 1).x + segm.query(ind + k, n).x << "\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2000000000000000001;
map<string, int> M;
void solve() {
char c;
cin >> c;
string s;
cin >> s;
for (int i = 0; i < s.length(); i++)
if (s[i] % 2)
s[i] = '1';
else
s[i] = '0';
while (s.length() < 18) s = '0' + s;
if (c == '+') {
M[s]++;
} else if (c == '-') {
M[s]--;
} else {
cout << M[s] << "\n";
}
}
int main() {
int a;
cin >> a;
string s;
cin >> s;
vector<int> ans;
if (s[0] == 'B') ans.push_back(1);
for (int i = 1; i < s.length(); i++)
if (s[i] == 'B' && s[i - 1] == 'B')
ans[ans.size() - 1]++;
else if (s[i] == 'B')
ans.push_back(1);
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
register int a, b, j = 0;
cin >> a >> b;
cout << min(a, b) + 1 << endl;
for (int i = b; i >= 0; i--) {
if (j <= a) cout << j << ' ' << i << endl;
j++;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, c;
int main() {
ios::sync_with_stdio(false);
cin >> n;
m = c = 0;
for (int i = 1; i <= n; i++) {
int a, b;
cin >> a >> b;
if (a > b) m++;
if (a < b) c++;
}
if (m > c) cout << "Mishka" << endl;
if (m < c) cout << "Chris" << endl;
if (m == c) cout << "Friendship is magic!^^" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, pair<int, int> > tab;
int main() {
int n, v[3];
pair<int, int> ans;
int maior = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &v[0], &v[1], &v[2]);
sort(v, v + 3);
for (int j = 0; j < 3; j++)
for (int k = j + 1; k < 3; k++) {
pair<int, int> x = tab[make_pair(v[j], v[k])];
int ind = 3 - j - k;
int aux[3] = {v[0], v[1], v[2]};
aux[ind] += x.first;
sort(aux, aux + 3);
if (aux[0] > maior) {
maior = aux[0];
ans.first = i;
ans.second = x.second;
}
}
if (tab[make_pair(v[0], v[1])].first < v[2])
tab[make_pair(v[0], v[1])] = make_pair(v[2], i);
if (tab[make_pair(v[0], v[2])].first < v[1])
tab[make_pair(v[0], v[2])] = make_pair(v[1], i);
if (tab[make_pair(v[1], v[2])].first < v[0])
tab[make_pair(v[1], v[2])] = make_pair(v[0], i);
}
if (ans.first > ans.second) swap(ans.first, ans.second);
if (ans.first)
printf("2\n%d %d\n", ans.first, ans.second);
else
printf("1\n%d\n", ans.second);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, a;
cin >> n;
vector<pair<int, int> > v;
for (i = 1; i <= n; i++) {
cin >> a;
v.push_back({a, i});
}
sort(v.begin(), v.end());
for (i = 0; i < n / 2; i++) {
cout << v[i].second << " " << v[n - i - 1].second << endl;
;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string c, a, b;
cin >> b >> a >> c;
if (a[2] == a[0] && b[0] == c[2] && b[2] == c[0] && b[1] == c[1])
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
int n;
int main() {
scanf("%d", &n);
printf("%d", (2 * n - 1) * (2 * n - 1) + 4 * (n - 1) * n / 2);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char getdiff(char a, char b) {
char x = a;
while (x == a || x == b) {
x = (((x - 'a') + 1) % 26) + 'a';
}
return x;
}
void solve() {
int n, k;
cin >> n >> k;
string s, t;
cin >> s >> t;
int diff = 0;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) diff++;
}
int mindif = diff / 2 + (diff % 2);
if (k < mindif) {
cout << -1 << endl;
return;
}
vector<char> ans(n, 'Z');
int tochange = min(diff, k);
k -= tochange;
int keepsame = diff - tochange;
for (int i = 0, j = 0; i < n; i++) {
if (j >= keepsame) break;
if (s[i] != t[i]) {
ans[i] = s[i];
j++;
}
}
for (int i = n - 1, j = 0; i >= 0; i--) {
if (j >= keepsame) break;
if (s[i] != t[i]) {
ans[i] = t[i];
j++;
}
}
for (int i = 0; i < n; i++) {
if (s[i] != t[i] && ans[i] == 'Z') ans[i] = getdiff(s[i], t[i]);
}
for (int i = 0; i < n; i++) {
if (s[i] == t[i]) {
if (k > 0) {
ans[i] = getdiff(s[i], t[i]);
} else {
ans[i] = s[i];
}
k--;
}
}
for (auto x : ans) cout << x;
cout << endl;
}
int main() {
cin.tie(0)->sync_with_stdio(0);
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
vector<long long int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
long long int lo = 0, hi = 0, max_dist = -1;
for (; hi < n && lo < n; hi++) {
long long int dif = a[hi] - a[lo];
long long int dist = hi - lo + 1;
if (dif <= 5 && dist > max_dist) {
max_dist = dist;
}
if (dif > 5) {
while (dif > 5) {
lo++;
dif = a[hi] - a[lo];
}
dist = hi - lo + 1;
if (dif <= 5 && dist > max_dist) {
max_dist = dist;
cout << a[lo] << " " << a[hi] << "\n";
}
}
}
cout << max_dist << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
char s[N];
int d[N];
int main() {
int n, a, b, t, i, j, k, w = 0;
scanf("%d%d%d%d%s", &n, &a, &b, &t, s + 1), ++b;
for (i = 1; i <= n; ++i) d[i] = s[i] == 'w' ? b : 1;
if (d[1] > t) return puts("0"), 0;
for (i = 1, j = d[1]; j <= t && i <= n; j += d[++i] + a)
;
w = i - 1;
if (w == n) return printf("%d", w), 0;
for (i = 1, j = d[1] + a + d[n]; j <= t; j += d[++i] + a + a)
;
for (k = n; j -= d[i--] + a + a, i;) {
while (j <= t) j += d[--k] + a;
j -= d[k++] + a, w = max(w, i + n - k + 1);
}
for (i = n, j = d[1] + a + d[n] + a; j <= t; j += d[--i] + a + a)
;
for (k = 1; j -= d[i++] + a + a, i <= n;) {
while (j <= t) j += d[++k] + a;
j -= d[k--] + a, w = max(w, k + n - i + 1);
}
printf("%d", w);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
int a, b, k;
cin >> a >> b >> k;
cout << (a - b) * 1ll * (k / 2) + a * (k & 1) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, pos, left, right;
cin >> n >> pos >> left >> right;
int on_left, on_right;
on_left = on_right = 1;
if (left == 1) on_left = 0;
if (right == n) on_right = 0;
int step = 0;
if (on_left && on_right) {
step = min(abs(pos - left), abs(pos - right));
step += abs(left - right);
step += 2;
} else if (on_left) {
step += abs(pos - left);
step += 1;
} else if (on_right) {
step += abs(pos - right);
step += 1;
}
cout << step << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct point {
double x;
double y;
};
int main() {
point one, two;
cin >> one.x >> one.y >> two.x >> two.y;
double t;
double v;
cin >> v >> t;
double vx, vy, wx, wy;
cin >> vx >> vy >> wx >> wy;
double l = 0;
double r = (1 << 28);
double mid;
double ans;
double dist;
point now;
for (int i = 0; i < 100; i++) {
mid = (l + r) / 2;
now = one;
now.x += vx * min(mid, t);
now.y += vy * min(mid, t);
now.x += wx * max((double)0, mid - t);
now.y += wy * max((double)0, mid - t);
dist = sqrt((two.x - now.x) * (two.x - now.x) +
(two.y - now.y) * (two.y - now.y));
if (dist <= v * mid) {
ans = mid;
r = mid;
} else {
l = mid;
}
}
printf("%.15f\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5000010;
vector<long long> v[N];
int a[N];
long long com2(long long n) { return n * (n - 1) / 2; }
int main() {
long long n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] >= m) {
printf("0\n");
return 0;
}
}
for (int i = 1; i <= n; i++)
if (a[i]) {
for (int j = i; j <= n; j++) v[0].push_back(a[j]);
break;
}
if (v[0].size() == 2) {
long long lt = 1, rt = m / v[0][0] + 1, mid;
long long ans = 0;
while (lt <= rt) {
mid = (lt + rt) >> 1;
if (1LL * mid * v[0][0] + v[0][1] >= m)
ans = mid, rt = mid - 1;
else
lt = mid + 1;
}
cout << ans << endl;
} else if (v[0].size() == 3) {
long long lt = 1, rt = 2000000000, mid;
long long ans = 0;
while (lt <= rt) {
mid = (lt + rt) >> 1;
long long p = com2(mid + 1);
if (m / v[0][0] < p) {
ans = mid, rt = mid - 1;
continue;
}
p = p * v[0][0] + mid * v[0][1] + v[0][2];
if (p >= m) {
ans = mid, rt = mid - 1;
} else
lt = mid + 1;
}
cout << ans << endl;
} else {
for (int i = 1; i < N; i++) {
long long sum = 0;
for (int j = 0; j < v[i - 1].size(); j++) {
sum += v[i - 1][j];
v[i].push_back(sum);
if (sum >= m) {
printf("%d\n", i);
return 0;
}
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int ver[5005];
bool G[5005][5005];
int sa[102], so[102];
int ma[5005];
int cnt;
bool help(int u, bool se[]) {
if (se[u]) return 0;
se[u] = 1;
for (int i = 0; i < cnt; i++) {
if (G[u][i]) {
if (ma[i] == -1 || help(ma[i], se)) {
ma[i] = u;
return 1;
}
}
}
return 0;
}
int Mma() {
fill(ma, ma + 5005, -1);
int res = 0;
for (int i = 0; i < cnt; i++) {
bool se[5005];
fill(se, se + 5005, 0);
if (help(i, se)) res++;
}
return res / 2;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, a, u, v;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a;
sa[i] = cnt;
while (a % 2 == 0) {
ver[cnt++] = 2;
a /= 2;
}
for (int j = 3; j * j <= a; j += 2) {
while (a % j == 0) {
ver[cnt++] = j;
a /= j;
}
}
if (a > 2) ver[cnt++] = a;
so[i] = cnt - 1;
}
while (m--) {
cin >> u >> v;
for (int i = sa[u]; i <= so[u]; i++)
for (int j = sa[v]; j <= so[v]; j++) {
G[i][j] = G[j][i] = (ver[i] == ver[j]);
}
}
cout << Mma();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[70002];
struct node {
int deg, s, ind;
} a[70006], b[70006];
int cmp(node ka, node kb) { return ka.deg < kb.deg; }
int main() {
int n, m, i, j;
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n; i++) {
G[i].clear();
scanf("%d%d", &a[i].deg, &a[i].s);
a[i].ind = i;
b[i] = a[i];
}
sort(a, a + n, cmp);
queue<node> q;
for (i = 0; i < n; i++) {
if (a[i].deg == 1) q.push(a[i]);
}
int cnt = 0;
while (!q.empty()) {
node now = q.front();
q.pop();
int deg = now.deg;
int s = b[now.ind].s;
int ind = now.ind;
b[ind].deg--;
if (b[ind].deg < 0) continue;
b[s].s ^= ind;
b[s].deg--;
if (b[s].deg < 0) continue;
G[ind].push_back(s);
cnt++;
if (b[s].deg == 1) q.push(b[s]);
}
printf("%d\n", cnt);
for (i = 0; i < n; i++) {
for (j = 0; j < G[i].size(); j++) printf("%d %d\n", i, G[i][j]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int maxn = 5e5 + 5;
int a[maxn];
int q;
long long pos[21];
int ans[maxn];
long long d[21];
struct node {
long long l, r;
int id;
} s[maxn];
bool cmp(node x, node y) { return x.r < y.r; }
void add(long long a, long long id) {
for (int i = 20; i >= 0; i--) {
if ((a >> i) & 1) {
if (d[i] == 0) {
d[i] = a;
pos[i] = id;
break;
}
if (pos[i] < id) swap(d[i], a), swap(pos[i], id);
a ^= d[i];
}
}
}
long long query(int id) {
long long tot = 0;
for (int i = 20; i >= 0; i--) {
if ((tot ^ d[i]) > tot && pos[i] >= id) tot ^= d[i];
}
return tot;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &s[i].l, &s[i].r);
s[i].id = i;
}
sort(s + 1, s + 1 + q, cmp);
int l = 1;
for (int i = 1; i <= q; i++) {
while (l <= s[i].r && l <= n) add(a[l], l), ++l;
ans[s[i].id] = query(s[i].l);
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int a[N], x[N];
struct Seg {
int l, r, sum;
} tree[N * 4];
void BTree(int l, int r, int idx) {
tree[idx].l = l;
tree[idx].r = r;
tree[idx].sum = 0;
if (l == r) return;
int mid = (l + r) >> 1;
BTree(l, mid, idx << 1);
BTree(mid + 1, r, idx << 1 | 1);
}
void Insert(int id, int x, int idx) {
if (tree[idx].l == tree[idx].r) {
tree[idx].sum += x;
return;
}
int mid = (tree[idx].l + tree[idx].r) >> 1;
if (id <= mid)
Insert(id, x, idx << 1);
else
Insert(id, x, idx << 1 | 1);
tree[idx].sum = tree[idx << 1].sum + tree[idx << 1 | 1].sum;
}
int Query(int k, int idx) {
if (tree[idx].sum < k) return -1;
if (tree[idx].l == tree[idx].r) return tree[idx].l;
if (tree[idx << 1].sum >= k) return Query(k, idx << 1);
return Query(k - tree[idx << 1].sum, idx << 1 | 1);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
BTree(1, n, 1);
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
if (x[i] == -1) {
vector<int> del;
for (int j = 1; j <= m; j++) {
int t = Query(a[j], 1);
if (t == -1) break;
del.push_back(t);
}
for (int j = 0; j < del.size(); j++) Insert(del[j], -1, 1);
} else
Insert(i, 1, 1);
}
if (tree[1].sum == 0) printf("Poor stack!");
for (int i = 1; i <= n; i++) {
int t = Query(i, 1);
if (t == -1) break;
printf("%d", x[t]);
}
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
char c = getchar();
int f = 1, nm = 0;
while ('0' > c || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c && c <= '9') nm = nm * 10 + c - '0', c = getchar();
return (f * nm);
}
struct Edge {
int to, old;
} e[200010 * 2];
int sz[200010], bl[200010], fa[200010], dep[200010], l[200010], tot,
dfn[200010], tim;
inline void Dfs0(int x) {
sz[x] = 1, dep[x] = dep[fa[x]] + 1;
for (int i = l[x]; i; i = e[i].old)
if (e[i].to != fa[x]) fa[e[i].to] = x, Dfs0(e[i].to), sz[x] += sz[e[i].to];
}
inline void Dfs1(int x, int y) {
bl[x] = y, dfn[x] = ++tim;
int k = 0;
for (int i = l[x]; i; i = e[i].old)
if (e[i].to != fa[x] && sz[k] < sz[e[i].to]) k = e[i].to;
if (k) Dfs1(k, y);
for (int i = l[x]; i; i = e[i].old)
if (e[i].to != fa[x] && e[i].to != k) Dfs1(e[i].to, e[i].to);
}
inline int Lca(int x, int y) {
if (dep[bl[x]] < dep[bl[y]]) swap(x, y);
while (bl[x] != bl[y]) {
x = fa[bl[x]];
if (dep[bl[x]] < dep[bl[y]]) swap(x, y);
}
if (dep[x] < dep[y]) return (x);
return (y);
}
int n, m, cnt, f[200010];
struct Node {
long long s;
int t, l, r;
} t[200010 * 4];
inline Node Meg(Node l, Node r) {
Node x;
x.s = l.s + r.s, x.t = l.t + r.t;
x.l = l.l, x.r = r.r;
if (l.t == l.l) x.l += r.l;
if (r.t == r.r) x.r += l.r;
x.s += f[l.r + r.l] - f[l.r] - f[r.l];
return (x);
}
inline Node Ask(int x, int l, int r, int a, int b) {
int md = (l + r) / 2;
if (l == a && r == b) return (t[x]);
if (b <= md) return (Ask(x * 2, l, md, a, b));
if (md < a) return (Ask(x * 2 + 1, md + 1, r, a, b));
if (a <= md && md < b) {
Node L = Ask(x * 2, l, md, a, md);
Node R = Ask(x * 2 + 1, md + 1, r, md + 1, b);
return (Meg(L, R));
}
}
inline void Ins(int x, int l, int r, int a) {
int md = (l + r) / 2;
if (l == r) {
t[x].s = f[1], t[x].t = t[x].l = t[x].r = 1;
return;
}
if (a <= md)
Ins(x * 2, l, md, a);
else
Ins(x * 2 + 1, md + 1, r, a);
t[x] = Meg(t[x * 2], t[x * 2 + 1]);
}
inline void Build(int x, int l, int r) {
t[x].t = (r - l + 1);
if (l == r) return;
Build(x * 2, l, (l + r) / 2), Build(x * 2 + 1, (l + r) / 2 + 1, r);
}
inline Node Work(int x, int y) {
Node res = (Node){0, 0, 0}, now = res;
while (dep[bl[x]] > dep[y]) {
now = Ask(1, 1, n, dfn[bl[x]], dfn[x]);
res = Meg(now, res), x = fa[bl[x]];
}
if (x != y) {
now = Ask(1, 1, n, dfn[y] + 1, dfn[x]);
res = Meg(now, res);
}
return (res);
}
long long ans[200010];
struct Que {
int op, u, v, w;
} q[200010];
bool Cmpw(Que a, Que b) { return (a.w > b.w || a.w == b.w && a.op < b.op); }
inline void Lnk(int x, int y) {
e[++tot].to = y, e[tot].old = l[x], l[x] = tot;
}
int main() {
n = Read(), m = Read();
for (int i = 1; i < n; i++) f[i] = Read();
for (int i = 1; i < n; i++) {
cnt++, q[i].op = 0, q[i].u = Read(), q[i].v = Read(), q[i].w = Read();
Lnk(q[i].u, q[i].v), Lnk(q[i].v, q[i].u);
}
for (int i = 1; i <= m; i++)
q[++cnt].op = i, q[cnt].u = Read(), q[cnt].v = Read(), q[cnt].w = Read();
sort(q + 1, q + cnt + 1, Cmpw);
Dfs0(1), Dfs1(1, 1);
Build(1, 1, n);
for (int i = 1; i <= cnt; i++) {
if (q[i].op == 0) {
if (fa[q[i].v] == q[i].u) swap(q[i].u, q[i].v);
Ins(1, 1, n, dfn[q[i].u]);
} else {
int lca = Lca(q[i].u, q[i].v);
Node L = Work(q[i].u, lca), R = Work(q[i].v, lca);
swap(L.l, L.r);
Node Ans = Meg(L, R);
ans[q[i].op] = Ans.s;
}
}
for (int i = 1; i <= m; i++) printf("%I64d\n", ans[i]);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, a[N], q;
bool lk[N];
struct query {
int t, p, x;
query(int _t = 0, int _p = 0, int _x = 0) {
t = _t;
p = _p;
x = _x;
}
};
query w[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
cin >> q;
for (int i = 1; i <= q; ++i) {
cin >> w[i].t;
if (w[i].t == 1)
cin >> w[i].p >> w[i].x;
else
cin >> w[i].x;
}
int mz = 0;
w[mz].x = 0;
for (int i = q; i >= 1; --i) {
if (w[i].t == 2) {
if (w[mz].x < w[i].x) {
mz = i;
}
}
}
for (int i = 1; i < mz; ++i)
if (w[i].t == 1) a[w[i].p] = w[i].x;
for (int i = 1; i <= n; ++i) {
if (a[i] < w[mz].x) a[i] = w[mz].x;
}
int maxz = 0;
memset(lk, 0, sizeof lk);
for (int i = q; i > mz; --i) {
if (w[i].t == 1) {
if (!lk[w[i].p]) {
lk[w[i].p] = true;
a[w[i].p] = max(maxz, w[i].x);
}
} else
maxz = max(maxz, w[i].x);
}
for (int i = 1; i <= n; ++i) cout << a[i] << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int vis[12][12][1 << 12];
int cnt[1 << 12];
int val[1 << 12];
int n;
bool rec(int node, int ones, int mask) {
if (vis[node][ones][mask]) return 0;
vis[node][ones][mask] = true;
if (node == n) return (mask == 1 << (n - 1)) && (ones == 0);
for (int one = 0; one <= ones; one++) {
for (int submask = mask;; submask = mask & (submask - 1)) {
int no = val[submask];
if (no + one + 1 == a[node] && one + cnt[submask] >= 2) {
if (rec(node + 1, ones - one, (mask ^ submask) | (1 << node)))
return true;
}
if (submask == 0) break;
}
}
return false;
}
bool setup() {
for (int mask = 0; mask < (1 << n); mask++) {
int sum = 0, c = 0;
for (int bit = 0; bit < n; bit++) {
if (mask & (1 << bit)) c++, sum += a[bit];
}
val[mask] = sum, cnt[mask] = c;
}
return false;
}
int main() {
int aa, ones = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> aa;
if (aa == 1)
ones++;
else
a.push_back(aa);
}
n -= ones;
if (n == 0) {
if (ones == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
sort(a.begin(), a.end());
bool answer = true;
for (int i = 0; i < n; i++) {
if (a[i] == 2) answer = false;
}
if (ones < n) answer = false;
if (n + ones != a[n - 1]) answer = false;
if (!answer || setup() || !rec(0, ones, 0))
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool rows[50] = {0}, col[50] = {0};
int main() {
int n, m, count;
set<int> s;
set<int>::iterator it;
string z[50];
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> z[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (z[i][j] == '#') {
s.insert(j);
}
}
it = s.begin();
for (int j = 1; j < s.size(); j++) {
it++;
for (int k = 0; k < n; k++) {
if (z[k][*it] != z[k][*s.begin()]) {
cout << "No\n";
return 0;
}
}
}
s.clear();
}
cout << "Yes";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1600;
long long tab[MAX][MAX], prefsum[MAX][MAX], maxodlewej[MAX][MAX],
maxodprawej[MAX][MAX], dp[MAX][MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N, M;
cin >> N >> M;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
cin >> tab[i][j];
}
prefsum[i][0] = maxodlewej[i][0] = tab[i][0];
for (int j = 1; j < M; ++j) {
maxodlewej[i][j] = maxodprawej[i][j] = prefsum[i][j] =
prefsum[i][j - 1] + tab[i][j];
maxodlewej[i][j] = max(maxodlewej[i][j - 1], prefsum[i][j]);
}
}
for (int i = 0; i < N; ++i) {
for (int j = M - 2; j >= 0; --j) {
maxodprawej[i][j] = max(maxodprawej[i][j + 1], prefsum[i][j]);
}
}
for (int i = 0; i < M; ++i) {
dp[0][i] = prefsum[0][i];
}
for (int i = 1; i < N; ++i) {
if (i & 1) {
dp[i][M - 1] = -1e15;
for (int j = 0; j < M - 1; ++j) {
long long maxa = maxodprawej[i - 1][j + 1];
dp[i][j] = prefsum[i][j] + maxa;
}
maxodlewej[i][0] = dp[i][0];
for (int j = 1; j < M; ++j) {
maxodlewej[i][j] = max(maxodlewej[i][j - 1], dp[i][j]);
}
} else {
dp[i][0] = -1e15;
for (int j = 1; j < M; ++j) {
long long maxa = maxodlewej[i - 1][j - 1];
dp[i][j] = prefsum[i][j] + maxa;
}
maxodprawej[i][M - 1] = dp[i][M - 1];
for (int j = M - 2; j >= 0; --j) {
maxodprawej[i][j] = max(maxodprawej[i][j + 1], dp[i][j]);
}
}
}
cout << *max_element(dp[N - 1], dp[N - 1] + M);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000001;
const int mod = 1000000007;
char b[101][101];
int n;
void make(int x, int y, char v) {
if (0 <= x && 0 <= y && y < n && x < n) {
if (b[x][y] != ' ') return;
b[x][y] = v;
char nxt = (v == 'W') ? 'B' : 'W';
make(x + 1, y + 2, nxt);
make(x + 2, y + 1, nxt);
make(x - 1, y + 2, nxt);
make(x - 2, y + 1, nxt);
make(x + 1, y - 2, nxt);
make(x + 2, y - 1, nxt);
make(x - 1, y - 2, nxt);
make(x - 2, y - 1, nxt);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) b[i][j] = ' ';
make(0, 0, 'W');
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (b[i][j] == ' ') b[i][j] = 'W';
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << b[i][j];
cout << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int F[1010];
int A[1010];
int n;
int main() {
cin >> n;
int i;
for (i = 1; i <= n; i++) cin >> A[i];
F[0] = 0;
F[1] = A[1];
i = 2;
while (i <= n) {
F[i] = min(max(F[i - 1], F[i - 2]), A[i]);
i++;
}
cout << F[n] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int* arr = new int[n];
for (int i = 0; i < n; i++) {
int a;
cin >> a;
while (a % 2 == 0) {
a /= 2;
}
while (a % 3 == 0) {
a /= 3;
}
arr[i] = a;
}
int dist = distance(arr, unique(arr, arr + n));
if (dist == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
int64_t sum = 0;
cin >> n;
while (n--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
sum += (c - a + 1) * (d - b + 1);
}
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 2100 * 500;
const int maxm = 4100;
const int mod = 1e9 + 7;
const int inf = 1e9 + 500;
vector<pair<char, pair<int, int> > > bach[maxn];
int cn = 2;
int en[maxn];
int trii[maxm][26];
int vazn[maxm][26];
int enn[maxm];
int sz[maxn];
int cnn = 1;
int k;
int dp[maxm][2100];
void add(string s) {
int p = 1;
for (int i = 0; i < s.size(); i++) {
s[i] -= 'a';
char c = s[i];
bool peyda = 0;
for (int j = 0; j < bach[p].size(); j++) {
if (bach[p][j].first == c) {
peyda = 1;
p = bach[p][j].second.first;
break;
}
}
if (!peyda) {
bach[p].push_back(make_pair(c, make_pair(cn, 1)));
p = cn;
cn++;
}
}
en[p]++;
}
int compp(int p) {
int kh = cnn;
cnn++;
for (int i = 0; i < bach[p].size(); i++) {
int v = compp(bach[p][i].second.first);
trii[kh][bach[p][i].first] = v;
vazn[kh][bach[p][i].first] = bach[p][i].second.second;
}
enn[kh] = en[p];
return kh;
}
void comp(int p) {
for (int i = 0; i < bach[p].size(); i++) {
comp(bach[p][i].second.first);
}
for (int i = 0; i < bach[p].size(); i++) {
char c = bach[p][i].first;
int v = bach[p][i].second.first;
if (bach[v].size() == 1 && en[v] == 0) {
bach[p][i].second.second += bach[v][0].second.second;
bach[p][i].second.first = bach[v][0].second.first;
}
}
}
void dfs(int a) {
sz[a] = enn[a];
for (int i = 0; i <= sz[a]; i++) {
dp[a][i] = 0;
}
for (int i = 0; i < 26; i++) {
int v = trii[a][i];
if (v != 0) {
dfs(v);
for (int p = sz[a] + sz[v]; p >= 0; p--) {
for (int k = 0; k <= sz[v]; k++) {
int j = p - k;
if (j < 0 || j > sz[a]) {
continue;
}
dp[a][p] =
max(dp[a][p], dp[a][j] + dp[v][k] + vazn[a][i] * k * (k - 1) / 2);
}
}
sz[a] += sz[v];
}
}
}
int main() {
for (int i = 0; i < maxm; i++) {
for (int j = 0; j < 2100; j++) {
dp[i][j] = -inf;
}
}
int n;
cin >> n >> k;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
add(s);
}
comp(1);
compp(1);
dfs(1);
cout << dp[1][k];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 7;
void op(const string ff) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
freopen((ff + ".inp").c_str(), "r", stdin);
freopen((ff + ".out").c_str(), "w", stdout);
}
void init() { op((fopen("t.inp", "r")) ? "t" : "(filename_here)"); }
long long n, k;
long long a[100001];
long long solve() {
cin >> n >> k;
for (long long i = (1); i <= (n); i++) cin >> a[i];
sort(a + 1, a + n + 1, greater<long long>());
long long t = 0;
for (long long i = (1); i <= (n); i++) {
t += a[i];
if (t < k * i) return i - 1;
}
return n;
}
string ans[] = {"NO", "YES"};
signed main() {
long long t;
cin >> t;
while (t--) cout << solve() << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 405;
int dp[N][N];
string s, a, b;
bool check() {
for (int i = 0; i <= a.length(); ++i)
for (int j = 0; j <= b.length(); ++j) dp[i][j] = 0;
for (int i = 0; i <= a.length(); ++i)
for (int j = i == 0; j <= b.length(); ++j) {
dp[i][j] = INT_MAX;
if (i - 1 >= 0) {
int pos = dp[i - 1][j] + 1;
while (pos <= s.length() && s[pos - 1] != a[i - 1]) ++pos;
if (pos <= s.length()) dp[i][j] = min(dp[i][j], pos);
}
if (j - 1 >= 0) {
int pos = dp[i][j - 1] + 1;
while (pos <= s.length() && s[pos - 1] != b[j - 1]) ++pos;
if (pos <= s.length()) dp[i][j] = min(dp[i][j], pos);
}
}
return dp[a.length()][b.length()] != INT_MAX;
}
int main() {
int T;
cin >> T;
while (T--) {
bool ok = 0;
cin >> s >> b;
a.clear();
while (b.length()) {
ok |= check();
a += b.front();
b.erase(0, 1);
}
puts(ok ? "YES" : "NO");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t, i, n, p, k, ans, cnt, j, f, w;
cin >> t;
for (; t--;) {
cin >> n >> p >> k;
vector<int> a(n);
ans = 0;
j = 0;
for (i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
for (i = 0; i <= k; i++) {
cnt = i;
w = j;
for (f = i + k - 1; f < n; f += k) {
if (w + a[f] <= p) {
cnt += k;
w += a[f];
} else
break;
}
ans = max(ans, cnt);
j += a[i];
if (j > p) break;
}
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using std::max;
using std::min;
const int N = 8005, T = 20000;
int dp[N][4005], n, p, Q, mxt, v, w, t, L[T + 5], R[T + 5], cnt, r;
struct goods {
int v, w;
};
std::vector<goods> e[T + 5];
void solve(int *dp, int t) {
for (auto u : e[t]) {
for (int i = 4000; i >= u.v; i--) dp[i] = max(dp[i], dp[i - u.v] + u.w);
}
}
int main() {
scanf("%d%d", &n, &p);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &v, &w, &t);
e[t].push_back({v, w});
mxt = std::max(mxt, t);
}
scanf("%d", &Q);
for (int i = 1; i <= T; i += p) {
for (int j = i; j < i + p && j <= T; j++) {
if (j > i) R[j] = R[j - 1];
if (!e[j].empty()) {
++cnt;
memcpy(dp[cnt], dp[R[j]], sizeof(dp[cnt]));
solve(dp[cnt], j);
R[j] = cnt;
}
}
for (int j = i - 1; j > i - p && j; j--) {
if (j < i - 1) L[j] = L[j + 1];
if (!e[j].empty()) {
++cnt;
memcpy(dp[cnt], dp[L[j]], sizeof(dp[cnt]));
solve(dp[cnt], j);
L[j] = cnt;
}
}
}
while (Q--) {
scanf("%d%d", &r, &v);
int l = r - p + 1;
if (l < 0) l = 0;
l = L[l], r = R[r];
int ans = 0;
for (int i = 0; i <= v; i++) ans = std::max(ans, dp[l][i] + dp[r][v - i]);
printf("%d\n", ans);
}
}
| 9 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 7;
class TreeArray {
private:
int arr[maxn], n;
int Lowbit(int x) { return x & (-x); }
public:
void Init(int x) {
n = x;
memset(arr, 0, sizeof(arr));
}
void AddVal(int pos, int val, int op) {
if (op == 0) {
while (pos) {
arr[pos] = std ::max(arr[pos], val);
pos -= Lowbit(pos);
}
} else {
while (pos <= n) {
arr[pos] = std ::max(arr[pos], val);
pos += Lowbit(pos);
}
}
}
int Query(int pos, int op) {
if (!pos) {
return 0;
}
int res = 0;
if (op == 0) {
while (pos <= n) {
res = std ::max(res, arr[pos]);
pos += Lowbit(pos);
}
} else {
while (pos) {
res = std ::max(res, arr[pos]);
pos -= Lowbit(pos);
}
}
return res;
}
};
class Solution {
private:
int n, a[maxn], start[maxn], end[maxn], ans, maxx, sum[maxn];
TreeArray tree;
char res[maxn];
public:
Solution() {
Get();
Solve();
}
void Get() {
scanf("%d", &n);
for (register int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
maxx = std ::max(maxx, a[i]);
}
}
void Solve() {
tree.Init(maxx);
for (register int i = 1; i <= n; i++) {
end[i] = tree.Query(a[i], 1) + 1;
ans = std ::max(ans, end[i]);
tree.AddVal(a[i] + 1, end[i], 1);
}
tree.Init(maxx);
for (register int i = n; i >= 1; i--) {
start[i] = tree.Query(a[i] + 1, 0) + 1;
tree.AddVal(a[i], start[i], 0);
}
for (register int i = 1; i <= n; i++) {
if (start[i] + end[i] <= ans) {
res[i - 1] = '1';
continue;
}
res[i - 1] = '2';
sum[start[i]]++;
}
for (register int i = 1; i <= n; i++) {
if (res[i - 1] == '1') {
continue;
}
if (sum[start[i]] == 1) {
res[i - 1] = '3';
}
}
puts(res);
}
};
Solution sol;
int main() {}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 407;
int n;
int c[MAX_N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &c[i]);
}
int ans = (int)1e9;
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; ++j) {
int sum1 = c[j], b = c[i] - 1, cnt1 = 1;
for (int k = 1; k <= j; ++k) {
cnt1 += b / c[k];
sum1 += b / c[k] * c[k];
b %= c[k];
}
int temp = sum1, cnt2 = 0;
for (int k = 1; k <= n; ++k) {
cnt2 += sum1 / c[k];
sum1 %= c[k];
}
if (cnt1 < cnt2) ans = min(ans, temp);
}
}
if (ans == (int)1e9) ans = -1;
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 100000;
const long long inf = 10000000000;
long long n;
long long t[maxn + 2], v[maxn + 2], s[maxn + 2], sum;
vector<long long> G[maxn + 2];
void dfs(long long nod, long long nivel) {
if (nivel % 2) {
v[nod] = s[nod] - s[t[nod]];
} else {
if (G[nod].size() > 1) {
long long minim = inf;
for (auto it : G[nod]) {
minim = min(minim, s[it] - s[t[nod]]);
}
v[nod] = minim;
s[nod] = s[t[nod]] + minim;
} else {
v[nod] = 0;
s[nod] = s[t[nod]];
}
}
if (G[nod].size()) {
for (auto it : G[nod]) {
dfs(it, nivel + 1);
}
}
}
int main() {
cin >> n;
for (int i = 2; i <= n; i++) {
cin >> t[i];
G[t[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
for (int i = 2; i <= n; i++) {
if (s[i] != -1) {
if (s[i] < s[t[t[i]]]) {
cout << "-1";
return 0;
}
}
}
v[1] = s[1];
dfs(1, 1);
for (int i = 1; i <= n; i++) {
sum = sum + v[i];
}
cout << sum;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, child, node, P[200005];
void Print() {
for (int i = 2; i <= n; i++) cout << P[i] << ' ' << i << "\n";
exit(0);
}
int main() {
cin >> n >> child;
node = n - child;
if (child >= node) {
node--;
int tmp = 1;
while (child > node) {
child--;
P[++tmp] = 1;
}
if (tmp == n) {
cout << 2 << "\n";
Print();
}
int Count = 0;
for (int i = tmp + 1; i <= n; i += 2) {
Count++;
P[i] = 1;
P[i + 1] = i;
}
if (Count == 1)
cout << 3 << "\n";
else
cout << 4 << "\n";
Print();
} else {
int len = (node - 1) / child, mod = (node - 1) % child;
if (mod == 0)
cout << 2 * (len + 1) << "\n";
else if (mod == 1)
cout << 2 * (len + 1) + 1 << "\n";
else
cout << 2 * (len + 1) + 2 << "\n";
for (int i = 2; i <= child + 1; i++) P[i] = 1;
for (int i = 2; i <= n - child; i++) P[i + child] = i;
Print();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n_keys, n_chests;
int odd_keys, even_keys, odd_chests, even_chests;
int main() {
cin >> n_keys >> n_chests;
for (int i = 0; i < n_keys; i++) {
int x;
cin >> x;
if (x % 2 == 0)
even_keys++;
else
odd_keys++;
}
for (int i = 0; i < n_chests; i++) {
int x;
cin >> x;
if (x % 2 == 0)
even_chests++;
else
odd_chests++;
}
cout << min(even_chests, odd_keys) + min(odd_chests, even_keys) << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
long long f = 0;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x = f ? -x : x;
}
long long Q, n, m, ans;
void make(long long x, long long y, long long beg) {
if (x < 0 || y < 0 || beg < 0 || beg > 9) return;
long long res = beg, tmp = 10;
while (y--) res += tmp * 9, tmp *= 10;
if (x >= 8) res += tmp * 8, tmp *= 10, x -= 8;
while (x)
if (x >= 9)
res += tmp * 9, tmp *= 10, x -= 9;
else
res += tmp * x, x = 0;
ans = min(ans, res);
}
void make(long long x, long long beg) {
if (x < 0 || beg < 0 || beg > 9) return;
long long res = beg, tmp = 10;
while (x)
if (x >= 9)
res += tmp * 9, tmp *= 10, x -= 9;
else
res += tmp * x, x = 0;
ans = min(ans, res);
}
signed main() {
read(Q);
while (Q--) {
ans = 0x3f3f3f3f3f3f3f3f;
read(n), read(m), ++m;
if (n < m * (m - 1) / 2) {
puts("-1");
continue;
}
long long p = n - m * (m - 1) / 2, q = p / m;
if (p % m == 0) make(q - min(10 - m, q), min(10 - m, q));
for (long long i = 10 - m + 1; i <= 9; i++) {
p = 10 - i, q = m - p;
for (long long j = 0; j <= 15; j++) {
long long num =
n - (19 * p - p * p) / 2 - (q * q - q) / 2 - 9 * j * p - q;
if (num % (p + q) == 0) make(num / (p + q), j, i);
}
}
if (ans >= 0x3f3f3f3f3f3f3f3f)
puts("-1");
else
printf("%lld\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn], t[maxn], y;
struct node {
int x, y, s, t;
} no[maxn];
bool cmp1(node a, node b) { return a.x > b.x || (a.x == b.x && a.y < b.y); }
bool cmp2(node a, node b) { return a.s < b.s; }
int lowbit(int x) { return x & (-x); }
int query(int x) {
int ans = 0;
while (x) {
ans += t[x];
x -= lowbit(x);
}
return ans;
}
void update(int x) {
while (x <= maxn) {
t[x]++;
x += lowbit(x);
}
return;
}
int main() {
int n;
while (cin >> n) {
int k = n;
memset(no, 0, sizeof(no));
memset(a, 0, sizeof(a));
memset(t, 0, sizeof(t));
for (int i = 0; i < k; i++) {
cin >> no[i].x >> a[i];
no[i].y = a[i];
no[i].s = i;
}
sort(a, a + n);
n = unique(a, a + n) - a;
for (int i = 0; i < n; i++)
no[i].y = lower_bound(a, a + n, no[i].y) - a + 1;
sort(no, no + n, cmp1);
for (int i = 0; i < k; i++) {
y = no[i].y;
no[i].t = query(y);
update(y);
}
sort(no, no + n, cmp2);
for (int i = 0; i < k; i++) cout << no[i].t << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long a, long long b,
long long mod = (long long)(1e9 + 7)) {
if (!b) return 1;
a %= mod;
return modpow(a * a % mod, b / 2, mod) * (b & 1 ? a : 1) % mod;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 50, maxr = 5000;
int n, r;
long double K;
long double S[maxn], F[maxn], p[maxn];
long double E[maxn][maxr + 1];
void init(long double mid) {
K = mid;
for (int i = 0; i < maxn; i++)
for (int j = 0; j < maxr + 1; j++) E[i][j] = -1;
}
long double dp(int i, int j) {
if (j < 0)
return K;
else if (i == n)
return 0;
else if (E[i][j] != -1)
return E[i][j];
else {
return E[i][j] = min(K, p[i] * (dp(i + 1, j - F[i]) + F[i]) +
(1 - p[i]) * (dp(i + 1, j - S[i]) + S[i]));
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
clock_t start = clock();
while (cin >> n >> r) {
for (int i = 0; i < n; i++) {
cin >> F[i] >> S[i] >> p[i];
p[i] /= 100.0;
}
long double lo = 0, hi = 1e9;
for (int _ = 0; _ < 100; _++) {
long double mid = (lo + hi) / 2;
init(mid);
if (dp(0, r) == mid)
lo = mid;
else
hi = mid;
}
cout << setprecision(12) << lo << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, a, b;
cin >> n >> m >> a >> b;
long long rem = n % m;
cout << min((m - rem) * a, rem * b) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
int money = s * 100;
int ans = 0;
int flag = 0;
for (int i = 0; i < n; i++) {
int x1, y1;
cin >> x1 >> y1;
int price = x1 * 100 + y1;
if (money >= price) flag = 1;
int temp = (money - price) % 100;
if (temp > ans) ans = temp;
}
if (flag)
cout << ans << endl;
else
cout << -1 << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long len[1000005];
int p[1000005], v[1005];
int main() {
long long n, k;
cin >> n >> k;
long long sum = (n * (n + 1)) / 2;
if (sum > k) {
cout << -1 << endl;
return 0;
}
len[1] = 0;
for (int i = 2; i <= n; i++) len[i] = len[i - 1] + i / 2;
k = min(k, sum + len[n]);
for (int i = 1; i <= n; i++) p[i] = i;
long long add = k - sum;
long long esq = 1, dir = n;
while (add > 0) {
if (dir - esq <= add) {
swap(p[esq], p[dir]);
add -= (dir - esq);
} else {
long long dif = min(dir - esq, add);
swap(p[esq], p[esq + dif]);
break;
}
esq++;
dir--;
}
cout << k << endl;
for (int i = 1; i <= n; i++) printf("%d ", i);
puts("");
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
puts("");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int rev(int c) {
int res = 0;
for (int i = 0; i < (int)(8); ++i) {
res <<= 1;
if (c & 1) res |= 1;
c /= 2;
}
return res;
}
int vs[1000];
int main(void) {
string line;
getline(cin, line);
for (int i = 0; i < (int)(line.size()); ++i) {
vs[i] = rev((int)line[i]);
}
int prev = 0;
for (int i = 0; i < (int)(line.size()); ++i) {
int res = (256 + prev - vs[i]) % 256;
cout << res << endl;
prev = vs[i];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
if (n == 1) return false;
if (n == 2) return true;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
long long powm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * 1ll * a % 1000000007;
a = a * 1ll * a % 1000000007;
b >>= 1;
}
return res;
}
long long mul(long long x, long long y) { return (x * 1ll * y) % 1000000007; }
void solve() {
long long i = 0, j = 0, k = 0, n = 0, m = 0, rb, cb, rd, cd;
cin >> n >> m >> rb >> cb >> rd >> cd;
if (rd >= rb && cd >= cb) {
{
cout << min((rd - rb), (cd - cb)) << "\n";
return;
};
}
if (cd >= cb) {
cout << min((n - rb) * 2 + abs(rb - rd), (cd - cb)) << "\n";
return;
};
if (rd >= rb) {
cout << min((m - cb) * 2 + abs(cb - cd), (rd - rb)) << "\n";
return;
};
{
cout << min((((n - rb) * 2) + abs(rb - rd)), ((m - cb) * 2 + abs(cb - cd)))
<< "\n";
return;
}
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cout << setprecision(15);
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool Palindrome(string s) {
int n = s.size();
for (int i = 0, j = n - 1; i <= j; i++, j--) {
if (s[i] != s[j]) return 0;
}
return 1;
}
void solve(int t) {
int i, j, n, m, k;
string s;
cin >> s;
n = s.size();
set<char> st;
for (i = 0; i < n / 2; i++) st.insert(s[i]);
if (st.size() == 1 || n <= 3) {
cout << "Impossible\n";
return;
}
string s2 = s;
for (i = 0; i < n; i++) {
s2 = s2.back() + s2;
s2.pop_back();
if (s2 != s && Palindrome(s2)) {
cout << 1 << endl;
return;
}
}
cout << 2 << endl;
return;
}
int main() {
int t, tt = 1;
for (t = 1; t <= tt; t++) solve(t);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
inline int read() {
int w = 0, r = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') r = -1;
ch = getchar();
}
while (isdigit(ch)) {
w = (w << 1) + (w << 3) + (ch ^ 48);
ch = getchar();
}
return w * r;
}
int T, n;
int uset[N], rnk[N], f[N];
int find(int x) {
if (uset[x] != x) uset[x] = find(uset[x]);
return uset[x];
}
bool join(int x, int y) {
int f1 = find(x), f2 = find(y);
if (f1 == f2) return 0;
if (rnk[f1] < rnk[f2]) {
uset[f1] = f2;
} else {
if (rnk[f1] == rnk[f2]) rnk[f1]++;
uset[f2] = f1;
}
return 1;
}
struct line {
int ed, nxt;
} li[2 * N];
int head[N], cnt;
inline void add(int u, int v) {
li[++cnt].ed = v;
li[cnt].nxt = head[u];
head[u] = cnt;
}
bool flg;
int tp, tot, s, t;
int pth[N], mrk[N], typ[N], fnl[N];
void dfs(int u, int fa) {
if (flg) return;
pth[++tp] = u;
mrk[u] = 1;
if (u == t) {
flg = 1;
return;
}
for (int i = head[u]; i; i = li[i].nxt) {
int v = li[i].ed;
if (v == fa) continue;
dfs(v, u);
if (flg) return;
}
tp--;
mrk[u] = 0;
}
void clean() {
cnt = 0;
tp = 0;
tot = 0;
flg = 0;
for (int i = 1; i <= n; i++) {
head[i] = fnl[i] = pth[i] = mrk[i] = typ[i] = 0;
}
}
int main() {
T = read();
while (T--) {
n = read();
s = 0;
t = 0;
for (int i = 1; i <= n; i++) {
uset[i] = i;
rnk[i] = 0;
}
for (int i = 1; i <= n; i++) {
int x = read();
if (!join(i, i - x)) {
s = i;
t = i - x;
} else {
add(i, i - x);
add(i - x, i);
}
typ[i] = 1;
}
dfs(s, 0);
for (int i = 1; i <= tp; i++)
if (typ[i]) fnl[++tot] = pth[i];
printf("%d\n", tot);
for (int i = 1; i <= tot; i++) printf("%d ", fnl[i]);
puts("");
clean();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool SR(int &_x) { return scanf("%d", &_x) == 1; }
bool SR(long long &_x) { return scanf("%lld", &_x) == 1; }
bool SR(double &_x) { return scanf("%lf", &_x) == 1; }
bool SR(char *_s) { return scanf("%s", _s) == 1; }
bool RI() { return true; }
template <typename I, typename... T>
bool RI(I &_x, T &..._tail) {
return SR(_x) && RI(_tail...);
}
void SP(const int _x) { printf("%d", _x); }
void SP(const long long _x) { printf("%lld", _x); }
void SP(const double _x) { printf("%.16lf", _x); }
void SP(const char *s) { printf("%s", s); }
void PL() { puts(""); }
template <typename I, typename... T>
void PL(const I _x, const T... _tail) {
SP(_x);
if (sizeof...(_tail)) putchar(' ');
PL(_tail...);
}
int dig[16];
long long mem[16][2][16];
long long dp(int pos, bool any, int hi) {
long long &ans = mem[pos][any][hi];
if (~ans) return ans;
if (pos == 0) return ans = (any || hi <= dig[pos]);
ans = 0;
for (int i = (0); i <= int(min(any ? 15 : dig[pos], hi)); i++) {
const bool sa = any || i < dig[pos];
ans += dp(pos - 1, sa, hi);
if (i == hi)
for (int j = 0; j < int(hi); j++) ans += dp(pos - 1, sa, j);
}
return ans;
}
int isgood[16][1 << 16];
void predo() {
static int tmp[1 << 16];
for (int i = 0; i < int(1 << 16); i++) tmp[i] = max(tmp[i / 16], i % 16);
for (int i = 0; i < int(16); i++)
for (int j = 0; j < int(1 << 16); j++)
if (j & (1 << max(tmp[j], i))) isgood[i][j] = 1;
for (int i = 0; i < int(16); i++)
for (int j = (1); j <= int((1 << 16) - 1); j++)
isgood[i][j] += isgood[i][j - 1];
for (int i = 0; i < int(16); i++)
;
}
vector<long long> upper(const long long &x) {
vector<long long> ret(16, 0);
if (x == 0) {
ret[0]++;
return ret;
}
memset(mem, -1, sizeof(mem));
int len = 0;
for (auto y = x; y; y /= 16) dig[len++] = y % 16;
for (int i = 0; i < int(16); i++) ret[i] = dp(len - 1, 0, i);
return ret;
}
long long calc(const long long &x) {
if (x == 0) return 0;
;
long long ans = 0;
auto cnt = upper(x / (1 << 16));
for (int i = 0; i < int(16); i++) ans += cnt[i] * isgood[i][(1 << 16) - 1];
;
int hi = 0;
for (auto y = x / (1 << 16); y; y /= 16) hi = max(1LL * hi, y % 16);
ans -= isgood[hi][(1 << 16) - 1];
ans += isgood[hi][x % (1 << 16)];
return ans;
}
long long cnt2(const long long &l, const long long &r) {
long long ans = 0;
for (long long i = l; i <= r; i++) {
long long hi = 0;
for (long long j = i; j; j /= 16) hi = max(hi, j % 16);
if (i & (1 << hi)) ans++;
}
return ans;
}
int main() {
predo();
int t;
RI(t);
while (t--) {
long long l, r;
scanf("%llx %llx", &l, &r);
long long ans = calc(r);
ans -= calc(l - 1);
PL(ans);
}
return 0;
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.