solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int H[1002012], Nxt[1002012], B[1002012], Arr[1002012], Pos[1002012],
Epos[1002012], Deg[1002012], C[1002012], Vpos[1002012], D[1002012];
bool Used[1002012];
int S, n, num, Num, Color, m;
int T[4 * 1002012];
inline void Edge(const int& x, const int& y) {
B[++num] = y;
if (!H[x])
H[x] = num;
else
Nxt[num] = Nxt[H[x]], Nxt[H[x]] = num;
}
inline void Add(const int& x, const int& y) {
Edge(x, y);
Edge(y, x);
}
inline void travel(const int& x, const int& depth) {
D[x] = depth;
Vpos[x] = ++Num;
Used[x] = 1;
C[x] = Color;
for (int i = H[x]; i; i = Nxt[i])
if (!Used[B[i]]) {
Epos[(i + 1) >> 1] = ++Num;
travel(B[i], depth + 1);
}
}
inline void Travel(const int& x) {
Used[x] = 1;
for (int i = H[x]; i; i = Nxt[i]) {
Pos[++Color] = ++Num;
Epos[(i + 1) >> 1] = ++Num;
travel(B[i], 1);
}
}
inline void upd(int x, const int& p) {
for (; x <= Num; x += ((x) & (-(x)))) T[x] += p;
}
inline int sum(int x) {
int ans = 0;
for (; x; x -= ((x) & (-(x)))) ans += T[x];
return ans;
}
int main() {
scanf("%d", &n);
int x, y;
for (int i = 0; i < n - 1; ++i)
scanf("%d%d", &x, &y), --x, --y, Add(x, y), ++Deg[x], ++Deg[y];
S = 0;
for (int i = 0; i < n; ++i)
if (Deg[i] > 2) S = i;
Travel(S);
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
scanf("%d", &x);
if (x == 1) {
scanf("%d", &x);
upd(Epos[x], -1);
} else if (x == 2) {
scanf("%d", &x);
upd(Epos[x], 1);
} else {
scanf("%d%d", &x, &y);
--x;
--y;
if (y == S) swap(x, y);
if (x == S) {
if (sum(Vpos[y]) - sum(Pos[C[y]]) > 0)
printf("-1\n");
else
printf("%d\n", D[y]);
} else if (C[x] == C[y]) {
if (Vpos[x] < Vpos[y]) swap(x, y);
if (sum(Vpos[x]) - sum(Vpos[y]) > 0)
printf("-1\n");
else
printf("%d\n", abs(D[x] - D[y]));
} else {
if (sum(Vpos[x]) - sum(Pos[C[x]] - 1) + sum(Vpos[y]) -
sum(Pos[C[y]] - 1) >
0)
printf("-1\n");
else
printf("%d\n", D[x] + D[y]);
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MN = 1e6 + 3;
void output() {
string s;
cin >> s;
long long len = s.size();
long long ans = 0;
for (long long i = (0); i < (len); i++) {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u' || s[i] == '1' || s[i] == '3' || s[i] == '5' ||
s[i] == '7' || s[i] == '9') {
ans++;
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
for (long long i = (0); i < (t); i++) {
output();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long l, r, a, b, c;
int main() {
cin >> l >> r;
if (r - l + 1 < 3) {
cout << -1;
return 0;
}
if ((l % 2 == 1) && (r - l + 1 == 3)) {
cout << -1;
return 0;
}
if (l % 2 == 0)
a = l;
else
a = l + 1;
b = a + 1;
c = b + 1;
cout << a << ' ' << b << ' ' << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 2;
struct ques {
int id, l, r, d, u;
} Q[maxn];
long long ans[maxn];
int p[maxn], last;
bool cmp1(ques A, ques B) { return A.d < B.d; }
bool cmp2(ques A, ques B) { return A.u < B.u; }
int n, m;
int tr[maxn];
int lowbit(int x) { return (x & (-x)); }
void add(int x) {
if (x == 0) return;
for (int i = x; i <= n; i += lowbit(i)) {
tr[i]++;
}
}
long long query(int x) {
long long ans = 0;
for (int i = x; i >= 1; i -= lowbit(i)) {
ans += tr[i];
}
return ans;
}
long long calc(int x) {
return max(0LL, ((long long)x * ((long long)x - 1) / 2));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
p[x] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &Q[i].l, &Q[i].d, &Q[i].r, &Q[i].u);
if (Q[i].l > Q[i].r) swap(Q[i].l, Q[i].r);
if (Q[i].d > Q[i].u) swap(Q[i].d, Q[i].u);
Q[i].id = i;
ans[Q[i].id] = (long long)n * ((long long)n - 1) / 2 - calc(Q[i].d - 1) -
calc(n - Q[i].r) - calc(Q[i].l - 1) - calc(n - Q[i].u);
}
sort(Q + 1, Q + 1 + m, cmp1);
last = 1;
for (int i = 1; i <= m; i++) {
for (int j = last; j < Q[i].d; j++) add(p[j]);
long long num1 = query(Q[i].l - 1), num2 = query(n) - query(Q[i].r);
ans[Q[i].id] += calc(num1) + calc(num2);
last = Q[i].d;
}
memset(tr, 0, sizeof(tr));
sort(Q + 1, Q + 1 + m, cmp2);
last = n;
for (int i = m; i >= 1; i--) {
for (int j = last; j > Q[i].u; j--) add(p[j]);
long long num1 = query(Q[i].l - 1), num2 = query(n) - query(Q[i].r);
ans[Q[i].id] += calc(num1) + calc(num2);
;
last = Q[i].u;
}
for (int i = 1; i <= m; i++) printf("%lld\n", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
long long prime[1000001];
using namespace std;
int Prime(int a) {
for (int i = 2; i <= a / 2; ++i) {
if (a % i == 0) {
return 0;
}
}
return 1;
}
void sieve() {
for (int i = 2; i <= 1000000; i++) prime[i] = 1;
int maxn = 1000000;
for (int i = 2; i * i <= maxn; i++) {
if (prime[i] == 1) {
for (int j = i; j * j <= maxn; j += i) {
prime[j] = 0;
}
}
}
}
void fibo(long long a[], long long n) {
long long x = 0;
long long y = 1;
a[0] = 0;
a[1] = 1;
for (long long i = 2; i < n; ++i) {
a[i] = (x + y) % 10;
x = y;
y = a[i];
}
}
bool binarySearch(vector<long long> arr, int l, int r, int x) {
if (r >= l) {
int mid = l + (r - l) / 2;
if (arr[mid] == x) return 1;
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return 0;
}
long long s[200001], x, a[200001];
void bs(long long low, long long high) {
long long mid = (low + high) / 2;
if (s[mid] == x) {
cout << mid + 1 << " " << a[mid];
} else if ((x < s[mid]) && (x >= s[mid - 1])) {
cout << mid << " " << x - s[mid - 1];
} else if (x > s[mid]) {
return bs(mid + 1, high);
} else {
return bs(low, mid - 1);
}
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
long long t, n, k, x, r, m, s, y, a, b, c;
string z;
cin >> t;
while (t--) {
cin >> a >> b;
if (a == b) {
cout << 0 << endl;
continue;
}
if (a > b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
k = 0;
x = b - a;
k += x / 5;
x %= 5;
k += x / 2;
x %= 2;
k += x;
cout << k << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3fll;
struct edge {
int u, v, cx, cy;
} e[50000 + 10], g[200 + 10];
int fa[200 + 10];
int n, m, G, S;
bool cmp(edge a, edge b) {
if (a.cx == b.cx) return a.cy < b.cy;
return a.cx < b.cx;
}
void init() {
for (int i = 1; i <= n; ++i) fa[i] = i;
}
int Find(int c) {
if (fa[c] != c) fa[c] = Find(fa[c]);
return fa[c];
}
int main() {
scanf("%d%d%d%d", &n, &m, &G, &S);
for (int i = 1; i <= m; ++i)
scanf("%d%d%d%d", &e[i].u, &e[i].v, &e[i].cx, &e[i].cy);
sort(e + 1, e + m + 1, cmp);
int top = 0;
long long ans = inf;
for (int i = 1; i <= m; ++i) {
init();
g[++top] = e[i];
for (int j = top; j >= 2; --j)
if (g[j].cy < g[j - 1].cy) swap(g[j], g[j - 1]);
int cnt = 0;
for (int j = 1; j <= top; ++j) {
int fx = Find(g[j].u), fy = Find(g[j].v);
if (fx != fy) {
g[++cnt] = g[j];
fa[fx] = fy;
if (cnt == n - 1) break;
}
}
if (cnt == n - 1)
ans = min(ans, (long long)e[i].cx * G + (long long)g[cnt].cy * S);
top = cnt;
}
if (ans == inf)
printf("-1\n");
else
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string s[1001];
pair<string, string> com[1001];
set<int> has[300][30];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 1; i <= int(n); i++) {
cin >> s[i];
int len = int(s[i].size());
for (int k = 0; k < len; k++) {
int val = 0;
int l = 0;
for (int j = k; j < len; j++) {
l++;
val = val * 2 + int(s[i][j] - '0');
if (val >= 1 << 16) break;
{ has[i][l].insert(val); }
}
}
if (len <= 16) {
com[i].first = s[i];
com[i].second = s[i];
} else {
com[i].first = s[i].substr(0, 16);
com[i].second = s[i].substr(len - 16, 16);
}
}
int m;
cin >> m;
for (int k = 1; k <= int(m); k++) {
int x, y;
cin >> x >> y;
string a = com[x].second;
string b = com[y].first;
string res = a + b;
int len1 = int(com[x].second.size());
int len2 = int(com[y].first.size());
for (int i = 1; i <= len1; i++) {
for (int j = 1; j <= len2; j++) {
int total = i + j;
string fir = com[x].second.substr(len1 - i);
string sec = com[y].first.substr(0, j);
string result = fir + sec;
int val = 0;
if (total > 16) continue;
for (int i = 0; i < total; i++) {
val = val * 2 + int(result[i] - '0');
}
has[k + n][total].insert(val);
}
}
for (int i = 1; i <= 16; i++) {
for (auto aa : has[x][i]) has[k + n][i].insert(aa);
for (auto aa : has[y][i]) has[k + n][i].insert(aa);
}
int ans = 0;
for (int i = 1; i <= 16; i++) {
if (int(has[k + n][i].size()) == (1 << i))
ans = i;
else
break;
}
cout << ans << '\n';
if (int(com[x].first.size()) >= 16) {
com[k + n].first = com[x].first;
} else {
assert(com[x].first == com[x].second);
int rem = 16 - int(com[x].first.size());
string more = com[y].first.substr(0, min(int(com[y].first.size()), rem));
com[k + n].first = com[x].first + more;
}
if (int(com[y].second.size()) >= 16) {
com[k + n].second = com[y].second;
} else {
assert(com[y].first == com[y].second);
int rem = 16 - int(com[y].second.size());
int len1 = int(com[x].second.size());
int cando = min(rem, len1);
string more = com[x].second.substr(len1 - cando, cando);
com[k + n].second = more + com[y].second;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int L = 70;
long long d[11][L][1 << 10];
long long d1[11][L];
long long f(int b, long long n) {
long long n0 = n;
vector<int> x;
while (n) {
x.push_back(n % b);
n /= b;
}
long long res = 0;
int mask = 0;
for (int i = x.size() - 1; i >= 0; --i) {
for (int j = 1; j < x[i]; ++j) {
res += d[b][i][mask ^ (1 << j)];
}
if (i != x.size() - 1) {
if (x[i]) res += d[b][i][mask ^ 1];
} else {
res += d1[b][i];
}
mask ^= (1 << x[i]);
}
return res;
}
const int MS = 100000;
long long s[11][MS];
long long stupid(int b, int n) { return s[b][n]; }
bool mtest(int b, int n) {
vector<int> c(b);
while (n) {
c[n % b]++;
n /= b;
}
for (int x : c)
if (x % 2) return 0;
return 1;
}
int main() {
for (int b = 2; b <= 10; ++b) {
d[b][0][0] = 1;
for (int i = 0; i + 1 < L; ++i) {
for (int mask = 0; mask < (1 << b); ++mask)
if (d[b][i][mask]) {
for (int x = 0; x < b; ++x) {
d[b][i + 1][mask ^ (1 << x)] += d[b][i][mask];
}
}
}
for (int l = 1; l < L; ++l) {
d1[b][l] = d1[b][l - 1];
for (int x = 1; x < b; ++x) d1[b][l] += d[b][l - 1][1 << x];
}
}
int T;
scanf("%d", &T);
for (int test = 1; test <= T; ++test) {
long long l, r;
int b;
scanf("%d%lld%lld", &b, &l, &r);
printf("%lld\n", f(b, r + 1) - f(b, l));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct Node {
int x, y;
} p[5000];
vector<int> v[5];
map<double, int> mp;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &p[i].x, &p[i].y);
for (int i = 2; i <= n; i++) p[i].x -= p[1].x, p[i].y -= p[1].y;
p[1].x = 0, p[1].y = 0;
int flag = 1;
while (flag) {
for (int i = 1; i <= n; i++)
if (p[i].x & 1 || p[i].y & 1) {
flag = 0;
break;
}
if (!flag) break;
for (int i = 1; i <= n; i++) p[i].x /= 2, p[i].y /= 2;
}
for (int i = 1; i <= 4; i++) v[i].clear();
for (int i = 1; i <= n; i++) {
if (p[i].x & 1 && p[i].y & 1)
v[1].push_back(i);
else if (p[i].x & 1 && !(p[i].y & 1))
v[2].push_back(i);
else if (!(p[i].x & 1) && p[i].y & 1)
v[3].push_back(i);
else
v[4].push_back(i);
}
if ((v[1].size() || v[4].size()) && (v[2].size() || v[3].size())) {
printf("%d\n", v[1].size() + v[4].size());
for (int i = 0; i < v[1].size(); i++) printf("%d ", v[1][i]);
for (int i = 0; i < v[4].size(); i++) printf("%d ", v[4][i]);
} else if ((v[1].size() && v[4].size()) && !(v[2].size() || v[3].size())) {
printf("%d\n", v[1].size());
for (int i = 0; i < v[1].size(); i++) printf("%d ", v[1][i]);
} else if (!(v[1].size() || v[4].size()) && (v[2].size() && v[3].size())) {
printf("%d\n", v[2].size());
for (int i = 0; i < v[2].size(); i++) printf("%d ", v[2][i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int BUFFER_SIZE = 1 << 15;
char input_buffer[BUFFER_SIZE];
int input_pos = 0, input_len = 0;
void _update_input_buffer() {
input_len = fread(input_buffer, sizeof(char), BUFFER_SIZE, stdin);
input_pos = 0;
if (input_len == 0) input_buffer[0] = EOF;
}
inline char next_char(bool advance = true) {
if (input_pos >= input_len) _update_input_buffer();
return input_buffer[advance ? input_pos++ : input_pos];
}
template <typename T>
inline void read_int(T &number) {
bool negative = false;
number = 0;
while (!isdigit(next_char(false)))
if (next_char() == '-') negative = true;
do {
number = 10 * number + (next_char() - '0');
} while (isdigit(next_char(false)));
if (negative) number = -number;
}
template <typename T, typename... Args>
inline void read_int(T &number, Args &...args) {
read_int(number);
read_int(args...);
}
} // namespace IO
const long long LL_INF = (long long)2e18 + 5;
template <typename T1, typename T2>
void minimize(T1 &a, const T2 &b) {
if (b < a) a = b;
}
int main() {
int N, M, K;
IO::read_int(N, M, K);
vector<int> shovels(N);
for (auto &s : shovels) IO::read_int(s);
nth_element(shovels.begin(), shovels.begin() + K, shovels.end());
sort(shovels.begin(), shovels.begin() + K);
vector<long long> shovel_sum(K + 1, 0);
for (int i = 0; i < K; i++) shovel_sum[i + 1] = shovel_sum[i] + shovels[i];
vector<int> best_offer(K + 1);
for (int i = 0; i <= K; i++) best_offer[i] = i;
for (int i = 0; i < M; i++) {
int x, y;
IO::read_int(x, y);
y = x - y;
if (x <= K) best_offer[x] = min(best_offer[x], y);
}
vector<long long> dp(K + 1, LL_INF);
dp[0] = 0;
for (int k = 1; k <= K; k++)
for (int x = 1; x <= k; x++)
minimize(dp[k],
dp[k - x] + shovel_sum[k] - shovel_sum[k - best_offer[x]]);
cout << dp[K] << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[112];
bool solve() {
int n, k;
scanf("%d %d", &n, &k);
int last_non_zero = -1;
int cur_val;
for (int i = 0; i < n; i++) {
scanf("%d", &cur_val);
a[i + 1] = cur_val;
if (cur_val == 0) {
continue;
}
if (last_non_zero > cur_val) {
return true;
}
last_non_zero = cur_val;
}
if (k > 1) {
return true;
}
int b_val;
scanf("%d", &b_val);
for (int i = 1; i <= n; i++) {
if (a[i] == 0) {
return !(a[i - 1] <= b_val && (i == n || b_val <= a[i + 1]));
}
}
}
int main() {
if (solve()) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma warning(disable : 4786)
using namespace std;
struct test {
char str[5];
int s;
} M[1005];
void rotate(int i) {
char temp, t1;
temp = M[i].str[0];
M[i].str[0] = M[i].str[2];
t1 = M[i].str[1];
M[i].str[1] = temp;
temp = M[i].str[3];
M[i].str[3] = t1;
M[i].str[2] = temp;
}
int main() {
int n, i, j, k, res;
char str[5];
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n - 1; i++) {
scanf("%s", str);
M[i].str[0] = str[0];
M[i].str[1] = str[1];
scanf("%s", str);
M[i].str[2] = str[0];
M[i].str[3] = str[1];
M[i].str[4] = NULL;
M[i].s = 0;
scanf("%s", str);
}
scanf("%s", str);
M[i].str[0] = str[0];
M[i].str[1] = str[1];
scanf("%s", str);
M[i].str[2] = str[0];
M[i].str[3] = str[1];
M[i].str[4] = NULL;
M[i].s = 0;
res = 0;
for (i = 0; i < n; i++) {
if (M[i].s == 0) {
res++;
for (j = i + 1; j < n; j++) {
if (!strcmp(M[i].str, M[j].str)) {
M[j].s = 1;
}
rotate(j);
if (!strcmp(M[i].str, M[j].str)) {
M[j].s = 1;
}
rotate(j);
if (!strcmp(M[i].str, M[j].str)) {
M[j].s = 1;
}
rotate(j);
if (!strcmp(M[i].str, M[j].str)) {
M[j].s = 1;
}
}
}
}
printf("%d\n", res);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, cnt = 0;
cin >> n >> k;
vector<int> r(2 * n + 1);
for (int i = 0; i < 2 * n + 1; i++) cin >> r[i];
for (int i = 1; i < 2 * n + 1; i += 2) {
if (r[i] - r[i - 1] > 1 && r[i] - r[i + 1] > 1) {
r[i]--;
cnt++;
}
if (cnt == k) break;
}
for (int i = 0; i < 2 * n + 1; i++) cout << r[i] << " ";
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int cnt[20005];
int d[4];
int main() {
int i, j, k, n, max, v, goal;
while (scanf("%d", &n) != EOF) {
for (i = 1; i <= 3; i++) scanf("%d", &d[i]);
max = 0;
goal = n * 2;
memset(cnt, 0, sizeof(cnt));
cnt[0] = 1;
for (i = 1; i <= 3; i++) {
if (i == 1)
v = 1;
else if (i == 2)
v = 2;
else if (i == 3)
v = 4;
for (j = max; j >= 0; j--) {
if (cnt[j]) {
for (k = 1; k <= d[i]; k++) {
if (j + k * v > goal) break;
cnt[j + k * v] += cnt[j];
}
}
}
max += v * d[i];
if (max > goal) max = goal;
}
printf("%d\n", cnt[goal]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
std::vector<long long int> v, vv;
long long int pre[N];
map<long long int, long long int> mp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n, xx = 0;
cin >> n;
for (int i = 0; i < n; i++) {
long long int x;
cin >> x;
if (mp.find(x) == mp.end()) {
mp[x] = 1;
v.push_back(x);
}
}
sort(v.begin(), v.end());
for (int i = 1; i < (int)v.size(); i++) {
vv.push_back(v[i] - v[i - 1]);
}
sort(vv.begin(), vv.end());
if (vv.size()) pre[0] = vv[0];
for (int i = 1; i < (int)vv.size(); i++) pre[i] = pre[i - 1] + vv[i];
long long int q, ans;
cin >> q;
while (q--) {
long long int x, y;
cin >> x >> y;
long long int pos =
lower_bound(vv.begin(), vv.end(), (y - x + 1)) - vv.begin();
long long int ans = ((int)v.size() - pos) * (y - x + 1);
if (pos) ans += pre[pos - 1];
cout << ans << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long ADD(long long a, long long b, long long mod) {
return (a + b + mod + mod) % mod;
}
inline long long SUBS(long long a, long long b, long long mod) {
return (a - b + mod + mod) % mod;
}
inline long long MUL(long long a, long long b, long long mod) {
return (a * b + mod) % mod;
}
long long bigMod(long long base, long long power, long long mod) {
if (!power) return 1;
if (!base) return 0;
long long temp = bigMod(base, power / 2, mod);
if (power % 2 == 0) {
return (temp * temp) % mod;
} else
return (((temp * temp) % mod) * base) % mod;
}
inline long long modInverse(long long a, long long modp) {
return bigMod(a, modp - 2, modp);
}
inline long long modInverseExtended(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
void autoinput() {}
int main() {
autoinput();
long long N;
scanf("%lld", &N);
;
if (N < 3) {
puts("-1");
return 0;
}
long long arr[N + 2][N + 2];
long long vis[N + 2][N + 2];
memset(vis, -1, sizeof vis);
memset(arr, 0, sizeof arr);
long long mx = N * N + 1;
for (long long i = 1; i <= N; i++) {
for (long long j = 1; j <= N; j++) {
vis[i][j] = 0;
if (i <= 3 && j <= 3) vis[i][j] = 1;
}
}
arr[1][1] = (mx - 10) + 2;
arr[1][2] = (mx - 10) + 8;
arr[1][3] = (mx - 10) + 7;
arr[2][1] = (mx - 10) + 3;
arr[2][2] = (mx - 10) + 4;
arr[2][3] = (mx - 10) + 6;
arr[3][1] = (mx - 10) + 1;
arr[3][2] = (mx - 10) + 5;
arr[3][3] = (mx - 10) + 9;
mx -= 10;
long long x = 4, y = 1;
while (mx) {
arr[x][y] = mx;
vis[x][y] = 1;
if (vis[x + 1][y] == 0)
x++;
else if (vis[x - 1][y] == 0)
x--;
else if (vis[x][y + 1] == 0)
y++;
mx--;
}
for (long long i = 1; i <= N; i++) {
for (long long j = 1; j <= N; j++) {
printf("%lld ", arr[i][j]);
}
puts("");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k, m;
cin >> n >> k >> m;
map<int, vector<int> > mp;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
mp[x % m].push_back(x);
}
for (auto it : mp) {
if (it.second.size() >= k) {
cout << "Yes" << endl;
for (int i = 0; i < k; ++i) {
cout << it.second[i] << " ";
}
cout << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 3e3 + 88;
const int inf = 1e9 + 88;
const int logn = 22;
const int maxa = 3e6 + 88;
const char sgl[5] = {'a', 'e', 'i', 'o', 'u'};
const char sep = 'a' - 1;
long long readint() {
long long cur;
scanf("%I64d", &cur);
return cur;
}
bool cmp(pair<int, int> i, pair<int, int> j) { return i > j; }
pair<int, int> mn[maxn][maxn];
pair<int, int> b[maxn];
vector<pair<int, int> > q;
int a[maxn], d[maxn];
void solve() {
int n = readint(), i, j;
for (i = 0; i < n; i++) a[i] = readint();
for (i = 0; i < n; i++) b[i] = {a[i], i};
sort(b, b + n, cmp);
for (i = 0; i < n; i++) mn[i][i] = {b[i].first - b[i + 1].first, i};
pair<int, int> res = {0, 0};
for (i = 0; i < n; i++)
for (j = i + i + 1 - (i + 1) / 2; j <= min(i + 2 * (i + 1), n - 2); j++) {
int cnt1 = i + 1, cnt2 = j - i;
int l = max(cnt1 - cnt1 / 2, cnt2 - cnt2 / 2);
int r = min(2 * cnt1, 2 * cnt2);
l = max(1, l);
r = min(n - j - 1, r);
if (l > r) continue;
pair<int, int> cur = {b[i].first - b[i + 1].first,
b[j].first - b[j + 1].first};
if (res < cur) {
res = cur;
q.clear();
}
if (res == cur) q.push_back({i, j});
}
for (i = 1; i < n; i++)
for (j = 0; j < n - i; j++)
mn[j][j + i] = max(mn[j][j + i - 1], mn[j + 1][j + i]);
int pos1 = 0, pos2 = 0, pos3 = 0, ans = -1;
for (i = 0; i < q.size(); i++) {
int cnt1 = q[i].first + 1, cnt2 = q[i].second - cnt1 + 1;
int l = max(cnt1 - cnt1 / 2, cnt2 - cnt2 / 2);
int r = min(2 * cnt1, 2 * cnt2);
l = cnt1 + cnt2 + max(1, l) - 1;
r = cnt1 + cnt2 + min(n - cnt1 - cnt2, r) - 1;
pair<int, int> cur = mn[l][r];
if (cur.first > ans) {
pos1 = q[i].first;
pos2 = q[i].second;
pos3 = cur.second;
ans = cur.first;
}
}
for (i = 0; i <= pos1; i++) d[b[i].second] = 1;
for (i = pos1 + 1; i <= pos2; i++) d[b[i].second] = 2;
for (i = pos2 + 1; i <= pos3; i++) d[b[i].second] = 3;
for (i = 0; i < n; i++) printf("%d ", (d[i] == 0 ? -1 : d[i]));
}
int main() {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int p[2100];
double dp[2100][2100][2][2];
int lt[2100];
int rt[2100];
int h;
int n;
double t;
double calc(int a, int b, int c, int d) {
if (a > b) return 0;
if (dp[a][b][c][d] > -0.5) {
return dp[a][b][c][d];
}
if (a == b) {
int ld = h;
int rd = h;
if (c)
ld -= max(0, (h * 2 - (p[a] - p[a - 1])));
else if (a)
ld -= max(0, h - (p[a] - p[a - 1]));
if (d)
rd -= max(0, (h * 2 - (p[a + 1] - p[a])));
else if (a < n - 1)
rd -= max(0, h - (p[a + 1] - p[a]));
return dp[a][b][c][d] = (double)ld * t + (double)rd * (1.0 - t);
}
double ret = 0;
double tmp = 0;
int ld = h;
if (c)
ld -= max(0, (h * 2 - (p[a] - p[a - 1])));
else if (a)
ld -= max(0, h - (p[a] - p[a - 1]));
tmp += ((double)ld + calc(a + 1, b, 0, d)) * t;
int rd = h + p[min(rt[a], b)] - p[a];
if (d)
rd -= max(0, (h * 2 - (p[b + 1] - p[min(rt[a], b)])));
else if (b < n - 1)
rd -= max(0, h - (p[b + 1] - p[min(rt[a], b)]));
tmp += ((double)rd + calc(min(rt[a], b) + 1, b, 1, d)) * (1.0 - t);
ret += tmp;
tmp = 0;
rd = h;
if (d)
rd -= max(0, (h * 2 - (p[b + 1] - p[b])));
else if (b < n - 1)
rd -= max(0, h - (p[b + 1] - p[b]));
tmp += ((double)rd + calc(a, b - 1, c, 0)) * (1.0 - t);
ld = h + p[b] - p[max(a, lt[b])];
if (c)
ld -= max(0, (h * 2 - (p[max(a, lt[b])] - p[a - 1])));
else if (a)
ld -= max(0, h - (p[max(a, lt[b])] - p[a - 1]));
tmp += ((double)ld + calc(a, max(a, lt[b]) - 1, c, 1)) * t;
ret += tmp;
return dp[a][b][c][d] = ret / 2;
}
int main() {
int a, b;
double c;
scanf("%d%d%lf", &a, &b, &c);
n = a;
t = c;
h = b;
for (int i = 0; i < a; i++) {
scanf("%d", p + i);
}
std::sort(p, p + a);
int now = 0;
for (int i = 0; i < a; i++) {
lt[i] = now;
if (i < a - 1 && p[i + 1] - p[i] >= b) now = i + 1;
}
now = a - 1;
for (int i = a - 1; i >= 0; i--) {
rt[i] = now;
if (i >= 0 && p[i] - p[i - 1] >= b) now = i - 1;
}
for (int i = 0; i < 2100; i++)
for (int j = 0; j < 2100; j++) {
for (int k = 0; k < 2; k++)
for (int l = 0; l < 2; l++) dp[i][j][k][l] = -1;
}
printf("%.12f\n", calc(0, a - 1, 0, 0));
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
class MaxFlowSolver {
public:
int S, D;
vector<vector<int> > F;
vector<vector<int> > C;
vector<bool> viz;
vector<int> T;
vector<int> Q;
int stq, drq;
vector<vector<int> > G;
MaxFlowSolver(int n) {
n += 3;
S = 0;
D = n - 1;
F.resize(n);
C.resize(n);
viz.resize(n);
T.resize(n);
Q.resize(n);
stq = drq = 0;
G.resize(n);
for (int i = 0; i < n; i++) {
F[i].resize(n);
C[i].resize(n);
G[i].resize(n);
}
}
void add_edge(int u, int v, int w) {
G[u].push_back(v);
G[v].push_back(u);
C[u][v] += w;
}
bool BFS(int S, int D) {
Q[stq = drq = 1] = S;
fill(viz.begin(), viz.end(), 0);
viz[S] = 1;
while (stq <= drq) {
int nod = Q[stq++];
if (nod == D) continue;
for (auto it : G[nod]) {
if (!viz[it] && F[nod][it] < C[nod][it]) {
viz[it] = 1;
T[it] = nod;
Q[++drq] = it;
}
}
}
return viz[D];
}
int maxflow() {
int flow = 0;
while (BFS(S, D)) {
for (auto it : G[D]) {
if (!viz[it] || F[it][D] == C[it][D]) continue;
int fmin = 1 << 30;
T[D] = it;
for (int nod = D; nod != S; nod = T[nod])
fmin = min(fmin, C[T[nod]][nod] - F[T[nod]][nod]);
if (!fmin) continue;
for (int nod = D; nod != S; nod = T[nod]) {
F[T[nod]][nod] += fmin;
F[nod][T[nod]] -= fmin;
}
flow += fmin;
}
}
return flow;
}
};
const int NMAX = 100;
int n, m;
int a[NMAX + 5];
int u[NMAX + 5];
int v[NMAX + 5];
int cnt[NMAX + 5];
vector<int> primes;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
int ba = a[i];
for (int j = 2; 1LL * j * j <= a[i]; j++) {
if (a[i] % j == 0) {
primes.push_back(j);
while (a[i] % j == 0) {
a[i] /= j;
}
}
}
if (a[i] != 1) {
primes.push_back(a[i]);
}
a[i] = ba;
}
sort(primes.begin(), primes.end());
primes.resize(unique(primes.begin(), primes.end()) - primes.begin());
for (int j = 1; j <= m; j++) {
scanf("%d %d", &u[j], &v[j]);
if (u[j] % 2 == 1) {
swap(u[j], v[j]);
}
}
int ans = 0;
for (auto it : primes) {
MaxFlowSolver tmp(n + 4);
for (int i = 1; i <= n; i++) {
cnt[i] = 0;
while (a[i] % it == 0) {
cnt[i]++;
a[i] /= it;
}
if (cnt[i]) {
if (i % 2 == 0)
tmp.add_edge(tmp.S, i, cnt[i]);
else
tmp.add_edge(i, tmp.D, cnt[i]);
}
}
for (int i = 1; i <= m; i++) {
tmp.add_edge(u[i], v[i], 100);
}
ans += tmp.maxflow();
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 7100;
int dp[N][2], s[2][N], k[N], n, vis[N][2], cnt[N][2];
queue<pair<int, int> > q;
int main() {
scanf("%d", &n);
scanf("%d", &k[0]);
for (int i = 0; i < k[0]; i++) scanf("%d", &s[0][i]);
scanf("%d", &k[1]);
for (int i = 0; i < k[1]; i++) scanf("%d", &s[1][i]);
memset(vis, 0, sizeof(vis));
dp[0][0] = dp[0][1] = 0;
q.push(make_pair(0, 0));
q.push(make_pair(0, 1));
while (!q.empty()) {
int t1 = q.front().first, t2 = q.front().second;
q.pop();
for (int i = 0; i < k[t2 ^ 1]; i++) {
int t = (t1 - s[t2 ^ 1][i] + n) % n;
if (t == 0) continue;
if (dp[t1][t2] == 0) {
dp[t][t2 ^ 1] = 1;
cnt[t][t2 ^ 1] = k[t2 ^ 1];
} else
cnt[t][t2 ^ 1]++;
if (!vis[t][t2 ^ 1] && cnt[t][t2 ^ 1] >= k[t2 ^ 1]) {
vis[t][t2 ^ 1] = 1;
q.push(make_pair(t, t2 ^ 1));
}
}
}
for (int i = 1; i < n; i++) {
if (vis[i][0]) {
if (dp[i][0])
printf("Win ");
else
printf("Lose ");
} else
printf("Loop ");
}
printf("\n");
for (int i = 1; i < n; i++) {
if (vis[i][1]) {
if (dp[i][1])
printf("Win ");
else
printf("Lose ");
} else
printf("Loop ");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MSIZE = 2e5 + 10;
const int INF = 1e9;
const int MAXMEMSET = 127;
vector<pair<int, int> > seg;
int timer = 0;
vector<vector<int> > g;
vector<int> id;
struct node {
int val = 0;
char add = 0;
};
int dfs(int v) {
id[timer] = v;
seg[v].first = seg[v].second = timer++;
for (int to : g[v]) seg[v].second = dfs(to);
return seg[v].second;
}
node t[MSIZE * 4];
void build(int a[], int v, int tl, int tr) {
if (tl == tr)
t[v].val = a[id[tl]];
else {
int tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
t[v].val = t[v * 2].val + t[v * 2 + 1].val;
}
}
void push(int v, int tl, int tr) {
if (t[v].add == 1) {
int tm = (tl + tr) / 2;
t[v * 2].val = tm - tl + 1 - t[v * 2].val;
t[v * 2 + 1].val = tr - tm - t[v * 2 + 1].val;
t[v * 2].add ^= 1;
t[v * 2 + 1].add ^= 1;
t[v].add = 0;
}
}
void update(int v, int tl, int tr, int l, int r) {
if (l > r) return;
if (l == tl && tr == r) {
t[v].val = tr - tl + 1 - t[v].val;
t[v].add ^= 1;
} else {
push(v, tl, tr);
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(r, tm));
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
t[v].val = t[v * 2].val + t[v * 2 + 1].val;
}
}
int get(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r) return t[v].val;
push(v, tl, tr);
int tm = (tl + tr) / 2;
return get(v * 2, tl, tm, l, min(tm, r)) +
get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n;
cin >> n;
g.resize(n);
seg.resize(n);
id.resize(n);
for (int i = 0; i < n - 1; ++i) {
int p;
cin >> p;
g[p - 1].push_back(i + 1);
}
int a[MSIZE];
for (int i = 0; i < n; ++i) cin >> a[i];
dfs(0);
build(a, 1, 0, n - 1);
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
string s;
int v;
cin >> s >> v;
v--;
if (s[0] == 'g')
cout << get(1, 0, n - 1, seg[v].first, seg[v].second) << '\n';
else
update(1, 0, n - 1, seg[v].first, seg[v].second);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
}
void online_judge() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
const int flag_max = 0x3f3f3f3f;
const long long OO = 1e6 + 9;
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long d[OO];
int main() {
fast();
long long n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
d[a]++;
d[b]++;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += (d[i] * (d[i] - 1LL) - d[i] * ((long long)n - d[i] - 1LL) +
((long long)n - d[i] - 1LL) * ((long long)n - d[i] - 2LL));
}
cout << ans / 6 << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ar[10000009], pr[10000009];
int ap[10000009];
int seen[10000009], cnt[10000009];
map<int, int> mymap;
vector<int> vec;
int main() {
int i, j, k, l;
long long N, M, L, K;
long long MOD = 1000000007, Q, index, ans, now, temp;
cin >> N >> L >> K;
M = L / N;
Q = L % N;
if (L % N) {
K = min(K, L / N + 1);
} else
K = min(K, L / N);
for (i = 1; i <= N; i++) {
int temppp;
scanf("%d", &temppp);
ar[i] = temppp;
vec.push_back(ar[i]);
}
if (N >= L) {
cout << L << endl;
return 0;
}
sort(vec.begin(), vec.end());
index = 0;
index++;
mymap[vec[0]] = index;
for (i = 1; i < N; i++) {
if (vec[i] != vec[i - 1]) {
index++;
mymap[vec[i]] = index;
}
}
for (i = 1; i <= N; i++) {
ar[i] = mymap[ar[i]];
pr[i] = ar[i];
cnt[ar[i]]++;
}
sort(pr + 1, pr + 1 + N);
for (j = 1; j <= N; j++) ap[pr[j]] = 1;
ans = 0;
for (i = 1; i <= K; i++) {
temp = 0;
for (j = 1; j <= N; j++) {
if (seen[pr[j]] == 0) {
temp += ap[pr[j]] * 1LL * cnt[pr[j]];
temp %= MOD;
seen[pr[j]] = 1;
}
}
temp %= MOD;
temp *= ((M - i + 1) % MOD);
temp %= MOD;
for (j = 1; j <= Q; j++) {
temp += ap[ar[j]];
temp %= MOD;
}
temp %= MOD;
ans += temp;
ans %= MOD;
for (j = 1; j <= N; j++) {
seen[pr[j]] = 0;
}
now = 0;
for (j = 1; j <= N; j++) {
if (seen[pr[j]] == 0) {
now += ap[pr[j]] * 1LL * cnt[pr[j]];
now %= MOD;
ap[pr[j]] = now;
seen[pr[j]] = 1;
}
}
for (j = 1; j <= N; j++) {
seen[pr[j]] = 0;
}
}
cout << ans % MOD << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, u, v;
int p1 = 2, p2 = 2, p3 = 3;
pair<pair<int, int>, int> P[100004];
pair<int, int> ans[100004];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
P[i] = make_pair(make_pair(u, -v), i);
}
sort(P, P + m);
for (int i = 0; i < m; i++) {
int a = P[i].first.first, b = P[i].first.second, c = P[i].second;
if (b == -1) {
ans[c] = make_pair(1, p1), p1++;
} else {
if (p2 == 1) p3++, p2 = p3 - 1;
if (p3 >= p1) return cout << -1, 0;
ans[c] = make_pair(p2, p3), p2--;
}
}
for (int i = 0; i < m; i++) printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s;
long long t;
int C[100010];
int main() {
scanf("%d%d%d%lld", &n, &m, &s, &t);
s--;
while (t % n) {
if (s < m)
s = s + (t % n);
else
s = s - (t % n);
s = (s % n + n) % n;
t--;
}
memset(C, 255, sizeof(C));
while (t) {
if (C[s] != -1) {
vector<int> cur;
for (int p = C[s]; p != s; p = C[p]) cur.push_back(p);
cur.push_back(s);
printf("%d\n", cur[(t / n - 1) % cur.size()] + 1);
return 0;
}
int p = s;
for (int i = n - 1; i >= 1; i--) {
if (s < m)
s = s + i;
else
s = s - i + n;
s = s % n;
}
C[p] = s;
t -= n;
}
printf("%d\n", s + 1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, dp[100005], a[100005], ans;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%lld", &x);
a[x]++;
}
for (int i = 1; i <= 100000; i++) a[i] = a[i] * i;
dp[1] = a[1];
dp[2] = max(a[1], a[2]);
for (int i = 3; i <= 100000; i++) {
dp[i] = max(dp[i - 1], max(dp[i - 2], dp[i - 3]) + a[i]);
}
cout << dp[100000] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ToInt(string& s, int len) {
int r = 0;
for (int i = 0, max_ = (len); i < max_; ++i) {
r *= 10;
r += s[i] - '0';
}
return r;
}
int GCD(int a, int b) { return b != 0 ? GCD(b, a % b) : a; }
int LCM(int a, int b) { return a * (b / GCD(a, b)); }
long long Pow(long long n, long long e) {
if (e == 0) return 1;
if (e == 1)
return n;
else if (e & 1) {
long long t = Pow(n, e / 2);
return n * t * t;
} else {
long long t = Pow(n, e / 2);
return t * t;
}
}
int x[100005], yes[100005], no[100005];
int main() {
int N, M, y = 0, n = 0;
scanf("%d %d", &N, &M);
for (int i = 0, max_ = (N); i < max_; ++i) {
scanf("%d", &x[i]);
if (x[i] > 0) {
++yes[x[i]];
++y;
} else if (x[i] < 0) {
++no[-x[i]];
++n;
}
}
vector<int> v;
int valid = 0;
for (int i = (1), max_ = (N + 1); i < max_; ++i) {
int t = yes[i] + n - no[i];
if (t == M) {
++valid;
v.push_back(i);
}
}
for (int i = 0, max_ = (N); i < max_; ++i) {
if (x[i] > 0) {
bool f = binary_search((v).begin(), (v).end(), x[i]);
if (!f) {
printf("Lie\n");
} else {
if ((int)(v).size() == 1)
printf("Truth\n");
else
printf("Not defined\n");
}
} else {
bool f = binary_search((v).begin(), (v).end(), -x[i]);
if (!f) {
printf("Truth\n");
} else {
if ((int)(v).size() == 1)
printf("Lie\n");
else
printf("Not defined\n");
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int c, tt, n, x, y, z, m;
while (scanf("%d%d", &n, &m) == 2) {
while (n--) {
scanf("%d%d%d", &x, &y, &z);
if (x == y) {
printf("%d\n", z);
continue;
}
int k = 2 * m - 2;
int a = z / k;
int b = z % k;
if (b >= m - 1) {
c = 2 * m - b - 1;
if (x <= c) {
tt = a * k + b + c - x;
c = x;
if (c >= y)
tt += (x - y);
else
tt += (x + y - 2);
} else {
tt = a * k + b + x + c - 2;
c = x;
if (c <= y)
tt += (y - c);
else
tt += (2 * (m - c) + c - y);
}
} else {
c = b + 1;
if (x >= c) {
tt = a * k + b + x - c;
c = x;
if (c <= y)
tt += (y - x);
else
tt += (2 * (m - c) + c - y);
} else {
tt = a * k + b + 2 * (m - c) + c - x;
c = x;
if (y <= c)
tt += (c - y);
else
tt += (2 * (c - 1) + y - c);
}
}
printf("%d\n", tt);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, i, j, p;
int b[101010], a[100100], mii = 0x3f3f3f3f;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
if (n == 1 || n == 2) {
for (i = 1; i <= n; i++) {
cin >> a[i];
}
cout << 0;
return 0;
}
k = 0;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
int y;
for (i = -1; i <= 1; i++) {
for (j = -1; j <= 1; j++) {
y = 1;
int s = abs(i) + abs(j);
b[1] = a[1] + i;
b[2] = a[2] + j;
p = b[2] - b[1];
for (k = 3; k <= n; k++) {
b[k] = b[k - 1] + p;
if (abs(b[k] - a[k]) > 1) {
y = 0;
break;
}
if (b[k] != a[k]) {
s++;
}
}
if (y) {
mii = min(mii, s);
}
}
}
if (mii != 0x3f3f3f3f)
cout << mii;
else
cout << -1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200024;
int s[MAX_N], k[MAX_N];
vector<int> v[MAX_N];
bool used[MAX_N];
int main() {
int n, ans = 0, p;
cin >> n;
s[0] = 1;
for (int i = 1; i < n; i++) {
cin >> p;
s[i] = s[p - 1] + 1;
}
for (int i = 0; i < n; i++) {
k[s[i]]++;
}
for (int i = 0; i < 2 * n; i++) ans += k[i] % 2;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5, M = 2e6;
struct CPOINT {
int x, y;
int& operator[](int id) { return id == 1 ? x : y; }
bool operator<(const CPOINT& Cb) const& {
if (x == Cb.x) return y < Cb.y;
return x < Cb.x;
}
} pnt[N + 3];
double Tex(CPOINT Ca, CPOINT Cb) {
return Ca.x == Cb.x ? (Ca.y > Cb.y ? -1e9 : 1e9)
: double(Ca.y - Cb.y) / (Ca.x - Cb.x);
}
struct SSTACK {
int stk[N + 3], top;
void Push(int Vv) { stk[++top] = Vv; }
int Size() { return top; }
void Pop() { stk[top--] = 0; }
int Fir() { return stk[top]; }
int Sec() { return stk[top - 1]; }
int& operator[](int id) { return stk[id]; }
};
SSTACK Sup, Slow;
int n;
int Cn[M + 3];
long long Rcnt;
int GetLowY(CPOINT Ca, CPOINT Cb, int x) {
if (x == Ca.x) {
if (Cb.x == Ca.x) return max(Cb.y, Ca.y);
return Ca.y;
}
int Rl = -1, Rr = 2e6 + 1;
while (Rl + 1 < Rr) {
int Rm = (Rl + Rr) >> 1;
if (1ll * (Rm - Ca.y) * (Cb.x - Ca.x) <= 1ll * (Cb.y - Ca.y) * (x - Ca.x))
Rl = Rm;
else
Rr = Rm;
}
return Rl;
}
int GetHigY(CPOINT Ca, CPOINT Cb, int x) {
if (x == Ca.x) {
if (Cb.x == Ca.x) return min(Cb.y, Ca.y);
return Ca.y;
}
int Rl = -1, Rr = 2e6 + 1;
while (Rl + 1 < Rr) {
int Rm = (Rl + Rr) >> 1;
if (1ll * (Rm - Ca.y) * (Cb.x - Ca.x) >= 1ll * (Cb.y - Ca.y) * (x - Ca.x))
Rr = Rm;
else
Rl = Rm;
}
return Rr;
}
long double Solve() {
sort(pnt + 1, pnt + 1 + n);
while (Sup.Size()) Sup.Pop();
while (Slow.Size()) Slow.Pop();
Sup.Push(1);
Sup.Push(2);
Slow.Push(1);
Slow.Push(2);
for (int i = 3; i <= n; i++) {
while (Sup.Size() >= 2 &&
Tex(pnt[Sup.Sec()], pnt[Sup.Fir()]) <= Tex(pnt[Sup.Fir()], pnt[i]))
Sup.Pop();
Sup.Push(i);
while (Slow.Size() >= 2 && Tex(pnt[Slow.Sec()], pnt[Slow.Fir()]) >=
Tex(pnt[Slow.Fir()], pnt[i]))
Slow.Pop();
Slow.Push(i);
}
int Lef = pnt[Sup[1]][1], Rig = pnt[Sup.Fir()][1];
memset(Cn, 0, sizeof Cn);
long double totCn = 0, Rs = 0, totCni = 0, totCni2 = 0;
int Vup = 2, Vlow = 2;
Rcnt = 0;
for (int i = Lef; i <= Rig; i++) {
while (i > pnt[Sup[Vup]][1]) Vup++;
while (i > pnt[Slow[Vlow]][1]) Vlow++;
Cn[i] = GetLowY(pnt[Sup[Vup - 1]], pnt[Sup[Vup]], i) -
GetHigY(pnt[Slow[Vlow - 1]], pnt[Slow[Vlow]], i) + 1;
Rcnt += Cn[i];
totCn += (long double)Cn[i];
totCni += (long double)i * Cn[i];
totCni2 += (long double)i * i * Cn[i];
}
Rs = (totCn * totCni2 - totCni * totCni);
return Rs;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &pnt[i][1], &pnt[i][2]);
pnt[i][1] += (int)1e6;
pnt[i][2] += (int)1e6;
}
long double Vans = Solve();
for (int i = 1; i <= n; i++) swap(pnt[i][1], pnt[i][2]);
Vans += Solve();
printf("%.10f\n", double(Vans / Rcnt / (Rcnt - 1)));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
const int mov[8][2] = {{2, 1}, {2, -1}, {1, 2}, {1, -2},
{-1, 2}, {-1, -2}, {-2, 1}, {-2, -1}};
int n, m;
int fw[N][N], fb[N][N];
void bfs(int sx, int sy, int f[][N]) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
f[i][j] = -1;
}
}
int x, y, nx, ny;
queue<pair<int, int>> Q;
f[sx][sy] = 0;
Q.push({sx, sy});
while (!Q.empty()) {
x = Q.front().first;
y = Q.front().second;
Q.pop();
for (int k = 0; k < 8; k++) {
nx = x + mov[k][0], ny = y + mov[k][1];
if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
if (f[nx][ny] == -1) {
f[nx][ny] = f[x][y] + 1;
Q.push({nx, ny});
}
}
}
}
void go(int x, int y, int f[][N]) {
int nx, ny;
while (f[x][y]) {
for (int k = 0; k < 8; k++) {
nx = x + mov[k][0], ny = y + mov[k][1];
if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
if (f[nx][ny] >= 0 && f[nx][ny] < f[x][y]) {
x = nx;
y = ny;
break;
}
}
printf("%d %d\n", x, y);
}
}
int main() {
int xw, yw, xb, yb, hn, hm;
scanf("%d%d", &n, &m);
scanf("%d%d%d%d", &xw, &yw, &xb, &yb);
hn = n >> 1, hm = m >> 1;
bfs(hn, hm, fw);
bfs(hn + 1, hm, fb);
double tw = fw[xw][yw];
double tb = fb[xb][yb] + 0.5;
double twb = fb[xw][yw];
double tbb = fw[xb][yb] + 0.5;
if (((xw + yw) & 1) ^ ((xb + yb) & 1)) {
if (tw < tb) {
puts("WHITE");
go(xw, yw, fw);
} else if (twb < tb + 1) {
puts("WHITE");
if (fb[xw][yw]) {
go(xw, yw, fb);
} else {
printf("%d %d\n", xw - 2, yw - 1);
printf("%d %d\n", xw, yw);
}
go(hn + 1, hm, fw);
} else {
puts("BLACK");
go(xb, yb, fb);
}
} else {
if (tb < tw) {
puts("BLACK");
go(xb, yb, fb);
} else if (tbb < tw + 1) {
puts("BLACK");
if (fw[xb][yb]) {
go(xb, yb, fw);
} else {
printf("%d %d\n", xb - 2, yb - 1);
printf("%d %d\n", xb, yb);
}
go(hn, hm, fb);
} else {
puts("WHITE");
go(xw, yw, fw);
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int NUM = 4e5 + 5;
const int mod = 1e9 + 7;
long long INF = 1e9;
pair<int, int> pinf = {INF, INF};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int a, b;
cin >> a >> b;
for (int x = -a + 1; x < a; x++)
for (int y = -a + 1; y < a; y++) {
if (x * x + y * y != a * a) continue;
int x1 = y;
int y1 = -x;
if (b * x1 % a != 0 || b * y1 % a != 0) continue;
int x2 = x + (b * x1) / a;
int y2 = y + (b * y1) / a;
if (x2 != x && x2 != 0 && y2 != 0 && y2 != y) {
cout << "YES" << endl;
cout << 0 << ' ' << 0 << endl;
cout << x << ' ' << y << endl;
cout << x2 << ' ' << y2 << endl;
return 0;
}
}
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, a, b, c, d, i, j, k, l, n, m, x, y, s, v, h, h1, h2;
cin >> n >> m >> t;
l = 1;
k = 1;
a = 1;
b = 1;
x = 1;
j = 0;
if (n >= t) {
y = t - 1;
x = 1;
} else if (n < t) {
x = t - n;
y = n;
}
while (1) {
k = 1;
l = 1;
a = 1;
b = 1;
if (y < 4 || x > m) break;
h = n;
for (i = 1; i <= y; i++) {
l = l * h;
k = k * i;
if (l % k == 0) {
l = l / k;
k = 1;
}
--h;
}
h1 = m;
for (i = 1; i <= x; i++) {
a = a * h1;
b = b * i;
if (a % b == 0) {
a = a / b;
b = 1;
}
h1--;
}
s = l / k;
v = a / b;
j += (l * a);
y--;
x++;
}
cout << j;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1 = "qwertyuiopasdfghjkl;zxcvbnm,./";
string s;
char c;
cin >> c;
int cnt;
if (c == 'R')
cnt = -1;
else
cnt = 1;
cin >> s;
for (int i = 0; i < s.length(); i++) {
char x = s[i];
for (int j = 0; j < s1.length(); j++)
if (s1[j] == x) {
cout << s1[j + cnt];
break;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int K = 30;
int n, m;
vector<pair<int, int>> g[N];
bitset<N> vis;
int d[N];
int base[K + 5];
void add(int x) {
for (int i = K; i >= 0; i--) {
bool bit = (x & (1 << i));
if (bit) {
if (base[i] == 0) {
base[i] = x;
return;
} else {
x = (x ^ base[i]);
}
}
}
}
void dfs(int u) {
vis[u] = 1;
for (auto e : g[u]) {
int v = e.first;
int w = e.second;
if (vis[v]) {
int cur = (d[v] ^ w ^ d[u]);
add(cur);
} else {
d[v] = (d[u] ^ w);
dfs(v);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
}
dfs(1);
int ans = d[n];
for (int i = K; i >= 0; i--) {
ans = min(ans, (ans ^ base[i]));
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int a1 = 0, a2 = 0, a3 = 0, b1 = 0, b2 = 0, b3 = 0;
int max(int a, int b);
scanf("%d%d", &a1, &b1);
scanf("%d%d", &a2, &b2);
scanf("%d%d", &a3, &b3);
int temp = 0, sum[5] = {0}, longl[5] = {0};
sum[1] = a2 + a3;
sum[2] = a2 + b3;
sum[3] = a3 + b2;
sum[4] = b3 + b2;
longl[1] = max(b2, b3);
longl[2] = max(a3, b2);
longl[3] = max(a2, b3);
longl[4] = max(a3, a2);
int i = 0;
for (i = 1; i < 5; i++) {
if ((sum[i] <= a1 && longl[i] <= b1) || (sum[i] <= b1 && longl[i] <= a1)) {
printf("YES\n");
break;
}
}
if (i == 5) {
printf("NO\n");
}
}
int max(int a, int b) {
int shu = 0;
shu = (a > b) ? a : b;
return shu;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int finish = 0;
vector<long long> ans;
void dfs(long long s, long long t) {
if (s > t || s < 0) return;
if (s == t) {
finish = 1;
cout << "YES"
<< "\n";
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << ("");
}
if (finish) return;
ans.push_back(s * 10 + 1);
dfs(s * 10 + 1, t);
ans.pop_back();
ans.push_back(2 * s);
dfs(2 * s, t);
ans.pop_back();
}
int main() {
int s, t;
cin >> s >> t;
ans.push_back(s);
dfs(s, t);
if (!finish) cout << ("NO");
ans.pop_back();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int LINES = 1e3;
const int COLORS = 3;
const int MOVES = 3;
const int NIMS = 4;
const long long MOD = 998244353;
int linesCount;
int linesSizes[LINES];
vector<pair<int, int>> colored[LINES];
int availableMoves[COLORS];
void read() {
cin >> linesCount;
for (int i = 0; i < linesCount; ++i) {
cin >> linesSizes[i];
}
int coloredCount;
cin >> coloredCount;
while (coloredCount--) {
int line, index, color;
cin >> line >> index >> color;
--line, --index, --color;
colored[line].push_back({index, color});
}
for (int i = 0; i < linesCount; ++i) {
sort(colored[i].begin(), colored[i].end());
}
for (int color = 0; color < COLORS; ++color) {
for (int move = 0; move < MOVES; ++move) {
int value;
cin >> value;
availableMoves[color] |= (value << move);
}
}
}
struct Vector {
static const int SIZE = NIMS * NIMS * NIMS;
long long at[SIZE];
Vector() {
for (int i = 0; i < SIZE; ++i) {
at[i] = 0;
}
}
};
struct Matrix {
static const int SIZE = NIMS * NIMS * NIMS;
long long at[SIZE][SIZE];
Matrix() {
for (int i = 0; i < SIZE; ++i) {
for (int j = 0; j < SIZE; ++j) {
at[i][j] = 0;
}
}
}
Matrix operator*(const Matrix& other) const {
Matrix result;
for (int i = 0; i < SIZE; ++i) {
for (int j = 0; j < SIZE; ++j) {
for (int k = 0; k < SIZE; ++k) {
result.at[i][j] += at[i][k] * other.at[k][j];
result.at[i][j] %= MOD;
}
}
}
return result;
}
Vector operator*(const Vector& other) const {
Vector result;
for (int i = 0; i < SIZE; ++i) {
for (int j = 0; j < SIZE; ++j) {
result.at[i] += at[i][j] * other.at[j];
result.at[i] %= MOD;
}
}
return result;
}
};
const int TRANSFORMATIONS = 31;
Matrix unknownColorPartialTransformations[TRANSFORMATIONS];
Matrix knownColorTransformations[COLORS];
inline int nimArrayToIndex(int* nims) {
return (nims[0] << 4) | (nims[1] << 2) | nims[2];
}
inline bool nextNimArray(int* nims) {
int i;
for (i = 0; i < MOVES; ++i) {
++nims[i];
if (nims[i] == NIMS) {
nims[i] = 0;
} else {
break;
}
}
return i != MOVES;
}
inline int mexOfNimArray(int* nims, int mask) {
bool used[NIMS] = {};
int i;
for (i = 0; i < MOVES; ++i) {
if (mask & (1 << i)) {
used[nims[i]] = true;
}
}
for (i = 0; used[i]; ++i) {
}
return i;
}
void formTransformations() {
int curNims[MOVES] = {};
do {
for (int color = 0; color < COLORS; ++color) {
int nextNims[MOVES] = {mexOfNimArray(curNims, availableMoves[color]),
curNims[0], curNims[1]};
int curIndex = nimArrayToIndex(curNims);
int nextIndex = nimArrayToIndex(nextNims);
++unknownColorPartialTransformations[0].at[nextIndex][curIndex];
++knownColorTransformations[color].at[nextIndex][curIndex];
}
} while (nextNimArray(curNims));
for (int i = 1; i < TRANSFORMATIONS; ++i) {
unknownColorPartialTransformations[i] =
unknownColorPartialTransformations[i - 1] *
unknownColorPartialTransformations[i - 1];
}
}
void updateConditionWithKnownColor(Vector& condition, int color) {
condition = knownColorTransformations[color] * condition;
}
void updateConditionWithUnknownColor(Vector& condition, int iterations) {
for (int part = 0; part < TRANSFORMATIONS; ++part) {
if (iterations & (1 << part)) {
condition = unknownColorPartialTransformations[part] * condition;
}
}
}
long long solve() {
formTransformations();
long long sets[NIMS] = {1, 0, 0, 0};
int initialNims[MOVES] = {3, 3, 3};
for (int line = 0; line < linesCount; ++line) {
Vector curCondition;
curCondition.at[nimArrayToIndex(initialNims)] = 1;
int nextPos = 0;
int nextCell = 0;
while (nextPos < linesSizes[line]) {
if (nextCell == colored[line].size()) {
int jump = linesSizes[line] - nextPos;
updateConditionWithUnknownColor(curCondition, jump);
nextPos += jump;
} else if (nextPos < colored[line][nextCell].first) {
int jump = colored[line][nextCell].first - nextPos;
updateConditionWithUnknownColor(curCondition, jump);
nextPos += jump;
} else {
updateConditionWithKnownColor(curCondition,
colored[line][nextCell].second);
++nextCell;
++nextPos;
}
}
int curNims[MOVES] = {};
long long setsAdditions[NIMS] = {};
do {
setsAdditions[curNims[0]] += curCondition.at[nimArrayToIndex(curNims)];
setsAdditions[curNims[0]] %= MOD;
} while (nextNimArray(curNims));
long long newSets[NIMS] = {};
for (int nim = 0; nim < NIMS; ++nim) {
for (int nimAdd = 0; nimAdd < NIMS; ++nimAdd) {
newSets[nim ^ nimAdd] += sets[nim] * setsAdditions[nimAdd];
newSets[nim ^ nimAdd] %= MOD;
}
}
copy(newSets, newSets + NIMS, sets);
}
return sets[0];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
read();
cout << solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
class Graph {
int V;
list<int> *adj;
public:
Graph(int V);
void addEdge(int v, int w);
void longestPathLength();
pair<int, int> bfs(int u);
};
Graph::Graph(int V) {
this->V = V;
adj = new list<int>[V];
}
void Graph::addEdge(int v, int w) {
adj[v].push_back(w);
adj[w].push_back(v);
}
pair<int, int> Graph::bfs(int u) {
int dis[V];
memset(dis, -1, sizeof(dis));
queue<int> q;
q.push(u);
dis[u] = 0;
while (!q.empty()) {
int t = q.front();
q.pop();
for (auto it = adj[t].begin(); it != adj[t].end(); it++) {
int v = *it;
if (dis[v] == -1) {
q.push(v);
dis[v] = dis[t] + 1;
}
}
}
int maxDis = 0;
int nodeIdx;
for (int i = 0; i < V; i++) {
if (dis[i] > maxDis) {
maxDis = dis[i];
nodeIdx = i;
}
}
return make_pair(nodeIdx, maxDis);
}
void Graph::longestPathLength() {
pair<int, int> t1, t2;
t1 = bfs(1);
t2 = bfs(t1.first);
cout << t2.second;
}
int main() {
int n, m;
cin >> n >> m;
Graph g(n + 1);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g.addEdge(a, b);
}
g.longestPathLength();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
map<long long, long long> hash;
for (i = 0; i < n; i++) {
int d, b;
cin >> b >> d;
hash[b]++;
hash[d]--;
}
int mi = 0, a = 0, b = 0;
for (auto it : hash) {
mi += it.second;
if (mi > b) {
b = mi;
a = it.first;
}
}
cout << a << " " << b << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> n;
cout << (n - 2) * (n - 2) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, k, temp;
cin >> n >> k;
if (n % 2 == 0) {
if (k % 2 == 1) {
cout << "NO";
} else {
temp = sqrt(n);
if (temp >= k) {
cout << "YES";
} else {
cout << "NO";
}
}
} else {
if (k % 2 == 0) {
cout << "NO";
} else {
temp = sqrt(n);
if (temp >= k) {
cout << "YES";
} else {
cout << "NO";
}
}
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x = 0, y = 0, z = 0;
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
x += a;
y += b;
c += z;
}
if (!x && !y && !z)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
long long a, b, gc;
long long ga, gb, gcc;
cin >> a >> b;
gc = gcd(a, b);
gcc = a / gc * b;
ga = gcc / a - 1;
gb = gcc / b - 1;
if (ga < gb)
ga++;
else if (ga > gb)
gb++;
if (ga > gb)
cout << "Dasha" << endl;
else if (ga < gb)
cout << "Masha" << endl;
else
cout << "Equal" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
const int N = 200005;
int n;
int main() {
scanf("%d", &n);
long long ans = 0;
for (int a = 1; a <= n; ++a)
for (int b = a; b <= n; ++b) {
int c = a ^ b;
if (c <= n && c >= b && a + b > c) ++ans;
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
template <typename T>
inline bool chkmin(T& a, T b) {
return a > b ? a = b, true : false;
}
template <typename T>
inline bool chkmax(T& a, T b) {
return a < b ? a = b, true : false;
}
const int maxN = 1e5 + 5;
struct Edge {
int v, next;
Edge() {}
Edge(int v, int next) : v(v), next(next) {}
} G[maxN << 1];
int st[maxN], e;
void addedge(int u, int v) {
G[++e] = Edge(v, st[u]);
st[u] = e;
}
int N;
int dfn[maxN], dfs_clock, g[maxN][20], deep[maxN];
void dfs(int u, int fr) {
dfn[u] = ++dfs_clock;
g[u][0] = fr;
deep[u] = deep[fr] + 1;
for (int i = (1), _end = (18); i <= _end; ++i)
g[u][i] = g[g[u][i - 1]][i - 1];
for (int e = st[u]; e; e = G[e].next)
if (G[e].v != fr) dfs(G[e].v, u);
}
int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = (18), _end = (0); i >= _end; --i)
if (deep[g[x][i]] >= deep[y]) x = g[x][i];
if (x == y) return x;
for (int i = (18), _end = (0); i >= _end; --i)
if (g[x][i] != g[y][i]) x = g[x][i], y = g[y][i];
return g[x][0];
}
void PreWork() {
scanf("%d", &N);
for (int i = (1), _end = (N - 1); i <= _end; ++i) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
dfs(1, 0);
}
bool cmp(const int& x, const int& y) { return dfn[x] < dfn[y]; }
int M, Key[maxN];
void init() {
scanf("%d", &M);
for (int i = (1), _end = (M); i <= _end; ++i) scanf("%d", &Key[i]);
sort(Key + 1, Key + 1 + M, cmp);
}
int stk[maxN], tp;
bool isKey[maxN];
int f[maxN], HasKey[maxN];
;
inline void update(int u, int v) {
if (isKey[u]) {
if (isKey[v]) {
f[u] += f[v] + 1;
} else {
f[u] += f[v] + (HasKey[v] >= 1);
}
HasKey[u] = 1;
} else {
if (isKey[v]) {
HasKey[u]++;
f[u] += f[v];
} else {
HasKey[u] += HasKey[v] == 1;
f[u] += f[v] + (HasKey[v] >= 2);
}
}
}
int lover[maxN], fucker = 0;
int Dp() {
++fucker;
for (int i = (1), _end = (M); i <= _end; ++i) {
lover[Key[i]] = fucker;
if (lover[g[Key[i]][0]] == fucker) return -1;
}
int IdxKey = 1;
stk[tp = 1] = 1;
if (Key[1] == 1) {
isKey[1] = true;
IdxKey = 2;
HasKey[1] = 0;
} else {
isKey[1] = false;
HasKey[1] = 0;
}
f[1] = 0;
if (IdxKey <= M) {
stk[++tp] = Key[IdxKey++];
isKey[stk[tp]] = true;
HasKey[stk[tp]] = 0;
f[stk[tp]] = 0;
}
for (int i = (IdxKey), _end = (M); i <= _end; ++i) {
int u = stk[tp - 1], v = stk[tp], x = Key[i];
for (int lca = LCA(x, v); dfn[lca] < dfn[v];) {
if (dfn[lca] <= dfn[u]) {
update(u, v);
tp--;
} else {
stk[tp] = lca;
f[lca] = 0;
HasKey[lca] = 0;
isKey[lca] = false;
update(lca, v);
}
u = stk[tp - 1];
v = stk[tp];
}
stk[++tp] = x;
isKey[x] = true;
HasKey[x] = 0;
f[x] = 0;
}
while (tp > 1) {
int u = stk[tp - 1], v = stk[tp];
update(u, v);
tp--;
}
return f[1] + (isKey[1] == false && HasKey[1] >= 2);
}
int main() {
PreWork();
int T;
scanf("%d", &T);
for (int i = (1), _end = (T); i <= _end; ++i) {
init();
printf("%d\n", Dp());
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
char s[105][105 * 105];
char name[105][15];
int map[105][105];
int state[105][4];
int n, m;
long long w[105][2];
int flag[105];
int od[105];
int find(char *s) {
int i, o, p, j, k;
for (i = 0; i < m; ++i)
if (strcmp(s, name[i]) == 0) return i;
return -1;
}
void init() {
int i, o, p, j, k;
char s1[105], s2[105];
int x, y;
scanf("%d\n", &n);
for (i = 0; i < n; ++i) {
gets(s[i]);
for (j = 0; s[i][j]; ++j)
if (s[i][j] == '.') {
if (s[i][j + 1] == 's') {
if (s[i][j + 5] == 'b') {
sscanf(&s[i][j + 12], "%d", &p);
s[i][j] = 0;
state[find(s[i])][1] = p;
} else {
sscanf(&s[i][j + 13], "%d", &p);
s[i][j] = 0;
state[find(s[i])][2] = p;
}
} else {
s[i][strlen(s[i]) - 1] = 0;
s[i][j] = 0;
x = find(s[i]);
char *st = &s[i][j + 6];
y = find(st);
map[x][++map[x][0]] = y;
}
s[i][j] = '.';
break;
}
if (s[i][j] != '.') {
sscanf(s[i], "%s %s", s1, s2);
if (s1[0] == 'W') {
char *st;
st = &s2[0];
while (*st != '(') ++st;
*st = 0;
++st;
sscanf(st, "%d", &x);
while (*st != ',') ++st;
++st;
sscanf(st, "%d", &y);
if (find(s2) == -1) {
strcpy(name[m], s2);
state[m][0] = -1;
state[m][1] = x;
state[m][2] = y;
++m;
}
} else {
if (find(s2) == -1) {
strcpy(name[m], s2);
if (s1[0] == 'H')
state[m][0] = 0;
else
state[m][0] = 1;
++m;
}
}
}
}
}
void work(int k) {
int i, o, p, j;
long long x = 0, y = 0;
if (flag[k] != 0) return;
for (i = 1; i <= map[k][0]; ++i) {
p = map[k][i];
work(p);
if (state[k][0] == 0) {
x += w[p][0];
if (y < w[p][1]) y = w[p][1];
}
if (state[k][0] == 1) {
if (x < w[p][0]) x = w[p][0];
y += w[p][1];
}
}
if (map[k][0] != 0) {
if (state[k][0] == 0) x += (map[k][0] - 1) * state[k][2];
if (state[k][0] == 1) y += (map[k][0] - 1) * state[k][2];
x += state[k][1] * 2;
y += state[k][1] * 2;
}
if (state[k][0] == -1) {
x = state[k][1];
y = state[k][2];
}
flag[k] = 1;
w[k][0] = x;
w[k][1] = y;
}
void out(long long k, int t) {
int i, o, p, j;
if (t == 0 && k == 0) {
printf("0");
return;
}
if (k == 0) return;
out(k / 10, t + 1);
printf("%d", (int)(k % 10));
}
void output() {
int i, o, p, j, k;
for (i = 0; i < 105; ++i) od[i] = i;
for (i = 0; i < m; ++i)
for (j = i + 1; j < m; ++j)
if (strcmp(name[od[i]], name[od[j]]) > 0) {
p = od[i];
od[i] = od[j];
od[j] = p;
}
for (i = 0; i < m; ++i) {
p = od[i];
printf("%s ", name[p]);
out(w[p][0], 0);
printf(" ");
out(w[p][1], 0);
printf("\n");
}
}
int main() {
init();
int i;
for (i = 0; i < m; ++i) work(i);
output();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct st {
int neg, pos;
int ans;
st() { neg = pos = ans = 0; };
} tree[3 * 1000006], q[3 * 1000006];
void merge(int x, st T[]) {
T[x].ans = T[2 * x].ans + T[2 * x + 1].ans;
int omar = min(T[2 * x].pos, T[2 * x + 1].neg);
T[x].ans += 2 * omar;
T[x].pos = T[2 * x].pos - omar + T[2 * x + 1].pos;
T[x].neg = T[2 * x + 1].neg - omar + T[2 * x].neg;
}
char ar[1000006];
void init(int x, int a, int b) {
if (a == b) {
tree[x] = st();
if (ar[a] == ')')
tree[x].neg = 1;
else
tree[x].pos = 1;
return;
}
init(2 * x, a, (a + b) / 2);
init(2 * x + 1, (a + b) / 2 + 1, b);
merge(x, tree);
}
int query(int x, int a, int b, int i, int j) {
if (a > j || b < i) {
q[x] = st();
return 0;
}
if (i <= a && j >= b) {
q[x].ans = tree[x].ans;
q[x].neg = tree[x].neg;
q[x].pos = tree[x].pos;
return q[x].ans;
}
query(2 * x, a, (a + b) / 2, i, j);
query(2 * x + 1, (a + b) / 2 + 1, b, i, j);
merge(x, q);
return q[x].ans;
}
int main() {
scanf("%s", ar);
int n = strlen(ar);
int Q;
int u, v;
init(1, 0, n - 1);
scanf("%d", &Q);
while (Q--) {
scanf("%d%d", &u, &v);
printf("%d\n", query(1, 0, n - 1, u - 1, v - 1));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> actual;
int neighbor, dists[100010];
long long v[100010];
bool vis[100010];
vector<int> s[62], graph[100010], aux;
queue<pair<int, int> > q;
int bfs(int node) {
int b, ans = 1e9;
for (int k = 0; k < (int)graph[node].size(); k++) {
b = graph[node][k];
for (int i = 0; i < (int)aux.size(); i++)
vis[aux[i]] = false, dists[aux[i]] = 1e9;
aux.clear();
q.push(make_pair(0, node));
dists[node] = 0;
while (not q.empty()) {
actual = q.front();
q.pop();
if (vis[actual.second]) continue;
vis[actual.second] = true;
aux.emplace_back(actual.second);
for (int i = 0; i < (int)graph[actual.second].size(); i++) {
neighbor = graph[actual.second][i];
if (actual.second == node and neighbor == b) continue;
if (not vis[neighbor]) {
if (dists[actual.second] + 1 < dists[neighbor]) {
dists[neighbor] = dists[actual.second] + 1;
q.push(make_pair(dists[neighbor], neighbor));
}
}
}
}
ans = min(ans, dists[b] + 1);
}
return ans;
}
int main() {
int n;
bool nope;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &v[i]);
dists[i] = 1e9;
for (int j = 0; j < 62; j++) {
if ((v[i] & (1LL << ((long long)j))) != 0LL) s[j].emplace_back(i);
}
}
for (int i = 0; i < 62; i++) {
if (s[i].size() > 2) {
printf("3\n");
return 0;
}
}
for (int i = 0; i < 62; i++) {
for (int j = 0; j < (int)s[i].size(); j++) {
for (int k = j + 1; k < (int)s[i].size(); k++) {
nope = false;
for (int w = 0; w < (int)graph[s[i][j]].size(); w++) {
if (graph[s[i][j]][w] == s[i][k]) nope = true;
}
if (nope) continue;
graph[s[i][j]].emplace_back(s[i][k]);
graph[s[i][k]].emplace_back(s[i][j]);
}
}
}
int ans = 1e9;
for (int i = 0; i < n; i++) ans = min(ans, bfs(i));
printf("%d\n", ans == 1e9 ? -1 : ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct S {
long long a, b;
long long f(const S &other) const { return b + other.a; }
bool operator<(const S &other) const {
return this->f(other) < other.f(*this);
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<S> v(n);
for (S &s : v) cin >> s.a >> s.b;
sort(v.begin(), v.end());
long long res = 0;
for (int i = 0, j = 1; i < n; ++i, ++j)
res += v[i].a * (j - 1) + v[i].b * (n - j);
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> node[1010];
int main() {
int n, p, leafNode;
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
scanf("%d", &p);
node[p].push_back(i);
}
for (int i = 1; i <= n; i++) {
leafNode = 0;
if (!node[i].empty()) {
for (auto child : node[i])
if (node[child].empty()) leafNode++;
if (leafNode < 3) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
namespace IO {
static const int IN_BUF = 1 << 23, OUT_BUF = 1 << 23;
inline char myGetchar() {
static char buf[IN_BUF], *ps = buf, *pt = buf;
if (ps == pt) {
ps = buf, pt = buf + fread(buf, 1, IN_BUF, stdin);
}
return ps == pt ? EOF : *ps++;
}
template <typename T>
inline bool read(T &x) {
bool op = 0;
char ch = IO::myGetchar();
x = 0;
for (; !isdigit(ch) && ch != EOF; ch = IO::myGetchar()) {
op ^= (ch == '-');
}
if (ch == EOF) {
return false;
}
for (; isdigit(ch); ch = IO::myGetchar()) {
x = x * 10 + (ch ^ '0');
}
if (op) {
x = -x;
}
return true;
}
inline int readStr(char *s) {
int n = 0;
char ch = IO::myGetchar();
for (; isspace(ch) && ch != EOF; ch = IO::myGetchar())
;
for (; !isspace(ch) && ch != EOF; ch = IO::myGetchar()) {
s[n++] = ch;
}
s[n] = '\0';
return n;
}
inline void myPutchar(char x) {
static char pbuf[OUT_BUF], *pp = pbuf;
struct _flusher {
~_flusher() { fwrite(pbuf, 1, pp - pbuf, stdout); }
};
static _flusher outputFlusher;
if (pp == pbuf + OUT_BUF) {
fwrite(pbuf, 1, OUT_BUF, stdout);
pp = pbuf;
}
*pp++ = x;
}
template <typename T>
inline void print_(T x) {
if (x == 0) {
IO::myPutchar('0');
return;
}
std::vector<int> num;
if (x < 0) {
IO::myPutchar('-');
x = -x;
}
for (; x; x /= 10) {
num.push_back(x % 10);
}
while (!num.empty()) {
IO::myPutchar(num.back() ^ '0');
num.pop_back();
}
}
template <typename T>
inline void print(T x, char ch = '\n') {
print_(x);
IO::myPutchar(ch);
}
inline void printStr_(const char *s, int n = -1) {
if (n == -1) {
n = strlen(s);
}
for (int i = 0; i < n; ++i) {
IO::myPutchar(s[i]);
}
}
inline void printStr(const char *s, int n = -1, char ch = '\n') {
printStr_(s, n);
IO::myPutchar(ch);
}
} // namespace IO
using namespace IO;
const int N = 200005, LG = 18;
int n, l[N], r[N];
int p[N], a[N];
int Log[N], mn[N][LG];
std::vector<std::pair<int, int>> vec[N];
int my_min(int x, int y) { return l[p[x]] < l[p[y]] ? x : y; }
void initST() {
Log[1] = 0;
for (int i = 2; i <= n; ++i) {
Log[i] = Log[i >> 1] + 1;
}
for (int i = 1; i <= n; ++i) {
mn[i][0] = i;
}
for (int j = 1; j < LG; ++j) {
for (int i = 1; i + (1 << j) - 1 <= n; ++i) {
mn[i][j] = my_min(mn[i][j - 1], mn[i + (1 << (j - 1))][j - 1]);
}
}
}
int query(int l, int r) {
int t = Log[r - l + 1];
return my_min(mn[l][t], mn[r - (1 << t) + 1][t]);
}
int main() {
read(n);
for (int i = 1; i <= n; ++i) {
read(l[i]), read(r[i]);
vec[r[i]].push_back({l[i], i});
}
std::priority_queue<std::pair<int, int>> Q;
for (int i = n; i; --i) {
for (auto v : vec[i]) {
Q.push(v);
}
p[i] = Q.top().second;
Q.pop();
a[p[i]] = i;
}
initST();
int x = 0, y = 0;
for (int i = 1; i <= n; ++i) {
if (i == r[p[i]]) {
continue;
}
int j = query(i + 1, r[p[i]]);
if (l[p[j]] <= i) {
x = i, y = j;
break;
}
}
if (!x) {
printStr("YES");
for (int i = 1; i <= n; ++i) {
print(a[i], ' ');
}
IO::myPutchar('\n');
} else {
printStr("NO");
for (int i = 1; i <= n; ++i) {
print(a[i], ' ');
}
IO::myPutchar('\n');
std::swap(a[p[x]], a[p[y]]);
for (int i = 1; i <= n; ++i) {
print(a[i], ' ');
}
IO::myPutchar('\n');
}
}
| 9 |
#include <bits/stdc++.h>
long long x;
int n;
std::vector<int> d;
std::vector<long long> pre, s;
long long sum(int x, int y) {
if (x <= 0 || y <= 0) return 0;
return 1LL * y * (y + 1) / 2 - 1LL * x * (x - 1) / 2;
}
int main() {
std::cin >> n >> x;
d.resize(2 * n + 1, 0);
pre.resize(2 * n + 1, 0);
s.resize(2 * n + 1, 0);
for (int i = 1; i <= n; ++i) std::cin >> d[i], d[i + n] = d[i];
for (int i = 1; i <= 2 * n; ++i) pre[i] = pre[i - 1] + d[i];
for (int i = 1; i <= 2 * n; ++i) s[i] = s[i - 1] + sum(1, d[i]);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
long long can = pre[i - 1] + x;
int pos = std::lower_bound(pre.begin(), pre.end(), can) - pre.begin();
if (pos == i) {
ans = std::max(ans, sum(d[i] - x + 1, d[i]));
} else {
int cur = d[i], left = x - (pre[pos - 1] - pre[i - 1]), tail = pos;
ans = std::max(ans, s[pos - 1] - s[i - 1] + sum(1, left));
cur -= (d[tail] - left);
while (cur > 0 && tail <= 2 * n) {
ans = std::max(ans, s[tail] - s[i] + sum(d[i] - cur + 1, d[i]));
if (tail == n) break;
tail++;
cur -= d[tail];
}
}
}
std::cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5 + 1;
ll a[N], b[N];
vector<int> adj[N];
vector<int> order;
vector<bool> vis;
void dfs(int u) {
vis[u] = true;
for (int v : adj[u]) {
if (!vis[v]) dfs(v);
}
order.push_back(u);
}
void testcase() {
int n;
cin >> n;
for (int i = 1; i <= (n); ++i) cin >> a[i];
for (int i = 1; i <= (n); ++i) {
cin >> b[i];
if (b[i] != -1) {
adj[i].push_back(b[i]);
}
}
vis = vector<bool>(n + 1);
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i);
}
reverse(order.begin(), order.end());
vector<int> neg, pos;
ll sum = 0;
for (int o : order) {
sum += (ll)(a[o]);
if (a[o] < 0) {
neg.push_back(o);
} else {
pos.push_back(o);
if (b[o] >= 1) a[b[o]] += a[o];
}
}
cout << sum << "\n";
for (int o : pos) {
cout << o << " ";
}
reverse(neg.begin(), neg.end());
for (int o : neg) {
cout << o << " ";
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
if (0) cin >> t;
while (t--) {
testcase();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<int> global;
set<int> temp;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int numb;
cin >> numb;
global.insert(numb);
temp.insert(numb);
set<int> newTemp;
for (set<int>::iterator it = temp.begin(); it != temp.end(); ++it) {
newTemp.insert((*it | numb));
global.insert((*it | numb));
}
temp = newTemp;
}
cout << global.size();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const double PI = acos(-1);
template <class T>
constexpr T INF() {
return ::std::numeric_limits<T>::max();
}
template <class T>
constexpr T HINF() {
return INF<T>() / 2;
}
template <typename T_char>
T_char TL(T_char cX) {
return tolower(cX);
};
template <typename T_char>
T_char TU(T_char cX) {
return toupper(cX);
};
const int vy[] = {-1, -1, -1, 0, 1, 1, 1, 0},
vx[] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int popcnt(unsigned long long n) {
int cnt = 0;
for (int i = 0; i < 64; i++)
if ((n >> i) & 1) cnt++;
return cnt;
}
int d_sum(LL n) {
int ret = 0;
while (n > 0) {
ret += n % 10;
n /= 10;
}
return ret;
}
int d_cnt(LL n) {
int ret = 0;
while (n > 0) {
ret++;
n /= 10;
}
return ret;
}
LL gcd(LL a, LL b) {
if (b == 0) return a;
return gcd(b, a % b);
};
LL lcm(LL a, LL b) {
LL g = gcd(a, b);
return a / g * b;
};
char fld[3][3];
int cr, no;
int crc, noc;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
for (LL i = (0); i < (3); i++)
for (LL j = (0); j < (3); j++) {
cin >> fld[i][j];
if (fld[i][j] == 'X') cr++;
if (fld[i][j] == '0') no++;
}
if (!(no + 1 == cr || no == cr)) {
cout << "illegal" << endl;
return 0;
}
for (LL i = (0); i < (3); i++) {
if (fld[i][0] == 'X' && fld[i][1] == 'X' && fld[i][2] == 'X') crc++;
if (fld[i][0] == '0' && fld[i][1] == '0' && fld[i][2] == '0') noc++;
}
for (LL i = (0); i < (3); i++) {
if (fld[0][i] == 'X' && fld[1][i] == 'X' && fld[2][i] == 'X') crc++;
if (fld[0][i] == '0' && fld[1][i] == '0' && fld[2][i] == '0') noc++;
}
if (fld[0][0] == 'X' && fld[1][1] == 'X' && fld[2][2] == 'X') crc++;
if (fld[0][0] == '0' && fld[1][1] == '0' && fld[2][2] == '0') noc++;
if (fld[0][2] == 'X' && fld[1][1] == 'X' && fld[2][0] == 'X') crc++;
if (fld[0][2] == '0' && fld[1][1] == '0' && fld[2][0] == '0') noc++;
if (crc > 1 || noc > 1 || (crc == 1 && noc == 1)) {
if (abs(crc - noc) < 2) {
cout << "illegal" << endl;
return 0;
}
}
if ((cr == no + 1 && noc) || (no == cr && crc)) {
cout << "illegal" << endl;
return 0;
}
if (crc) {
cout << "the first player won" << endl;
return 0;
}
if (noc) {
cout << "the second player won" << endl;
return 0;
}
if (no + cr == 9) {
cout << "draw" << endl;
return 0;
}
if (no + 1 == cr) {
cout << "second" << endl;
return 0;
}
if (no == cr) {
cout << "first" << endl;
return 0;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int findIdx(const vector<long long> &verts, long long v) {
for (int i = 0; i < verts.size(); i++) {
if (verts[i] == v) return i;
}
return -1;
}
void solve() {
long long n, m, k;
cin >> n >> m >> k;
vector<pair<long long, pair<long long, long long>>> edges(m);
for (int i = 0; i < m; i++) {
cin >> edges[i].second.first >> edges[i].second.second >> edges[i].first;
}
sort(edges.begin(), edges.end());
vector<long long> verts;
for (int i = 0; i < min(m, k); i++) {
long long u = edges[i].second.first, v = edges[i].second.second;
verts.push_back(u);
verts.push_back(v);
}
verts.erase(unique(verts.begin(), verts.end()), verts.end());
long long INF = 1e17;
n = verts.size();
vector<vector<long long>> dp(n, vector<long long>(n, INF));
for (int i = 0; i < min(m, k); i++) {
long long u = edges[i].second.first, v = edges[i].second.second,
w = edges[i].first;
long long uIdx = findIdx(verts, u), vIdx = findIdx(verts, v);
dp[uIdx][vIdx] = w;
dp[vIdx][uIdx] = w;
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (dp[i][k] + dp[k][j] < dp[i][j]) dp[i][j] = dp[i][k] + dp[k][j];
}
}
}
vector<long long> mat;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
mat.push_back(dp[i][j]);
}
}
sort(mat.begin(), mat.end());
cout << mat[k - 1];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using T = pair<ld, ld>;
const ld eps = 1e-6;
inline ld ternary_search(T a1, T a2, T b1, T b2) {
ld l = 0.0, r = 1.0;
T v1 = T(a2.first - a1.first, a2.second - a1.second);
T v2 = T(b2.first - b1.first, b2.second - b1.second);
for (int i = 0; i < 99; i++) {
ld m1 = (l * 2.0 + r) / 3.0;
ld m2 = (l + 2.0 * r) / 3.0;
T p1 = T(a1.first + v1.first * m1, a1.second + v1.second * m1);
T p2 = T(b1.first + v2.first * m1, b1.second + v2.second * m1);
ld aux1 = (p2.first - p1.first) * (p2.first - p1.first) +
(p2.second - p1.second) * (p2.second - p1.second);
p1 = T(a1.first + v1.first * m2, a1.second + v1.second * m2);
p2 = T(b1.first + v2.first * m2, b1.second + v2.second * m2);
ld aux2 = (p2.first - p1.first) * (p2.first - p1.first) +
(p2.second - p1.second) * (p2.second - p1.second);
if (aux1 > aux2) {
l = m1;
} else {
r = m2;
}
}
T p1 = T(a1.first + v1.first * l, a1.second + v1.second * l);
T p2 = T(b1.first + v2.first * l, b1.second + v2.second * l);
return (p2.first - p1.first) * (p2.first - p1.first) +
(p2.second - p1.second) * (p2.second - p1.second);
}
int main() {
int n, d[3];
scanf("%d", &n);
scanf("%d %d", d + 1, d + 2);
vector<T> a(n), b(n);
for (int i = 0; i < n; i++) {
scanf("%Lf %Lf", &a[i].first, &a[i].second);
scanf("%Lf %Lf", &b[i].first, &b[i].second);
}
int ans = 0;
ld mx = 0.0;
bool can = false, notseen = true;
for (int i = 0; i < n - 1; i++) {
mx = max(mx, (a[i].first - b[i].first) * (a[i].first - b[i].first) +
(a[i].second - b[i].second) * (a[i].second - b[i].second));
can = can || (mx > d[2] * d[2]);
ld mn = ternary_search(a[i], a[i + 1], b[i], b[i + 1]);
if (notseen && mn - eps <= (ld)d[1] * d[1]) {
++ans;
mx = 0.0;
can = false;
notseen = false;
} else if (can && mn - eps <= (ld)d[1] * d[1]) {
++ans;
mx = 0.0;
can = false;
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 * 1e9;
const long long limit = 2 * 1e12;
const int mod = 1e9 + 7;
const int MOD = 1e9 + 711;
const int MOD2 = 1e9 + 933;
const int MOD3 = 1e9 + 993;
const int maxn = 7e6 + 100;
int main() {
cout.tie(0);
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
vector<long long> a(n + 1);
vector<long long> p;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (i > 1) {
p.push_back(a[i] - a[i - 1]);
}
}
sort(p.begin(), p.end());
if (k >= n) {
cout << 0;
return 0;
}
if (k == 1) {
cout << a[n] - a[1];
return 0;
}
long long ans = 0;
for (int i = 0; i < n - k; ++i) {
ans += p[i];
}
cout << ans;
cerr << "\n\nTime elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1005];
int ans = 1e9 + 5, anst;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int t = 1; t <= 100; t++) {
int tmp = 0;
for (int i = 1; i <= n; i++) {
tmp += min(abs(a[i] - t), min(abs(a[i] - t - 1), abs(a[i] - t + 1)));
}
if (ans > tmp) {
ans = tmp;
anst = t;
}
}
printf("%d %d\n", anst, ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
template <typename T>
inline void read(T& x) {
x = 0;
char temp = getchar();
bool f = false;
while (!isdigit(temp)) {
if (temp == '-') f = true;
temp = getchar();
}
while (isdigit(temp)) {
x = (x << 1) + (x << 3) + temp - '0';
temp = getchar();
}
if (f) x = -x;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
inline int Val(char s) { return s == '(' ? 1 : -1; }
int n, m;
char str[MAXN << 1];
int sum[MAXN << 3], lmax[MAXN << 3], lmin[MAXN << 3], rmax[MAXN << 3],
rmin[MAXN << 3], ld[MAXN << 3], rd[MAXN << 3], rad[MAXN << 3],
ans[MAXN << 3];
inline int ls(int x) { return x << 1; }
inline int rs(int x) { return x << 1 | 1; }
inline void Pushup(int id) {
sum[id] = sum[ls(id)] + sum[rs(id)];
lmax[id] = max(lmax[ls(id)], sum[ls(id)] + lmax[rs(id)]);
lmin[id] = min(lmin[ls(id)], sum[ls(id)] + lmin[rs(id)]);
rmax[id] = max(rmax[rs(id)], sum[rs(id)] + rmax[ls(id)]);
rmin[id] = min(rmin[rs(id)], sum[rs(id)] + rmin[ls(id)]);
ld[id] = max(ld[ls(id)],
max(ld[rs(id)] - sum[ls(id)], rad[ls(id)] + lmax[rs(id)]));
rd[id] = max(rd[rs(id)],
max(rd[ls(id)] + sum[rs(id)], rad[rs(id)] - rmin[ls(id)]));
rad[id] = max(rad[ls(id)] + sum[rs(id)], rad[rs(id)] - sum[ls(id)]);
ans[id] = max(max(ans[ls(id)], ans[rs(id)]),
max(ld[rs(id)] - rmin[ls(id)], rd[ls(id)] + lmax[rs(id)]));
}
void Build(int id, int l, int r) {
if (l == r) {
int v = Val(str[l]);
sum[id] = v;
lmax[id] = rmax[id] = max(0, v);
lmin[id] = rmin[id] = min(0, v);
ld[id] = rd[id] = rad[id] = ans[id] = 1;
return;
}
int mid = l + r >> 1;
Build(ls(id), l, mid), Build(rs(id), mid + 1, r);
Pushup(id);
}
void Modify(int id, int l, int r, int target, int val) {
if (l == r && l == target) {
int v = Val(str[l]);
sum[id] = v;
lmax[id] = rmax[id] = max(0, v);
lmin[id] = rmin[id] = min(0, v);
ld[id] = rd[id] = rad[id] = ans[id] = 1;
return;
}
int mid = l + r >> 1;
if (target <= mid)
Modify(ls(id), l, mid, target, val);
else
Modify(rs(id), mid + 1, r, target, val);
Pushup(id);
}
int main() {
read(n), read(m), n = n - 1 << 1;
scanf("%s", str + 1);
Build(1, 1, n);
print(ans[1]), puts("");
while (m--) {
int x, y;
read(x), read(y);
if (str[x] != str[y])
swap(str[x], str[y]), Modify(1, 1, n, x, Val(str[x])),
Modify(1, 1, n, y, Val(str[y]));
print(ans[1]), puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
#include <iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<cmath>
#include <iomanip>
#include<string.h>
#include<queue>
#include <map>
#define LL long long
#define MM 1000000007
#define ff first
#define ss second
#define pii pair<int, int>
using namespace std;
int main()
{
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
LL i,t,z,j,ans,n,m,temp,l,r,flag,k,co,t1,t2;
cin>>t;
for(z=0;z<t;z++)
{
cin>>t1>>t2;
ans=co=temp=0;
t1--;
cout<<t1<<" "<<t2<<"\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const long long mod = 1e9 + 7;
long long power(long long a, long long b, long long m = mod) {
if (b < 0) {
return power(power(a, -b), mod - 2);
}
long long x = 1;
while (b) {
if (b & 1) {
x = 1ll * x * a % m;
}
a = 1ll * a * a % m;
b /= 2;
}
return x;
}
const int N = 2e5 + 9;
vector<int> g[N], gr[N];
vector<int> topo;
void bye() {
cout << "-1\n";
exit(0);
}
int col[N];
void dfs(int u) {
col[u] = 1;
for (int v : g[u]) {
if (col[v] == 2) continue;
if (col[v] == 1) {
bye();
}
dfs(v);
}
col[u] = 2;
topo.push_back(u);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[v].push_back(u);
gr[u].push_back(v);
}
for (int i = 0; i < n; i++) {
if (col[i] == 0) {
dfs(i);
}
}
vector<int> f1(n + 2, n + 10), f2(n + 2, n + 10);
for (int u : topo) {
f1[u] = u;
for (int v : g[u]) {
f1[u] = min(f1[v], f1[u]);
}
}
reverse(topo.begin(), topo.end());
for (int u : topo) {
f2[u] = u;
for (int v : gr[u]) {
f2[u] = min(f2[v], f2[u]);
}
}
string ans;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (min(f1[i], f2[i]) >= i) {
ans += 'A';
cnt++;
} else
ans += 'E';
}
cout << cnt << endl << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
const long long mod = 1000000;
using namespace std;
int main() {
long long m, h1, a1, x1, y1, h2, a2, x2, y2;
cin >> m >> h1 >> a1 >> x1 >> y1 >> h2 >> a2 >> x2 >> y2;
long long i;
bool flag = 0;
long long i1, i2, j1, j2;
j1 = j2 = 0;
for (i = 0; i < mod; i++) {
h1 = (x1 * h1 + y1) % m;
if (h1 == a1) {
flag = 1;
i1 = i + 1;
break;
}
}
if (!flag) {
cout << -1 << endl;
return 0;
}
for (i = 0; i < mod; i++) {
h1 = (x1 * h1 + y1) % m;
if (h1 == a1) {
j1 = i + 1;
break;
}
}
flag = 0;
for (i = 0; i < mod; i++) {
h2 = (x2 * h2 + y2) % m;
if (h2 == a2) {
flag = 1;
i2 = i + 1;
break;
}
}
if (!flag) {
cout << -1 << endl;
return 0;
}
for (i = 0; i < mod; i++) {
h2 = (x2 * h2 + y2) % m;
if (h2 == a2) {
j2 = i + 1;
break;
}
}
flag = 0;
if (i1 == i2) {
cout << i1 << endl;
return 0;
} else {
if (i1 < i2) {
for (i = 0; i < mod; i++) {
i1 = i1 + j1;
if (j2 == 0 && i1 == i2) {
flag = 1;
cout << i1 << endl;
break;
}
if (j2 != 0 && (i1 - i2 >= 0) && (i1 - i2) % j2 == 0) {
flag = 1;
cout << i1 << endl;
break;
}
}
if (!flag) cout << -1 << endl;
} else {
for (i = 0; i < mod; i++) {
i2 = i2 + j2;
if (j1 == 0 && i1 == i2) {
flag = 1;
cout << i2 << endl;
break;
}
if (j1 != 0 && (i2 - i1 >= 0) && (i2 - i1) % j1 == 0) {
flag = 1;
cout << i2 << endl;
break;
}
}
if (!flag) cout << -1 << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 20;
int a, b, da, db, t, x;
long long saghf(long long a, long long b) {
if (b * (a / b) == a) return a / b;
return a / b + 1;
}
int gcd(int a, int b) {}
int f(int a, int b) {
if (a - b >= 0) return a - b;
return 0;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> x >> t >> a >> b >> da >> db;
for (int i = 0; i < t; i++) {
for (int j = 0; j < t; j++) {
if (f(a, da * i) + f(b, db * j) == x || f(a, da * i) == x ||
f(b, db * j) == x || f(b, db * i) == x || f(a, da * j) == x) {
cout << "YES";
return 0;
}
}
}
if (x == 0) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long INF = 1e18;
const double PI = acos(-1);
const long long tam = 1000100;
const long long MOD = 1e9 + 7;
const long long cmplog = 29;
int hijos[tam];
vector<int> g[tam];
pair<long long, long long> pcen;
int n;
void dfs(int u, int pa) {
hijos[u] = 1;
int maxx = 0;
for (int w : g[u]) {
if (w == pa) continue;
dfs(w, u);
hijos[u] += hijos[w];
maxx = max(maxx, hijos[w]);
}
maxx = max(maxx, n - hijos[u]);
pcen = min(pcen, pair<long long, long long>(maxx, u));
}
vector<pair<long long, long long> > queries[tam];
set<int> sdown[tam];
void dfs2(int u, int pa, int idx) {
hijos[u] = 1;
for (int w : g[u]) {
if (w == pa) continue;
dfs2(w, u, idx);
hijos[u] += hijos[w];
}
int pup = n - hijos[u];
queries[idx].push_back({pup, u});
sdown[idx].insert(hijos[u]);
}
int mejor(multiset<int> &s, int precio) {
auto it = s.upper_bound(precio / 2);
int ans = precio;
if (it != s.end()) {
ans = min(ans, max(precio - *it, *it));
}
if (it != s.begin()) {
it--;
ans = min(ans, max(precio - *it, *it));
}
return ans;
}
bool fans[tam];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
int iz, der;
for (long long i = 0; i < n - 1; i++) {
cin >> iz >> der;
g[iz].push_back(der);
g[der].push_back(iz);
}
pcen = pair<long long, long long>(n, n);
dfs(1, 1);
int ucen = pcen.second;
multiset<int> siz, sder;
for (long long i = 0; i < g[ucen].size(); i++) {
int w = g[ucen][i];
dfs2(w, ucen, i);
}
for (long long idx = 0; idx < g[ucen].size(); idx++) {
for (int xx : sdown[idx]) sder.insert(xx);
}
fans[ucen] = 1;
for (long long idx = 0; idx < g[ucen].size(); idx++) {
for (int xx : sdown[idx]) {
sder.erase(sder.find(xx));
}
for (auto par : queries[idx]) {
int u = par.second;
int pup = par.first;
int bst = min(mejor(siz, pup), mejor(sder, pup));
int otro = n - hijos[g[ucen][idx]];
bst = min(bst, max(pup - otro, otro));
if (bst <= n / 2)
fans[u] = 1;
else
fans[u] = 0;
}
for (int xx : sdown[idx]) {
siz.insert(xx);
}
}
for (long long i = 1; i < n + 1; i++) cout << fans[i] << ' ';
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int maxN = 2010;
int n;
int a[maxN];
int dp[maxN][maxN][2][2];
int pref[maxN][2], suff[maxN][2];
void getDp(int ind) {
dp[ind][ind][a[ind]][a[ind]] = 1;
for (int i = ind + 1; i <= n; i++) {
if (a[i] == 0) {
dp[ind][i][0][0] = dp[ind][i - 1][0][0] + 1;
dp[ind][i][1][0] = max(dp[ind][i - 1][1][0], dp[ind][i - 1][1][1]) + 1;
dp[ind][i][1][1] = dp[ind][i - 1][1][1];
} else {
dp[ind][i][0][0] = dp[ind][i - 1][0][0];
dp[ind][i][1][0] = dp[ind][i - 1][1][0];
dp[ind][i][1][1] = dp[ind][i - 1][1][1] + 1;
}
}
}
signed main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i]--;
}
for (int i = 1; i <= n; i++) getDp(i);
for (int i = 1; i <= n; i++) {
if (a[i] == 0) {
pref[i][0] = pref[i - 1][0] + 1;
pref[i][1] = pref[i - 1][1];
} else {
pref[i][0] = pref[i - 1][0];
pref[i][1] = max(pref[i - 1][0], pref[i - 1][1]) + 1;
}
}
for (int i = n; i >= 1; i--) {
if (a[i] == 0) {
suff[i][0] = max(suff[i + 1][0], suff[i + 1][1]) + 1;
suff[i][1] = suff[i + 1][1];
} else {
suff[i][0] = suff[i + 1][0];
suff[i][1] = suff[i + 1][1] + 1;
}
}
int ans = max(pref[n][0], pref[n][1]);
for (int l = 1; l < n; l++) {
for (int r = l + 1; r <= n; r++) {
ans = max(ans, pref[l - 1][0] + dp[l][r][1][0] + suff[r + 1][1]);
ans = max(ans, pref[l - 1][0] + dp[l][r][0][0] + suff[r + 1][0]);
ans = max(ans, pref[l - 1][0] + dp[l][r][0][0] + suff[r + 1][1]);
ans = max(ans, pref[l - 1][0] + dp[l][r][1][1] + suff[r + 1][1]);
ans = max(ans, pref[l - 1][1] + dp[l][r][1][1] + suff[r + 1][1]);
}
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int k, a, b;
scanf("%d", &k);
for (int i = 1; i < k; i++) {
for (int j = 1; j < k; j++) {
if (j == 1) {
printf("%d", i);
continue;
}
a = i * j / k;
b = i * j % k;
if (a == 0)
printf(" %d", b);
else
printf(" %d%d", a, b);
}
puts("");
}
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n;
std::cin >> n;
for (int i = 0; i < n; i++) {
bool flag = true;
int x;
std::cin >> x;
for (int a = 0; a <= 1000; a += 3) {
for (int b = 0; b <= 1000 - a; b += 5) {
for (int c = 0; c <= 1000 - a - b; c += 7)
if (a + b + c == x) {
std::cout << a / 3 << " " << b / 5 << " " << c / 7 << std::endl;
flag = false;
break;
}
if (!flag) break;
}
if (!flag) break;
}
if (flag) std::cout << -1 << std::endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int w = 0;
double vtotal = 0, ototal = 0;
vtotal = n * 100;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
ototal += k;
}
double p = ototal / vtotal;
std::cout << p * 100;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, m, maxi = INT_MIN;
cin >> n;
string s;
vector<string> v;
for (i = 0; i < n; i++) {
cin >> s;
v.push_back(s);
}
int narr[7] = {0};
for (i = 0; i < 7; i++) {
for (j = 0; j < n; j++) {
narr[i] += v[j][i] - '0';
}
maxi = max(narr[i], maxi);
}
cout << maxi;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string gv[3];
int i, j, k;
char ans[4];
map<string, int> mp;
for (i = 0; i < 3; i++) {
cin >> gv[i];
mp[gv[i]]++;
}
if ((mp["A<B"] == 1 || mp["B>A"] == 1) && (mp["A<C"] == 1 || mp["C>A"] == 1))
ans[0] = 'A';
else if ((mp["C<B"] == 1 || mp["B>C"] == 1) &&
(mp["C<A"] == 1 || mp["A>C"] == 1))
ans[0] = 'C';
else
ans[0] = 'B';
if ((mp["A>B"] == 1 || mp["B<A"] == 1) && (mp["A>C"] == 1 || mp["C<A"] == 1))
ans[2] = 'A';
else if ((mp["C>B"] == 1 || mp["B<C"] == 1) &&
(mp["C>A"] == 1 || mp["A<C"] == 1))
ans[2] = 'C';
else
ans[2] = 'B';
if ((ans[0] == 'A' && ans[2] == 'B') || (ans[0] == 'B' && ans[2] == 'A'))
ans[1] = 'C';
else if ((ans[0] == 'A' && ans[2] == 'C') || (ans[0] == 'C' && ans[2] == 'A'))
ans[1] = 'B';
else
ans[1] = 'A';
if (ans[0] != ans[1] && ans[0] != ans[2] && ans[1] != ans[2])
cout << ans[0] << ans[1] << ans[2] << endl;
else
cout << "Impossible" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
char arr[5][210];
void testc() {
int n;
scanf("%d", &n);
for (int i = 1; i <= 2; i++) scanf("%s", &arr[i][1]);
if (arr[1][1] == '1' || arr[2][n] == '1') return void(printf("NO"));
for (int i = 1; i <= n; i++)
if (arr[1][i] == '1' && arr[2][i] == '1') return void(printf("NO"));
printf("YES");
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
testc();
if (t) putchar('\n');
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long int subtree[200001], coltotal[200001];
long long int col[200001], n;
int root = 0;
void dfs(vector<vector<int> >& v, int i, int parent) {
int j;
subtree[i] = 1;
coltotal[i] = col[i];
for (j = 0; j < v[i].size(); j++) {
if (v[i][j] != parent) {
dfs(v, v[i][j], i);
subtree[i] += subtree[v[i][j]];
coltotal[i] += coltotal[v[i][j]];
}
}
}
void dfsdp(vector<vector<int> >& v, int i, int parent) {
int j;
bool flag = true;
for (j = 0; j < v[i].size(); j++) {
if (v[i][j] != parent) {
if (coltotal[v[i][j]] % subtree[v[i][j]] ||
coltotal[v[i][j]] / subtree[v[i][j]] != col[v[i][j]])
flag = false;
dfsdp(v, v[i][j], i);
}
}
if (flag) {
long long int x = coltotal[1] - coltotal[i];
if (i == 1 ||
(x % (n - subtree[i]) == 0 && (x / (n - subtree[i]) == col[parent])))
root = i;
}
}
int main() {
cin >> n;
int i, x, y;
vector<vector<int> > v(n + 1);
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (i = 1; i <= n; i++) {
cin >> col[i];
}
dfs(v, 1, 0);
dfsdp(v, 1, 0);
if (root) {
cout << "YES"
<< "\n";
cout << root << "\n";
} else
cout << "NO"
<< "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int row, col, n, ver[51] = {0}, hor[51] = {0};
scanf("%d", &n);
for (int i = 1; i <= n * n; i++) {
scanf("%d %d", &row, &col);
if ((ver[row] == 0) && (hor[col] == 0)) {
printf("%d ", i);
ver[row] = 1;
hor[col] = 1;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(2, 3, "Ofast")
#pragma GCC target("avx", "avx2")
using namespace std;
template <typename T1, typename T2>
void ckmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
void ckmax(T1 &a, T2 b) {
if (a < b) a = b;
}
int read() {
int x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();
return f ? -x : x;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void print(T x, char let) {
print(x), putchar(let);
}
const int N = 200005;
const int inf = 1e9;
int n, q;
struct SMT1 {
long long sum[N << 2], tag[N << 2];
void pushup(int u) { sum[u] = sum[(u << 1)] + sum[(u << 1 | 1)]; }
void pushtag(int u, int tg, int l, int r) {
tag[u] += tg, sum[u] += 1ll * tg * (r - l + 1);
}
void pushdown(int u, int l, int r) {
if (tag[u]) {
int mid = l + r >> 1;
pushtag((u << 1), tag[u], l, mid),
pushtag((u << 1 | 1), tag[u], mid + 1, r);
tag[u] = 0;
}
}
void build(int u, int l, int r) {
if (l == r) {
sum[u] = 1;
return;
}
int mid = l + r >> 1;
build((u << 1), l, mid), build((u << 1 | 1), mid + 1, r);
pushup(u);
}
void update(int u, int l, int r, int ql, int qr, int x) {
if (ql > qr) return;
if (ql <= l && r <= qr) {
pushtag(u, x, l, r);
return;
}
pushdown(u, l, r);
int mid = l + r >> 1;
if (ql <= mid) update((u << 1), l, mid, ql, qr, x);
if (qr > mid) update((u << 1 | 1), mid + 1, r, ql, qr, x);
pushup(u);
}
long long query(int u, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return sum[u];
int mid = l + r >> 1;
pushdown(u, l, r);
long long ret = 0;
if (ql <= mid) ret += query((u << 1), l, mid, ql, qr);
if (qr > mid) ret += query((u << 1 | 1), mid + 1, r, ql, qr);
return ret;
}
} smt1;
struct SMT2 {
int mx[N << 2], mx2[N << 2], cnt[N << 2];
int tag[N << 2];
void pushup(int u) {
if (mx[(u << 1)] == mx[(u << 1 | 1)])
mx[u] = mx[(u << 1)], mx2[u] = max(mx2[(u << 1)], mx2[(u << 1 | 1)]),
cnt[u] = cnt[(u << 1)] + cnt[(u << 1 | 1)];
else if (mx[(u << 1)] > mx[(u << 1 | 1)])
mx[u] = mx[(u << 1)], mx2[u] = max(mx2[(u << 1)], mx[(u << 1 | 1)]),
cnt[u] = cnt[(u << 1)];
else
mx[u] = mx[(u << 1 | 1)], mx2[u] = max(mx[(u << 1)], mx2[(u << 1 | 1)]),
cnt[u] = cnt[(u << 1 | 1)];
}
void pushtag(int u, int t) {
if (mx[u] > t) mx[u] = t, tag[u] = t;
}
void pushdown(int u) {
if (tag[u] != inf)
pushtag((u << 1), tag[u]), pushtag((u << 1 | 1), tag[u]), tag[u] = inf;
}
void build(int u, int l, int r) {
tag[u] = inf;
if (l == r) {
mx[u] = l, mx2[u] = 0, cnt[u] = 1;
return;
}
int mid = l + r >> 1;
build((u << 1), l, mid), build((u << 1 | 1), mid + 1, r);
pushup(u);
}
void beat(int u, int l, int r, int ql, int qr, int x) {
if (ql > qr || mx[u] <= x) return;
if (ql <= l && r <= qr && mx2[u] < x) {
smt1.update(1, 1, n, x + 1, mx[u], -cnt[u]);
pushtag(u, x);
return;
}
pushdown(u);
int mid = l + r >> 1;
if (ql <= mid) beat((u << 1), l, mid, ql, qr, x);
if (qr > mid) beat((u << 1 | 1), mid + 1, r, ql, qr, x);
pushup(u);
}
void update(int u, int l, int r, int pos, int x) {
if (l == r) {
if (x > mx[u])
smt1.update(1, 1, n, mx[u] + 1, x, 1);
else
smt1.update(1, 1, n, x + 1, mx[u], -1);
mx[u] = x, mx2[u] = 0, cnt[u] = 1;
return;
}
pushdown(u);
int mid = l + r >> 1;
if (pos <= mid)
update((u << 1), l, mid, pos, x);
else
update((u << 1 | 1), mid + 1, r, pos, x);
pushup(u);
}
} smt2;
int main() {
n = read(), q = read();
smt1.build(1, 1, n);
smt2.build(1, 1, n);
while (q--) {
int opt = read(), x = read(), y = read();
if (opt == 1) {
smt2.beat(1, 1, n, 1, x - 1, x - 1);
smt2.update(1, 1, n, x, y);
} else {
print(smt1.query(1, 1, n, x, y), '\n');
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
getchar();
vector<double> v;
map<double, int> mp;
for (int i = 0; i < n; i++) {
char d;
double a, b, c;
scanf("%c%lf%c%lf%c%c%lf", &d, &a, &d, &b, &d, &d, &c);
getchar();
v.push_back((a + b) / c);
mp[v[i]]++;
}
for (auto it = v.begin(); it != v.end(); it++) {
printf("%d ", mp.find(*it)->second);
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
namespace IO {
const int SIZE = (1 << 20) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = obuf + SIZE - 1;
char _st[55];
int _qr = 0;
inline char gc() {
return (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++) : *iS++);
}
inline void qread() {}
template <class T1, class... T2>
inline void qread(T1 &IEE, T2 &...ls) {
register T1 __ = 0, ___ = 1;
register char ch;
while (!isdigit(ch = gc())) ___ = (ch == '-') ? -___ : ___;
do {
__ = (__ << 1) + (__ << 3) + (ch ^ 48);
} while (isdigit(ch = gc()));
__ *= ___;
IEE = __;
qread(ls...);
return;
}
template <class T>
inline void QreadArr(T Begin, T End) {
while (Begin != End) {
qread(*Begin);
++Begin;
}
}
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
return;
}
inline void putc_(char _x) {
*oS++ = _x;
if (oS == oT) flush();
}
inline void qwrite() {}
template <class T1, class... T2>
inline void qwrite(T1 IEE, T2... ls) {
if (!IEE) putc_('0');
if (IEE < 0) putc_('-'), IEE = -IEE;
while (IEE) _st[++_qr] = IEE % 10 + '0', IEE /= 10;
while (_qr) putc_(_st[_qr--]);
qwrite(ls...);
return;
}
template <class T>
inline void WriteArr(T Begin, T End) {
const char Kg = ' ', Edl = '\n';
while (Begin != End) {
qwrite(*Begin);
++Begin;
putc_(Kg);
}
putc_(Edl);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher;
} // namespace IO
using namespace IO;
using namespace std;
mt19937_64 rnd(chrono::steady_clock::now().time_since_epoch().count());
long long My_Rand(long long Mod) { return (unsigned long long)(rnd()) % Mod; }
template <class T1, class T2>
void Min(const T1 x, const T2 y) {
return x > y ? y : x;
}
template <class T1, class T2>
void Max(const T1 x, const T2 y) {
return x > y ? x : y;
}
template <class T1, class T2>
void To_max(T1 &x, const T2 y) {
x < y ? x = y : x = x;
}
template <class T1, class T2>
void To_min(T1 &x, const T2 y) {
x > y ? x = y : x = x;
}
inline long long qpow(long long n, long long base, long long mod = 1e18) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * base % mod;
base = base * base % mod;
n >>= 1;
}
return ret % mod;
}
inline long long gcd(long long x, long long y) {
return !y ? x : gcd(y, x % y);
}
inline long long lcm(long long x, long long y) { return x / gcd(x, y) * y; }
const int N = 2e5 + 5;
int n, m, s, cnt;
int fa[N << 1];
void init() {
for (int i = 1; i <= n + m; ++i) fa[i] = i;
}
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
int main() {
qread(n, m, s);
init();
for (int i = 1; i <= s; ++i) {
int x, y;
qread(x, y), y += n;
x = find(x), y = find(y);
if (x != y) fa[x] = y;
}
for (int i = 1; i <= n + m; ++i) cnt += (fa[i] == i);
cout << cnt - 1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, mod = 1e9 + 7;
const long long inf = 1e18 + 1;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
for (int l = 0; l < t; l++) {
int n, p, k;
cin >> n >> p >> k;
vector<int> inp;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
inp.push_back(x);
}
sort(inp.begin(), inp.end());
long long dp[n + 10];
dp[1] = inp[0];
dp[0] = 0;
if (dp[1] > p) {
cout << 0 << "\n";
continue;
}
long long ans = 1;
for (int i = 1; i < n; i++) {
dp[i + 1] = min(dp[i] + inp[i], dp[i - 1] + inp[i]);
if (dp[i + 1] <= p) ans++;
}
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
const double eps = 1e-9;
const double pi = acos(-1.0);
const int maxn = (int)1e5 + 10;
int f[maxn], in[maxn], used[maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &f[i]);
--f[i];
++in[f[i]];
}
vector<pair<int, int> > comp;
for (int i = 0; i < n; i++) {
if (used[i] || in[i]) continue;
comp.push_back(make_pair(i, i));
int cur = i;
while (!used[cur]) {
used[cur] = 1;
cur = f[cur];
}
comp.back().second = cur;
}
for (int i = 0; i < n; i++) {
if (used[i]) continue;
comp.push_back(make_pair(i, i));
int cur = i;
while (!used[cur]) {
used[cur] = 1;
cur = f[cur];
}
}
if ((int)(comp).size() == 1 && comp[0].first == comp[0].second) {
cout << 0 << endl;
return 0;
}
cout << (int)(comp).size() << endl;
for (int i = 0; i < (int)(comp).size(); i++)
cout << comp[i].second + 1 << " "
<< comp[(i + 1) % (int)(comp).size()].first + 1 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
int a[500005];
int main() {
int n;
cin >> n;
for (int i = int(1); i < int(n + 1); ++i) cin >> a[i];
if (n == 1) {
cout << "yes" << endl;
cout << "1 1";
return 0;
}
bool f = true;
bool f1 = true;
int x, y;
x = y = 0;
int t = 0;
vector<pair<int, int> > p;
for (int i = int(1); i < int(n - 1 + 1); ++i) {
if (a[i] < a[i + 1] && t != 1) {
t = 1;
p.push_back(make_pair(i, t));
}
if (a[i] > a[i + 1] && t != -1) {
t = -1;
p.push_back(make_pair(i, t));
}
}
if (int((p).size()) == 1) {
if (p[0].second == 1)
cout << "yes" << endl << "1 1";
else
cout << "yes" << endl << "1 " << n;
}
if (int((p).size()) == 2) {
if (p[0].second == 1) {
if (a[n] >= a[p[1].first - 1])
cout << "yes" << endl << p[1].first << " " << n;
else
cout << "no";
} else {
if (a[1] <= a[p[1].first + 1])
cout << "yes" << endl << "1 " << p[1].first;
else
cout << "no";
}
}
if (int((p).size()) == 3) {
if (p[0].second == -1)
cout << "no";
else {
if (a[p[1].first] <= a[p[2].first + 1] &&
a[p[2].first] >= a[p[1].first - 1])
cout << "yes" << endl << p[1].first << " " << p[2].first;
else
cout << "no";
}
}
if (int((p).size()) > 3) cout << "no";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int v;
long long w;
bool flat;
node(int v, long long w, bool flat) : v(v), w(w), flat(flat){};
};
vector<node> edge[100005];
struct node1 {
int po;
long long w;
} temp[100005];
bool vis[100005];
bool sta[100005];
int cnt[100005];
long long dis[100005];
void spfa() {
int u;
queue<int> q;
q.push(1);
vis[1] = true;
dis[1] = 0;
while (!q.empty()) {
u = q.front();
q.pop();
vis[u] = false;
for (int i = 0; i < edge[u].size(); i++) {
if (dis[edge[u][i].v] > dis[u] + edge[u][i].w) {
dis[edge[u][i].v] = dis[u] + edge[u][i].w;
sta[edge[u][i].v] = edge[u][i].flat;
cnt[edge[u][i].v] = 1;
if (!vis[edge[u][i].v]) {
vis[edge[u][i].v] = true;
q.push(edge[u][i].v);
}
} else if (dis[edge[u][i].v] == dis[u] + edge[u][i].w) {
cnt[edge[u][i].v]++;
if (!edge[u][i].flat) sta[edge[u][i].v] = false;
}
}
}
}
int main() {
int n, m, k, u, v;
long long w;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
scanf("%d%d%I64d", &u, &v, &w);
edge[u].push_back(node(v, w, false));
edge[v].push_back(node(u, w, false));
}
for (int i = 0; i < k; i++) {
scanf("%d%I64d", &temp[i].po, &temp[i].w);
edge[1].push_back(node(temp[i].po, temp[i].w, true));
edge[temp[i].po].push_back(node(1, temp[i].w, true));
}
memset(vis, false, sizeof(vis));
memset(sta, false, sizeof(sta));
memset(dis, 0x3f3f3f, sizeof(dis));
memset(cnt, 0, sizeof(cnt));
spfa();
int ans = 0;
for (int i = 0; i < k; i++) {
if (dis[temp[i].po] < temp[i].w)
ans++;
else if (dis[temp[i].po] == temp[i].w && cnt[temp[i].po] != 1) {
if (sta[temp[i].po]) {
cnt[temp[i].po]--;
ans++;
} else {
ans++;
}
}
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 2e5 + 5;
const int inf = 0x3f3f3f3f;
int a[N];
int main() {
std::ios::sync_with_stdio(false);
int T, n, d;
cin >> T;
while (T--) {
cin >> n;
memset(a, 0, sizeof(int) * (n + 1));
for (int i = 0; i < n; i++) {
cin >> d;
a[d]++;
}
sort(a + 1, a + n + 1, greater<int>());
int ans = a[1];
int pre = a[1];
pre--;
for (int i = 2; i <= n && a[i] != 0 && pre; i++) {
if (pre < a[i]) {
if (pre >= 1) {
ans += pre;
pre--;
}
} else if (a[i] == pre) {
ans += pre;
pre--;
} else if (a[i] < pre) {
ans += a[i];
pre = a[i];
pre--;
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[103][103], l[103], b[103][103], r[103];
int main() {
int n, m, sum = 0, ans = 0, ans2 = 0;
scanf("%d%d", &n, &m);
memset(l, 0x3f, sizeof(l));
memset(r, 0x3f, sizeof(r));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
scanf("%d", &a[i][j]);
b[j][i] = a[i][j];
sum += a[i][j];
r[j] = min(r[j], b[j][i]);
l[i] = min(l[i], a[i][j]);
}
}
for (int i = 1; i <= n; ++i) {
sum -= l[i] * m;
ans += l[i];
for (int j = 1; j <= m; ++j) {
a[i][j] -= l[i];
}
}
for (int i = 1; i <= m; ++i) {
ans2 += r[i];
for (int j = 1; j <= n; ++j) {
b[i][j] -= r[i];
}
}
for (int i = 1; i <= m; ++i) {
if (a[1][i] != 0) {
for (int j = 2; j <= n; ++j)
if (a[j][i] != a[j - 1][i]) return 0 * puts("-1");
ans += a[1][i];
sum -= a[1][i] * n;
}
}
for (int i = 1; i <= n; ++i)
if (b[1][i] != 0) ans2 += b[1][i];
if (sum) return 0 * puts("-1");
if (ans <= ans2) {
printf("%d\n", ans);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= l[i]; ++j) printf("row %d\n", i);
for (int i = 1; i <= m; ++i)
for (int j = 1; j <= a[1][i]; ++j) printf("col %d\n", i);
} else {
printf("%d\n", ans2);
for (int i = 1; i <= m; ++i)
for (int j = 1; j <= r[i]; ++j) printf("col %d\n", i);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= b[1][i]; ++j) printf("row %d\n", i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int query(vector<int>& v) {
if (v.size() < 2) return 0;
printf("? %d\n", v.size());
for (int i = 0; i < v.size(); ++i) printf("%d ", v[i]);
puts("");
fflush(stdout);
int res;
scanf("%d", &res);
return res;
}
int query(int x, vector<int>& v) {
v.push_back(x);
int res = query(v);
v.pop_back();
return res - query(v);
}
int n, u[600 + 5], dep[600 + 5], fa[600 + 5];
vector<int> R[3];
void get(int x, vector<int>& v, vector<int>& t, int s) {
if (!s) return;
int cnt = 0;
if (s == v.size()) {
for (int i = 0; i < v.size(); ++i) t.push_back(v[i]);
return;
}
vector<int> a, b;
for (int i = 0; i < v.size() / 2; ++i) a.push_back(v[i]);
for (int i = v.size() / 2; i < v.size(); ++i) b.push_back(v[i]);
int p = query(x, a);
get(x, a, t, p);
get(x, b, t, s - p);
}
void dfs(int x) {
R[u[x]].push_back(x);
vector<int> v, t;
for (int i = 1; i <= n; ++i)
if (!u[i]) v.push_back(i);
get(x, v, t, query(x, v));
for (int i = 0; i < t.size(); ++i)
u[t[i]] = 3 - u[x], fa[t[i]] = x, dep[t[i]] = dep[x] + 1;
for (int i = 0; i < t.size(); ++i) dfs(t[i]);
}
int main() {
scanf("%d", &n);
u[1] = 1;
dfs(1);
int x = query(R[1]), y = query(R[2]);
if (!x && !y) {
printf("Y %d\n", R[1].size());
for (int i = 0; i < R[1].size(); ++i) printf("%d ", R[1][i]);
return 0;
}
x = x ? 1 : 2;
for (int i = 0; i < R[x].size(); ++i) {
int s = R[x][i];
swap(R[x][i], R[x].back());
R[x].pop_back();
vector<int> t;
get(s, R[x], t, query(s, R[x]));
R[x].push_back(s);
swap(R[x][i], R[x].back());
if (t.size()) {
vector<int> a, b;
while (s != t[0])
if (dep[s] > dep[t[0]])
a.push_back(s), s = fa[s];
else
b.push_back(t[0]), t[0] = fa[t[0]];
printf("N %d\n", a.size() + b.size() + 1);
for (int i = 0; i < a.size(); ++i) printf("%d ", a[i]);
printf("%d ", s);
for (int i = b.size(); i--;) printf("%d ", b[i]);
return 0;
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
double p[110], f[110], g[110], Max, Ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lf", &p[i]);
Max = max(Max, p[i]);
}
if (Max >= 0.5) {
printf("%.12lf\n", Max);
return 0;
}
sort(p + 1, p + n + 1);
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
double x = 0, y = 1;
for (int k = i; k <= j; k++) {
x = x * (1 - p[k]) + p[k] * y;
y = y * (1 - p[k]);
}
Ans = max(Ans, x);
}
printf("%.12lf", Ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double pi = 3.1415926536;
int main() {
int n;
cin >> n;
int r[n];
for (int i = 0; i < n; i++) cin >> r[i];
double area = 0;
sort(r, r + n);
for (int i = n - 1; i >= 0; i -= 2) {
if (i > 0)
area += (r[i] * r[i] - r[i - 1] * r[i - 1]);
else
area += r[0] * r[0];
}
area *= pi;
printf("%0.10lf", area);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, k;
long long ksm(long long x, long long t) {
long long y = 1;
for (; t; t >>= 1) t& 1 ? y = y * x % 1000000009 : 0, x = x * x % 1000000009;
return y;
}
long long co, ans;
char S[100005];
signed main() {
cin >> n >> a >> b >> k;
co = ksm(ksm(a, 1000000009 - 2) * b % 1000000009, k);
if (co == 1)
co = (n + 1) / k;
else
co = (ksm(co, n / k + 1) - 1) * ksm(co - 1, 1000000009 - 2) % 1000000009;
cin >> S;
for (long long i = 0; i < k; i++)
ans += ksm(a, n - i) * ksm(b, i) % 1000000009 * co % 1000000009 *
(S[i] == '+' ? 1 : -1);
cout << (ans % 1000000009 + 1000000009) % 1000000009;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int power(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) {
res = (res * a) % 1000000007;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long int expo(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) {
res = (res * a);
}
a = (a * a);
b >>= 1;
}
return res;
}
void solve() {
int a, b, c, x, y, z;
cin >> a >> b >> c >> x >> y >> z;
int da = a - x, db = b - y, dc = c - z;
if (da >= 0 && db >= 0 && dc >= 0)
cout << "Yes\n";
else {
int create = 0;
if (da > 0) create += da / 2;
if (db > 0) create += db / 2;
if (dc > 0) create += dc / 2;
if (da < 0) create += da;
if (db < 0) create += db;
if (dc < 0) create += dc;
if (create >= 0)
cout << "Yes\n";
else
cout << "No\n";
}
}
int main() {
std::ios::sync_with_stdio(false);
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int MAXSIZE = 10000020;
int bufpos;
char buf[MAXSIZE];
void init() {
buf[fread(buf, 1, MAXSIZE, stdin)] = '\0';
bufpos = 0;
}
int readint() {
int val = 0;
for (; !isdigit(buf[bufpos]); bufpos++)
;
for (; isdigit(buf[bufpos]); bufpos++) val = val * 10 + buf[bufpos] - '0';
return val;
}
char readchar() {
for (; isspace(buf[bufpos]); bufpos++)
;
return buf[bufpos++];
}
int readstr(char *s) {
int cur = 0;
for (; isspace(buf[bufpos]); bufpos++)
;
for (; !isspace(buf[bufpos]); bufpos++) s[cur++] = buf[bufpos];
s[cur] = '\0';
return cur;
}
char bf[1 << 25], st[20], *w = bf;
void flush() {
fwrite(bf, 1, w - bf, stdout);
w = bf;
}
inline void pc(register char c) { *w++ = c; }
void print(register int n) {
register char *t = st;
do {
*t++ = n % 10 + 48;
} while (n /= 10);
while (t-- > st) pc(*t);
}
int n, q, fa[66666], aa[66666], kh[66666], a[66666], p[66666], fp[66666],
siz[66666], ck, pa[66666];
vector<int> edge[66666];
int dd[66666];
void dfs(int u) {
siz[u] = 1;
p[++ck] = u;
fp[u] = ck;
pa[ck] = fp[fa[u]];
dd[ck] = dd[pa[ck]] + 1;
for (auto v : edge[u]) {
dfs(v);
siz[u] += siz[v];
}
}
int main() {
init();
n = readint();
q = readint();
for (int i = 1; i <= n; ++i) {
aa[i] = readint();
}
for (int i = 2; i <= n; ++i) {
fa[i] = readint();
edge[fa[i]].push_back(i);
}
dfs(1);
for (int i = 1; i <= n; ++i) {
a[fp[i]] = aa[i];
kh[i] = -50001;
}
for (int i = 1; i <= q; ++i) {
int x = readint();
int y = siz[x];
x = fp[x];
int pp = i + 1, gg = y >> 3, *jj = kh + x, *diao = dd + x, *aa = a + x;
int ans = 0, cnt = 0;
for (int j = 0; j < gg; ++j, jj += 8, diao += 8, aa += 8) {
int w;
w = jj[0] + aa[0] < pp, jj[0] = w ? i : jj[0], ans += w * diao[0],
cnt += w;
w = jj[1] + aa[1] < pp, jj[1] = w ? i : jj[1], ans += w * diao[1],
cnt += w;
w = jj[2] + aa[2] < pp, jj[2] = w ? i : jj[2], ans += w * diao[2],
cnt += w;
w = jj[3] + aa[3] < pp, jj[3] = w ? i : jj[3], ans += w * diao[3],
cnt += w;
w = jj[4] + aa[4] < pp, jj[4] = w ? i : jj[4], ans += w * diao[4],
cnt += w;
w = jj[5] + aa[5] < pp, jj[5] = w ? i : jj[5], ans += w * diao[5],
cnt += w;
w = jj[6] + aa[6] < pp, jj[6] = w ? i : jj[6], ans += w * diao[6],
cnt += w;
w = jj[7] + aa[7] < pp, jj[7] = w ? i : jj[7], ans += w * diao[7],
cnt += w;
}
gg <<= 3;
for (int j = gg; j < y; ++j) {
int w;
w = jj[j - gg] + aa[j - gg] < pp, jj[j - gg] = w ? i : jj[j - gg],
ans += w * diao[j - gg], cnt += w;
;
}
ans = ans - cnt * dd[x];
print(ans);
pc(' ');
print(cnt);
pc('\n');
}
flush();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)2e9;
int dp[55][2][2][2];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i <= n; i++) {
for (int a = 0; a < 2; a++) {
for (int b = 0; b < 2; b++) {
for (int c = 0; c < 2; c++) {
dp[i][a][b][c] = INF;
}
}
}
}
dp[0][0][0][0] = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int index = i;
for (int a = 0; a < 2; a++) {
for (int b = 0; b < 2; b++) {
for (int c = 0; c < 2; c++) {
for (int i = 0; i < m; i++) {
int mn = min(i, m - i);
if ('0' <= s[i] && s[i] <= '9') {
dp[index + 1][1][b][c] =
min(dp[index + 1][1][b][c], dp[index][a][b][c] + mn);
} else if ('a' <= s[i] && s[i] <= 'z') {
dp[index + 1][a][1][c] =
min(dp[index + 1][a][1][c], dp[index][a][b][c] + mn);
} else if (s[i] == '#' || s[i] == '*' || s[i] == '&') {
dp[index + 1][a][b][1] =
min(dp[index + 1][a][b][1], dp[index][a][b][c] + mn);
} else {
dp[index + 1][a][b][c] =
min(dp[index + 1][a][b][c], dp[index][a][b][c] + mn);
}
}
}
}
}
}
cout << dp[n][1][1][1];
return 0;
}
| 3 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <map>
int32_t main()
{
using namespace std;
ios::sync_with_stdio(0); cin.tie(0);
int64_t T = 1;;
cin >> T;
while(T--)
{
int64_t N;
cin >> N;
vector < int64_t > A(N), B, cnt(N+1, 1);
for(int64_t i = 0; i < N; ++i)
{
cin >> A[i];
if(B.size() && A[i] == B.back())
continue;
B.push_back(A[i]);
}
// cout << B.size() << "\n";
for(auto &i : B)
cnt[i]++;
cnt[B[0]] -= 1;
cnt[B[B.size()-1]] -= 1;
// cout << cnt[B[B.size()-1]] << "\n";
int64_t ret = 1e9;
for(int64_t &i : B)
ret = min(ret, cnt[i]);
cout << ret << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long double dp[205][205][405];
inline int id(int x) { return (x < 0) ? (200 - x) : x; }
int main() {
int n, l, init, cnt = 0, bags[201];
cin >> n >> l >> init;
long double p[n + 1];
for (int j = 0; j < n; j++) {
cin >> p[j];
p[j] /= 100;
}
for (int j = 0; j < n; j++) cin >> bags[j];
memset(dp, 0, sizeof(dp));
dp[0][0][init] = 1;
for (int i = 0; i < n; i++) {
for (int k = -200; k < 201; k++) {
for (int j = 0; j <= i; j++) {
dp[i + 1][j][id(k)] += dp[i][j][id(k)] * ((long double)1 - p[i]);
if (bags[i] == -1)
dp[i + 1][j + 1][id(k - 1)] += p[i] * dp[i][j][id(k)];
else
dp[i + 1][j + 1][id((k + bags[i]) > 200 ? 200 : (k + bags[i]))] +=
dp[i][j][id(k)] * p[i];
}
}
}
long double ans = 0;
cnt = 0;
for (int j = l; j < 201; j++)
for (int k = 0; k < 201; k++) {
ans += dp[n][j][k];
}
cout << fixed << setprecision(9) << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
auto b = a;
sort(b.begin(), b.end());
int c = 0;
for (int i = 0; i < n; i++) {
if (b[i] != a[i]) c++;
}
c > 2 ? cout << "NO" : cout << "YES";
}
| 2 |
#include <bits/stdc++.h>
static const long long LLMAX = 0x7fffffffffffffffLL;
static const int IMAX = 0x7fffffff;
using namespace std;
bool endWith(const string& str, const string& suf) {
if (str.length() < suf.length()) return false;
string sub = str.substr(str.length() - suf.length());
return sub == suf;
}
char type(const string& str) {
if (endWith(str, "lios")) {
return 'A';
} else if (endWith(str, "liala")) {
return 'B';
} else if (endWith(str, "etr")) {
return 'C';
} else if (endWith(str, "etra")) {
return 'D';
} else if (endWith(str, "initis")) {
return 'E';
} else if (endWith(str, "inites")) {
return 'F';
} else {
return 'X';
}
}
int main() {
string line;
while (getline(cin, line)) {
if (string::npos == line.find_first_of(' ')) {
if (type(line) != 'X') {
printf("YES\n");
} else {
printf("NO\n");
}
continue;
}
istringstream iss(line);
bool valid = true;
bool gender;
bool fst = true;
bool adj = false;
bool noun = false;
bool verb = false;
while (iss >> line) {
char ch = type(line);
if (ch == 'X') {
valid = false;
break;
}
if (fst) {
gender = (ch == 'A' || ch == 'C' || ch == 'E') ? true : false;
fst = false;
} else {
if (gender != ((ch == 'A' || ch == 'C' || ch == 'E') ? true : false)) {
valid = false;
break;
}
}
if (noun == true) {
if (ch == 'A' || ch == 'B' || ch == 'C' || ch == 'D') {
valid = false;
break;
}
}
if (noun == false) {
if (ch == 'E' || ch == 'F') {
valid = false;
break;
}
}
if (verb == true) {
if (ch == 'A' || ch == 'B' || ch == 'C' || ch == 'D') {
valid = false;
break;
}
}
if (ch == 'A' || ch == 'B') {
adj = true;
} else if (ch == 'C' || ch == 'D') {
noun = true;
} else if (ch == 'E' || ch == 'F') {
verb = true;
}
}
if (noun == false) {
valid = false;
}
if (valid) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, a[N], deg[N];
vector<int> G[N];
int solve(int c) {
queue<int> q[2];
for (int i = 1; i <= n; ++i) deg[i] = G[i].size();
for (int i = 1; i <= n; ++i)
if (deg[i] == 1) q[(!a[i] || a[i] == c) ? 0 : 1].push(i);
int ans = 0, cnt = 0;
for (int t = 0, cur = c; cnt < n; t ^= 1, cur = 3 - cur) {
ans++;
while (q[t].size()) {
int u = q[t].front();
q[t].pop();
cnt++;
for (int v : G[u])
if (--deg[v] == 1) {
q[(!a[v] || a[v] == cur) ? t : (t ^ 1)].push(v);
}
}
}
return ans;
}
int main() {
int test;
scanf("%d", &test);
while (test--) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
if (n == 1) {
puts("1");
continue;
}
for (int i = 1; i <= n; ++i) G[i].clear();
for (int i = 1; i <= n - 1; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
printf("%d\n", min(solve(1), solve(2)));
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int f[n], b[m];
map<int, int> af, cf;
for (int i = 0; i < n; i++) {
cin >> f[i];
af[f[i]] = i;
cf[f[i]]++;
}
bool flag = 0;
for (int i = 0; i < m; i++) {
cin >> b[i];
if (cf[b[i]] == 0) {
cout << "Impossible";
return 0;
}
if (cf[b[i]] > 1) flag = 1;
}
if (flag) {
cout << "Ambiguity";
return 0;
}
cout << "Possible\n";
for (int i = 0; i < m; i++) cout << af[b[i]] + 1 << ' ';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int v[105];
int main() {
ios_base::sync_with_stdio(false);
int n, x, y, i, j, poz = 0;
cin >> n >> x >> y;
for (i = 1; i <= n; i++) cin >> v[i];
sort(v + 1, v + n + 1);
for (i = 1; i <= n; i++)
if (v[i] <= x) poz = i;
if (y >= x) {
if (poz % 2 == 0)
cout << poz / 2;
else
cout << poz / 2 + 1;
return 0;
} else
cout << n;
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.