solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
int cnt = 0;
int flag = 0;
int chk, chk1;
int ar[100];
cin >> x >> y;
int arr[y][2];
for (int i = 1; i <= y; i++) cin >> arr[i][0] >> arr[i][1];
int t1 = arr[1][0];
int t2 = arr[1][1];
int t3 = t1 / t2;
if ((t1 % t2) != 0) {
t3++;
}
int ind = 1;
while (t1 > (arr[1][1] - 1) * t3 && ind < 100) {
for (int i = 1; i <= y; i++) {
if (arr[i][0] <= ((arr[i][1] - 1) * t3) || (arr[i][0] > t3 * arr[i][1])) {
break;
} else if (i == y) {
cnt++;
if (flag == 0) {
chk = x / t3;
if ((x % t3) != 0) chk++;
flag = 1;
} else {
chk1 = x / t3;
if ((x % t3) != 0) chk1++;
}
if (chk == chk1) cnt--;
}
}
t3++;
ind++;
if (cnt >= 2) break;
}
if (cnt >= 2 || (y == 0 && x > 1))
cout << "-1" << endl;
else {
cout << chk;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
string a, b;
cin >> a >> b;
long long zero = 0, zero_zero = 0, one_zero = 0, one = 0;
for (int i = 0; i < n; i++) {
if (b[i] == '0' && a[i] == '1') one_zero++;
if (b[i] == '0' && a[i] == '0') zero_zero++;
if (a[i] == '0') zero++;
if (a[i] == '1') one++;
}
zero -= zero_zero;
one -= one_zero;
cout << zero_zero * one_zero + zero_zero * one + one_zero * zero;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
float n, m, sum;
cin >> n >> m;
sum += ((m * m) - (n * n)) / (2 * n);
cout << fixed << setprecision(13) << sum;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 7, MAX_LOG = 18;
vector<pair<int, long long> > adj[MAXN];
int anc[MAXN][MAX_LOG], height[MAXN];
long long maxWeight[MAXN][MAX_LOG];
int compNum[MAXN];
bitset<MAXN> isPassed;
void dfs(int root, int parent, int comp) {
isPassed[root] = true;
if (parent != -1) {
anc[root][0] = parent;
for (int i = 1; (1 << i) <= height[root]; ++i) {
anc[root][i] = anc[anc[root][i - 1]][i - 1];
maxWeight[root][i] =
max(maxWeight[root][i - 1], maxWeight[anc[root][i - 1]][i - 1]);
}
}
compNum[root] = comp;
for (int i = 0; i < (int)adj[root].size(); ++i) {
int neighbour = adj[root][i].first, w = adj[root][i].second;
if (!isPassed[neighbour]) {
height[neighbour] = height[root] + 1;
maxWeight[neighbour][0] = w;
dfs(neighbour, root, comp);
}
}
return;
}
pair<int, long long> parFinder(int v, int cnt) {
long long maxW = 0;
int comp = 1;
for (int i = 0; comp <= cnt; ++i) {
if (((cnt >> i) & 1) == 1) {
maxW = max(maxW, maxWeight[v][i]);
v = anc[v][i];
}
comp = comp << 1;
}
return make_pair(v, maxW);
}
int BS(int height, int vertexOne, int vertexTwo) {
if (vertexOne == vertexTwo) return 0;
long long maxW = 0;
for (int i = MAX_LOG; i >= 0; --i) {
if (((height >> i) and 1) == 1) {
if (anc[vertexOne][i] != anc[vertexTwo][i]) {
maxW = max(maxW, maxWeight[vertexOne][i]);
maxW = max(maxW, maxWeight[vertexTwo][i]);
vertexOne = anc[vertexOne][i];
vertexTwo = anc[vertexTwo][i];
height -= (1 << i);
}
}
}
maxW = max(maxW, maxWeight[vertexOne][0]);
maxW = max(maxW, maxWeight[vertexTwo][0]);
return maxW;
}
int lca(int v, int u) {
if (height[u] > height[v]) swap(v, u);
pair<int, long long> temp;
temp = parFinder(v, height[v] - height[u]);
long long PAns = BS(height[temp.first], temp.first, u);
return max(PAns, temp.second);
}
int par[MAXN];
int root(int x) {
if (par[x] < 0) {
return x;
} else {
par[x] = root(par[x]);
return par[x];
}
}
bool insert(int v, int u, long long w) {
v = root(v);
u = root(u);
if (v == u) return false;
if (par[v] > par[u]) swap(v, u);
par[v] += par[u];
par[u] = v;
adj[v].push_back(make_pair(u, w));
adj[u].push_back(make_pair(v, w));
return true;
}
vector<pair<long long, pair<int, int> > > edges;
long long kruskal() {
memset(par, -1, sizeof par);
sort(edges.begin(), edges.end());
long long treeWeight = 0;
for (int i = 0; i < (int)edges.size(); ++i) {
long long w = edges[i].first;
int v = edges[i].second.first, u = edges[i].second.second;
if (insert(v, u, w)) treeWeight += w;
}
return treeWeight;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int m, n;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int temp1, temp2, w;
cin >> temp1 >> temp2 >> w;
temp1--;
temp2--;
edges.push_back(make_pair(w, make_pair(temp1, temp2)));
}
long long treeWeight = kruskal();
int compCounter = 0;
for (int i = 0; i < n; ++i) {
if (!isPassed[i]) {
compCounter++;
dfs(i, -1, compCounter);
}
}
int numberOfQueries;
cin >> numberOfQueries;
for (int i = 0; i < numberOfQueries; ++i) {
int x, y;
cin >> x >> y;
x--;
y--;
if (compCounter > 2)
cout << "-1\n";
else if (compCounter > 1 and compNum[x] == compNum[y])
cout << "-1\n";
else if (compCounter > 1 and compNum[x] != compNum[y])
cout << treeWeight << "\n";
else
cout << treeWeight - lca(x, y) << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << "YES\n";
while (n--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << 2 * (a & 1) + (b & 1) + 1 << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], num[100005], vis[100005];
int main() {
set<int> s;
int n, i;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = n - 1; i >= 0; i--) {
s.insert(a[i]);
num[i] = s.size();
}
long long int ans = 0;
for (i = 0; i < n - 1; i++) {
if (!vis[a[i]]) {
vis[a[i]] = 1;
ans += num[i + 1];
}
}
printf("%lld\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int res[1000005];
int cal(int n) {
int res = 0;
for (int i = 0;; i++) {
if ((1 << i) > n) break;
if ((1 << i) & n) continue;
res |= (1 << i);
}
return res;
}
int main() {
int n;
while (cin >> n) {
long long ans = 0;
memset(res, -1, sizeof(res));
for (int i = n; i >= 0; i--) {
if (res[i] != -1) continue;
res[i] = cal(i);
res[cal(i)] = i;
ans += (i ^ cal(i)) << 1;
}
cout << ans << endl;
for (int i = 0; i <= n; i++) printf("%d ", res[i]);
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename A, typename B>
ostream &operator<<(ostream &out, pair<A, B> p) {
return out << '(' << p.first << ", " << p.second << ')';
}
template <typename A,
typename B = typename enable_if<!is_same<A, string>::value,
typename A::value_type>::type>
ostream &operator<<(ostream &out, A vector) {
out << '{';
string sep;
for (B x : vector) out << sep << x, sep = ", ";
return out << '}';
}
void dbg_print() { cerr << endl; }
template <typename A, typename... B>
void dbg_print(A a, B... b) {
cerr << ' ' << a;
dbg_print(b...);
}
inline int to_int(const string &s) {
int x = 0;
for (auto c : s) {
x *= 10;
x += c - '0';
}
return x;
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int n;
cin >> n;
array<set<int>, 2> free_poses;
array<set<int>, 2> bad_poses;
array<vector<string>, 2> free_files;
vector<int> who(n, -1);
auto get_index = [&](const string &s) {
bool ok = true;
ok &= s[0] != '0';
for (auto x : s) {
ok &= isdigit(x);
}
if (!ok) return -1;
int x = to_int(s) - 1;
if (0 <= x && x < n) return x;
return -1;
};
set<string> names;
int pretests = 0;
for (int i = 0; i < n; i++) {
string name;
int type;
cin >> name >> type;
names.insert(name);
pretests += type;
int id = get_index(name);
if (id == -1) {
free_files[type].push_back(name);
} else {
who[id] = type;
}
}
for (int i = 0; i < pretests; i++) {
if (who[i] == 1) continue;
if (who[i] == -1) {
free_poses[1].insert(i);
} else {
bad_poses[1].insert(i);
}
}
for (int i = pretests; i < n; i++) {
if (who[i] == 0) continue;
if (who[i] == -1) {
free_poses[0].insert(i);
} else {
bad_poses[0].insert(i);
}
}
vector<pair<string, string>> ans;
if (((int)((free_poses[0]).size())) + ((int)((free_poses[1]).size())) == 0 &&
((int)((bad_poses[0]).size())) + ((int)((bad_poses[1]).size())) > 0) {
for (int i = 0; i < 2; i++) {
if (!((int)((bad_poses[i]).size()))) continue;
int who = *bad_poses[i].begin();
bad_poses[i].erase(bad_poses[i].begin());
string name(6, 'a');
while (names.count(name)) {
for (auto &x : name) {
x = 'a' + rand() % 26;
}
}
ans.emplace_back(to_string(who + 1), name);
free_files[i ^ 1].push_back(name);
free_poses[i].insert(who);
break;
}
}
while (true) {
bool any = false;
for (int i = 0; i < 2; i++) {
if (!((int)((free_poses[i]).size())) ||
!((int)((bad_poses[i ^ 1]).size())))
continue;
any = true;
int to = *free_poses[i].begin();
free_poses[i].erase(free_poses[i].begin());
int from = *bad_poses[i ^ 1].begin();
bad_poses[i ^ 1].erase(bad_poses[i ^ 1].begin());
free_poses[i ^ 1].insert(from);
ans.emplace_back(to_string(from + 1), to_string(to + 1));
break;
}
if (!any) break;
}
for (int i = 0; i < 2; i++) {
assert(((int)((free_files[i]).size())) == ((int)((free_poses[i]).size())));
while (((int)((free_files[i]).size()))) {
string from = free_files[i].back();
free_files[i].pop_back();
int pos = *free_poses[i].begin();
free_poses[i].erase(free_poses[i].begin());
ans.emplace_back(from, to_string(pos + 1));
}
}
cout << ((int)((ans).size())) << '\n';
for (auto [s, t] : ans) {
cout << "move " << s << ' ' << t << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int f[1010][32][32][32][2], n, h, mo = 1e9 + 9;
int main() {
scanf("%d%d", &n, &h);
memset(f, 0x00, sizeof f);
f[0][0][0][0][0] = 1;
for (int i = 1; i <= n; i++)
for (int k1 = 0; k1 <= h; k1++)
for (int k2 = k1; k2 <= h; k2++)
for (int k3 = k2; k3 <= h; k3++) {
if (k1 != h)
f[i][1][min(k2 + 1, h)][min(k3 + 1, h)][0] =
(f[i][1][min(h, k2 + 1)][min(h, k3 + 1)][0] +
f[i - 1][k1][k2][k3][0]) %
mo;
else
f[i][1][min(k2 + 1, h)][min(k3 + 1, h)][1] =
(f[i][1][min(h, k2 + 1)][min(h, k3 + 1)][1] +
f[i - 1][k1][k2][k3][0]) %
mo;
if (k2 != h)
f[i][1][min(k1 + 1, h)][min(k3 + 1, h)][0] =
(f[i][1][min(k1 + 1, h)][min(k3 + 1, h)][0] +
f[i - 1][k1][k2][k3][0]) %
mo;
else
f[i][1][min(k1 + 1, h)][min(k3 + 1, h)][1] =
(f[i][1][min(k1 + 1, h)][min(k3 + 1, h)][1] +
f[i - 1][k1][k2][k3][0]) %
mo;
if (k3 != h)
f[i][1][min(k1 + 1, h)][min(k2 + 1, h)][0] =
(f[i][1][min(k1 + 1, h)][min(k2 + 1, h)][0] +
f[i - 1][k1][k2][k3][0]) %
mo;
else
f[i][1][min(k1 + 1, h)][min(k2 + 1, h)][1] =
(f[i][1][min(k1 + 1, h)][min(k2 + 1, h)][1] +
f[i - 1][k1][k2][k3][0]) %
mo;
f[i][min(k1 + 1, h)][min(k2 + 1, h)][min(k3 + 1, h)][0] =
(f[i][min(k1 + 1, h)][min(k2 + 1, h)][min(k3 + 1, h)][0] +
f[i - 1][k1][k2][k3][0]) %
mo;
if (k1 != h)
f[i][min(k2 + 1, h)][min(k3 + 1, h)][h][0] =
(f[i][min(k2 + 1, h)][min(k3 + 1, h)][h][0] +
f[i - 1][k1][k2][k3][1]) %
mo;
else
f[i][min(k2 + 1, h)][min(k3 + 1, h)][h][1] =
(f[i][min(k2 + 1, h)][min(k3 + 1, h)][h][1] +
f[i - 1][k1][k2][k3][1]) %
mo;
if (k2 != h)
f[i][min(k1 + 1, h)][min(k3 + 1, h)][h][0] =
(f[i][min(k1 + 1, h)][min(k3 + 1, h)][h][0] +
f[i - 1][k1][k2][k3][1]) %
mo;
else
f[i][min(k1 + 1, h)][min(k3 + 1, h)][h][1] =
(f[i][min(k1 + 1, h)][min(k3 + 1, h)][h][1] +
f[i - 1][k1][k2][k3][1]) %
mo;
if (k3 != h)
f[i][min(k1 + 1, h)][min(k2 + 1, h)][h][0] =
(f[i][min(k1 + 1, h)][min(k2 + 1, h)][h][0] +
f[i - 1][k1][k2][k3][1]) %
mo;
else
f[i][min(k1 + 1, h)][min(k2 + 1, h)][h][1] =
(f[i][min(k1 + 1, h)][min(k2 + 1, h)][h][1] +
f[i - 1][k1][k2][k3][1]) %
mo;
f[i][min(k1 + 1, h)][min(k2 + 1, h)][min(k3 + 1, h)][1] =
(f[i][min(k1 + 1, h)][min(k2 + 1, h)][min(k3 + 1, h)][1] +
f[i - 1][k1][k2][k3][1]) %
mo;
}
int ans = 0;
for (int i = 0; i <= h; i++)
for (int j = i; j <= h; j++)
for (int k = j; k <= h; k++) {
ans = (ans + f[n][i][j][k][0]) % mo;
if (i != h || j != h || k != h) ans = (ans + f[n][i][j][k][1]) % mo;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int l, r;
int main() {
scanf("%d%d", &l, &r);
if (l == r)
printf("%d", l);
else
puts("2");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long ans = -((long long)1 << 62);
int n, u, r;
int a[105];
int b[105];
int k[105];
int p[105];
void process(int m, int op) {
if (((u - m) & 1) == 0) {
long long an = 0;
for (int i = 1; i <= n; i++) an += a[i] * k[i];
ans = max(an, ans);
}
if (m == u) {
return;
}
if (op == 0) {
for (int i = 1; i <= n; i++) a[i] ^= b[i];
process(m + 1, 1);
for (int i = 1; i <= n; i++) a[i] ^= b[i];
}
vector<int> a1;
a1.push_back(1);
for (int i = 1; i <= n; i++) a1.push_back(a[i]);
for (int i = 1; i <= n; i++) a[i] = a1[p[i]] + r;
process(m + 1, 0);
for (int i = 1; i <= n; i++) a[i] = a1[i];
}
int main() {
scanf("%d %d %d", &n, &u, &r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) scanf("%d", &k[i]);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
process(0, 0);
printf("%I64d", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int V = 1200;
struct Point {
int x, y, id, flag;
Point() {}
Point(int x, int y) : x(x), y(y) {}
Point operator-(const Point& p) const { return Point(x - p.x, y - p.y); }
} p[V], tmp[V];
int n, id[V][V], ct[V][V];
int AB(int x) {
if (x < 0) return -x;
return x;
}
bool Less(Point x, Point y) {
return (long long)x.x * y.y < (long long)x.y * y.x;
}
bool cmp(Point x, Point y) { return Less(y, x); }
int N, M, po[V], id2[V][V];
void init() {
int i, j, top, tail, un, dn;
for (i = 0; i < N; i++) {
un = 0;
dn = n - 2;
for (j = 0; j < n; j++) {
if (i == j) continue;
if (p[j].y >= p[i].y) {
tmp[un].x = p[j].x - p[i].x;
tmp[un].y = p[j].y - p[i].y;
tmp[un].id = p[j].id;
tmp[un].flag = p[j].flag;
un++;
} else {
tmp[dn].x = p[j].x - p[i].x;
tmp[dn].y = p[j].y - p[i].y;
tmp[dn].id = p[j].id;
tmp[dn].flag = p[j].flag;
dn--;
}
}
sort(tmp, tmp + un, cmp);
sort(tmp + dn + 1, tmp + n - 1, cmp);
top = 0;
for (j = 0; j < n - 1; j++) {
id[i][tmp[j].id] = top;
id2[i][tmp[j].id] = j;
if (tmp[j].flag == 0) top++;
po[j] = tmp[j].id;
}
top = 0;
tail = 1;
bool C = false;
for (top = 0; top < n - 1; top++) {
while (Less(tmp[tail], tmp[top]) || ((!C) && top == tail)) {
tail++;
if (tail == n - 1) {
tail = 0;
C = true;
}
}
if (C)
ct[i][tmp[top].id] = id[i][po[tail]] + M - id[i][po[top]];
else
ct[i][tmp[top].id] = id[i][po[tail]] - id[i][po[top]];
}
}
}
int d(int x, int y, int z) {
if (id2[x][y] < id2[x][z])
return id[x][z] - id[x][y];
else
return M + id[x][z] - id[x][y];
}
int Cal(int x, int y, int z) {
int ret = 0;
if (Less(p[z] - p[x], p[y] - p[x]))
ret += d(x, y, z) + ct[z][y];
else
ret += d(x, z, y) + ct[y][z];
if (Less(p[z] - p[y], p[x] - p[y]))
ret += d(y, x, z) + ct[z][x];
else
ret += d(y, z, x) + ct[x][z];
if (Less(p[y] - p[z], p[x] - p[z]))
ret += d(z, x, y) + ct[y][x];
else
ret += d(z, y, x) + ct[x][y];
ret -= 2 * M;
return ret;
}
int _, ca, i, j, k;
int main() {
while (~scanf("%d%d", &N, &M)) {
for (i = 0; i < N; i++) scanf("%d%d", &p[i].x, &p[i].y);
for (i = 0; i < N; i++) p[i].flag = 1;
for (i = 0; i < M; i++) scanf("%d%d", &p[i + N].x, &p[i + N].y);
for (i = 0; i < M; i++) p[i + N].flag = 0;
if (N < 3) {
puts("0");
continue;
}
if (M == 0) {
printf("%d\n", N * (N - 1) * (N - 2) / 6);
continue;
}
n = N + M;
for (i = 0; i < n; i++) p[i].id = i;
init();
int ans = 0;
for (i = 0; i < N; i++)
for (j = i + 1; j < N; j++)
for (k = j + 1; k < N; k++)
if (Cal(i, j, k) == 0) ans++;
printf("%d\n", ans);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int nofQs;
cin >> nofQs;
int minSec = INT_MAX;
vector<int> custs(nofQs);
for (int i = 0; i < nofQs; i++) {
cin >> custs[i];
}
for (int i = 0; i < nofQs; i++) {
int tAmt = 0;
for (int j = 0; j < custs[i]; j++) {
int nofItems;
cin >> nofItems;
tAmt += (nofItems * 5);
tAmt += 15;
}
minSec = min(tAmt, minSec);
}
cout << minSec;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[5005][5005];
int pre[5005][5005];
vector<pair<int, int> > V[5005];
int n, m, T;
struct Node {
int x;
int step;
int t;
};
void bfs() {
Node nd;
nd.x = 1;
nd.step = 1;
nd.t = 0;
dp[1][1] = 0;
queue<Node> Q;
Q.push(nd);
while (!Q.empty()) {
nd = Q.front();
Q.pop();
int x = nd.x;
int step = nd.step + 1;
int t = nd.t;
for (int i = 0; i < V[x].size(); ++i) {
int w = V[x][i].first;
int ttt = t + V[x][i].second;
if (ttt <= 1000000000)
if (dp[w][step] > ttt || dp[w][step] == -1) {
pre[w][step] = x;
dp[w][step] = ttt;
Node tmp;
tmp.x = w;
tmp.step = step;
tmp.t = ttt;
Q.push(tmp);
}
}
}
int mx = 0;
int index = -1;
for (int i = 0; i <= 5000; ++i) {
if (dp[n][i] != -1 && dp[n][i] <= T) {
mx = max(mx, i);
}
}
cout << mx << endl;
vector<int> ans;
ans.push_back(n);
int tx = dp[n][mx];
int point = n;
while (pre[point][mx] != -1) {
ans.push_back(pre[point][mx]);
point = pre[point][mx];
mx--;
}
for (int i = ans.size() - 1; i >= 0; --i) {
cout << ans[i] << " ";
}
cout << endl;
}
int main() {
memset(dp, -1, sizeof dp);
memset(pre, -1, sizeof pre);
cin >> n >> m >> T;
while (m--) {
int a, b, c;
cin >> a >> b >> c;
V[a].push_back(make_pair(b, c));
}
bfs();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int pribor, guests, max_ = -1;
cin >> pribor >> guests;
int A[pribor];
int B[100];
for (int i = 0; i < 100; i++) {
B[i] = 0;
}
for (int i = 0; i < pribor; i++) {
cin >> A[i];
B[A[i] - 1]++;
}
int razn = 0;
for (int i = 0; i < 100; i++) {
if (B[i] > max_) {
max_ = B[i];
}
if (B[i] != 0) {
razn++;
}
}
if (max_ <= guests) {
cout << razn * guests - pribor;
} else {
if (max_ % guests == 0) {
int vsego = max_ / guests;
cout << vsego * guests * razn - pribor;
} else {
int vsego = max_ / guests + 1;
cout << vsego * guests * razn - pribor;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(int first) {
return first ? 8 * sizeof(int) - __builtin_clz(first) : 0;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
class TaskC {
public:
void solve(istream& cin, ostream& cout) {
int N, K;
cin >> N >> K;
vector<int> A(N);
cin >> A;
sort(A.begin(), A.end());
vector<int> D(1e6 + 1, 0);
for (int i = 0; i < N; ++i) {
for (int j = i + 1; j < N; ++j) {
D[A[j] - A[i]]++;
}
}
vector<int> E(1e6 + 1, 0);
for (int i = 1; i <= 1e6; ++i) {
for (int j = i; j <= 1e6; j += i) {
E[i] += D[j];
}
}
for (int i = N - K; i <= 1e6; ++i) {
if (E[i] <= K * (K + 1) / 2) {
unordered_set<int> S;
int c = 0;
for (int a : A) {
int b = a % i;
if (!S.insert(b).second && ++c > K) break;
}
if (c <= K) {
cout << i << endl;
return;
}
}
}
cout << int(1e6 + 1) << '\n';
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
TaskC solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 10;
int t, n, a[mx];
vector<int> res;
int main() {
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n / 2; i++) {
res.push_back(a[i]);
res.push_back(a[n - 1 - i]);
}
if (n % 2) res.push_back(a[(n / 2)]);
reverse(res.begin(), res.end());
for (int i = 0; i < n; i++) cout << res[i] << " ";
cout << endl;
res.clear();
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define ll long long
#define fi first
#define se second
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, a, b, sol = 0;
cin >> n;
vector<pair<pair<int, int>, pair<int, int>>> vp; // smaller, bigger, turned, id
for (int i = 1; i <= n; i++) {
cin >> a >> b;
if (min(a, b) > n) {
cout << -1 << "\n";
return 0;
}
if (a < b) vp.push_back({{a, b}, {1, i}});
else vp.push_back({{b, a}, {2, i}});
}
sort(vp.begin(), vp.end());
vector<int> minL(n), maxR(n);
minL[0] = vp[0].fi.se;
maxR[n - 1] = vp[n - 1].fi.se;
for (int i = 1; i < n; i++) minL[i] = min(minL[i - 1], vp[i].fi.se);
for (int i = n - 2; i >= 0; i--) maxR[i] = max(maxR[i + 1], vp[i].fi.se );
vector<int> points;
points.push_back(0);
for (int i = 1; i < n; i++) {
if (minL[i - 1] > maxR[i]) points.push_back(i);
}
points.push_back(n);
vector<int> st(n);
for (int i = 0; i < points.size() - 1; i++) {
int lt = points[i];
int rt = points[i + 1] - 1;
int min1 = n * 3, min2 = n * 3;
for (int j = lt; j <= rt; j++) {
if (vp[j].fi.se < min1) {
st[j] = 1;
min1 = vp[j].fi.se;
}
else if (vp[j].fi.se < min2) {
st[j] = 2;
min2 = vp[j].fi.se;
}
else {
cout << -1 << "\n";
return 0;
}
}
int cnt = 0;
for (int j = lt; j <= rt; j++) {
if (st[j] != vp[j].se.fi) cnt++;
}
sol += min(cnt, rt - lt + 1 - cnt);
}
cout << sol << "\n";
// for (auto e : points) cout << e << " ";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
int n, cnt1, cnt2;
char s[100005];
int main() {
scanf("%d", &n);
scanf("%s", s);
for (int i = (int)(0); i <= (int)(n - 1); ++i) {
if (s[i] == 'D')
++cnt1;
else
++cnt2;
}
if (cnt1 > cnt2)
puts("Danik");
else if (cnt2 > cnt1)
puts("Anton");
else
puts("Friendship");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dist[200003];
int visited[200003];
vector<pair<long long, long long>> adj[200003];
int main() {
int n, m;
cin >> n >> m;
long long u, v, g;
long long arr[200003];
for (int i = 0; i < m; i++) {
cin >> u >> v >> g;
adj[u].push_back(make_pair(v, 2 * g));
adj[v].push_back(make_pair(u, 2 * g));
}
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
for (int i = 1; i <= n; i++) {
q.push(make_pair(arr[i], i));
dist[i] = arr[i];
}
while (!q.empty()) {
pair<long long, long long> p = q.top();
long long x = p.second;
q.pop();
if (p.first <= dist[x])
;
else
continue;
for (auto it : adj[x]) {
long long nd = it.second;
if (dist[it.first] > dist[x] + nd) {
dist[it.first] = dist[x] + nd;
q.push(make_pair(dist[it.first], it.first));
}
}
}
for (int i = 1; i <= n; i++) {
cout << dist[i] << " ";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e16 + 10;
bool cmp;
inline long long div(long long a, int b) { return a / b - (a < 0 && a % b); }
struct Line {
mutable int k;
mutable long long b, xr;
bool operator<(const Line &n) const { return cmp ? xr < n.xr : k < n.k; }
void isect(const Line &n) const {
if (k == n.k) {
xr = (b > n.b) ? INF : -INF;
} else {
xr = div(b - n.b, n.k - k);
}
}
void display() const { printf("y = %dx + %I64d, xr = %I64d\n", k, b, xr); }
};
struct LowConvHull : public multiset<Line> {
void ins(const Line &l) {
iterator m = insert(l), n = m++;
for (; m != end();) {
n->isect(*m);
if (n->xr >= m->xr) {
m = erase(m);
} else {
break;
}
}
if (m == end()) {
n->xr = INF;
}
if (n == begin()) {
return;
}
(--(m = n))->isect(*n);
if (m->xr >= n->xr) {
n = erase(n);
m->isect(*n);
return;
}
for (; (n = m) != begin() && (--m)->xr >= n->xr;) {
n = erase(n);
m->isect(*n);
}
if (m == begin() && m->xr == -INF) {
erase(m);
}
}
long long query(int x) {
cmp = 1;
Line l = *lower_bound((Line){0, 0, x});
cmp = 0;
return 1LL * l.k * x + l.b;
}
void display() {
printf("Lower Convex Hull:\n");
for (Line l : *this) {
l.display();
}
printf("over\n");
}
};
struct Edge {
int ed, nxt;
};
const int maxn = 1e5 + 10;
int n, cnt;
LowConvHull lch;
int a[maxn], b[maxn], hed[maxn], sz[maxn];
long long dp[maxn];
Edge e[maxn << 1];
inline void addEdge(int u, int v) {
e[cnt].ed = v;
e[cnt].nxt = hed[u];
hed[u] = cnt++;
}
void DFS1(int u, int p) {
int i, v;
sz[u] = 1;
for (i = hed[u]; i != -1; i = e[i].nxt) {
v = e[i].ed;
if (v == p) {
continue;
}
DFS1(v, u);
sz[u] += sz[v];
}
}
void DFS2(int u, int p, LowConvHull &lch) {
int i, v, maxt = 0;
LowConvHull tlch;
for (i = hed[u]; i != -1; i = e[i].nxt) {
v = e[i].ed;
if (v != p && sz[v] > sz[maxt]) {
maxt = v;
}
}
if (sz[u] == 1) {
dp[u] = 0;
} else {
DFS2(maxt, u, lch);
for (i = hed[u]; i != -1; i = e[i].nxt) {
v = e[i].ed;
if (v == p || v == maxt) {
continue;
}
tlch.clear();
DFS2(v, u, tlch);
for (Line l : tlch) {
lch.ins((Line){l.k, l.b, -INF});
}
}
dp[u] = -lch.query(a[u]);
}
lch.ins((Line){-b[u], -dp[u], -INF});
}
int main() {
int i, j, k, u, v;
scanf("%d", &n);
for (i = (1); i <= (n); i++) {
scanf("%d", &a[i]);
}
for (i = (1); i <= (n); i++) {
scanf("%d", &b[i]);
}
memset(hed, -1, sizeof(hed));
for (i = (1); i <= (n - 1); i++) {
scanf("%d%d", &u, &v);
addEdge(u, v);
addEdge(v, u);
}
DFS1(1, 0);
DFS2(1, 0, lch);
for (i = (1); i <= (n - 1); i++) {
printf("%I64d ", dp[i]);
}
printf("%I64d\n", dp[n]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int getint() {
int s = 0, o = 1;
char c;
for (c = getchar(); c < '0' || c > '9'; c = getchar())
if (c == '-') o = -1;
for (; c >= '0' && c <= '9'; c = getchar()) s *= 10, s += c - '0';
return s * o;
}
const int maxn = 100010, B = 300, maxm = 2000010;
int a[maxn], pr[maxm], d[maxn];
vector<int> factor[maxn], p, st[maxm];
vector<int> e[maxn];
pair<int, int> res[maxn];
int n;
void pre() {
for (int i = 2; i <= 2000; ++i) {
if (!pr[i]) {
p.push_back(i);
for (int j = i + i; j <= 2000; j += i) pr[j] = 1;
}
}
}
void fac(int n, vector<int> &v) {
v.clear();
for (int i = 0; i < p.size(); i++)
if (p[i] * p[i] <= n) {
if (n % p[i] == 0) {
v.push_back(p[i]);
while (n % p[i] == 0) n /= p[i];
}
} else
break;
if (n > 1) v.push_back(n);
}
void dfs(int u, int F) {
int v, pr;
res[u] = make_pair(0, -1);
for (int i = 0; i < factor[u].size(); i++) {
pr = factor[u][i];
if (st[pr].size() && res[u].first < d[st[pr].back()])
res[u] = make_pair(d[st[pr].back()], st[pr].back());
st[pr].push_back(u);
}
for (int i = 0; i < e[u].size(); i++)
if (e[u][i] != F) {
d[e[u][i]] = d[u] + 1;
dfs(e[u][i], u);
}
for (int i = 0; i < factor[u].size(); i++) {
pr = factor[u][i];
st[pr].pop_back();
}
}
int main(int argc, char const *argv[]) {
int x, y, que, o, u, ans;
pre();
n = getint(), que = getint();
for (int i = 1; i < 1 + n; i++) fac(a[i] = getint(), factor[i]);
for (int i = 0; i < n - 1; i++) {
x = getint(), y = getint();
e[x].push_back(y), e[y].push_back(x);
}
d[1] = 1;
dfs(1, 0);
for (int qq = 0; qq < que; qq++) {
o = getint();
if (o == 1) {
ans = res[getint()].second;
printf("%d\n", ans ? ans : -1);
} else {
x = getint();
fac(a[x] = getint(), factor[x]);
dfs(1, 0);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
char c = getchar();
int x = 0;
for (; c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) + c - '0';
return x;
}
const int N = 2e5 + 5, L = 50;
const long long inf = 1e16;
struct node {
int x1, x2, y1, y2, id;
} a[N];
bool cmp1(node a, node b) {
if (max(a.x1, a.x2) == max(b.x1, b.x2)) return a.id < b.id;
return max(a.x1, a.x2) > max(b.x1, b.x2);
}
bool cmp2(node a, node b) { return a.id < b.id; }
int n, m, q, to[L + 2][N], cov[N << 2];
long long t[N], dis[L + 2][N];
const int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
void build(int x = 1, int l = -1, int r = m + 1) {
cov[x] = 0;
if (l == r) return;
int mid = l + r >> 1;
build((x << 1), l, mid), build((x << 1 | 1), mid + 1, r);
}
void update(int sl, int sr, int w, int x = 1, int l = -1, int r = m + 1) {
if (sl <= l && r <= sr) {
cov[x] = w;
return;
}
if (cov[x]) cov[(x << 1)] = cov[(x << 1 | 1)] = cov[x];
int mid = l + r >> 1;
if (sl <= mid) update(sl, sr, w, (x << 1), l, mid);
if (sr > mid) update(sl, sr, w, (x << 1 | 1), mid + 1, r);
cov[x] = (cov[(x << 1)] == cov[(x << 1 | 1)] ? cov[(x << 1)] : 0);
}
int query(int s, int x = 1, int l = -1, int r = m + 1) {
if (cov[x] || l == r) return cov[x];
int mid = l + r >> 1;
return s <= mid ? query(s, (x << 1), l, mid)
: query(s, (x << 1 | 1), mid + 1, r);
}
void transform() {
for (int i = 1; i <= n + q; ++i) {
swap(a[i].x1, a[i].y1), a[i].x1 = m - a[i].x1;
swap(a[i].x2, a[i].y2), a[i].x2 = m - a[i].x2;
}
}
inline char getdir(node a) {
if (a.x1 > a.x2) return 0;
if (a.x1 < a.x2) return 1;
if (a.y1 > a.y2) return 2;
if (a.y1 < a.y2) return 3;
}
inline bool have(int l1, int r1, int l2, int r2) {
if (l1 > r1) swap(l1, r1);
if (l2 > r2) swap(l2, r2);
if (l2 <= l1 && l1 <= r2) return true;
if (l2 <= r1 && r1 <= r2) return true;
return false;
}
inline int getdis(node a, node b) {
if (getdir(a) < 2 && getdir(b) < 2 && have(a.x1, a.x2, b.x1, b.x2)) return 0;
if (getdir(a) > 1 && getdir(b) > 1 && have(a.y1, a.y2, b.y1, b.y2)) return 0;
switch (getdir(a)) {
case 0:
return a.x2 - max(b.x1, b.x2);
case 1:
return min(b.x1, b.x2) - a.x2;
case 2:
return a.y2 - max(b.y1, b.y2);
case 3:
return min(b.y1, b.y2) - a.y2;
}
}
inline int odis(node a, node b) { return abs(a.x2 - b.x2) + abs(a.y2 - b.y2); }
void move(int& x, int& y, int d, int t) { x += t * dx[d], y += t * dy[d]; }
int main() {
n = gi(), m = gi();
for (int i = 1; i <= n; ++i)
a[i].x1 = gi(), a[i].y1 = gi(), a[i].x2 = gi(), a[i].y2 = gi(), a[i].id = i;
q = gi();
for (int i = 1; i <= q; ++i) {
int x = gi(), y = gi(), nx, ny;
char op[2];
scanf("%s%lld", op, &t[i]);
if (op[0] == 'L') nx = x + 1, ny = y;
if (op[0] == 'R') nx = x - 1, ny = y;
if (op[0] == 'U') nx = x, ny = y - 1;
if (op[0] == 'D') nx = x, ny = y + 1;
a[n + i] = (node){nx, x, ny, y, i + n};
}
for (int T = 1; T <= 4; transform(), ++T) {
sort(a + 1, a + 1 + n + q, cmp1), build();
for (int i = 1; i <= n + q; ++i) {
if (a[i].x1 < a[i].x2) {
int now = query(a[i].y1);
to[0][a[i].id] = a[now].id;
dis[0][a[i].id] = odis(a[i], a[now]);
}
if (a[i].id <= n) update(min(a[i].y1, a[i].y2), max(a[i].y1, a[i].y2), i);
}
}
for (int i = 1; i <= L; ++i)
for (int j = 1; j <= n + q; ++j) {
to[i][j] = to[i - 1][to[i - 1][j]];
dis[i][j] = min(inf, dis[i - 1][j] + dis[i - 1][to[i - 1][j]]);
}
sort(a + 1, a + 1 + n + q, cmp2);
for (int i = 1; i <= q; ++i) {
int u = n + i;
for (int j = L; ~j; --j)
if (to[j][u] && t[i] >= dis[j][u]) t[i] -= dis[j][u], u = to[j][u];
int x = a[u].x2, y = a[u].y2;
if (!to[0][u]) {
move(x, y, getdir(a[u]), min(t[i], 1ll * m));
x = max(x, 0), x = min(x, m);
y = max(y, 0), y = min(y, m);
printf("%d %d\n", x, y);
continue;
}
node nxt = a[to[0][u]];
int d = getdis(a[u], nxt);
if (d > t[i])
move(x, y, getdir(a[u]), t[i]);
else {
t[i] -= d;
move(x, y, getdir(a[u]), d);
move(x, y, getdir(nxt), t[i]);
}
printf("%d %d\n", x, y);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10, modd = 1e9 + 7, inf = 0x3f3f3f3f, INF = 0x7fffffff,
hmod1 = 0x48E2DCE7, hmod2 = 0x60000005;
const int dir[4][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
const double eps = 1e-8;
template <class T>
inline void scand(T &x) {
char c;
x = 0;
while ((c = getchar()) < '0')
;
while (c >= '0' && c <= '9') x = x * 10 + (c - 48), c = getchar();
}
inline long long min(long long a, long long b) { return a < b ? a : b; }
inline long long max(long long a, long long b) { return a > b ? a : b; }
inline long long gcd(long long a, long long b) {
return b == 0 ? a : gcd(b, a % b);
}
inline long long exgcd(long long a, long long b, long long &x, long long &y) {
long long d;
(b == 0 ? (x = 1, y = 0, d = a)
: (d = exgcd(b, a % b, y, x), y -= a / b * x));
return d;
}
inline long long qpow(long long a, long long n) {
long long sum = 1;
while (n) {
if (n & 1) sum = sum * a % modd;
a = a * a % modd;
n >>= 1;
}
return sum;
}
inline long long qmul(long long a, long long n) {
long long sum = 0;
while (n) {
if (n & 1) sum = (sum + a) % modd;
a = (a + a) % modd;
n >>= 1;
}
return sum;
}
inline long long inv(long long a) { return qpow(a, modd - 2); }
inline long long madd(long long a, long long b) {
return (a % modd + b % modd) % modd;
}
inline long long mmul(long long a, long long b) { return a % modd * b % modd; }
inline void uadd(long long &a, long long b) { a = madd(a, b); }
inline void umul(long long &a, long long b) { a = mmul(a, b); }
long long l, p, num[maxn], len[2], tl[maxn], tr[maxn], ans[2][maxn];
long long get_next() {
long long pp = p + 1;
while (pp < l && num[pp + 1] == 0) pp++;
return pp;
}
int cmp() {
for (int i = len[0]; i >= 1; i--) {
if (ans[0][i] < ans[1][i])
return 0;
else if (ans[1][i] < ans[0][i])
return 1;
}
return 0;
}
void calc(long long k, int id) {
memset(tl, 0, sizeof(tl));
memset(tr, 0, sizeof(tr));
long long pl = 0, pr = 0, t = 0;
len[id] = max(k, l - k) + 1;
for (int i = k; i >= 1; i--) tl[++pl] = num[i];
for (int i = l; i > k; i--) tr[++pr] = num[i];
for (int i = 1; i <= len[id]; i++) {
long long res = tl[i] + tr[i] + t;
ans[id][i] = res % 10;
t = res / 10;
}
}
void print(int id, long long len) {
while (ans[id][len] == 0) len--;
for (int i = len; i >= 1; i--) printf("%I64d", ans[id][i]);
putchar('\n');
}
int main() {
cin >> l;
for (int i = 1; i <= l; i++) scanf("%1I64d", &num[i]);
p = 0;
while (p <= l) {
long long np = get_next();
if (abs(l - 2 * np) < abs(l - 2 * p))
p = np;
else {
calc(p, 0);
calc(np, 1);
if (len[0] != len[1]) {
if (len[0] < len[1])
print(0, len[0]);
else
print(1, len[1]);
} else {
int id = cmp();
print(id, len[id]);
}
break;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int parent[100010];
int son[100010];
int aux[100010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int j = 0; j < k; j++) {
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", &aux[i]);
for (int i = 0; i < m - 1; i++) {
parent[aux[i]] = aux[i + 1];
son[aux[i + 1]] = aux[i];
}
}
int ans = 0;
for (int i = 1; i < n; i++) {
if (parent[i] == i + 1) continue;
int j = i;
while (parent[j] != 0) {
int a = parent[j];
son[parent[j]] = 0;
parent[j] = 0;
ans++;
j = a;
}
ans++;
if (son[i + 1] != 0) {
j = son[i + 1];
while (parent[j] != 0) {
int a = parent[j];
son[parent[j]] = 0;
parent[j] = 0;
ans++;
j = a;
}
}
if (parent[i + 1] != 0) {
j = i + 1;
while (parent[j] != 0) {
int a = parent[j];
son[parent[j]] = 0;
parent[j] = 0;
ans++;
j = a;
}
}
parent[i] = i + 1;
son[i + 1] = i;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a, cost1[1000005], cost2[1000005], cost, x, sol1, sol3, sol2, sol4, b, t,
i, st, dr, p, m, xx;
string s;
int main() {
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
cin >> n >> a >> b >> t;
cin >> s;
cost = 1;
if (s[0] == 'w') cost += b;
if (cost <= t) sol1 = sol2 = 1;
for (i = 1; i < n; i++) {
if (i) cost1[i] = 1 + a + cost1[i - 1];
if (s[i] == 'w') cost1[i] += b;
if (cost1[i] + cost <= t) sol1++;
}
x = n;
s += s;
n += n;
for (i = x - 1; i; i--) {
if (i != x) cost2[x - i] = 1 + a + cost2[x - i - 1];
if (s[i] == 'w') cost2[x - i] += b;
if (cost2[x - i] + cost <= t) sol2++;
}
cost = 0;
for (i = x; i; i--) {
cost++;
if (s[i] == 'w') cost += b;
st = 0;
dr = x - 1;
xx = t - cost - (x - i) * a;
p = 0;
if (xx > 0)
while (st <= dr) {
m = (st + dr) / 2;
if (cost1[m] <= xx) {
p = m;
st = m + 1;
} else
dr = m - 1;
}
if (cost <= t) sol3 = max(sol3, x - i + 1 + p);
cost += a;
}
cost = 0;
for (i = x; i < n; i++) {
cost++;
if (s[i] == 'w') cost += b;
st = 0;
p = 0;
dr = x - 1;
xx = t - cost - (i - x) * a;
if (xx > 0)
while (st <= dr) {
m = (st + dr) / 2;
if (cost2[m] <= xx) {
p = m;
st = m + 1;
} else
dr = m - 1;
}
if (cost <= t) sol4 = max(sol4, i - x + 1 + p);
cost += a;
}
cout << min(x, max(max(sol1, sol2), max(sol3, sol4)));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, num;
scanf("%d %d %d", &n, &m, &k);
string sol = "";
for (int i = 0; i < n - 1; i++) sol.append("D");
for (int i = 0; i < m - 1; i++) sol.append("L");
string up = "";
for (int i = 0; i < n - 1; i++) up.append("U");
string down = "";
for (int i = 0; i < n - 1; i++) down.append("D");
for (int i = 0; i < m; i++) {
if (i % 2)
sol.append(down);
else
sol.append(up);
sol.append("R");
}
num = n - 1 + m - 1 + n * m;
printf("%d\n", num);
cout << sol;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, count = 0;
cin >> n;
while (n--) {
int a, b;
cin >> a >> b;
if (b - a >= 2) count += 1;
}
cout << count;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long x[5005], a[5005], b[5005], c[5005], d[5005];
long long dis[5005][5005] = {0};
long long pre[5005];
long long get_dis(long long i, long long j) {
long long anss = abs(x[i] - x[j]);
if (j < i)
anss += (c[i] + b[j]);
else
anss += (d[i] + a[j]);
return anss;
}
int main() {
long long n, s, e;
scanf("%lld%lld%lld", &n, &s, &e);
long long i, j;
for (i = 1; i <= n; i++) scanf("%lld", &x[i]);
for (i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (i = 1; i <= n; i++) scanf("%lld", &b[i]);
for (i = 1; i <= n; i++) scanf("%lld", &c[i]);
for (i = 1; i <= n; i++) scanf("%lld", &d[i]);
pre[s] = e;
long long sum = get_dis(s, e);
for (i = 1; i <= n; i++) {
if (i != s && i != e) {
long long minn = 1e15;
long long minj;
for (j = s; j != e; j = pre[j]) {
long long dis = get_dis(j, i) + get_dis(i, pre[j]) - get_dis(j, pre[j]);
if (dis < minn) {
minn = dis;
minj = j;
}
}
sum += minn;
pre[i] = pre[minj];
pre[minj] = i;
}
}
printf("%lld\n", sum);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int n, s, b = 0;
cin >> n >> s;
vector<pair<int, int>> a(n);
int max = INT_MIN;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
cin >> a[i].second;
}
for (int i = 0; i < n; i++) {
if (a[i].first < s) {
b = 100 - a[i].second;
if (b == 100) b = 0;
if (max < b) max = b;
}
if (a[i].first == s && a[i].second == 0) {
b = 0;
if (max < b) max = b;
}
}
if (max == INT_MIN)
cout << "-1";
else
cout << max;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
os << "]";
return os;
}
template <class T>
ostream &operator<<(ostream &os, set<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const int N = 100005;
int n, m, k;
unordered_set<int> adj[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
cin >> n >> m >> k;
for (int i = 1; i < n + 1; i++) adj[i].clear();
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].insert(y);
adj[y].insert(x);
}
set<pair<int, int>> S;
vector<int> clique;
for (int i = 1; i < n + 1; i++) S.insert({adj[i].size(), i});
while (!S.empty() && S.begin()->first < k) {
int x = S.begin()->second;
S.erase(S.begin());
if (adj[x].size() == k - 1 && k * (k - 1) / 2 <= m) {
vector<int> v;
for (auto it : adj[x]) v.push_back(it);
v.push_back(x);
bool possible = true;
for (auto it : v) {
for (auto it1 : v) {
if (it == it1) continue;
if (adj[it].find(it1) == adj[it].end()) {
possible = false;
break;
}
}
}
if (possible) {
clique = v;
break;
}
}
for (auto y : adj[x]) {
if (S.find({adj[y].size(), y}) != S.end()) {
auto it = S.find({adj[y].size(), y});
adj[y].erase(x);
S.erase(it);
S.insert({adj[y].size(), y});
}
}
adj[x].clear();
}
if (!clique.empty()) {
cout << 2 << '\n';
for (auto it : clique) cout << it << ' ';
cout << '\n';
} else if (!S.empty()) {
cout << 1 << ' ' << S.size() << '\n';
for (auto it : S) cout << it.second << ' ';
cout << '\n';
} else {
cout << -1 << '\n';
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = INT_MAX;
const long long int infl = LLONG_MAX;
long long int n, i, j, k, m, a, b;
int main() {
cin >> n >> m >> a >> b;
long long int x = n % m;
long long int cost2 = x * b;
long long int cost1 = (m - x) * a;
cout << min(cost1, cost2);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], vis[100005];
vector<int> v[100005];
vector<pair<int, int> > ans;
int main() {
int n, i, j, p, c, two, one, flag = 0;
scanf("%d", &n);
;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
;
}
c = 0;
for (i = 1; i <= n; i++) {
p = i;
while (!vis[p]) {
;
v[c].push_back(p);
vis[p] = 1;
p = a[p];
}
c++;
};
one = -1;
two = -1;
for (i = 0; i < c; i++) {
if (v[i].size() != 1 and v[i].size() != 2) {
if (v[i].size() % 2 == 1) {
flag = 1;
}
}
if (v[i].size() == 1) {
one = i;
}
if (v[i].size() == 2) {
two = i;
}
}
if (one == -1 && two == -1) {
cout << "NO";
return 0;
}
if (one > -1) {
for (i = 1; i <= n; i++) {
if (i == v[one][0]) {
} else {
ans.push_back(make_pair(v[one][0], i));
}
}
cout << "YES\n";
for (i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << "\n";
}
return 0;
}
if (flag == 1) {
cout << "NO";
return 0;
}
if (two > -1) {
for (i = 0; i < c; i++) {
if (i == two) {
continue;
} else {
for (j = 0; j < v[i].size(); j += 2) {
ans.push_back(make_pair(v[i][j], v[two][0]));
ans.push_back(make_pair(v[i][j + 1], v[two][1]));
}
}
}
ans.push_back(make_pair(v[two][0], v[two][1]));
}
cout << "YES\n";
for (i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
vector<pair<int, int> > vec(n);
map<pair<int, int>, set<int> > mp;
for (int i = 0; i < n; i++) {
cin >> vec[i].first >> vec[i].second;
}
int x, y, x1, x2, y1, y2;
long long cnt = 0, res = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
x1 = vec[i].first;
x2 = vec[j].first;
y1 = vec[i].second;
y2 = vec[j].second;
x = x1 - x2;
y = y1 - y2;
int temp = gcd(x, y);
x = x / temp;
y = y / temp;
if (x < 0 || (x == 0 && y < 0)) {
x = -x;
y = -y;
}
long long c = 1LL * y * x1 - 1LL * x * y1;
pair<int, int> pp(x, y);
if (!mp[pp].count(c)) {
cnt++;
mp[pp].insert(c);
res += cnt - mp[pp].size();
}
}
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1000000007;
int h, w, n, f[2005];
long long jc[200005], inv[200005];
struct node {
int x, y;
} p[2005];
int C(int n, int m) { return jc[n] * inv[m] % P * inv[n - m] % P; }
long long mypow(long long a, int b) {
long long c = 1;
while (b) {
if (b & 1) c = c * a % P;
a = a * a % P;
b >>= 1;
}
return c;
}
bool cmp(node a, node b) {
if (a.x == b.x) return a.y < b.y;
return a.x < b.x;
}
int main() {
jc[0] = 1;
inv[0] = 1;
for (int i = 1; i <= 200000; i++) {
jc[i] = jc[i - 1] * i % P;
inv[i] = mypow(jc[i], P - 2);
}
scanf("%d%d%d", &h, &w, &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &p[i].x, &p[i].y);
sort(p + 1, p + 1 + n, cmp);
p[n + 1].x = h, p[n + 1].y = w;
for (int i = 1; i <= n + 1; i++) {
f[i] = C(p[i].x + p[i].y - 2, p[i].x - 1);
for (int j = 1; j <= i - 1; j++) {
if (p[j].x > p[i].x || p[j].y > p[i].y) continue;
f[i] = (f[i] - (long long)f[j] * C(p[i].x - p[j].x + p[i].y - p[j].y,
p[i].x - p[j].x)) %
P;
}
}
cout << (f[n + 1] + P) % P;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
constexpr double EPS = 1e-8;
int t;
cin >> t;
while (t--) {
int d;
cin >> d;
int D = d * d - 4 * d;
if (D < 0) {
cout << "N\n";
} else {
double a = (d + sqrt(D)) / 2;
double b = (d - sqrt(D)) / 2;
if (b < -EPS) {
cout << "N\n";
} else {
cout << "Y " << fixed << setprecision(10) << a << ' ' << b << '\n';
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MAXN = 35, MAXK = 50 + 10;
int t, dp[MAXN][MAXN][MAXK];
vector<int> res;
void make_dp() {
for (int i = 0; i < MAXN; i++)
for (int j = 0; j < MAXN; j++)
for (int k = 0; k < MAXK; k++) dp[i][j][k] = INF;
dp[0][0][0] = 0;
dp[1][1][1] = 0;
dp[1][1][0] = 0;
for (int n = 0; n < MAXN; n++) {
for (int m = 0; m < MAXN; m++) {
for (int k = 0; k < MAXK; k++) {
if (n == 0 || m == 0) dp[n][m][k] = 0;
if (k == 0) dp[n][m][k] = 0;
if (m * n == k) dp[n][m][k] = 0;
if (k > m * n) continue;
for (int i = 1; i < n; i++)
for (int j = 0; j <= k; j++)
dp[n][m][k] =
min(dp[n][m][k], dp[i][m][j] + m * m + dp[n - i][m][k - j]);
for (int i = 1; i < m; i++)
for (int j = 0; j <= k; j++)
dp[n][m][k] =
min(dp[n][m][k], dp[n][i][j] + n * n + dp[n][m - i][k - j]);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
make_dp();
for (int SinaKhare_Dadasham = 0; SinaKhare_Dadasham < t;
SinaKhare_Dadasham++) {
int n, m, k;
cin >> n >> m >> k;
cout << dp[n][m][k] << endl;
}
}
| 6 |
#include <bits/stdc++.h>
const int N = 2010;
int n, m;
char mp[N][N];
int a, b, d;
int f[N][N];
bool vis[N][N];
bool flg;
int top;
std::pair<int, int> stk[N * N];
int dx[N], dy[N];
int dfs(int x, int y) {
stk[++top] = std::make_pair(x, y);
if (x == 0 || y == 0 || x > n || y > m) return 0;
if (vis[x][y]) {
flg = true;
return 0;
}
vis[x][y] = true;
if (f[x][y]) return f[x][y];
return f[x][y] = dfs(x + dx[mp[x][y]], y + dy[mp[x][y]]) + 1;
}
void solv() {
a = 1, b = 1, d = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", mp[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) f[i][j] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
flg = false;
if (f[i][j] == 0) {
top = 0;
dfs(i, j);
}
if (flg) {
std::pair<int, int> tmp = stk[top], tmp2 = stk[top];
int val = f[tmp.first][tmp.second];
do {
vis[tmp2.first][tmp2.second] = false;
f[tmp2.first][tmp2.second] = val;
--top;
tmp2 = stk[top];
} while (stk[top] != tmp);
}
std::pair<int, int> tmp2;
while (top) {
tmp2 = stk[top];
vis[tmp2.first][tmp2.second] = false;
--top;
}
if (f[i][j] > d) {
d = f[i][j];
a = i;
b = j;
}
}
printf("%d %d %d\n", a, b, d);
}
int main() {
dx['U'] = -1;
dx['D'] = 1;
dy['L'] = -1;
dy['R'] = 1;
int cza;
scanf("%d", &cza);
while (cza--) solv();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long gcd(long long a, long long b) {
return !b ? a : gcd(b, a % b);
}
int main() {
int q;
scanf("%d", &q);
for (int test = 0; test < q; test++) {
long long n;
scanf("%I64d", &n);
printf("%I64d\n", 4 * n / gcd(4 * n, n + 1) + 1);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 2;
const long long MN = -1e9;
const long long mod = 998244353;
const long long md = 998244353;
int main() {
long long t;
cin >> t;
while (t--) {
long long n0, n1, n2;
cin >> n0 >> n1 >> n2;
string ans = "";
if (n0 > 0) {
for (int i = 0; i < n0 + 1; i++) {
ans += '0';
}
}
bool check = false;
bool check2 = false;
if (n1 > 0) {
int cnt;
int x;
if (n0 > 0) {
x = n1;
cnt = 1;
} else {
x = n1 + 1;
cnt = 0;
}
for (int i = 0; i < x; i++) {
if (cnt % 2 == 0) {
if (i != x - 1) {
ans += '0';
cnt++;
} else {
check2 = true;
}
} else {
if (i == x - 1) {
check = true;
}
ans += '1';
cnt++;
}
}
}
if (n2 > 0) {
int x;
if (check || check2) {
x = n2;
} else {
x = n2 + 1;
}
for (int i = 0; i < x; i++) {
ans += '1';
}
}
if (check2) {
ans += '0';
}
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 7;
int n;
vector<int> E[maxn];
int b[maxn], g[maxn], ans[maxn];
void dfs(int x, int y) {
if (ans[x]) return;
ans[x] = y;
for (int i = 0; i < E[x].size(); i++) dfs(E[x][i], 1 - y);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
E[2 * i - 1].push_back(2 * i);
E[2 * i].push_back(2 * i - 1);
}
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
E[x].push_back(y);
E[y].push_back(x);
b[i] = x, g[i] = y;
}
int now = 0, tmp = 0;
for (int i = 1; i <= 2 * n; i++) {
if (!ans[i]) dfs(i, tmp);
}
for (int i = 1; i <= n; i++)
cout << ans[b[i]] + 1 << " " << ans[g[i]] + 1 << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 500 + 10;
int n, m;
int a[MAXn][MAXn];
int r[MAXn][MAXn], c[MAXn][MAXn];
int f[MAXn][MAXn];
int ans = -(1 << 30);
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0, _n = (n); i < _n; i++)
for (int j = 0, _n = (m); j < _n; j++) cin >> a[i][j];
for (int i = 0, _n = (n); i < _n; i++)
for (int j = 0, _n = (m); j < _n; j++)
r[i][j + 1] = r[i][j] + a[i][j], c[i + 1][j] = c[i][j] + a[i][j];
for (int i = 0, _n = (n - 2); i < _n; i++)
for (int j = 0, _n = (m - 2); j < _n; j++) f[i][j] = a[i][j];
for (int k = 5; k <= min(n, m); k += 4)
for (int i = 0, _n = (n - k + 1); i < _n; i++)
for (int j = 0, _n = (m - k + 1); j < _n; j++) {
f[i][j] = f[i + 2][j + 2] + (r[i][j + k] - r[i][j]) +
(c[i + k][j + k - 1] - c[i + 1][j + k - 1]) +
(r[i + k - 1][j + k - 1] - r[i + k - 1][j]) +
(c[i + k - 1][j] - c[i + 2][j]) + a[i + 2][j + 1];
(ans = max(ans, f[i][j]));
}
for (int i = 0, _n = (n - 2); i < _n; i++)
for (int j = 0, _n = (m - 2); j < _n; j++) {
f[i][j] = a[i][j] + a[i][j + 1] + a[i][j + 2] + a[i + 1][j + 2] +
a[i + 2][j + 2] + a[i + 2][j + 1] + a[i + 2][j];
(ans = max(ans, f[i][j]));
}
for (int k = 7; k <= min(n, m); k += 4)
for (int i = 0, _n = (n - k + 1); i < _n; i++)
for (int j = 0, _n = (m - k + 1); j < _n; j++) {
f[i][j] = f[i + 2][j + 2] + (r[i][j + k] - r[i][j]) +
(c[i + k][j + k - 1] - c[i + 1][j + k - 1]) +
(r[i + k - 1][j + k - 1] - r[i + k - 1][j]) +
(c[i + k - 1][j] - c[i + 2][j]) + a[i + 2][j + 1];
(ans = max(ans, f[i][j]));
}
cout << ans << endl;
{
int _;
cin >> _;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int f(int x) { return (x >= 0) ? x : -x; }
int main() {
ios_base::sync_with_stdio(0);
int a, b, s, pom;
cin >> a >> b >> s;
pom = f(a) + f(b);
if (s >= pom && s % 2 == pom % 2) {
cout << "Yes\n";
} else {
cout << "No\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
int n;
cin >> s;
for (int i = 0; i < s.size(); i++) {
s[i] = tolower(s[i]);
if (s[i] == 'o') s[i] = '0';
if (s[i] == 'l') s[i] = '1';
if (s[i] == 'i') s[i] = '1';
}
cin >> n;
while (n--) {
cin >> t;
for (int i = 0; i < t.size(); i++) {
t[i] = tolower(t[i]);
if (t[i] == 'o') t[i] = '0';
if (t[i] == 'l') t[i] = '1';
if (t[i] == 'i') t[i] = '1';
}
if (s == t) {
puts("No");
return 0;
}
}
puts("Yes");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long maxm = -1e18;
long long minm = 1e18;
bool isP(long long n) {
if (n == 2LL) return 1;
if (n % 2LL == 0LL)
return 0;
else if (n == 1)
return 0;
for (long long i = 3; i * i <= n; ++i)
if (n % i == 0) return 0;
return 1;
}
void solve() {
int n;
cin >> n;
string res;
while (n > 0) {
if (n == 3) {
res = res + "7";
n -= 3;
} else {
res = res + "1";
n -= 2;
}
}
string result;
for (int i = res.length() - 1; i >= 0; i--) {
result = result + res[i];
}
cout << result << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a, pax = 1e18 + 1;
int main() {
cin >> a;
long long l = a - pax % a * 9 % a * 9 % a, r = pax + l - 1;
cout << l << " " << r;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, x, y, q, fa[N];
double p[N], sum[N], w, ans;
vector<int> G[N];
void dfs(int u, int pr) {
ans -= p[u];
for (auto v : G[u])
if (v != pr) {
fa[v] = u;
dfs(v, u);
ans -= (1 - p[u]) * (1 - p[v]);
sum[u] += 1 - p[v];
}
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); i++) scanf("%lf", &p[i]);
p[0] = 1;
for (int i = (1); i <= (n - 1); i++)
scanf("%d%d", &x, &y), x++, y++, G[x].push_back(y), G[y].push_back(x);
ans = n;
dfs(1, 0);
scanf("%d", &q);
for (int i = (1); i <= (q); i++) {
scanf("%d%lf", &x, &w);
x++;
ans += p[x] + (1 - p[x]) * sum[x] + (1 - p[fa[x]]) * (1 - p[x]);
sum[fa[x]] -= 1 - p[x];
p[x] = w;
ans -= p[x] + (1 - p[x]) * sum[x] + (1 - p[fa[x]]) * (1 - p[x]);
sum[fa[x]] += 1 - p[x];
printf("%.10lf\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using ll = long long;
ll mod = 1e9 + 7;
int const N = 3e5 + 100;
mt19937 rnd;
ll random(ll limit) {
uniform_int_distribution<ll> uniform_dist(0, limit);
return uniform_dist(rnd);
}
ll bpow(ll a, ll p) {
ll res = 1;
while (p > 0) {
if (p % 2) {
res = (res * a) % mod;
}
a = (a * a) % mod;
p /= 2;
}
return res;
}
ll inv(ll a) { return bpow(a, mod - 2); }
void solve() {
ll n, m, k, r, c;
cin >> n >> m >> k >> r >> c;
ll x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
ll dx = min(abs(x1 - x2), c);
ll dy = min(abs(y1 - y2), r);
ll num1 = dx * r + dy * (c - dx);
if (dx == 0 && dy == 0) {
num1 = r * c;
} else if (dx == 0) {
num1 = c * dy;
} else if (dy == 0)
num1 = r * dx;
ll x3 = max(x1, x2);
ll x4 = min(x1 + c, x2 + c);
ll y3 = max(y1, y2);
ll y4 = min(y1 + r, y2 + r);
ll num3 = (x4 - x3) * (y4 - y3);
if (y4 <= y3 || x4 <= x3) num3 = 0;
ll num2 = n * m - (2 * r * c - num3);
ll num = num1 + num2;
ll ans = bpow(k, num);
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
rnd = mt19937(956231);
int t;
t = 1;
while (t--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n;
int x = 1;
int y = 2;
int z = 3;
bool res = true;
for (int i = 0; i < n; i++) {
int q;
cin >> q;
if (q != x && q != y)
res = false;
else if (q == x)
swap(y, z);
else
swap(x, z);
}
(res) ? cout << "YES" : cout << "NO";
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
clock_t t = clock();
namespace my_std {
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
inline T rnd(T l, T r) {
return uniform_int_distribution<T>(l, r)(rng);
}
template <typename T>
inline bool chkmax(T& x, T y) {
return x < y ? x = y, 1 : 0;
}
template <typename T>
inline bool chkmin(T& x, T y) {
return x > y ? x = y, 1 : 0;
}
template <typename T>
inline void read(T& t) {
t = 0;
char f = 0, ch = getchar();
double d = 0.1;
while (ch > '9' || ch < '0') f |= (ch == '-'), ch = getchar();
while (ch <= '9' && ch >= '0') t = t * 10 + ch - 48, ch = getchar();
if (ch == '.') {
ch = getchar();
while (ch <= '9' && ch >= '0') t += d * (ch ^ 48), d *= 0.1, ch = getchar();
}
t = (f ? -t : t);
}
template <typename T, typename... Args>
inline void read(T& t, Args&... args) {
read(t);
read(args...);
}
char __sr[1 << 21], __z[20];
int __C = -1, __zz = 0;
inline void Ot() { fwrite(__sr, 1, __C + 1, stdout), __C = -1; }
inline void print(register int x) {
if (__C > 1 << 20) Ot();
if (x < 0) __sr[++__C] = '-', x = -x;
while (__z[++__zz] = x % 10 + 48, x /= 10)
;
while (__sr[++__C] = __z[__zz], --__zz)
;
__sr[++__C] = '\n';
}
void file() {}
inline void chktime() {}
long long ksm(long long x, int y) {
long long ret = 1;
for (; y; y >>= 1, x = x * x % 1000000007ll)
if (y & 1) ret = ret * x % 1000000007ll;
return ret;
}
long long inv(long long x) { return ksm(x, 1000000007ll - 2); }
} // namespace my_std
using namespace my_std;
int n;
int edge[233][233];
long long a[233][233];
void make_edge(int x, int y, long long w) {
a[x][x] += w;
a[x][y] -= w;
}
long long gauss(int n, int type) {
long long ret = 1;
for (int i = (1); i <= (n); i++) {
int tmp = -1;
for (int j = (i); j <= (n); j++)
if (a[j][i]) tmp = j;
if (tmp != i) ret = -ret, swap(a[i], a[tmp]);
for (int j = (i + 1); j <= (n); j++) {
long long I = a[j][i] * inv(a[i][i]) % 1000000007ll;
for (int k = (i); k <= (n + type); k++)
(a[j][k] += 1000000007ll - I * a[i][k] % 1000000007ll) %= 1000000007ll;
}
}
for (int i = (1); i <= (n); i++) ret = ret * a[i][i] % 1000000007ll;
return (ret % 1000000007ll + 1000000007ll) % 1000000007ll;
}
long long s[233][233];
long long ans[233];
int main() {
file();
read(n);
int x, y;
for (int i = (1); i <= (n - 1); i++) read(x, y), edge[x][y] = edge[y][x] = 1;
for (int t = (1); t <= (n); t++) {
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) a[i][j] = 0;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) make_edge(i, j, edge[i][j] ? t : 1);
s[t][n + 1] = gauss(n - 1, 0);
long long cur = 1;
for (int i = (1); i <= (n); i++)
s[t][i] = cur, cur = cur * t % 1000000007ll;
}
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n + 1); j++) a[i][j] = s[i][j];
gauss(n, 1);
for (int i = (n); i >= (1); i--) {
for (int j = (i + 1); j <= (n); j++)
(a[i][n + 1] -= a[i][j] * ans[j - 1] % 1000000007ll - 1000000007ll) %=
1000000007ll;
ans[i - 1] = a[i][n + 1] * inv(a[i][i]) % 1000000007ll;
}
for (int i = (0); i <= (n - 1); i++) printf("%lld ", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int n, k;
std::cin >> n >> k;
std::vector<bool> look_right(n, false);
for (size_t i = 0; i < n; i++) {
char t;
std::cin >> t;
if (t == 'R') look_right.at(i) = true;
}
int min_moves = 0;
std::vector<std::vector<int>> moves;
for (;;) {
moves.emplace_back();
for (size_t i = 0; i < n - 1; i++) {
if (look_right.at(i) && !look_right.at(i + 1)) {
min_moves++;
moves.back().push_back(i);
look_right.at(i) = false;
look_right.at(i + 1) = true;
i++;
}
}
if (moves.back().size() == 0) {
moves.pop_back();
break;
}
}
if (min_moves < k || moves.size() > k)
std::cout << -1 << std::endl;
else {
int nmoves = moves.size();
auto itb = moves.cbegin();
auto itl = itb->cbegin();
while (nmoves < k) {
nmoves++;
std::cout << "1 " << *itl + 1 << '\n';
itl++;
if (itl == itb->cend()) {
nmoves--;
itb++;
itl = itb->cbegin();
}
}
for (; itb != moves.cend(); itb++, itl = itb->cbegin()) {
std::cout << std::distance(itl, itb->cend()) << ' ';
for (; itl != itb->cend(); itl++) std::cout << *itl + 1 << ' ';
std::cout << std::endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int rlen = 1 << 18 | 1;
inline char gc() {
static char buf[rlen], *ib, *ob;
(ib == ob) && (ob = (ib = buf) + fread(buf, 1, rlen, stdin));
return ib == ob ? -1 : *ib++;
}
inline int read() {
int ans = 0;
char ch = gc();
while (!isdigit(ch)) ch = gc();
while (isdigit(ch)) ans = ((ans << 2) + ans << 1) + (ch ^ 48), ch = gc();
return ans;
}
inline int Read(char* s) {
int top = 0;
char ch = gc();
while (!isalpha(ch) && !isdigit(ch)) ch = gc();
while (isalpha(ch) || isdigit(ch)) s[++top] = ch, ch = gc();
return top;
}
const int N = 205;
int n, m;
const int mod1 = 1e9 + 9;
const long long inf = 1e18;
const unsigned long long bas = 311;
inline int add1(const int& a, const int& b) {
return a + b >= mod1 ? a + b - mod1 : a + b;
}
inline int dec1(const int& a, const int& b) {
return a >= b ? a - b : a - b + mod1;
}
inline int mul1(const int& a, const int& b) { return (long long)a * b % mod1; }
struct Hash_string {
vector<unsigned long long> pw1, s1;
vector<int> pw2, s2;
int len;
inline void init(char* s, int n) {
len = n;
pw1.clear(), pw2.clear(), s1.clear(), s2.clear();
pw1.resize(n + 1), pw2.resize(n + 1), s1.resize(n + 1), s2.resize(n + 1);
pw1[0] = pw2[0] = 1;
for (register int i = 1; i <= n; ++i) {
pw1[i] = pw1[i - 1] * bas;
s1[i] = s1[i - 1] * bas + (unsigned long long)s[i];
pw2[i] = mul1(pw2[i - 1], bas);
s2[i] = add1(mul1(s2[i - 1], bas), (int)s[i]);
}
}
inline void update(char x) {
pw1.push_back(pw1.back() * bas);
s1.push_back(s1.back() * bas + (unsigned long long)x);
pw2.push_back(mul1(pw2.back(), bas));
s2.push_back(add1(mul1(s2.back(), bas), (int)x));
++len;
}
inline unsigned long long get1(int l, int r) {
return s1[r] - s1[l - 1] * pw1[r - l + 1];
}
inline unsigned long long get2(int l, int r) {
return dec1(s2[r], mul1(s2[l - 1], pw2[r - l + 1]));
}
} S[2];
char s[1000005];
int Len[1000005];
inline int init(int a, int b) {
int n = S[a].len, m = S[b].len;
int up = min(n, m), ret = 0;
for (register int i = 1; i <= up; ++i)
if (S[a].get1(n - i + 1, n) == S[b].get1(1, i) &&
S[a].get2(n - i + 1, n) == S[b].get2(1, i))
ret = i;
return ret;
}
int main() {
n = read();
int cur = 0;
S[0].init(s, 0);
for (register int len, i = 1; i <= n; ++i) {
len = Read(s);
S[1].init(s, len);
int tt = init(0, 1);
for (register int j = tt + 1; j <= len; ++j)
cout << s[j], S[0].update(s[j]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, k = 0, n = 0, m = 0;
string s;
cin >> s;
for (i = 0; i < s.length(); i++) {
if (s[i] == '+')
k++;
else
k--;
n = min(n, k);
m = max(m, k);
}
cout << m - n;
return 0;
}
| 3 |
#include <bits/stdc++.h>
typedef struct {
int c, t, i;
} ele;
ele e[2012];
int cmp(ele a, ele b) { return a.t < b.t || a.t == b.t && a.c > b.c; }
int main() {
long long int ans = 0;
int n, k, i, min = (1 << 31) - 1;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d %d", &e[i].c, &e[i].t);
ans += e[i].c;
e[i].i = i + 1;
}
ans *= 2;
std::sort(e, e + n, cmp);
for (i = 0; i < k - 1; i++) {
if (e[i].t == 1) ans -= e[i].c;
}
if (e[i].t == 1) {
for (; i < n; i++)
if (min > e[i].c) min = e[i].c;
ans -= min;
}
printf("%I64d.%I64d\n", ans / 2, ans % 2 * 5);
for (i = 0; i < k - 1; i++) printf("1 %d\n", e[i].i);
printf("%d", n - k + 1);
for (; i < n; i++) printf(" %d", e[i].i);
putchar(10);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
bool in(int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m) {
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
cin >> n >> m;
char data[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> data[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < 4; k++) {
if (in(i + dx[k], j + dy[k]) && data[i + dx[k]][j + dy[k]] == 'W' &&
data[i][j] == 'S') {
cout << "No";
return 0;
}
}
}
}
cout << "Yes" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (data[i][j] == '.')
cout << 'D';
else
cout << data[i][j];
}
cout << endl;
}
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll sum[500005];
struct node
{ ll n,index;}n1;
bool operator<(node a,node b)
{
return a.n<b.n;
}
int main()
{
ll tc,n,i,u;
cin>>tc;
while(tc--)
{
cin>>n;
vector<node>vct;
for(i=0;i<n;i++)
{ cin>>u;
n1.n=u;n1.index=i+1;
vct.push_back(n1);
}
sort(vct.begin(),vct.end());
vector<ll>ans;ll index=-1;
for(i=0;i<n-1;i++)
{
if(i==0) sum[i]=vct[i].n;
else sum[i]=sum[i-1]+vct[i].n;
if(sum[i]<vct[i+1].n)
index=i;
}
for(i=index+1;i<n;i++)
ans.push_back(vct[i].index);
sort(ans.begin(),ans.end());
cout<<ans.size()<<endl;
for(i=0;i<ans.size();i++)
cout<<ans[i]<<" ";
cout<<endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf1 = 1e9 + 9;
const long long inf2 = 1e16 + 9;
const long long mol = 1e9 + 7;
const int maxn = 2e5 + 9;
const long long maxx = 1e12 + 9;
int n, q, l, r;
string s;
vector<int> ar[26];
bool judge() {
int cnt = 0;
for (int i = 0; i < 26; i++)
if (upper_bound(ar[i].begin(), ar[i].end(), r) -
upper_bound(ar[i].begin(), ar[i].end(), l))
cnt++;
return cnt >= 3;
}
int main() {
cin >> s;
n = s.size();
for (int i = 0; i < n; i++) ar[s[i] - 'a'].push_back(i);
scanf("%d", &q);
while (q--) {
scanf("%d%d", &l, &r);
l--, r--;
if (l == r || s[l] != s[r] || judge())
printf("YES\n");
else
printf("NO\n");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
struct node {
int x, k;
} a[100010];
int n;
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) scanf("%d %d", &a[i].x, &a[i].k);
if (n == 1) {
if (a[n].x == 0)
printf("YES\n");
else
printf("NO\n");
continue;
}
int f = 1, i, j;
for (i = 2; i <= n; i++) {
if (a[i].x == 0) continue;
for (j = i - 1; j >= 1; j--) {
if (a[i].k == a[j].k && a[j].x == a[i].x - 1) break;
}
if (j == 0) {
f = 0;
break;
}
}
if (f == 0)
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int n, m;
long long v[110], ans[3];
int max(int a, int b) { return a > b ? a : b; }
void cmax(int& a, int b) { b > a ? a = b : 1; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%lld", v + i);
for (int k = 2; k <= m * 2; k++) {
int l = max(1, k - m), r = k + 1 >> 1, mx = -1, mx2 = -1, t = 1;
for (int i = 0; i < n; i++) {
int x = v[i] % k;
cmax(l, x < r ? x + 1 : k - x);
if (x > mx)
mx2 = mx, mx = x;
else
cmax(mx2, x);
if (x >= r) t = !t;
}
cmax(l, mx2 / 2 + 1);
ans[t] += r - l << 1 | k & 1 ^ 1;
ans[2] += l - max(1, k - m);
r = mx / 2 + 1;
if (l < r && t) ans[2] += r - l, ans[1] -= r - l << 1;
}
printf("%lld %lld %lld %lld\n", ans[2], ans[2], ans[0], ans[1]);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, f = 0, c = 0;
cin >> n;
int t[n], x[n], y[n], sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0;
for (i = 0; i < n; i++) {
cin >> t[i] >> x[i] >> y[i];
if (t[i] == 1) {
sum1 += x[i];
sum2 += y[i];
} else {
sum3 += x[i];
sum4 += y[i];
}
}
if (sum1 >= sum2) f++;
if (sum3 >= sum4) c++;
if (f == 1)
cout << "LIVE" << endl;
else
cout << "DEAD" << endl;
if (c == 1)
cout << "LIVE";
else
cout << "DEAD";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<string> s(n);
for (int i = 0; i < n; i++) cin >> s[i];
int sz = s[0].size();
string result(sz, 0);
for (int i = 0; i < n; i++)
for (int j = 0; j < sz; j++) {
if (s[i][j] != '?') {
if (result[j] == 0)
result[j] = s[i][j];
else if (result[j] != s[i][j])
result[j] = '?';
}
}
for (int i = 0; i < sz; i++)
if (result[i] == 0) result[i] = 'a';
cout << result << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
set<long long> v, h;
set<long long>::iterator l, r;
multiset<long long> V, H;
multiset<long long>::iterator lx, rx;
int main() {
long long mh, mv, n;
long long x;
cin >> mv >> mh >> n;
string s;
v.insert(0);
v.insert(mv);
h.insert(0);
h.insert(mh);
V.insert(mv);
H.insert(mh);
while (n--) {
cin >> s >> x;
if (s[0] == 'H') {
h.insert(x);
long long right = *(++h.find(x));
long long left = *(--h.find(x));
H.erase(H.find(right - left));
H.insert(right - x);
H.insert(x - left);
} else {
v.insert(x);
long long right = *(++v.find(x));
long long left = *(--v.find(x));
V.erase(V.find(right - left));
V.insert(right - x);
V.insert(x - left);
}
lx = V.end();
rx = H.end();
cout << (*(--lx)) * (*(--rx)) << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long dp[100100];
long long a[100100];
long long solve(long long i) {
if (i == 0) return 0;
if (dp[i] != -1) return dp[i];
long long sol = 0;
sol = min(k, i - 1) + min(k, n - i) + 1;
if (a[i] == 0) {
return dp[i] = sol;
} else {
long long p = i - a[i] - 1;
sol = solve(a[i]);
if ((2 * k) > p) {
long long lasta = min(a[i] + k, n);
long long lasti = min(i + k, n);
long long t = max(lasti - lasta, (long long)0);
sol += t;
} else {
sol += (min(k, i - 1) + min(k, n - i) + 1);
}
return dp[i] = sol;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
memset(dp, -1, sizeof dp);
for (int i = 1; i <= n; i++) {
solve(i);
}
for (int i = 1; i <= n; i++) {
cout << dp[i] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 100;
const int mod = 1e9 + 7;
const int inf = (1 << 30);
const int block = 316;
vector<int> v[maxn];
int par[maxn];
bool mark[maxn];
int get(int u) {
if (par[u] < 0) return u;
return par[u] = get(par[u]);
}
void merge(int u, int w) {
u = get(u), w = get(w);
if (u == w) return;
if (par[u] > par[w]) swap(u, w);
par[u] += par[w];
par[w] = u;
}
bool visited[maxn];
int main() {
ios_base::sync_with_stdio(false);
memset(par, -1, sizeof par);
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= q; i++) {
int x, y;
cin >> x >> y;
v[y].push_back(x);
visited[x] = 1;
}
for (int i = 1; i <= m; i++) {
if (v[i].size() > 1)
for (int j = 0; j < v[i].size() - 1; j++) merge(v[i][j], v[i][j + 1]);
}
vector<int> ans;
for (int i = 1; i <= n; i++) {
int u = get(i);
if (visited[u] and !mark[u]) {
ans.push_back(u);
mark[u] = 1;
}
}
int cnt = ans.size() - 1;
int tot = 0;
for (int i = 1; i <= n; i++)
if (!visited[i]) tot++;
int sum = 0;
for (int i = 1; i <= m; i++)
if (v[i].empty()) sum++;
cout << tot + sum + cnt << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1001001001;
const long long INFLL = 1001001001001001001LL;
template <typename T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <typename T>
void chmin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
void chmax(T& a, T b) {
if (a < b) a = b;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
double fin() {
double x;
scanf("%lf", &x);
return x;
}
int A[200050];
int main() {
int N = in();
for (int i = 0; i < N; ++i) {
A[i] = in() + i;
}
sort(A, A + N);
bool ok = true;
for (int i = 0; i < N; ++i) {
ok &= A[i] - i >= 0;
if (i > 0) {
ok &= A[i] > A[i - 1];
}
}
if (!ok) {
puts(":(");
return 0;
}
for (int i = 0; i < N; ++i) {
printf("%d%c", A[i] - i, i == N - 1 ? '\n' : ' ');
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double d, h, v, e;
int flag = 0;
double ans, volume = 0;
cin >> d >> h >> v >> e;
volume = 3.1415926535897932384 * (d / 2) * (d / 2) * h;
for (int i = 0; i < 10000; i++) {
volume = volume + 3.1415926535897932384 * (d / 2) * (d / 2) * e - v;
if (volume <= 0) {
flag = 1;
ans = 3.1415926535897932384 * (d / 2) * (d / 2) * h /
(v - 3.1415926535897932384 * (d / 2) * (d / 2) * e);
break;
}
}
cout.precision(10);
if (flag) {
cout << "YES" << endl;
cout << ans << endl;
} else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int f1[N], f2[N];
int Find1(int t) { return f1[t] = (t == f1[t] ? t : Find1(f1[t])); }
int Find2(int t) { return f2[t] = (t == f2[t] ? t : Find2(f2[t])); }
void join1(int x, int y) {
int fx = Find1(x);
int fy = Find1(y);
if (fx != fy) f1[fy] = fx;
}
void join2(int x, int y) {
int fx = Find2(x);
int fy = Find2(y);
if (fx != fy) f2[fy] = fx;
}
int aa[N], bb[N];
long long ans;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) f1[i] = f2[i] = i;
for (int i = 1; i < n; i++) {
int x, y, f;
cin >> x >> y >> f;
if (f)
join1(x, y);
else
join2(x, y);
}
for (int i = 1; i <= n; i++) aa[Find1(i)]++, bb[Find2(i)]++;
for (int i = 1; i <= n; i++) {
if (aa[i]) ans += 1ll * aa[i] * (aa[i] - 1);
if (bb[i]) ans += 1ll * bb[i] * (bb[i] - 1);
if (aa[f1[i]] && bb[f2[i]]) ans += 1ll * (aa[f1[i]] - 1) * (bb[f2[i]] - 1);
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int INF = 1e9 + 19;
const int logn = 17;
int n, m;
int a[maxn];
bool isSpec[maxn];
vector<pair<int, int> > g[maxn];
int depth[maxn], len[maxn];
int p[maxn][logn];
int in[maxn], out[maxn];
int arr[maxn];
int Time = 0;
int f[maxn];
void ReadInput() {
cin >> n >> m;
fill(begin(isSpec), end(isSpec), false);
for (int i = 1; i <= m; ++i) {
int x;
cin >> x;
isSpec[x] = true;
}
for (int i = 1; i < n; ++i) {
int u, v, w;
cin >> u >> v >> w;
g[u].push_back(pair<int, int>(v, w));
g[v].push_back(pair<int, int>(u, w));
}
}
void dfs1(int u, int par) {
in[u] = ++Time;
arr[Time] = u;
p[u][0] = par;
for (int k = 1; k < logn; ++k) p[u][k] = p[p[u][k - 1]][k - 1];
for (auto to : g[u]) {
int v = to.first;
int w = to.second;
if (v != par) {
depth[v] = depth[u] + 1;
len[v] = len[u] + w;
dfs1(v, u);
}
}
out[u] = Time;
}
int LCA(int u, int v) {
if (depth[u] < depth[v]) swap(u, v);
for (int k = logn - 1; k >= 0; --k)
if (depth[p[u][k]] >= depth[v]) u = p[u][k];
if (u == v) return u;
for (int k = logn - 1; k >= 0; --k)
if (p[u][k] != p[v][k]) {
u = p[u][k];
v = p[v][k];
}
return p[u][0];
}
struct TNode {
int val;
int cnt, child;
inline TNode operator+(const TNode& other) {
if (val < other.val) return other;
if (val > other.val) return *this;
return {val, cnt + other.cnt, child};
}
} nodes[maxn * 4];
int lazy[maxn * 4];
void Build(int x, int l, int r) {
if (l == r) {
nodes[x] =
(isSpec[arr[l]]) ? TNode{len[arr[l]], 1, arr[l]} : TNode{-INF, 0, 0};
return;
}
int mid = (l + r) / 2;
Build(x * 2, l, mid);
Build(x * 2 + 1, mid + 1, r);
nodes[x] = nodes[x * 2] + nodes[x * 2 + 1];
}
inline void push(int x) {
int t = lazy[x];
if (t == 0) return;
lazy[x * 2] += t;
nodes[x * 2].val += t;
lazy[x * 2 + 1] += t;
nodes[x * 2 + 1].val += t;
lazy[x] = 0;
}
TNode Get(int x, int l, int r, int L, int R) {
if (l >= L && r <= R) return nodes[x];
push(x);
int mid = (l + r) / 2;
if (R <= mid) return Get(x * 2, l, mid, L, R);
if (L > mid) return Get(x * 2 + 1, mid + 1, r, L, R);
return Get(x * 2, l, mid, L, mid) + Get(x * 2 + 1, mid + 1, r, mid + 1, R);
}
void Update(int x, int l, int r, int L, int R, int k) {
if (L > r || l > R) return;
if (l >= L && r <= R) {
nodes[x].val += k;
lazy[x] += k;
return;
}
push(x);
int mid = (l + r) / 2;
if (mid >= R)
Update(x * 2, l, mid, L, R, k);
else if (mid < L)
Update(x * 2 + 1, mid + 1, r, L, R, k);
else {
Update(x * 2, l, mid, L, mid, k);
Update(x * 2 + 1, mid + 1, r, mid + 1, R, k);
}
nodes[x] = nodes[x * 2] + nodes[x * 2 + 1];
}
inline void Inc(int u, int v) {
int x = LCA(u, v);
++f[u];
++f[v];
--f[x];
--f[p[x][0]];
}
void calc(int u) {
TNode temp = Get(1, 1, n, 1, n);
int x = u;
for (int k = logn - 1; k >= 0; --k) {
if (p[x][k] == 0) continue;
if (Get(1, 1, n, in[p[x][k]], out[p[x][k]]).val < temp.val) x = p[x][k];
}
if (Get(1, 1, n, in[x], out[x]).val < temp.val) x = p[x][0];
int y = Get(1, 1, n, in[x], out[x]).child;
for (int k = logn - 1; k >= 0; --k) {
if (depth[p[y][k]] <= depth[x]) continue;
if (Get(1, 1, n, in[p[y][k]], out[p[y][k]]).cnt < temp.cnt) y = p[y][k];
}
if (Get(1, 1, n, in[y], out[y]).cnt < temp.cnt) y = p[y][0];
Inc(u, y);
}
void dfs2(int u, int par) {
if (isSpec[u]) calc(u);
for (auto to : g[u]) {
int v = to.first;
int w = to.second;
if (v == par) continue;
Update(1, 1, n, 1, n, w);
Update(1, 1, n, in[v], out[v], -w * 2);
dfs2(v, u);
Update(1, 1, n, in[v], out[v], w * 2);
Update(1, 1, n, 1, n, -w);
}
}
void dfs3(int u, int par) {
for (auto to : g[u]) {
int v = to.first;
if (v == par) continue;
dfs3(v, u);
f[u] += f[v];
}
}
void Solve() {
depth[1] = 1;
len[1] = 0;
dfs1(1, 0);
fill(begin(lazy), end(lazy), 0);
Build(1, 1, n);
dfs2(1, 0);
dfs3(1, 0);
int mx = 0, cnt = 0;
for (int i = 1; i <= n; ++i) {
if (isSpec[i]) continue;
if (mx < f[i]) {
mx = f[i];
cnt = 1;
} else if (mx == f[i])
++cnt;
}
cout << mx << ' ' << cnt << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
ReadInput();
Solve();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct node {
string s;
int id;
} lt[1000010];
bool cmp(node a, node b) {
for (int i = 0; i < a.s.length(); i++) {
if (a.s[i] == b.s[i]) continue;
if (i % 2)
return a.s[i] > b.s[i];
else
return a.s[i] < b.s[i];
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> lt[i].s, lt[i].id = i;
sort(lt + 1, lt + n + 1, cmp);
for (int i = 1; i <= n; i++) cout << lt[i].id << ' ';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> a[500005];
int cnt, val;
bool check(double x) {
double rfrom = 1e9 + 7, rto = 1e9 + 7;
for (int i = 0; i < n; i++) {
if (a[i].second >= 0) {
if (rfrom == 1e9 + 7 || rto < a[i].first)
rfrom = a[i].first, rto = a[i].first + (a[i].second * x);
else
rto = max(rto, a[i].first + (a[i].second * x));
} else {
if (a[i].first + (a[i].second * x) <= rto && rfrom != 1e9 + 7) return 1;
}
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &a[i].first, &a[i].second);
sort(a, a + n);
double l = 0, h = 1e18, mid, ans = -1;
for (int i = 0; i <= 200; i++) {
mid = (l + h) / 2.0;
if (check(mid))
h = mid, ans = mid;
else
l = mid;
}
if (ans < 0)
printf("-1\n");
else
printf("%.9f\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a{};
long long int b{};
long long int c{};
double z{};
long long int s{};
long long int e{};
double d{};
cin >> a >> b >> c;
if (a - b == c * b)
cout << a - b;
else {
z = (static_cast<double>((a * c) - (b * c))) / (static_cast<double>(b));
s = ((a * c) - (b * c)) / b;
d = static_cast<double>(s);
if (z > d) {
e = static_cast<int>(z);
cout << s + 1;
} else {
cout << s;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename... T>
void rd(T&... args) {
((cin >> args), ...);
}
template <typename... T>
void pp(T... args) {
((cout << args << " "), ...);
cout << "\n";
}
void solve() {
long long int n;
cin >> n;
long long int arr[100001] = {0};
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
arr[x]++;
}
long long int sq = 0, g2 = 0;
for (long long int i = 0; i < 100001; i++) {
g2 += arr[i] / 2;
sq += arr[i] / 4;
}
long long int q;
cin >> q;
while (q--) {
char c;
long long int x;
rd(c, x);
if (c == '+') {
g2 -= arr[x] / 2;
sq -= arr[x] / 4;
arr[x]++;
g2 += arr[x] / 2;
sq += arr[x] / 4;
} else {
g2 -= arr[x] / 2;
sq -= arr[x] / 4;
arr[x]--;
g2 += arr[x] / 2;
sq += arr[x] / 4;
}
if (sq && g2 >= 4)
cout << "YES\n";
else
cout << "NO\n";
}
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a * (b / (gcd(a, b))); }
int power(int x, int n) {
if (n == 0)
return 1;
else if (n % 2 == 0) {
int y = power(x, n / 2);
return y * y;
} else
return x * power(x, n - 1);
}
int big_mod(int base, int power, int mod) {
if (power == 0)
return 1;
else if (power % 2 == 0) {
int y = (big_mod(base, power / 2, mod)) % mod;
return (y * y) % mod;
} else {
int y1 = base % mod;
int y2 = (big_mod(base, power - 1, mod)) % mod;
return (y1 * y2) % mod;
}
}
int main() {
std::ios_base::sync_with_stdio(0);
int num, temp, a, b, c;
while (cin >> num) {
vector<int> v1;
v1.clear();
for (int A = 1; A <= num; A++) {
cin >> temp;
v1.push_back(temp);
}
bool j = false;
for (int A = 0; A < v1.size(); A++) {
if (j) break;
for (int B = 0; B < v1.size(); B++) {
if (j) break;
if (A == B) continue;
for (int C = 0; C < v1.size(); C++) {
if (j) break;
if (B == C || A == C) continue;
if (v1[A] == v1[B] + v1[C]) {
j = true;
a = A + 1;
b = B + 1;
c = C + 1;
}
}
}
}
if (j)
cout << a << " " << b << " " << c << endl;
else
cout << -1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
#pragma warning(disable : 6031)
void IO() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); }
const int N = (int)1e5 + 5;
int a[N];
int main() {
IO();
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a, a + n + 1);
int cnt = 1;
for (int i = 1; i <= n; i++)
if (a[i] >= cnt) cnt++;
cout << cnt;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
int cnt[20];
long long d[20];
long long l, r, k;
struct Point {
long long x, y;
} dp[20][1 << 11][2];
Point dfs(long long len, long long state, bool limit, bool non_zero) {
if (len == 0) return Point{1, 0};
if (!limit && dp[len][state][non_zero].y) return dp[len][state][non_zero];
Point ans = Point{0, 0};
int maxn = limit ? cnt[len] : 9;
for (int i = 0; i <= maxn; ++i) {
long long temp = state | ((non_zero || i) << i);
if (__builtin_popcountll(temp) > k) continue;
Point t = dfs(len - 1, temp, limit && i == maxn, non_zero || i);
ans.x = (ans.x + t.x) % MOD;
ans.y = (ans.y + t.y + i * d[len - 1] % MOD * t.x % MOD) % MOD;
}
return dp[len][state][non_zero] = ans;
}
long long solve(long long x) {
memset(dp, 0, sizeof dp);
memset(cnt, 0, sizeof cnt);
int len = 0;
while (x) {
cnt[++len] = x % 10;
x /= 10;
}
return dfs(len, 0, true, 0).y;
}
int main() {
d[0] = 1;
for (int i = 1; i < 20; ++i) d[i] = d[i - 1] * 10 % MOD;
cin >> l >> r >> k;
cout << (solve(r) - solve(l - 1) + MOD) % MOD << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
static const int MOD = 1000000007;
using ll = long long;
using u32 = uint32_t;
using namespace std;
template <class T>
constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;
int main() {
int q;
cin >> q;
while (q--) {
ll n;
scanf("%lld", &n);
string s;
while (n) {
s += '0' + (n % 3);
n /= 3;
}
reverse(s.begin(), s.end());
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '2') {
int j = i;
while (j >= 0 && s[j] >= '1') j--;
if (j == -1) {
s = '1' + string(s.size(), '0');
} else {
s[j] = '1';
for (int k = j + 1; k < s.size(); ++k) {
s[k] = '0';
}
}
break;
}
}
reverse(s.begin(), s.end());
ll ans = 0, k = 1;
for (int i = 0; i < s.size(); ++i) {
ans += (s[i] - '0') * k;
k *= 3;
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
vector<int> mp[100005], mp1[100005];
int v[100005], no[100005], ans;
int gc(int x, int y) {
if (x == 0) return y;
if (y == 0) return x;
int z = y;
while (x % y != 0) {
z = x % y;
x = y;
y = z;
}
return z;
}
void dfs(int x) {
v[x] = 1;
for (int c : mp[x]) {
if (!v[c]) {
no[c] = no[x] + 1;
dfs(c);
} else {
ans = gc(ans, abs(no[c] - no[x] - 1));
}
}
for (int c : mp1[x]) {
if (!v[c]) {
no[c] = no[x] - 1;
dfs(c);
} else {
ans = gc(ans, abs(no[c] - no[x] + 1));
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int(i) = 0; (i) < (int)(m); (i)++) {
int u, v;
scanf("%d%d", &u, &v);
mp[u].push_back(v);
mp1[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!v[i]) {
dfs(i);
}
if (ans == 0) ans = n;
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int sol(vector<vector<int>> adj, vector<int> col, int c) {
int cnt = 1;
vector<int> curcol[3];
int n = adj.size();
vector<bool> visited(n, false);
vector<int> siz(n);
for (int i = 0; i < n; i++) {
siz[i] = adj[i].size();
if (adj[i].size() == 1) {
curcol[col[i]].push_back(i);
visited[i] = 1;
}
}
while ((!curcol[0].empty()) || (!curcol[1].empty()) || (!curcol[2].empty())) {
if (curcol[0].empty() && curcol[c].empty()) {
cnt++;
c = 3 - c;
continue;
}
int v;
if (!curcol[0].empty()) {
v = curcol[0].back();
curcol[0].pop_back();
} else {
v = curcol[c].back();
curcol[c].pop_back();
}
for (auto u : adj[v]) {
if (visited[u]) continue;
siz[u]--;
if (siz[u] < 2) {
curcol[col[u]].push_back(u);
visited[u] = 1;
}
}
siz[v] = 0;
}
return cnt;
}
void solve() {
int n;
cin >> n;
vector<vector<int>> adj(n);
vector<int> col(n);
for (int i = 0; i < n; i++) cin >> col[i];
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
--a;
--b;
adj[a].push_back(b);
adj[b].push_back(a);
}
cout << min(sol(adj, col, 1), sol(adj, col, 2)) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long read() {
long long s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
inline void print(long long *f, long long len) {
for (long long i = 0; i < len; i++) printf("%lld ", f[i]);
puts("");
}
signed main() {
cin >> n >> m;
if (m * (m - 1) < n) {
puts("NO");
return 0;
}
puts("YES");
long long nw = n;
for (long long i = 1; i < min(m, m) && nw; ++i) {
for (long long j = 1; j <= min(m, m) && nw; ++j) {
printf("%lld %lld\n", j, (j + i - 1) % m + 1);
--nw;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void normal(long long int &a) { a = (a + 998244353) % 998244353; }
inline int modMul(long long int a, long long int b) {
a %= 998244353, b %= 998244353;
normal(a), normal(b);
return (a * b) % 998244353;
}
inline int modAdd(long long int a, long long int b) {
a %= 998244353, b %= 998244353;
normal(a), normal(b);
return (a + b) % 998244353;
}
inline int modSub(long long int a, long long int b) {
a %= 998244353, b %= 998244353;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline int modPow(long long int b, long long int p) {
int r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline int modInv(int a) { return modPow(a, 998244353 - 2); }
inline int modDiv(int a, int b) { return modMul(a, modInv(b)); }
inline int fact(int r) {
int ans = 1;
while (r) ans = modMul(ans, r), r--;
return ans;
}
inline int invfact(int r) {
int ans = 1;
while (r) ans = modMul(ans, modInv(r)), r--;
return ans;
}
inline double dgcd(double a, double b) {
if (a < b) return dgcd(b, a);
if (b < .0001) return a;
return dgcd(b, fmod(a, b));
}
const long long int N = 2e6;
const long long int INF = (long long int)1e12;
long long int power(long long int base, long long int exp) {
long long int res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base);
base = (base * base);
exp /= 2;
}
return res;
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
void Abesaale() {
long long int n;
cin >> n;
string s;
cin >> s;
vector<long long int> even, odd;
long long int sum = 0;
for (long long int i = 0; i < n; i++) {
sum += (s[i] - '0');
if ((s[i] - '0') % 2 == 0)
even.push_back(i);
else
odd.push_back(i);
}
if (odd.size() >= 2) {
for (long long int i = 0; i < 2; i++) cout << s[odd[i]];
cout << endl;
return;
} else {
cout << -1 << endl;
return;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
clock_t start, end;
start = clock();
cout << fixed << setprecision(11);
cin >> t;
while (t--) {
Abesaale();
}
end = clock();
double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct NODE {
int num, cnt, time;
NODE() {}
NODE(int _num, int _cnt, int _time) : num(_num), cnt(_cnt), time(_time) {}
bool operator<(const NODE &t) const { return time > t.time; }
};
priority_queue<NODE> que;
int n, m;
int sx, sy, ex, ey;
char mp[1005][1005];
int t[1005][1005][4];
bool ok[333][4];
bool inmap(int x, int y) { return x >= 1 && x <= n && y >= 1 && y <= m; }
void init() {
ok['+'][0] = true, ok['+'][1] = true, ok['+'][2] = true, ok['+'][3] = true;
ok['|'][0] = true, ok['|'][3] = true;
ok['-'][1] = true, ok['-'][2] = true;
ok['^'][0] = true;
ok['>'][2] = true;
ok['v'][3] = true;
ok['<'][1] = true;
ok['L'][0] = true, ok['L'][2] = true, ok['L'][3] = true;
ok['U'][2] = true, ok['U'][3] = true, ok['U'][1] = true;
ok['R'][0] = true, ok['R'][1] = true, ok['R'][3] = true;
ok['D'][0] = true, ok['D'][1] = true, ok['D'][2] = true;
}
char change(char ch, int cnt) {
cnt %= 4;
if (ch == '+') return '+';
if (ch == '-') return cnt & 1 ? '|' : '-';
if (ch == '|') return cnt & 1 ? '-' : '|';
if (ch == '^') {
if (cnt == 0) return '^';
if (cnt == 1) return '>';
if (cnt == 2) return 'v';
return '<';
}
if (ch == '>') {
if (cnt == 0) return '>';
if (cnt == 1) return 'v';
if (cnt == 2) return '<';
return '^';
}
if (ch == 'v') {
if (cnt == 0) return 'v';
if (cnt == 1) return '<';
if (cnt == 2) return '^';
return '>';
}
if (ch == '<') {
if (cnt == 0) return '<';
if (cnt == 1) return '^';
if (cnt == 2) return '>';
return 'v';
}
if (ch == 'L') {
if (cnt == 0) return 'L';
if (cnt == 1) return 'U';
if (cnt == 2) return 'R';
return 'D';
}
if (ch == 'U') {
if (cnt == 0) return 'U';
if (cnt == 1) return 'R';
if (cnt == 2) return 'D';
return 'L';
}
if (ch == 'R') {
if (cnt == 0) return 'R';
if (cnt == 1) return 'D';
if (cnt == 2) return 'L';
return 'U';
}
if (ch == 'D') {
if (cnt == 0) return 'D';
if (cnt == 1) return 'L';
if (cnt == 2) return 'U';
return 'R';
}
return '*';
}
void bfs() {
memset(t, -1, sizeof t);
que.push(NODE((sx - 1) * m + sy, 0, 0));
while (!que.empty()) {
NODE now = que.top();
que.pop();
int cnt = now.cnt, x = (now.num - 1) / m + 1,
y = now.num % m == 0 ? m : now.num % m;
char ch = change(mp[x][y], cnt);
if (t[x][y][cnt] != -1) continue;
t[x][y][cnt] = now.time;
bool vis[4] = {false, false, false, false};
for (int i = 0; i < 4; ++i) {
char t_ch = change(ch, i);
if (!vis[0] && inmap(x - 1, y) && ok[t_ch][0] &&
ok[change(mp[x - 1][y], cnt + i)][3] &&
t[x - 1][y][(cnt + i) % 4] == -1)
vis[0] = true,
que.push(NODE((x - 1 - 1) * m + y, (cnt + i) % 4, now.time + i + 1));
if (!vis[1] && inmap(x + 1, y) && ok[t_ch][3] &&
ok[change(mp[x + 1][y], cnt + i)][0] &&
t[x + 1][y][(cnt + i) % 4] == -1)
vis[1] = true,
que.push(NODE((x + 1 - 1) * m + y, (cnt + i) % 4, now.time + i + 1));
if (!vis[2] && inmap(x, y - 1) && ok[t_ch][1] &&
ok[change(mp[x][y - 1], cnt + i)][2] &&
t[x][y - 1][(cnt + i) % 4] == -1)
vis[2] = true,
que.push(NODE((x - 1) * m + y - 1, (cnt + i) % 4, now.time + i + 1));
if (!vis[4] && inmap(x, y + 1) && ok[t_ch][2] &&
ok[change(mp[x][y + 1], cnt + i)][1] &&
t[x][y + 1][(cnt + i) % 4] == -1)
vis[3] = true,
que.push(NODE((x - 1) * m + y + 1, (cnt + i) % 4, now.time + i + 1));
}
}
int ans = 1 << 30;
for (int i = 0; i < 4; ++i)
if (t[ex][ey][i] != -1) ans = min(ans, t[ex][ey][i]);
if (ans == 1 << 30)
printf("%d\n", -1);
else
printf("%d\n", ans);
}
int main() {
init();
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%s", mp[i] + 1);
scanf("%d%d%d%d", &sx, &sy, &ex, &ey);
bfs();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double x[1001], y[1001];
int n, m;
double xa, ya, xb, yb;
int seg(double xa, double ya, double xb, double yb, int p) {
if ((x[p] - xa) * (yb - ya) - (y[p] - ya) * (xb - xa) > 1e-5)
return 1;
else if ((x[p] - xa) * (yb - ya) - (y[p] - ya) * (xb - xa) < -1e-5)
return -1;
else
return 0;
}
double len(double xa, double ya, double xb, double yb, int p) {
return ((x[p] - xa) * (y[p] - y[(p + 1) % n]) -
(x[p] - x[(p + 1) % n]) * (y[p] - ya)) /
((xb - xa) * (y[p] - y[(p + 1) % n]) -
(x[p] - x[(p + 1) % n]) * (yb - ya));
}
double calc(double xa, double ya, double xb, double yb) {
int sign;
double temp, t;
priority_queue<pair<double, int>, vector<pair<double, int> >,
greater<pair<double, int> > >
pq;
for (int i = 0; i < n; i++) {
if (seg(xa, ya, xb, yb, i) == seg(xa, ya, xb, yb, (i + 1) % n)) continue;
pq.push(
make_pair(len(xa, ya, xb, yb, i),
seg(xa, ya, xb, yb, i) - seg(xa, ya, xb, yb, (i + 1) % n)));
}
sign = 0;
temp = 0;
while (pq.size() > 1) {
sign += pq.top().second;
t = pq.top().first;
pq.pop();
if (sign) temp += pq.top().first - t;
}
return temp * sqrt((xb - xa) * (xb - xa) + (yb - ya) * (yb - ya));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%lf%lf", &x[i], &y[i]);
for (int i = 0; i < m; i++) {
scanf("%lf%lf%lf%lf", &xa, &ya, &xb, &yb);
printf("%f\n", calc(xa, ya, xb, yb));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400005;
const int g = 3;
const int MOD = 998244353;
int ksm(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = 1LL * res * a % MOD;
a = 1LL * a * a % MOD, b >>= 1;
}
return res;
}
int W[2][N << 1];
void init(int n = 400000) {
for (int len = 1; len <= n; len <<= 1) {
int w = ksm(g, (MOD - 1) / len), iw = ksm(w, MOD - 2);
W[0][len] = W[1][len] = 1;
for (int k = 1; k < len; k++)
W[0][len + k] = 1LL * W[0][len + k - 1] * w % MOD,
W[1][len + k] = 1LL * W[1][len + k - 1] * iw % MOD;
}
return;
}
vector<int> operator+(const vector<int> &F, const vector<int> &G) {
vector<int> f = F, g = G;
int n = f.size() - 1, m = g.size() - 1;
int s = max(n, m);
vector<int> res(s + 1);
for (int i = 0; i <= s; i++) {
if (i <= n) res[i] = (res[i] + f[i]) % MOD;
if (i <= m) res[i] = (res[i] + g[i]) % MOD;
}
return res;
}
vector<int> operator-(const vector<int> &F, const vector<int> &G) {
vector<int> f = F, g = G;
int n = f.size() - 1, m = g.size() - 1;
int s = max(n, m);
vector<int> res(s + 1);
for (int i = 0; i <= s; i++) {
if (i <= n) res[i] = (res[i] + f[i]) % MOD;
if (i <= m) res[i] = (res[i] - g[i] + MOD) % MOD;
}
return res;
}
vector<int> operator*(const vector<int> &F, const int &x) {
vector<int> f = F;
int n = f.size() - 1;
for (int i = 0; i <= n; i++) f[i] = 1LL * f[i] * x % MOD;
return f;
}
vector<int> operator*(const int &x, const vector<int> &F) { return F * x; }
vector<int> ntt(const vector<int> &F, const vector<int> &G,
const function<int(int, int)> &mul) {
vector<int> f = F, g = G;
int n = f.size() - 1, m = g.size() - 1;
m += n, n = 1;
while (n <= m) n <<= 1;
f.resize(n), g.resize(n);
vector<int> rev(n);
for (int i = 0; i < n; i++) {
rev[i] = rev[i / 2] >> 1;
if (i & 1) rev[i] |= n >> 1;
}
static const int BIT = 15;
function<void(vector<int> &)> dft = [=](vector<int> &F) {
int n = F.size();
vector<unsigned long long> f(n);
for (int i = 0; i < n; i++) f[i] = F[rev[i]];
for (int len = 2; len <= n; len <<= 1) {
if (len & (1 << BIT)) {
for (int i = 0; i < n; i++) f[i] %= MOD;
}
for (int i = 0; i < n; i += len)
for (int k = i; k < i + len / 2; k++) {
unsigned long long l = f[k];
int r = f[k + len / 2] * W[0][len + k - i] % MOD;
f[k] = l + r;
f[k + len / 2] = l + MOD - r;
}
}
for (int i = 0; i < n; i++) F[i] = f[i] % MOD;
return;
};
function<void(vector<int> &)> idft = [=](vector<int> &F) {
int n = F.size();
vector<unsigned long long> f(n);
for (int i = 0; i < n; i++) f[i] = F[rev[i]];
for (int len = 2; len <= n; len <<= 1) {
if (len & (1 << BIT)) {
for (int i = 0; i < n; i++) f[i] %= MOD;
}
for (int i = 0; i < n; i += len)
for (int k = i; k < i + len / 2; k++) {
unsigned long long l = f[k];
int r = f[k + len / 2] * W[1][len + k - i] % MOD;
f[k] = l + r;
f[k + len / 2] = l + MOD - r;
}
}
for (int i = 0; i < n; i++) F[i] = f[i] % MOD;
return;
};
dft(f);
dft(g);
for (int i = 0; i < n; i++) f[i] = mul(f[i], g[i]);
idft(f);
int invn = ksm(n, MOD - 2);
f.resize(m + 1);
for (int i = 0; i <= m; i++) f[i] = 1LL * f[i] * invn % MOD;
return f;
}
vector<int> operator*(const vector<int> &F, const vector<int> &G) {
return ntt(F, G,
[=](const int &x, const int &y) { return 1LL * x * y % MOD; });
}
vector<int> getinv(const vector<int> &F) {
vector<int> f = F;
int m = f.size() - 1;
int n = 1;
while (n <= m) n <<= 1;
f.resize(n);
vector<int> g = {ksm(f[0], MOD - 2)};
for (int m = 2; m <= n; m <<= 1) {
vector<int> t(f.begin(), f.begin() + m);
g = ntt(t, g, [=](const int &x, const int &y) {
return (2 * y - 1LL * y * y % MOD * x % MOD + MOD) % MOD;
});
g.resize(m);
}
g.resize(m + 1);
return g;
}
int w;
struct Complex {
int real, imag;
bool operator==(const Complex &b) const {
return real == b.real && imag == b.imag;
}
Complex operator*(const Complex &b) const {
Complex res;
res.real = (1LL * real * b.real + 1LL * w * imag % MOD * b.imag) % MOD;
res.imag = (1LL * real * b.imag + 1LL * imag * b.real) % MOD;
return res;
}
friend Complex ksm(Complex a, int b) {
Complex res = (Complex){1, 0};
while (b) {
if (b & 1) res = res * a;
a = a * a, b >>= 1;
}
return res;
}
};
int cipolla(int n) {
static mt19937 myrand(time(NULL));
if (n == 0) return 0;
function<bool(int)> check = [=](const int &n) {
return ksm(n, (MOD - 1) / 2) == 1;
};
if (!check(n)) return -1;
int a = myrand() % (MOD - 1) + 1;
while (check((1LL * a * a - n + MOD) % MOD)) a = myrand() % (MOD - 1) + 1;
w = (1LL * a * a - n + MOD) % MOD;
Complex res = ksm((Complex){a, 1}, (MOD + 1) / 2);
return res.real;
}
vector<int> sqrt(const vector<int> &F) {
vector<int> f = F;
int m = f.size() - 1;
int n = 1;
while (n <= m) n <<= 1;
f.resize(n);
int g0 = cipolla(f[0]);
vector<int> g = {min(g0, MOD - g0)};
int inv2 = ksm(2, MOD - 2);
for (int m = 2; m <= n; m <<= 1) {
vector<int> t(f.begin(), f.begin() + m);
g.resize(m);
g = g * inv2 + ntt(t, getinv(g), [=](const int &x, const int &y) {
return 1LL * inv2 * x % MOD * y % MOD;
});
g.resize(m);
}
g.resize(m + 1);
return g;
}
int n, m;
int c[N];
int main() {
init();
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
vector<int> g(m + 1);
for (int i = 1; i <= n; i++)
if (c[i] <= m) g[c[i]] = 1;
vector<int> f = 2 * getinv((vector<int>){1} + sqrt((vector<int>){1} - 4 * g));
for (int i = 1; i <= m; i++) printf("%d\n", f[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > v;
int main() {
ios_base::sync_with_stdio(false);
long long int n, second, a, b;
cin >> n >> second;
long long int tim = 0;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back({a, b});
}
sort(v.rbegin(), v.rend());
long long int prev = second;
for (int i = 0; i < n; i++) {
tim += (prev - v[i].first);
prev = v[i].first;
if (tim < v[i].second) {
tim = v[i].second;
}
}
tim += (prev - 0);
cout << tim << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main(void) {
int n, d, i, j, k, ans = 0;
scanf("%d %d", &n, &d);
int w[n + 10], b[d + 10];
for (i = 0; i < n; i++) scanf("%d", &w[i]);
for (i = 0; i < d; i++) scanf("%d", &b[i]);
bool visit[n + 10];
for (i = 0; i < n + 10; i++) visit[i] = false;
for (i = 0; i < d; i++) {
for (k = 0; k < n + 10; k++) visit[k] = false;
for (j = i - 1; j >= 0 && b[i] != b[j]; j--) {
if (!visit[b[j]]) {
ans += w[b[j] - 1];
visit[b[j]] = true;
}
}
}
printf("%d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vc<vc<T>>;
template <class T>
void mkuni(vector<T>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
template <class T>
void print(T x, int suc = 1) {
cout << x;
if (suc == 1)
cout << '\n';
else
cout << ' ';
}
template <class T>
void print(const vector<T>& v, int suc = 1) {
for (int i = 0; i < v.size(); i++)
print(v[i], i == (int)(v.size()) - 1 ? suc : 2);
}
bool inline ask(int u) {
cout << "? " << u << endl;
string ret;
cin >> ret;
return ret == "Y";
}
int main() {
int n, k;
cin >> n >> k;
int var = max(1, k / 2);
int cnt = (n + var - 1) / var;
vector<int> ok(n + 1, 1);
int ans = 0;
for (int i = 1; i <= n; i++)
if (ask(i)) ok[i] = 0;
for (int i = 1; i <= cnt; i++) {
for (int j = i + 2; j <= cnt; j++) {
cout << "R" << endl;
int l = (i - 1) * var + 1, r = i * var;
for (int i = l; i <= r; i++) ask(i);
l = (j - 1) * var + 1, r = min(n, j * var);
for (int i = l; i <= r; i++)
if (ask(i)) ok[i] = 0;
}
}
for (int i = 1; i <= n; i++) ans += ok[i];
cout << "! " << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 55;
int n, w, m;
vector<pair<int, int> > ans[MAXM];
void init() {
for (int i = 0; i < m; ++i) {
ans[i].clear();
}
}
int main() {
while (scanf("%d %d %d", &n, &w, &m) == 3) {
init();
int flag = true;
int vol = m * w;
int acc, goal;
acc = goal = n * w;
int cup_id = 0;
for (int i = 0; i < n && flag; ++i) {
int cnt = 0;
int cur_vol = vol;
while (cur_vol) {
int d = min(cur_vol, acc);
cur_vol -= d;
acc -= d;
ans[cup_id].push_back({i + 1, d});
++cnt;
if (acc == 0) {
acc = goal;
++cup_id;
}
}
if (cnt > 2) flag = false;
}
if (!flag)
puts("NO");
else {
puts("YES");
for (int i = 0; i < m; ++i) {
for (int j = 0; j < ans[i].size(); ++j) {
pair<int, int> p = ans[i][j];
printf("%d %.12lf ", p.first, double(p.second) / double(m));
}
puts("");
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long sum = 0;
multiset<pair<long long, pair<long long, int> >,
greater<pair<long long, pair<long long, int> > > >
s;
int dfs(int a, vector<bool> &visited, vector<pair<long long, long long> > adj[],
long long x) {
visited[a] = true;
int count = 0;
for (int i = 0; i < (int)adj[a].size(); ++i) {
if (!visited[adj[a][i].first]) {
long long x = adj[a][i].second;
count += dfs(adj[a][i].first, visited, adj, x);
}
}
if ((int)adj[a].size() == 1) {
if (a != 1) {
sum += x;
pair<long long, pair<long long, int> > temp;
temp.first = (x + 1) / 2;
temp.second.first = x;
temp.second.second = 1;
s.insert(temp);
}
return 1;
} else {
if (a != 1) {
sum += 1LL * count * x;
pair<long long, pair<long long, int> > temp;
temp.first = ((x + 1) / 2) * count;
temp.second.first = x;
temp.second.second = count;
s.insert(temp);
}
return count;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
s.clear();
sum = 0;
int n;
long long S;
cin >> n >> S;
vector<pair<long long, long long> > adj[n + 1];
for (int i = 0; i < n - 1; ++i) {
int u, v;
long long w;
cin >> u >> v >> w;
adj[u].push_back(make_pair(v, w));
adj[v].push_back(make_pair(u, w));
}
vector<bool> visited(n + 1, false);
int a = dfs(1, visited, adj, 0);
int move = 0;
while (sum > S) {
pair<long long, pair<long long, int> > x;
x = *(s.begin());
s.erase(s.begin());
sum -= x.first;
long long y = x.second.first;
int z = x.second.second;
y /= 2;
x.first = (y + 1) / 2 * z;
x.second.first = y;
s.insert(x);
++move;
}
cout << move << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MAX_N = 1e5 + 100;
const pair<int, int> BAD = {INF, INF};
vector<pair<int, int> > cnt;
void build(vector<pair<int, int> >& a, int l, int r, int v) {
if (l == r) {
cnt[v] = a[l];
return;
}
int leftEnd = (l + r) / 2;
build(a, l, leftEnd, v * 2 + 1);
build(a, leftEnd + 1, r, v * 2 + 2);
cnt[v] = min(cnt[v * 2 + 1], cnt[v * 2 + 2]);
}
pair<int, int> rmq(int l, int r, int tl, int tr, int v) {
if (l > r) return BAD;
if (l == tl && r == tr) return cnt[v];
int leftEnd = (tl + tr) / 2;
return min(rmq(l, min(leftEnd, r), tl, leftEnd, v * 2 + 1),
rmq(max(l, leftEnd + 1), r, leftEnd + 1, tr, v * 2 + 2));
}
vector<vector<int> > g(MAX_N);
vector<int> pos(MAX_N, -1), len(MAX_N);
vector<pair<int, int> > d;
vector<bool> u(MAX_N);
void dfs(int v, int depth) {
u[v] = true;
d.push_back({depth, v});
len[v] = depth;
pos[v] = d.size() - 1;
for (int to : g[v]) {
if (!u[to]) {
dfs(to, depth + 1);
d.push_back({depth, v});
}
}
}
int N;
int LCA(int a, int b) {
return rmq(min(pos[a], pos[b]), max(pos[a], pos[b]), 0, N - 1, 0).second;
}
int solve(int s, int t, int f) {
int ans = 0;
int l1 = LCA(s, f);
int l2 = LCA(t, f);
int l3 = LCA(s, t);
ans += len[f] - max(len[l1], len[l2]) + 1;
if (l1 == l2) {
if (len[l3] >= len[l1]) {
ans += len[l3] - len[l1];
}
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
int n, q;
cin >> n >> q;
for (int i = 2; i <= n; ++i) {
int to;
cin >> to;
g[to].push_back(i);
g[i].push_back(to);
}
dfs(1, 0);
N = d.size();
cnt.resize(4 * N);
build(d, 0, N - 1, 0);
while (q--) {
int a, b, c;
cin >> a >> b >> c;
cout << max(solve(a, b, c), max(solve(a, c, b), solve(b, c, a))) << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1024], t[1024];
bool b[1024];
vector<int> p;
pair<int, int> arr[32];
int sz;
vector<pair<int, int> > ans, res;
void rev(int l, int r) {
reverse(arr + l, arr + r + 1);
for (int i = l; i <= r; i++) swap(arr[i].first, arr[i].second);
}
bool dfs(int cnt) {
int lpt = 0, lval = 0;
while (lpt < sz && arr[lpt].first == lval) lval = arr[lpt].second + 1, lpt++;
if (lpt == sz) return true;
int rpt = sz - 1, rval = n - 1;
while (rpt >= 0 && arr[rpt].second == rval) rval = arr[rpt].first - 1, rpt--;
if (rpt < 0) return true;
bool ok = true;
for (int i = lpt; ok && i < rpt; i++)
if (arr[i].second != arr[i + 1].first + 1) ok = false;
if (ok) {
rev(lpt, rpt);
ans.push_back(pair<int, int>(lpt, rpt));
return true;
}
if (cnt < 2) {
for (int l = 0; l < sz - 1; l++)
for (int r = l + 1; r < sz; r++) {
rev(l, r);
if (dfs(cnt + 1)) {
ans.push_back(pair<int, int>(l, r));
return true;
}
rev(l, r);
}
}
return false;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]), a[i]--;
for (int i = 0; i <= n; i++) b[i] = false;
b[0] = b[n] = true;
for (int i = 1; i < n; i++)
if (abs(a[i] - a[i - 1]) != 1) b[i] = true;
p.clear();
for (int i = 0; i <= n; i++)
if (b[i]) {
if (0 <= i - 1) p.push_back(i - 1);
p.push_back(i);
if (i + 1 <= n) p.push_back(i + 1);
}
sort(p.begin(), p.end());
sz = unique(p.begin(), p.end()) - p.begin();
p.resize(sz);
for (int i = 1; i < sz; i++)
arr[i - 1] = pair<int, int>(a[p[i - 1]], a[p[i] - 1]);
sz--;
ans.clear();
if (dfs(0)) {
int k = int(ans.size());
printf("%d\n", k);
res.resize(k);
for (int i = 0; i < k; i++) {
int lval = 1;
for (int j = 0; j < ans[i].first; j++)
lval += abs(arr[j].second - arr[j].first) + 1;
int rval = n;
for (int j = sz - 1; j > ans[i].second; j--)
rval -= abs(arr[j].second - arr[j].first) + 1;
res[i].first = lval;
res[i].second = rval;
rev(ans[i].first, ans[i].second);
}
for (int i = 0; i < k; i++) printf("%d %d\n", res[i].first, res[i].second);
for (int i = 0; i < n; i++) t[i] = i;
for (int i = 0; i < k; i++)
reverse(t + res[i].first - 1, t + res[i].second);
for (int i = 0; i < n; i++) assert(a[i] == t[i]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k, fa[2010], f[2010][2010], lcp[2010], order[2010], sz[2010];
string s[2010];
int fd(int x) { return fa[x] == x ? x : fa[x] = fd(fa[x]); }
int cmp(int x, int y) { return lcp[x] > lcp[y]; }
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> s[i];
sort(s + 1, s + 1 + n);
for (int i = 1; i <= n; i++) fa[i] = i, sz[i] = 1;
for (int i = 1; i < n; i++)
while (lcp[i] < min(s[i].size(), s[i + 1].size()) &&
s[i][lcp[i]] == s[i + 1][lcp[i]])
lcp[i]++;
for (int i = 1; i < n; i++) order[i] = i;
sort(order + 1, order + n, cmp);
for (int i = 1; i < n; i++) {
int hh = order[i];
int x = fd(hh), y = fd(hh + 1);
for (int i = min(sz[x] + sz[y], k); i > 0; i--)
for (int j = 0; j <= min(i, sz[x]); j++) {
f[x][i] = max(f[x][i], f[x][j] + f[y][i - j] + lcp[hh] * j * (i - j));
}
fa[y] = x;
sz[x] += sz[y];
}
cout << f[fd(1)][k] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-12;
const int inf = 2000000000;
const long long int infLL = (long long int)1e18;
long long int MOD = 1000000007;
int MOD1 = 1000000007;
int MOD2 = 1000000009;
inline bool checkBit(long long int n, long long int i) {
return n & (1LL << i);
}
inline long long int setBit(long long int n, long long int i) {
return n | (1LL << i);
;
}
inline long long int resetBit(long long int n, long long int i) {
return n & (~(1LL << i));
}
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long int year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long int &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline long long int modMul(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline long long int modAdd(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline long long int modSub(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long int modPow(long long int b, long long int p) {
long long int r = 1LL;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1LL;
}
return r;
}
inline long long int modDiv(long long int a, long long int b) {
return modMul(a, modPow(b, MOD - 2));
}
bool comp(const pair<long long int, pair<long long int, long long int>> &p1,
const pair<long long int, pair<long long int, long long int>> &p2) {
return p1.first > p2.first;
}
bool comp1(const pair<long long int, long long int> &p1,
const pair<long long int, long long int> &p2) {
if (p1.first == p2.first) {
return p1.second > p2.second;
}
return p1.first < p2.first;
}
long long int converter(string a) {
long long int i, mul = 1LL, r, t, ans = 0LL;
if (a.length() == 0) return 0;
for (i = a.length() - 1; i >= 0; i--) {
t = a[i] - '0';
r = t % 10;
ans += (mul * r);
mul = mul * 10;
}
return ans;
}
int msb(unsigned x) {
union {
double a;
int b[2];
};
a = x;
return (b[1] >> 20) - 1023;
}
const int MAX = (int)2e5 + 5;
int h[MAX], k_par[MAX][20], n, dp[MAX], cp[MAX];
vector<int> adj[MAX];
void dfs(int u, int cnt, int p) {
h[u] = cnt;
k_par[u][0] = p;
for (auto v : adj[u])
if (v != p) dfs(v, cnt + 1, u);
}
void build(int x) {
dfs(x, 0, 0);
for (int j = 1; (1 << j) <= n; ++j) {
for (int i = 1; i <= n; ++i)
if (k_par[i][j - 1] != 0) k_par[i][j] = k_par[k_par[i][j - 1]][j - 1];
}
}
int lca(int u, int v) {
if (h[u] < h[v]) swap(u, v);
for (int i = 19; i >= 0; i--)
if (k_par[u][i] && h[k_par[u][i]] >= h[v]) u = k_par[u][i];
if (u == v) return u;
for (int i = 19; i >= 0; i--)
if (k_par[u][i] != k_par[v][i]) u = k_par[u][i], v = k_par[v][i];
return k_par[u][0];
}
int dist(int u, int v) { return h[u] + h[v] - h[lca(u, v)] * 2; }
vector<set<int>> tree;
struct CentroidDecomposition {
vector<set<int>> tree;
vector<int> dad, sub;
CentroidDecomposition(vector<set<int>> &tree) : tree(tree) {
int n = tree.size();
dad.resize(n + 1);
sub.resize(n + 1);
build(1, 0);
}
void build(int u, int p) {
int n = dfs(u, p);
int centroid = dfs(u, p, n);
if (p == 0) p = centroid;
dad[centroid] = p;
set<int> temp = tree[centroid];
for (auto v : temp) {
tree[centroid].erase(v);
tree[v].erase(centroid);
build(v, centroid);
}
}
int dfs(int u, int p) {
sub[u] = 1;
for (auto v : tree[u])
if (v != p) sub[u] += dfs(v, u);
return sub[u];
}
int dfs(int u, int p, int n) {
for (auto v : tree[u])
if (v != p and sub[v] > n / 2) return dfs(v, u, n);
return u;
}
int operator[](int i) { return dad[i]; }
};
void getPars() {
CentroidDecomposition ds = CentroidDecomposition(tree);
for (int i = 1; i <= n; ++i) cp[i] = ds.dad[i];
}
void update(int u) {
int v = u;
while (1) {
dp[v] = min(dp[v], dist(u, v));
if (v == cp[v]) break;
v = cp[v];
}
}
int query(int u) {
int ans = inf, v = u;
while (1) {
ans = min(ans, dist(v, u) + dp[v]);
if (cp[v] == v) break;
v = cp[v];
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int i, x, y, q, tp;
cin >> n >> q;
tree.resize(n + 1);
fill(dp, dp + n + 1, inf);
for (i = 1; i < n; ++i) {
cin >> x >> y;
tree[x].insert(y);
tree[y].insert(x);
adj[x].push_back(y);
adj[y].push_back(x);
}
getPars();
build(1);
update(1);
for (i = 1; i <= q; ++i) {
cin >> tp >> x;
if (tp == 1)
update(x);
else
cout << query(x) << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[5009];
int main() {
int n, x1, x2, x3, x4;
cin >> n;
for (int i = 0; i < n; i++) {
int sum1;
if (i == 0) {
printf("? %d %d\n", 1, 2);
fflush(stdout);
scanf("%d", &x1);
} else if (i == 1) {
printf("? %d %d\n", 1, 3);
fflush(stdout);
scanf("%d", &x2);
} else if (i == 2) {
printf("? %d %d\n", 2, 3);
fflush(stdout);
scanf("%d", &x3);
} else {
printf("? %d %d\n", i + 1, 3);
fflush(stdout);
scanf("%d", &sum1);
a[i] = sum1 - a[2];
}
if (i == 2) {
x4 = (x2 + x3 - x1) / 2;
a[2] = x4;
a[0] = x2 - a[2];
a[1] = x3 - a[2];
}
fflush(stdout);
}
printf("! ");
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << "\n";
fflush(stdout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, j, z, x = 10, k = 0, year = 0, l = 0, f = 0;
string s;
cin >> n;
while (n--) {
cin >> s;
x = 10;
f = 0;
year = 0;
k = s.length() - 4;
for (i = 1; i < k; i++) {
f += x;
x *= 10;
}
for (i = 4; i < s.length(); i++) {
year = year * 10 + 10 * (s[i] - 48);
}
year /= 10;
while (year < 1989 + f) {
year += x;
}
cout << year << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> name;
int pos[1005];
int v1[1005];
int v2[1005];
int h[1005];
int a[1005];
int b[1005];
int f[1005];
int n, m, c;
int find(int x) {
if (f[x] == 0) return x;
f[x] = find(f[x]);
return f[x];
}
void joint(int x, int y) {
int fx, fy;
fx = find(x), fy = find(y);
if (fx != fy) f[fx] = fy;
}
void connect(int v[]) {
int i, flag;
memset(f, 0, sizeof(f));
do {
flag = 0;
for (i = 1; i <= m; ++i)
if (v[i] == 0 &&
(find(pos[i]) == find(a[i]) || find(pos[i]) == find(b[i]))) {
joint(a[i], b[i]);
v[i] = flag = 1;
}
} while (flag);
}
void work() {
int i, j, x, y, k, p;
string st;
for (i = 1; i <= c; ++i) {
cin >> st;
name[st] = i;
scanf("%d%d", &x, &y);
h[i] = x;
for (j = 1; j <= y; ++j) {
scanf("%d", &k);
pos[k] = x;
}
}
connect(v1);
for (i = 1; i <= c; ++i) {
cin >> st;
p = name[st];
scanf("%d%d", &x, &y);
if (find(x) != find(h[p])) {
printf("NO\n");
return;
}
for (j = 1; j <= y; ++j) {
scanf("%d", &k);
if (find(x) != find(pos[k])) {
printf("NO\n");
return;
}
pos[k] = x;
}
}
connect(v2);
for (i = 1; i <= m; ++i)
if (v1[i] != v2[i]) {
printf("NO\n");
return;
}
printf("YES\n");
}
int main() {
int i;
scanf("%d%d%d", &n, &m, &c);
for (i = 1; i <= m; ++i) scanf("%d%d", &a[i], &b[i]);
work();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, tp[1001], mx, as;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int in;
scanf("%d", &in);
tp[in]++;
mx = max(mx, tp[in]);
}
for (int i = 1; i <= 1000; i++) {
if (tp[i] >= 1) as++;
}
printf("%d %d", mx, as);
return 0;
while (1) puts("(〃'▽'〃)");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
long double w, v, u;
int main() {
cin >> n >> w >> v >> u;
long double ans = 0;
long double mxx = 0;
bool lol = 0;
for (int i = 0; i < n; ++i) {
long double x, y;
cin >> x >> y;
x -= (v / u) * y;
mxx = max(mxx, x);
if (x < 0) lol = 1;
}
if (lol)
cout << setprecision(20) << mxx / v + w / u << "\n";
else
cout << setprecision(20) << w / u << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, q;
struct Edge {
int v;
long long d;
Edge() {
v = 0;
d = 0;
}
Edge(int rv, int rd) {
v = rv;
d = rd;
}
};
struct SortEdge {
int u;
int v;
long long d;
};
bool operator<(const SortEdge& a, const SortEdge& b) {
if (a.d != b.d) return a.d < b.d;
if (a.u != b.u) return a.u < b.u;
return a.v < b.v;
}
vector<Edge> e[100005];
long long du[100005];
int pre[100005];
int fa[100005 * 4][21];
long long ans[100005 * 4];
int dsuFa[100005 * 4];
int topK;
int level[100005 * 4];
int tl[100005 * 4];
int tr[100005 * 4];
vector<SortEdge> se;
void dijstra() {
priority_queue<pair<long long, int>> pq;
int i;
for (i = 1; i <= n; i++) {
if (i <= k) {
du[i] = 0;
pq.push({0, i});
} else {
du[i] = -1;
}
pre[i] = i;
}
while (!pq.empty()) {
auto cur = pq.top();
pq.pop();
int u = cur.second;
long long cd = -cur.first;
for (auto& it : e[u]) {
long long nd = cd + it.d;
if (du[it.v] == -1 || du[it.v] > nd) {
du[it.v] = nd;
pq.push({-nd, it.v});
pre[it.v] = pre[u];
}
}
}
}
int dsuFind(int x) {
if (dsuFa[x] != x) {
dsuFa[x] = dsuFind(dsuFa[x]);
}
return dsuFa[x];
}
void dsuUnion(int x, int y, long long val) {
int xx = dsuFind(x);
int yy = dsuFind(y);
topK++;
fa[xx][0] = topK;
fa[yy][0] = topK;
dsuFa[xx] = topK;
dsuFa[yy] = topK;
dsuFa[topK] = topK;
ans[topK] = val;
tl[topK] = xx;
tr[topK] = yy;
}
void dfs(int u) {
for (int j = 1; j < 21; j++) {
fa[u][j] = fa[fa[u][j - 1]][j - 1];
}
if (tl[u]) {
level[tl[u]] = level[u] + 1;
dfs(tl[u]);
}
if (tr[u]) {
level[tr[u]] = level[u] + 1;
dfs(tr[u]);
}
}
int lca(int a, int b) {
if (level[a] < level[b]) {
int c = a;
a = b;
b = c;
}
int ha = level[a];
int hb = level[b];
int begina = a;
int beginb = b;
int beginlevela = level[a];
int beginlevelb = level[b];
int deltaH = ha - hb;
for (int i = 0; i < 21; i++) {
if (deltaH & (1 << i)) {
a = fa[a][i];
}
}
for (int i = 20; i >= 0; i--) {
if (fa[a][i] != fa[b][i]) {
a = fa[a][i];
b = fa[b][i];
}
}
return fa[a][0];
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m >> k >> q;
int i;
for (i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
e[a].push_back({b, c});
e[b].push_back({a, c});
}
dijstra();
for (i = 1; i <= n; i++) {
for (int j = 0; j < e[i].size(); j++) {
if (i > e[i][j].v) {
if (pre[i] != pre[e[i][j].v]) {
if (pre[i] <= k && pre[e[i][j].v] <= k) {
se.push_back(
{pre[i], pre[e[i][j].v], du[i] + du[e[i][j].v] + e[i][j].d});
}
}
}
}
}
sort(se.begin(), se.end());
topK = k;
for (i = 1; i <= k; i++) {
dsuFa[i] = i;
tl[i] = 0;
tr[i] = 0;
level[i] = 0;
}
for (i = 0; i < se.size(); i++) {
if (dsuFind(se[i].u) != dsuFind(se[i].v)) {
dsuUnion(se[i].u, se[i].v, se[i].d);
}
}
level[topK] = 1;
dfs(topK);
while (q--) {
int a, b;
cin >> a >> b;
int c = lca(a, b);
if (c > 0) {
cout << ans[c] << endl;
} else {
cout << a << " " << b << endl;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string a;
string b;
int k;
void scan() {
cin >> a >> b;
cin >> k;
}
void solve() {
int br = 0;
for (int i = 1; i <= a.size() - 1; ++i)
if (a.substr(i) + a.substr(0, i) == b) {
++br;
}
if (k == 0) {
cout << (a == b) << endl;
return;
} else if (k == 1) {
cout << br << endl;
} else {
if (a.size() == 2) {
if (a == b && a[0] == a[1]) {
cout << 1 << endl;
return;
}
if (a == b) {
cout << (k + 1) % 2 << endl;
return;
}
swap(a[1], a[0]);
if (a == b) {
cout << (k) % 2 << endl;
return;
}
return;
}
long long zero = 1, others = 0;
for (int i = 0; i < k; ++i) {
long long nz, no;
nz = others * (a.size() - 1);
no = zero + others * (a.size() - 2);
zero = nz % 1000000007;
others = no % 1000000007;
}
long long res = others * br;
if (a == b) res += zero;
res %= 1000000007;
cout << res << endl;
}
}
int main() {
scan();
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
long int array1[n + 5];
array1[0] = 0;
for (int i = 1; i <= n - 1; i++) {
cin >> array1[i];
array1[i] += array1[i - 1];
}
long int ret = 1e10;
for (int i = k; i <= n - 1; i++) {
ret = min(ret, array1[i] - array1[i - k]);
}
cout << ret << endl;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.