solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, q, tail(0), root[200010], p[200010];
struct tree {
int lc, rc, x;
tree() { lc = rc = x = 0; }
} t[200010 * 30];
template <class Aqua>
inline void read(Aqua &s) {
s = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) s = s * 10 + c - '0', c = getchar();
}
void modify(int &cur, int pre, int l, int r, int pos) {
cur = ++tail;
t[cur].lc = t[pre].lc, t[cur].rc = t[pre].rc;
t[cur].x = t[pre].x + 1;
if (l == r) return;
if (pos <= ((l + r) >> 1))
modify(t[cur].lc, t[pre].lc, l, ((l + r) >> 1), pos);
else
modify(t[cur].rc, t[pre].rc, ((l + r) >> 1) + 1, r, pos);
}
long long query(int cl, int cr, int l, int r, int L, int R) {
if (L > R) return 0;
if (L <= l && r <= R) return t[cr].x - t[cl].x;
long long ans = 0;
if (((l + r) >> 1) >= L)
ans += query(t[cl].lc, t[cr].lc, l, ((l + r) >> 1), L, R);
if (((l + r) >> 1) < R)
ans += query(t[cl].rc, t[cr].rc, ((l + r) >> 1) + 1, r, L, R);
return ans;
}
int main() {
read(n), read(q);
for (int i = 1; i <= n; i++) read(p[i]);
for (int i = 1; i <= n; i++) modify(root[i], root[i - 1], 1, n, p[i]);
long long x, y, x_, y_, ans, a, b, c;
for (int i = 1; i <= q; i++) {
read(x), read(y), read(x_), read(y_);
ans = x_ * (n - x + 1) - (x_ - x + 1) * (x_ - x + 2) / 2;
a = query(0, root[x_], 1, n, y_ + 1, n);
b = query(root[x - 1], root[n], 1, n, y_ + 1, n);
c = query(root[x - 1], root[x_], 1, n, y_ + 1, n);
ans -= a * b - c * (c + 1) / 2;
a = query(0, root[x_], 1, n, 1, y - 1);
b = query(root[x - 1], root[n], 1, n, 1, y - 1);
c = query(root[x - 1], root[x_], 1, n, 1, y - 1);
ans -= a * b - c * (c + 1) / 2;
printf("%lld\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
#pragma GCC ostarimize("O500")
using namespace std;
const bool db = false;
set<pair<int, int>> s;
int a[200100];
int main() {
int n, k, q;
scanf("%d %d %d\n", &n, &k, &q);
for (int i = 1; i <= n; i++) scanf("%d ", &a[i]);
scanf("\n");
int type, num;
set<pair<int, int>>::iterator it;
while (q--) {
scanf("%d %d\n", &type, &num);
if (type == 1) {
s.insert({-a[num], num});
if (s.size() > k) {
it = s.end();
it--;
s.erase(it);
}
} else {
if (s.count({-a[num], num}))
puts("YES");
else
puts("NO");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool is_digit(char c) { return '0' <= c && c <= '9'; }
bool is_op(char c) { return c == '+' || c == '*'; }
long long prior(char c) {
if (c == '+')
return 1;
else
return 2;
}
void work(vector<long long> &st, char op) {
long long r = st.back();
st.pop_back();
long long l = st.back();
st.pop_back();
if (op == '+') {
st.push_back(l + r);
} else if (op == '*') {
st.push_back(l * r);
}
}
long long get(string s) {
vector<long long> st;
vector<char> op;
for (long long i = 0; i < s.size(); ++i) {
if (is_digit(s[i])) {
long long x = s[i] - '0';
while (i + 1 < s.size() && is_digit(s[i + 1])) {
++i;
x = x * 10 + (s[i] - '0');
}
st.push_back(x);
} else if (is_op(s[i])) {
while (op.size() && prior(op.back()) >= prior(s[i])) {
work(st, op.back());
op.pop_back();
}
op.push_back(s[i]);
}
}
while (op.size()) {
work(st, op.back());
op.pop_back();
}
return st.back();
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
long long n = s.size();
vector<long long> p;
p.push_back(-1);
for (long long i = 0; i < n; ++i) {
if (s[i] == '*') {
p.push_back(i);
}
}
p.push_back(n);
long long ans = 0;
for (long long i = 0; i < p.size(); ++i) {
for (long long j = i + 1; j < p.size(); ++j) {
long long l = p[i] + 1;
long long r = p[j] - 1;
string t = s.substr(l, r - l + 1);
long long val = get(t);
string ns = s.substr(0, l) + to_string(val) + s.substr(r + 1, n - r - 1);
ans = max(ans, get(ns));
}
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double v, e, ans, c;
long long int n, m, i, a, b, ar[505];
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> ar[i];
ans = 0;
while (m--) {
cin >> a >> b >> c;
v = ar[a] + ar[b];
e = c;
if ((v / e) > ans) ans = (v / e);
}
cout << fixed << setprecision(10) << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100005;
map<long long, int> M;
int n, nrSeg = 0;
long long partialSum[MaxN];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
partialSum[i] = partialSum[i - 1] + x;
++M[partialSum[i]];
nrSeg = max(nrSeg, M[partialSum[i]]);
}
cout << n - nrSeg << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
int a[100001], p[100001], N, Q;
int T[2100001], ls[2100001], rs[2100001], n, root[100001];
int end[100001], steps[100001];
int build(int l, int r) {
int p = ++n;
T[p] = r - l + 1;
if (l < r) {
int m = l + r >> 1;
ls[p] = build(l, m);
rs[p] = build(m + 1, r);
}
return p;
}
int get_kth(int p, int x) {
int l = 1, r = N;
while (l < r) {
int m = l + r >> 1;
if (x <= T[ls[p]])
p = ls[p], r = m;
else
x -= T[ls[p]], p = rs[p], l = m + 1;
}
return l;
}
int P(int p, int x, int w) {
int l = 1, r = N, root;
T[root = ++n] = T[p] + w;
while (l < r) {
int m = l + r >> 1;
if (x <= m)
ls[n] = n + 1, rs[n] = rs[p], p = ls[p], r = m;
else
rs[n] = n + 1, ls[n] = ls[p], p = rs[p], l = m + 1;
T[++n] = T[p] + w;
}
return root;
}
int G(int p, int x) {
int l = 1, r = N, ans = 0;
while (l < r) {
int m = l + r >> 1;
if (x <= m)
p = ls[p], r = m;
else
ans += T[ls[p]], p = rs[p], l = m + 1;
}
return ans + T[p];
}
int main() {
scanf("%d%d", &N, &Q);
for (int i = 1; i <= N; i++) scanf("%d", a + i);
end[0] = a[1] - 1;
steps[0] = 0;
for (int i = 1; i < N; i++) {
int add = (a[i + 1] - end[i - 1] - 1) / i;
end[i] = end[i - 1] + i * add;
steps[i] = steps[i - 1] + add;
}
for (int i = 2; i <= N; i++) p[i] = (p[i - 1] + a[i] - a[i - 1]) % (i - 1);
root[N] = build(1, N);
for (int i = N; i; i--) {
p[i] = get_kth(root[i], p[i] + 1);
root[i - 1] = P(root[i], p[i], -1);
}
while (Q--) {
int x, k;
scanf("%d%d", &x, &k);
if (x < a[1]) {
printf("%d\n", x);
continue;
}
int belong = std::lower_bound(end + 1, end + N, x) - end;
k += steps[belong - 1] + (x - end[belong - 1] - 1) / belong + 1;
int ord = (x - end[belong - 1] - 1) % belong + 1;
ord = get_kth(root[belong], ord);
belong = std::lower_bound(steps + 1, steps + N, k) - steps;
printf("%lld\n", end[belong - 1] +
(long long)(k - steps[belong - 1] - 1) * belong +
G(root[belong], ord));
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int s[1000000];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a, b;
cin >> a >> b;
vector<int> v;
int tot = 0, cnt = 0;
for (int(i) = (1); (i) < (a + 1); (i)++) {
if (tot + i <= a) {
tot += i;
v.push_back(i);
cnt++;
} else
break;
}
int rem = a - tot;
for (int(i) = 0; (i) < (rem); (i)++) v[v.size() - 1 - i] += 1;
for (int(i) = 0; (i) < (v.size()); (i)++) s[v[i]] += 1;
cout << cnt << "\n";
for (int(i) = 0; (i) < (v.size()); (i)++) cout << v[i] << " ";
cout << "\n";
tot = 0, cnt = 0;
vector<int> v2;
for (int(i) = (1); (i) < (b + 1); (i)++) {
if (s[i] > 0) continue;
if (i + tot <= b) {
tot += i;
v2.push_back(i);
} else
break;
}
cout << v2.size() << "\n";
for (int(i) = 0; (i) < (v2.size()); (i)++) cout << v2[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ifstream fin("input.txt", ios::in);
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cout << setprecision(10);
cout << fixed;
long long n, a, b, c;
cin >> n >> a >> b >> c;
if (a <= b - c) return cout << n / a, 0;
if (n < b) {
cout << n / a;
return 0;
}
long long ans = 0;
long long op = (n - b) / (b - c);
ans += op;
n -= op * (b - c);
if (n >= b) {
ans++;
n -= b;
n += c;
}
if (n >= b) {
ans++;
n -= b;
n += c;
}
ans += n / a;
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long t, n, k, p;
cin >> t;
while (t--) {
cin >> n >> k;
long long a = n;
for (long long i = 1; i * i <= n && i <= k; ++i) {
if (n % i == 0) {
p = n / i;
a = min(a, p);
if (p <= k) {
a = min(a, i);
}
}
}
cout << a << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int N = 20, M = 1e4 + 10, msiz = N * N;
const int dx[5] = {1, -1, 0, 0, 0}, dy[5] = {0, 0, 1, -1, 0};
int base[msiz][msiz], n, m, k, f[msiz], a[M][4], cur[msiz][msiz],
tmp[msiz][msiz], cb[msiz][msiz], siz, h[N][N];
bool check(int x, int y) {
return (x >= 0 && x < n && y >= 0 && y < m && !h[x][y]);
}
void modified(int x, int y, int type) {
if (!type) f[x * m + y] = 0;
h[x][y] = type ^ 1;
for (auto i = 0; i <= 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (check(nx, ny))
base[x * m + y][nx * m + ny] = base[nx * m + ny][x * m + y] = type;
}
}
void init() {
for (auto x = 0; x < n; x++)
for (auto y = 0; y < m; y++) modified(x, y, 1);
siz = n * m;
f[0] = 1;
}
void upmatrix(int x) {
memset(cur, 0, sizeof(cur));
for (auto i = 0; i < siz; i++) cur[i][i] = 1;
for (auto i = 0; i < siz; i++)
for (auto j = 0; j < siz; j++) cb[i][j] = base[i][j];
while (x) {
if (x & 1) {
for (auto i = 0; i < siz; i++)
for (auto j = 0; j < siz; j++) tmp[i][j] = cur[i][j], cur[i][j] = 0;
for (auto i = 0; i < siz; i++)
for (auto j = 0; j < siz; j++)
for (auto k = 0; k < siz; k++)
cur[i][j] = (cur[i][j] + 1LL * tmp[i][k] * cb[k][j]) % MOD;
}
for (auto i = 0; i < siz; i++)
for (auto j = 0; j < siz; j++) tmp[i][j] = cb[i][j], cb[i][j] = 0;
for (auto i = 0; i < siz; i++)
for (auto j = 0; j < siz; j++)
for (auto k = 0; k < siz; k++)
cb[i][j] = (cb[i][j] + 1LL * tmp[i][k] * tmp[k][j]) % MOD;
x >>= 1;
}
for (auto i = 0; i < siz; i++) tmp[0][i] = f[i];
memset(f, 0, sizeof(f));
for (auto i = 0; i < siz; i++)
for (auto j = 0; j < siz; j++)
f[i] = (f[i] + 1LL * tmp[0][j] * cur[j][i]) % MOD;
}
void solve() {
init();
for (auto i = 1; i <= k; i++) {
upmatrix(a[i][3] - a[i - 1][3]);
if (a[i][0] == 0) printf("%d\n", f[a[i][1] * m + a[i][2]]);
if (a[i][0] == 1) modified(a[i][1], a[i][2], 0);
if (a[i][0] == 2) modified(a[i][1], a[i][2], 1);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (auto i = 1; i <= k; i++)
for (auto j = 0; j <= 3; j++) scanf("%d", a[i] + j), a[i][j]--;
solve();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, flag = 0;
cin >> n >> m;
string s[2][m], c;
for (int i = 0; i < m; i++) {
cin >> s[0][i];
cin >> s[1][i];
}
for (int i = 0; i < n; i++) {
cin >> c;
flag = 0;
for (int j = 0; j < 2; j++) {
for (int k = 0; k < m; k++) {
if (s[j][k] == c) {
if (s[1][k].length() < s[0][k].length())
cout << s[1][k] << " ";
else
cout << s[0][k] << " ";
flag = 1;
break;
}
}
if (flag == 1) break;
}
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isPalindrome(string n, int l, int r) {
if (l >= r)
return true;
else if (n[l] != n[r])
return false;
return isPalindrome(n, l + 1, r - 1);
}
int main() {
int n;
cin >> n;
while (n % 10 == 0) n /= 10;
string a = std::to_string(n);
if (isPalindrome(a, 0, a.length() - 1))
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, pos, maximo;
string s;
cin >> n;
while (n > 0) {
cin >> s;
pos = -1;
maximo = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'R') {
if (i - pos > maximo) {
maximo = i - pos;
}
pos = i;
}
}
if ((s.size()) - pos > maximo) {
maximo = (s.size()) - pos;
}
cout << maximo << endl;
n--;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<long long> ls(n), nw;
for (long long &x : ls) cin >> x;
long long amx = 0, mx = 0, ni, sm = 0, u = 0, a, b;
for (; u < k; u++) sm += ls[u];
nw.push_back(sm);
vector<pair<long long, long long>> lk;
for (u = k; u < n; u++) {
sm += (ls[u] - ls[u - k]);
nw.push_back(sm);
}
for (u = n - k; u >= 0; u--) {
if ((n - 2 * k - u >= 0) && nw[u] + lk[n - 2 * k - u].first >= amx) {
amx = nw[u] + lk[n - 2 * k - u].first;
a = u;
b = lk[n - 2 * k - u].second;
}
if (nw[u] >= mx) {
mx = nw[u], ni = u;
}
lk.push_back({mx, ni});
}
cout << a + 1 << " " << b + 1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int t, n, to[200001];
int caled[200001];
int main() {
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> to[i];
memset(caled, 0, sizeof(caled));
for (int i = 1; i <= n; i++) {
if (caled[i]) continue;
int p = i, cnt = 0;
while (to[p] != i) cnt++, p = to[p];
p = i;
caled[p] = ++cnt;
while (to[p] != i) caled[p] = cnt, p = to[p];
}
for (int i = 1; i <= n; i++) cout << caled[i] << ' ';
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> p;
void generate_prime(int a) {
int i;
for (i = 2; i * i <= a; i++) {
if (a % i == 0) {
p.push_back(i);
while (a % i == 0) a /= i;
}
}
if (a > 1) p.push_back(a);
}
void modify_prime(int a, int b) {
int i;
vector<int> q;
for (i = 0; i < p.size(); i++)
if (a % p[i] == 0 || b % p[i] == 0) {
q.push_back(p[i]);
}
p.clear();
for (i = 0; i < q.size(); i++) p.push_back(q[i]);
}
int main(int argc, char *argv[]) {
int n, a, b, i, j;
cin >> n;
cin >> a >> b;
generate_prime(a);
generate_prime(b);
sort(p.begin(), p.end());
for (i = 1; i < n; i++) {
cin >> a >> b;
modify_prime(a, b);
}
if (p.size())
cout << p[0] << endl;
else
cout << -1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const double eps = 1e-8;
const int INF32 = 0x3f3f3f3f;
const long long INF64 = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const unsigned long long mod2 = 1;
const int N = 1e6 + 5;
const int sz = (1 << 20);
int a[N], n;
long long getnum(int m) {
long long ret = 0;
for (int i = 0, p = n - 1; i < n; ++i) {
p = max(p, i);
while (p > i && a[i] + a[p] >= m) --p;
ret += n - p - 1;
}
return ret;
}
bool calc(int m) {
for (auto i = lower_bound(a, a + n, m << 1); i != a + n; ++i) *i %= m << 1;
sort(a, a + n);
return (getnum(m) - getnum(m << 1) + getnum(3 * m)) & 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
int m = (1 << 29), ans = 0;
while (m) {
if (calc(m)) ans += m;
m >>= 1;
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
T abs(T x) {
return x < 0 ? -x : x;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
bool chmin(T& x, const T& y) {
if (x > y) {
x = y;
return true;
}
return false;
}
template <typename T>
bool chmax(T& x, const T& y) {
if (x < y) {
x = y;
return true;
}
return false;
}
const int INF = 1e+9 + 42;
const int MOD = 1000000007;
int main(int, char**) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
while (cin >> n) {
int ans = 1;
set<int> l;
set<int> r;
l.insert(-INF);
r.insert(INF);
vector<int> v;
bool ok = true;
for (int i = 0; i < n; ++i) {
string c;
int p;
cin >> c >> p;
if (c == "ADD") {
v.push_back(p);
} else {
int pmin = *l.rbegin();
int pmax = *r.begin();
if (pmin < p && p < pmax) {
ans += ans;
if (ans >= MOD) {
ans -= MOD;
}
} else if (p <= pmin) {
auto it = l.find(p);
if (it != l.end()) {
l.erase(it);
}
} else if (pmax <= p) {
auto it = r.find(p);
if (it != r.end()) {
r.erase(it);
}
}
ok &= pmin <= p && p <= pmax;
for (auto& x : v) {
if (x < p) {
l.insert(x);
} else if (p < x) {
r.insert(x);
}
}
v.clear();
}
}
{
int pmin = *l.rbegin();
int pmax = *r.begin();
int c = 0;
for (auto& x : v) {
c += (pmin < x && x < pmax);
}
ans = ans * (long long)(c + 1) % MOD;
}
cout << (ok ? ans : 0) << endl;
}
cerr << "Time execute: " << clock() / (double)CLOCKS_PER_SEC << " sec"
<< endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int N = 2e5 + 5;
int n, m;
int pre[2][N], cnt[2][N];
int Find(int x, int d) {
return pre[d][x] == x ? x : pre[d][x] = Find(pre[d][x], d);
}
void join(int x, int y, int d) {
int fx = Find(x, d), fy = Find(y, d);
if (fx != fy) {
pre[d][fx] = fy;
cnt[d][fy] += cnt[d][fx];
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++)
pre[0][i] = pre[1][i] = i, cnt[0][i] = cnt[1][i] = 1;
for (int i = 1; i <= n - 1; i++) {
int x, y, d;
scanf("%d%d%d", &x, &y, &d);
join(x, y, d);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
int fx = Find(i, 0), fy = Find(i, 1);
ans += 1ll * cnt[0][fx] * cnt[1][fy] - 1;
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[1000];
int i = 0, lower = 0, upper = 0;
cin >> a;
int len = strlen(a);
while (a[i] != 0) {
if (a[i] >= 'a' && a[i] <= 'z') {
lower++;
i++;
} else if (a[i] >= 'A' && a[i] <= 'Z') {
upper++;
i++;
} else
i++;
}
if (upper > lower) {
for (i = 0; i < len; i++) {
if (a[i] >= 97 && a[i] <= 122) {
a[i] = a[i] - 32;
}
}
cout << a;
} else {
for (i = 0; i < len; i++) {
if (a[i] >= 65 && a[i] <= 92) {
a[i] = a[i] + 32;
}
}
cout << a;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[10001], i, j, k, p, n, m;
cin >> n >> m;
int c = 0;
for (int t = 1; t <= n; t++) {
cin >> p;
for (i = 0; i < p; i++) {
cin >> a[c];
c++;
}
}
sort(a, a + c);
k = 1;
for (i = 0; i < c; i++) {
if (a[i] == k) {
k++;
}
}
if (k - 1 == m)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 0x3f3f3f3f;
struct P {
int x, y;
} point[41];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, maxx = INT_MIN, maxy = INT_MIN, minx = INT_MAX, miny = INT_MAX;
cin >> n;
for (auto i = (0); i < (4 * n + 1); ++i) {
cin >> point[i].x >> point[i].y;
maxx = max(maxx, point[i].x);
maxy = max(maxy, point[i].y);
minx = min(minx, point[i].x);
miny = min(miny, point[i].y);
}
for (auto i1 = (minx); i1 < (maxx + 1); ++i1)
for (auto i2 = (i1); i2 < (maxx + 1); ++i2)
for (auto j1 = (miny); j1 < (maxy + 1); ++j1)
for (auto j2 = (j1); j2 < (maxy + 1); ++j2) {
P tmp;
int cnt = 0;
for (int k = 0; cnt <= 1 && k < 4 * n + 1; ++k)
if ((i1 != point[k].x && i2 != point[k].x && j1 != point[k].y &&
j2 != point[k].y) ||
i1 > point[k].x || i2 < point[k].x || j1 > point[k].y ||
j2 < point[k].y) {
tmp = point[k];
++cnt;
}
if (cnt == 1) {
cout << tmp.x << ' ' << tmp.y;
return 0;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int towers[200000];
int heightCount[200001];
int main() {
int n, k;
cin >> n >> k;
int minheight = 200000;
int maxHeight = 0;
for (int i = 0; i < n; i++) {
cin >> towers[i];
minheight = min(minheight, towers[i]);
maxHeight = max(maxHeight, towers[i]);
heightCount[towers[i]]++;
}
for (int i = 200000; i > 0; i--) {
heightCount[i - 1] += heightCount[i];
}
long long ans = 0;
int sum = 0;
for (int i = 200000; i > minheight; i--) {
sum += heightCount[i];
if (sum > k) {
sum -= heightCount[i];
ans++;
sum = 0;
i++;
}
}
if (maxHeight != minheight) {
++ans;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int test;
cin >> test;
while (test--) {
long long a, b;
cin >> a >> b;
cout << a + b << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mod_pow(long long int a, long long int b, long long int m) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
for (long long int i = 0; i < n - 1; i++) cout << a[i] + a[i + 1] << " ";
cout << a[n - 1];
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int q;
q = 1;
while (q--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, u, v, d[2010];
long long f[2010][2010], p[2010][2010];
vector<pair<int, long long> > a[2010];
queue<int> Q;
bool b[2010];
struct dkm {
int u, v;
long long d;
dkm(int u = 0, int v = 0, long long d = 0) : u(u), v(v), d(d) {}
bool operator<(const dkm& clgt) const { return d < clgt.d; }
} w[2000010];
int get(int i) {
if (d[i] == i) return i;
return d[i] = get(d[i]);
}
void loang(int s) {
memset(b, 0, sizeof(b));
while (!Q.empty()) Q.pop();
Q.push(s);
b[s] = 1;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int j = 0; j < a[u].size(); j++) {
int v = a[u][j].first;
long long l = a[u][j].second;
if (b[v]) continue;
p[s][v] = p[s][u] + l;
Q.push(v);
b[v] = 1;
}
}
}
int main() {
scanf("%d", &n);
for (int i = (1), _b = (n); i <= _b; i++)
for (int j = (1), _b = (n); j <= _b; j++) {
scanf("%lld", &f[i][j]);
if (i < j) w[++m] = dkm(i, j, f[i][j]);
}
for (int i = (1), _b = (n); i <= _b; i++) d[i] = i;
sort(w + 1, w + m + 1);
for (int i = (1), _b = (m); i <= _b; i++) {
u = get(w[i].u);
v = get(w[i].v);
if (u != v) {
if (w[i].d == 0) printf("NO"), exit(0);
p[w[i].u][w[i].v] = p[w[i].v][w[i].u] = w[i].d;
a[w[i].u].push_back(pair<int, long long>(w[i].v, w[i].d));
a[w[i].v].push_back(pair<int, long long>(w[i].u, w[i].d));
d[u] = v;
}
}
for (int i = (1), _b = (n); i <= _b; i++) loang(i);
for (int i = (1), _b = (n); i <= _b; i++)
for (int j = (1), _b = (n); j <= _b; j++)
if (p[i][j] != f[i][j]) printf("NO"), exit(0);
printf("YES");
}
| 5 |
#include <bits/stdc++.h>
int main() {
int cot, hang, buoc, c, h, so;
for (hang = 1; hang <= 5; hang++) {
for (cot = 1; cot <= 5; cot++) {
scanf("%d", &so);
if (so == 1) {
c = cot - 3;
h = hang - 3;
if (c < 0) c = 0 - c;
if (h < 0) h = 0 - h;
buoc = c + h;
}
}
}
printf("%d", buoc);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> E[200005];
int dp[1005][1005];
const int inf = 1000000000;
bool ans[200005];
struct query {
int l, r, s, t, id;
query(int l, int r, int s, int t, int id) : l(l), r(r), s(s), t(t), id(id) {}
};
vector<query> Q[200005];
int main() {
ios_base::sync_with_stdio(0);
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) cin >> E[i].first >> E[i].second;
for (int i = 1; i <= q; i++) {
int l, r, s, t;
cin >> l >> r >> s >> t;
Q[l].push_back(query(l, r, s, t, i));
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) dp[i][j] = inf;
for (int i = m; i > 0; i--) {
int a = E[i].first;
int b = E[i].second;
dp[a][b] = dp[b][a] = i;
for (int j = 1; j <= n; j++) {
if (dp[a][j] > dp[b][j])
dp[a][j] = dp[b][j];
else
dp[b][j] = dp[a][j];
}
for (int j = 0; j < Q[i].size(); j++)
if (Q[i][j].r >= dp[Q[i][j].s][Q[i][j].t]) ans[Q[i][j].id] = true;
}
for (int i = 1; i <= q; i++) cout << (ans[i] == true ? "Yes\n" : "No\n");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, sum = 0, k;
vector<int> kub;
int main() {
cin >> n;
kub.resize(n);
for (int i = 0; i < n; i++) {
cin >> kub[i];
sum += kub[i];
}
if (sum % n != 0) {
cout << "Unrecoverable configuration." << endl;
return 0;
}
int sr = sum / n, k1, k2, ki1, ki2;
bool ok1 = true, ok2 = true;
;
for (int i = 0; i < n; i++) {
if (kub[i] != sr) {
if (ok1) {
k1 = kub[i];
ki1 = i;
ok1 = false;
} else if (ok2) {
k2 = kub[i];
ki2 = i;
ok2 = false;
} else {
cout << "Unrecoverable configuration." << endl;
return 0;
}
}
}
if (ok1 && ok2) {
cout << "Exemplary pages." << endl;
return 0;
}
if (ok1 ^ ok2) {
cout << "Unrecoverable configuration." << endl;
return 0;
}
if (k1 + k2 != 2 * sr) {
cout << "Unrecoverable configuration." << endl;
return 0;
}
if (k1 > k2) {
printf("%d ml. from cup #%d to cup #%d.", k1 - sr, ki2 + 1, ki1 + 1);
} else {
printf("%d ml. from cup #%d to cup #%d.", k2 - sr, ki1 + 1, ki2 + 1);
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char w1[40], w2[40];
int n, m, k, a[1000005], b[1000005], ans = -1, ansl, ansr, cnt[1 << 20], ofs;
int t1[40], t2[40], g[1 << 20], f[1 << 20][40];
int main() {
scanf("%d%d%d%s%s", &n, &m, &k, w1 + 1, w2 + 1);
for (int i = 1; i < 1 << k; i++) cnt[i] = cnt[i ^ (i & -i)] + 1;
for (int j = 1; j <= k; j++)
a[0] = (a[0] << 1) ^ w1[j] ^ '0', b[0] = (b[0] << 1) ^ w2[j] ^ '0',
t1[j] = j;
ofs = k - cnt[a[0]] - cnt[b[0]];
for (int i = 0; i < 1 << k; g[i++] = n + 1)
for (int j = 1; j <= k; j++) f[i][j] = n + 1;
g[a[0]] = 0;
for (int i = 1, x, y; i <= n; i++) {
scanf("%d%d", &x, &y);
swap(t1[x], t1[y]);
for (int j = 1; j <= k; j++) t2[t1[j]] = j;
for (int j = 1; j <= k; j++)
a[i] = (a[i] << 1) ^ w1[t2[j]] ^ '0',
b[i] = (b[i] << 1) ^ w2[t2[j]] ^ '0';
g[a[i]] = min(g[a[i]], i);
}
for (int t = 0; t < k; t++)
for (int j = 0; j < 1 << k; j += 1 << t + 1)
for (int i = j; i < (j ^ (1 << t)); i++)
g[i] = min(g[i], g[i ^ (1 << t)]);
for (int i = 0; i < 1 << k; i++) f[i][cnt[i]] = g[i];
for (int t = 0; t < k; t++)
for (int j = 0; j < 1 << k; j += 1 << t + 1)
for (int i = j; i < (j ^ (1 << t)); i++)
for (int o = 1; o <= cnt[i]; o++)
f[i ^ (1 << t)][o] = min(f[i ^ (1 << t)][o], f[i][o]);
for (int i = 0; i < 1 << k; i++)
for (int j = k; j; j--) f[i][j - 1] = min(f[i][j - 1], f[i][j]);
for (int i = m; i <= n; i++) {
int t = k;
while (f[b[i]][t] > i - m) t--;
if (t * 2 + ofs > ans) ans = t * 2 + ofs, ansl = f[b[i]][t] + 1, ansr = i;
}
printf("%d\n%d %d\n", ans, ansl, ansr);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
if (y == 0) return 1;
long long int p = power(x, y / 2) % 1000000007;
p = (p * p) % 1000000007;
return (y % 2 == 0) ? p : (x * p) % 1000000007;
}
long long int factorial[100007] = {0};
long long int fact(long long int n) {
memset(factorial, 0, sizeof(factorial));
factorial[0] = 1;
factorial[1] = 1;
for (int i = 1; i < n; i++) {
factorial[i] = (factorial[i - 1] * i) % 1000000007;
}
}
long long int ncr(long long int n, long long int r) {
long long int ans = 1;
long long int i;
for (i = r + 1; i <= n; i++) {
ans = (ans * i) % 1000000007;
}
for (i = 2; i <= n - r; i++) {
ans = (ans * power(i, 1000000007 - 2)) % 1000000007;
}
return ans;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool prime[100000006];
void sieve(long long int n) {
memset(prime, true, sizeof(prime));
prime[1] = false;
for (long long int p = 2; p * p <= n; p++) {
if (prime[p]) {
for (long long int i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
long long int i;
for (i = 0; i < n; i++) {
cin >> a[i];
}
vector<long long int> v;
long long int count = 1;
for (i = 0; i < n / 2; i++) {
if (a[i] == a[i + 1]) {
count++;
} else {
v.push_back(count);
count = 1;
}
}
if (v.size() < 3)
cout << 0 << " " << 0 << " " << 0 << '\n';
else {
long long int g = v[0], s, b;
i = 1;
long long int sum = 0;
int bol = 0;
while (i < v.size()) {
sum += v[i];
i++;
if (sum > v[0]) break;
}
if (sum <= v[0]) {
bol = 1;
} else {
s = sum;
}
if (bol == 0) {
sum = 0;
while (i < v.size()) {
sum += v[i];
i++;
}
if (sum <= v[0])
bol = 1;
else
b = sum;
}
if (bol == 1)
cout << 0 << " " << 0 << " " << 0 << '\n';
else
cout << g << " " << s << " " << b << '\n';
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long double pi = acos(-1);
const int MOD = 1e9 + 7;
vector<vector<int> > graph;
int especial = -1;
void dfs(int atual, vector<int> &usados, int color) {
usados[atual] = color;
for (int v : graph[atual])
if (usados[v] == 0)
dfs(v, usados, color);
else if (usados[v] == color)
especial = v;
}
int main() {
ios::sync_with_stdio(false);
;
int n;
cin >> n;
graph.resize(n);
vector<int> v(n);
vector<int> ind(n, 0);
for (int i = 0; i < n; i++) {
cin >> v[i];
v[i]--;
}
for (int i = 0; i < n; i++)
if (i != v[i]) {
graph[v[i]].push_back(i);
ind[i]++;
}
vector<int> root;
vector<int> cicle;
vector<int> usados(n, 0);
for (int i = 0; i < n; i++) {
if (ind[i] == 0) {
dfs(i, usados, 1);
root.push_back(i);
}
}
int color = 2;
for (int i = 0; i < n; i++)
if (usados[i] == 0 and graph[i].size() > 0 and ind[i] > 0) {
dfs(i, usados, color++);
if (especial != -1) cicle.push_back(especial);
especial = -1;
}
if (root.size() == 0) {
cout << cicle.size() << "\n";
v[cicle[0]] = cicle[0];
for (int i = 1; i < cicle.size(); i++) v[cicle[i]] = cicle[0];
for (int X = 0; X < v.size(); X++) cout << v[X] + 1 << " ";
cout << "\n";
;
} else {
cout << root.size() - 1 + cicle.size() << "\n";
for (int i = 1; i < root.size(); i++) v[root[i]] = root[0];
for (int i = 0; i < cicle.size(); i++) v[cicle[i]] = root[0];
for (int X = 0; X < v.size(); X++) cout << v[X] + 1 << " ";
cout << "\n";
;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, m, p, t, s, u, a[1000005], h[1000005], v[1000005], g[5002][5002],
f[2][5002];
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] > t) t = a[i];
}
h[0] = v[m] = g[0][0] = s = 1;
for (int i = 1; i <= m; i++) h[i] = 1ll * h[i - 1] * i % p;
for (int i = m; i; i--) v[i - 1] = 1ll * v[i] * i % p;
for (int i = 1; i <= t; i++)
for (int j = 1; j <= i && j <= m; j++)
g[i][j] = (g[i - 1][j - 1] + 1ll * g[i - 1][j] * (j - 1) % p) % p;
for (int i = 1, b = 0; i <= n; i++, b ^= 1) {
for (int j = 1; j <= t; j++) f[b][j] = 0;
for (int j = 1; j <= a[i] && j <= m; j++)
f[b][j] = (1ll * (1ll * v[m - j] * s % p - 1ll * f[b ^ 1][j] * h[j] % p) *
g[a[i]][j] % p +
p) %
p,
(u += f[b][j]) %= p;
s = u, u = 0;
}
return printf("%d\n", s), 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tt;
cin >> tt;
while (tt--) {
int n, k;
cin >> n >> k;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
int r = n - 2;
while (k--) {
a[n - 1] += a[r];
r--;
}
cout << a[n - 1] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
register long long x = 0, f = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ '0');
ch = getchar();
}
return f ? x : -x;
}
const int N = 1e5 + 10, M = 1e6;
long long m;
struct point {
int x, y;
};
inline point operator+(const point &a, const point &b) {
return (point){a.x + b.x, a.y + b.y};
}
inline point operator-(const point &a, const point &b) {
return (point){a.x - b.x, a.y - b.y};
}
inline long long cross(const point &a, const point &b) {
return 1ll * a.x * b.y - 1ll * b.x * a.y;
}
inline bool operator<(const point &a, const point &b) {
return a.x == b.x ? a.y < b.y : a.x < b.x;
}
set<point> s;
inline set<point>::iterator pre(set<point>::iterator it) { return --it; }
inline set<point>::iterator nxt(set<point>::iterator it) { return ++it; }
inline void ins(point a) {
set<point>::iterator r = s.lower_bound(a), l = pre(r);
if (r != s.end() && cross((*l) - a, (*r) - a) >= 0) return;
while (l != s.begin() && cross((*pre(l)) - (*l), a - (*l)) >= 0)
--l, s.erase(nxt(l));
if (r != s.end())
while (nxt(r) != s.end() && cross(a - (*r), (*nxt(r)) - (*r)) >= 0)
++r, s.erase(pre(r));
s.insert(a);
}
inline bool work(int t, int h) {
set<point>::iterator x = s.lower_bound((point){(int)ceil((double)h / t), 0});
if (x == s.end()) return 0;
point l = (*pre(x)), r = (*x);
long long tim =
1ll * (r.x - l.x) * t * l.y + 1ll * (r.y - l.y) * (h - 1ll * t * l.x);
return tim <= m * (r.x - l.x);
}
int main() {
int j = 0, q = read();
m = read();
s.insert((point){0, 0});
for (int i = (1), _ed = (q); i <= _ed; ++i) {
int op = read() - 1, a = (read() + j) % M + 1, b = (read() + j) % M + 1;
if (!op)
ins((point){a, b});
else {
int f = work(a, b);
if (!f)
puts("NO");
else
puts("YES"), j = i;
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int t, n, k, m;
const int N = 1e5 + 50, M = 8;
int l[N], r[N];
pair<int, int> e[N << 1];
bool used[M];
int bit[N];
int dp[1 << M];
inline void update(int &a, int b, int c = 0) {
if (b == -1) return;
a = max(a, b + c);
}
bool isGood[1 << M];
int main(int argc, char const *argv[]) {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < (1 << k); ++i) {
int j = i;
int cnt = 0;
while (j) {
cnt += j & 1;
j >>= 1;
}
if (cnt & 1) isGood[i] = 1;
}
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &l[i], &r[i]);
e[i * 2 - 2] = make_pair(l[i], i);
e[i * 2 - 1] = make_pair(r[i] + 1, -i);
}
sort(e, e + 2 * n);
memset(bit, -1, sizeof bit);
int lim = 1 << k, lastx = 0;
memset(dp, -1, sizeof dp);
dp[0] = 0;
for (int i = 0; i < n * 2; ++i) {
auto &now = e[i];
int id = abs(now.second), type = now.second;
int dx = now.first - lastx;
lastx = now.first;
;
for (int mask = 0; mask < lim; ++mask)
update(dp[mask], dp[mask], isGood[mask] * dx);
if (type < 0) {
int &b = bit[id];
for (int mask = 0; mask < lim; ++mask) {
update(dp[mask], dp[mask | (1 << b)]);
dp[mask | (1 << b)] = -1;
}
used[b] = false;
b = -1;
} else {
int b = -1;
for (int j = 0; j < k; ++j)
if (!used[j]) {
used[j] = true;
bit[id] = j;
b = j;
break;
}
for (int mask = lim - 1; mask >= 0; --mask)
if ((mask >> b) & 1) update(dp[mask], dp[mask ^ (1 << b)]);
};
for (int j = 0; j < lim; ++j)
;
}
int ans = 0;
for (int i = 0; i < lim; ++i) update(ans, dp[i]);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline long long read1() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
using namespace std;
const int N = 3e5 + 10;
int n, m, siz, d[N], dis[N], top, st[N], p[N], pre[N];
int cnt, head[N], nxt[N + N], to[N + N];
bool vis[N];
void add_edge(int u, int v) {
nxt[++cnt] = head[u];
to[cnt] = v;
head[u] = cnt;
}
void dfs(int u) {
vis[u] = 1;
st[++siz] = u;
for (int i = head[u], v; i; i = nxt[i])
if (!vis[v = to[i]]) dfs(v);
}
int main() {
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int u = read();
int v = read();
d[u]++;
d[v]++;
add_edge(u, v);
add_edge(v, u);
}
memset(dis, -1, sizeof dis);
dis[1] = 1;
st[++top] = 1;
for (int i = 1; i <= top; i++)
for (int u = st[i], j = head[u], v; j; j = nxt[j])
if (!~dis[v = to[j]]) {
dis[v] = dis[u] + 1;
pre[v] = u;
st[++top] = v;
}
if (~dis[n] && dis[n] <= 5) {
printf("%d\n", dis[n] - 1);
top = 0;
for (int i = n; i != 1; i = pre[i]) st[++top] = i;
st[++top] = 1;
for (int i = top; i >= 1; i--) printf("%d ", st[i]);
return 0;
}
p[1] = top;
if (d[1] + 1 < p[1]) {
vis[1] = 1;
for (int i = head[1]; i; i = nxt[i]) vis[to[i]] = 1;
for (int i = head[1]; i; i = nxt[i])
for (int j = head[to[i]]; j; j = nxt[j])
if (!vis[to[j]]) {
puts("4");
printf("%d %d %d %d %d\n", 1, to[i], to[j], 1, n);
return 0;
}
} else {
if (~dis[n] && dis[n] <= 6) {
printf("%d\n", dis[n] - 1);
top = 0;
for (int i = n; i != 1; i = pre[i]) st[++top] = i;
st[++top] = 1;
for (int i = top; i; i--) printf("%d ", st[i]);
return 0;
}
vis[1] = 1;
for (int i = head[1], v; i; i = nxt[i])
if (!vis[v = to[i]]) {
siz = 0;
dfs(v);
for (int j = 1; j <= siz; j++)
if (d[v = st[j]] < siz) {
memset(vis, 0, sizeof vis);
vis[v] = 1;
for (int k = head[v]; k; k = nxt[k]) vis[to[k]] = 1;
for (int k = head[v]; k; k = nxt[k])
for (int l = head[to[k]]; l; l = nxt[l])
if (!vis[to[l]]) {
puts("5");
printf("%d %d %d %d %d %d\n", 1, v, to[k], to[l], v, n);
return 0;
}
}
}
}
puts("-1");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct A {
int u, v, w, i;
bool operator<(const A& o) const { return w < o.w; }
};
A E[250100];
int p[250100];
int level[250100];
int dp[18][250100];
long long MAX[18][250100];
int mark[250100];
long long ans[250100];
long long sum;
vector<pair<int, int> > g[250100];
int fin(int i) { return p[i] == i ? i : p[i] = fin(p[i]); }
void dfs(int now, int state = 1, int p = 0) {
level[now] = state;
for (auto x : g[now]) {
if (x.first == p) continue;
dfs(x.first, state + 1, now);
dp[0][x.first] = now;
MAX[0][x.first] = x.second;
}
}
long long LCA(int u, int v) {
long long ma = 0;
if (level[u] < level[v]) swap(u, v);
for (int i = 17; i >= 0; i--)
if (level[dp[i][u]] >= level[v]) ma = max(ma, MAX[i][u]), u = dp[i][u];
if (u == v) return ma;
for (int i = 17; i >= 0; i--)
if (dp[i][u] != dp[i][v])
ma = max(ma, max(MAX[i][u], MAX[i][v])), u = dp[i][u], v = dp[i][v];
return max(ma, max(MAX[0][u], MAX[0][v]));
}
int main() {
int n, m, u, v, w;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &u, &v, &w);
E[i] = {u, v, w, i};
}
sort(E, E + m);
for (int i = 0; i < m; i++) {
int pu = fin(E[i].u), pv = fin(E[i].v);
if (pu != pv) {
mark[i] = 1;
p[pu] = pv;
sum += E[i].w;
g[E[i].u].push_back({E[i].v, E[i].w});
g[E[i].v].push_back({E[i].u, E[i].w});
}
}
dfs(1);
for (int i = 1; i <= 17; i++)
for (int j = 1; j <= n; j++)
dp[i][j] = dp[i - 1][dp[i - 1][j]],
MAX[i][j] = max(MAX[i - 1][j], MAX[i - 1][dp[i - 1][j]]);
for (int i = 0; i < m; i++) {
int u = E[i].u, v = E[i].v;
if (mark[i])
ans[E[i].i] = sum;
else
ans[E[i].i] = sum + E[i].w - LCA(u, v);
}
for (int i = 0; i < m; i++) printf("%lld\n", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n;
string s;
map<string, int> hmap;
cin >> n;
int max = INT_MIN;
for (i = 0; i < n; i++) {
cin >> s;
if (hmap.find(s) == hmap.end()) {
hmap[s] = 1;
if (1 > max) max = 1;
} else {
hmap[s]++;
if (hmap[s] > max) max = hmap[s];
}
}
cout << max << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int freq[27];
char sent[101];
int main() {
int n;
scanf("%d", &n);
scanf("%s", sent);
while (n--) {
if (isupper(sent[n])) sent[n] = tolower(sent[n]);
freq[sent[n] - 'a']++;
}
for (int i = 0; i < 26; i++)
if (!freq[i]) {
printf("NO\n");
return 0;
}
printf("YES\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
out << "{";
for (const T &a : v) out << a << ", ";
out << "}";
return out;
}
template <typename S, typename T>
ostream &operator<<(ostream &out, const pair<S, T> &p) {
out << "(" << p.first << ", " << p.second << ")";
return out;
}
int z, n;
struct triple {
int a, b, c;
triple(int a, int b, int c) : a(a), b(b), c(c) {}
triple(){};
bool operator==(const triple &second) {
return (b == second.b && c == second.c);
}
};
bool operator<(const triple &first, const triple &second) {
return (first.b < second.b || (first.b == second.b && first.c < second.c));
}
triple v[200007];
int dbf[20][200007];
void kmr(int *t, int n) {
int i, j;
for (int i = 0; i < (int)n; i++) dbf[0][i] = t[i];
for (j = 1; 1 << j <= n; j++) {
int s = 0;
for (i = 0; i + (1 << j) <= n; i++) {
v[s++] = triple(i, dbf[j - 1][i], dbf[j - 1][i + (1 << (j - 1))]);
}
sort(v, v + s);
int k = 0;
for (int i = 0; i < (int)s; i++) {
if (i > 0 && !(v[i] == v[i - 1])) k++;
dbf[j][v[i].a] = k;
}
}
}
inline bool equals(int a, int b, int c, int d, int dbf[][200007]) {
int j = log2(b - a + 1);
int k = log2(d - c + 1);
return dbf[j][a] == dbf[k][c] &&
dbf[j][b - (1 << j) + 1] == dbf[k][d - (1 << k) + 1];
}
inline bool equals(int a, int b, int s, int dbf[][200007]) {
return equals(a, a + s - 1, b, b + s - 1, dbf);
}
int s[200007];
map<int, vector<int> > let;
vector<pair<int, int> > rep;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < (int)n; i++) {
cin >> s[i];
let[s[i]].push_back(i);
}
kmr(s, n);
for (auto &kv : let) {
int c = kv.first;
vector<int> v = kv.second;
for (int i = 0; i < (int)v.size(); i++) {
for (int j = i + 1; j < (int)v.size(); j++) {
int a = v[i], b = v[j];
int len = b - a;
if (b + len <= n && equals(a, b, len, dbf))
rep.push_back(make_pair(len, a));
}
}
}
sort(rep.begin(), rep.end());
int start = 0;
for (int i = 0; i < (int)rep.size(); i++) {
if (rep[i].second >= start) {
start = rep[i].second + rep[i].first;
}
}
cout << n - start << endl;
for (int i = start; i < (int)n; i++) cout << s[i] << " ";
cout << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
};
int s[210][210];
int dx[] = {1, 0, 0, -1};
int dy[] = {0, 1, -1, 0};
int main() {
int i, j, k, m, n, p, q;
while (~scanf("%d%d", &n, &m)) {
memset(s, 0, sizeof(s));
s[100][100] = n;
vector<node> ss;
node ret;
ret.x = 100;
ret.y = 100;
ss.push_back(ret);
for (i = 0; i < ss.size(); i++) {
int x = ss[i].x;
int y = ss[i].y;
int j = s[x][y] / 4;
s[x][y] %= 4;
for (k = 0; k < 4; k++) {
int nx = x + dx[k];
int ny = y + dy[k];
s[nx][ny] += j;
if (s[nx][ny] - j < 4 && s[nx][ny] >= 4) {
ret.x = nx;
ret.y = ny;
ss.push_back(ret);
}
}
}
while (m--) {
scanf("%d%d", &p, &q);
if (abs(p) >= 100 || abs(q) >= 100) {
puts("0");
continue;
}
printf("%d\n", s[p + 100][q + 100]);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
map<int, bool> mp;
mp[1] = 1;
mp[2] = 1;
int ara[39];
ara[1] = 1;
ara[2] = 1;
for (int i = 3;; i++) {
ara[i] = ara[i - 1] + ara[i - 2];
if (ara[i] > 1000) break;
mp[ara[i]] = 1;
}
cin >> n;
string s = "";
for (int i = 1; i <= n; i++) {
if (mp[i])
s += 'O';
else
s += 'o';
}
cout << s << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ans = 0, fh = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fh = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
return ans * fh;
}
const int maxn = 1e6 + 100;
struct Xxj {
int p[31], ele;
inline void insert(int x) {
if (ele == 30) return;
for (int i = 30; ~i; i--)
if ((x >> i) & 1) {
if (!p[i]) {
p[i] = x;
break;
}
x ^= p[i];
}
}
inline int query(int x) {
for (int i = 30; ~i; i--) x = min(x, x ^ p[i]);
return x;
}
} g;
struct Rev {
int tl, tr, x, y, z;
} a[maxn];
struct node {
int x, y, z;
};
int n, m, q, fa[maxn], p[maxn], ans[maxn], siz[maxn], cnt, tim;
vector<Rev> seg[maxn << 2];
map<pair<int, int>, int> pos;
pair<int, int> b[maxn];
inline int getfa(int x) {
while (x != fa[x]) x = fa[x];
return x;
}
inline int getxor(int x, int tmp = 0) {
while (x != fa[x]) tmp ^= p[x], x = fa[x];
return tmp;
}
inline void work(int o, Xxj &g, vector<node> &vc) {
for (int i = 0, lim = seg[o].size(); i < lim; i++) {
Rev now = seg[o][i];
int x = now.x, y = now.y, z = now.z;
int fx = getfa(x), fy = getfa(y);
if (fx == fy) {
g.insert(getxor(x) ^ getxor(y) ^ z);
} else {
if (siz[fx] > siz[fy]) swap(x, y), swap(fx, fy);
z ^= getxor(x) ^ getxor(y);
vc.push_back((node){fx, fy, siz[fy]});
fa[fx] = fy, p[fx] = z, siz[fy] += siz[fx];
}
}
}
inline void Clear(vector<node> vc) {
for (int i = vc.size() - 1; ~i; i--) {
node now = vc[i];
int x = now.x, y = now.y, z = now.z;
fa[x] = x, p[x] = 0, siz[y] = z;
}
}
void query(int o, int l, int r, Xxj g) {
vector<node> vc;
vc.clear();
work(o, g, vc);
int mid = l + r >> 1;
if (l == r)
ans[l] = g.query(getxor(b[l].first) ^ getxor(b[l].second));
else
query(o << 1, l, mid, g), query(o << 1 | 1, mid + 1, r, g);
Clear(vc);
}
void insert(int o, int l, int r, int ql, int qr, Rev qz) {
if (ql == l && qr == r) {
seg[o].push_back(qz);
return;
}
int mid = l + r >> 1;
if (ql <= mid) insert(o << 1, l, mid, ql, min(qr, mid), qz);
if (qr > mid) insert(o << 1 | 1, mid + 1, r, max(ql, mid + 1), qr, qz);
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) {
int x = read(), y = read(), z = read();
if (x > y) swap(x, y);
a[++cnt] = (Rev){1, -1, x, y, z};
pos[make_pair(x, y)] = cnt;
}
q = read();
for (int i = 1; i <= q; i++) {
int ms = read(), x = read(), y = read();
if (x > y) swap(x, y);
if (ms == 1) {
a[pos[make_pair(x, y)] = ++cnt] = (Rev){tim + 1, -1, x, y, read()};
}
if (ms == 2) {
a[pos[make_pair(x, y)]].tr = tim;
}
if (ms == 3) {
b[++tim] = make_pair(x, y);
}
}
for (int i = 1; i <= cnt; i++)
if (a[i].tr == -1) a[i].tr = tim;
for (int i = 1; i <= cnt; i++)
if (a[i].tl <= a[i].tr) insert(1, 1, tim, a[i].tl, a[i].tr, a[i]);
for (int i = 1; i <= n; i++) fa[i] = i, siz[i] = 1;
query(1, 1, tim, g);
for (int i = 1; i <= tim; i++) printf("%d\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
deque<pair<string, int>> a;
int mx;
vector<string> ans[N];
void solve(int l = 1) {
if (a.empty()) return;
auto cur = a.front();
a.pop_front();
mx = max(mx, l);
ans[l].push_back(cur.first);
for (int i = 0; i < cur.second; i++) {
solve(l + 1);
}
}
int main() {
string s = "";
char c;
while ((c = getchar()) != EOF) {
if (c != ',') {
s += c;
} else {
int num = 0;
char c;
while ((c = getchar()) != EOF) {
if (c == ',') break;
num = num * 10 + c - '0';
}
a.push_back({s, num});
s = "";
}
}
while (!a.empty()) solve();
printf("%d\n", mx);
for (int i = 1; i <= mx; i++) {
for (string s : ans[i]) {
printf("%s ", s.c_str());
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n;
struct point {
int x, y;
bool operator<(const point& a) const { return x == a.x ? y < a.y : x < a.x; }
};
struct BIT {
int bit[maxn];
void init() { memset(bit, 0, sizeof(bit)); }
int lowbit(int x) { return x & -x; }
int pre_sum(int x) {
int sum = 0;
while (x > 0) {
sum += bit[x];
x -= lowbit(x);
}
return sum;
}
long long query(int l, int r) { return pre_sum(r) - pre_sum(l - 1); }
void insert(int k, int v) {
while (k <= n) {
bit[k] += v;
k += lowbit(k);
}
}
};
int ordy[maxn];
point p[maxn];
bool compy(const int& a, const int& b) {
return p[a].y == p[b].y ? p[a].x <= p[b].x : p[a].y > p[b].y;
}
int main() {
scanf("%d", &n);
BIT bit;
bit.init();
p[0].x = 0;
p[0].y = 0;
ordy[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i].x, &p[i].y);
ordy[i] = i;
}
sort(p, p + n + 1);
sort(ordy, ordy + n + 1, compy);
int l = 0, r;
long long ans = 0;
while (l < n) {
r = l;
bit.insert(ordy[r], 1);
if (ordy[r] < n && p[ordy[r]].x == p[ordy[r] + 1].x) {
bit.insert(ordy[r] + 1, -1);
}
while (p[ordy[r]].y == p[ordy[r + 1]].y) {
bit.insert(ordy[++r], 1);
if (ordy[r] < n && p[ordy[r]].x == p[ordy[r] + 1].x) {
bit.insert(ordy[r] + 1, -1);
}
}
for (int i = l; i <= r; i++) {
int lx = (i == l ? 1 : ordy[i - 1] + 1);
long long cnt1 = bit.query(lx, ordy[i]);
long long cnt2 = bit.query(ordy[i], n);
ans += cnt1 * cnt2;
}
l = r + 1;
}
printf("%lld", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long poww(long long x, long long y, long long m) {
x = x % m;
if (y == 0) {
return 1;
}
if (y % 2 == 0) {
return poww(x * x, y / 2, m);
} else {
return (x * poww(x * x, y / 2, m)) % m;
}
}
void io();
const int mod = 998244353;
const int maxn = 300000 + 10;
int n;
long long a[maxn];
long long fact[maxn];
int main() {
io();
int i, j;
fact[0] = 1;
cin >> n;
for (long long i = 1; i <= 2 * n; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= mod;
}
for ((i) = 0; (i) < (2 * n); i = i + 1) cin >> a[i];
sort(a, a + 2 * n);
long long second = 0;
for ((i) = n; (i) < (2 * n); i = i + 1) second += a[i];
for ((i) = 0; (i) < (n); i = i + 1) second -= a[i];
second %= mod;
long long c1 = fact[2 * n];
long long c2 = (fact[n] * fact[n]) % mod;
c2 = poww(c2, mod - 2, mod) % mod;
long long c3 = (c1 * c2) % mod;
long long ans = (c3 * second) % mod;
cout << ans;
return 0;
}
void io() {}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int a, b;
cin >> a >> b;
if (a == b) {
cout << "infinity";
return 0;
}
if (a < b) {
cout << 0;
return 0;
}
int u = 0;
int i = a - b;
for (int j = 1; j <= sqrt(i); j++) {
if ((i % j) == 0) {
if ((a % j) == b) u++;
if (j == sqrt(i)) continue;
if ((a % (i / j)) == b) u++;
}
}
cout << u;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<ld, ld>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<ld>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
str Tout[2] = {"NO", "YES"};
str tout[2] = {"No", "Yes"};
int main() {
char s[9][3][3];
for (int g = (0); g < (3); g++)
for (int d = (0); d < (3); d++) {
for (int i = (0); i < (3); i++) {
for (int j = (0); j < (3); j++) {
cin >> s[g * 3 + i][d][j];
}
}
}
int x, y;
cin >> x >> y;
int numb = x / 3 * 3 - (x % 3 == 0) * 3 + y / 3 + (y % 3 != 0);
x = x % 3 + (x % 3 == 0) * 3;
y = y % 3 + (y % 3 == 0) * 3;
numb = (x - 1) * 3 + y;
int f = 0;
for (int i = (0); i < (3); i++) {
for (int j = (0); j < (3); j++)
if (s[numb - 1][i][j] == '.') {
s[numb - 1][i][j] = '!';
f++;
}
}
if (!f) {
for (int i = (0); i < (9); i++)
for (int j = (0); j < (3); j++)
for (int g = (0); g < (3); g++)
if (s[i][j][g] == '.') s[i][j][g] = '!';
}
for (int g = (0); g < (3); g++) {
for (int i = (0); i < (3); i++) {
for (int j = (0); j < (3); j++) {
for (int d = (0); d < (3); d++) cout << s[g * 3 + j][i][d];
cout << " ";
}
cout << "\n";
}
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[100];
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> ar[i];
sum = sum + ar[i];
}
if (sum % 2 != 0) {
cout << sum;
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (ar[i] > ar[j]) {
int t;
t = ar[j];
ar[j] = ar[i];
ar[i] = t;
}
}
}
int t;
for (int i = 0; i < n; i++) {
if (ar[i] % 2 != 0) {
t = sum - ar[i];
if (t > ar[i]) {
cout << t;
return 0;
}
}
}
cout << 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> A[110];
long long f[110][110][2], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &A[i].first, &A[i].second);
sort(A + 1, A + n + 1);
A[0].first = -1000000000;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= i; j++)
for (int k = 0; k <= 1; k++) {
ans = max(ans, f[i][j][k]);
long long pos = A[j].first + k * A[j].second;
long long mpos = -1000000000000000000LL, nj = j, nk = k;
for (int a = i + 1; a <= n; a++)
for (int b = 0; b <= 1; b++) {
long long npos = A[a].first + b * A[a].second;
if (npos > mpos) mpos = npos, nj = a, nk = b;
f[a][nj][nk] =
max(f[a][nj][nk], f[i][j][k] +
min((long long)A[a].second, npos - pos) +
mpos - npos);
}
}
printf("%I64d\n", ans);
return 0;
}
| 11 |
/// Author :Nguyễn Thái Sơn -Ti20 -THPT chuyên Lương Thế Vinh
#include<bits/stdc++.h>
#define TASK "test"
#define ll long long
#define ull unsigned long long
#define fi first
#define se second
#define ti20_ntson int main()
#define all(x) (x).begin(),(x).end()
#define vi vector<int>
#define vii pair<int,int>
using namespace std;
const int oo = 1e9;
const int maxN = 35005;
int n,a[maxN],st[4*maxN],lazy[4*maxN],f[105][maxN],k,pre[maxN];
void build(int id, int l, int r)
{
st[id] = oo;
lazy[id] = 0;
if (l == r) return;
int mid = l+r >>1;
build(id*2,l,mid);
build(id*2+1,mid+1,r);
}
void nhap()
{
cin >> n >> k;
for (int i=1; i<=n; i++) cin >> a[i];
for (int i=0; i<=n; i++)
for (int j=0; j<=k; j++)
f[j][i] = oo;
f[0][0] = 0;
}
void down(int id)
{
int s = lazy[id];
st[id*2] +=s;
lazy[id*2] +=s;
st[id*2+1] +=s;
lazy[id*2+1] +=s;
lazy[id] =0;
}
void update(int id, int l, int r, int u, int v, int val)
{
if (r < u || v < l) return;
if (u <= l && r <= v){
st[id] += val;
lazy[id] += val;
return;
}
int mid = l +r >> 1;
down(id);
update(id * 2, l, mid, u, v, val);
update(id * 2 + 1, mid + 1, r, u, v, val);
st[id] = min(st[id * 2], st[id * 2 + 1]);
}
void tienxuli(int id, int l, int r, int u, int val)
{
if (l > u || r< u) return;
if (l == r && l == u) {
st[id] = val;
return;
}
int mid = l+r >>1;
tienxuli(id*2,l,mid,u,val);
tienxuli(id*2+1,mid+1,r,u,val);
st[id] = min(st[id*2],st[id*2+1]);
}
int get(int id, int l, int r, int u, int v)
{
if (l > v || r < u) return 1e9;
if (l >= u && r <=v) return st[id];
down(id);
int mid = l+r >>1;
return min (get(id*2,l,mid,u,v),get(id*2+1,mid+1,r,u,v));
}
void xuli(int z)
{
build(1,0,n);
// f[z][0] = 0;
for (int i=0; i<=n; i++) {
// if (z-1 == 0 && i == 0) cout << "YES";
tienxuli(1,0,n,i,f[z-1][i]);
}
for (int i=1; i<=n; i++) {
if (pre[a[i]] != 0) {
update(1,0,n,0,pre[a[i]]-1,i-pre[a[i]]);
}
pre[a[i]] = i;
f[z][i] = get(1,0,n,0,i-1);
// f[z][i] = min (f[z][i],f[z-1][i-1]);
}
for (int i=1; i<=n; i++)
pre[a[i]] =0;
}
void solve()
{
for (int i=1; i<=k; i++)
xuli(i);
cout << f[k][n];
}
ti20_ntson
{
ios_base::sync_with_stdio(false);cin.tie(0); cout.tie(0);
//freopen(TASK".INP","r",stdin);
//freopen(TASK".OUT","w",stdout);
int tv =1;
for (int i=1; i<=tv; i++) {
nhap();
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
int main() {
int n;
string s;
cin >> n >> s;
bool f = 0;
for (int i = 0; i < n - 1; i++) {
if (s[i] == 'R' && s[i + 1] == 'L') {
cout << i + 1 << " " << i + 2 << endl;
f = 1;
break;
}
}
int x = -1, y = n + 2;
if (!f)
for (int i = 0; i < n; i++) {
if (s[i] == 'R') {
x = max(x, i);
y = min(y, i);
}
}
if (x != -1 && y != n + 2) {
cout << y + 1 << " " << x + 2 << endl;
f = 1;
}
x = -1, y = n + 2;
if (!f)
for (int i = 0; i < n; i++) {
if (s[i] == 'L') {
x = max(x, i);
y = min(y, i);
}
}
if (x != -1 && y != n + 2) {
cout << y + 1 << " " << y << endl;
f = 1;
}
if (!f) cout << "1 1\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Line {
int a, b, c;
Line(int, int, int, int);
bool operator<(const Line &rl) const {
if (a != rl.a)
return a < rl.a;
else if (b != rl.b)
return b < rl.b;
else
return c < rl.c;
}
friend ostream &operator<<(ostream &os, const Line &rl) {
os << rl.a << "x + " << rl.b << "y = " << rl.c;
return os;
}
};
int N, M;
int R[1500];
complex<int> O[1500];
map<Line, pair<vector<int>, vector<int> > > f;
void read();
void solve();
int gcd(int, int);
int main() {
read();
solve();
return 0;
}
void read() {
int x1, y1, x2, y2;
cin >> N >> M;
for (int i = 0; i < N; ++i) {
cin >> x1 >> y1 >> x2 >> y2;
x1 <<= 1, y1 <<= 1, x2 <<= 1, y2 <<= 1;
Line ln(x1, y1, x2, y2);
if (x1 != x2) {
f[ln].first.push_back(min(x1, x2));
f[ln].second.push_back(max(x1, x2));
} else {
f[ln].first.push_back(min(y1, y2));
f[ln].second.push_back(max(y1, y2));
}
}
for (int i = 0; i < M; ++i) {
cin >> x1 >> y1 >> R[i];
x1 <<= 1, y1 <<= 1, R[i] <<= 1;
O[i] = complex<int>(x1, y1);
}
}
void solve() {
long long res = 0;
for (map<Line, pair<vector<int>, vector<int> > >::iterator itr = f.begin();
itr != f.end(); ++itr) {
stable_sort((itr->second.first).begin(), (itr->second.first).end());
stable_sort((itr->second.second).begin(), (itr->second.second).end());
}
for (int i = 0; i < M; ++i)
for (int j = i + 1; j < M; ++j) {
if (R[i] != R[j]) continue;
if (norm(O[i] - O[j]) <= (R[i] + R[j]) * (R[i] + R[j])) continue;
int vx = -(imag(O[i]) - imag(O[j])), vy = real(O[i]) - real(O[j]);
complex<int> p1 = (O[i] + O[j]) / 2, p2 = p1 + complex<int>(vx, vy);
Line ln(real(p1), imag(p1), real(p2), imag(p2));
if (f.count(ln)) {
vector<int> &rv1 = f[ln].first;
vector<int> &rv2 = f[ln].second;
int cv = vx != 0 ? real(p1) : imag(p1);
res += int(upper_bound((rv1).begin(), (rv1).end(), cv) - rv1.begin());
res -= int(lower_bound((rv2).begin(), (rv2).end(), cv) - rv2.begin());
}
}
cout << res << "\n";
}
Line::Line(int x1, int y1, int x2, int y2) {
int g;
a = -(y2 - y1), b = x2 - x1, c = a * x1 + b * y1;
g = gcd(gcd(a, b), c);
a /= g, b /= g, c /= g;
}
int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 10;
const long long MOD = 998244353;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const long double EPS = 1e-6;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, a;
cin >> n;
bool t = false;
for (int i = 0; i < n; i++) {
cin >> a;
if (a == 1) t = true;
}
if (t)
cout << -1 << '\n';
else
cout << 1 << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
set<long long> S;
void go(const long long &x, const int &M, const long long &U) {
if (x > U) return;
if (x > M) S.insert(x);
go(10 * x + 4, M, U), go(10 * x + 7, M, U);
}
bool ok(long long x) {
for (; x; x /= 10) {
int a = x % 10;
if (a != 4 && a != 7) return false;
}
return true;
}
int main() {
long long N, K;
cin >> N >> K;
long long F = -1;
int M = 1;
for (long long f = 1; f * M < K; f *= M, M++)
;
if (M > (int)N) {
cout << -1 << endl;
return 0;
}
M = min((int)N, 20);
go(0, 0, N - M);
vector<long long> a(M);
for (int _n(M), i(0); i < _n; i++) a[i] = N - M + i + 1;
if (K < F || F == -1) {
for (long long k = K - 1; k > 0;) {
long long f = 1;
int i = 1;
while (f * (i + 1) <= k) f *= ++i;
int j = k / f;
swap(a[M - i - 1], a[M - i + j - 1]);
sort(&a[0] + M - i, &a[0] + M);
k -= f * j;
}
} else if (K == F) {
reverse((a).begin(), (a).end());
}
int ans = 0;
for (int _n(M), i(0); i < _n; i++)
if (ok(N - M + i + 1) && ok(a[i])) ans++;
ans += S.size();
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) {
ans = (ans * a);
}
a = (a * a);
b >>= 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long a, b, i, l = 0, u;
cin >> a >> b;
if (a > b) {
cout << "-1";
return 0;
}
if (a == 0 && b == 0) {
cout << "0";
return 0;
}
if (a == 0 && b % 2 == 0) {
cout << "2\n" << b / 2 << " " << b / 2;
return 0;
}
if (a == b) {
cout << 1 << "\n" << a;
return 0;
}
if (a % 2 != 0 && b % 2 != 0) {
long long d = b - a;
if (d == 0) {
cout << "1\n" << 1;
return 0;
}
if ((a & (d / 2)) == 0) {
cout << "2"
<< "\n";
cout << a + d / 2 << " ";
cout << d / 2;
return 0;
}
cout << "3"
<< "\n";
cout << a << " ";
cout << d / 2 << " " << d / 2;
return 0;
}
if (a % 2 == 0 && b % 2 == 0) {
long long d = a;
vector<int> v;
while (d > 0) {
v.push_back(d & 1);
d = d >> 1;
}
while (v.size() <= 60) {
v.push_back(0);
}
for (i = 60; i >= 0; i--) {
if (v[i] == 0) {
u = power(2, i);
if (a + l + 2 * u == b) break;
if (a + l + 2 * u < b) {
l = l + 2 * u;
}
}
}
if (((a + l / 2 + u) ^ (l / 2 + u)) != a) {
long long d = b - a;
cout << "3"
<< "\n";
cout << a << " ";
cout << d / 2 << " " << d / 2;
return 0;
}
cout << "2\n";
cout << a + l / 2 + u << " " << l / 2 + u << "\n";
return 0;
}
cout << "-1";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <class T>
bool umin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool umax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
map<pair<int, int>, vector<pair<int, int>>> mp;
int n;
const int N = 1e5 + 5;
vector<int> a(N), b(N);
bool dp(int i, int prev, vector<int> &ans) {
ans[i - 1] = prev;
if (i == n) return 1;
bool temp = 0;
for (int num = 0; num < 4; ++num) {
int And = prev & num;
int Or = prev | num;
if (And == b[i - 1] && Or == a[i - 1]) temp = temp || dp(i + 1, num, ans);
};
return temp;
}
void solve() {
cin >> n;
for (int i = 0; i < n - 1; ++i) cin >> a[i];
bool ok = 1;
for (int i = 0; i < n - 1; ++i) {
cin >> b[i];
if (b[i] > a[i]) ok = 0;
}
if (!ok) {
cout << "NO";
return;
}
for (int i = 0; i < 4; ++i) {
vector<int> ans(n);
if (dp(1, i, ans)) {
cout << "YES\n";
for (int i = 0; i < n; ++i) cout << ans[i] << " ";
return;
}
}
cout << "NO";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int i = 1; i < t + 1; ++i) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5, V = 51e5, M = 15, D = 8, Q = 11e5, S = 3000;
vector<pair<int, int>> qr[N];
bool comp[S];
int pr[S], ans[Q], dp[V][D], best[M], a[N], ct[V], sz[128];
int cp = 0;
int main() {
for (int i = 2; i < S; i++) {
if (!comp[i]) {
pr[cp++] = i;
for (int j = i * i; j < S; j += i) {
comp[j] = 1;
}
}
}
sz[0] = 0;
for (int i = 1; i < 128; i++) sz[i] = sz[i ^ (i & -i)] + 1;
int n, q;
scanf("%d%d", &n, &q);
for (int i = 0; i < V; i++) {
for (int j = 0; j < D; j++) {
dp[i][j] = -1;
}
}
for (int i = 0; i < M; i++) best[i] = -1;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d%d", &l, &r);
qr[r - 1].push_back({l - 1, i});
}
for (int i = 0; i < n; i++) {
vector<int> d;
int t = a[i];
for (int j = 0; pr[j] * pr[j] <= t; j++) {
int c = 0;
while (t % pr[j] == 0) {
c ^= 1;
t /= pr[j];
}
if (c) d.push_back(pr[j]);
}
if (t > 1) d.push_back(t);
vector<int> g(1 << d.size());
g[0] = 1;
for (int j = 0; j < d.size(); j++) {
g[1 << j] = d[j];
}
for (int j = 1; j < (1 << d.size()); j++) {
g[j] = g[j & -j] * g[j ^ (j & -j)];
ct[g[j]] = sz[j];
}
ct[a[i]] = d.size();
for (int j : g) {
for (int k = 0; k < M; k++) {
int c = k + ct[a[i]] - ct[j];
best[c] = max(best[c], dp[j][k]);
}
dp[j][ct[a[i]] - ct[j]] = i;
}
for (auto p : qr[i]) {
for (int k = 0; k < M; k++) {
if (best[k] >= p.first) {
ans[p.second] = k;
break;
}
}
}
}
for (int i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int v = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
v = v * 10 + c - '0';
c = getchar();
}
return v * f;
}
const int Maxn = 105;
int cnt[Maxn][26];
int S1[Maxn], S2[Maxn], S3[Maxn];
char tmp[Maxn];
void Query(int l, int r) {
printf("? %d %d\n", l, r);
fflush(stdout);
memset(cnt, 0, sizeof(cnt));
int c = (r - l + 1) * (r - l + 2) / 2;
for (int i = 0; i < c; i++) {
scanf("%s", tmp);
int l = strlen(tmp);
for (int j = 0; j < l; j++) {
cnt[l][tmp[j] - 'a']++;
}
}
}
int ans[Maxn];
vector<pair<int, int> > G[Maxn];
bool vis[Maxn];
int main() {
int n;
scanf("%d", &n);
if (n == 1) {
Query(1, 1);
for (int i = 0; i < 26; i++) {
if (cnt[1][i]) {
printf("! %c\n", i + 'a');
fflush(stdout);
return 0;
}
}
}
int l = 1, r = n, mid = l + r >> 1;
vector<int> V;
if (mid - l == r - mid) {
Query(1, n);
int T = (n + 1) / 2;
for (int i = T; i >= 1; i--) {
for (int j = 0; j < 26; j++) {
S1[i] += cnt[i][j] * j;
S1[i] -= cnt[i - 1][j] * j;
}
for (int j = i + 1; j <= T; j++) {
S1[i] -= S1[j];
}
}
for (int i = 1; i <= T; i++) {
int x = i, y = n + 1 - i;
if (x == y) {
ans[x] = S1[i];
V.push_back(x);
} else {
G[x].push_back(make_pair(y, S1[i]));
G[y].push_back(make_pair(x, S1[i]));
}
}
Query(1, mid - 1);
T = mid / 2;
for (int i = T; i >= 1; i--) {
for (int j = 0; j < 26; j++) {
S2[i] += cnt[i][j] * j;
S2[i] -= cnt[i - 1][j] * j;
}
for (int j = i + 1; j <= T; j++) {
S2[i] -= S2[j];
}
}
for (int i = 1; i <= T; i++) {
int x = i, y = mid - i;
if (x == y) {
ans[x] = S2[i];
V.push_back(x);
} else {
G[x].push_back(make_pair(y, S2[i]));
G[y].push_back(make_pair(x, S2[i]));
}
}
Query(mid, n);
T = (n - mid + 2) / 2;
for (int i = T; i >= 1; i--) {
for (int j = 0; j < 26; j++) {
S3[i] += cnt[i][j] * j;
S3[i] -= cnt[i - 1][j] * j;
}
for (int j = i + 1; j <= T; j++) {
S3[i] -= S3[j];
}
}
for (int i = 1; i <= T; i++) {
int x = i + mid - 1, y = mid + n - x;
if (x == y) {
ans[x] = S3[i];
V.push_back(x);
} else {
G[x].push_back(make_pair(y, S3[i]));
G[y].push_back(make_pair(x, S3[i]));
}
}
while (!V.empty()) {
int x = V.back();
V.pop_back();
if (vis[x]) continue;
vis[x] = true;
for (int i = 0; i < G[x].size(); i++) {
int A = G[x][i].first, S = G[x][i].second;
ans[A] = S - ans[x];
V.push_back(A);
}
}
printf("! ");
for (int i = 1; i <= n; i++) {
putchar(ans[i] + 'a');
}
printf("\n");
fflush(stdout);
return 0;
}
Query(1, n);
int T = (n + 1) / 2;
for (int i = T; i >= 1; i--) {
for (int j = 0; j < 26; j++) {
S1[i] += cnt[i][j] * j;
S1[i] -= cnt[i - 1][j] * j;
}
for (int j = i + 1; j <= T; j++) {
S1[i] -= S1[j];
}
}
for (int i = 1; i <= T; i++) {
int x = i, y = n + 1 - i;
if (x == y) {
ans[x] = S1[i];
V.push_back(x);
} else {
G[x].push_back(make_pair(y, S1[i]));
G[y].push_back(make_pair(x, S1[i]));
}
}
Query(1, mid);
T = (mid + 1) / 2;
for (int i = T; i >= 1; i--) {
for (int j = 0; j < 26; j++) {
S2[i] += cnt[i][j] * j;
S2[i] -= cnt[i - 1][j] * j;
}
for (int j = i + 1; j <= T; j++) {
S2[i] -= S2[j];
}
}
for (int i = 1; i <= T; i++) {
int x = i, y = mid + 1 - i;
if (x == y) {
ans[x] = S2[i];
V.push_back(x);
} else {
G[x].push_back(make_pair(y, S2[i]));
G[y].push_back(make_pair(x, S2[i]));
}
}
Query(mid, n);
T = (n - mid + 2) / 2;
for (int i = T; i >= 1; i--) {
for (int j = 0; j < 26; j++) {
S3[i] += cnt[i][j] * j;
S3[i] -= cnt[i - 1][j] * j;
}
for (int j = i + 1; j <= T; j++) {
S3[i] -= S3[j];
}
}
for (int i = 1; i <= T; i++) {
int x = i + mid - 1, y = mid + n - x;
if (x == y) {
ans[x] = S3[i];
V.push_back(x);
} else {
G[x].push_back(make_pair(y, S3[i]));
G[y].push_back(make_pair(x, S3[i]));
}
}
while (!V.empty()) {
int x = V.back();
V.pop_back();
if (vis[x]) continue;
vis[x] = true;
for (int i = 0; i < G[x].size(); i++) {
int A = G[x][i].first, S = G[x][i].second;
ans[A] = S - ans[x];
V.push_back(A);
}
}
printf("! ");
for (int i = 1; i <= n; i++) {
putchar(ans[i] + 'a');
}
printf("\n");
fflush(stdout);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
struct point {
double x, y;
point() {}
point(const double &x, const double &y) : x(x), y(y) {}
friend point operator+(const point &a, const point &b) {
return point(a.x + b.x, a.y + b.y);
}
friend point operator-(const point &a, const point &b) {
return point(a.x - b.x, a.y - b.y);
}
friend point operator/(const point &a, const double &b) {
return point(a.x / b, a.y / b);
}
friend point rotate(const point &a, const double &COS, const double &SIN) {
return point(a.x * COS - a.y * SIN, a.x * SIN + a.y * COS);
}
friend double dot(const point &a, const point &b) {
return a.x * b.x + a.y * b.y;
}
friend double dist(const point &a, const point &b) {
return sqrt(dot(a - b, a - b));
}
friend double det(const point &a, const point &b) {
return a.x * b.y - a.y * b.x;
}
void out() { printf("%.12f %.12f\n", x, y); }
void in() { cin >> x >> y; }
} q[7], p, v;
double a, b, c, d;
int main() {
p.in(), v.in();
cin >> a >> b >> c >> d;
a /= 2, c /= 2;
q[0] = point(b, 0);
q[1] = point(0, a);
q[2] = point(0, c);
q[3] = point(-d, c);
q[4] = point(-d, -c);
q[5] = point(0, -c);
q[6] = point(0, -a);
double l = dist(point(0, 0), v);
for (int i = 0; i < 7; i++) {
(rotate(q[i], v.x / l, v.y / l) + p).out();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
char a[n + 1][m + 1];
vector<long long int> v[n + 1], v1[m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
int flag = 0, cnt, cnt1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cnt = 0;
cnt1 = 0;
if (i != j) {
for (int k = 1; k <= m; k++) {
if (a[i][k] == a[j][k] && a[i][k] == '#')
cnt = 1;
else if (a[i][k] == '#' || a[j][k] == '#')
cnt1 = 1;
}
}
if (cnt == 1 && cnt1 == 1) flag = 1;
}
}
if (flag)
cout << "No";
else
cout << "Yes";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int t, n, i, a[200005];
cin >> t;
while (t--) {
cin >> n;
for (i = 0; i < 2 * n; i++) cin >> a[i];
sort(a, a + 2 * n);
cout << a[n] - a[n - 1] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
long long n, m, k;
cin >> n >> m >> k;
const long long pad = 200000;
vector<vector<pair<long long, long long> > > sens(2 * pad + 3);
for (long long i = 0; i < k; i++) {
long long x, y;
cin >> x >> y;
sens[x - y + pad].push_back({x, i});
sens[x - (2 * m - y) + pad].push_back({x, i});
sens[(2 * n - x) - y + pad].push_back({2 * n - x, i});
sens[(2 * n - x) - (2 * m - y) + pad].push_back({2 * n - x, i});
}
m = 2 * m;
n = 2 * n;
set<long long> p;
p.insert(0);
long long pend = 0;
long long tl = 0;
vector<long long> t(2 * pad + 3, -1);
while (true) {
t[pad + pend] = tl;
if (pend >= 0) {
tl += min(m, n - pend);
if (min(m, n - pend) == m)
pend = pend + m;
else
pend = pend - n;
} else {
tl += min(m + pend, n);
if (min(m + pend, n) == m + pend)
pend = m + pend;
else
pend = pend - n;
}
if (pend == n or pend == -m or p.count(pend) > 0)
break;
else
p.insert(pend);
}
vector<long long> tf(k, LLONG_MAX);
for (long long j = -m; j <= n; j++) {
if (t[pad + j] >= 0) {
for (auto x : sens[pad + j])
if (j > 0)
tf[x.second] = min(tf[x.second], t[pad + j] + x.first - j);
else
tf[x.second] = min(tf[x.second], t[pad + j] + x.first);
}
}
for (auto x : tf) {
if (x == LLONG_MAX)
cout << -1 << "\n";
else
cout << x << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int pos[1 << 12], num[1 << 12];
int p[1 << 12], q[1 << 12];
void maintain(int x, int y) {
for (;;) {
int t = pos[q[x] ^ num[x]];
if (t == x)
return;
else if (t == y) {
swap(p[x], p[y]);
swap(pos[p[x]], pos[p[y]]);
return;
}
swap(q[y], q[t]);
swap(p[x], p[y]);
swap(pos[p[x]], pos[p[y]]);
swap(p[x], p[t]);
swap(pos[p[x]], pos[p[t]]);
x = t;
}
}
int fir[1 << 12];
int main() {
int n;
scanf("%d", &n);
int s = 0;
for (int i = 0; i < (1 << n); i++) {
scanf("%d", &fir[i]);
s ^= fir[i];
}
if (s) {
puts("Fou");
return 0;
}
for (int i = 0; i < (1 << n); i++) p[i] = q[i] = pos[i] = i;
for (int i = 0; i < (1 << n) - 1; i++) {
num[i + 1] ^= (num[i] ^ fir[i]);
num[i] = fir[i];
maintain(i, i + 1);
}
puts("Shi");
for (int i = 0; i < (1 << n); i++) printf("%d ", p[i]);
printf("\n");
for (int i = 0; i < (1 << n); i++) printf("%d ", q[i]);
printf("\n");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
vector<array<long long, 5>> v(m);
for (long long i = 0; i < n; i++) {
string s;
cin >> s;
for (long long j = 0; j < m; j++) v[j][s[j] - 'A']++;
}
vector<long long> a(m);
for (long long &i : a) cin >> i;
long long ans = 0;
for (long long i = 0; i < m; i++) {
long long ma = 0;
for (long long j = 0; j < 5; j++) ma = max(ma, v[i][j]);
ans += (ma * a[i]);
}
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cin.tie(nullptr);
long long t_c = 1;
while (t_c--) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Z = (int)1e5 + 111;
const int inf = (int)1e9 + 111;
const long long llinf = (long long)1e18 + 5;
const int MOD = (int)1e9 + 7;
long double need[Z], a[Z], b[Z], c[Z];
vector<int> g[Z];
void dfs(int v) {
need[v] = a[v] - b[v];
for (int to : g[v]) {
dfs(to);
}
for (int to : g[v]) {
if (need[to] < 0) {
need[v] += need[to];
} else {
need[v] += need[to] * c[to];
}
}
}
int main() {
srand(time(0));
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> b[i];
}
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 2; i <= n; ++i) {
int x, k;
cin >> x >> k;
g[x].push_back(i);
c[i] = k;
}
dfs(1);
cout << (need[1] <= 0 ? "YES" : "NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct tri {
int x, y, v;
tri(int x, int y, int v) {
this->x = x;
this->y = y;
this->v = v;
}
tri() {}
};
bool operator<(tri a, tri b) { return a.x < b.x; }
const int H = 100, L = 100000;
int main() {
int h1, h2, N, n[2];
n[0] = n[1] = 0;
scanf("%d %d %d", &h1, &h2, &N);
tri A[2][101];
int v, a, b;
char c;
while (N--) {
scanf("%d %c %d %d", &v, &c, &a, &b);
if (c == 'F')
A[0][n[0]++] = tri(a, b, v);
else
A[1][n[1]++] = tri(a, b, v);
}
sort(A[0], A[0] + n[0]);
sort(A[1], A[1] + n[1]);
int ans = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < n[i]; j++) {
int points = 0, id = -1;
double tg = 1. * L / (h1 + 2 * H * j + h2), p = h1 * tg;
bool valid = true;
for (int k = 0; valid and k <= j; k++) {
id++;
while (id < n[i] and (p < A[i][id].x or p > A[i][id].y)) id++;
if (id == n[i]) valid = false;
points += A[i][id].v;
p += 2 * H * tg;
}
p = (h1 + H) * tg;
id = -1;
for (int k = 0; valid and k < j; k++) {
id++;
while (id < n[1 - i] and (p < A[1 - i][id].x or p > A[1 - i][id].y))
id++;
if (id == n[1 - i]) valid = false;
points += A[1 - i][id].v;
p += 2 * H * tg;
}
if (valid) ans = max(ans, points);
}
h1 = H - h1;
h2 = H - h2;
}
for (int i = 0; i < 2; i++) {
for (int j = 0; j < n[i]; j++) {
int points = 0, id = -1;
double tg = 1. * L / (h1 + 2 * H * (j + 1) - h2), p = h1 * tg;
bool valid = true;
for (int k = 0; valid and k <= j; k++) {
id++;
while (id < n[i] and (p < A[i][id].x or p > A[i][id].y)) id++;
if (id == n[i]) valid = false;
points += A[i][id].v;
p += 2 * H * tg;
}
p = (h1 + H) * tg;
id = -1;
for (int k = 0; valid and k <= j; k++) {
id++;
while (id < n[1 - i] and (p < A[1 - i][id].x or p > A[1 - i][id].y))
id++;
if (id == n[1 - i]) valid = false;
points += A[1 - i][id].v;
p += 2 * H * tg;
}
if (valid) ans = max(ans, points);
}
h1 = H - h1;
h2 = H - h2;
}
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> cum;
long long A, B;
int count(int x) {
auto it = cum.upper_bound(x);
it--;
return (*it).second;
}
int count(int x, int y) { return count(y) - count(x - 1); }
map<pair<long long, long long>, long long> memo;
long long eval(long long left, long long right) {
pair<long long, long long> key = {left, right};
if (memo.find(key) != memo.end()) return memo[key];
if (left == right) {
long long ct = count(left, right);
return memo[key] = (ct ? ct * B : A);
}
long long mid = (left + right) / 2, ct = count(left, right);
if (!ct) return memo[key] = A;
return memo[key] = min((right - left + 1) * ct * B,
eval(left, mid) + eval(mid + 1, right));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k >> A >> B;
vector<int> a(k);
map<int, int> ct;
for (int i = 0; i < k; i++) cin >> a[i], ct[a[i]]++;
cum[0] = 0;
long long pre = 0;
for (auto it : ct) pre += it.second, cum[it.first] = pre;
cout << eval(1, (1 << n)) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[15];
int main() {
int n;
while (~scanf("%d", &n)) {
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x]++, a[y]++;
}
int flag = 0;
for (int i = 1; i <= 5; i++) {
if (a[i] != 2) {
flag = 1;
}
}
if (flag)
printf("WIN\n");
else
printf("FAIL\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
template <class T>
inline void umin(T &x, T y) {
x = x < y ? x : y;
}
template <class T>
inline void umax(T &x, T y) {
x = x > y ? x : y;
}
inline unsigned int R() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
const int N = 466666, inf = 0x3f3f3f3f;
int n, k, dis[N], pre[N], q[N];
vector<int> e[N];
int s[N], len, ans[N];
bool gg[N];
int bfs(int S) {
for (register int i = (0); i <= (n); i++) dis[i] = inf;
int f = 0, r = 1;
q[f] = S;
dis[S] = 0;
memset(pre, 0, sizeof(pre));
int res = S;
while (f != r) {
int u = q[f++];
if (dis[u] > dis[res]) res = u;
for (register int i = (0); i <= (((int)e[u].size()) - 1); i++)
if (dis[e[u][i]] > dis[u] + 1) {
dis[e[u][i]] = dis[u] + 1;
q[r++] = e[u][i];
pre[e[u][i]] = u;
}
}
return res;
}
void GG() {
puts("No");
exit(0);
}
int CUR;
void dfs(int u, int fa, int d) {
if (!gg[u] && d + CUR >= k && d + len - CUR + 1 >= k) GG();
if (CUR > len - CUR + 1) {
ans[u] = (CUR + d) % k;
if (!ans[u]) ans[u] = k;
} else {
ans[u] = ((CUR - d) % k + k) % k;
if (!ans[u]) ans[u] = k;
}
for (register int i = (0); i <= (((int)e[u].size()) - 1); i++)
if (e[u][i] != fa && !gg[e[u][i]]) dfs(e[u][i], u, d + 1);
}
void ini(int S, int T) {
for (int u = T;; u = pre[u]) {
s[++len] = u;
if (u == S) break;
}
for (register int i = (1); i <= (len); i++)
ans[s[i]] = i % k == 0 ? k : i % k, gg[s[i]] = 1;
for (CUR = 1; CUR <= len; CUR++) {
dfs(s[CUR], 0, 0);
}
}
void DFS(int u, int fa, int x) {
ans[u] = x;
for (register int i = (0); i <= (((int)e[u].size()) - 1); i++)
if (e[u][i] != fa) DFS(e[u][i], u, 3 - x);
}
int main() {
read(n);
read(k);
for (register int i = (1); i <= (n - 1); i++) {
int u, v;
read(u);
read(v);
e[u].push_back(v);
e[v].push_back(u);
}
if (k == 2) {
DFS(1, 0, 1);
puts("Yes");
for (register int i = (1); i <= (n); i++) printf("%d ", ans[i]);
return 0;
}
int s = bfs(1), t = bfs(s);
if (dis[t] <= k - 2) {
puts("Yes");
for (register int i = (1); i <= (n); i++) printf("1 ");
return 0;
}
ini(s, t);
puts("Yes");
for (register int i = (1); i <= (n); i++) printf("%d ", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s = 0;
cin >> n;
while (n--) {
string a;
cin >> a;
if (a[1] == '+')
s++;
else
s--;
}
cout << s;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bitset<300000000 + 5> p;
void prime_list(int n) {
p.set();
int t = sqrt(n);
for (int i = 3; i <= t; i += 2)
if (p[i]) {
for (int j = i * i; j <= n; j += 2 * i) p[j] = 0;
}
}
int main() {
int l, r, c = 0;
scanf("%d%d", &l, &r);
prime_list(r);
c = l <= 2 && r >= 2;
for (int i = max(l / 4 * 4 + 1, 5); i <= r; i += 4)
if (i >= l && p[i]) c++;
printf("%d", c);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool ans[105][105], f[55][55][55][55], g[55][55][55][55];
void DP() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[i][j][i][j] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (i != n && ans[i][j] == ans[i + 1][j]) f[i][j][i + 1][j] = 1;
if (j != n && ans[i][j] == ans[i][j + 1]) f[i][j][i][j + 1] = 1;
}
for (int len = 0; len <= 2 * n; len++) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (n + n - i - j < len) break;
for (int dx = 0; dx <= len; dx++) {
int dy = len - dx;
if (i + dx > n || j + dy > n) continue;
int x = i + dx, y = j + dy;
if (f[i][j][x][y] == 0) continue;
if (ans[i - 1][j] == ans[x + 1][y]) f[i - 1][j][x + 1][y] = 1;
if (ans[i - 1][j] == ans[x][y + 1]) f[i - 1][j][x][y + 1] = 1;
if (ans[i][j - 1] == ans[x + 1][y]) f[i][j - 1][x + 1][y] = 1;
if (ans[i][j - 1] == ans[x][y + 1]) f[i][j - 1][x][y + 1] = 1;
}
}
}
}
int main() {
scanf("%d", &n);
ans[1][1] = 1;
ans[n][n] = 0;
printf("? 1 1 2 2\n");
fflush(stdout);
int s;
scanf("%d", &s);
ans[2][2] = s;
for (int i = 1; i <= n; i++)
for (int j = ((i & 1) ? 1 : 2); j < n; j += 2) {
if ((j == 1 || j == 2) && i + 2 <= n) {
printf("? %d %d %d %d\n", i, j, i + 2, j);
fflush(stdout);
int x;
scanf("%d", &x);
ans[i + 2][j] = ans[i][j] ^ x ^ 1;
}
if (j + 2 > n) break;
printf("? %d %d %d %d\n", i, j, i, j + 2);
fflush(stdout);
int x;
scanf("%d", &x);
ans[i][j + 2] = ans[i][j] ^ x ^ 1;
}
for (int i = 1; i <= n; i++)
for (int j = ((i & 1) ? 2 : 1); j < n; j += 2) {
if ((j == 1 || j == 2) && i + 2 <= n) {
printf("? %d %d %d %d\n", i, j, i + 2, j);
fflush(stdout);
int x;
scanf("%d", &x);
ans[i + 2][j] = ans[i][j] ^ x ^ 1;
}
if (j + 2 > n) break;
printf("? %d %d %d %d\n", i, j, i, j + 2);
fflush(stdout);
int x;
scanf("%d", &x);
ans[i][j + 2] = ans[i][j] ^ x ^ 1;
}
printf("? 1 2 2 3\n");
fflush(stdout);
scanf("%d", &s);
if ((s == 0 && ans[1][2] == ans[2][3]) ||
(s == 1 && ans[1][2] != ans[2][3])) {
for (int i = 2; i < n; i += 2)
for (int j = 1; j <= n; j += 2) ans[i][j] ^= 1;
}
DP();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = i; k <= n; k++)
for (int l = j; l <= n; l++) g[i][j][k][l] = f[i][j][k][l];
memset(f, 0, sizeof(f));
for (int i = 1; i <= n; i++)
for (int j = ((i & 1) ? 2 : 1); j <= n; j += 2) ans[i][j] ^= 1;
DP();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = i; k <= n; k++)
for (int l = j; l <= n; l++) {
if (k + l - i - j <= 2) continue;
if (f[i][j][k][l] != g[i][j][k][l]) {
printf("? %d %d %d %d\n", i, j, k, l);
fflush(stdout);
int x;
scanf("%d", &x);
if (x == g[i][j][k][l]) {
for (int xx = 1; xx <= n; xx++)
for (int yy = ((xx & 1) ? 2 : 1); yy <= n; yy += 2)
ans[xx][yy] ^= 1;
}
printf("!\n");
for (int xx = 1; xx <= n; xx++) {
for (int yy = 1; yy <= n; yy++) printf("%d", ans[xx][yy]);
printf("\n");
}
return 0;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
double pi = 3.1415926536;
const int oo = (int)1e9;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int di[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dj[] = {1, -1, 0, 0, 1, -1, 1, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int c1, c2, c3, c4;
cin >> c1 >> c2 >> c3 >> c4;
int n, m;
int sum = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x * c1 < c2)
sum += x * c1;
else
sum += c2;
}
if (sum > c3) sum = c3;
int sum2 = 0;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (x * c1 < c2)
sum2 += x * c1;
else
sum2 += c2;
}
if (sum2 > c3) sum2 = c3;
sum += sum2;
cout << min(sum, c4);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int M = 3e5 + 5;
int m = 0;
int cnt[M];
long long dp[M][8];
long long power(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % MOD;
b >>= 1;
a = a * a % MOD;
}
return ans;
}
long long C(long long a, long long b) {
long long ans = 1;
for (int i = 0; i < b; i += 1) {
ans = ans * (a - i) % MOD;
}
for (int i = 2; i <= b; i += 1) {
ans = ans * power(i, MOD - 2) % MOD;
}
return ans;
}
int main() {
int n;
cin >> n;
map<int, int> a;
for (int i = 0, x = 0; i < n; i += 1) {
cin >> x;
a[x] += 1;
m = max(m, x);
}
m += 1;
for (int i = 1; i < m; i += 1) {
cnt[i] = 0;
for (int j = i; j < m; j += i) {
if (a.count(j)) cnt[i] += a[j];
}
}
for (int j = 1; j < 8; j += 1) {
for (int i = m - 1; i > 0; i -= 1) {
dp[i][j] = 0;
if (cnt[i] < j) continue;
dp[i][j] = C(cnt[i], j);
for (int k = i + i; k < m; k += i) {
dp[i][j] = (dp[i][j] - dp[k][j] + MOD) % MOD;
}
}
if (dp[1][j] != 0) {
cout << j << endl;
return 0;
}
}
cout << -1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n;
cin >> n;
cin >> s;
cin >> s;
if (s == "week") {
if ((n == 5 || n == 6)) cout << 53;
if ((n >= 1 && n <= 4)) cout << 52;
if ((n == 7)) cout << 52;
}
if (s == "month") {
if (n >= 1 && n <= 29) cout << 12;
if (n == 30) cout << 11;
if (n == 31) cout << 7;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool check(char arr[]);
int main(void) {
char arr[109];
cin >> arr;
if (check(arr)) {
cout << "YES";
} else {
cout << "NO";
}
}
bool check(char arr[]) {
for (int i = 0; arr[i] != '\0'; i++) {
if (arr[i] == 'H' || arr[i] == 'Q' || arr[i] == '9') {
return true;
}
}
return false;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200;
char a[MAXN][MAXN];
bool mark[MAXN];
vector<int> t;
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
int ans = 0;
for (int i = 0; i < m; i++) {
bool flag = 0;
for (int j = 1; j < n; j++) {
if (a[j][i] > a[j - 1][i] && !mark[j - 1]) {
mark[j - 1] = 1;
t.push_back(j - 1);
} else if (!mark[j - 1] && a[j][i] < a[j - 1][i]) {
ans++;
flag = 1;
break;
}
}
if (flag) {
for (int j = 0; j < t.size(); j++) mark[t[j]] = 0;
}
t.clear();
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[105], b[105], dp[105][20005];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
}
memset(dp, -1, sizeof(dp));
for (int i = 0; i <= n; i++) dp[i][10000] = 0;
for (int i = 1; i <= n; i++) {
for (int j = k * b[i] - a[i]; j <= 20000; j++) {
if (dp[i - 1][j - k * b[i] + a[i]] == -1) {
dp[i][j] = dp[i - 1][j];
} else {
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - k * b[i] + a[i]] + a[i]);
}
}
}
printf("%d", dp[n][10000] == 0 ? -1 : dp[n][10000]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, n;
cin >> a >> b >> c >> n;
a = a - c;
b = b - c;
n = n - a - b - c;
if (n > 0 && a >= 0 && b >= 0 && c >= 0) {
cout << n;
} else {
cout << "-1";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
long long pow(int a, int b) {
if (b == 0 || a == 1) return 1;
if (b % 2 == 0)
return pow(a, b / 2) * pow(a, b / 2);
else
return pow(a, b / 2) * pow(a, b / 2) * a;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
if (a > b)
return gcd(a % b, b);
else
return gcd(b % a, a);
}
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int c;
cin >> c;
int m1[c], m2[c];
int ans[c];
int d = max(a, b);
for (int i = 0; i < c; i++) {
cin >> m1[i] >> m2[i];
ans[i] = 0;
if (m1[i] > d || m2[i] > d) ans[i] = 1;
if (m1[i] + m2[i] < b || m1[i] + m2[i] > a + a - b) ans[i] = 1;
if (abs(m1[i] - m2[i]) > b) ans[i] = 1;
}
for (int i = 0; i < c; i++)
if (ans[i] == 0)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool debug = false;
int a[100005];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
sort(a, a + n);
int x = a[0], r = 0;
for (int i = 0, j; i < n; i = j) {
for (j = i + 1; a[i] == a[j]; j++)
;
if (x + 1 < a[i]) {
puts("NO");
return 0;
}
m = j - i;
if (m > r) {
x = a[i];
r = m - r;
} else {
r = r - m;
}
}
puts(r ? "NO" : "YES");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;
const int n_ = 1e5 + 1000;
long long power(long long a, long long n, long long mod = MOD) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
int n, m, g[n_], G, vis[n_], dis[n_], sum, C;
vector<int> e[n_], re[n_], tp, cmp[n_];
queue<int> q;
void dfs(int u) {
vis[u] = 1;
for (auto v : e[u])
if (!vis[v]) dfs(v);
tp.push_back(u);
}
void rdfs(int u, int c) {
g[u] = c;
cmp[c].push_back(u);
vis[u] = 1;
for (auto v : re[u])
if (!vis[v]) rdfs(v, c);
}
void SCC() {
for (int i = 0; i < n; i++) {
if (!vis[i]) dfs(i);
}
memset(vis, 0, sizeof vis);
for (int i = n - 1; i >= 0; i--) {
if (!vis[tp[i]]) rdfs(tp[i], G++);
}
}
int bfs(int s) {
int ret = INF;
vis[s] = 1;
q.push(s);
dis[s] = 0;
while (q.size()) {
int u = q.front();
q.pop();
for (auto v : e[u]) {
if (!vis[v]) {
vis[v] = 1;
dis[v] = dis[u] + 1;
q.push(v);
} else if (v == s) {
ret = min(ret, dis[u] + 1);
}
}
}
return ret;
}
int get(int c) {
int ret = INF;
for (auto u : cmp[c]) {
while (q.size()) q.pop();
memset(vis, 0, sizeof vis);
ret = min(ret, bfs(u));
}
return (ret == INF ? 0 : ret);
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
e[u].push_back(v);
re[v].push_back(u);
}
SCC();
for (int i = 0; i < G; i++) {
int fl = 1;
for (auto u : cmp[i]) {
for (auto v : e[u]) {
fl &= (g[u] == g[v]);
}
}
if (fl) {
int tmp = get(i);
sum += tmp;
C += (tmp != 0);
}
}
cout << n + C + 998 * sum << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXD = 2002;
int main() {
int n;
cin >> n;
vector<int> T(n), D(n), P(n);
for (int i = (0); i < (n); i++) cin >> T[i] >> D[i] >> P[i];
vector<int> indexes;
for (int i = (0); i < (n); i++) indexes.push_back(i);
sort(indexes.begin(), indexes.end(),
[=](int i, int j) { return D[i] < D[j]; });
vector<vector<int>> dp(n + 1, vector<int>(MAXD * 2, 0));
for (int i = (0); i < (n); i++)
for (int t = (0); t < (MAXD); t++) {
if (dp[i + 1][t] < dp[i][t]) {
dp[i + 1][t] = dp[i][t];
}
if (t + T[indexes[i]] < D[indexes[i]]) {
if (dp[i + 1][t + T[indexes[i]]] < dp[i][t] + P[indexes[i]]) {
dp[i + 1][t + T[indexes[i]]] = dp[i][t] + P[indexes[i]];
}
}
}
int time = -1;
int max_p = 0;
for (int t = (0); t < (MAXD); t++)
if (max_p < dp[n][t]) {
max_p = dp[n][t];
time = t;
}
vector<int> item_order;
while (time > 0 and n > 0) {
if (dp[n - 1][time] == dp[n][time]) {
--n;
continue;
} else {
item_order.push_back(indexes[n - 1]);
time -= T[indexes[n - 1]];
--n;
}
}
reverse(item_order.begin(), item_order.end());
cout << max_p << endl;
cout << item_order.size() << endl;
for (auto itm : item_order) printf("%d ", itm + 1);
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int num[100005];
int a, b;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> num[i];
cin >> a >> b;
sort(num, num + n);
int len = unique(num, num + n) - num;
int ans = 0;
while (a > b) {
int t = a - 1;
for (int i = 0; i < len && i > -1; i++) {
if (a - a % num[i] < b)
num[i--] = num[--len];
else
t = min(t, a - a % num[i]);
}
ans++;
a = t;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
cout << (a - 1) * 9 + b << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[int(3e5 + 5)];
void solve() {
bool f = 0;
long long ans[2] = {0, 0};
for (long long i = 0; i < (n); ++i) {
ans[f] += a[i] / 2;
ans[!f] += a[i] - a[i] / 2;
f = !f;
}
cout << min(ans[0], ans[1]);
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long test = 1;
while (test--) {
cin >> n;
for (long long i = 0; i < (n); ++i) cin >> a[i];
solve();
cout << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1012345678;
const double PI = acos(-1.0);
const double EPS = 0.0000000304;
const int MAX = 1231231;
int dp[MAX];
int tp[MAX];
char ip[MAX];
int op[MAX];
int L;
vector<pair<int, int> > ans;
int main() {
gets(ip);
L = strlen(ip);
for (int(i) = 0; (i) < (L); (i)++) {
op[i] = ip[L - i - 1] - '0';
}
int bs = 0, bt = -1;
for (int(i) = 0; (i) < (L); (i)++) {
tp[i] = -1;
dp[i] = dp[i - 1] + op[i];
bs += (1 - op[i]);
if (dp[i] > bs + 2) {
dp[i] = bs + 2;
tp[i] = bt + 1;
}
if (bs > dp[i]) {
bs = dp[i];
bt = i;
}
}
printf("%d\n", dp[L - 1]);
int id = L - 1;
while (id >= 0) {
if (tp[id] == -1) {
if (op[id]) {
ans.push_back((make_pair((id), (1))));
}
id--;
} else {
int rr = tp[id], nn = id;
ans.push_back((make_pair((id + 1), (1))));
ans.push_back((make_pair((rr), (-1))));
while (nn >= rr) {
if (!op[nn]) {
ans.push_back((make_pair((nn), (-1))));
}
nn--;
}
id = nn - 1;
}
}
for (int(i) = 0; (i) < (ans.size()); (i)++) {
if (ans[i].second > 0) {
printf("+2^%d\n", ans[i].first);
} else {
printf("-2^%d\n", ans[i].first);
}
}
}
| 6 |
#include <bits/stdc++.h>
void err() { std::cout << '\n'; }
template <typename T, typename... Args>
void err(T a, Args... args) {
std::cout << a << ' ';
err(args...);
}
template <template <typename...> class T, typename t, typename... A>
void err(const T<t> &arg, const A &...args) {
for (auto &v : arg) std::cout << v << ' ';
err(args...);
}
using namespace std;
const int N = 1000 + 5;
int n;
vector<int> G[N], sons[N];
bool chk[N];
int now;
void dfs(int u, int fa) {
for (auto v : G[u])
if (v != fa) {
dfs(v, u);
sons[u].push_back(v);
}
}
int query(int u, int v) {
cout << '?' << ' ' << u << ' ' << v << endl;
int z;
cin >> z;
return z;
}
int get(int u) {
chk[u] = true;
int SZ = (int)(sons[u]).size();
for (auto it : sons[u])
if (chk[it]) --SZ;
if (SZ == 0) return u;
for (auto it : sons[u])
if (!chk[it]) {
return get(it);
}
}
void gao(int u) {
now = u;
int SZ = (int)(sons[u]).size();
for (auto it : sons[u])
if (chk[it]) --SZ;
if (SZ == 0) {
return;
} else if (SZ == 1) {
for (auto it : sons[u])
if (!chk[it]) {
int to = get(it);
int z = query(u, to);
now = z;
if (z == to || z == u) return;
gao(now);
return;
}
} else {
vector<int> v;
for (auto it : sons[u])
if (!chk[it]) v.push_back(it);
for (int i = 0; i < (int)(v).size(); i += 2) {
if (i + 1 < (int)(v).size()) {
int z = query(v[i], v[i + 1]);
if (z == v[i] || z == v[i + 1]) {
now = z;
gao(now);
return;
}
} else {
int to = get(v[i]);
int z = query(u, to);
now = z;
if (z == to || z == u) return;
gao(now);
return;
}
}
}
}
void run() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, 0);
gao(1);
cout << "!" << ' ' << now << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
run();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
int k;
cin >> n >> k;
vector<long long> div;
for (long long i = 1; i * i <= n; ++i) {
if (n % i == 0) {
div.push_back(i);
long long ni = n / i;
if (i != ni) {
div.push_back(ni);
}
}
}
sort(div.begin(), div.end());
if (k <= div.size()) {
cout << div[k - 1] << '\n';
} else {
cout << -1 << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
static long long int r, j, l, x, y, b, m, n, s, q, i, z, p, k, c, d, t;
string s1, s2, s3, s4, st1, st2;
long long int a[1000009];
unordered_map<long long int, long long int> dp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long int i = 1; i < n + 1; i++) {
cin >> a[i];
a[i] %= k;
}
for (long long int i = 1; i < n + 1; i++) {
if (a[i] == 0) {
cout << "YES";
return 0;
}
if (dp[k - a[i]] > 0) {
cout << "YES";
return 0;
}
unordered_map<long long int, long long int> temp;
for (auto x : dp) {
if (x.second > 0) temp[(a[i] + x.first) % k]++;
}
for (auto x : temp) {
dp[x.first]++;
}
dp[a[i]]++;
}
cout << "NO";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string a, b, c, d, s;
int main() {
cin >> a >> b;
int m1 = 0, m2 = 0;
for (int i = 0; i < (int)a.size(); i++) m1 += (a[i] == '1');
for (int i = 0; i < (int)b.size(); i++) m2 += (b[i] == '1');
if (m1 & 1) m1++;
if (m1 >= m2)
puts("YES");
else
puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string pirmas, antras;
cin >> pirmas >> antras;
int nuliu = 0, vienetu = 0;
for (int i = 0; i < n; i++) {
if (pirmas[i] == '0')
nuliu++;
else
vienetu++;
}
vector<int> ats;
bool visi_vienetai;
if (nuliu > vienetu) {
visi_vienetai = false;
for (int i = 0; i < n; i++) {
if (pirmas[i] == '1') {
if (i != 0) {
ats.push_back(i - 1);
}
ats.push_back(i);
}
}
} else {
visi_vienetai = true;
for (int i = 0; i < n; i++) {
if (pirmas[i] == '0') {
if (i != 0) {
ats.push_back(i - 1);
}
ats.push_back(i);
}
}
}
for (int i = n - 1; i >= 0; i--) {
if (visi_vienetai) {
if (antras[i] == '1')
continue;
else {
ats.push_back(i);
visi_vienetai = false;
}
} else {
if (antras[i] == '0')
continue;
else {
ats.push_back(i);
visi_vienetai = true;
}
}
}
cout << ats.size() << " ";
for (int i = 0; i < ats.size(); i++) cout << ats[i] + 1 << " ";
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#include <algorithm>
using namespace std;
#define ll long long
void solve(){
ll n;
cin>>n;
ll ans=0;
for(int i=1;i<=9;i++){
ll x=0;
for(int j=1;j<=10;j++){
x=x*10+i;
if(x<=n){
ans++;
}
}
}
cout<<ans<<endl;
}
int main(){
int t;cin>>t;
while(t--){
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target( \
"avx,avx2,fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long MOD = 1e9 + 7;
const int N = 1000000;
long long dp[N];
const int NN = 8 * N;
long long dr[NN];
long long gg[NN];
void push(long long v, long long l, long long r) {
dr[v] = min(dr[v], gg[v]);
gg[2 * v + 1] = min(gg[v], gg[2 * v + 1]);
gg[2 * v + 2] = min(gg[v], gg[2 * v + 2]);
gg[v] = MOD;
}
void ch(long long v, long long l, long long r, long long ln, long long rn,
long long x) {
push(v, l, r);
if ((r <= ln || rn <= l)) {
return;
}
if (ln <= l && r <= rn) {
gg[v] = min(x, gg[v]);
push(v, l, r);
return;
}
ch(2 * v + 1, l, (l + r) / 2, ln, rn, x);
ch(2 * v + 2, (l + r) / 2, r, ln, rn, x);
dr[v] = min(dr[2 * v + 1], dr[2 * v + 2]);
}
long long sm(long long v, long long l, long long r, long long x) {
push(v, l, r);
if (l + 1 == r) {
return dr[v];
}
if ((l + r) / 2 > x) {
return sm(2 * v + 1, l, (l + r) / 2, x);
} else {
return sm(2 * v + 2, (l + r) / 2, r, x);
}
}
vector<long long> gd[N];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0),
cout << fixed << setprecision(20);
long long n;
cin >> n;
memset(dr, MOD, sizeof(dr));
memset(gg, MOD, sizeof(gg));
vector<long long> x;
set<long long> tmp;
for (int i = 0; i < n; i++) {
long long xx;
cin >> xx;
tmp.insert(xx);
}
for (auto i : tmp) {
x.push_back(i);
}
long long a, b;
cin >> a >> b;
n = x.size();
long long ans = 0;
long long k;
while (a > b) {
k = a - 1;
for (int i = 0; i < n; i++) {
long long nw = a - a % x[i];
if (nw >= b) k = min(nw, k);
}
long long t = n - 1;
while (t && ((a - a % x[t]) < b)) t--;
t++;
n = t;
a = k;
ans++;
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400 + 5;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
char s[N][N];
int row[N][N], col[N][N], dia[N][N], dia2[N][N];
int n, m;
int check8(int x, int y) {
int ret = 0;
int mx = min(x - 1, min(y - 1, m - y));
for (int a = 1; a <= mx; ++a) {
int tx = x - a, y1 = y - a, y2 = y + a;
int tmp = row[tx][y2] - row[tx][y1 - 1];
tmp += dia2[x][y] - dia2[tx - 1][y2 + 1];
tmp += dia[x][y] - dia[tx - 1][y1 - 1];
if (!tmp) ret++;
}
return ret;
}
int check7(int x, int y) {
int mx = min(n - x, m - y);
int ret = 0;
for (int a = 1; a <= mx; ++a) {
int tx = x + a, ty = y + a;
int tmp = row[x][ty] - row[x][y - 1];
tmp += col[tx][y] - col[x - 1][y];
tmp += dia2[tx][y] - dia2[x - 1][ty + 1];
if (!tmp) ret++;
}
return ret;
}
int check6(int x, int y) {
int mx = min(n - x, y - 1);
int ret = 0;
for (int a = 1; a <= mx; ++a) {
int tx = x + a, ty = y - a;
int tmp = row[x][y] - row[x][ty - 1];
tmp += col[tx][y] - col[x - 1][y];
tmp += dia[tx][y] - dia[x - 1][ty - 1];
if (!tmp) ret++;
}
return ret;
}
int check5(int x, int y) {
int mx = min(min(n - x, x - 1), y - 1);
int ret = 0;
for (int a = 1; a <= mx; ++a) {
int x1 = x - a, x2 = x + a, ty = y - a;
int tmp = col[x2][ty] - col[x1 - 1][ty];
tmp += dia2[x2][ty] - dia2[x - 1][y + 1];
tmp += dia[x][y] - dia[x1 - 1][ty - 1];
if (!tmp) ret++;
}
return ret;
}
int check4(int x, int y) {
int mx = min(min(n - x, x - 1), m - y);
int ret = 0;
for (int a = 1; a <= mx; ++a) {
int x1 = x - a, x2 = x + a, ty = y + a;
int tmp = col[x2][ty] - col[x1 - 1][ty];
tmp += dia2[x][y] - dia2[x1 - 1][ty + 1];
tmp += dia[x2][ty] - dia[x - 1][y - 1];
if (!tmp) ret++;
}
return ret;
}
int check3(int x, int y) {
int ret = 0;
int mx = min(n - x, min(y - 1, m - y));
for (int a = 1; a <= mx; ++a) {
int tx = x + a, y1 = y - a, y2 = y + a;
int tmp = row[tx][y2] - row[tx][y1 - 1];
tmp += dia2[tx][y1] - dia2[x - 1][y + 1];
tmp += dia[tx][y2] - dia[x - 1][y - 1];
if (!tmp) ret++;
}
return ret;
}
int check2(int x, int y) {
int ret = 0;
int mx = min(n - x, y - 1);
for (int a = 1; a <= mx; ++a) {
int tx = x + a, ty = y - a;
int tmp = row[tx][y] - row[tx][ty - 1];
tmp += col[tx][y] - col[x - 1][y];
tmp += dia2[tx][ty] - dia2[x - 1][y + 1];
if (!tmp) ret++;
}
return ret;
}
int check1(int x, int y) {
int ret = 0;
int mx = min(n - x, m - y);
for (int a = 1; a <= mx; ++a) {
int tx = x + a, ty = y + a;
int tmp = row[tx][ty] - row[tx][y - 1];
tmp += dia[tx][ty] - dia[x - 1][y - 1];
tmp += col[tx][y] - col[x - 1][y];
if (!tmp) ret++;
}
return ret;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; ++j) row[i][j] = row[i][j - 1] + (s[i][j] == '1');
}
for (int j = 1; j <= m; ++j) {
for (int i = 1; i <= n; ++i) col[i][j] = col[i - 1][j] + (s[i][j] == '1');
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
dia[i][j] = dia[i - 1][j - 1] + (s[i][j] == '1');
dia2[i][j] = dia2[i - 1][j + 1] + (s[i][j] == '1');
}
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j)
if (s[i][j] == '0') {
int cnt = 0;
cnt += check1(i, j);
cnt += check2(i, j);
cnt += check3(i, j);
cnt += check4(i, j);
cnt += check5(i, j);
cnt += check6(i, j);
cnt += check7(i, j);
cnt += check8(i, j);
ans += cnt;
}
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long base = 7;
int main() {
int n;
cin >> n;
n--;
string s1, s2;
cin >> s1 >> s2;
vector<int> a1(n, 0);
map<char, int> con;
con['N'] = 0;
con['W'] = 1;
con['S'] = 2;
con['E'] = 3;
for (int i = n - 1; i >= 0; i--) {
a1[n - 1 - i] = (con[s1[i]] + 2) % 4;
}
vector<int> a2(n, 0);
for (int i = 0; i < n; i++) {
a2[i] = con[s2[i]];
}
long long h1 = 0, h2 = 0;
bool can = true;
long long expo = 1;
for (int i = 0; i < n; i++) {
h1 = (h1 * base + (long long)a1[i]) % mod;
h2 = (h2 + expo * (long long)a2[n - 1 - i]) % mod;
expo = (expo * base) % mod;
if (h1 == h2) {
can = false;
break;
}
}
if (can)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Solver {
int n;
int k, l;
int a[1000005];
Solver(string s, int kk, int l1) {
k = kk, l = l1;
n = s.size();
for (int i = 1; i <= n; i++) {
a[i] = s[i - 1] - '0';
}
}
pair<long long int, long long int> calc(long long int cost) {
vector<long long int> d(n + 1), cnt(n + 1);
for (int i = 1; i <= n; i++) {
d[i] = d[i - 1] + a[i];
cnt[i] = cnt[i - 1];
int u = min(i, l);
if (d[i] < d[i - u] + u - cost) {
d[i] = d[i - u] + u - cost;
cnt[i] = cnt[i - u] + 1;
}
}
return {d[n], cnt[n]};
}
long long int solve() {
int lower = 0, upper = n;
while (lower < upper) {
int mid = (lower + upper) / 2;
auto u = calc(mid);
if (u.second > k) {
lower = mid + 1;
} else {
upper = mid;
}
}
auto u = calc(lower);
return u.first + k * 1ll * lower;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
int n, k, l;
cin >> n >> k >> l;
string s, s2;
cin >> s;
s2 = s;
for (int i = 0; i <= n - 1; i++) {
if (s[i] >= 'A' && s[i] <= 'Z') {
s[i] = '1';
s2[i] = '0';
} else {
s[i] = '0';
s2[i] = '1';
}
}
Solver a(s, k, l);
Solver b(s2, k, l);
cout << n - max(a.solve(), b.solve()) << endl;
return 0;
}
| 10 |
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
const int N = 1001;
const int K = 1001;
int n, k;
const int mod = 1e9 + 7;
int dp[N][K][2];
int solve(int curr, int k, int dir) {
if (k == 1) {
return 1;
}
if (dp[curr][k][dir] != -1) {
return dp[curr][k][dir];
}
int ans = 2; // me and my copy
if (dir == 1) {
if (curr < n)
ans += solve(curr + 1, k, dir) - 1;
ans %= mod;
if (curr > 1)
ans += solve(curr - 1, k - 1, 1 - dir) - 1;
ans %= mod;
dp[curr][k][dir] = ans;
} else {
if (curr > 1)
ans += solve(curr - 1, k, dir) - 1;
ans %= mod;
if (curr < n)
ans += solve(curr + 1, k - 1, 1 - dir) -1;
ans %= mod;
dp[curr][k][dir] = ans;
}
return ans;
}
int main() {
int t;
cin >> t;
while (t--) {
cin >> n >> k;
memset(dp, -1, sizeof(dp));
cout << solve(1, k, 1) << endl;
}
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.