solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int tc = 1;
cin >> tc;
while (tc--) {
long long int n;
cin >> n;
long long int a[n], i;
long long int p = 0, m = 0, z = 0;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
if (a[i] > 0)
cout << a[i] << " ";
else
cout << a[i] * (-1) << " ";
} else {
if (a[i] > 0)
cout << a[i] * (-1) << " ";
else
cout << a[i] << " ";
}
}
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
set<int> adj[200000];
set<int> unvis;
int sz[200000];
int cur = 0;
void dfs(int x) {
sz[cur]++;
auto it = unvis.begin();
while (it != unvis.end()) {
if (adj[x].count(*it)) {
it++;
} else {
int last = *it;
unvis.erase(it);
dfs(last);
it = unvis.upper_bound(last);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].insert(b);
adj[b].insert(a);
}
for (int i = 0; i < n; i++) {
unvis.insert(i);
}
for (int i = 0; i < n; i++) {
auto it = unvis.find(i);
if (it != unvis.end()) {
unvis.erase(it);
dfs(i);
cur++;
}
}
cout << cur << endl;
sort(sz, sz + cur);
for (int i = 0; i < cur; i++) {
cout << sz[i] << ' ';
}
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
vector<int> s(n), l(n), dl(n + 1, 0), ds(n + 1, 0);
for (int i = 1; i < n; i++) cin >> s[i];
for (int i = 1; i < n; i++) cin >> l[i];
ds[2] = s[1];
dl[2] = l[1] + c;
for (int i = 3; i <= n; i++) {
ds[i] = min(dl[i - 1], ds[i - 1]) + s[i - 1];
dl[i] = min(dl[i - 1] - c, ds[i - 1]) + l[i - 1] + c;
}
for (int i = 1; i <= n; i++) cout << min(dl[i], ds[i]) << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
double fRand(double fMin, double fMax) {
double f = (double)rand() / RAND_MAX;
return fMin + f * (fMax - fMin);
}
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
struct line {
int a, b, id;
long long get(int x) { return 1LL * a * x + b; }
bool inline operator<(const line &rhs) const {
return make_tuple(a, b) < make_tuple(rhs.a, rhs.b);
}
};
double inter(line l1, line l2) { return 1.0 * (l1.b - l2.b) / (l2.a - l1.a); }
bool isBad(line l1, line l2) { return (l1.a == l2.a && l1.b <= l2.b); }
bool isBad(line l1, line l2, line l3) {
return (inter(l3, l1) <= inter(l2, l1));
}
line getMax(line a, line b, int x) { return (a.get(x) > b.get(x)) ? a : b; }
void addLine(deque<line> &h, line l) {
int n;
while ((n = (int)h.size()) > 0 && isBad(h[n - 1], l)) h.pop_back();
while ((n = (int)h.size()) > 1 && isBad(h[n - 2], h[n - 1], l)) h.pop_back();
h.push_back(l);
}
line bestLine(deque<line> &h, int x) {
while ((int)h.size() > 1 && h[0].get(x) < h[1].get(x)) h.pop_front();
return h[0];
}
deque<line> combine(deque<line> &h1, deque<line> &h2) {
deque<line> res;
int i = 0, j = 0, n = (int)h1.size(), m = (int)h2.size();
while (i < n && j < m) {
if (h1[i] < h2[j])
addLine(res, h1[i++]);
else
addLine(res, h2[j++]);
}
while (i < n) addLine(res, h1[i++]);
while (j < m) addLine(res, h2[j++]);
return res;
}
struct IT {
private:
vector<deque<line> > t;
int n;
void build(int id, int l, int r, line a[]) {
if (l == r) {
addLine(t[id], a[l]);
return;
}
int m = (l + r) / 2;
build(2 * id, l, m, a);
build(2 * id + 1, m + 1, r, a);
t[id] = combine(t[2 * id], t[2 * id + 1]);
}
line query(int id, int l, int r, int i, int j, int x) {
if (l > j || r < i) return {0, 0, -1};
if (i <= l && r <= j) return bestLine(t[id], x);
int m = (l + r) / 2;
return getMax(query(2 * id, l, m, i, j, x),
query(2 * id + 1, m + 1, r, i, j, x), x);
}
public:
IT(int n, line a[]) : n(n) {
t.assign(4 * n + 1, deque<line>());
build(1, 1, n, a);
}
int query(int l, int r, int x) { return query(1, 1, n, l, r, x).id; }
};
struct Query {
int l, r, t, id;
bool inline operator<(const Query &rhs) const { return t < rhs.t; }
};
const int MAXN = 1e5 + 5;
int n, q, ans[MAXN];
line a[MAXN];
Query Q[MAXN];
int main() {
scanf("%d%d", &n, &q);
for (int i = (1); i <= (n); ++i) {
scanf("%d%d", &a[i].b, &a[i].a);
a[i].id = i;
}
IT t(n, a);
for (int i = (1); i <= (q); ++i) {
scanf("%d%d%d", &Q[i].l, &Q[i].r, &Q[i].t);
Q[i].id = i;
}
sort(Q + 1, Q + q + 1);
for (int i = (1); i <= (q); ++i)
ans[Q[i].id] = t.query(Q[i].l, Q[i].r, Q[i].t);
for (int i = (1); i <= (q); ++i) printf("%d\n", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
char a[580][580];
int m, n;
scanf("%d%d", &n, &m);
int minx = 600, miny = 600, maxx = -1, maxy = -1, flag = 0;
for (int i = 0; i < n; i++) {
scanf("%s", a[i]);
for (int j = 0; j < m; j++)
if (a[i][j] == 'X') {
flag++;
if (i < minx) minx = i;
if (i > maxx) maxx = i;
if (j < miny) miny = j;
if (j > maxy) maxy = j;
}
}
if ((maxx - minx + 1) * (maxy - miny + 1) == flag)
printf("YES\n");
else
printf("NO\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void slove(int n) {
if (n == 1) {
int x;
cin >> x;
if (x != 0)
cout << "BitLGM" << '\n';
else
cout << "BitAryo" << '\n';
} else if (n == 2) {
int x, y;
cin >> x >> y;
if (x > y) swap(x, y);
int k = y - x;
double t = (1 + sqrt(5)) / 2;
int c = k * t;
if (c == x)
cout << "BitAryo" << '\n';
else
cout << "BitLGM" << '\n';
} else {
int ans = 0;
for (int i = 0; i < 3; i++) {
int x;
cin >> x;
ans ^= x;
}
if (ans != 0)
cout << "BitLGM" << '\n';
else
cout << "BitAryo" << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
slove(n);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, i, j, a[100], ans = -1, x = 0, y = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1)
x++;
else
y++;
}
for (i = 1; i <= n; i++) {
long long int c1 = 0;
long long int c0 = 0;
if (i % k)
j = i % k - 1;
else
j = k - 1;
for (; j < n; j += k) {
if (a[j] == 1)
c1++;
else
c0++;
}
ans = max(ans, abs(x - c1 - y + c0));
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
char a[maxn];
int N, cnt[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> (a + 1);
N = strlen(a + 1);
int last_hash = 0;
vector<int> ans;
for (int i = 1; i <= N; ++i)
if (a[i] == '#') last_hash = i;
for (int i = 1; i <= N; ++i) {
cnt[i] += cnt[i - 1];
if (a[i] == '(') ++cnt[i];
if (a[i] == ')') --cnt[i];
if (a[i] == '#') --cnt[i];
if (cnt[i] < 0) {
cout << -1 << endl;
exit(0);
}
if (a[i] == '#') {
if (i < last_hash) ans.push_back(1);
}
}
ans.push_back(cnt[N] + 1);
int pos = 0;
for (int i = 1; i <= N; ++i) {
cnt[i] = 0;
cnt[i] += cnt[i - 1];
if (a[i] == '(') ++cnt[i];
if (a[i] == ')') --cnt[i];
if (a[i] == '#') {
cnt[i] -= ans[pos];
++pos;
}
if (cnt[i] < 0) {
cout << -1 << endl;
exit(0);
}
}
if (cnt[N] > 0) {
cout << -1 << endl;
exit(0);
}
for (int i : ans) cout << i << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool isOn[1000010] = {0};
void solve() {
long long n, m, k;
cin >> n >> m >> k;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
isOn[a[i]] = 1;
}
if (k == 1) {
cout << n << "\n";
return;
}
sort(a, a + n);
long long i1 = 0, i2 = 0;
long long ans = 0;
long long cnt = 0;
while (i1 < n and i2 < n) {
while (i2 < n and (a[i2] - a[i1] + 1) <= m) {
if (isOn[a[i2]]) {
cnt++;
if (cnt == k) {
isOn[a[i2]] = 0;
ans++;
cnt--;
}
}
i2++;
}
if (isOn[a[i1]]) cnt--;
i1++;
}
cout << ans << "\n";
}
int main() {
cin.sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
int data[120][120];
vector<int> v;
long long int m;
inline void solve() {
cin >> n;
for (long long int i = (0); i < (n); i++) {
for (long long int j = (0); j < (n); j++) {
scanf("%d", &data[i][j]);
}
}
long long int counte = 0;
for (long long int i = (0); i < (n); i++) {
int flag = 0;
for (long long int j = (0); j < (n); j++) {
if (data[i][j] == 1 || data[i][j] == 3) {
flag = 1;
break;
}
}
if (!flag) {
counte++;
v.push_back(i + 1);
}
}
cout << counte << endl;
for (long long int i = (0); i < (v.size()); i++) cout << v[i] << " ";
}
int main() {
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> my;
int main() {
int n, r1 = 0;
cin >> n;
string s;
cin >> s;
int l = s.length();
for (int i = 0; i < l; i++) {
for (int j = i; j < l; j++) {
r1 += s[j] - '0';
my[r1]++;
}
r1 = 0;
}
if (n == 0) {
cout << 2 * (my[0] * (l * (l + 1) / 2)) - my[0] * my[0] << endl;
return 0;
}
long long res = 0;
for (map<long long, long long>::iterator it = my.begin(); it != my.end();
it++) {
if ((it->first) && n % (it->first) == 0)
res += my[it->first] * my[n / (it->first)];
}
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct obj {
long long ind;
long long x;
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, k;
cin >> n >> k;
vector<obj> a(n);
for (long long i = 0; i < n; ++i) {
cin >> a[i].x;
a[i].ind = i;
}
vector<vector<long long>> indxx(n);
for (long long i = 0; i < n; ++i) {
indxx[a[i].x].push_back(a[i].ind);
}
if (indxx[0].size() > 1) {
cout << "-1";
return 0;
}
long long el = 0;
for (long long i = 1; i < n; ++i) {
if (indxx[i].size() > (indxx[i - 1].size() * (k - el))) {
cout << "-1";
return 0;
}
el = 1;
}
vector<vector<long long>> adj(n);
long long p = 0, c = 1, pi = 0, ci = 0, e = 0;
el = 0;
while (e < n - 1) {
long long cnt = 0;
while ((e < n - 1) && (cnt < (k - el)) && (ci < indxx[c].size())) {
adj[indxx[p][pi]].push_back(indxx[c][ci]);
++e;
++ci;
++cnt;
}
if (ci < indxx[c].size()) {
++pi;
continue;
} else {
++p, pi = 0, ++c, ci = 0;
}
el = 1;
}
cout << n - 1 << "\n";
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < adj[i].size(); ++j) {
cout << i + 1 << " " << adj[i][j] + 1 << "\n";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long arr = 5e5 + 100;
const long long md = 1e9 + 7;
const long long base = 1e9 + 7;
long long cnt[100];
string getmax() {
string res = "";
for (long long i = 0; i <= 9; i++) {
long long c = cnt[i];
while (c--) {
res += i + '0';
}
}
return (res);
}
bool ok(string st1, string st2) {
if (st1.size() < st2.size())
return (1);
else
return (st1 <= st2);
}
signed main() {
string a, b;
cin >> a >> b;
for (long long i = 0; i < a.size(); i++) cnt[a[i] - '0']++;
string ans = "";
for (long long i = 0; i < a.size(); i++) {
char mx = '0';
for (long long j = 0; j < 10; j++)
if (cnt[j] != 0) {
cnt[j]--;
string now = ans;
now += char(j + '0');
now += getmax();
if (ok(now, b)) mx = j + '0';
cnt[j]++;
}
cnt[mx - '0']--;
ans += mx;
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, ans = 0;
cin >> n;
vector<int> A(n), App(n + 1, 0);
vector<bool> Not_changed(n + 1, true);
for (int i = 0; i < n; i++) {
cin >> A[i];
App[A[i]]++;
}
queue<int> Q;
for (int i = 1; i <= n; i++)
if (App[i] == 0) {
Q.push(i);
ans++;
}
Q.push((1 << 30));
for (int i = 0; i < n; i++)
if (App[A[i]] > 1) {
if (!Not_changed[A[i]] || Q.front() < A[i]) {
App[A[i]]--;
A[i] = Q.front();
Q.pop();
} else
Not_changed[A[i]] = false;
}
cout << ans << endl;
for (int i = 0; i < n; i++) cout << A[i] << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e9 + 7;
const int inf = 1 << 30;
string s;
long long dp[2005][4005];
long long DP[2005][4005];
int n, m, in, inB = inf;
long long mod(long long x) { return (x + Mod) % Mod; }
long long F(int pos, int tapawut) {
if (tapawut > 0) return 0;
if (pos > n) return (tapawut == 0);
long long &res = DP[pos - m][-tapawut];
if (~res) return res;
res = 0;
res = mod(res + F(pos + 1, tapawut + 1));
res = mod(res + F(pos + 1, tapawut - 1));
return res;
}
long long Solution(int pos, int tapawut) {
if (pos > n - m + 1 || tapawut < 0) return 0;
long long &res = dp[pos][tapawut];
if (~res) return res;
res = 0;
if (tapawut + inB >= 0) res = mod(F(pos + m, -(tapawut + in)));
res = mod(res + Solution(pos + 1, tapawut + 1));
res = mod(res + Solution(pos + 1, tapawut - 1));
return res;
}
int main() {
scanf("%d%d", &n, &m);
cin >> s;
for (int i = 0; i < m; i++) {
in += (s[i] == '(');
in -= (s[i] == ')');
inB = min(inB, in);
}
if (in > 2000 || in < -2000) {
puts("0");
exit(0);
}
memset(DP, -1, sizeof(DP));
memset(dp, -1, sizeof(dp));
long long ans = Solution(1, 0);
printf("%lld", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500010;
int tt = 1;
bool w[N], c[N];
int head[N], to[N], nxt[N], in[N], a[N], b[N], v[N];
inline int gi() {
int x = 0, o = 1;
char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
inline void lnk(int x, int y) {
++in[x], ++in[y];
to[++tt] = y, nxt[tt] = head[x], head[x] = tt;
to[++tt] = x, nxt[tt] = head[y], head[y] = tt;
}
inline void dfs(int x) {
for (int &i = head[x]; i; i = nxt[i])
if (!w[i]) {
w[i] = w[i ^ 1] = 1, c[i] = 1;
dfs(to[i]);
}
}
int main() {
int n, tp = 0;
cin >> n;
for (int i = 1; i <= n; i++) a[i] = v[++tp] = gi(), b[i] = v[++tp] = gi() + 1;
sort(v + 1, v + 1 + tp);
tp = unique(v + 1, v + 1 + tp) - v - 1;
for (int i = 1; i <= n; i++) {
int x, y;
x = lower_bound(v + 1, v + 1 + tp, a[i]) - v;
y = lower_bound(v + 1, v + 1 + tp, b[i]) - v;
lnk(x, y);
}
for (int i = 1, x = 0; i <= tp; i++)
if (in[i] & 1) {
if (x)
lnk(x, i), x = 0;
else
x = i;
}
for (int i = 1; i <= tp; i++)
if (head[i]) dfs(i);
for (int i = 1; i <= n; i++) printf("%d ", c[i << 1]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int n, m, a[N], b[N], x, Ans;
long long s[N], s1[N];
void check(long long sx, int len) {
for (int l = 1, r = 0; r < m; l++) {
while (r < m && sx * (s1[r + 1] - s1[l - 1]) <= x) r++;
Ans = max(Ans, len * (r - l + 1));
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
cin >> x;
if (n > m) swap(n, m), swap(a, b);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
for (int i = 1; i <= m; i++) s1[i] = s1[i - 1] + b[i];
for (int i = 1; i <= n; i++) {
long long sum = 1e18;
for (int j = 1; j <= n - i + 1; j++)
sum = min(sum, s[j + i - 1] - s[j - 1]);
check(sum, i);
}
printf("%d\n", Ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int T;
int dp[N][3];
int dpar[N];
int find_depth(int node, int par, vector<int> G[]) {
if (G[node].size() == 1 && par != node) return 0;
for (auto it : G[node]) {
if (it != par) {
int cur = find_depth(it, node, G) + 1;
if (cur > dp[node][2]) {
dp[node][2] = cur;
sort(dp[node], dp[node] + 3, greater<int>());
}
}
}
return dp[node][0];
}
void find_depth_from_par(int node, int par, vector<int> G[], int root) {
if (node != root) {
if (dp[par][0] == dp[node][0] + 1)
dpar[node] = dp[par][1] + 1;
else
dpar[node] = dp[par][0] + 1;
if (dpar[node] > dp[node][2]) {
dp[node][2] = dpar[node];
sort(dp[node], dp[node] + 3, greater<int>());
}
}
for (auto it : G[node])
if (it != par) find_depth_from_par(it, node, G, root);
}
int find_size(int node, int par, vector<int> G[], int root, int tar) {
if (node == tar) return 0;
int cur = -1;
for (auto it : G[node]) {
if (it != par) cur = max(cur, find_size(it, node, G, root, tar));
}
if (cur == -1)
return -1;
else
return cur + 1;
}
int find_par_depth_son(int node, int pa, vector<int> G[], int deepness,
int par[], int depth[], int son[]) {
par[node] = pa;
depth[node] = deepness;
son[node] = -1;
int cur = 0;
for (auto it : G[node]) {
if (it != pa) {
int here =
find_par_depth_son(it, node, G, deepness + 1, par, depth, son) + 1;
if (here > cur) {
son[node] = it;
cur = here;
}
}
}
return cur;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> T;
while (T--) {
int n, a, b, i, j, des = -1;
cin >> n >> a >> b;
a--, b--;
vector<int> G[n];
for (j = 0; j < n; j++)
for (i = 0; i < 3; i++) dp[j][i] = 0;
for (i = 0; i < n; i++) dpar[i] = 0;
for (i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--, y--;
G[x].push_back(y);
G[y].push_back(x);
}
find_depth(0, 0, G);
find_depth_from_par(0, 0, G, 0);
int siz = find_size(a, a, G, a, b) + 1;
for (i = 0; i < n; i++) {
if (dp[i][2] >= siz - 1) des = i;
}
if (des == -1)
cout << "NO\n";
else {
int par[n];
int depth[n];
int son[n];
map<int, int> mphead;
map<int, int> mptail;
find_par_depth_son(des, des, G, 0, par, depth, son);
int head = a, tail = b, maxi = -1;
bool pass = false;
bool hea = true;
while (true) {
while (son[head] != -1) {
tail = par[tail];
head = son[head];
}
if (depth[head] - depth[tail] >= siz - 1) {
pass = true;
break;
}
if (hea) {
if (mphead.count(depth[head]))
break;
else
mphead.insert({depth[head], 0});
} else {
if (mptail.count(depth[head]))
break;
else
mptail.insert({depth[head], 0});
}
swap(head, tail);
if (hea)
hea = false;
else
hea = true;
}
if (pass)
cout << "YES\n";
else
cout << "NO\n";
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int l, r;
cin >> l >> r;
for (int i = l; i <= r; ++i) {
int a = i, len = 0;
set<int> S;
while (a > 0) {
S.insert(a % 10);
a /= 10;
++len;
}
if (S.size() == len) {
cout << i << '\n';
return;
}
}
cout << "-1\n";
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void yes(long long i) {
cout << "YES"
<< "\n"
<< i << "\n";
exit(0);
}
void no() {
cout << "NO"
<< "\n";
exit(0);
}
int main() {
std::ios::sync_with_stdio(false);
string s;
cin >> s;
for (int i = 0; i < 1000; i += 8) {
long long current = (i % 10) + '0';
long long t = i;
bool once = false;
for (int j = s.size() - 1; j >= 0; j--) {
if (s[j] == current) {
t /= 10;
once = true;
current = (t % 10) + '0';
}
}
if (t == 0 && once) yes(i);
}
no();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
signed main() {
long long n, m;
cin >> n >> m;
double ans = 0.0;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long x, y, c;
for (long long i = 0; i < m; i++) {
cin >> x >> y >> c;
x--;
y--;
ans = max(ans, (double)(a[x] + a[y]) / c);
}
cout << setprecision(16) << fixed << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << '\n';
err(++it, args...);
}
template <typename A, typename B>
string to_string(pair<A, B> p);
string to_string(const string& second) { return '"' + second + '"'; }
string to_string(const char* second) { return to_string((string)second); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
int a[200005];
bool b[200005], c[200005];
vector<long long> e[200005];
long long res;
pair<long long, long long> dfs(long long x, long long par, long long minn) {
long long rem, sum = 1;
pair<long long, long long> tmp;
pair<long long, long long> cnt;
if (b[x] > c[x])
cnt.first++;
else if (b[x] < c[x])
cnt.second++;
minn = min(minn, (long long)a[x]);
for (auto p : e[x]) {
if (p == par) continue;
tmp = dfs(p, x, minn);
cnt.first += tmp.first;
cnt.second += tmp.second;
}
if (a[x] == minn) {
rem = min(cnt.first, cnt.second);
res += (rem * 2 * a[x]);
cnt.first -= rem;
cnt.second -= rem;
}
return cnt;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, n, q, prev, maxx, i, j, k1, k2, k3, k, x, y, flag, sum, cnt, ans,
minn, cur;
cin >> n;
k1 = k2 = 0;
res = 0;
for (i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
if (b[i] > c[i]) k1++;
if (b[i] < c[i]) k2++;
}
if (k1 != k2) {
cout << "-1\n";
return 0;
}
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
x--;
y--;
e[x].push_back(y);
e[y].push_back(x);
}
dfs(0, -1, 1e9 + 5);
cout << res << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int N = 510;
using namespace std;
char s[N][N];
int a[N][N];
int top_to_down[N][N];
int left_to_right[N][N];
int main() {
int n, m, k;
int i, j;
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < n; i++) scanf("%s", s[i]);
if (n < 3 || m < 3) {
printf("0\n");
return 0;
}
memset(a, 0, sizeof(a));
for (i = 1; i < n - 1; i++) {
for (j = 1; j < m - 1; j++) {
if (s[i][j] == '1' && s[i][j + 1] == '1' && s[i + 1][j] == '1' &&
s[i - 1][j] == '1' && s[i][j - 1] == '1')
a[i][j] = 1;
}
}
n -= 2;
m -= 2;
memset(top_to_down, 0, sizeof(top_to_down));
memset(left_to_right, 0, sizeof(left_to_right));
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
left_to_right[i][j] = left_to_right[i][j - 1] + a[i][j];
top_to_down[i][j] = top_to_down[i - 1][j] + a[i][j];
}
long long ans = 0;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
int len = 1;
int pos = j;
int tmp = a[i][j];
while (i + len - 1 <= n) {
while (tmp >= k && pos >= j) {
tmp -= top_to_down[i + len - 1][pos] - top_to_down[i - 1][pos];
pos--;
}
while (tmp < k && pos + 1 <= m) {
tmp +=
top_to_down[i + len - 1][pos + 1] - top_to_down[i - 1][pos + 1];
pos++;
}
if (tmp >= k) ans += (m - pos + 1);
tmp += left_to_right[i + len][pos] - left_to_right[i + len][j - 1];
len++;
}
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[100005];
int cnt = 0;
void solve() {
int n;
cin >> n;
for (int i = 1; i <= 2 * n; i++) {
cin >> arr[i];
}
for (int i = 1; i <= 2 * n; i += 2) {
for (int j = i + 1; j <= 2 * n; j++) {
if (arr[j] == arr[i]) {
for (int k = j; k > i + 1; k--) {
arr[k] = arr[k - 1];
cnt++;
}
arr[i + 1] = arr[i];
break;
}
}
}
cout << cnt << endl;
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100005];
int n, dep[100005];
void dfs(int x, int p) {
for (auto &i : graph[x]) {
if (i == p) continue;
dep[i] = dep[x] + 1;
dfs(i, x);
}
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int s, e;
scanf("%d %d", &s, &e);
graph[s].push_back(e);
graph[e].push_back(s);
}
dep[1] = 1;
dfs(1, 0);
double ret = 0;
for (int i = 1; i <= n; i++) {
ret += 1.0 / dep[i];
}
printf("%.10f", ret);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 250005;
using lint = long long;
using pi = pair<int, int>;
int n, mod;
lint fact[MAXN];
int main() {
fact[0] = 1;
cin >> n >> mod;
for (int i = 1; i <= n; i++) fact[i] = fact[i - 1] * i % mod;
lint ret = 0;
for (int i = 1; i <= n; i++) {
ret += (n - i + 1) * (fact[i] * fact[n - i + 1] % mod);
ret %= mod;
}
cout << ret << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1507;
int n;
long long a[maxn];
struct node {
int l, r;
long long sum;
node() {}
node(int a, int b, long long c) { l = a, r = b, sum = c; }
bool operator<(const node &a) const { return r < a.r; }
};
map<long long, vector<node> > mp, ans;
map<long long, vector<node> >::iterator it;
long long ss[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
ss[i] = a[i] + ss[i - 1];
}
for (int i = 1; i <= n; i++) {
for (int l = 0, r = l + i; r <= n; l++, r++) {
long long tmp = ss[r] - ss[l];
mp[tmp].push_back(node(l + 1, r, tmp));
}
}
long long ansval = 0, cnt = 0;
for (it = mp.begin(); it != mp.end(); it++) {
sort(it->second.begin(), it->second.end());
int tmp = 0, tim = 0;
for (int i = 0; i < it->second.size(); i++) {
if (it->second[i].l > tim) {
ans[it->first].push_back(it->second[i]);
tmp++, tim = it->second[i].r;
}
}
if (tmp > cnt) cnt = tmp, ansval = it->first;
}
printf("%d\n", cnt);
for (int i = 0; i < cnt; i++)
printf("%d %d\n", ans[ansval][i].l, ans[ansval][i].r);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 5e5 + 50;
const long long ninf = -1e9;
const long long mod = 1e9 + 7;
long long bit[inf];
long long n;
void update(long long i) {
while (i <= n + 5) {
bit[i] += 1;
i += (i & (-i));
}
}
long long query(long long i) {
long long sum = 0;
while (i > 0) {
sum += bit[i];
i -= (i & (-i));
}
return sum;
}
void solve() {
long long k, d;
cin >> n >> k >> d;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
sort((a).begin(), (a).end());
vector<long long> dp(n + 5, 0);
dp[0] = 1;
update(1);
long long lft = 0;
for (long long i = 0; i < n; i++) {
while (lft < i && a[i] - a[lft] > d) {
lft++;
}
if (i - k + 2 >= lft)
dp[i + 1] = (query(i - k + 2) - query(lft)) >= 1 ? 1 : 0;
if (dp[i + 1]) {
update(i + 2);
}
}
if (dp[n]) {
cout << "YES";
} else
cout << "NO";
cout << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T = 1;
while (T--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n - 1; ++i) {
string q;
cin >> q;
int j = 0;
while (s[j] == q[j] and j < s.size()) ++j;
if (j != s.size()) s = s.substr(0, j);
}
cout << s.size() << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
const long double pi = acos(-1.0);
const int_fast64_t mod = 1e9 + 7;
struct pr {
int_fast64_t x;
int_fast64_t y;
int_fast64_t dst;
pr() {}
pr(int_fast64_t x, int_fast64_t y, int_fast64_t dst) : x(x), y(y), dst(dst) {}
inline bool operator<(const pr& cmp2) const {
if (dst != cmp2.dst) return dst < cmp2.dst;
if (x != cmp2.x) return x < cmp2.x;
return y < cmp2.y;
}
inline bool operator==(const pr& cmp2) const {
return (cmp2.dst == dst) && (cmp2.x == x) && (cmp2.y == y);
}
inline bool operator>(const pr& cmp2) const {
if (dst != cmp2.dst) return dst > cmp2.dst;
if (x != cmp2.x) return x > cmp2.x;
return y > cmp2.y;
}
};
struct point {
int_fast64_t x;
int_fast64_t y;
point() {}
point(int_fast64_t x, int_fast64_t y) : x(x), y(y) {}
inline bool operator<(const point& cmp2) const {
if (cmp2.x != x) return cmp2.x < x;
return cmp2.y < y;
}
inline bool operator==(const point& cmp2) const {
return (cmp2.x == x) && (cmp2.y == y);
}
inline bool operator>(const point& cmp2) const {
if (cmp2.x != x) return cmp2.x > x;
return cmp2.y > y;
}
};
namespace std {
template <typename T>
struct hash<vector<T> > {
size_t operator()(const vector<T>& k) const {
size_t ret = 0xf3ee477d;
for (size_t i = 0; i != k.size(); ++i) ret ^= hash(hash(k[i]) + i);
return ret;
}
};
template <>
struct hash<pr> {
size_t operator()(const pr& cmp1) const {
return (hash<int_fast64_t>()(cmp1.x)) ^ (hash<int_fast64_t>()(cmp1.y)) ^
(hash<int_fast64_t>()(cmp1.dst));
}
};
template <>
struct hash<point> {
size_t operator()(const point& cmp1) const {
return (hash<int_fast64_t>()(cmp1.x)) ^ (hash<int_fast64_t>()(cmp1.y));
}
};
} // namespace std
inline bool spoint(const point& cmp1, const point& cmp2) {
if (cmp1.x != cmp2.x) return cmp1.x < cmp2.x;
return cmp1.y < cmp2.y;
}
inline bool spr(const pr& cmp1, const pr& cmp2) {
if (cmp1.dst != cmp2.dst) return cmp1.dst < cmp2.dst;
if (cmp1.x != cmp2.x) return cmp1.x < cmp2.x;
return cmp1.y < cmp2.y;
}
void sub() {
int_fast64_t n, x;
cin >> n >> x;
if (n <= x) {
cout << n * (n - 1) / 2 + 1 << endl;
} else
cout << x * (x + 1) / 2 << endl;
}
void solve() {
int_fast64_t t;
cin >> t;
while (t--) sub();
}
void init() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
srand(time(0));
}
int main() {
init();
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
long long mod = 1000000007LL;
long long mod2 = 998244353LL;
int n, m, k;
int main() {
cin >> n >> m >> k;
bool ok = false;
for (int i = 1; i <= k; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (abs(x - 1) <= 4 || abs(x - n) <= 4 || abs(y - 1) <= 4 ||
abs(y - m) <= 4) {
ok = true;
}
}
if (ok)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
const int MAXA = 20;
const long double PI = acos(-1.0);
int N, M;
pair<long long, long long> pt[MAXN];
long double pdist[MAXN];
long double pang[MAXN];
long double hlo[MAXN], hhi[MAXN];
long double nhi[MAXN];
int nnext[2 * MAXN];
long long njump[MAXN][MAXA];
bool works(long double d) {
for (int i = 0; i < N; i++) {
long double v = acos(d / pdist[i]);
hlo[i] = pang[i] - v;
if (hlo[i] <= -PI) hlo[i] += 2 * PI;
hhi[i] = pang[i] + v;
if (hhi[i] >= PI) hhi[i] -= 2 * PI;
nhi[i] = hhi[i];
}
sort(nhi, nhi + N);
for (int i = 0; i < 2 * N; i++) nnext[i] = i - N;
for (int i = 0; i < N; i++) {
int xloc = lower_bound(nhi, nhi + N, hhi[i]) - nhi;
int yloc;
if (hlo[i] >= nhi[N - 1])
yloc = 0;
else
yloc = lower_bound(nhi, nhi + N, hlo[i]) - nhi;
yloc--;
if (yloc >= xloc) yloc -= N;
nnext[xloc] = max(nnext[xloc], yloc);
}
for (int i = 0; i < N; i++) nnext[i + N] = nnext[i] + N;
for (int i = 1; i < 2 * N; i++) {
nnext[i] = max(nnext[i], nnext[i - 1]);
}
for (int i = 0; i < N; i++) {
njump[i][0] = i + N - nnext[i + N];
}
for (int i = 1; i < MAXA; i++) {
for (int j = 0; j < N; j++) {
int nv = (j - njump[j][i - 1]) % N;
if (nv < 0) nv += N;
njump[j][i] = njump[j][i - 1] + njump[nv][i - 1];
}
}
for (int i = 0; i < N; i++) {
int cloc = i;
long long cjump = 0;
for (int j = 0; j < MAXA; j++) {
if (M & (1 << j)) {
cjump += njump[cloc][j];
cloc -= njump[cloc][j];
cloc %= N;
if (cloc < 0) cloc += N;
}
}
if (cjump >= N) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> N >> M;
for (int i = 0; i < N; i++) cin >> pt[i].first >> pt[i].second;
cout << fixed << setprecision(9);
long double dlo = 1e9;
for (int i = 0; i < N; i++) {
if (pt[i].first == 0 && pt[i].second == 0) {
cout << 0. << "\n";
return 0;
}
pdist[i] = sqrt(pt[i].first * pt[i].first + pt[i].second * pt[i].second);
pang[i] = atan2(pt[i].second, pt[i].first);
dlo = min(dlo, pdist[i]);
}
long double lo = 0.0, hi = dlo;
for (int run = 0; run < 50; run++) {
long double mid = (lo + hi) / 2;
if (works(mid)) {
lo = mid;
} else
hi = mid;
}
cout << lo << "\n";
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2100000;
const int mod = 998244353;
int n;
long long jc[Maxn], ans;
long long powp(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long C(int x, int y) {
return jc[x] * powp(jc[y], mod - 2) % mod * powp(jc[x - y], mod - 2) % mod;
}
int main() {
scanf("%d", &n);
jc[0] = 1;
for (int i = 1; i <= n; i++) jc[i] = jc[i - 1] * i % mod;
for (int i = 0; i <= n; i++)
ans = (ans + C(n, i) * (jc[i] - 1) % mod * jc[n - i] % mod) % mod;
ans = (ans + 1) % mod;
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long maxn = 2005;
const long long inf = 1ll << 50;
int mp[10] = {119, 36, 93, 109, 46, 107, 123, 37, 127, 111};
long long disp[maxn], ans[maxn];
long long dp[maxn][maxn];
long long n, k;
bool is_possible(int index, int rem) {
if (rem < 0) {
return false;
}
if (index == n) {
return rem == 0;
}
if (dp[index][rem] != -1) {
return dp[index][rem];
}
bool res = false;
for (int i = 9; i >= 0; i--) {
bool test = ((mp[i] & disp[index]) != disp[index]);
if (test) continue;
auto calculate_loss = [](long long a, long long b) {
return __builtin_popcount(a ^ b);
};
long long loss = calculate_loss(disp[index], mp[i]);
if (is_possible(index + 1, rem - loss)) {
res = true;
break;
}
}
return dp[index][rem] = res;
}
void get_largest_number(int index, int rem) {
if (index == n) {
return;
}
for (int i = 9; i >= 0; i--) {
bool test = ((mp[i] & disp[index]) != disp[index]);
if (test) continue;
auto calculate_loss = [](long long a, long long b) {
return __builtin_popcount(a ^ b);
};
long long loss = calculate_loss(disp[index], mp[i]);
if (is_possible(index + 1, rem - loss)) {
ans[index] = i;
get_largest_number(index + 1, rem - loss);
return;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(dp, -1, sizeof(dp));
cin >> n >> k;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
reverse(str.begin(), str.end());
disp[i] = bitset<7>(str).to_ullong();
}
if (is_possible(0, k)) {
get_largest_number(0, k);
for (int i = 0; i < n; i++) {
cout << ans[i];
}
} else {
cout << -1 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long kol;
int main() {
long long n, w, h, back;
cin >> n >> w >> h;
back = max(w, h);
for (int i = 2; i <= n; i++) {
long long w, h;
cin >> w >> h;
if (kol == 0 && w <= back && h <= back) {
kol--;
back = max(w, h);
}
if (w <= back && h > back && kol == 0 || w > h && h <= back && kol == 0) {
if (w <= back)
back = w;
else
back = h;
kol--;
}
kol++;
}
if (kol == 0)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
// #include <atcoder/all>
// #include <bits/stdc++.h>
#include <complex>
#include <queue>
#include <set>
#include <unordered_set>
#include <list>
#include <chrono>
#include <random>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <stack>
#include <iomanip>
#include <fstream>
using namespace std;
// using namespace atcoder;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> p32;
typedef pair<ll, ll> p64;
typedef pair<p64, p64> pp64;
typedef pair<double, double> pdd;
typedef vector<ll> v64;
typedef vector<int> v32;
typedef vector<vector<int>> vv32;
typedef vector<vector<ll>> vv64;
typedef vector<vector<p64>> vvp64;
typedef vector<p64> vp64;
typedef vector<p32> vp32;
ll MOD = 1e9 + 7;
double eps = 1e-12;
#define forn(i, e) for (ll i = 0; i < e; i++)
#define forsn(i, s, e) for (ll i = s; i < e; i++)
#define rforn(i, s) for (ll i = s; i >= 0; i--)
#define rforsn(i, s, e) for (ll i = s; i >= e; i--)
#define ln '\n'
#define dbg(x) cout << #x << " = " << x << ln
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define INF 2e18
#define fast_cin() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((ll)(x).size())
#define zero ll(0)
#define set_bits(x) __builtin_popcountll(x)
// #define mint modint998244353
ll mpow(ll a, ll b)
{
if (a == 0)
return 0;
if (b == 0)
return 1;
ll t1 = mpow(a, b / 2);
t1 *= t1;
t1 %= MOD;
if (b % 2)
t1 *= a;
t1 %= MOD;
return t1;
}
ll mpow(ll a, ll b, ll p)
{
if (a == 0)
return 0;
if (b == 0)
return 1;
ll t1 = mpow(a, b / 2, p);
t1 *= t1;
t1 %= p;
if (b % 2)
t1 *= a;
t1 %= p;
return t1;
}
ll modinverse(ll a, ll m)
{
ll m0 = m;
ll y = 0, x = 1;
if (m == 1)
return 0;
while (a > 1)
{
ll q = a / m;
ll t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0)
x += m0;
return x;
}
mt19937_64 mt(chrono::steady_clock::now().time_since_epoch().count());
ll range(ll l, ll r)
{
return l + mt() % (r - l + 1);
}
ll rev(ll v)
{
return mpow(v, MOD - 2);
}
int LIM = 2e5 + 100;
vv64 adj(LIM);
v64 fib(1000, 1);
v64 S(LIM, 0);
vp64 edges(1);
v64 active(1);
int N;
int node;
void dfs(int n, int pa, int &idx, int k)
{
S[n] = 1;
for (int c : adj[n])
{
if (active[c] == 0)
continue;
p64 temp = edges[c];
int v;
if (temp.fi == n)
v = temp.se;
else
v = temp.fi;
if (v == pa)
continue;
dfs(v, n, idx, k);
if (S[v] == fib[k - 1] || S[v] == fib[k - 2])
{
idx = c;
node = v;
}
S[n] += S[v];
}
}
bool check(int n, int k)
{
if (k <= 2)
return true;
int idx = -1;
dfs(n, -1, idx, k);
// cout << "a" << endl;
if (idx == -1)
return false;
active[idx] = 0;
int u = edges[idx].fi, v = edges[idx].se;
if (u == node)
swap(u, v);
// cout << n << " " << u << " " << v << endl;
int k1, k2;
k1 = k - 1;
k2 = k - 2;
if (S[v] == fib[k - 1])
swap(k1, k2);
bool f1 = check(u, k1), f2 = check(v, k2);
return f1 && f2;
}
void solve()
{
ll n;
cin >> n;
N = n;
for (int i = 1; i < n; i++)
{
int u, v;
cin >> u >> v;
edges.push_back({u, v});
active.push_back(1);
adj[u].push_back(i);
adj[v].push_back(i);
}
int k = -1;
for (int i = 1; i < 1000; i++)
{
if (fib[i] == n)
{
k = i;
break;
}
}
if (k == -1)
{
cout << "NO" << endl;
return;
}
if (check(1, k))
{
cout << "YES" << endl;
}
else
{
cout << "NO" << endl;
}
}
int main()
{
fast_cin();
ll t = 1;
for (int i = 2; i < 50; i++)
{
fib[i] = fib[i - 1] + fib[i - 2];
}
// cin >> t;
forn(i, t)
{
// cout << "Case #" << i+1 << ": ";
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e6 + 100;
const int mod = (int)1e9 + 7;
const int maxlog = (int)20;
const int P = mod;
int n, m, res, ans[maxn];
vector<int> g[maxn], gr[maxn];
set<pair<int, int> > second;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
g[v].push_back(u);
gr[u].push_back(v);
}
res = n;
for (int i = 1; i <= n; i++) {
second.insert(make_pair(gr[i].size(), -i));
}
while (second.size()) {
int v = second.begin()->second;
v = -v;
second.erase(second.begin());
if (ans[v]) continue;
ans[v] = res--;
for (int to : g[v]) {
if (!ans[to]) {
gr[to].erase(gr[to].begin());
second.insert(make_pair(gr[to].size(), -to));
}
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 7 |
#include <bits/stdc++.h>
#define lowbit(x) ((x)&(-(x)))
#define mkp make_pair
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN=3e3+10;
const int MAXM=2e6+10;
const int inf=1e9;
struct Edge
{
int to,nxt,w;
};
int n,S,T,cnt_e=1;
int a[MAXN],b[MAXN];
int head[MAXN],cur_h[MAXN];
int deep[MAXN];
Edge e[MAXM];
inline void addedge(int u,int v,int w)
{
e[++cnt_e].to=v;
e[cnt_e].w=w;
e[cnt_e].nxt=head[u];
head[u]=cnt_e;
}
inline bool bfs()
{
for(int i=1;i<=n+2;i++) cur_h[i]=head[i];
for(int i=1;i<=n+2;i++) deep[i]=-1;
queue<int> q;
q.push(S); deep[S]=1;
while(!q.empty())
{
int u=q.front();
q.pop();
for(int i=head[u];i;i=e[i].nxt)
{
int v=e[i].to,w=e[i].w;
if(deep[v]!=-1 || !w) continue;
deep[v]=deep[u]+1;
q.push(v);
if(v==T) return true;
}
}
return false;
}
inline int dfs(int u,int flow)
{
if(u==T || !flow) return flow;
int res=0;
for(int &i=cur_h[u];i;i=e[i].nxt)
{
int v=e[i].to,w=e[i].w;
if(deep[v]!=deep[u]+1 || !w) continue;
int k=dfs(v,min(flow,w));
if(!k) deep[v]=-1;
e[i].w-=k; e[i^1].w+=k;
flow-=k; res+=k;
if(!flow) break;
}
return res;
}
inline int dinic()
{
int res=0;
while(bfs()) res+=dfs(S,inf);
return res;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
S=n+1; T=n+2;
int sum=0;
for(int i=1;i<=n;i++)
{
scanf("%d",&b[i]);
if(b[i]>0)
{
sum+=b[i];
addedge(S,i,b[i]);
addedge(i,S,0);
}
else
{
addedge(i,T,-b[i]);
addedge(T,i,0);
}
}
static int lst[110];
for(int i=1;i<=n;i++)
{
for(int j=1;j<=100;j++)
if(a[i]%j==0 && lst[j])
{
addedge(i,lst[j],inf);
addedge(lst[j],i,0);
}
lst[a[i]]=i;
}
printf("%d\n",sum-dinic());
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int _inf = 0xc0c0c0c0;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long _INF = 0xc0c0c0c0c0c0c0c0;
const long long mod = (int)1e9 + 7;
const int N = 2e5 + 100;
int n, Q;
int p[N], l[N];
int x[N], y[N];
long long ans[N];
vector<int> q[N];
long long lz[N << 2], seg[N << 2];
void PushDown(int rt) {
if (~lz[rt]) {
lz[rt << 1] = lz[rt << 1 | 1] = lz[rt];
seg[rt << 1] = seg[rt << 1 | 1] = lz[rt];
lz[rt] = -1;
}
}
void PushUp(int rt) { seg[rt] = seg[rt << 1] + seg[rt << 1 | 1]; }
void Updata(int L, int R, long long c, int l, int r, int rt) {
if (L > R) return;
if (L <= l && r <= R) {
lz[rt] = seg[rt] = c;
return;
}
int m = l + r >> 1;
PushDown(rt);
if (L <= m) Updata(L, R, c, l, m, rt << 1);
if (m < R) Updata(L, R, c, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
long long Query(int L, int R, int l, int r, int rt) {
if (L > R) return 0;
if (L <= l && r <= R) return seg[rt];
long long ret = 0;
int m = l + r >> 1;
PushDown(rt);
if (L <= m) ret += Query(L, R, l, m, rt << 1);
if (m < R) ret += Query(L, R, m + 1, r, rt << 1 | 1);
return ret;
}
int Ac() {
memset(lz, -1, sizeof lz);
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", &p[i], &l[i]);
scanf("%d", &Q);
for (int i = 1; i <= Q; ++i) {
scanf("%d%d", &x[i], &y[i]);
q[x[i]].push_back(i);
}
for (int i = n; i >= 1; --i) {
Updata(i, i, inf, 1, n, 1);
int pos = upper_bound(p + 1, p + 1 + n, p[i] + l[i]) - p - 1;
if (pos == n) {
Updata(i + 1, n, 0, 1, n, 1);
} else {
Updata(i + 1, pos, 0, 1, n, 1);
pos++;
long long dif = p[pos] - p[i] - l[i];
if (dif < Query(pos, pos, 1, n, 1)) Updata(pos, pos, dif, 1, n, 1);
}
for (int id : q[i]) {
ans[id] = Query(i + 1, y[id], 1, n, 1);
}
}
for (int i = 1; i <= Q; ++i) {
printf("%lld\n", ans[i]);
}
return 0;
}
int main() {
Ac();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> vprime;
void SieveOfEratosthenes(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p]) vprime.push_back(p);
}
int countFreq(string &pat, string &txt) {
int M = pat.length();
int N = txt.length();
int res = 0;
for (int i = 0; i <= N - M; i++) {
int j;
for (j = 0; j < M; j++)
if (txt[i + j] != pat[j]) break;
if (j == M) {
res++;
j = 0;
}
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long a, b, c, d, e, g, h, k, l, m, n, t, f,
f1 = 0, flag2 = 0, flag = 0, flag1 = 0, co = 0, co1 = 0, co2 = 0, sum = 0,
sum1 = 0, ma = 0, ma1 = 0, ma2 = 0, mi = 100000000000, mi1 = 100000000000,
mi2 = 100, mi3 = 1000;
long long co3 = 0, co4 = 0, co5 = 0, co6 = 0, co7 = 0, co8 = 0, mul = 1,
sum2 = 0;
long long arr[100001] = {0}, arr1[100001] = {0};
long long a1, a2, b1, b2, c1, c2, a3, a4, b3, b4, b5, b6, m1, m2, k1, l1, m3,
m4, d1, d2;
double pi = 2 * acos(0.0);
char ch;
string str, str1, str2, str3, str4, str5;
set<long long> s1;
set<long long> s2;
set<long long> s3;
stack<long long> st;
int x[] = {1, 0, 0, -1};
int y[] = {0, 1, -1, 0};
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
if (n == 1) {
cout << 1 << endl;
return 0;
}
k = 1;
co = 1;
for (int i = 0; i < n; i++) {
for (int j = k; j < n; j++) {
if ((v[j] - v[i]) <= 5) {
co++;
} else {
ma = max(ma, co);
co--;
k = j;
break;
}
}
ma = max(ma, co);
if (ma >= (n - i)) break;
}
cout << ma << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double min[5];
double wrong[5];
double maxScore[5] = {500, 1000, 1500, 2000, 2500};
int success = 0, unsuccess = 0;
for (int i = 0; i < 5; ++i) cin >> min[i];
for (int j = 0; j < 5; ++j) cin >> wrong[j];
double res = 0.0;
for (int k = 0; k < 5; ++k) {
res += max(0.3 * maxScore[k],
(1 - (min[k] / 250.0)) * maxScore[k] - (50.0 * wrong[k]));
}
cin >> success;
cin >> unsuccess;
res += 100 * success;
res -= 50 * unsuccess;
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e6 + 3;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
string a, all;
cin >> a;
for (int i = 0; i < a.size(); i++) {
if (a[i] == '>') all += "1000";
if (a[i] == '<') all += "1001";
if (a[i] == '+') all += "1010";
if (a[i] == '-') all += "1011";
if (a[i] == '.') all += "1100";
if (a[i] == ',') all += "1101";
if (a[i] == '[') all += "1110";
if (a[i] == ']') all += "1111";
}
long long int bases = 1, ans = 0;
for (int i = all.size() - 1; i >= 0; i--) {
ans += bases * (all[i] - '0');
ans %= mod;
bases *= 2;
bases %= mod;
}
cout << (ans + mod) % mod << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int maxn = 100005;
using namespace std;
int a[maxn], dp[maxn];
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int ans = 1;
for (int i = 0; i < n; i++) {
vector<int> p;
int x = a[i];
for (int j = 2; j * j <= x; j++)
if (x % j == 0) {
p.push_back(j);
while (x % j == 0) x /= j;
}
if (x != 1) p.push_back(x);
int cur = 0;
for (int y : p) cur = max(cur, dp[y] + 1);
for (int y : p) dp[y] = max(dp[y], cur);
ans = max(ans, cur);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
const long long maxn = 2e5 + 1e2;
struct Node {
long long a, b, w;
};
struct stt {
long long f[4 * maxn];
long long add[4 * maxn];
long long val[4 * maxn];
void up(long long root) { f[root] = min(f[root << 1], f[root << 1 | 1]); }
void pushdown(long long root, long long l, long long r) {
if (add[root]) {
add[root << 1] += add[root];
add[root << 1 | 1] += add[root];
f[root << 1] += add[root];
f[root << 1 | 1] += add[root];
add[root] = 0;
}
}
void build(long long root, long long l, long long r) {
if (l == r) {
f[root] = val[l];
return;
}
long long mid = l + r >> 1;
build(root << 1, l, mid);
build(root << 1 | 1, mid + 1, r);
up(root);
}
void update(long long root, long long l, long long r, long long x,
long long y, long long p) {
if (x <= l && r <= y) {
f[root] += p;
add[root] += p;
return;
}
pushdown(root, l, r);
long long mid = l + r >> 1;
if (x <= mid) update(root << 1, l, mid, x, y, p);
if (y > mid) update(root << 1 | 1, mid + 1, r, x, y, p);
up(root);
}
};
stt a, b;
Node ymh[maxn];
long long n, m, cnt;
long long pp[maxn];
long long q;
vector<pair<long long, long long> > v[maxn];
void print(long long x) {
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
signed main() {
n = read(), m = read();
q = read();
for (register long long i = 1; i < n; ++i)
a.val[i] = read(), pp[i] = a.val[i], b.val[i + 1] = read();
for (register long long i = 1; i <= m; ++i) {
ymh[i].a = read(), ymh[i].b = read(), ymh[i].w = read();
v[ymh[i].a].push_back(make_pair(ymh[i].b, ymh[i].w));
}
b.build(1, 1, n);
for (register long long i = 1; i <= n; ++i) {
for (register long long j = 0; j < v[i].size(); ++j) {
b.update(1, 1, n, 1, v[i][j].first, v[i][j].second);
}
a.val[i] += b.f[1];
}
a.build(1, 1, n);
cout << a.f[1] << endl;
for (long long i = 1; i <= q; i++) {
long long x = read(), y = read();
a.update(1, 1, n, x, x, y - pp[x]);
pp[x] = y;
print(a.f[1]);
puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const long long MOD = 1e9 + 7;
long long A, B, n, x;
void solve() {
long long t[2][2] = {A, 0, B, 1};
long long ans[2][2] = {x, 1, 0, 0};
long long tmp[2][2] = {0};
while (n) {
if (n & 1) {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) tmp[i][j] = ans[i][j];
memset(ans, 0, sizeof(ans));
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k)
ans[i][j] = (ans[i][j] + tmp[i][k] * t[k][j]) % MOD;
}
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) tmp[i][j] = t[i][j];
memset(t, 0, sizeof(t));
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k)
t[i][j] = (t[i][j] + tmp[i][k] * tmp[k][j]) % MOD;
n /= 2;
}
cout << ans[0][0] << endl;
}
int main() {
cin >> A >> B >> n >> x;
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char buff[142];
bool lower(int x, int y) {
printf("? %d %d\n", x, y);
fflush(stdout);
scanf("%s", buff);
return buff[0] == 'y';
}
void ans(int a) {
printf("! %d\n", a);
fflush(stdout);
}
void solve() {
int n = 1;
while (lower(n / 2, n)) n *= 2;
int b = n / 2, e = n;
while (e - b > 1) {
int m = (b + e) / 2;
lower(b, m) ? b = m : e = m;
}
ans(e);
}
int main() {
while (true) {
scanf("%s", buff);
if (buff[0] != 's') break;
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
char val = '2';
set<long long int> v[2];
string s = n;
for (long long int i = 0; i < s.length(); i++) {
if (s[i] == '0' && val != '0') {
val = '0';
v[0].insert(i);
} else if (s[i] == '1' && val != '1') {
val = '1';
v[1].insert(i);
}
}
set<long long int>::iterator it;
string ans = "";
if (!v[0].empty()) {
it = v[0].begin();
for (long long int i = 0; i < s.length(); i++) {
if (*it != i) ans += s[i];
}
} else {
for (long long int i = 1; i < s.length(); i++) {
ans += s[i];
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 3;
struct Point {
int x, y, id;
} p[N];
bool cmp1(const Point& A, const Point& B) { return A.x < B.x; }
bool cmp2(const Point& A, const Point& B) { return A.y < B.y; }
bool cmp3(const Point& A, const Point& B) { return A.y > B.y; }
int n, sz;
int main() {
scanf("%d", &n);
sz = sqrt(n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i].x, &p[i].y);
p[i].id = i;
}
sort(p + 1, p + n + 1, cmp1);
for (int l = 1, r, fg = 0; l <= n; l = r + 1, fg ^= 1) {
r = min(l + sz - 1, n);
if (fg)
sort(p + l, p + r + 1, cmp2);
else
sort(p + l, p + r + 1, cmp3);
for (int i = l; i <= r; i++) printf("%d ", p[i].id);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void print(vector<T> v) {
cerr << "[";
if (v.size()) cerr << v[0];
for (int i = (1); i < (v.size()); ++i) cerr << ", " << v[i];
cerr << "]\n";
}
template <class T>
string i2s(T x) {
ostringstream o;
o << x;
return o.str();
}
vector<string> splt(string s, char c = ' ') {
vector<string> all;
int p = 0, np;
while (np = s.find(c, p), np >= 0) {
if (np != p) all.push_back(s.substr(p, np - p));
p = np + 1;
}
if (p < s.size()) all.push_back(s.substr(p));
return all;
}
int main() {
int n, m;
cin >> n >> m;
vector<double> p(n + 1, 0);
p[0] = 1.0;
for (int j = (0); j < (n - 1); ++j) {
for (int i = p.size() - 2; i >= 0; i--) {
double z = 1.0 * (m - 1 - i) / (n * m - j - 1);
p[i + 1] += z * p[i];
p[i] *= (1.0 - z);
}
}
double rv = 0;
for (int i = (0); i < (n); ++i) rv += p[i] * (i + 1) / n;
cout << rv << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
int n, x[N], poz1, poz2, poz3;
double rmax = 0;
long long sp[N];
double avgg(int i, int j) {
long long t = sp[i] - sp[i - j - 1] + sp[n] - sp[n - j];
int nr = 2 * j + 1;
return (double)t / nr - (double)x[i];
}
bool calc() {
int i, j, pas;
for (i = 2; i < n; ++i) {
pas = (1 << 20);
for (j = 1; pas; pas /= 2)
if (i - (j + pas) > 0 && n - (j + pas) >= i &&
avgg(i, j + pas) > avgg(i, j + pas - 1))
j += pas;
double re = avgg(i, j);
if (re > rmax) {
rmax = re;
poz1 = i - j;
poz2 = i;
poz3 = n - j + 1;
}
}
return 0;
}
int main() {
int i;
cin >> n;
for (i = 1; i <= n; ++i) {
scanf("%d", &x[i]);
}
sort(x + 1, x + n + 1);
for (i = 1; i <= n; ++i) {
sp[i] = sp[i - 1] + x[i];
}
if (n < 3) {
cout << n << "\n";
for (i = 1; i <= n; ++i) cout << x[i] << " ";
return 0;
}
rmax = 0;
poz1 = 1;
poz2 = 2;
poz3 = n + 1;
calc();
cout << n - poz3 + 1 + poz2 - poz1 + 1 << "\n";
for (i = poz1; i <= poz2; ++i) cout << x[i] << " ";
for (i = poz3; i <= n; ++i) cout << x[i] << " ";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long _sieve_size;
bitset<10000010> bs;
vector<long long> primes;
void sieve(long long upperbound) {
_sieve_size = upperbound + 1;
bs.set();
bs[0] = bs[1] = 0;
for (long long i = 2; i <= _sieve_size; i++)
if (bs[i]) {
for (long long j = i * i; j <= _sieve_size; j += i) bs[j] = 0;
primes.push_back(i);
}
}
map<long long, long long> getPrimeFact(long long n) {
long long i = 0, pf = primes[0];
map<long long, long long> ans;
while (pf * pf <= n) {
while (n % pf == 0) {
n /= pf;
ans[pf]++;
}
pf = primes[++i];
}
if (n != 1) ans[n]++;
return ans;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
long long poww(long long a, long long x) {
if (x == 0) return 1LL;
long long res = poww(a, x / 2);
if (x % 2) {
return a * res * res;
} else {
return res * res;
}
}
int main() {
int n;
scanf("%d", &n);
sieve(200100);
vector<long long> a(n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
if (n == 2) {
printf("%lld\n", lcm(a[0], a[1]));
return 0;
}
vector<map<long long, long long>> primeFacts(n);
map<long long, pair<long long, long long>> doisMenores;
map<long long, long long> apareceu;
for (int i = 0; i < int(primes.size()); i++) {
doisMenores[primes[i]] =
make_pair(0x3f3f3f3f3f3f3f3fLL, 0x3f3f3f3f3f3f3f3fLL);
}
for (int i = 0; i < n; i++) {
primeFacts[i] = getPrimeFact(a[i]);
for (auto par : primeFacts[i]) {
long long num = par.first;
long long pot = par.second;
apareceu[num]++;
if (doisMenores[num].first >= pot) {
doisMenores[num].second = doisMenores[num].first;
doisMenores[num].first = pot;
} else if (doisMenores[num].second >= pot) {
doisMenores[num].second = pot;
}
}
}
long long ans = 1;
for (long long p : primes) {
if (apareceu[p] == n - 1) {
ans *= poww(p, doisMenores[p].first);
} else if (apareceu[p] == n) {
ans *= poww(p, doisMenores[p].second);
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int *tree[400005];
void join(int *L, int *R, int *res) {
if (R == NULL) {
for (int i = 0; i < 60; i++) {
res[i] = L[i];
}
return;
}
if (L == NULL) {
for (int i = 0; i < 60; i++) {
res[i] = R[i];
}
return;
}
for (int i = 0; i < 60; i++) {
res[i] = L[i] + R[(i + L[i]) % 60];
}
}
int *upd(int i, int l, int r, int x, int y) {
if (x > r || x < l) {
return tree[i];
}
if (l == r) {
for (int j = 0; j < 60; j++) {
if (j % y == 0)
tree[i][j] = 2;
else
tree[i][j] = 1;
}
return tree[i];
}
join(upd(i * 2 + 1, l, (l + r) / 2, x, y),
upd(i * 2 + 2, (l + r) / 2 + 1, r, x, y), tree[i]);
return tree[i];
}
int *get(int i, int l, int r, int a, int b) {
if (l >= a && r <= b) {
return tree[i];
}
if (l > b || r < a) {
return NULL;
}
int *L = get(i * 2 + 1, l, (l + r) / 2, a, b);
int *R = get(i * 2 + 2, (l + r) / 2 + 1, r, a, b);
int *ret = new int[60];
join(L, R, ret);
if (L != NULL && L != tree[i * 2 + 1]) delete L;
if (R != NULL && R != tree[i * 2 + 2]) delete R;
return ret;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < 400005; i++) tree[i] = new int[60];
int V;
for (int i = 0; i < n; i++) {
scanf("%d", &V);
upd(0, 0, n - 1, i, V);
}
int q;
scanf("%d", &q);
while (q--) {
char c;
int x, y;
scanf(" %c %d %d", &c, &x, &y);
x--;
y -= 2;
if (c == 'A') {
int *ret = get(0, 0, n - 1, x, y);
printf("%d\n", ret[0]);
if (ret != NULL && ret != tree[0]) delete ret;
} else {
y += 2;
upd(0, 0, n - 1, x, y);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
std::ostream& operator<<(std::ostream& os, const pair<T1, T2>& p) {
os << "[" << p.first << ", " << p.second << "]";
return os;
}
template <class T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
os << "[";
bool first = true;
for (typename std::vector<T>::const_iterator it = v.begin(); it != v.end();
++it) {
if (!first) os << ", ";
first = false;
os << *it;
}
os << "]";
return os;
}
vector<string> _split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return v;
}
void _print(vector<string>::iterator) {}
template <typename T, typename... Args>
void _print(vector<string>::iterator it, T a, Args... args) {
string name = it->substr((*it)[0] == ' ', it->length());
if (isalpha(name[0]))
cerr << name << " = " << a << " ";
else
cerr << name << " ";
_print(++it, args...);
}
const int N = 1001001;
int n, e;
int a[N], b[N];
vector<int> g[N];
int T;
vector<int> cand[N];
vector<int> order;
int ans_team[N], ans_conf[N];
int team[N], conf[N];
vector<int> contestant_list[N];
int main() {
scanf("%d", &n);
scanf("%d", &e);
for (int i = 1; i <= e; i++) {
scanf("%d", &a[i]);
scanf("%d", &b[i]);
g[a[i]].push_back(b[i]);
g[b[i]].push_back(a[i]);
}
for (int i = 1; i <= n; i++) {
int cnt;
scanf("%d", &cnt);
for (int j = 0; j < cnt; j++) {
int val;
scanf("%d", &val);
T = max(T, val);
cand[i].push_back(val);
}
}
while (true) {
for (int i = 1; i <= T; i++) {
contestant_list[i].clear();
}
for (int i = 1; i <= n; i++) {
team[i] = rand() % (cand[i].size());
team[i] = cand[i][team[i]];
contestant_list[team[i]].push_back(i);
}
order.clear();
for (int i = 1; i <= T; i++) {
order.push_back(i);
}
random_shuffle(order.begin(), order.end());
for (int i = 1; i <= T; i++) {
conf[i] = 0;
}
for (int i = 0; i < order.size(); i++) {
int id = order[i];
int cnt1 = 0;
int cnt2 = 0;
for (int j = 0; j < contestant_list[id].size(); j++) {
int contestant_id = contestant_list[id][j];
for (int q = 0; q < g[contestant_id].size(); q++) {
int other = g[contestant_id][q];
int other_team = team[other];
if (conf[other_team] == 0) continue;
if (conf[other_team] == 1)
cnt1++;
else
cnt2++;
}
}
if (cnt1 > cnt2) {
conf[id] = 2;
} else if (cnt1 < cnt2) {
conf[id] = 1;
} else {
conf[id] = rand() % 2 + 1;
}
}
int good_edges = 0;
for (int i = 1; i <= e; i++) {
int g1 = conf[team[a[i]]];
int g2 = conf[team[b[i]]];
if (g1 != g2) good_edges++;
}
if (good_edges * 2 < e) continue;
for (int i = 1; i <= n; i++) {
ans_team[i] = team[i];
}
for (int i = 1; i <= T; i++) {
ans_conf[i] = conf[i];
}
break;
}
for (int i = 1; i <= n; i++) {
if (i > 1) printf(" ");
printf("%d", ans_team[i]);
}
puts("");
for (int i = 1; i <= T; i++) {
if (i > 1) printf(" ");
printf("%d", ans_conf[i]);
}
puts("");
return 0;
}
| 8 |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
void solve1(int l, int r, std::string str) {
l = 0;
for (auto c : str) {
if (c == '<') l++;
}
for (int i = 0, j = 0; i < (int)str.size(); i = j) {
while (j < (int)str.size() && str[i] == str[j]) j++;
if (str[i] == '>') {
for (int x = 0; x < j - i; x++) {
std::cout << r-- << ' ';
}
} else {
for (int x = 0; x < j - i; x++) {
std::cout << l - (j - i - 1) + x << ' ';
}
l -= j - i;
}
}
std::cout << r << '\n';
}
void solve2(int l, int r, std::string str) {
for (int i = 0, j = 0; i < (int)str.size(); i = j) {
while (j < (int)str.size() && str[i] == str[j]) j++;
if (str[i] == '>') {
for (int x = 0; x < j - i; x++) {
std::cout << l + (j - i) - x << ' ';
}
std::cout << l << ' ';
l += (j - i) + 1;
} else {
for (int x = i == 0 ? 0 : 1; x < j - i; x++) {
std::cout << l++ << ' ';
}
}
}
if (str.back() == '<') {
std::cout << (int)str.size() + 1 << '\n';
} else {
std::cout << '\n';
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int t;
std::cin >> t;
while (t--) {
int l, r;
l = 1;
std::string str;
std::cin >> r >> str;
solve1(l, r, str);
solve2(l, r, str);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)2e9;
const double EPS = (double)1e-9;
const double PI = (double)acos(-1.0);
const long long MOD = (long long)1e9 + 7;
void base() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
int n, a;
cin >> n;
int total = 0;
for (int i = 0; i < n; i++) {
cin >> a;
total += a;
}
int ans = 0;
for (int i = 1; i <= 5; i++) {
if ((total + i) % (n + 1) != 1) {
ans++;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long maxm(long long a, long long b) {
if (a > b) return a;
return b;
}
long long minm(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long prod = binpow(a, b / 2);
if (b % 2 == 0)
return (prod * prod);
else
return (((a * prod)) * prod);
}
int swap(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}
int findpar(vector<int>& dsu, int k) {
if (dsu[k] == k || dsu[k] == -1) return dsu[k];
dsu[k] = findpar(dsu, dsu[k]);
return dsu[k];
}
void unon(vector<int>& dsu, vector<long long>& size, int a, int b) {
if (findpar(dsu, a) == findpar(dsu, b)) return;
int apr = findpar(dsu, a), bpr = findpar(dsu, b);
int don = apr, rec = bpr;
if (size[apr] > size[bpr]) swap(don, rec);
dsu[don] = rec;
size[rec] += size[don];
return;
}
bool notedge(int i, int j, int n, int m) {
if (i == 0 || i == n - 1 || j == 0 || j == m - 1) return false;
return true;
}
void solve() {
int n, m, k;
cin >> n >> m >> k;
vector<vector<char>> grid(n, vector<char>(m));
vector<int> dsu(m * n, -1);
vector<long long> size(m * n, 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> grid[i][j];
if (notedge(i, j, n, m) && grid[i][j] == '.') dsu[i * m + j] = i * m + j;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == '.' && notedge(i, j, n, m)) {
if (i > 0) {
if (grid[i - 1][j] == '.') {
int ind = (i - 1) * m + j;
if (findpar(dsu, ind) == -1 && findpar(dsu, i * m + j) != -1)
dsu[findpar(dsu, i * m + j)] = -1;
else if (findpar(dsu, ind) != -1 && findpar(dsu, i * m + j) != -1)
unon(dsu, size, ind, i * m + j);
}
}
if (i < n - 1) {
if (grid[i + 1][j] == '.') {
int ind = (i + 1) * m + j;
if (findpar(dsu, ind) == -1 && findpar(dsu, i * m + j) != -1)
dsu[findpar(dsu, i * m + j)] = -1;
else if (findpar(dsu, ind) != -1 && findpar(dsu, i * m + j) != -1)
unon(dsu, size, ind, i * m + j);
}
}
if (j > 0) {
if (grid[i][j - 1] == '.') {
int ind = i * m + j - 1;
if (findpar(dsu, ind) == -1 && findpar(dsu, i * m + j) != -1)
dsu[findpar(dsu, i * m + j)] = -1;
else if (findpar(dsu, ind) != -1 && findpar(dsu, i * m + j) != -1)
unon(dsu, size, ind, i * m + j);
}
}
if (j < m - 1) {
if (grid[i][j + 1] == '.') {
int ind = (i)*m + j + 1;
if (findpar(dsu, ind) == -1 && findpar(dsu, i * m + j) != -1)
dsu[findpar(dsu, i * m + j)] = -1;
else if (findpar(dsu, ind) != -1 && findpar(dsu, i * m + j) != -1)
unon(dsu, size, ind, i * m + j);
}
}
}
}
}
vector<pair<int, int>> ans;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (findpar(dsu, i * m + j) == i * m + j)
ans.push_back(make_pair(size[i * m + j], i * m + j));
}
sort(ans.begin(), ans.end());
set<int> par;
int sum = 0;
for (int i = 0; i < ans.size() - k; i++) {
sum += ans[i].first;
par.insert(ans[i].second);
}
cout << sum << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (par.find(findpar(dsu, i * m + j)) != par.end())
cout << '*';
else
cout << grid[i][j];
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int nextint() {
int a;
cin >> a;
return a;
}
const int mod = (int)1e9 + 7;
const int INF = (int)1e9;
const int N = (int)1e6 + 10;
int n, m, sx, sy;
bool used[105][105];
void dfs(int x, int y) {
if (x > n || x < 1 || y > m || y < 1 || used[x][y]) return;
used[x][y] = 1;
cout << x << ' ' << y << '\n';
for (int i = 1; i <= n; i++) dfs(x + i, y), dfs(x - i, y);
for (int i = 1; i <= m; i++) dfs(x, y + i), dfs(x, y - i);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> sx >> sy;
dfs(sx, sy);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
double holdres;
bool blocked[MAXN];
pair<int, int> val[MAXN];
vector<double> tmp;
double res[MAXN];
vector<pair<int, int>> v1[MAXN];
vector<int> cmp;
bool visited[MAXN];
bool visited2[MAXN];
queue<int> q1;
void dfs(int curr, int par) {
visited[curr] = true;
cmp.push_back(curr);
for (auto x : v1[curr]) {
int a, b;
if (x.second == 1) {
a = 1 - val[curr].first;
} else {
a = 2 - val[curr].first;
}
b = -val[curr].second;
if (!visited[x.first]) {
val[x.first].first = a;
val[x.first].second = b;
dfs(x.first, curr);
} else if (x.first == par) {
if (val[x.first].second == b) {
if (val[x.first].first == a) {
continue;
}
cout << "NO" << endl;
exit(0);
} else {
double setval = (double)((double)a - (double)val[x.first].first) /
((double)val[x.first].second - (double)b);
if (holdres != -1e9) {
if (setval != holdres) {
cout << "NO" << endl;
exit(0);
}
}
holdres = setval;
continue;
}
} else {
if (val[x.first].second == b) {
if (val[x.first].first == a) {
continue;
}
cout << "NO" << endl;
exit(0);
} else {
double setval = (double)((double)a - (double)val[x.first].first) /
((double)val[x.first].second - (double)b);
if (holdres != -1e9) {
if (setval != holdres) {
cout << "NO" << endl;
exit(0);
}
}
holdres = setval;
continue;
}
}
}
}
void dfs2(int curr, int par, double hold) {
visited2[curr] = true;
res[curr] = (double)val[curr].first + (double)val[curr].second * (double)hold;
for (auto x : v1[curr]) {
if (!visited2[x.first]) {
dfs2(x.first, curr, hold);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y, w;
cin >> x >> y >> w;
v1[x].push_back(make_pair(y, w));
v1[y].push_back(make_pair(x, w));
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
val[i].first = 0;
val[i].second = 1;
holdres = -1e9;
dfs(i, i);
if (holdres != -1e9) {
dfs2(i, i, holdres);
cmp.clear();
continue;
}
tmp.clear();
for (int x : cmp) {
tmp.push_back((double)-val[x].first / (double)val[x].second);
}
sort(tmp.begin(), tmp.end());
double val2 = tmp[(int)tmp.size() / 2];
if ((int)tmp.size() % 2 == 0 && (int)tmp.size() > 2) {
val2 = (double)(tmp[(int)tmp.size() / 2] +
tmp[((int)tmp.size() / 2) - 1]) /
2;
}
dfs2(i, i, val2);
cmp.clear();
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
cout << setprecision(10) << res[i] << " ";
}
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7, N = 1 << 20;
int a[N][21];
long long ans[N];
int32_t main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
;
int n, w;
cin >> n >> w;
for (int t = 0; t < n; t++) {
int m;
cin >> m;
for (int i = 0; i < m; i++) cin >> a[i][0];
for (int j = 1; j <= 20; j++)
for (int i = 0; i + (1 << (j - 1)) < m; i++)
a[i][j] = max(a[i][j - 1], a[i + (1 << (j - 1))][j - 1]);
for (int i = 0; i < w; i++) {
int l = max(0, i - w + m);
int r = min(m - 1, i);
int len = r - l + 1, lg = 32 - __builtin_clz(len) - 1;
int res = max(a[l][lg], a[r - (1 << lg) + 1][lg]);
if (res < 0 && (i >= m || i < w - m)) res = 0;
ans[i] += res;
if (l == 0 && r == m - 1) i = max(i, w - m - 1);
ans[i + 1] -= res;
}
}
for (int i = 1; i < w; i++) ans[i] += ans[i - 1];
for (int i = 0; i < w; i++) cout << ans[i] << " \n"[i == w - 1];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[400];
int ans = 0;
int main() {
cin >> n;
n *= 2;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
if (a[i - 1] != a[i]) {
int j;
for (j = i + 1; j <= n; j++) {
if (a[j] == a[i]) break;
}
while (j != i + 1) swap(a[j], a[j - 1]), j--, ans++;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
const long long N = 1e6 + 10;
const long long IM = 1e18;
const long long PI = 3.14159265;
void PV(vector<long long> v) {
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n";
}
void PA(long long v[], long long n, long long x = 0) {
for (long long i = x; i < n + x; i++) cout << v[i] << " ";
cout << "\n";
}
void IN(long long a[], long long n, long long x = 0) {
for (long long i = x; i < n + x; i++) cin >> a[i];
}
inline void PTN(long long n = 1, long long a = 0, long long b = 0,
long long c = 0) {
if (n--) cout << a << " ";
if (n--) cout << b << " ";
if (n--) cout << c << " ";
cout << "\n";
}
inline void op() {}
long long a[N], b[N];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
op();
long long i, j, x, y, u, l;
long long tt = 1;
{
i = j = x = y = u = l = 0;
long long n, m;
cin >> n;
IN(a, n);
sort(a, a + n);
cin >> m;
IN(b, m);
sort(b, b + m);
long long ans1, ans2, ans = 0;
ans1 = 3 * n;
ans2 = 3 * m;
ans = ans1 - ans2;
for (i = 0; i < n; i++) {
j = a[i] - 1;
x = (n - i) * 3 + i * 2;
if (j > b[m - 1])
y = 2 * m;
else if (j < b[0])
y = 3 * m;
else {
u = upper_bound(b, b + m, j) - b;
y = (m - u) * 3 + 2 * u;
}
if (x - y > ans) {
ans = x - y;
ans1 = x;
ans2 = y;
}
while (j + 1 == a[i] && i < n) i++;
i--;
}
for (i = 0; i < m; i++) {
j = b[i] - 1;
y = (m - i) * 3 + i * 2;
if (j > a[n - 1])
x = 2 * n;
else if (j < a[0])
x = 3 * n;
else {
u = upper_bound(a, a + n, j) - a;
x = (n - u) * 3 + u * 2;
}
if (x - y > ans) {
ans = x - y;
ans1 = x;
ans2 = y;
}
while (j + 1 == b[i] && i < m) i++;
i--;
}
x = 2 * n;
y = 2 * m;
if (x - y > ans) {
ans = x - y;
ans1 = x;
ans2 = y;
}
cout << ans1 << ":" << ans2 << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int stmp;
const int MAX = 100000;
const int INF = 1000000001;
vector<int> G[MAX + 1];
double res;
int n;
void dfs(int v, int p, int d) {
res += 1. / d;
for (__typeof((G[v]).begin()) u = (G[v]).begin(); u != (G[v]).end(); ++u)
if (*u != p) dfs(*u, v, d + 1);
}
int main(int argc, char *argv[]) {
stmp = scanf("%d", &n);
for (int foo = 0; foo < (n - 1); ++foo) {
int a, b;
stmp = scanf("%d %d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
dfs(1, 1, 1);
printf("%.8lf\n", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
int ans[100005], head[100005], tail = 0;
struct E {
int v, next;
} e[2 * 100005];
void add(int u, int v) {
e[tail].v = v;
e[tail].next = head[u];
head[u] = tail++;
}
set<int> query[100005], res[100005], lca[100005];
set<int>::iterator it;
void dfs(int u, int fa) {
for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].v;
if (v == fa) continue;
dfs(v, u);
for (it = query[v].begin(); it != query[v].end(); it++)
if (query[u].count(*it)) ans[*it] = (int)1e9;
if (res[v].size() > res[u].size()) swap(res[u], res[v]);
for (it = res[v].begin(); it != res[v].end(); it++) {
if (query[u].count(*it))
ans[*it]++;
else if (res[u].count(*it))
lca[u].insert(*it);
else
res[u].insert(*it);
}
}
for (it = lca[u].begin(); it != lca[u].end(); it++) {
ans[*it]++;
if (res[u].count(*it)) res[u].erase(*it);
}
for (it = query[u].begin(); it != query[u].end(); it++) {
if (res[u].count(*it)) ans[*it]++;
res[u].insert(*it);
}
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
add(u, v);
add(v, u);
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int k;
scanf("%d", &k);
while (k--) {
int xx;
scanf("%d", &xx);
query[xx].insert(i);
}
}
dfs(1, -1);
for (int i = 1; i <= q; i++) {
if (ans[i] < (int)1e9)
printf("%d\n", ans[i]);
else
printf("-1\n");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, ans, mx, mxh, mnh, h, now, pmx, pnow, dl, dr, dp;
int a[N], pre[N];
vector<int> p[N];
struct Seg {
int l, r, be, is;
} d[N + N];
void upd(int h, int x) {
if (h < d[dp].l) --dp;
if (h > d[dp].r) ++dp;
if (d[dp].is)
ans = max(ans, (min(p[mx][pmx], p[now][pnow]) - 1) - p[mx][h + d[dp].be]);
else
ans = max(ans, (min(p[mx][pmx], p[now][pnow]) - 1) - d[dp].be);
}
void doit(int l, int r) {
for (int i = l, _e = r; i < _e; ++i)
if (++h > mxh) {
d[++dr] = (Seg){h, h + (r - i - 1), -h + i, 1};
h = mxh = d[dr].r;
pmx = r;
break;
} else
++pmx, upd(h, p[mx][i]);
}
int main() {
scanf("%d", &n);
for (int i = 1, _e = n; i <= _e; ++i)
scanf("%d", &a[i]), p[a[i]].push_back(i);
for (int i = 1, _e = n; i <= _e; ++i)
if (p[i].size() > p[mx].size()) mx = i;
int las = 1;
p[mx].push_back(n + 1);
for (int i = 0, _e = p[mx].size(); i < _e; ++i) {
for (int j = las, _e = p[mx][i]; j < _e; ++j) pre[j] = i;
las = p[mx][i] + 1;
}
for (int i = 1, _e = n; i <= _e; ++i)
if (i != mx && p[i].size()) {
now = i;
mnh = mxh = h = 0;
pmx = pnow = 0;
p[i].push_back(n + 1);
dp = dl = dr = n;
d[n] = (Seg){0, 0, 0, 0};
int las = 0;
for (int k = 0, _e = p[i].size() - 1; k < _e; ++k) {
int j = p[i][k], las2 = pre[j];
doit(las, las2);
++pnow;
if (--h < mnh)
mnh = h, d[--dl] = (Seg){h, h, j, 0};
else
upd(h, j);
las = las2;
}
doit(las, p[mx].size() - 1);
}
printf("%d\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const double oo = 1e9;
const double eps = 1e-9;
const int LN = 20;
int l[N], r[N], st[N];
double x[N], d[N], dp[N][LN];
bool good(int i, int p, int j) { return d[p] - (x[j] - x[i]) / 2 > -eps; }
int main() {
int i, j, u, n, p, zn;
double xl, xr, X, L, R;
bool fl;
pair<double, int> pr;
scanf("%d", &n);
for (i = 0; i <= n + 1; ++i) scanf("%lf", &x[i]);
for (i = 1; i <= n; ++i) scanf("%lf", &d[i]);
d[0] = d[n + 1] = oo;
r[n + 1] = n + 1;
for (i = n; i >= 0; --i) {
p = i + 1;
while ((p != r[p]) && !good(i, p, r[p])) p = r[p];
r[i] = p;
}
l[0] = 0;
for (i = 1; i <= n + 1; ++i) {
p = i - 1;
while ((p != l[p]) && !good(l[p], p, i)) p = l[p];
l[i] = p;
}
if (r[0] != n + 1) {
printf("0\n");
return 0;
}
for (i = 0; i <= n + 1; ++i) {
p = r[i];
if (d[i] - (x[p] - x[i]) / 2 < eps)
dp[i][0] = oo;
else
dp[i][0] = x[p] - 2 * d[i];
}
dp[n + 1][0] = 0;
for (u = 1; u < LN; ++u)
for (i = 0; i <= n + 1; ++i) {
j = min(n + 1, i + (1 << (u - 1)));
dp[i][u] = min(dp[i][u - 1], dp[j][u - 1]);
}
st[1] = 0;
for (i = 2; i < N; ++i) {
st[i] = st[i - 1];
if ((1 << (st[i] + 1)) <= i) ++st[i];
}
L = 0;
R = oo;
for (int it = 0; it <= 100; ++it) {
X = (L + R) / 2;
fl = false;
for (i = j = 0; (i <= n) && !fl; ++i) {
p = l[i];
if (d[i] - (x[i] - x[p]) / 2 < eps) continue;
for (; (j <= n + 1) && (X - (x[j] - x[i]) / 2 > -eps); ++j)
;
xr = 2 * d[i] + x[p];
if (i + 1 == j) continue;
zn = st[j - i - 1];
xl = min(dp[i + 1][zn], dp[j - (1 << zn)][zn]);
if (abs(xl - oo) < eps) continue;
if (xr - xl > -eps) fl = true;
}
if (fl)
R = X;
else
L = X;
}
X = (L + R) / 2;
printf("%.5lf\n", X);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, u, v;
set<int> a, b;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
a.insert(x);
}
for (int i = 0; i < m; i++) {
scanf("%d", &x);
b.insert(x);
}
for (int i = 1; i < 10; i++) {
if (a.count(i) && b.count(i)) {
printf("%d\n", i);
return 0;
}
}
u = *a.begin();
v = *b.begin();
if (u > v) swap(u, v);
printf("%d\n", u * 10 + v);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long mod7 = 1000000007LL;
inline long long getint() {
long long _x = 0, _tmp = 1;
char _tc = getchar();
while ((_tc < '0' || _tc > '9') && _tc != '-') _tc = getchar();
if (_tc == '-') _tc = getchar(), _tmp = -1;
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x * _tmp;
}
inline long long add(long long _x, long long _y, long long _mod = mod7) {
_x += _y;
return _x >= _mod ? _x - _mod : _x;
}
inline long long sub(long long _x, long long _y, long long _mod = mod7) {
_x -= _y;
return _x < 0 ? _x + _mod : _x;
}
inline long long mul(long long _x, long long _y, long long _mod = mod7) {
_x *= _y;
return _x >= _mod ? _x % _mod : _x;
}
long long mypow(long long _a, long long _x, long long _mod) {
if (_x == 0) return 1LL;
long long _ret = mypow(mul(_a, _a, _mod), _x >> 1, _mod);
if (_x & 1) _ret = mul(_ret, _a, _mod);
return _ret;
}
long long mymul(long long _a, long long _x, long long _mod) {
if (_x == 0) return 0LL;
long long _ret = mymul(add(_a, _a, _mod), _x >> 1, _mod);
if (_x & 1) _ret = add(_ret, _a, _mod);
return _ret;
}
void sleep(double sec = 1021) {
clock_t s = clock();
while (clock() - s < CLOCKS_PER_SEC * sec)
;
}
int __ = 1, _cs;
const int N = 5140;
void build() {}
long long n, a[N], k;
void init() {
n = getint();
for (int i = 0; i < n; i++) a[i] = getint();
k = (n + 1) / 2;
}
long long dp[2][N][2][2], ans[N];
const long long inf = 1e18;
long long down_to(long long cur, long long hill) { return min(cur, hill - 1); }
void solve() {
for (int i = 0; i <= k; i++)
for (int j = 0; j < 2; j++)
for (int u = 0; u < 2; u++) dp[0][i][j][u] = inf;
dp[0][0][0][0] = 0;
for (int _ = 0; _ < n; _++) {
int now = _ & 1, nxt = 1 ^ now;
int h = a[_];
for (int i = 0; i <= k; i++)
for (int j = 0; j < 2; j++)
for (int u = 0; u < 2; u++) dp[nxt][i][j][u] = inf;
for (int i = 0; i <= k; i++)
for (int j = 0; j < 2; j++)
for (int u = 0; u < 2; u++) {
if (dp[now][i][j][u] == inf) continue;
{ dp[nxt][i][u][0] = min(dp[nxt][i][u][0], dp[now][i][j][u]); }
if (u == 0 and i + 1 <= k) {
long long cst = 0;
if (_) {
if (j) {
long long cur = down_to(a[_ - 1], a[_ - 2]);
cst += cur - down_to(cur, h);
} else {
cst += a[_ - 1] - down_to(a[_ - 1], h);
}
}
if (_ + 1 < n) cst += a[_ + 1] - down_to(a[_ + 1], h);
dp[nxt][i + 1][u][1] =
min(dp[nxt][i + 1][u][1], dp[now][i][j][u] + cst);
}
}
}
for (int i = 0; i <= k; i++) ans[i] = inf;
for (int i = 0; i <= k; i++)
for (int j = 0; j < 2; j++)
for (int u = 0; u < 2; u++) ans[i] = min(ans[i], dp[n & 1][i][j][u]);
for (int i = 1; i <= k; i++) printf("%lld%c", ans[i], " \n"[i == k]);
}
int main() {
build();
while (__--) {
init();
solve();
}
}
| 5 |
#include <bits/stdc++.h>
long long int a[100100];
long long int max1, max = 0;
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
while (a[i] % 2 == 0) a[i] /= 2;
while (a[i] % 3 == 0) a[i] /= 3;
}
for (i = 0; i < n - 1; i++) {
if (a[i] != a[i + 1]) {
printf("No");
return 0;
}
}
printf("Yes");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int lcnt[3005][3005];
int rcnt[3005][3005];
int S[3005];
char c[3005][3005];
void add(int first, int k) {
for (int i = first; i < 3005; i += i & -i) {
S[i] += k;
}
}
int query(int first) {
int res = 0;
for (int i = first; i > 0; i -= i & -i) {
res += S[i];
}
return res;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", c[i] + 1);
for (int j = 1; j <= m; j++) {
if (c[i][j] == 'z')
lcnt[i][j] = lcnt[i][j - 1] + 1;
else
lcnt[i][j] = 0;
}
for (int j = m; j >= 1; j--) {
if (c[i][j] == 'z')
rcnt[i][j] = rcnt[i][j + 1] + 1;
else
rcnt[i][j] = 0;
}
}
long long res = 0;
for (int i = 1; i <= n + m; i++) {
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pq;
for (int j = 1; j <= n; j++) {
if (i - j > m) continue;
if (i - j <= 0) break;
if (c[j][i - j] == 'z') {
add(j, 1);
pq.push(make_pair(lcnt[j][i - j] + j, j));
while (!pq.empty() && pq.top().first == j) {
add(pq.top().second, -1);
pq.pop();
}
res += query(j) - query(j - rcnt[j][i - j]);
} else {
while (!pq.empty()) {
add(pq.top().second, -1);
pq.pop();
}
}
}
while (!pq.empty()) {
add(pq.top().second, -1);
pq.pop();
}
}
printf("%lld\n", res);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long x, i, F[101];
cin >> x;
for (i = 1; i <= 100; i++) {
if (i % 2 == 0)
F[i] = 0;
else {
F[i] = ceil(double(i * i) / 2) + 1;
}
}
if (x == 3) {
cout << 5 << endl;
} else {
for (i = 1; i <= 100; i += 2) {
if (x < F[i]) {
cout << i << endl;
break;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[1000010];
int dp[1000010];
int main() {
int i, j, n, top = 0;
scanf("%s", s + 1);
for (i = 1; s[i] == 'F'; i++) top++;
for (i; s[i]; i++)
if (s[i] == 'F') {
top++;
if (i - top > dp[top - 1])
dp[top] = i - top;
else
dp[top] = dp[top - 1] + 1;
}
printf("%d\n", dp[top]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s;
int k, n, g[27][27];
int dp[101][27][101];
int go(int pos, int last, int k) {
if (k < 0) return -(1e8);
if (pos == n) return 0;
if (dp[pos][last][k] != -1) return dp[pos][last][k];
int res = -(1e8);
for (int i = 0; i < 26; i++) {
res = max(res, g[last][i] + go(pos + 1, i, k - ((s[pos] - 'a') != i)));
}
return dp[pos][last][k] = res;
}
int main() {
cin >> s;
n = s.size();
k = ({
int t;
scanf("%d", &t);
t;
});
int z = ({
int t;
scanf("%d", &t);
t;
});
for (int i = 0; i < z; i++) {
char cx, cy;
int cz;
cin >> cx >> cy >> cz;
g[cx - 'a'][cy - 'a'] = cz;
}
int res = -(1e8);
memset(dp, -1, sizeof(dp));
for (int i = 0; i < 26; i++) {
int K = k;
if ((s[0] - 'a') != i) K--;
res = max(res, go(1, i, K));
}
cout << res << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int bit_cnt(int k) {
int ret = 0;
for (; k; ret++) {
k &= k - 1;
}
return ret;
}
int main() {
map<char, int> mp;
mp['R'] = 0;
mp['G'] = 1;
mp['B'] = 2;
mp['Y'] = 3;
mp['W'] = 4;
mp['1'] = 0;
mp['2'] = 1;
mp['3'] = 2;
mp['4'] = 3;
mp['5'] = 4;
int num;
string str;
vector<string> vs;
cin >> num;
for (int i = 0; (i) < (num); i++) {
cin >> str;
vs.push_back(str);
}
int ans = 2000000000;
for (int i = 0; (i) < (32); i++) {
for (int j = 0; (j) < (32); j++) {
bool done = true;
for (int a = 0; (a) < (num); a++) {
for (int b = a + 1; (b) <= (num - 1); b++) {
if (vs[a] == vs[b]) continue;
if (vs[a][0] != vs[b][0] &&
((i & (1 << (mp[vs[a][0]]))) || (i & (1 << (mp[vs[b][0]]))))) {
continue;
}
if (vs[a][1] != vs[b][1] &&
((j & 1 << mp[vs[a][1]]) || (j & 1 << mp[vs[b][1]]))) {
continue;
}
done = false;
break;
}
}
if (done) {
ans = min(ans, bit_cnt(i) + bit_cnt(j));
}
}
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int cansel_sync = (ios::sync_with_stdio(0), cin.tie(0), 0);
long long gcd(long long a, long long b) {
while (b ^= a ^= b ^= a %= b)
;
return a;
}
const int MAXN = 114514;
int a[MAXN];
int sum[MAXN];
int n, q, l, r;
void solve() {
cin >> n;
sum[0] = 0;
for (int i = (1); i <= (n); i++) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
cin >> q;
while (q--) {
cin >> l >> r;
cout << (sum[r] - sum[l - 1]) / 10 << endl;
}
}
int main() { solve(); }
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
vector<int> v;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v.push_back(a);
}
int t = n;
for (int i = 0; i < n; i++) {
int p = max(0, i - x), q = min(n - 1, i + y), s = 0;
for (int j = p; j <= q; j++) {
if (v[i] <= v[j]) s += 1;
}
if (s == q - p + 1) {
t = i + 1;
break;
}
}
cout << t << endl;
}
| 1 |
#include <bits/stdc++.h>
long n, m, k;
long a[1000][2];
long sum = 0;
long dis[1000];
long vis[1000];
long min[1000];
int main() {
scanf("%ld %ld %ld", &n, &m, &k);
for (long i = 0; i < n; i++) scanf("%ld %ld", &a[i][0], &a[i][1]);
for (long i = 0; i < n; i++) {
if (vis[a[i][0]] == 0) {
sum = sum + a[i][1];
vis[a[i][0]] = 1;
min[a[i][0]] = a[i][1];
}
if (min[a[i][0]] > a[i][1]) {
sum = sum - (min[a[i][0]] - a[i][1]);
min[a[i][0]] = a[i][1];
}
}
if (sum > k) sum = k;
printf("%ld", sum);
getchar();
getchar();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const long long mod = 998244353;
long long modpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return ans;
}
long long fac[N], inv[N];
long long choose(int n, int r) {
return fac[n] * inv[r] % mod * inv[n - r] % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
if (k == 1) {
cout << 0 << endl;
return 0;
}
int h[n];
for (int i = 0; i < n; i++) cin >> h[i];
int t = 0;
for (int i = 0; i < n; i++)
if (h[i] != h[(i + 1) % n]) t++;
for (int i = 0; i <= n; i++) fac[i] = i ? fac[i - 1] * i % mod : 1;
inv[n] = modpow(fac[n], mod - 2);
for (int i = n - 1; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
long long ans = 0;
long long half = modpow(2, mod - 2);
for (int i = 0; i < t; i++) {
long long K = t - i;
if (K & 1)
ans += modpow(k - 2, i) * choose(t, i) % mod * modpow(2, K - 1) % mod;
else
ans += modpow(k - 2, i) * choose(t, i) % mod *
(modpow(2, K) + mod - choose(K, K / 2)) % mod * half % mod;
if (ans >= mod) ans -= mod;
}
ans = (ans * modpow(k, n - t)) % mod;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int hm[] = {1, -1, 0, 0};
int vm[] = {0, 0, 1, -1};
int bfs(vector<vector<char> > &graph, int r, int c) {
vector<vector<bool> > used(r, vector<bool>(c, false));
vector<vector<int> > dist(r, vector<int>(c, 0));
pair<int, int> p = make_pair(0, 0);
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++)
if (graph[i][j] == 'E') p = make_pair(i, j);
queue<pair<int, int> > q;
q.push(p);
used[p.first][p.second] = true;
while (!q.empty()) {
p = q.front();
q.pop();
int x0 = p.first, y0 = p.second;
for (int k = 0; k < 4; k++) {
int x1 = x0 + hm[k], y1 = y0 + vm[k];
if (x1 < 0 or x1 >= r or y1 < 0 or y1 >= c) continue;
if (used[x1][y1]) continue;
if (graph[x1][y1] == 'T') continue;
dist[x1][y1] = dist[x0][y0] + 1;
used[x1][y1] = true;
q.push(make_pair(x1, y1));
}
}
pair<int, int> player = make_pair(0, 0);
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++)
if (graph[i][j] == 'S') player = make_pair(i, j);
int count = 0;
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++)
if (dist[i][j] != 0 and
dist[i][j] <= dist[player.first][player.second] and
graph[i][j] != 'S')
count += (int(graph[i][j] - '0'));
return count;
}
int main() {
ios::sync_with_stdio(false);
int r = 0, c = 0;
cin >> r >> c;
vector<vector<char> > graph(r, vector<char>(c, '\0'));
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++) cin >> graph[i][j];
int count = bfs(graph, r, c);
cout << count << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x1, x2, y1, y2;
cin >> x1 >> x2 >> y1 >> y2;
cout << max(abs(x2 - y2), abs(x1 - y1));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 256;
char s[maxn][maxn];
int l[maxn], r[maxn], n, m;
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < (n); ++i) {
scanf("%s", s[i]);
l[i] = m;
r[i] = -1;
for (int j = 0; j < (m); ++j) {
if (s[i][j] == 'G') continue;
l[i] = min(l[i], j);
r[i] = max(r[i], j);
}
}
int ans = 0;
while (n && r[n - 1] == -1) {
--n;
}
int now = 0;
for (int i = 0; i < (n); ++i) {
if (i & 1) {
int next = l[i];
if (i + 1 < n) {
next = min(next, l[i + 1]);
}
if (next != m) {
ans += abs(next - now);
now = next;
}
} else {
int next = r[i];
if (i + 1 < n) {
next = max(next, r[i + 1]);
}
if (next != -1) {
ans += abs(next - now);
now = next;
}
}
if (i < n - 1) ++ans;
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[200005];
long long h[200005];
vector<long long> adj[100005];
long long cnt[100005];
long long vis[100005];
pair<long long, long long> v[200005];
long long l = 0;
void dfs(int node) {
vis[node] = 1;
cnt[node] = a[node];
long long cnth = 0, cnts = 0;
for (int i = 0; i < adj[node].size(); i++) {
int child = adj[node][i];
if (vis[child] == 0) {
dfs(child);
cnt[node] += cnt[child];
cnth += v[child].first;
cnts += v[child].second;
}
}
long long q = cnt[node] - h[node] + 2;
long long n1 = q / 2;
long long ch = cnt[node] - (n1 - 1);
long long cs = (n1 - 1);
if (ch - cs != h[node] || ch < 0 || cs < 0) {
l = 1;
return;
}
v[node].first = ch;
v[node].second = cs;
long long p = cnt[node] - a[node];
if (cnts + cnth > p) {
l = 1;
return;
}
if (cnth > ch) {
l = 1;
return;
} else {
long long p1 = p - cnth;
if (cnts < p1 && p1 > 0) {
l = 1;
return;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
l = 0;
for (int i = 1; i <= n; i++) {
vis[i] = 0;
adj[i].clear();
v[i].first = 0;
v[i].second = 0;
cnt[i] = 0;
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
for (int i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1);
if (l == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool query(int x, int y) {
if (x == -1) return false;
cout << 1 << ' ' << x << ' ' << y << endl;
cout.flush();
string ans;
cin >> ans;
return ans[0] == 'T';
}
int get(int l, int r) {
if (l > r) return -1;
while (l + 1 < r) {
int m = (l + r) / 2;
if (query(m, m + 1)) {
r = m;
} else {
l = m;
}
}
if (query(l, r)) {
return l;
} else {
return r;
}
}
int main() {
ios::sync_with_stdio(0);
int n, k;
cin >> n >> k;
int x = get(1, n);
int y = get(1, x - 1);
if (!query(y, x)) {
y = get(x + 1, n);
}
cout << 2 << ' ' << x << ' ' << y << endl;
cout.flush();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int v, nxt;
} e[500005];
int head[500005], tot;
int dep[500005];
void AddEdge(int u, int v) {
e[++tot] = {v, head[u]};
head[u] = tot;
e[++tot] = {u, head[v]};
head[v] = tot;
}
void dfs(int x, int f) {
dep[x] = dep[f] + 1;
for (int i = head[x]; i; i = e[i].nxt) {
if (e[i].v == f) continue;
dfs(e[i].v, x);
}
}
int main() {
int n, a, b;
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d%d", &a, &b);
AddEdge(a, b);
}
dep[1] = 1;
dfs(1, 0);
double ans = 0.0;
for (int i = 1; i <= n; ++i) ans += 1.0 / dep[i];
printf("%.7f", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool flag = 0, flag1 = 0, flag2 = 0;
int main() {
long long int n;
cin >> n;
long long int a[n], b[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
long long int eq = 0, cnta = 0, cntb = 0;
for (long long int i = 0; i < n; i++) {
if (a[i] == b[i]) eq++;
if (a[i] == 1 && b[i] == 0) cnta++;
if (b[i] == 1 && a[i] == 0) cntb++;
}
if (eq == n)
cout << -1;
else if (cnta == 0 && cntb != 0)
cout << -1;
else if (cnta > cntb)
cout << 1;
else
cout << ceil((double)(cntb + 1) / cnta);
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, i, c = 0, d = 0;
scanf("%d", &n);
char a[n + 1];
scanf("%s", a);
for (i = 0; i < n; i++) {
if (a[i] == '0') {
c++;
}
if (a[i] == '1') {
d++;
}
}
if (c > d) {
printf("%d", c - d);
} else if (d > c) {
printf("%d", d - c);
} else if (c == d) {
printf("0");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 21);
int a[maxn], dp[maxn][21];
void update(int x, int k) {
if (k > 20) return;
if (dp[x][k] >= 2) return;
++dp[x][k];
update(x, k + 1);
if (x >> k & 1) update(x ^ (1 << k), k);
}
signed main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int ans = 0;
for (int i = n; i >= 1; i--) {
int res = 0, bit = 0;
for (int j = 20; j >= 0; j--) {
if (a[i] >> j & 1)
res |= 1 << j;
else if (dp[bit | (1 << j)][20] >= 2)
res |= 1 << j, bit |= 1 << j;
}
update(a[i], 0);
if (i <= n - 2) ans = max(ans, res);
}
cout << ans << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int a, x, y;
scanf("%d", &a);
x = a % 5;
y = a / 5;
if (x != 0) {
y = y + 1;
}
printf("%d", y);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const double PI = 2 * asin(1);
const double EPS = 1e-8;
const int INF = 0x3fffffff;
const int MOD = 1e9 + 7;
struct Node {
int d;
string s;
Node(int dd = 0, string ss = "") : d(dd), s(ss) {}
};
int g_m;
string g_s;
vector<Node> vn;
bool input() {
cin >> g_s;
if (cin.eof()) return false;
vn.clear();
cin >> g_m;
int d;
string s;
for (int i = 0; i < g_m; ++i) {
scanf("%d->", &d);
getline(cin, s);
vn.push_back(Node(d, s));
}
return true;
}
void solve() {
LL w, v;
vector<LL> vll_w, vll_v;
for (int i = 0; i < 10; ++i) vll_v.push_back(i), vll_w.push_back(10);
for (int i = g_m - 1; i >= 0; --i) {
string &s = vn[i].s;
int d = vn[i].d, l = s.size();
v = 0, w = 1;
for (int j = 0; j < l; ++j) {
v *= vll_w[s[j] - '0'];
v += vll_v[s[j] - '0'];
v %= MOD;
w *= vll_w[s[j] - '0'];
w %= MOD;
}
vll_v[d] = v, vll_w[d] = w;
}
LL ans = 0;
string &s = g_s;
for (int i = 0; i < s.size(); ++i) {
ans *= vll_w[s[i] - '0'];
ans += vll_v[s[i] - '0'];
ans %= MOD;
}
cout << ans << endl;
}
int main() {
while (input()) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int dp[N << 1][N << 2][N][2] = {0};
char c[N << 1];
int n, l, ans = 0;
int dfs(int x, int cnt_t, int sum_t, int now) {
if (cnt_t > n) return 0;
if (x == l) {
ans = max(ans, abs(now) - ((n - cnt_t) & 1));
return ans;
}
int &sum = dp[x][now + 100][n - cnt_t][(sum_t - cnt_t) & 1];
if (sum) return sum;
if (c[x] == 'F') {
int m = ((sum_t - cnt_t) & 1) ? -1 : 1;
return sum = dfs(x + 1, cnt_t, sum_t, now + m);
}
if (c[x] == 'T') {
int ans1 = dfs(x + 1, cnt_t, sum_t + 1, now);
int m = ((sum_t - cnt_t) & 1) ? -1 : 1;
int ans2 = dfs(x + 1, cnt_t + 1, sum_t + 1, now + m);
return sum = max(ans1, ans2);
}
}
int main() {
scanf("%s%d", c, &n);
l = strlen(c);
dfs(0, 0, 0, 0);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int combi(long long int n, long long int k) {
long long int ans = 1;
k = k > n - k ? n - k : k;
long long int j = 1;
for (; j <= k; j++, n--) {
if (n % j == 0) {
ans *= n / j;
} else if (ans % j == 0) {
ans = ans / j * n;
} else {
ans = (ans * n) / j;
}
}
return ans;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int findlcm(vector<long long int> arr, long long int n) {
long long int ans = arr[0];
for (long long int i = 1; i < n; i++)
ans = (((arr[i] * ans)) / (gcd(arr[i], ans)));
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m, k;
cin >> n >> m >> k;
map<pair<long long int, long long int>, long long int> wei;
vector<vector<long long int> > adj(n + 1);
long long int x, y, l;
for (long long int i = 0; i < m; i++) {
cin >> x >> y >> l;
adj[x].push_back(y);
adj[y].push_back(x);
if (wei[{x, y}] == 0) {
wei[{x, y}] = l;
wei[{y, x}] = l;
} else {
wei[{x, y}] = min(wei[{x, y}], l);
wei[{y, x}] = min(wei[{y, x}], l);
}
}
vector<long long int> sto;
for (long long int i = 0; i < k; i++) {
cin >> x;
sto.push_back(x);
}
if (k == 0) {
cout << "-1";
} else {
queue<long long int> q;
for (long long int i = 0; i < k; i++) {
q.push(sto[i]);
}
long long int dis[n + 1];
for (long long int i = 0; i < n + 1; i++) dis[i] = 1e18;
for (long long int i = 0; i < k; i++) {
dis[sto[i]] = 0;
}
while (!q.empty()) {
long long int x = (q.front());
q.pop();
for (long long int i = 0; i < adj[x].size(); i++) {
if (dis[adj[x][i]] > dis[x] + wei[{x, adj[x][i]}]) {
dis[adj[x][i]] = dis[x] + wei[{x, adj[x][i]}];
q.push(adj[x][i]);
}
}
}
long long int ans = 1e18;
for (long long int i = 1; i <= n; i++) {
if (dis[i] > 0 && dis[i] < ans) ans = dis[i];
}
if (ans == 1e18)
cout << "-1";
else
cout << ans;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, m, count = 0;
char a[10001];
cin >> n;
cin >> a;
for (i = 0; i < n; i++) {
if (a[i] == 'o' && a[i + 1] == 'g' && a[i + 2] == 'o') {
count = 1;
for (j = i + 3;; j++) {
if (a[j] == 'g' && a[j + 1] == 'o') {
count = 1;
j++;
} else {
i = j - 1;
break;
}
}
if (count == 1) cout << "***";
} else if (a[i] == 'o' && a[i + 1] != 'g') {
cout << a[i];
} else if (a[i] == 'o' && a[i + 1] == 'g' && a[i + 2] != 'o') {
cout << a[i];
} else
cout << a[i];
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string mas[] = {"ABSINTH", "BEER", "BRANDY", "CHAMPAGNE", "GIN", "RUM",
"SAKE", "TEQUILA", "VODKA", "WHISKEY", "WINE"};
int n, babies = 0;
cin >> n;
string str;
for (int i = 0; i < n; i++) {
cin >> str;
if (isdigit(str[0])) {
if (atoi(str.c_str()) < 18) babies++;
} else {
for (int j = 0; j < 11; j++) {
if (mas[j] == str) {
babies++;
}
}
}
}
cout << babies;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int sumN(long long int n) { return (n * (n + 1)) / 2; }
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
long long int z = 1;
while (z * 2 <= n) z *= 2;
cout << sumN(n) - 2 * (z * 2 - 1) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int a[3];
for (int i = 0; i < 3; i++) cin >> a[i];
sort(a, a + 3);
int sum = 0;
for (int i = 0;; i++) {
if (a[1] + a[0] > a[2])
break;
else {
sum++;
a[1] += 1;
}
}
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, m, mat[maxn], cnt;
long long ans;
vector<int> adj[maxn];
map<int, int> mp;
struct Data {
int pri, size, ind;
} sho[maxn], cst[maxn];
bool cmp(const Data& a, const Data& b) { return a.pri > b.pri; }
bool dfs(int v) {
for (auto u : adj[v])
if (mat[u] != v && (mat[u] == -1 || dfs(mat[u]))) {
mat[u] = v;
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
memset(mat, -1, sizeof(mat));
cin >> n;
for (int i = 0; i < n; i++) {
cin >> sho[i].pri >> sho[i].size;
sho[i].ind = i + 1;
}
sort(sho, sho + n, cmp);
for (int i = 0; i < n; i++) mp[sho[i].size] = i + 1;
cin >> m;
for (int i = 0; i < m; i++) cin >> cst[i].pri >> cst[i].size;
for (int i = 0; i < m; i++) {
int ind = mp[cst[i].size];
if (ind && cst[i].pri >= sho[ind - 1].pri) {
adj[ind - 1].push_back(i);
}
ind = mp[cst[i].size + 1];
if (ind && cst[i].pri >= sho[ind - 1].pri) {
adj[ind - 1].push_back(i);
}
}
for (int i = 0; i < n; i++)
if (dfs(i)) {
ans = ans + sho[i].pri;
cnt++;
}
cout << ans << "\n" << cnt << "\n";
for (int i = 0; i < m; i++)
if (mat[i] != -1) cout << i + 1 << " " << sho[mat[i]].ind << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 23, maxs = 1 << 22 | 1;
int n, m, all, e[maxn], g[maxn], dsu[maxn][maxn], ans, out;
int dsu_find(int dsu[], int x) {
return dsu[x] < 0 ? x : dsu[x] = dsu_find(dsu, dsu[x]);
}
void dsu_merge(int dsu[], int u, int v) {
u = dsu_find(dsu, u);
v = dsu_find(dsu, v);
if (u == v) return;
if (dsu[u] < dsu[v]) swap(u, v);
if (dsu[u] == dsu[v]) --dsu[v];
dsu[u] = v;
}
void dfs(int dep, int sel, int cov) {
if (dep == n) {
if (cov < all) return;
int cnt = 0;
for (int i = 0, fir = -1; i < n; ++i) {
if (!(sel & (1 << i))) continue;
++cnt;
if (fir == -1)
fir = i;
else if (dsu_find(dsu[n], fir) != dsu_find(dsu[n], i))
return;
}
if (cnt < ans) {
ans = cnt;
out = sel;
}
return;
}
memcpy(dsu[dep + 1], dsu[dep], n * sizeof(int));
dfs(dep + 1, sel, cov);
int adt = e[dep] & sel;
for (int i = 0; i < n; ++i)
if (adt & (1 << i)) dsu_merge(dsu[dep + 1], dep, i);
dfs(dep + 1, sel | 1 << dep, cov | e[dep]);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) e[i] |= 1 << i;
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
e[u] |= 1 << v;
e[v] |= 1 << u;
}
if (m == n * (n - 1) / 2) {
puts("0");
return 0;
}
ans = n;
out = all = (1 << n) - 1;
memset(dsu[0], -1, n * sizeof(int));
dfs(0, 0, 0);
printf("%d\n", ans);
for (int i = 0, fir = 1; i < n; ++i)
if (out & (1 << i)) {
if (fir)
fir = 0;
else
putchar(' ');
printf("%d", i + 1);
}
puts("");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
void solve() {
double w, h;
cin >> w >> h;
double a1, b1, a2, b2;
cin >> a1 >> b1 >> a2 >> b2;
double w1, h1;
cin >> w1 >> h1;
double ans = 0x3f3f3f3f;
double ans1;
if (a2 - a1 + w1 <= w + eps) {
ans1 = w1 - a1;
if (ans1 <= 0) ans1 = 0;
ans = min(ans, ans1);
ans1 = w1 - (w - a2);
if (ans1 <= 0) ans1 = 0;
ans = min(ans, ans1);
}
if (b2 - b1 + h1 <= h + eps) {
ans1 = h1 - b1;
if (ans1 <= 0) ans1 = 0;
ans = min(ans, ans1);
ans1 = h1 - (h - b2);
if (ans1 <= 0) ans1 = 0;
ans = min(ans, ans1);
}
if (ans > 0x3f3f3f3f / 2) {
cout << -1 << "\n";
return;
}
printf("%.9lf\n", ans);
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
inline vector<vector<int>> f(const vector<pair<int, int>> &edges,
const int offset) {
cerr << "offset"
<< " = " << (offset) << endl;
vector<vector<int>> adj(n);
for (const pair<int, int> &e : edges) {
int u = e.first;
int v = e.second;
u += offset;
v += offset;
if (u >= n) u -= n;
if (v >= n) v -= n;
assert(0 <= u && u < n);
assert(0 <= v && v < n);
if (u > v) swap(u, v);
adj[u].push_back(v);
}
for (int i = 0; i < n; ++i) sort(adj[i].begin(), adj[i].end());
return adj;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int m;
cin >> n >> m;
vector<pair<int, int>> edges(m);
for (auto &&e : edges) cin >> e.first >> e.second;
const vector<vector<int>> adj = f(edges, 0);
for (int i = 1; i < n; ++i)
if (n % i == 0 && f(edges, i) == adj) {
cout << "Yes";
return 0;
}
cout << "No";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int D = 1000000007;
int n, a, b;
map<int, int> m;
int main() {
cin >> n >> a >> b;
for (int i = 0; i < n; ++i) {
int t;
scanf("%d", &t);
m[t] = i;
}
vector<int> v(n, -1);
bool swaped = false;
if (a > b) {
swaped = true;
std::swap(a, b);
}
while (!m.empty()) {
map<int, int>::iterator it = m.end();
--it;
int value = it->first;
int index = it->second;
if (m.find(a - value) != m.end()) {
v[m[a - value]] = 0;
v[m[value]] = 0;
m.erase(value);
m.erase(a - value);
continue;
}
if (m.find(b - value) != m.end()) {
v[m[b - value]] = 1;
v[m[value]] = 1;
m.erase(value);
m.erase(b - value);
continue;
}
printf("NO\n");
return 0;
}
cout << "YES" << endl;
if (!swaped)
for (int i = 0; i < n; ++i) {
printf("%d ", v[i]);
}
else
for (int i = 0; i < n; ++i) {
printf("%d ", 1 - v[i]);
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200500;
int a[maxn], b[maxn], mp[maxn], ordn[maxn];
int n, m;
int ck(int idx, int ord) {
if (idx < 1) return 0;
if (idx > n) return 0;
if (ordn[a[idx]] > ord) return 0;
return 1;
}
void solve() {
cin >> n >> m;
for (int i = (1), iend = (n); i <= iend; i++) cin >> a[i], mp[a[i]] = i;
for (int i = (1), iend = (m); i <= iend; i++) cin >> b[i], ordn[b[i]] = i;
int ans = 1;
for (int i = (1), iend = (m); i <= iend; i++) {
int cnt = ck(mp[b[i]] - 1, i) + ck(mp[b[i]] + 1, i);
ans = 1ll * ans * cnt % 998244353;
}
cout << ans << endl;
for (int i = (1), iend = (n); i <= iend; i++)
ordn[i] = mp[i] = a[i] = b[i] = 0;
}
int main() {
ios::sync_with_stdio(0);
int t;
cin >> t;
while (t--) solve();
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.