solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int a[20][20];
int b[400];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m;
int pos, neg, zero;
pos = neg = zero = 0;
int cnt = 1;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
if (a[i][j] > 0) {
pos++;
} else if (a[i][j] < 0) {
neg++;
} else
zero++;
if (a[i][j] >= 0)
b[cnt++] = a[i][j];
else
b[cnt++] = -a[i][j];
}
}
sort(b + 1, b + cnt, less<int>());
int minn = min(pos, neg);
int sum = 0;
for (int i = 1; i < cnt; i++) {
sum += b[i];
}
if (neg % 2 == 1 && zero == 0) sum -= 2 * b[1];
printf("%d\n", sum);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main(void) {
long long int t, n;
scanf("%lld", &t);
for (int i = 0; i < t; i++) {
scanf("%lld", &n);
long long int x = n / 2;
printf("%lld\n", (4 * x * (x + 1) * ((2 * x) + 1)) / 3);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
struct Point {
long long x, y;
Point() {}
Point(long long x, long long y) : x(x), y(y) {}
long double abs() const { return hypot(x, y); }
long double arg() const { return atan2(y, x); }
Point operator*(double o) const { return Point(x * o, y * o); }
Point operator+(const Point &o) const { return Point(x + o.x, y + o.y); }
Point operator-(const Point &o) const { return Point(x - o.x, y - o.y); }
bool operator<(const Point &o) const { return arg() < o.arg(); }
friend bool operator==(const Point &r1, const Point &r2) {
return r1.x == r2.x && r1.y == r2.y;
}
Point scale(double o) const { return *this * (o / abs()); }
Point rotY() const { return Point(-y, x); }
Point rotX() const { return Point(y, -x); }
long long cross(Point b) const { return x * b.y - b.x * y; }
long long dot(Point b) const { return x * b.x + y * b.y; }
long double disToSeg(Point &a, Point &b) {
return fabs(((*this) - a).cross(b - a) / (b - a).abs());
}
void readin() { scanf("%lld%lld", &x, &y); }
};
Point A[205], B[205];
int cnt;
vector<int> in[205], ot[205];
queue<int> q[205];
bool lft(Point a, Point b, Point c) { return (b - a).cross(c - a) < 0; }
void add(int x, int y) {
while (!q[x].empty() && lft(B[q[x].front()], B[y], B[x])) {
add(q[x].front(), y);
q[x].pop();
}
in[y].push_back(x);
ot[x].push_back(y);
q[y].push(x);
}
long double dp[205][205][55], tmp[205];
void fmain(int tid) {
scanf("%d%d", &n, &k);
k--;
for (int(i) = 1; (i) <= (int)(n); (i)++) A[i].readin();
long double ans = 0;
for (int(r) = 1; (r) <= (int)(n); (r)++) {
cnt = 0;
for (int(i) = 1; (i) <= (int)(n); (i)++)
if (A[i].y > A[r].y || (A[i].y == A[r].y && A[i].x > A[r].x)) {
B[++cnt] = A[i] - A[r];
}
sort(B + 1, B + 1 + cnt);
for (int(i) = 1; (i) <= (int)(cnt); (i)++) {
in[i].clear();
ot[i].clear();
while (!q[i].empty()) q[i].pop();
}
for (int(i) = 1; (i) <= (int)(cnt - 1); (i)++) add(i, i + 1);
for (int(i) = 1; (i) <= (int)(cnt); (i)++)
for (int(j) = 1; (j) <= (int)(cnt); (j)++)
for (int(z) = 1; (z) <= (int)(k); (z)++) dp[i][j][z] = 0;
for (int i = cnt; i; i--) {
int sz = (int)ot[i].size() - 1;
for (int(j) = 1; (j) <= (int)(k); (j)++) tmp[j] = 0;
for (int j = (int)in[i].size() - 1; ~j; j--) {
int x = in[i][j];
long long area = B[x].cross(B[i]);
dp[i][x][1] = area;
for (int z = 2; z < k; z++)
if (tmp[z - 1]) {
dp[i][x][z] = area + tmp[z - 1];
}
for (; sz >= 0 && lft(B[x], B[ot[i][sz]], B[i]); sz--) {
for (int z = 2; z < k; z++)
if (tmp[z - 1] < dp[ot[i][sz]][i][z - 1]) {
tmp[z - 1] = dp[ot[i][sz]][i][z - 1];
dp[i][x][z] = area + tmp[z - 1];
}
}
ans = max(ans, dp[i][x][k - 1]);
}
}
}
printf("%.2Lf\n", ans / 2);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c;
cin >> a >> b >> c;
if ((b - a) * c < 0 && b != a) {
cout << "NO";
return 0;
} else {
if (c == 0) {
cout << (b == a ? "YES" : "NO");
return 0;
}
if ((b - a) % c == 0) {
cout << "YES";
return 0;
}
}
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int parent[200005], rank1[200005] = {0}, dp[200005] = {0}, l, vis[200005] = {0};
vector<long long int> adj[500005];
void make_set(int v) {
parent[v] = v;
rank1[v] = 0;
}
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rank1[a] < rank1[b]) swap(a, b);
parent[b] = a;
if (rank1[a] == rank1[b]) rank1[a]++;
}
}
struct Edge {
long long int u, v, weight, id;
};
bool cmp(const Edge &e1, const Edge &e2) { return e1.weight < e2.weight; }
int n;
vector<Edge> edges;
vector<Edge> result;
set<long long int> st;
set<long long int>::iterator it;
long long int mst() {
long long int cost = 0;
for (int i = 1; i <= n; i++) make_set(i);
sort(edges.begin(), edges.end(), cmp);
for (Edge e : edges) {
if (find_set(e.u) != find_set(e.v)) {
cost += e.weight;
result.push_back(e);
st.insert(e.id);
union_sets(e.u, e.v);
}
}
for (long long int i = 0; i < result.size(); i++) {
long long int u = result[i].u;
long long int v = result[i].v;
adj[u].push_back(v);
adj[v].push_back(u);
}
return cost;
}
int timer;
int tin[200005] = {0}, tout[200005] = {0};
long long int up[200005][30], maxweight[200005][30];
map<pair<int, int>, long long int> mp;
void dfs(int v, long long int cost, int p) {
vis[v] = 1;
tin[v] = ++timer;
up[v][0] = p;
if (p == v)
maxweight[v][0] = 0;
else
maxweight[v][0] = cost;
for (int i = 1; i <= l; ++i) {
up[v][i] = up[up[v][i - 1]][i - 1];
maxweight[v][i] = max(maxweight[v][i - 1], maxweight[up[v][i - 1]][i - 1]);
}
for (int u : adj[v]) {
if (!vis[u]) dfs(u, mp[{u, v}], v);
}
tout[v] = ++timer;
}
bool is_ancestor(int u, int v) {
return tin[u] <= tin[v] && tout[u] >= tout[v];
}
int lca(int u, int v) {
long long int lc = 1;
if (is_ancestor(u, v))
lc = u;
else if (is_ancestor(v, u))
lc = v;
else {
for (int i = l; i >= 0; --i) {
if (!is_ancestor(up[u][i], v)) {
u = up[u][i];
}
}
lc = up[u][0];
}
return lc;
}
void preprocess(int root) {
timer = 0;
l = ceil(log2(n));
dfs(root, 0, root);
}
long long int solve(Edge e) {
long long int u = e.u;
long long int v = e.v;
long long int lc = lca(u, v);
long long int res = -1;
for (int i = l; i >= 0; --i) {
if (!is_ancestor(up[v][i], lc)) {
res = max(res, maxweight[v][i]);
v = up[v][i];
}
if (!is_ancestor(up[u][i], lc)) {
res = max(res, maxweight[u][i]);
u = up[u][i];
}
}
if (u != lc) res = max(res, maxweight[u][0]);
if (v != lc) res = max(res, maxweight[v][0]);
if (e.weight == res)
return 1;
else
return 0;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int m;
cin >> n >> m;
int i, j, x, y, z;
for (i = 1; i <= m; i++) {
cin >> x >> y >> z;
mp[{x, y}] = z;
mp[{y, x}] = z;
Edge e;
;
e.u = x;
e.v = y;
e.weight = z;
e.id = i;
edges.push_back(e);
}
x = mst();
long long int ans = 0;
preprocess(1);
for (Edge e : edges) {
if (st.find(e.id) == st.end()) {
if (solve(e)) ans++;
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char a[1002], b[1002];
int main() {
scanf("%s", a);
scanf("%s", b);
int alen = strlen(a);
int blen = strlen(b);
int aone = 0, bone = 0;
for (int i = 0; i < alen; i++) {
if (a[i] == '1') {
aone++;
}
}
for (int i = 0; i < blen; i++) {
if (b[i] == '1') {
bone++;
}
}
if (bone > aone + 1) {
printf("NO\n");
return 0;
}
if (aone % 2 == 0) {
if (bone > aone) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const double EPS = 1e-10;
inline double SQR(double x) { return x * x; }
inline long long SQR(long long x) { return x * x; }
inline int SQR(int x) { return x * x; }
inline double SQR3(double x) { return x * x * x; }
inline void DEBUG() { puts("jackie"); }
inline bool zero(double x) { return abs(x) < EPS; }
inline int inInt() {
int x = 0, c;
while ((unsigned int)((c = getchar()) - '0') >= 10) {
if ('-' == c) return -inInt();
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned int)((c = getchar()) - '0') < 10);
return x;
}
inline void outInt(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) outInt(x / 10);
putchar((x % 10) + '0');
}
const int MAXN = 600;
int cost[MAXN][MAXN];
char str[MAXN];
int dp[MAXN][MAXN];
int N, K;
const int nMax = 1000000;
int DP(int s, int k) {
if (s >= N) return 0;
if (k <= 0) return nMax;
if (-1 != dp[s][k]) return dp[s][k];
int ans = INF;
for (int i = s + 1; i <= N; i++) {
ans = min(ans, cost[s][i - 1] + DP(i, k - 1));
}
dp[s][k] = ans;
return dp[s][k];
}
void print(int s, int t) {
int x = s, y = t;
while (x < y) {
str[y] = str[x];
x++, y--;
}
for (int i = s; i <= t; i++) putchar(str[i]);
}
int main() {
scanf("%s", str);
scanf("%d", &K);
N = strlen(str);
for (int i = 0; i < N; i++) {
for (int j = i; j < N; j++) {
int s = i, t = j;
int a = 0;
while (s < t) {
if (str[s] != str[t]) a++;
s++, t--;
}
cost[i][j] = a;
}
}
memset(dp, -1, sizeof(dp));
int ans = DP(0, K);
printf("%d\n", ans);
int idx = 0;
int k = K;
while (idx < N) {
for (int j = idx + 1; j <= N; j++) {
if (DP(idx, k) == cost[idx][j - 1] + DP(j, k - 1)) {
print(idx, j - 1);
if (j != N) putchar('+');
idx = j;
k--;
break;
}
}
}
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long sum[500010], last[500010], n, a, b, t, ans;
char s[500010];
int main() {
scanf("%I64d%I64d%I64d%I64d", &n, &a, &b, &t);
scanf("%s", s + 1);
for (long long i = 1; i <= n; i++) sum[i] += sum[i - 1] + (s[i] == 'w') * b;
for (long long i = n; i; i--) last[i] = last[i + 1] + (s[i] == 'w') * b;
for (long long i = 1; i <= n; i++) {
long long now = sum[i] + i + a * (i - 1);
if (now > t) break;
ans = max(ans, i);
now += a * (i - 1);
if (now > t) continue;
long long l = 0, r = n - i, tmp = 0;
while (l <= r) {
long long mid = l + r >> 1;
if (now + last[n + 1 - mid] + mid + a * mid <= t)
tmp = mid, l = mid + 1;
else
r = mid - 1;
}
ans = max(ans, i + tmp);
}
for (long long i = 2; i <= n; i++) {
long long now = 1 + sum[1] + last[i] + (n - i + 1) * a + (n - i + 1);
if (now > t) continue;
ans = max(ans, n + 2 - i);
now += a * (n + 1 - i);
if (now > t) continue;
long long l = 0, r = i - 2, tmp = 0;
while (l <= r) {
long long mid = l + r >> 1;
if (now + sum[mid + 1] - sum[1] + a * mid + mid <= t)
tmp = mid, l = mid + 1;
else
r = mid - 1;
}
ans = max(ans, n + 2 - i + tmp);
}
printf("%I64d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
char ans[100][100], minn[100][100];
string A[10];
int F = false, MX, MY, visited[100][100], MINX = 99, MINY = 99;
void _clear() {
int i, j;
for (i = 0; i < (100); i++)
for ((j) = (0); (j) < (100); (j)++) ans[i][j] = '.';
}
void _extreme() {
int i, j;
MINX = MINY = 0;
for (i = 0; i < 100; i++)
for (j = 0; j < 100; j++) {
if (minn[i][j] != '.') {
MINX = (((MINX) > (i)) ? (MINX) : (i));
MINY = (((MINY) > (j)) ? (MINY) : (j));
}
}
}
bool islesser() {
int i, j;
for (i = 0; i < 100; i++) {
for (j = 0; j < 100; j++) {
if (ans[i][j] != minn[i][j]) {
if (ans[i][j] < minn[i][j])
return true;
else
return false;
}
}
}
}
void update() {
int i, j;
if (islesser()) {
F = true;
for (i = 0; i < (100); i++) {
for ((j) = (0); (j) < (100); (j)++) minn[i][j] = ans[i][j];
}
_extreme();
}
}
void find_extreme() {
int i, j;
MX = MY = 0;
for (i = 0; i < 100; i++)
for (j = 0; j < 100; j++) {
if (ans[i][j] != '.') {
MX = (((MX) > (i)) ? (MX) : (i));
MY = (((MY) > (j)) ? (MY) : (j));
}
}
for (i = 0; i < (MX + 1); i++) ans[i][MY + 1] = '\0';
}
pair<int, int> horizontal_write(int posx, int posy, int n) {
int i, j, l = A[n].size();
for (i = posy, j = 0; j < l; i++, j++) {
if (ans[posx][i] != '.' && ans[posx][i] != A[n][j])
return make_pair(-1, -1);
ans[posx][i] = A[n][j];
}
return make_pair(posx, i - 1);
}
pair<int, int> vertical_write(int posx, int posy, int n) {
int i, j, l = A[n].size();
for (i = posx, j = 0; j < l; i++, j++) {
if (ans[i][posy] != '.' && ans[i][posy] != A[n][j])
return make_pair(-1, -1);
ans[i][posy] = A[n][j];
}
return make_pair(i - 1, posy);
}
bool ispoxible(vector<int> v) {
int i, j, k;
pair<int, int> a, b, c;
_clear();
a = horizontal_write(0, 0, v[0]);
if (a.first == -1) return false;
a = vertical_write(a.first, a.second, v[2]);
if (a.first == -1) return false;
a = horizontal_write(a.first, a.second, v[5]);
b = a;
if (a.first == -1) return false;
a = vertical_write(0, 0, v[1]);
if (a.first == -1) return false;
a = horizontal_write(a.first, a.second, v[3]);
if (a.first == -1) return false;
a = vertical_write(a.first, a.second, v[4]);
c = a;
if (a.first == -1) return false;
if (b != c) return false;
find_extreme();
return true;
}
void _print() {
int i, j;
for (i = 0; i <= MINX; i++) {
for (j = 0; j < MINY; j++) printf("%c", minn[i][j]);
printf("\n");
;
}
}
int main() {
int i, j, k, n;
vector<int> t, z;
for (i = 0; i < (6); i++) cin >> A[i];
for (i = 0; i < (6); i++) t.push_back(i);
for (i = 0; i < (100); i++)
for ((j) = (0); (j) < (100); (j)++) minn[i][j] = 'Z';
sort(A, A + 6);
do {
if (ispoxible(t)) {
update();
}
} while (next_permutation((t).begin(), (t).end()));
if (!F)
printf("Impossible\n");
else
_print();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 9;
const int N = 2e5 + 10;
int a[N];
vector<pair<int, int>> vp;
map<int, int> mc;
void add(int x) {
if (x == 0) return;
mc[x]++;
}
void del(int x) {
if (x == 0) return;
mc[x]--;
if (mc[x] == 0) mc.erase(x);
}
int main() {
int n;
cin >> n;
int k = 0;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
vp.push_back({x, i});
}
sort(vp.begin(), vp.end());
set<int> s;
s.insert(0);
s.insert(n + 1);
add(n);
pair<int, int> ans = {0, 0};
vector<int> v;
for (auto &p : vp) v.push_back(p.first + 1);
reverse(v.begin(), v.end());
for (auto &x : v) {
while (!vp.empty() && vp.back().first >= x) {
int px = vp.back().second;
vp.pop_back();
auto iter = s.lower_bound(px);
int r = *iter;
int l = *(--iter);
del(r - l - 1);
add(px - l - 1);
add(r - px - 1);
s.insert(px);
}
if (mc.size() == 1) {
ans = max(ans, make_pair(mc.begin()->second, -x));
}
}
printf("%d\n", -ans.second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt, tim;
int dep[500000 + 10];
int to[500000 + 10], nxt[500000 + 10], w[500000 + 10], head[500000 + 10];
int low[500000 + 10], dfn[500000 + 10], id[500000 + 10], ans[500000 + 10];
int size[500000 + 10], hson[500000 + 10], dis[500000 + 10], f[(1 << 22) + 10];
void add(int u, int v, int w1) {
to[++cnt] = v;
nxt[cnt] = head[u];
w[cnt] = w1;
head[u] = cnt;
}
void dfs1(int x, int ff) {
size[x] = 1;
dfn[x] = ++tim;
id[tim] = x;
for (int i = head[x]; i; i = nxt[i]) {
int tox = to[i];
if (tox == ff) continue;
dep[tox] = dep[x] + 1;
dis[tox] = dis[x] ^ w[i];
dfs1(tox, x);
size[x] += size[tox];
if (size[hson[x]] < size[tox]) hson[x] = tox;
}
low[x] = tim;
}
void dfs2(int x, int ff, int op) {
for (int i = head[x]; i; i = nxt[i]) {
int tox = to[i];
if (tox == ff || tox == hson[x]) continue;
dfs2(tox, x, 0);
ans[x] = max(ans[x], ans[tox]);
}
if (hson[x]) {
dfs2(hson[x], x, 1);
ans[x] = max(ans[x], ans[hson[x]]);
}
if (f[dis[x]]) ans[x] = max(ans[x], f[dis[x]] - dep[x]);
for (int i = 0; i < 22; i++)
if (f[dis[x] ^ (1 << i)])
ans[x] = max(ans[x], f[dis[x] ^ (1 << i)] - dep[x]);
f[dis[x]] = max(f[dis[x]], dep[x]);
for (int e = head[x]; e; e = nxt[e]) {
int tox = to[e];
if (tox == ff || tox == hson[x]) continue;
for (int i = dfn[tox]; i <= low[tox]; i++) {
if (f[dis[id[i]]])
ans[x] = max(ans[x], f[dis[id[i]]] + dep[id[i]] - 2 * dep[x]);
for (int j = 0; j < 22; j++)
if (f[dis[id[i]] ^ (1 << j)])
ans[x] =
max(ans[x], f[dis[id[i]] ^ (1 << j)] + dep[id[i]] - 2 * dep[x]);
}
for (int i = dfn[tox]; i <= low[tox]; i++)
f[dis[id[i]]] = max(f[dis[id[i]]], dep[id[i]]);
}
if (!op)
for (int i = dfn[x]; i <= low[x]; i++) f[dis[id[i]]] = 0;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int ff;
char s[4];
scanf("%d%s", &ff, s + 1);
add(ff, i, 1 << (s[1] - 'a'));
}
dfs1(1, 0);
dfs2(1, 0, 0);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
pair<pair<int, int>, pair<int, int> > t[100010];
pair<int, int> t1[10010];
double p[10010], p1[110];
int main() {
for (int i = 0; i < (10010); ++i) p[i] = 1;
for (int i = 0; i < (110); ++i) p1[i] = 1;
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < (n); ++i)
scanf("%d%d%d%d", &t[i].first.first, &t[i].first.second, &t[i].second.first,
&t[i].second.second);
for (int i = 0; i < (m); ++i) scanf("%d%d", &t1[i].first, &t1[i].second);
sort(t, t + n);
sort(t1, t1 + m);
for (int i = 0; i < (n); ++i) {
int beg = t[i].first.first - t[i].first.second;
int posb = lower_bound(t1, t1 + m, make_pair(beg, 0)) - t1;
int pose = lower_bound(t1, t1 + m, make_pair(t[i].first.first, 0)) - t1 - 1;
if (posb <= pose) {
double pr = (100 - t[i].second.first) / 100.0;
if (pose - posb + 1 <= 3 * 110) {
while (posb <= pose) {
p[posb] *= pr;
posb++;
}
continue;
}
while (posb % 110) {
p[posb] *= pr;
posb++;
}
while (pose % 110 != 110 - 1) {
p[pose] *= pr;
pose--;
}
posb /= 110;
pose /= 110;
for (int j = (posb); j <= (pose); ++j) p1[j] *= pr;
}
}
for (int i = (n)-1; i >= (0); --i) {
int end = t[i].first.first + t[i].first.second;
int posb = lower_bound(t1, t1 + m, make_pair(t[i].first.first + 1, 0)) - t1;
int pose = lower_bound(t1, t1 + m, make_pair(end + 1, 0)) - t1 - 1;
if (posb <= pose) {
double pr = (100 - t[i].second.second) / 100.0;
if (pose - posb + 1 <= 3 * 110) {
while (posb <= pose) {
p[posb] *= pr;
posb++;
}
continue;
}
while (posb % 110) {
p[posb] *= pr;
posb++;
}
while (pose % 110 != 110 - 1) {
p[pose] *= pr;
pose--;
}
posb /= 110;
pose /= 110;
for (int j = (posb); j <= (pose); ++j) p1[j] *= pr;
}
}
double res = 0;
for (int i = 0; i < (m); ++i) res += t1[i].second * p[i] * p1[i / 110];
printf("%.10lf\n", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int C[1001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, d;
cin >> n >> m >> d;
int s = 0;
for (int i = 0; i < m; ++i) {
cin >> C[i];
s += C[i];
}
int l = n - s + m;
if ((l) / (m + 1) >= d) return cout << "NO\n", 0;
cout << "YES\n";
for (int i = 0; i < m; ++i) {
for (int j = 0, r = (n - s) / (m - i + 1); j < r; ++j, --n) cout << "0 ";
for (int j = 0; j < C[i]; ++j, --s, --n) cout << i + 1 << ' ';
}
for (int j = 0, r = (n - s); j < r; ++j, --n) cout << "0 ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, w, h, g[maxn], p[maxn], t[maxn];
pair<int, int> ans[maxn];
vector<int> xv, yv, res, v[2 * maxn];
bool cmp(const int u, int v) {
if (g[u] != g[v])
return g[u] == 2;
else
return g[u] == 2 ? p[u] > p[v] : p[u] < p[v];
}
int main() {
scanf("%d%d%d", &n, &w, &h);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &g[i], &p[i], &t[i]);
v[p[i] - t[i] + maxn].push_back(i);
}
for (int i = 0; i < 2 * maxn; i++) {
if (v[i].size()) {
for (int j = 0; j < v[i].size(); j++) {
int cur = v[i][j];
res.push_back(cur);
if (g[cur] == 1)
xv.push_back(p[cur]);
else
yv.push_back(p[cur]);
}
sort(xv.begin(), xv.end());
sort(yv.begin(), yv.end());
sort(res.begin(), res.end(), cmp);
for (int j = 0; j < xv.size(); j++) ans[res[j]] = make_pair(xv[j], h);
for (int j = 0; j < yv.size(); j++)
ans[res[j + xv.size()]] = make_pair(w, yv[yv.size() - j - 1]);
xv.clear();
yv.clear();
res.clear();
}
}
for (int i = 1; i <= n; i++) printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const int M = 1e6 + 10;
const int inf = 0x3f3f3f3f;
int n, k;
vector<int> G[N];
int a[N], c[N], sz[N], ans[N];
int cnt[N << 2];
void dfs1(int u) {
sz[u] = 1;
for (auto &v : G[u]) {
dfs1(v);
sz[u] += sz[v];
}
}
void build(int rt, int l, int r) {
if (l == r) {
cnt[rt] = 1;
return;
}
int mid = (l + r) >> 1;
build((rt << 1), l, mid);
build((rt << 1 | 1), mid + 1, r);
cnt[rt] = cnt[(rt << 1)] + cnt[(rt << 1 | 1)];
}
void update(int rt, int l, int r, int pos, int v) {
if (l == r) {
cnt[rt] += v;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
update((rt << 1), l, mid, pos, v);
else
update((rt << 1 | 1), mid + 1, r, pos, v);
cnt[rt] = cnt[(rt << 1)] + cnt[(rt << 1 | 1)];
}
int k_th(int rt, int l, int r, int k) {
if (l == r) {
return l;
}
int mid = (l + r) >> 1;
if (cnt[(rt << 1)] >= k)
return k_th((rt << 1), l, mid, k);
else
return k_th((rt << 1 | 1), mid + 1, r, k - cnt[(rt << 1)]);
}
void dfs2(int u) {
if (a[u] >= sz[u]) {
puts("NO");
exit(0);
}
ans[u] = k_th(1, 1, n, a[u] + 1);
update(1, 1, n, ans[u], -1);
for (auto &v : G[u]) dfs2(v);
}
int main() {
scanf("%d", &n);
int root, p;
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &p, &a[i]);
if (!p)
root = i;
else
G[p].push_back(i);
}
build(1, 1, n);
dfs1(root);
dfs2(root);
puts("YES");
for (int i = 1; i <= n; ++i) {
printf("%d ", ans[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100055, dig_max = 30;
struct ST {
ST *ch[26];
int val;
ST() {
for (int i = 0; i < (26); ++i) ch[i] = 0;
val = 0;
}
ST(ST *b) {
for (int i = 0; i < (26); ++i) ch[i] = b->ch[i];
val = b->val;
}
void insert(char *s, int pri_val) {
int len = strlen(s);
ST *p = this;
for (int i = 0; i < (len); ++i) {
int c = s[i] - 'a';
if (p->ch[c] != NULL)
p->ch[c] = new ST(p->ch[c]);
else
p->ch[c] = new ST;
p = p->ch[c];
}
p->val = pri_val;
}
int query(char *s) {
int len = strlen(s);
ST *p = this;
for (int i = 0; i < (len); ++i) {
int c = s[i] - 'a';
if (p->ch[c] == NULL) return -1;
p = p->ch[c];
}
return p->val <= 0 ? -1 : p->val;
}
} st[maxn];
struct NT {
NT *son[2];
int val;
NT() {
son[0] = son[1] = NULL;
val = 0;
}
NT(NT *b) {
son[0] = b->son[0], son[1] = b->son[1];
val = b->val;
}
void insert(int x, int del) {
NT *p = this;
for (int i = dig_max; i > (-1); --i) {
int st = (x >> i) & 1;
if (p->son[st] != NULL)
p->son[st] = new NT(p->son[st]);
else
p->son[st] = new NT;
p = p->son[st];
p->val += del;
}
}
int get_rk(int x) {
int ans = 0;
NT *p = this;
for (int i = dig_max; i > (-1); --i) {
int st = (x >> i) & 1;
if (st == 1 && p->son[0] != NULL) ans += p->son[0]->val;
p = p->son[st];
}
return ans;
}
} nt[maxn];
char s[maxn], op[20];
int main() {
int n;
scanf("%d", &n);
nt[0] = new NT;
st[0] = new ST;
for (int i = 1; i < (n + 1); ++i) {
scanf("%s", op, s);
if (op[0] == 's') {
int x;
scanf("%s %d", s, &x);
st[i] = new ST(st[i - 1]);
nt[i] = new NT(nt[i - 1]);
int pre_v = st[i].query(s);
if (pre_v != x) {
if (pre_v != -1) nt[i].insert(pre_v, -1);
nt[i].insert(x, 1);
st[i].insert(s, x);
}
} else if (op[0] == 'q') {
scanf("%s", s);
st[i] = new ST(st[i - 1]);
nt[i] = new NT(nt[i - 1]);
int pre_v = st[i].query(s);
if (pre_v != -1) pre_v = nt[i].get_rk(pre_v);
printf("%d\n", pre_v);
} else if (op[0] == 'r') {
scanf("%s", s);
st[i] = new ST(st[i - 1]);
nt[i] = new NT(nt[i - 1]);
int pre_v = st[i].query(s);
if (pre_v != -1) {
nt[i].insert(pre_v, -1);
st[i].insert(s, 0);
}
} else {
int x;
scanf("%d", &x);
st[i] = new ST(st[i - 1 - x]);
nt[i] = new NT(nt[i - 1 - x]);
}
fflush(stdout);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589793238460;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
int d = (a - b) / 2;
d = abs(d);
vector<int> ans;
int i = d;
while (i <= a + b - d) {
ans.push_back(i);
if ((a + b) & 1)
i++;
else
i += 2;
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
long long a[t];
for (int i = 0; i < t; i++) {
cin >> a[i];
if (a[i] == 1 || a[i] == 2) {
cout << "0" << endl;
} else {
cout << (a[i] - 1) / 2 << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using i32 = int;
using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f64 = double;
using f80 = long double;
long long power(long long a, long long b, long long p) {
if (!b) return 1;
long long t = power(a, b / 2, p);
t = t * t % p;
if (b & 1) t = t * a % p;
return t;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long px, py;
long long d = exgcd(b, a % b, px, py);
x = py;
y = px - a / b * py;
return d;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <class T>
inline void freshmin(T &a, const T &b) {
if (a > b) a = b;
}
template <class T>
inline void freshmax(T &a, const T &b) {
if (a < b) a = b;
}
template <class T>
void print(const T &a) {
for (auto x : a) printf("%d ", x);
puts("");
}
const int MAXN = 1000010;
const int MAXK = 30;
const int INF = 1000000000;
const int B = 31;
const int MOD = 1000000007;
const double pi = 3.1415926535897932384626433;
int dx[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy[] = {-1, 0, 1, -1, 1, -1, 0, 1};
int days[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool leap(int y) { return y % 4 == 0 && y % 100 != 0 || y % 400 == 0; }
int n, l, k;
char s[MAXN];
char a[1111][1111];
void solve() {
scanf("%d%d%d%s", &n, &l, &k, s + 1);
sort(s + 1, s + n * l + 1);
int L = 1, R = n * l;
int start = 1;
for (int i = 1; i <= l; ++i) {
for (int x = start; x <= k; ++x) a[x][i] = s[L++];
int pos = k;
while (pos >= start && a[pos][i] == a[k][i]) pos--;
for (int x = pos; x >= start; --x)
for (int j = l; j > i; --j) a[x][j] = s[R--];
start = pos + 1;
}
for (int i = 1; i <= l; ++i)
for (int x = k + 1; x <= n; ++x) a[x][i] = s[L++];
for (int i = 1; i <= n; ++i) puts(a[i] + 1);
}
int main() {
int T;
T = 1;
while (T--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int n;
int a[5];
int main() {
scanf("%d", &n);
int sum = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
a[x]++;
sum += x;
}
if (sum < 3 || sum == 5) {
printf("-1\n");
return 0;
}
int ans = 0;
int temp;
while (a[1]) {
temp = min(a[1], a[2]);
a[1] -= temp;
a[2] -= temp;
a[3] += temp;
ans += temp;
a[3] += a[1] / 3;
ans += a[1] / 3 * 2;
a[1] %= 3;
if (a[1] > a[3]) {
if (a[1] == 1) {
a[4] -= 2;
a[3] += 3;
a[1] = 0;
ans += 2;
} else if (a[1] == 2) {
a[4]--;
a[1] = 0;
a[3] += 2;
ans += 2;
}
}
temp = min(a[1], a[3]);
a[1] -= temp;
a[3] -= temp;
a[4] += temp;
ans += temp;
}
while (a[2]) {
a[3] += a[2] / 3 * 2;
ans += a[2] / 3 * 2;
a[2] %= 3;
if (a[2] == 2) {
ans += 2;
a[4]++;
a[2] = 0;
}
temp = min(a[2], a[4]);
a[2] -= temp;
a[4] -= temp;
a[3] += temp * 2;
ans += temp;
temp = min(a[2], a[3] / 2);
a[2] -= temp;
a[3] -= temp * 2;
a[4] += temp * 2;
ans += temp * 2;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int a[100005], ind[100005], s[100005][10], dp[100005][130],
hell = (-pow(10, 15));
bool comp(long long int i, long long int j) { return a[i] > a[j]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, p, k;
cin >> n >> p >> k;
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
ind[i] = i;
}
for (long long int i = 1; i <= n; i++)
for (long long int j = 0; j < p; j++) cin >> s[i][j];
sort(ind + 1, ind + n + 1, comp);
for (long long int i = 0; i < 100005; i++)
for (long long int j = 0; j < 130; j++) dp[i][j] = hell;
dp[0][0] = 0;
for (long long int i = 1; i <= n; i++)
for (long long int j = 0; j < pow(2, p); j++) {
long long int x = j, cnt = 0;
if (i - (__builtin_popcount(j)) <= k)
dp[i][j] = dp[i - 1][j] + a[ind[i]];
else
dp[i][j] = dp[i - 1][j];
while (x > 0) {
if (x & 1)
dp[i][j] = max(dp[i][j], dp[i - 1][j ^ (1 << cnt)] + s[ind[i]][cnt]);
x >>= 1;
cnt++;
}
}
cout << dp[n][(1 << p) - 1];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int arr[1001][1001];
int main() {
long long int n, sum = 0, count = 0, x, y, z, i;
scanf("%lld", &n);
while (n--) {
cin >> x >> y;
arr[x][y] = 1;
}
for (i = 1; i <= 1000; i++) {
count = 0;
y = 1;
z = i;
while (1) {
if (y > 1000 || z > 1000) break;
x = arr[y][z];
count += x;
y++;
z++;
}
sum += (((count) * (count - 1)) / 2);
}
for (i = 1; i <= 1000; i++) {
count = 0;
y = 1;
z = i;
while (1) {
if (y > 1000 || z < 1) break;
x = arr[y][z];
count += x;
y++;
z--;
}
sum += (((count) * (count - 1)) / 2);
}
for (i = 2; i <= 1000; i++) {
count = 0;
y = i;
z = 1000;
while (1) {
if (y > 1000 || z < 1) break;
x = arr[y][z];
count += x;
y++;
z--;
}
sum += (((count) * (count - 1)) / 2);
}
for (i = 2; i <= 1000; i++) {
count = 0;
y = i;
z = 1;
while (1) {
if (y > 1000 || z > 1000) break;
x = arr[y][z];
count += x;
y++;
z++;
}
sum += (((count) * (count - 1)) / 2);
}
printf("%lld\n", sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
int n, m, i, j, k, l, r, u, v, w;
const int maxn = 18;
const int maxm = 110;
const int maxmask = (1 << maxn) - 1;
const int infi = 1e9 + 7 + 1e7;
const long long infl = 1e18;
const double eps = 1e-6;
const int mod = 1000;
const int alp = 26;
vector<pair<long long, long long> > ar;
int main() {
cin >> n;
long long d = 0, l = 0, a, b = -1;
for (i = 0; i < n; ++i) {
scanf("%I64d", &a);
if (a == -1) {
++l;
} else {
if (l) {
ar.push_back(make_pair(-1, l));
l = 0;
}
ar.push_back(make_pair(a, 0));
}
}
if (l) {
ar.push_back(make_pair(-1, l));
l = 0;
}
l = 1;
pair<long long, long long> c = make_pair(0, 0);
if (ar.size() <= 2) {
cout << 1;
return 0;
}
if (ar.size() == 3 && ar[0].first == -1 && ar[2].first == -1) {
cout << 1;
return 0;
}
if (ar[0].first == -1) {
c.first = ar[0].second;
a = ar[1].first;
i = 2;
} else {
i = 1;
a = ar[0].first;
}
int res = 0;
for (i = i; i < ar.size(); ++i) {
if (ar[i].first != -1) {
if (l == 0) {
a = ar[i].first;
++l;
continue;
}
if (l == 1) {
long long d;
d = (ar[i].first - a) / (c.second + 1);
if (d * (c.second + 1) != ar[i].first - a) {
++res;
c.first = c.second = 0;
a = ar[i].first;
l = 1;
continue;
}
if (d > 0 && c.first) {
d *= c.first;
d = a - d;
if (d <= 0) {
++res;
c.first = 0;
l = 1;
a = ar[i].first;
c.first = c.second = 0;
continue;
}
d = (ar[i].first - a) / (c.second + 1);
}
b = d;
a = ar[i].first;
c.second = 0;
++l;
} else {
long long d;
d = b * (c.second + 1);
if (a + d != ar[i].first) {
++res;
c.second = c.first = 0;
l = 1;
a = ar[i].first;
continue;
}
c.second = 0;
a = ar[i].first;
++l;
}
} else {
if (l == 1) {
c.second += ar[i].second;
} else {
if (b >= 0) {
c.second += ar[i].second;
} else {
long long d;
d = b * (c.second + ar[i].second);
d += a;
if (d > 0) {
c.second += ar[i].second;
} else {
c.second += ar[i].second;
++res;
j = 0;
while (d <= 0) {
++j;
d -= b;
}
c.first = j;
c.second = 0;
l = 0;
}
}
}
}
}
if (c.first || l || c.second || res == 0) {
++res;
}
cout << res;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, k;
cin >> n >> k;
vector<long long int> arr(n);
for (long long int i = 0; i < n; i++) cin >> arr[i];
set<long long int> st;
for (long long int i = 0; i < n; i++) st.emplace(arr[i]);
if (k == 1) {
if (st.size() > 1) {
cout << -1 << "\n";
return;
} else {
cout << 1 << "\n";
return;
}
};
if ((long long int)(st.size()) <= k) {
cout << 1 << "\n";
return;
}
long long int minn = 0;
set<long long int> un;
for (long long int i = 0; i < n;) {
un.emplace(arr[i]);
if ((long long int)(un.size()) == k) {
while (i < n) {
if (un.find(arr[i]) != un.end()) {
i++;
} else {
break;
}
}
un.clear();
un.emplace(0);
minn++;
} else {
i++;
}
}
if (un.size() > 1) minn++;
cout << max(1LL, minn) << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> a(n);
bool flag = true;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 1; i < n; ++i) {
if (a[i] % 2 != a[i - 1] % 2) flag = false;
}
cout << (flag ? "YES\n" : "NO\n");
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tt;
cin >> tt;
while (tt--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 2;
long long a[N], b[N];
priority_queue<pair<pair<long long, long long>, long long> > concac;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, i, j, k, l, sum, lef = -4e18, rig = 1e9, mid;
cin >> n >> sum;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
while (lef < rig) {
mid = (lef + rig) / 2;
if (lef + rig < 0) {
mid--;
}
l = 0;
for (i = 1; i <= n; i++) {
if (mid >= a[i]) {
b[i] = 0;
continue;
}
double cac = 1.0 / 2 + sqrt((double)(a[i] - mid - 1.0 / 4) / 3);
k = cac;
b[i] = min(a[i], k);
l += b[i];
}
if (l < sum) {
rig = mid;
} else {
lef = mid + 1;
}
}
mid = rig;
l = 0;
for (i = 1; i <= n; i++) {
if (mid >= a[i]) {
b[i] = 0;
continue;
}
double cac = 1.0 / 2 + sqrt((double)(a[i] - mid - 1.0 / 4) / 3);
k = floor(cac);
b[i] = min(a[i], k);
l += b[i];
}
for (i = 1; i <= n; i++) {
if (b[i] + 1 <= a[i]) {
concac.push(
{{a[i] - 3 * (b[i] + 1) * (b[i] + 1) + 3 * (b[i] + 1) - 1, a[i]}, i});
}
}
if (sum - l > n) {
cout << l << ' ' << sum << ' ' << mid << " CAC " << endl;
return 0;
}
while (l < sum) {
j = concac.top().first.first;
k = concac.top().first.second;
i = concac.top().second;
concac.pop();
b[i]++;
if (b[i] + 1 <= a[i]) {
concac.push(
{{a[i] - 3 * (b[i] + 1) * (b[i] + 1) + 3 * (b[i] + 1) - 1, a[i]}, i});
}
l++;
}
for (i = 1; i <= n; i++) {
cout << b[i] << ' ';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int a = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) {
a = (a << 3) + (a << 1) + (c ^ '0');
c = getchar();
}
return f ? -a : a;
}
const int MAXN = 1e5 + 10;
struct Edge {
int end, upEd;
} Ed[MAXN << 1];
bool vis[MAXN];
int head[MAXN], d[MAXN], in[MAXN], dep[MAXN], N, M, cntEd;
vector<int> v[3];
inline void addEd(int a, int b) {
Ed[++cntEd].end = b;
Ed[cntEd].upEd = head[a];
head[a] = cntEd;
++in[b];
}
bool dfs1(int x, int p) {
vis[x] = 1;
for (int i = head[x]; i; i = Ed[i].upEd)
if (!vis[Ed[i].end]) {
if (dfs1(Ed[i].end, x)) return 1;
} else if (Ed[i].end != p)
return 1;
return 0;
}
void mark(int x) {
vis[x] = 0;
if (!d[x]) d[x] = 1;
for (int i = head[x]; i; i = Ed[i].upEd)
if (vis[Ed[i].end]) mark(Ed[i].end);
}
bool dfs2(int x, int p) {
if (p && in[x] == 3) {
d[x] = 2;
return 1;
}
for (int i = head[x]; i; i = Ed[i].upEd)
if (Ed[i].end != p)
if (dfs2(Ed[i].end, x)) {
d[x] = 2;
return 1;
}
return 0;
}
void dfs3(int x, int p, vector<int>& v) {
v.push_back(x);
for (int i = head[x]; i; i = Ed[i].upEd)
if (Ed[i].end != p) dfs3(Ed[i].end, x, v);
}
int main() {
for (int T = read(); T; --T) {
N = read();
M = read();
memset(head, 0, sizeof(int) * (N + 1));
memset(vis, 0, sizeof(bool) * (N + 1));
memset(d, 0, sizeof(int) * (N + 1));
memset(in, 0, sizeof(int) * (N + 1));
cntEd = 0;
for (int i = 1; i <= M; ++i) {
int a = read(), b = read();
addEd(a, b);
addEd(b, a);
}
bool f = 0;
for (int i = 1; !f && i <= N; ++i)
if (!vis[i])
if (f = dfs1(i, 0)) mark(i);
for (int i = 1; !f && i <= N; ++i)
if (in[i] >= 4) {
d[i] = 2;
mark(i);
f = 1;
}
for (int i = 1; !f && i <= N; ++i)
if (in[i] == 3)
if (f = dfs2(i, 0)) {
memset(vis, 1, sizeof(vis));
mark(i);
}
for (int i = 1; !f && i <= N; ++i)
if (in[i] == 3) {
int cnt = 0;
v[0].clear();
v[1].clear();
v[2].clear();
for (int j = head[i]; j; j = Ed[j].upEd) dfs3(Ed[j].end, i, v[cnt++]);
if (v[0].size() > v[1].size()) swap(v[0], v[1]);
if (v[0].size() > v[2].size()) swap(v[0], v[2]);
if (v[1].size() > v[2].size()) swap(v[1], v[2]);
if (v[1].size() == 1 ||
v[0].size() == 1 && v[1].size() == 2 && v[2].size() < 5)
continue;
f = 1;
if (v[2].size() >= 5) {
d[i] = 6;
d[v[0][0]] = 3;
d[v[1][0]] = 4;
d[v[1][1]] = 2;
for (int j = 0; j < 5; ++j) d[v[2][j]] = 5 - j;
} else {
d[i] = (v[0].size() + 1) * (v[1].size() + 1) * (v[2].size() + 1);
for (int j = 0; j < 3; ++j)
for (int k = 0; k < v[j].size(); ++k)
d[v[j][k]] = (d[i]) / (v[j].size() + 1) * (v[j].size() - k);
}
}
if (f) {
puts("YES");
for (int i = 1; i <= N; ++i) printf("%d ", d[i]);
putchar('\n');
continue;
} else
puts("NO");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 1;
int n, ord[maxn];
int lnk[maxn], dep[maxn], fa[maxn], sz[maxn];
int seq[maxn], idx[maxn], son[maxn], top[maxn];
struct Edge {
int nxt, v;
} e[maxn << 1 | 1];
void tree_build(int rt) {
int L = 1, R = 0;
dep[rt] = fa[rt] = 0;
ord[++R] = rt;
while (L <= R) {
int u = ord[L++];
for (int it = lnk[u]; it != -1; it = e[it].nxt) {
int v = e[it].v;
if (v == fa[u]) continue;
dep[v] = dep[u] + 1;
fa[v] = u;
ord[++R] = v;
}
}
memset(sz + 1, 0, n * sizeof(int));
memset(son + 1, 0, n * sizeof(int));
++sz[rt];
for (int i = n; i > 1; --i) {
int u = ord[i], p = fa[u];
sz[p] += (++sz[u]);
if (sz[son[p]] < sz[u]) son[p] = u;
}
top[rt] = rt, idx[rt] = 1;
for (int i = 1; i <= n; ++i) {
int u = ord[i], id = idx[u];
seq[id++] = u;
if (sz[u] == 1) continue;
top[son[u]] = top[u];
idx[son[u]] = id;
id += sz[son[u]];
for (int it = lnk[u]; it != -1; it = e[it].nxt) {
int v = e[it].v;
if (v == fa[u] || v == son[u]) continue;
top[v] = v;
idx[v] = id;
id += sz[v];
}
}
}
int f[maxn];
struct Segment {
int sum, lft, rht;
} seg[maxn << 1 | 1];
inline int seg_idx(int L, int R) { return (L + R) | (L < R); }
void seg_upd(int L, int R, int x) {
int rt = seg_idx(L, R);
if (L == R) {
seg[rt] = (Segment){f[1], 1, 1};
return;
}
int M = (L + R) >> 1, lch = seg_idx(L, M), rch = seg_idx(M + 1, R);
if (x <= M)
seg_upd(L, M, x);
else
seg_upd(M + 1, R, x);
seg[rt].sum = seg[lch].sum - f[seg[lch].rht] + seg[rch].sum -
f[seg[rch].lft] + f[seg[lch].rht + seg[rch].lft];
seg[rt].lft = seg[lch].lft + (seg[lch].lft == M - L + 1 ? seg[rch].lft : 0);
seg[rt].rht = seg[rch].rht + (seg[rch].rht == R - M ? seg[lch].rht : 0);
}
Segment seg_que(int L, int R, int l, int r) {
if (l <= L && R <= r) return seg[seg_idx(L, R)];
int M = (L + R) >> 1;
if (r <= M) return seg_que(L, M, l, r);
if (l > M) return seg_que(M + 1, R, l, r);
Segment ret = seg_que(L, M, l, r), tmp = seg_que(M + 1, R, l, r);
ret.sum = ret.sum - f[ret.rht] + tmp.sum - f[tmp.lft] + f[ret.rht + tmp.lft];
ret.lft = ret.lft + (ret.lft == M - max(l, L) + 1 ? tmp.lft : 0);
ret.rht = tmp.rht + (tmp.rht == min(r, R) - M ? ret.rht : 0);
return ret;
}
int m, etot, w[maxn], p[2][maxn];
pair<int, int> eve[maxn << 1 | 1];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; ++i) scanf("%d", f + i);
memset(lnk + 1, -1, n * sizeof(int));
for (int i = 0; i < n - 1; ++i) {
int u, v;
scanf("%d%d%d", &u, &v, w + i);
e[i << 1] = (Edge){lnk[u], v};
lnk[u] = i << 1;
e[i << 1 | 1] = (Edge){lnk[v], u};
lnk[v] = i << 1 | 1;
}
tree_build(1);
for (int i = 0; i < n - 1; ++i) {
int u = e[i << 1 | 1].v, v = e[i << 1].v;
if (u == fa[v]) swap(u, v);
eve[etot++] = make_pair(w[i], u);
}
for (int i = 1; i <= m; ++i) {
int w;
scanf("%d%d%d", p[0] + i, p[1] + i, &w);
eve[etot++] = make_pair(w, -i);
}
sort(eve, eve + etot);
for (int i = etot - 1; i >= 0; --i)
if (eve[i].second > 0) {
seg_upd(1, n, idx[eve[i].second]);
} else {
int u = p[0][-eve[i].second], v = p[1][-eve[i].second];
Segment su = {}, sv = {};
for (int pu = top[u], pv = top[v]; pu != pv; u = fa[pu], pu = top[u]) {
if (dep[pu] < dep[pv]) {
swap(u, v);
swap(pu, pv);
swap(su, sv);
}
Segment tp = seg_que(1, n, idx[pu], idx[u]);
su.sum = tp.sum - f[tp.rht] + su.sum - f[su.lft] + f[tp.rht + su.lft];
su.lft = tp.lft + (tp.lft == idx[u] - idx[pu] + 1 ? su.lft : 0);
}
if (u != v) {
if (dep[u] < dep[v]) {
swap(u, v);
swap(su, sv);
}
Segment tp = seg_que(1, n, idx[v] + 1, idx[u]);
su.sum = tp.sum - f[tp.rht] + su.sum - f[su.lft] + f[tp.rht + su.lft];
su.lft = tp.lft + (tp.lft == idx[u] - idx[v] ? su.lft : 0);
}
p[0][-eve[i].second] =
su.sum - f[su.lft] + sv.sum - f[sv.lft] + f[su.lft + sv.lft];
}
for (int i = 1; i <= m; ++i) printf("%d\n", p[0][i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1000000];
vector<int> tree[1000000];
vector<int> tmp;
int rs[1000000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
long long s = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
s += a[i];
}
if (2 * n - 2 > s) {
cout << "NO";
return 0;
}
int re = 0;
int last = 0, res = 0, t = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] > 1) {
rs[re++] = i;
tree[last].push_back(i);
--a[i];
--a[last];
last = i;
} else if (a[i] == 1) {
tmp.push_back(i);
a[i] = 0;
t++;
}
}
if (!tmp.empty()) {
int x = tmp.back();
tmp.pop_back();
tree[rs[0]].push_back(x);
}
cout << "YES " << (n - t) - 1 + min(t, 2) << "\n" << n - 1 << "\n";
while (!tmp.empty()) {
int x = tmp.back();
tmp.pop_back();
cout << x << " ";
for (int i = n; i > 0; --i)
if (a[i] != 0) {
cout << i << "\n";
a[i]--;
break;
}
}
for (int i = 0; i < re; ++i) {
for (int x : tree[rs[i]]) {
cout << rs[i] << " " << x << "\n";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
template <typename T>
void no(T s) {
cout << s;
exit(0);
}
void no() {
cout << "NO";
exit(0);
}
constexpr int maxn = 0;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed << setprecision(20);
LL a, b, n, ans = 0;
cin >> a >> b;
n = a + b;
for (LL i = 1, L, R;; i = n / (L - 1)) {
L = n / (i + 1) + 1, R = n / i;
LL xR = a / i, xL = (a + i) / (i + 1);
LL yR = b / i, yL = (b + i) / (i + 1);
LL cL = max(xL + yL, L), cR = min(xR + yR, R);
if (xL <= xR and yL <= yR) ans += max(0LL, cR - cL + 1);
if (L == 1) break;
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
bool al = true;
cin >> n >> m;
for (int i = 0; i < n; i++) {
if (i % 2 != 0) {
if (al) {
for (int k = 0; k < m - 1; k++) {
cout << ".";
}
cout << "#" << endl;
al = false;
} else {
al = true;
cout << "#";
for (int k = 0; k < m - 1; k++) {
cout << ".";
}
cout << endl;
}
} else {
for (int j = 0; j < m; j++) {
cout << "#";
}
cout << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define int long long
#define double long double
#define f first
#define s second
using namespace std;
//ios_base::sync_with_stdio(false);
//cin.tie(0);
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
vector <int> p;
vector <bool> b(10001, 1);
for(int i = 2; i < 10001; ++i){
if(b[i])p.push_back(i*i);
else{
for(int j = 2*i; j < 10001; j+=i)b[j] =false;
}
}
int t;
cin >> t;
while(t--){
int n, k228;
cin >> n >> k228;
vector <int> a(n);
for(int i = 0; i< n; ++i)cin >> a[i];
int ans = 0;
set <int> s;
for(int i = 0; i < n; ++i){
int x = a[i];
for(auto pr:p){
if(x<pr)break;
while(x%pr==0)x/=pr;
}
if(s.find(x)==s.end()){
s.insert(x);
}
else{
ans++;
s.clear();
s.insert(x);
}
}
cout << ans+1 << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) return power(a * a % 1000000007, b / 2);
return a * power(a, b - 1) % 1000000007;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
map<char, char> w;
int main(int argc, char** argv) {
string a, b;
cin >> a >> b;
vector<pair<char, char> > ans;
for (int i = 0; i < a.size(); i++) {
if ((w[a[i]] != 0 || w[b[i]] != 0) &&
(w[a[i]] != b[i] || w[b[i]] != a[i])) {
cout << -1;
return 0;
}
if (w[a[i]] == b[i] && w[b[i]] == a[i])
continue;
else {
w[a[i]] = b[i];
w[b[i]] = a[i];
if (a[i] != b[i]) ans.push_back({b[i], a[i]});
}
}
cout << ans.size() << endl;
for (auto i : ans) cout << i.first << " " << i.second << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
long long aR = 0, aL = 0, bR = 0, bL = 0;
while (t--) {
long long t, x, y;
cin >> t >> x >> y;
if (t == 1) {
aR += x;
aL += y;
} else {
bR += x;
bL += y;
}
}
if (aR >= aL)
cout << "LIVE\n";
else
cout << "DEAD\n";
if (bR >= bL)
cout << "LIVE\n";
else
cout << "DEAD\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 gen(time(NULL));
const long double eps = 1e-9;
const int inf = 1e9;
const int mod = 1e9 + 7;
const long long infinity = 2 * 1e18;
long long x, y, l, r;
int main() {
cin >> x >> y >> l >> r;
set<long long> to;
int pow_x = 0;
long long mul = 1;
for (; mul <= 2e18 / x; mul *= x, pow_x++)
;
int pow_y = 0;
mul = 1;
for (; mul <= 2e18 / y; mul *= y, pow_y++)
;
mul = 1;
for (int i = 0; i < pow_x + 1; i++) {
long long mul_y = 1;
for (int j = 0; j < pow_y + 1; j++) {
if (l <= mul + mul_y && mul + mul_y <= r) to.insert(mul + mul_y);
mul_y *= y;
}
mul *= x;
}
to.insert(l - 1);
to.insert(r + 1);
long long ans = 0;
for (auto v : to) {
auto it = to.upper_bound(v);
if (it == to.end()) continue;
ans = max(ans, *it - v - 1);
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bitset<100005> B[27], ans, ones;
char s[100005], s2[100005];
int main(int nargs, char **args) {
scanf("%s", s + 1);
int len, q, t, l, r, len2;
len = strlen(s + 1);
for (int i = 1; i <= len; i++) {
B[s[i] - 'a'][i] = 1;
}
ones = ~ones;
scanf("%d", &q);
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%s", &l, s2);
B[s[l] - 'a'][l] = 0;
s[l] = s2[0];
B[s2[0] - 'a'][l] = 1;
} else {
scanf("%d%d%s", &l, &r, s2);
len2 = strlen(s2);
if (r - l + 1 < len2) {
puts("0");
continue;
}
ans = ones;
for (int i = 0; i < len2; i++) {
ans &= (B[s2[i] - 'a'] >> i);
}
ans >>= l;
cout << ans.count() - (ans >> (r - l - len2 + 2)).count() << endl;
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int t, nxt;
} e[200010];
int n, u, v, be[100010], cnt, vis[100010], deg[100010], pd[400010], pt[400010],
sz, T;
void add(const int& x, const int& y) {
e[++cnt] = (edge){y, be[x]}, be[x] = cnt;
}
void dfs(const int& x, const int& tim) {
int nw = tim;
vis[x] = 1, pd[++sz] = x, pt[sz] = nw;
for (int i = be[x], rm = deg[x] - (!!tim); i; i = e[i].nxt)
if (!vis[e[i].t]) {
if (nw == T) nw = tim - 1 - rm, pd[++sz] = x, pt[sz] = nw;
dfs(e[i].t, ++nw), pd[++sz] = x, pt[sz] = nw;
--rm;
}
if (tim && nw != tim - 1) pd[++sz] = x, pt[sz] = tim - 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i)
scanf("%d%d", &u, &v), add(u, v), add(v, u), ++deg[u], ++deg[v],
T = max(T, max(deg[u], deg[v]));
dfs(1, 0), printf("%d\n", sz);
for (int i = 1; i <= sz; ++i) printf("%d %d\n", pd[i], pt[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int rd() { return RAND_MAX == 32767 ? ((rand() << 15) ^ rand()) : rand(); }
const int maxn = 100010;
struct Point {
int x, y;
} p[maxn];
long long Cross(Point p0, Point p1, Point p2) {
return (long long)(p1.x - p0.x) * (p2.y - p0.y) -
(long long)(p1.y - p0.y) * (p2.x - p0.x);
}
int main() {
int n, m;
cin >> n;
for (int i = 0; i < n; i++) cin >> p[i].x >> p[i].y;
cin >> m;
for (int o = 0; o < m; o++) {
Point p0;
cin >> p0.x >> p0.y;
int inside = 1;
for (int i = 0; i < n; i++)
if (Cross(p[i], p[(i + 1) % n], p0) > 0) {
inside = 0;
break;
}
if (!inside) {
cout << 0 << endl;
continue;
}
int k = 0;
long long res = (long long)n * (n - 1) * (n - 2) / 6;
for (int i = 0, k = 0; i < n; i++) {
for (; (k + 1) % n != i && Cross(p[i], p[(k + 1) % n], p0) < 0;
k = (k + 1) % n)
;
if (i != k && (i + 1) % n != k) {
int N = k - i + 1;
if (N <= 0) N += n;
res -= (long long)(N - 1) * (N - 2) / 2;
}
if (k == i) k = (k + 1) % n;
}
cout << res << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
const int mod = 1e9 + 7;
int n, dp[N];
vector<int> adj[N];
bool odd, call;
void dfs(int x, int p) {
dp[x] = dp[p] + 1;
for (auto xx : adj[x])
if (xx != p) {
dp[xx] = dp[x] + 1;
dfs(xx, x);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
int xx = 0, lf = 0;
for (int i = 1; i <= n; i++) {
if (adj[i].size() == 1) {
lf++;
if (!call) {
dp[0] = -1;
call = 1;
dfs(i, 0);
}
}
for (auto x : adj[i])
if (adj[x].size() == 1) {
xx++;
break;
}
}
int mn = 1;
for (int i = 1; i <= n; i++)
if (adj[i].size() == 1 && dp[i] % 2) mn = 3;
cout << mn << " " << n - 1 - lf + xx << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int n, par[1001], vis[1001][2][2];
double dp[1001][2][2], ans = 0;
pair<long long int, pair<long long int, long long int>> cirs[1001];
std::vector<long long int> roots;
std::vector<long long int> adj[1007];
long long int dis2(pair<long long int, pair<long long int, long long int>> c1,
pair<long long int, pair<long long int, long long int>> c2) {
return abs(c1.second.first - c2.second.first) *
abs(c1.second.first - c2.second.first) +
abs(c1.second.second - c2.second.second) *
abs(c1.second.second - c2.second.second);
}
double area(pair<long long int, pair<long long int, long long int>> c) {
return 3.141592653589793238462643383279502884L * c.first * c.first;
}
void update(long long int i, long long int j) {
if (par[i] == -1)
par[i] = j;
else if (cirs[par[i]] > cirs[j])
par[i] = j;
}
bool inside(pair<long long int, pair<long long int, long long int>> c1,
pair<long long int, pair<long long int, long long int>> c2) {
double d = sqrt(dis2(c1, c2));
return (c2.first >= ((double)(c1.first + d)));
}
double dfs(long long int cur, long long int dep) {
double tr = 0, cr = 0;
if (par[cur] == -1 or dep)
tr = area(cirs[cur]);
else
tr = -area(cirs[cur]);
for (long long int v : adj[cur]) {
cr += dfs(v, (dep + 1) % 2);
}
return cr + tr;
}
int main() {
memset(par, -1, sizeof(par));
std::cin >> n;
for (long long int i = 0; i < n; i++) {
std::cin >> cirs[i].second.first >> cirs[i].second.second >> cirs[i].first;
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < n; j++) {
if (i == j) continue;
if (inside(cirs[i], cirs[j])) update(i, j);
}
}
for (long long int i = 0; i < n; i++) {
if (par[i] == -1)
roots.push_back(i);
else
adj[par[i]].push_back(i);
}
double res = 0;
for (long long int r : roots) res += dfs(r, 0);
std::cout << std::fixed << std::showpoint;
std::cout << std::setprecision(18);
std::cout << res << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, x, y, good, bad;
scanf("%d", &t);
while (t--) {
scanf("%d%d%d", &n, &x, &y);
bad = min(n, x + y - 1);
if (x + y <= n)
good = 1;
else
good = min(n, x + y - n + 1);
printf("%d %d\n", good, bad);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a[100100], i, z, cntOdd = 0, cntEven = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 0)
cntEven++;
else
cntOdd++;
}
if (cntOdd == 0) {
cout << 0;
return 0;
} else if (cntOdd <= cntEven) {
cout << cntOdd;
return 0;
} else if (cntOdd > cntEven) {
z = cntOdd - cntEven;
cout << cntEven + (z / 3);
return 0;
} else if (cntEven == 0) {
cout << cntOdd / 3;
return 0;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d, count = 0;
char dir = 'n', prev = 'n';
cin >> n;
cin >> a >> b;
for (int i = 0; i < n; i++) {
cin >> c >> d;
if (d > b)
dir = 'n';
else if (c > a)
dir = 'e';
else if (d < b)
dir = 's';
else if (c < a)
dir = 'w';
if (prev == 'e' && dir == 'n')
count++;
else if (prev == 'n' && dir == 'w')
count++;
else if (prev == 'w' && dir == 's')
count++;
else if (prev == 's' && dir == 'e')
count++;
prev = dir;
a = c;
b = d;
}
cout << count;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int s;
set<pair<int, int> > tree;
int i, j, m, n, k, l, o, p, x, y, q, tag;
set<int> car;
const int maxn = 1000001;
int place[maxn];
pair<int, int> gao(int l, int r) {
if (l == 1) return pair<int, int>(-r + 1, l);
if (r == n) return pair<int, int>(-(n - l), r);
return pair<int, int>(-((r + l) / 2 - l), (r + l) / 2);
}
int main() {
scanf("%d%d", &n, &q);
tree.insert(gao(1, n));
set<int>::iterator tt;
car.insert(-1);
car.insert(1 << 20);
for (int kk = 1; kk <= q; kk++) {
scanf("%d%d", &tag, &x);
if (tag == 1) {
s = tree.begin()->second;
place[x] = s;
tree.erase(tree.begin());
tt = car.upper_bound(s);
x = *(--tt);
y = *(++tt);
if (x == -1)
x = 1;
else
++x;
if (y == 1 << 20)
y = n;
else
--y;
car.insert(s);
if (s > 1) tree.insert(gao(x, s - 1));
if (s < n) tree.insert(gao(s + 1, y));
printf("%d\n", s);
} else {
s = place[x];
car.erase(s);
tt = car.upper_bound(s);
x = *(--tt);
y = *(++tt);
if (x == -1)
x = 1;
else
++x;
if (y == 1 << 20)
y = n;
else
--y;
if (s > 1) tree.erase(gao(x, s - 1));
if (s < n) tree.erase(gao(s + 1, y));
tree.insert(gao(x, y));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, p;
cin >> n >> p;
int ans = 0;
ans += 2;
int mn = min(n - p, p - 1);
int mx = max(n - p, p - 1);
ans += 4 * mn + 3 * mx;
ans++;
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e5 + 10;
const int LOG = 30;
struct Trie {
int l[Max * LOG], r[Max * LOG];
int sz = 1;
int val[Max * LOG];
void insert(int x) {
int pos = 1;
for (int i = LOG; i--;) {
val[pos]++;
if ((1 << i) & x)
if (r[pos])
pos = r[pos];
else
pos = r[pos] = ++sz;
else if (l[pos])
pos = l[pos];
else
pos = l[pos] = ++sz;
}
val[pos]++;
}
void rmv(int x) {
int pos = 1;
for (int i = LOG; i--;) {
val[pos]--;
if ((1 << i) & x)
pos = r[pos];
else
pos = l[pos];
}
val[pos]--;
}
int get(int x, int y) {
int pos = 1;
int ans = 0;
for (int i = LOG; i--;) {
if ((1 << i) & y) {
if ((1 << i) & x) {
ans += val[r[pos]];
pos = l[pos];
} else {
ans += val[l[pos]];
pos = r[pos];
}
} else if ((1 << i) & x)
pos = r[pos];
else
pos = l[pos];
}
return ans;
}
};
Trie trie;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int ty;
cin >> ty;
if (ty == 1) {
int x;
cin >> x;
trie.insert(x);
} else if (ty == 2) {
int x;
cin >> x;
trie.rmv(x);
} else {
int p, l;
cin >> p >> l;
cout << trie.get(p, l) << '\n';
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500001;
int a[maxn];
int cnt[maxn], cur[maxn];
int rem;
int c[maxn];
int d;
int m, k, n, s;
int main() {
scanf("%d%d%d%d", &m, &k, &n, &s);
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= s; i++) {
int x;
scanf("%d", &x);
cnt[x]++;
}
for (int i = 1; i < maxn; i++) {
if (cnt[i] > cur[i]) rem++;
}
int pos = 0;
for (int i = 1; i <= m; i++) {
while (pos < m && rem) {
cur[a[++pos]]++;
if (cnt[a[pos]] == cur[a[pos]]) rem--;
}
if (!rem) {
int cost = max(pos - i + 1 - k, 0) + (i - 1) % k;
if (cost <= m - n * k) {
printf("%d\n", cost);
for (int j = 1; j <= (i - 1) % k; j++) {
printf("%d ", j);
}
int del = max(pos - i + 1 - k, 0);
for (int j = i; j <= pos; j++) {
if (!del) break;
if (!cnt[a[j]])
del--, printf("%d ", j);
else
cnt[a[j]]--;
}
return 0;
}
}
if (cur[a[i]]-- == cnt[a[i]]) rem++;
}
printf("-1");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, f = -1, t, c, ans = 0;
cin >> n >> t >> c;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < n; i++) {
if (v[i] <= t) {
if (f == -1) f = i;
if (i - f + 1 >= c) ans++;
} else
f = -1;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> operator+(pair<long long, long long> a,
pair<long long, long long> b) {
return make_pair(a.first + b.first, a.second + b.second);
}
long long m;
map<long long, pair<long long, long long> > mp;
pair<long long, long long> dfs(long long x) {
if (mp.find(x) != mp.end()) return mp[x];
if (x == 0) return make_pair(0, 0);
long long l = 1, r = 1e5;
while (l < r) {
long long mid = (l + r + 1) / 2;
if (mid * mid * mid <= x)
l = mid;
else
r = mid - 1;
}
long long k = l * l * l;
return mp[x] = max(dfs(x % k) + make_pair(x / k, x / k * k),
dfs(k - 1) + make_pair(x / k - 1, (x / k - 1) * k));
}
int main() {
scanf("%I64d", &m);
pair<long long, long long> ans = dfs(m);
printf("%I64d %I64d\n", ans.first, ans.second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxm = 2e3 + 23;
const int maxn = 5e5 + 35;
int pre[maxn], n, m, first, second;
inline int Find(int first) {
return pre[first] == first ? first : pre[first] = Find(pre[first]);
}
inline void mix(int first, int second) {
int fx = Find(first);
int fy = Find(second);
pre[fx] = fy;
}
pair<int, int> p[maxn];
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d %d %d %d", &n, &m, &first, &second);
for (int i = 1; i <= m; ++i) scanf("%d %d", &p[i].first, &p[i].second);
for (int i = 1; i <= n; ++i) pre[i] = i;
for (int i = 1; i <= m; ++i) {
if (p[i].first != first && p[i].second != first)
mix(p[i].first, p[i].second);
}
mix(first, second);
int sumx = 0;
for (int i = 1; i <= n; ++i) {
if (Find(i) != Find(first)) sumx += 1;
}
for (int i = 1; i <= n; ++i) pre[i] = i;
for (int i = 1; i <= m; ++i) {
if (p[i].first != second && p[i].second != second)
mix(p[i].first, p[i].second);
}
mix(first, second);
int sumy = 0;
for (int i = 1; i <= n; ++i) {
if (Find(i) != Find(second)) sumy += 1;
}
cout << 1ll * sumx * sumy << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define ll long long
#define f first
#define s second
#define pii pair <int, int>
#define pb push_back
#define mp make_pair
using namespace std;
const int maxn = 1e6 + 111;
const int inf = INT_MAX;
const int mod = 1e9 + 7;
ll x, y;
void solve(){
cin >> x >> y;
ll ans = 0;
for (ll i = 2; i <= y;){
if (i + 1 > x)
break;
ll k = (i - 1) * (i + 1);
if (k <= x){
ans += (i - 1);
i++;
}
else{
ll h = x / (i + 1);
ll g = x / h;
ll cnt = min(g, y + 1) - (i + 1) + 1;
ans += cnt * h;
i += cnt;
}
}
cout << ans << endl;
}
int main(){
//freopen(".in", "r", stdin);
//freopen(".out", "w", stdout);
int qq = 1;
cin >> qq;
while (qq--){
solve();
}
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int type;
int N, Q, root = 1;
int dist[100010], lanac[100010], length[100010], A[100010], B[100010];
vector<int> v[100010];
vector<int> loga[100010];
void inc(int lan, int i, int val) {
for (; i < loga[lan].size(); i += i & -i) {
loga[lan][i] += val;
}
}
int sum(int lan, int lo, int hi) {
int ret = 0;
for (; hi > 0; hi -= hi & -hi) ret += loga[lan][hi];
for (--lo; lo > 0; lo -= lo & -lo) ret -= loga[lan][lo];
return ret;
}
void dfs(int node, int lan, int d, int exNode) {
dist[node] = d;
lanac[node] = lan;
length[lan] = max(length[lan], d);
for (int i = 0; i < v[node].size(); ++i) {
if (v[node][i] == exNode) continue;
if (node == root) {
dfs(v[node][i], i + 1, 1, node);
continue;
}
dfs(v[node][i], lan, d + 1, node);
}
}
int main(void) {
scanf("%d", &N);
for (int i = 0; i < N - 1; ++i) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
if (v[a].size() > 2) root = a;
if (v[b].size() > 2) root = b;
A[i + 1] = a;
B[i + 1] = b;
}
dfs(root, 0, 0, -1);
for (int i = 0; i < v[root].size(); ++i) {
for (int j = 0; j <= length[i + 1] + 5; ++j) loga[i + 1].push_back(0);
}
scanf("%d", &Q);
for (int i = 0; i < Q; ++i) {
scanf("%d", &type);
if (type == 1) {
int ind;
scanf("%d", &ind);
int a = A[ind], b = B[ind];
if (dist[a] > dist[b]) swap(a, b);
inc(lanac[b], dist[b], -1);
continue;
}
if (type == 2) {
int ind;
scanf("%d", &ind);
int a = A[ind], b = B[ind];
if (dist[a] > dist[b]) swap(a, b);
inc(lanac[b], dist[b], 1);
continue;
}
if (type == 3) {
int a, b;
scanf("%d%d", &a, &b);
if (a == root) {
if (sum(lanac[b], 1, dist[b]) == 0) {
printf("%d\n", dist[b]);
} else {
printf("-1\n");
}
continue;
}
if (b == root) {
if (sum(lanac[a], 1, dist[a]) == 0) {
printf("%d\n", dist[a]);
} else {
printf("-1\n");
}
continue;
}
if (a != root && b != root) {
if (lanac[a] == lanac[b]) {
if (sum(lanac[a], dist[a] + 1, dist[b]) != 0)
printf("-1\n");
else
printf("%d\n", abs(dist[a] - dist[b]));
} else {
if (sum(lanac[b], 1, dist[b]) != 0 ||
sum(lanac[a], 1, dist[a]) != 0) {
printf("-1\n");
continue;
}
printf("%d\n", dist[a] + dist[b]);
}
}
}
}
return 42 - 42;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, temp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
int cnt = 0, a = 0, b = 0, c = 0;
for (int i = 1; i <= n; i++) {
cin >> temp;
cnt++;
if (cnt == 1) {
a += temp;
} else if (cnt == 2) {
b += temp;
} else if (cnt == 3) {
c += temp;
}
if (cnt == 3) {
cnt = 0;
}
}
int maxx = max(a, max(b, c));
if (maxx == a) {
cout << "chest\n";
} else if (maxx == b) {
cout << "biceps\n";
} else if (maxx == c) {
cout << "back\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s[55][55];
int n, i, j, k, l, tag, jg;
cin >> n;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) cin >> s[i][j];
jg = 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) {
tag = 0;
for (k = 1; k <= n; k++)
for (l = 1; l <= n; l++)
if (s[i][k] + s[l][j] == s[i][j]) tag++;
if ((s[i][j] != 1) && (tag == 0)) jg = 0;
}
if (jg == 1)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100;
const int INF = (1 << 29);
const double EPS = 0.0000001;
const double Pi = acos(-1.0);
int n, m;
char ch[maxn][maxn];
int d[3][maxn][maxn];
bool vis[maxn][maxn];
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
struct Node {
int x, y;
int step;
};
bool f12, f23, f13, f123;
void bfs(char c) {
memset(d[c - '1'], -1, sizeof(d[c - '1']));
memset(vis, 0, sizeof(vis));
queue<Node> q;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ch[i][j] == c) q.push({i, j, 0}), vis[i][j] = 1;
}
}
while (!q.empty()) {
Node u = q.front();
q.pop();
d[c - '1'][u.x][u.y] = u.step;
for (int i = 0; i <= 3; i++) {
int nx = u.x + dx[i], ny = u.y + dy[i];
if (ch[nx][ny] == '#' || vis[nx][ny]) continue;
vis[nx][ny] = 1;
q.push({nx, ny, u.step + 1});
}
}
}
void debug(char c) {
cout << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%2d", d[c][i][j]);
}
cout << endl;
}
}
void judge() {
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= m; y++) {
for (int i = 0; i <= 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (ch[x][y] == '1' && ch[nx][ny] == '2') f12 = 1;
if (ch[x][y] == '2' && ch[nx][ny] == '3') f23 = 1;
if (ch[x][y] == '1' && ch[nx][ny] == '3') f13 = 1;
}
}
}
if (f12 && f23 || f23 && f13 || f13 && f12) f123 = 1;
}
void deal() {
int r1 = INF, r2 = INF;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ch[i][j] == '1') {
r1 = min(d[1][i][j], r1);
r2 = min(d[2][i][j], r2);
}
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (ch[i][j] == '1') d[1][i][j] = r1, d[2][i][j] = r2;
r1 = INF, r2 = INF;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ch[i][j] == '2') {
r1 = min(d[0][i][j], r1);
r2 = min(d[2][i][j], r2);
}
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (ch[i][j] == '2') d[0][i][j] = r1, d[2][i][j] = r2;
r1 = INF, r2 = INF;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ch[i][j] == '3') {
r1 = min(d[0][i][j], r1);
r2 = min(d[1][i][j], r2);
}
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (ch[i][j] == '3') d[0][i][j] = r1, d[1][i][j] = r2;
}
int main() {
while (cin >> n >> m) {
f12 = f23 = f13 = f123 = 0;
memset(ch, '#', sizeof(ch));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cin >> ch[i][j];
}
judge();
if (f123) {
puts("0");
continue;
}
bfs('1');
bfs('2');
bfs('3');
deal();
int ans = INF;
if (f12) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
bool tag = 1;
for (int k = 0; k <= 2; k++) {
if (d[k][i][j] == -1) tag = 0;
}
if (!tag) continue;
int tmp = 0;
tmp = min(d[0][i][j], d[1][i][j]) - 1 + d[2][i][j] - 1 + 1;
ans = min(ans, tmp);
}
}
} else if (f23) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
bool tag = 1;
for (int k = 0; k <= 2; k++) {
if (d[k][i][j] == -1) tag = 0;
}
if (!tag) continue;
int tmp = 0;
tmp = min(d[1][i][j], d[2][i][j]) - 1 + d[0][i][j] - 1 + 1;
ans = min(ans, tmp);
}
}
} else if (f13) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
bool tag = 1;
for (int k = 0; k <= 2; k++) {
if (d[k][i][j] == -1) tag = 0;
}
if (!tag) continue;
int tmp = 0;
tmp = min(d[0][i][j], d[2][i][j]) - 1 + d[1][i][j] - 1 + 1;
ans = min(ans, tmp);
}
}
} else {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
bool tag = 1;
for (int k = 0; k <= 2; k++) {
if (d[k][i][j] == -1) tag = 0;
}
if (!tag) continue;
int tmp = 0;
tmp = d[0][i][j] + d[1][i][j] + d[2][i][j] - 3 + 1;
ans = min(ans, tmp);
}
}
}
if (ans == INF)
puts("-1");
else
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-9;
const long long INF = 1000000000;
const int MAXN = 128;
int points[] = {0, 25, 18, 15, 12, 10, 8, 6, 4, 2, 1};
int t, n;
map<string, vector<int> > places;
map<string, int> score;
struct T {
string name;
vector<int> place;
int score;
};
bool cmp1(const T& a, const T& b) {
if (a.score != b.score) return a.score > b.score;
for (int i = 1; i <= 55; ++i)
if (a.place[i] != b.place[i]) return a.place[i] > b.place[i];
return a.name < b.name;
}
bool cmp2(const T& a, const T& b) {
if (a.place[1] != b.place[1]) return a.place[1] > b.place[1];
if (a.score != b.score) return a.score > b.score;
for (int i = 2; i <= 55; ++i)
if (a.place[i] != b.place[i]) return a.place[i] > b.place[i];
return a.name < b.name;
}
int main() {
cin >> t;
for (int tt = 0; tt < t; ++tt) {
cin >> n;
for (int i = 1; i <= n; ++i) {
string s;
cin >> s;
int kk = 0;
if (i <= 10) kk = points[i];
score[s] += kk;
if (places.find(s) == places.end()) places[s] = vector<int>(60);
places[s][i]++;
}
}
map<string, int>::iterator it;
vector<T> a;
for (it = score.begin(); it != score.end(); ++it) {
a.push_back(T());
a.back().name = it->first;
a.back().place = places[it->first];
a.back().score = it->second;
}
sort((a).begin(), (a).end(), cmp1);
cout << a[0].name << endl;
sort((a).begin(), (a).end(), cmp2);
cout << a[0].name << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long i, n, x, m, k, ans;
int main() {
cin >> n;
x = n;
while (x) {
x /= 10;
m++;
}
ans = n * m + m - 1;
k = 1;
for (i = 0; i < m - 1; i++) {
k *= 10;
ans -= k;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5012, K = 200012;
int n, k[N], sk[N], ans = 0;
long long a[N], x[N], y[N], m[N];
struct Data {
int x, id;
} w[K];
inline bool operator<(Data a, Data b) { return a.x < b.x; }
void Work1() {
long long r[K];
for (int i = 1; i <= n; ++i) {
int now = 0;
r[sk[i - 1] + 1] = a[i];
for (int j = sk[i - 1] + 2; j <= sk[i]; ++j) {
r[j] = (r[j - 1] * x[i] + y[i]) % m[i];
if (r[j] < r[j - 1]) ++now;
}
ans = max(ans, now);
}
printf("%d\n", ans);
int tot;
int u[N];
for (int i = 1; i <= n; ++i) u[i] = sk[i - 1] + 1;
for (int j = 1; j <= ans + 1; ++j) {
tot = 0;
for (int i = 1; i <= n; ++i) {
while (u[i] < sk[i] && r[u[i] + 1] >= r[u[i]])
++tot, w[tot].x = r[u[i]], w[tot].id = i, ++u[i];
if (u[i] <= sk[i]) ++tot, w[tot].x = r[u[i]], w[tot].id = i, ++u[i];
}
sort(w + 1, w + tot + 1);
for (int i = 1; i <= tot; ++i) printf("%d %d\n", w[i].x, w[i].id);
}
}
void Work2() {
long long p, q;
for (int i = 1; i <= n; ++i) {
int now = 0;
p = a[i];
for (int j = 2; j <= k[i]; ++j) {
q = (p * x[i] + y[i]) % m[i];
if (q < p) ++now;
p = q;
}
ans = max(ans, now);
}
printf("%d\n", ans);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d%I64d%I64d%I64d%I64d", &k[i], &a[i], &x[i], &y[i], &m[i]),
sk[i] = sk[i - 1] + k[i];
if (sk[n] <= 200000)
Work1();
else
Work2();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, f;
string t, z;
vector<string> a;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) z += '.';
for (int i = 0; i < n; i++) {
cin >> t;
if (t != z) {
a.push_back(t);
f = 1;
} else if (f)
a.push_back(t);
}
while (1) {
if (a[a.size() - 1] == z)
a.resize(a.size() - 1);
else
break;
}
n = a.size();
while (1) {
f = 0;
for (int j = 0; j < n; j++)
if (a[j][0] == 'X') {
f = 1;
break;
}
if (!f) {
for (int j = 1; j < m; j++) {
for (int l = 0; l < n; l++) a[l][j - 1] = a[l][j];
}
for (int j = 0; j < n; j++) {
if (m > 0) a[j].resize(m - 1);
}
m--;
} else
break;
}
while (1) {
f = 0;
for (int j = 0; j < n; j++)
if (a[j][m - 1] == 'X') {
f = 1;
break;
}
if (!f) {
for (int j = 0; j < n; j++) {
if (m > 0) a[j].resize(m - 1);
}
m--;
} else
break;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] == '.') {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
int diff = abs(a - b);
int count = 0;
for (int k = 10; k >= 1; k--) {
count += diff / k;
diff %= k;
}
cout << count << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
int sum[100010];
map<int, int> mp;
int main() {
int t;
cin >> t;
while (t--) {
mp.clear();
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) a[i + 1] = s[i] - '0' - 1;
int sum = 0;
long long res = 0;
for (int i = 1; i <= n; i++) {
sum += a[i];
if (sum == 0) res++;
res += mp[sum]++;
}
cout << res << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, p[100100], root;
bitset<100100> visited;
vector<vector<int> > r(100100);
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
int u = i, o = 1;
while (true) {
visited[u] = true;
u = p[u];
if (u == i)
break;
else
o++;
}
r[o].push_back(u);
}
}
bool possible = false;
if (!r[1].empty()) {
possible = true;
root = r[1][0];
swap(r[1][0], r[1][r[1].size() - 1]);
r[1].pop_back();
} else {
if (!r[2].empty()) {
bool aux = true;
for (int i = 0; i <= n; i++)
if (i % 2 == 1 && !r[i].empty()) aux = false;
if (aux) {
possible = true;
root = r[2][0];
swap(r[2][0], r[2][r[2].size() - 1]);
r[2].pop_back();
}
}
}
if (possible) {
printf("YES\n");
for (int i = 1; i <= n; i++)
if (!r[i].empty()) {
int root_aux = root;
for (int j = 0; j < (int)r[i].size(); j++) {
for (int k = 0; k < i; k++) {
printf("%d %d\n", root_aux, r[i][j]);
root_aux = p[root_aux];
r[i][j] = p[r[i][j]];
}
}
}
if (p[root] != root) printf("%d %d\n", root, p[root]);
} else
printf("NO\n");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int c[n], a[m];
for (int i = 0; i < n; ++i) cin >> c[i];
for (int i = 0; i < m; ++i) cin >> a[i];
int count = 0;
for (int i = 0, j = 0; i < n && j < m;) {
if (c[i] <= a[j]) {
++count;
++i;
++j;
} else
++i;
}
cout << count << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
double x, y;
};
struct square {
node f[5];
} A, B;
inline bool cal(const node &a, const square &b) {
double u = -999999999, r = -999999999, d = 999999999, l = 999999999;
for (int i = 1; i <= 4; i++) {
d = min(d, b.f[i].y);
u = max(u, b.f[i].y);
l = min(l, b.f[i].x);
r = max(r, b.f[i].x);
}
if (l <= a.x && r >= a.x && d <= a.y && u >= a.y) return 1;
return 0;
}
int main() {
for (int i = 1; i <= 4; i++) scanf("%lf%lf", &A.f[i].x, &A.f[i].y);
for (int i = 1; i <= 4; i++) scanf("%lf%lf", &B.f[i].x, &B.f[i].y);
bool yes = 0;
double u = -999999999, r = -999999999, d = 999999999, l = 999999999;
for (int i = 1; i <= 4; i++) {
d = min(d, B.f[i].y);
u = max(u, B.f[i].y);
l = min(l, B.f[i].x);
r = max(r, B.f[i].x);
}
yes = cal((node){(l + r) * 0.5, (u + d) * 0.5}, A);
for (int i = 1; i <= 4; i++)
if (cal(B.f[i], A)) yes = 1;
for (int i = 1; i <= 4; i++) {
int x = A.f[i].x, y = A.f[i].y;
A.f[i].x = x + y;
A.f[i].y = x - y;
}
for (int i = 1; i <= 4; i++) {
int x = B.f[i].x, y = B.f[i].y;
B.f[i].x = x + y;
B.f[i].y = x - y;
}
for (int i = 1; i <= 4; i++)
if (cal(A.f[i], B)) yes = 1;
if (yes == 1)
printf("yes\n");
else
printf("no\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
if (x > y + z) {
printf("+\n");
} else if (y > x + z) {
printf("-\n");
} else if (x == y && z == 0) {
printf("0\n");
} else {
printf("?\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string sol(string s, string prev) {
string ans = "a";
for (int i = 0; i < 4; i++) {
for (char c = '0'; c <= '9'; c++) {
if (c == '0' && i == 0) continue;
char tmp = s[i];
s[i] = c;
if (s < prev || s > "2011") {
s[i] = tmp;
continue;
}
ans = min(ans, s);
s[i] = tmp;
}
}
if (ans < prev || ans > "2011") throw "No solution";
return ans;
}
string s[1001];
vector<string> ans;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) cin >> s[i];
string ts = "0000";
for (int i = 0; i < n; i++) {
try {
string a = sol(s[i], ts);
ts = a;
ans.push_back(a);
} catch (const char* s) {
printf("%s\n", s);
return 0;
}
}
for (int i = 0; i < ans.size(); i++) cout << ans[i] << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
int n, h;
scanf("%d %d", &n, &h);
vector<pair<int, int> > v(n);
vector<int> ans(n);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i].first);
v[i].second = i;
}
sort(v.begin(), v.end());
if (n == 2) {
printf("0\n1 1");
return 0;
}
int ans1 = 1e9;
for (int i = n - 3; i >= 1; i--) {
ans1 = min(ans1, max(v[n - 1].first + v[n - 2].first,
v[n - 1].first + v[i].first + h) -
v[0].first - v[1].first);
}
ans1 = min(
ans1,
max(v[n - 1].first + v[n - 2].first, v[0].first + v[n - 1].first + h) -
min(v[1].first + v[2].first, v[1].first + v[0].first + h));
ans1 = min(ans1,
max(v[n - 2].first + v[n - 3].first,
v[n - 2].first + v[n - 1].first + h) -
min(v[0].first + v[n - 1].first + h, v[1].first + v[0].first));
ans1 = min(ans1, v[n - 1].first + v[n - 2].first - v[0].first - v[1].first);
printf("%d\n", ans1);
for (int i = n - 3; i >= 1; i--) {
if (ans1 ==
max(v[n - 1].first + v[n - 2].first, v[n - 1].first + v[i].first + h) -
v[0].first - v[1].first) {
for (int j = 0; j < i + 1; j++) ans[v[j].second] = 1;
for (int j = i + 1; j < n; j++) ans[v[j].second] = 2;
for (int j = 0; j < n; j++) printf("%d ", ans[j]);
printf("\n");
return 0;
}
}
if (ans1 ==
max(v[n - 1].first + v[n - 2].first, v[0].first + v[n - 1].first + h) -
min(v[1].first + v[2].first, v[1].first + v[0].first + h)) {
ans[v[0].second] = 1;
for (int i = 1; i < n; i++) ans[v[i].second] = 2;
for (int j = 0; j < n; j++) printf("%d ", ans[j]);
printf("\n");
return 0;
}
if (ans1 ==
max(v[n - 2].first + v[n - 3].first,
v[n - 2].first + v[n - 1].first + h) -
min(v[0].first + v[n - 1].first + h, v[1].first + v[0].first)) {
for (int i = 0; i < n - 1; i++) ans[v[i].second] = 2;
ans[v[n - 1].second] = 1;
for (int j = 0; j < n; j++) printf("%d ", ans[j]);
printf("\n");
return 0;
}
if (ans1 == v[n - 1].first + v[n - 2].first - v[0].first - v[1].first) {
for (int i = 0; i < n; i++) ans[v[i].second] = 2;
for (int j = 0; j < n; j++) printf("%d ", ans[j]);
printf("\n");
return 0;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 550;
struct PT {
double x, y;
PT(double a = 0, double b = 0) {
x = a;
y = b;
}
double operator*(PT p) { return x * p.y - y * p.x; }
PT operator-(PT p) { return PT(x - p.x, y - p.y); }
double operator/(PT p) { return x * p.x + y * p.y; }
double dis() { return sqrt(x * x + y * y); }
void init() { scanf("%lf%lf", &x, &y); }
};
double zo(double x) { return fabs(x) < 1e-8 ? 0 : x; }
struct PY {
int n;
PT pt[5];
PT &operator[](int x) { return pt[x]; }
void init() {
n = 4;
for (int i = 0; i < n; i++) pt[i].init();
}
double area() {
double ans = pt[n - 1] * pt[0];
for (int i = 0; i < n - 1; ++i) ans += pt[i] * pt[i + 1];
if (ans < 0) {
for (int i = 0, j = n - 1; i < j; i++, j--) swap(pt[i], pt[j]);
ans = -ans;
}
return ans;
}
} py[N];
pair<double, int> pr[N * N * 2];
double segP(PT a, PT b, PT c) {
if (zo(a.x - b.x) == 0) return (c.y - a.y) / (b.y - a.y);
return (c.x - a.x) / (b.x - a.x);
}
double plyUnion(int n) {
for (int i = 0; i < n; ++i) py[i][py[i].n] = py[i][0];
double sum = 0;
for (int i = 0; i < n; ++i) {
for (int ii = 0; ii < py[i].n; ++ii) {
PT &a = py[i][ii], &b = py[i][ii + 1];
int id = 0;
pr[++id] = make_pair(0, 0);
pr[++id] = make_pair(1, 0);
for (int j = 0; j < n; ++j) {
if (i == j) continue;
for (int jj = 0; jj < py[j].n; ++jj) {
PT &c = py[j][jj], &d = py[j][jj + 1];
double tc = zo((c - a) * (b - a));
double td = zo((d - a) * (b - a));
if (0 == tc && 0 == td) {
if ((c - d) / (a - b) > 0 && j < i) {
pr[++id] = make_pair(segP(a, b, c), 1);
pr[++id] = make_pair(segP(a, b, d), -1);
}
} else if ((tc > 0 || td > 0) && tc * td <= 0) {
int t = (tc > 0 ? -1 : 1);
double acd = (a - c) * (d - c);
double bcd = (b - c) * (d - c);
pr[++id] = make_pair(acd / (acd - bcd), t);
}
}
}
sort(pr + 1, pr + id + 1);
double lst = min(max(pr[1].first, 0.0), 1.0), now;
int t = pr[1].second;
double s = 0;
for (int j = 2; j <= id; j++) {
now = min(max(pr[j].first, 0.0), 1.0);
if (t == 0) s += now - lst;
t += pr[j].second;
lst = now;
}
sum += (a * b) * s;
}
}
return sum;
}
int main() {
int n;
scanf("%d", &n);
double sum = 0;
for (int i = 0; i < n; i++) {
py[i].init();
sum += py[i].area();
}
printf("%.9lf\n", sum / plyUnion(n));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int pos, N, base[500510], aft[500510], M, i;
int cnt, Len, T[500510 << 5], L[500510 << 5], R[500510 << 5], sum[500510 << 5];
inline int qr() {
int k = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
k = (k << 1) + (k << 3) + c - 48;
c = getchar();
}
return k * f;
}
inline int build(int l, int r) {
int rt = ++cnt;
sum[rt] = 0;
if (l < r) {
L[rt] = build(l, ((l + r) >> 1));
R[rt] = build(((l + r) >> 1) + 1, r);
}
return rt;
}
inline int update(int last, int l, int r, int x) {
int rt = ++cnt;
sum[rt] = sum[last] + 1;
R[rt] = R[last];
L[rt] = L[last];
if (l < r) {
if (x <= ((l + r) >> 1))
L[rt] = update(L[last], l, ((l + r) >> 1), x);
else
R[rt] = update(R[last], ((l + r) >> 1) + 1, r, x);
}
return rt;
}
inline int query(int Left, int Right, int l, int r, int k) {
if (l == r) return aft[l];
int qwq;
int x = sum[L[Right]] - sum[L[Left]], y = sum[R[Right]] - sum[R[Left]];
if (x > k)
if ((qwq = query(L[Left], L[Right], l, ((l + r) >> 1), k)) > 0) return qwq;
if (y > k)
if ((qwq = query(R[Left], R[Right], ((l + r) >> 1) + 1, r, k)) > 0)
return qwq;
return -1;
}
int main() {
cin >> N >> M;
for (i = 1; i <= N; i++) {
base[i] = qr();
aft[i] = base[i];
}
sort(aft + 1, aft + N + 1);
Len = unique(aft + 1, aft + N + 1) - (aft + 1);
T[0] = build(1, Len);
for (i = 1; i <= N; i++) {
pos = lower_bound(aft + 1, aft + Len + 1, base[i]) - aft;
T[i] = update(T[i - 1], 1, Len, pos);
}
for (i = 1; i <= M; i++) {
scanf("%d%d%d", &a, &b, &c);
int k = (b - a + 1) / c;
cout << query(T[a - 1], T[b], 1, Len, k) << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 100, M = 1e6 + 100;
int n, up[N], down[M], nei[M][2];
int lim;
bool mark[M], bad[M];
vector<int> vec;
int f(int a) { return lower_bound(vec.begin(), vec.end(), a) - vec.begin(); }
bool dfs(int v) {
mark[v] = true;
for (int i = 0; i < 2 && nei[v][i] <= lim; i++) {
int u = nei[v][i];
if (up[u] == -1 || (mark[up[u]] == false && dfs(up[u]))) {
up[u] = v;
down[v] = u;
return true;
}
}
return false;
}
bool ok(int X) {
lim = X;
fill(up, up + N, -1);
fill(down, down + M, -1);
memset(bad, false, sizeof bad);
int matching = 0;
bool done = false;
for (int v = 0; v < n; v++)
if (nei[v][0] > lim)
return false;
else if (nei[v][1] > lim) {
if (up[nei[v][0]] != -1) return false;
down[v] = nei[v][0];
up[nei[v][0]] = v;
bad[v] = true;
matching++;
}
while (done == false) {
done = true;
copy(bad, bad + n, mark);
for (int v = 0; v < n; v++)
if (mark[v] == false && down[v] == -1 && dfs(v)) {
matching++;
done = false;
}
}
return matching == n;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> nei[i][0] >> nei[i][1];
vec.push_back(nei[i][0]);
vec.push_back(nei[i][1]);
}
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
for (int i = 0; i < n; i++)
nei[i][0] = f(nei[i][0]), nei[i][1] = f(nei[i][1]);
if (ok(vec.size() - 1) == false) {
cout << -1;
return 0;
}
if (ok(vec.size() - 2) == false) {
cout << vec.back();
return 0;
}
int l = -1, r = vec.size() - 1;
while (r - l > 1) {
if (ok((l + r) >> 1))
r = lim;
else
l = lim;
}
cout << vec[r];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 501 * 1001;
vector<pair<pair<int, int>, pair<int, int> > > yal;
int par[MAXN] = {}, col[MAXN] = {};
int root(int x) {
if (par[x] < 0) {
return x;
}
int p = root(par[x]);
col[x] ^= col[par[x]];
return par[x] = p;
}
int main() {
int n, q, m, l, r;
scanf("%d%d%d", &n, &m, &q);
int x, y, z;
for (int i = 0; i < m; i++)
scanf("%d%d%d", &x, &y, &z), yal.push_back({{z, i}, {x, y}});
sort(yal.rbegin(), yal.rend());
for (int i = 0; i < q; i++) {
scanf("%d%d", &l, &r);
for (int i = 1; i <= n; i++) par[i] = -1, col[i] = 0;
bool f = 1;
for (int j = 0; j < m && f; j++) {
if (yal[j].first.second >= l - 1 && yal[j].first.second < r) {
x = yal[j].second.first, y = yal[j].second.second;
if (root(x) == root(y)) {
if (col[x] == col[y]) printf("%d\n", yal[j].first.first), f = 0;
} else {
bool ff = 0;
if (col[x] == col[y]) ff = 1;
x = root(x);
y = root(y);
if (par[y] < par[x]) swap(x, y);
par[x] += par[y];
if (ff) {
col[y] = 1;
}
par[y] = x;
}
}
}
if (f) puts("-1");
}
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const long long MOD = 1e9 + 7;
const long long N = 1e6 + 10;
const long long INF = 1e18 + 10;
bool isPrime(long long x) {
if (x <= 1) return false;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
vector<bool> prime(N, true);
vector<long long> primes;
void seive() {
prime[0] = prime[1] = false;
for (long long i = 2; i * i <= N; i++) {
if (prime[i]) {
for (long long j = i + i; j < N; j += i) prime[j] = false;
}
}
for (long long i = 0; i < N; i++) {
if (prime[i]) {
primes.emplace_back(i);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
seive();
long long n;
cin >> n;
if (isPrime(n)) {
cout << 1 << endl;
cout << n << endl;
return 0;
}
long long cur = n;
while (cur--) {
if (isPrime(cur)) {
debug() << " ["
<< "cur"
": "
<< (cur) << "] ";
if (cur + 2 == n) {
cout << 2 << endl;
cout << 2 << ' ' << cur << endl;
return 0;
}
int target = n - cur;
debug() << " ["
<< "target"
": "
<< (target) << "] ";
int L = 0, R = (int)primes.size() - 1;
while (L <= R) {
if (primes[L] + primes[R] == target) {
cout << 3 << endl;
cout << primes[L] << ' ' << primes[R] << ' ' << cur << endl;
return 0;
} else if (primes[L] + primes[R] > target)
R--;
else {
debug() << " ["
<< "L"
": "
<< (L)
<< "] "
" ["
<< "R"
": "
<< (R) << "] ";
debug() << " ["
<< "primes[L]"
": "
<< (primes[L])
<< "] "
" ["
<< "primes[R]"
": "
<< (primes[R]) << "] ";
L++;
}
}
}
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define fastIO std::ios::sync_with_stdio(false);cin.tie(NULL)
using namespace std;
#define int long long
#define N 2002
int dp[N][N];
int a[N];
int solve(int l , int r)
{
if(l>=r)
return 0;
if(dp[l][r]!=-1)
return dp[l][r];
return dp[l][r] = (a[r] - a[l]) + min(solve(l+1 , r) , solve(l , r-1));
}
int32_t main()
{
fastIO;
int n;
cin>>n;
for(int i=0 ; i<n ; i++)
cin>>a[i];
sort(a , a+n);
memset(dp , -1 , sizeof(dp));
cout<<solve(0 , n-1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool is_prime(int a) {
int sq = sqrt(a);
for (int i = 3; i <= sq; i += 2) {
if (a % i == 0) return 0;
}
return 1;
}
int main() {
int n, i, j;
cin >> n;
if (is_prime(n))
cout << "1" << endl << n;
else if (is_prime(n - 2))
cout << "2" << endl
<< "2"
<< " " << n - 2;
else if (is_prime(n - 4))
cout << "3" << endl
<< "2"
<< " "
<< "2"
<< " " << n - 4;
else {
for (i = n - 6;; i -= 2) {
if (is_prime(i)) break;
}
int sum = n - i;
for (j = 3;; j += 2) {
if (is_prime(j) && is_prime(sum - j)) break;
}
cout << "3" << endl;
cout << i << " " << j << " " << sum - j;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void Q_Q() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
int main() {
Q_Q();
string s;
cin >> s;
int n;
cin >> n;
vector<string> v;
while (n--) {
string ss;
cin >> ss;
v.push_back(ss);
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
if (s.length() <= v[i].length()) {
string ss = v[i];
string temp = ss.substr(0, s.length());
if (s == temp) return cout << v[i], 0;
}
}
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e3 + 10, inf = 1e9 + 10;
int dp[MAXN][MAXN], dp2[MAXN][MAXN], b[MAXN];
bool mark[MAXN];
pair<int, int> a[MAXN], par[MAXN][MAXN];
vector<int> ans1, ans2;
set<pair<int, int> > s2;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, p, s;
cin >> n >> p >> s;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
for (int i = 0; i < n; i++) cin >> b[i];
sort(a, a + n);
reverse(a, a + n);
memset(dp2, -63, sizeof dp2);
memset(dp, -63, sizeof dp);
dp2[n][0] = 0;
for (int i = n - 1; i >= 0; i--) {
dp2[i][0] = 0;
for (int j = 1; j <= n - i; j++)
dp2[i][j] = max(dp2[i + 1][j], dp2[i + 1][j - 1] + b[a[i].second]);
}
dp[0][0] = a[0].first;
dp[0][1] = b[a[0].second];
for (int i = 1; i < n; i++) {
for (int j = 0; j <= i + 1; j++) {
int ind = a[i].second;
dp[i][j] = dp[i - 1][j] + a[i].first;
par[i][j] = make_pair(i - 1, j);
if (j == 0) continue;
if (dp[i - 1][j - 1] + b[ind] > dp[i][j]) {
dp[i][j] = dp[i - 1][j - 1] + b[ind];
par[i][j] = make_pair(i - 1, j - 1);
}
}
}
int mx = 0, ind = 0;
for (int i = p - 1; i < s + p; i++) {
int val = dp[i][i - p + 1] + dp2[i + 1][s - (i - p) - 1];
if (val > mx) {
mx = val;
ind = i;
}
}
cout << mx << '\n';
int x1 = ind, x2 = ind - p + 1;
for (int i = 0; i < ind - p + 1;) {
int y1 = par[x1][x2].first, y2 = par[x1][x2].second;
if (y2 == x2 - 1) {
ans2.push_back(a[x1].second);
i++;
mark[a[x1].second] = true;
}
x1 = y1;
x2 = y2;
}
for (int i = 0; i <= ind; i++)
if (!mark[a[i].second]) ans1.push_back(a[i].second);
for (int i = n - 1; i > ind; i--)
s2.insert(make_pair(inf - b[a[i].second], a[i].second));
int cnt = 0;
for (auto y : s2) {
if (cnt == s - (ind - p + 1)) break;
cnt++;
ans2.push_back(y.second);
}
for (auto c1 : ans1) cout << c1 + 1 << " ";
cout << '\n';
for (auto c2 : ans2) cout << c2 + 1 << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
char s[N];
int buf[60];
long long fac[N];
long long inv[N];
long long dp[N];
long long tempDp[N];
long long ans[60][60];
int find(char x) {
int tmp;
if (x >= 'A' && x <= 'Z')
tmp = x - 'A' + 26;
else
tmp = x - 'a';
return tmp;
}
long long Pow(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = 1ll * ans * x % MOD;
x = 1ll * x * x % MOD;
y >>= 1;
}
return ans;
}
int main() {
fac[0] = fac[1] = 1;
inv[0] = inv[1] = 1;
for (int i = 2; i < N; ++i) {
fac[i] = fac[i - 1] * i % MOD;
}
while (~scanf("%s", s)) {
memset(buf, 0, sizeof(buf));
memset(ans, 0, sizeof(ans));
memset(dp, 0, sizeof(dp));
int n = strlen(s);
inv[n] = Pow(fac[n], MOD - 2);
for (int i = n - 1; i >= 0; i--)
inv[i] = (inv[i + 1] * 1ll * (i + 1)) % MOD;
for (int i = 0, len = strlen(s); i < len; ++i) {
buf[find(s[i])]++;
}
long long base = fac[n / 2] * fac[n / 2] % MOD;
for (int i = 0; i < 52; ++i) {
base = base * inv[buf[i]] % MOD;
}
dp[0] = 1;
for (int i = 0; i < 52; ++i) {
if (!buf[i]) continue;
for (int j = n; j >= buf[i]; --j) {
dp[j] = (dp[j] + dp[j - buf[i]]) % MOD;
}
}
for (int i = 0; i < 52; ++i) {
ans[i][i] = dp[n / 2];
}
for (int i = 0; i < 52; ++i) {
if (!buf[i]) continue;
for (int j = 0; j <= n; ++j) {
tempDp[j] = dp[j];
}
for (int j = buf[i]; j <= n; ++j) {
tempDp[j] = (tempDp[j] - tempDp[j - buf[i]] + MOD) % MOD;
}
for (int j = i + 1; j < 52; ++j) {
if (!buf[j]) continue;
for (int k = buf[j]; k <= n; ++k) {
tempDp[k] = (tempDp[k] - tempDp[k - buf[j]] + MOD) % MOD;
}
ans[i][j] = ans[j][i] = 2 * tempDp[n / 2] % MOD;
for (int k = n; k >= buf[j]; --k) {
tempDp[k] = (tempDp[k] + tempDp[k - buf[j]]) % MOD;
}
}
}
int q;
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
printf("%lld\n", base * ans[find(s[x - 1])][find(s[y - 1])] % MOD);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool critical[101][101][101];
vector<vector<string> > CPU;
int n, m, k;
void solve(int i, int j, int t) {
if (CPU[i][j][t] == '0') {
return;
}
if (i < n - 2 && CPU[i + 1][j][t] == '1' && CPU[i + 2][j][t] == '1') {
critical[i + 1][j][t] = true;
}
if (j < m - 2 && CPU[i][j + 1][t] == '1' && CPU[i][j + 2][t] == '1') {
critical[i][j + 1][t] = true;
}
if (t < k - 2 && CPU[i][j][t + 1] == '1' && CPU[i][j][t + 2] == '1') {
critical[i][j][t + 1] = true;
}
if (i < n - 1 && j < m - 1 && CPU[i + 1][j + 1][t] == '1' &&
(CPU[i + 1][j][t] == '1' || CPU[i][j + 1][t] == '1')) {
if (CPU[i + 1][j][t] == '0') {
critical[i][j + 1][t] = true;
}
if (CPU[i][j + 1][t] == '0') {
critical[i + 1][j][t] = true;
}
}
if (i < n - 1 && t < k - 1 && CPU[i + 1][j][t + 1] == '1' &&
(CPU[i + 1][j][t] == '1' || CPU[i][j][t + 1] == '1')) {
if (CPU[i + 1][j][t] == '0') {
critical[i][j][t + 1] = true;
}
if (CPU[i][j][t + 1] == '0') {
critical[i + 1][j][t] = true;
}
}
if (t < k - 1 && j < m - 1 && CPU[i][j + 1][t + 1] == '1' &&
(CPU[i][j][t + 1] == '1' || CPU[i][j + 1][t] == '1')) {
if (CPU[i][j][t + 1] == '0') {
critical[i][j + 1][t] = true;
}
if (CPU[i][j + 1][t] == '0') {
critical[i][j][t + 1] = true;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
vector<string> r;
CPU.push_back(r);
for (int j = 0; j < m; j++) {
string in;
cin >> in;
CPU.back().push_back(in);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int t = 0; t < k; t++) {
solve(i, j, t);
}
}
}
long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int t = 0; t < k; t++) {
if (critical[i][j][t]) {
ans++;
}
}
}
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
int main() {
ios_base::sync_with_stdio(false);
int col = 0;
int lin = 1;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0') {
if (col == 1) {
cout << "3 1" << '\n';
col = 0;
} else {
cout << "1 1" << '\n';
col++;
}
} else {
cout << lin << " " << 2 << '\n';
lin++;
if (lin == 5) lin = 1;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
char s[100001];
int n;
scanf("%d%s", &n, &s);
for (int i = 0; i < n; ++i) {
if (s[i] != 'a' && s[i] != 'e' && s[i] != 'o' && s[i] != 'i' &&
s[i] != 'u' && s[i] != 'y') {
printf("%c", s[i]);
continue;
}
if (s[i] == 'o' || s[i] == 'e') {
if (i == 0 && s[i] == s[i + 1] && s[i] != s[i + 2]) {
printf("%c%c", s[i], s[i]);
i++;
continue;
} else if (i == n - 2 && s[i] == s[i + 1] && s[i] != s[i - 1]) {
printf("%c%c", s[i], s[i]);
i++;
continue;
} else if (i < n - 1 && s[i] == s[i + 1] && s[i] != s[i - 1] &&
s[i] != s[i + 2]) {
printf("%c%c", s[i], s[i]);
i++;
continue;
}
}
if (s[i] != s[i - 1]) printf("%c", s[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, q, timer, x, y, n, m, cnt, even, flag, dlfjl, dskgj, dkfj, dskfj,
boom, r, c, z;
vector<int> f, g;
int p[100500], a[100500], dp[100500][202][2];
void norm(int &x) {
if (x >= 998244353) x -= 998244353;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
if (a[0] != -1)
dp[0][a[0]][1] = 1;
else {
for (int i = 1; i <= 200; i++) dp[0][i][1] = 1;
}
for (int i = 1; i < n; i++) {
int dp0 = 0, dp1 = 0;
int l = 1, r = 200;
if (a[i] != -1) l = r = a[i];
for (int j = 1; j <= 200; j++) {
if (j >= l && j <= r) {
dp[i][j][1] += dp1;
norm(dp[i][j][1]);
dp[i][j][1] += dp0;
norm(dp[i][j][1]);
}
dp1 += dp[i - 1][j][1];
dp0 += dp[i - 1][j][0];
norm(dp1);
norm(dp0);
}
dp0 = 0, dp1 = 0;
for (int j = 200; j >= 1; j--) {
dp1 += dp[i - 1][j][1];
dp0 += dp[i - 1][j][0];
norm(dp1);
norm(dp0);
if (j >= l && j <= r) {
dp[i][j][0] += dp[i - 1][j][1];
norm(dp[i][j][0]);
dp[i][j][0] += dp0;
norm(dp[i][j][0]);
}
}
}
int ans = 0;
for (int i = 1; i <= 200; i++) {
ans += dp[n - 1][i][0];
norm(ans);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 210000, M = 20;
long long n, w[N], mark[N], head[N], maxE, tqz[N], tree[N][M + 2];
struct Edge {
long long nxt, to, rdis;
} e[N];
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * w;
}
inline void Add(long long u, long long v, long long w) {
e[++maxE].nxt = head[u];
head[u] = maxE;
e[maxE].to = v;
e[maxE].rdis = w;
}
void DFS(long long x) {
for (long long i = 1; i <= M; i++) tree[x][i] = tree[tree[x][i - 1]][i - 1];
long long p = x;
for (long long i = M; i >= 0; i--)
if (tqz[x] - tqz[tree[p][i]] <= w[x] && tree[p][i]) p = tree[p][i];
mark[tree[x][0]]++, mark[tree[p][0]]--;
for (long long i = head[x]; i; i = e[i].nxt) {
tree[e[i].to][0] = x;
tqz[e[i].to] = tqz[x] + e[i].rdis;
DFS(e[i].to);
mark[x] += mark[e[i].to];
}
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) w[i] = read();
for (long long i = 2, u, v; i <= n; i++) {
u = read(), v = read();
Add(u, i, v);
}
DFS(1);
for (long long i = 1; i <= n; i++) printf("%lld ", mark[i]);
putchar('\n');
return 0;
}
| 5 |
#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};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long int lxt() {
long long int aaa;
scanf("%I64d", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int ar[100010], br[100010], ans[100010];
int main() {
int n = nxt();
for (int i = 0; i < n; i++) ar[i] = nxt();
for (int i = 0; i < n; i++) {
memset(br, 0, sizeof(br));
int dominant = 0;
for (int j = i; j < n; j++) {
br[ar[j]]++;
if (br[ar[j]] > br[dominant])
dominant = ar[j];
else if (br[ar[j]] == br[dominant]) {
dominant = min(dominant, ar[j]);
}
ans[dominant]++;
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char c[1001][1001];
int n, m;
int count(int row, int col) {
int i, j = 0;
if (c[row - 1][col - 1] == '*') j++;
if (c[row - 1][col] == '*') j++;
if (c[row - 1][col + 1] == '*') j++;
if (c[row][col - 1] == '*') j++;
if (c[row][col + 1] == '*') j++;
if (c[row + 1][col - 1] == '*') j++;
if (c[row + 1][col] == '*') j++;
if (c[row + 1][col + 1] == '*') j++;
if (j == c[row][col] - '0')
return 1;
else
return 0;
}
int point(int row, int col) {
int i, j, k = 0;
for (i = row - 1; i <= row + 1; i++)
for (j = col - 1; j <= col + 1; j++)
if (i != row || j != col) {
if (c[i][j] == '*') return 0;
}
return 1;
}
int main() {
int i, j, k;
cin >> n >> m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) cin >> c[i][j];
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (c[i][j] >= '1' && c[i][j] <= '9') {
if (count(i, j) == 0) {
cout << "NO" << endl;
return 0;
}
} else if (c[i][j] == '.') {
if (point(i, j) == 0) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, b;
cin >> n >> b;
queue<long long> q;
for (int i = 0; i < n; ++i) {
int t, d;
cin >> t >> d;
while (!q.empty() && q.front() <= t) q.pop();
if (q.empty()) {
cout << t + d << ' ';
q.push(t + d);
} else if (q.size() > b) {
cout << -1 << ' ';
} else {
cout << q.back() + d << ' ';
q.push(q.back() + d);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, t, ans;
int sum;
} a[200010], bus[200010];
int n, fa[200010][20], dep[200010], low[200010][20], dfnl[200010], dfnr[200010],
cnt;
vector<int> w[200010], busx[200010], px[200010];
void dfs1(int x) {
dfnl[x] = ++cnt;
dep[x] = dep[fa[x][0]] + 1;
for (int i = 1; i < 20; i++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = 0; i < w[x].size(); i++) dfs1(w[x][i]);
dfnr[x] = cnt;
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 19; i >= 0; i--)
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
if (x == y) return x;
for (int i = 19; i >= 0; i--)
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
return fa[x][0];
}
int update(int x, int y) {
if (dep[x] > dep[y]) return y;
return x;
}
void dfslow(int x) {
for (int i = 0; i < w[x].size(); i++) {
dfslow(w[x][i]);
low[x][0] = update(low[x][0], low[w[x][i]][0]);
}
}
pair<int, int> find_low(int x, int y) {
int res = 0;
if (dep[low[x][19]] > dep[y]) return make_pair(x, -1);
for (int i = 19; i >= 0; i--)
if (dep[low[x][i]] > dep[y]) {
res += (1 << i);
x = low[x][i];
}
return make_pair(x, res);
}
int tree[200010];
int que(int x) {
int res = 0;
while (x > 0) {
res += tree[x];
x -= x & (-x);
}
return res;
}
int query(int l, int r) { return que(r) - que(l - 1); }
void add(int l, int x) {
while (l <= n) {
tree[l] += x;
l += l & (-l);
}
}
void dfs(int x) {
for (int i = 0; i < px[x].size(); i++) {
int u = px[x][i];
a[u].sum = query(dfnl[a[u].y], dfnr[a[u].y]);
}
for (int i = 0; i < busx[x].size(); i++) {
int u = busx[x][i];
if (x == bus[u].x)
add(dfnl[bus[u].y], 1);
else
add(dfnl[bus[u].x], 1);
}
for (int i = 0; i < w[x].size(); i++) dfs(w[x][i]);
for (int i = 0; i < px[x].size(); i++) {
int u = px[x][i];
if (a[u].sum == query(dfnl[a[u].y], dfnr[a[u].y])) a[u].ans++;
}
}
int main() {
int x, m, u, v, q;
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
scanf("%d", &x);
w[x].push_back(i);
fa[i][0] = x;
}
for (int i = 1; i <= n; i++) low[i][0] = i;
dep[1] = 1;
dfs1(1);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
bus[i].x = u, bus[i].y = v;
bus[i].t = lca(u, v);
low[u][0] = update(low[u][0], bus[i].t);
low[v][0] = update(low[v][0], bus[i].t);
busx[u].push_back(i);
busx[v].push_back(i);
}
dfslow(1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 19; j++) low[i][j] = low[low[i][j - 1]][j - 1];
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
a[i].ans = 1;
scanf("%d%d", &u, &v);
if (dep[u] < dep[v]) swap(u, v);
int t = lca(u, v);
pair<int, int> res;
res = find_low(u, t);
if (res.second == -1) {
a[i].ans = -1;
continue;
}
a[i].x = res.first;
a[i].ans += res.second;
if (t == v) continue;
res = find_low(v, t);
if (res.second == -1) {
a[i].ans = -1;
continue;
}
a[i].y = res.first;
a[i].ans += res.second;
px[a[i].x].push_back(i);
}
dfs(1);
for (int i = 1; i <= q; i++) printf("%d\n", a[i].ans);
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
using namespace std;
using ld = long double;
using lli = long long;
using ii = pair<int, int>;
using vi = vector<int>;
template <int p>
struct Modular {
int v;
Modular(lli x = 0) {
if (abs(x) >= p) x %= p;
if (x < 0) x += p;
v = x;
}
Modular operator+(const Modular &m) const { return Modular(v + m.v); }
Modular operator-(const Modular &m) const { return Modular(v - m.v + p); }
Modular operator*(const Modular &m) const { return Modular(1LL * v * m.v); }
Modular operator/(const Modular &m) const { return *this * m.inv(); }
Modular inv() const { return Modular(minv(v, p)); }
Modular operator-() const { return Modular(-v); }
Modular &operator+=(const Modular &m) { return *this = *this + m; }
Modular &operator-=(const Modular &m) { return *this = *this - m; }
Modular &operator*=(const Modular &m) { return *this = *this * m; }
Modular &operator/=(const Modular &m) { return *this = *this / m; }
friend ostream &operator<<(ostream &os, const Modular &m) {
return os << m.v;
}
friend istream &operator>>(istream &is, Modular &m) { return is >> m.v; }
private:
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - lli(minv(m, a)) * lli(m) / a);
}
};
using Mint = Modular<998244353>;
template <class T>
T fpow(T x, lli n) {
T r(1);
for (; n > 0; n >>= 1) {
if (n & 1) r = r * x;
x = x * x;
}
return r;
}
int n;
int main() {
cin.tie(0)->sync_with_stdio(0), cout.tie(0);
while (cin >> n) {
for (auto i = (1) - ((1) > (n + 1)); i != (n + 1) - ((1) > (n + 1));
i += 1 - 2 * ((1) > (n + 1))) {
if (i == n) {
cout << 10 << '\n';
} else {
Mint ways = Mint(180) * fpow<Mint>(10, n - i - 1);
ways += Mint(n - i - 1) * 81 * fpow<Mint>(10, n - i - 1);
cout << ways << " ";
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
long long ss[1111], sl[1111], ts[1111], tl[1111];
long double pf[1111];
long long SS[1111], SL[1111], TS[1111], TL[1111];
long double PF[1111];
struct dpval {
long long score = -1, cntprob = 1e12, penal, cnttime;
dpval() {}
} dp[1111][2222];
bool operator>(dpval a, dpval b) {
return a.score > b.score || (a.score == b.score && a.penal < b.penal);
}
bool cmp(int a, int b) {
return TL[a] * PF[a] * (1 - PF[b]) < TL[b] * PF[b] * (1 - PF[a]);
}
void upd(int i, int j) {
dpval ndp = dp[i][j];
int ni = i + 1, nj;
nj = j;
if (ndp > dp[ni][nj]) {
dp[ni][nj] = ndp;
}
nj = j + ts[i];
if (nj <= t) {
ndp.score += ss[i] * 1e6;
ndp.penal += ts[i] * 1e12;
if (ndp > dp[ni][nj]) {
dp[ni][nj] = ndp;
}
}
nj = nj + tl[i];
if (nj <= t) {
ndp.score += sl[i] * (1e6 - 1e6 * pf[i]);
ndp.cntprob *= pf[i];
long double penal1 = tl[i] * (1e12 - ndp.cntprob);
ndp.penal += penal1;
if (ndp > dp[ni][nj]) {
dp[ni][nj] = ndp;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> t;
vector<int> FORSORT;
for (int i = 0; i < n; i++) {
FORSORT.push_back(i);
cin >> SS[i] >> SL[i] >> TS[i] >> TL[i] >> PF[i];
}
sort(FORSORT.begin(), FORSORT.end(), cmp);
reverse(FORSORT.begin(), FORSORT.end());
;
for (int i = 0; i < n; i++) {
ss[i] = SS[FORSORT[i]];
sl[i] = SL[FORSORT[i]];
ts[i] = TS[FORSORT[i]];
tl[i] = TL[FORSORT[i]];
pf[i] = PF[FORSORT[i]];
}
dp[0][0].score = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < t + 1; j++) {
if (dp[i][j].score != -1) {
upd(i, j);
}
}
}
dpval ans = dp[0][0];
for (int i = 0; i < n + 1; i++)
for (int j = 0; j < t + 1; j++)
if (dp[i][j] > ans) {
ans = dp[i][j];
}
printf("%.11Lf %.11Lf\n", (long double)ans.score / 1e6,
(long double)ans.penal / 1e12);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void printvec(vector<T>& vec) {
for (int i = 0; i < vec.size(); i++) {
cout << vec[i] << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
long long int prime[1000001];
for (int i = 2; i <= 1000000; i++) {
prime[i] = i;
}
prime[0] = -1;
prime[1] = -1;
for (int p = 2; p <= 1000000; p++) {
if (prime[p] == p) {
for (int i = p * 2; i <= 1000000; i += p) prime[i] = p;
}
}
long long int x;
cin >> x;
set<int> possible;
int i;
long long int mini1 = INT_MAX;
for (i = 1; i * i < x; i++) {
if (x % i == 0) {
if (prime[i] == i) {
if (x - i + 1 >= 3)
mini1 = min(mini1, x - i + 1);
else
mini1 = min(mini1, (long long int)3);
}
if (prime[x / i] == x / i) {
if (x - x / i + 1 >= 3)
mini1 = min(mini1, x - x / i + 1);
else
mini1 = min(mini1, (long long int)3);
}
}
}
if (i * i == x)
if (prime[i] == i) {
if (x - i + 1 >= 3)
mini1 = min(mini1, x - i + 1);
else
mini1 = min(mini1, (long long int)3);
}
long long int mini = INT_MAX;
for (int j = mini1; j <= x; j++) {
long long int x = j;
long long int i = j;
while (prime[i] != i) {
if (x - prime[i] + 1 >= 3)
mini = min(x - prime[i] + 1, mini);
else {
mini = 3;
}
i = i / prime[i];
}
}
cout << mini << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000003;
char in[500010];
inline int pow(int a, int b) {
if (b == 0) return 1;
if (b == 1) return a % mod;
long long r = pow(a, b / 2);
r = (r * r) % mod;
if (b % 2) r = (r * a) % mod;
return r;
}
int n, m;
inline char f(int x, int y) { return in[x * m + y]; }
int main() {
int i, j;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%s", &in[i * m]);
int ans = 1;
for (i = 0; i < n; i++) {
int f1 = 0, f2 = 0;
for (j = 0; j < m; j++) {
char c = f(i, j);
if (c == '1' || c == '2') {
if (j % 2 == 0)
f1 = 1;
else
f2 = 1;
} else if (c == '3' || c == '4') {
if (j % 2 == 0)
f2 = 1;
else
f1 = 1;
}
}
if (f1 && f2)
ans = 0;
else if (!f1 && !f2)
ans = (ans * 2) % mod;
}
for (j = 0; j < m; j++) {
int f1 = 0, f2 = 0;
for (i = 0; i < n; i++) {
char c = f(i, j);
if (c == '1' || c == '4') {
if (i % 2 == 0)
f1 = 1;
else
f2 = 1;
} else if (c == '2' || c == '3') {
if (i % 2 == 0)
f2 = 1;
else
f1 = 1;
}
}
if (f1 && f2)
ans = 0;
else if (!f1 && !f2)
ans = (ans * 2) % mod;
}
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i;
long long a[200005];
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long long j, k, ans = 0, Min = 1000000000;
for (int i = 0; i < n; i++) {
ans = 0;
for (int j = 0; j < a[i]; j++) {
cin >> k;
ans += (k * 5);
}
ans += (a[i] * 15);
if (ans < Min) Min = ans;
}
cout << Min << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool remax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
inline bool remin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
cout << 3 + 4 * min(k - 1, n - k) + 3 * max(k - 1, n - k);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<long long, long long>>> graph;
vector<bool> connected, vis;
vector<long long> child;
vector<long long> parent;
long long ans_g = 0;
long long ans_b = 0;
void dfs(long long u) {
vis[u] = true;
vector<pair<long long, long long>> unconnected;
for (auto edge : graph[u]) {
long long v = edge.first;
long long w = edge.second;
if (vis[v]) continue;
dfs(v);
if (connected[v] == false) {
unconnected.push_back({v, w});
}
}
long long n = unconnected.size();
for (long long i = 0; i < n - 1; i += 2) {
long long w2 = unconnected[i + 1].second, w1 = unconnected[i].second;
ans_g += w1 + w2;
long long v2 = unconnected[i + 1].first, v1 = unconnected[i].first;
connected[v1] = true;
connected[v2] = true;
}
if (n % 2) {
long long v = unconnected[n - 1].first, w = unconnected[n - 1].second;
ans_g += w;
connected[v] = true;
connected[u] = true;
}
}
void dfs_g(long long u) {
vis[u] = true;
for (auto edge : graph[u]) {
long long v = edge.first;
if (vis[v]) continue;
parent[v] = u;
dfs_g(v);
child[u] += child[v];
}
child[u]++;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
ans_g = 0;
long long n;
cin >> n;
graph.clear();
graph.resize(2 * n + 1);
long long k = 2 * n;
vector<pair<long long, pair<long long, long long>>> edges;
for (long long i = 0; i < k - 1; i++) {
long long u, v, w;
cin >> u >> v >> w;
graph[u].push_back({v, w});
graph[v].push_back({u, w});
edges.push_back({w, {u, v}});
}
connected.clear();
vis.clear();
connected.assign(k + 1, false);
vis.assign(k + 1, false);
dfs(1);
child.assign(k + 1, 0);
parent.assign(k + 1, 0);
vis.assign(k + 1, false);
ans_b = 0;
dfs_g(1);
for (auto edge : edges) {
long long w = edge.first;
long long u = edge.second.first;
long long v = edge.second.second;
long long c1 = child[u], c2 = child[v];
if (v == parent[u]) {
c2 = k - child[u];
} else if (u == parent[v]) {
c1 = k - child[v];
}
long long temp = min(c1, c2) * w;
ans_b += temp;
}
cout << ans_g << " " << ans_b << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, a, b, c;
fscanf(stdin, "%d%d%d%d", &a, &b, &c, &n);
int ans = 0;
for (int i = 1; i <= n; i++) {
int x;
fscanf(stdin, "%d", &x);
if ((b < x) && (x < c)) ans++;
}
fprintf(stdout, "%d\n", ans);
fclose(stdin);
fclose(stdout);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long arr[n];
map<long long, int> s;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (s.find(arr[i]) == s.end())
s.insert({arr[i], 1});
else
s[arr[i]]++;
}
int ans = 0;
for (auto a : s) ans = max(ans, a.second);
cout << (n - ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int a[11], b[11], v[11];
cin >> n >> m;
memset(v, 0, sizeof(v));
for (int i = 0; i < n; ++i) {
cin >> a[i];
v[a[i]]++;
}
for (int i = 0; i < m; ++i) {
cin >> b[i];
v[b[i]]++;
}
for (int i = 1; i <= 9; ++i) {
if (v[i] == 2) {
cout << i << endl;
return 0;
}
}
sort(a, a + n);
sort(b, b + n);
cout << min(a[0], b[0]) << max(a[0], b[0]) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r, r1;
scanf("%d%d%d", &n, &r, &r1);
float x;
x = (float)r1 / (float)(r - r1);
float angle = 2 * asin(x);
float cover = angle * r;
cover = (float)n * cover;
float pi = acos(-1);
if (((float)cover <= (float)(2 * pi * r) || n == 1) && r >= r1)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, i, j, k = 0;
char c;
scanf("%d %d", &n, &n);
char s[50];
gets(s);
for (i = 0; s[i] != '\0'; i++) {
if (s[i] == s[i + 1]) {
for (j = i; s[j] != '\0'; j++) {
s[j] = s[j + 1];
}
i--;
s[j - 1] = '\0';
k++;
}
}
printf("%d", k);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n;
long long x[N];
vector<int> divs[N];
void no() {
cout << "No\n";
exit(0);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 2; i <= n; i += 2) cin >> x[i];
for (int i = 1; i < N; i++) {
for (int j = i; j < N; j += i) {
divs[j].push_back(i);
}
}
long long cursum = 0;
for (int i = 1; i <= n; i += 2) {
x[i] = 1e15;
for (long long dd : divs[x[i + 1]]) {
long long d = dd;
long long e = x[i + 1] / d;
if (d > e) swap(d, e);
if ((e - d) % 2 == 1 || e == d) continue;
long long y = (e + d) / 2;
long long z = e - y;
if (z * z - cursum < x[i] && z * z - cursum > 0) x[i] = z * z - cursum;
}
if (x[i] == 1e15) no();
cursum += x[i] + x[i + 1];
}
cout << "Yes\n";
for (int i = 1; i <= n; i++) {
cout << x[i] << ' ';
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
double cross(pair<double, double> u, pair<double, double> v) {
return u.first * v.second - u.second * v.first;
}
int getSign(double a) {
if (fabs(a) < EPS) {
return 0;
}
return a > 0 ? 1 : -1;
}
pair<double, double> minuss(pair<double, double> a, pair<double, double> b) {
return pair<double, double>(a.first - b.first, a.second - b.second);
}
int main() {
pair<double, double> home, uni;
cin >> home.first >> home.second;
cin >> uni.first >> uni.second;
int cnt = 0;
int n;
cin >> n;
srand(time(NULL));
for (int i = 0; i < n; ++i) {
double a, b, c;
cin >> a >> b >> c;
pair<pair<double, double>, pair<double, double> > line;
if (fabs(a) < EPS || fabs(b) < EPS) {
if (fabs(a) < EPS) {
double y = -c / b;
if (y < max(home.second, uni.second) &&
y > min(home.second, uni.second)) {
cnt++;
}
} else {
double x = -c / a;
if (x < max(home.first, uni.first) && x > min(home.first, uni.first)) {
cnt++;
}
}
} else {
{
double random = rand();
line.first = pair<double, double>(random, (-c - a * random) / b);
}
{
double random = rand();
line.second = pair<double, double>(random, (-c - a * random) / b);
}
int sn1 = getSign(
cross(minuss(line.first, home), minuss(line.second, line.first)));
int sn2 = getSign(
cross(minuss(line.first, uni), minuss(line.second, line.first)));
if (sn1 != sn2) {
cnt++;
}
}
}
cout << cnt << endl;
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.