solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000050;
int T, x, y, a;
char ans[3][10] = {"Vanya", "Vova", "Both"};
int who[maxn], s;
inline int gcd(int u, int v) { return !v ? u : gcd(v, u % v); }
int main() {
int i, j, g;
long long sx, sy;
scanf("%d%d%d", &T, &x, &y);
swap(x, y);
g = gcd(x, y);
x /= g, y /= g;
s = x + y;
who[0] = who[s - 1] = 2;
for (i = 1, sx = sy = 0; i < s - 1; i++) {
if (sx + x < sy + y)
who[i] = 0, sx += x;
else
who[i] = 1, sy += y;
}
while (T--) scanf("%d", &a), printf("%s\n", ans[who[a % s]]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O2")
using namespace std;
class UnionFind {
public:
vector<int> p, rank;
UnionFind(int N) {
rank.assign(N, 1);
p.assign(N, 0);
for (int i = 0; i < N; i++) p[i] = i;
}
int findSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (!isSameSet(i, j)) {
int x = findSet(i), y = findSet(j);
if (rank[x] > rank[y])
p[y] = x, rank[x] += rank[y];
else {
p[x] = y;
rank[y] += rank[x];
}
}
}
};
class RMQ {
public:
struct node {
int mn, mx, l, r;
};
vector<int> h;
vector<node> st;
bool is_intersection(int l, int r, int ll, int rr) {
if (r < ll || rr < l) return 0;
return 1;
}
RMQ(vector<int> a) {
h = a;
st.resize(4 * h.size());
build(0, h.size() - 1);
}
void build(int l, int r, int k = 0) {
st[k].l = l, st[k].r = r;
if (l == r) {
st[k].mx = st[k].mn = l;
return;
}
build(l, (l + r) / 2, 2 * k + 1);
build((l + r) / 2 + 1, r, 2 * k + 2);
if (h[st[2 * k + 1].mn] <= h[st[2 * k + 2].mn])
st[k].mn = st[2 * k + 1].mn;
else
st[k].mn = st[2 * k + 2].mn;
if (h[st[2 * k + 1].mx] >= h[st[2 * k + 2].mx])
st[k].mx = st[2 * k + 1].mx;
else
st[k].mx = st[2 * k + 2].mx;
}
int minquery(int l, int r, int k = 0) {
if (l > r) return 1000000000;
int ll = st[k].l, rr = st[k].r, mid = (ll + rr) / 2;
if (ll >= l && rr <= r) return st[k].mn;
int ans = l;
if (!(r < ll || mid < l)) ans = minquery(l, r, 2 * k + 1);
if (!(r < mid + 1 || rr < l)) {
if (h[ans] > h[minquery(l, r, 2 * k + 2)])
ans = minquery(l, r, 2 * k + 2);
}
return ans;
}
int maxquery(int l, int r, int k = 0) {
if (l > r) return -1000000000;
int ll = st[k].l, rr = st[k].r, mid = (ll + rr) / 2;
if (ll >= l && rr <= r) return st[k].mx;
int ans = l;
if (!(r < ll || mid < l)) ans = maxquery(l, r, 2 * k + 1);
if (!(r < mid + 1 || rr < l)) {
if (h[ans] < h[maxquery(l, r, 2 * k + 2)])
ans = maxquery(l, r, 2 * k + 2);
}
return ans;
}
void update(int id, int val, int k = 0) {
int l = st[k].l, r = st[k].r, mid = (l + r) / 2;
if (l == r) {
h[l] = val;
return;
}
if (id >= l && id <= mid) update(id, val, 2 * k + 1);
if (mid + 1 <= id && id <= r) update(id, val, 2 * k + 2);
if (h[st[2 * k + 1].mn] <= h[st[2 * k + 2].mn])
st[k].mn = st[2 * k + 1].mn;
else
st[k].mn = st[2 * k + 2].mn;
if (h[st[2 * k + 1].mx] >= h[st[2 * k + 2].mx])
st[k].mx = st[2 * k + 1].mx;
else
st[k].mx = st[2 * k + 2].mx;
}
};
class LAZY {
public:
struct node {
int l, r, lazy = 0;
long long int lazyval = 0;
long long int sum = 0;
};
vector<node> st;
vector<int> h;
LAZY(vector<int> a) {
h = a;
st.resize(4 * h.size());
cst(0, h.size() - 1);
}
int intersectiontype1(int l, int r, int ll, int rr) {
if (r < ll || rr < l) return 0;
return 1;
}
void cst(int l, int r, int k = 0) {
st[k].l = l, st[k].r = r;
if (l == r) {
st[k].sum = h[l];
return;
}
cst(l, (l + r) / 2, 2 * k + 1);
cst((l + r) / 2 + 1, r, 2 * k + 2);
st[k].sum = st[2 * k + 1].sum + st[2 * k + 2].sum;
}
void shift(int k) {
st[k].sum = (st[k].r - st[k].l + 1) * st[k].lazyval;
if (st[k].l != st[k].r) {
st[2 * k + 1].lazyval = st[k].lazyval;
st[2 * k + 2].lazyval = st[k].lazyval;
st[2 * k + 1].lazy = st[2 * k + 1].lazy = 1;
st[2 * k + 2].lazy = st[2 * k + 2].lazy = 1;
}
st[k].lazyval = 0;
st[k].lazy = 0;
}
long long int query(int l, int r, int k = 0) {
if (st[k].lazy != 0) shift(k);
int ll = st[k].l, rr = st[k].r, mid = (ll + rr) / 2;
if (ll >= l && rr <= r) return st[k].sum;
long long int ans = 0;
if (intersectiontype1(ll, mid, l, r) == 1) ans = query(l, r, 2 * k + 1);
if (intersectiontype1(1 + mid, rr, l, r) == 1)
ans += query(l, r, 2 * k + 2);
return ans;
}
void update(int l, int r, long long int x, int k = 0) {
if (l > r) return;
int ll = st[k].l, rr = st[k].r, mid = (ll + rr) / 2;
if (ll >= l && rr <= r) {
st[k].lazyval = x;
st[k].lazy = 1;
return;
}
if (st[k].lazy != 0) shift(k);
if (st[k].l == st[k].r) return;
if (intersectiontype1(ll, mid, l, r) == 1) update(l, r, x, 2 * k + 1);
if (intersectiontype1(mid + 1, rr, l, r) == 1) update(l, r, x, 2 * k + 2);
if (st[2 * k + 1].lazy != 0) shift(2 * k + 1);
if (st[2 * k + 2].lazy != 0) shift(2 * k + 2);
st[k].sum = st[2 * k + 1].sum + st[2 * k + 2].sum;
}
int lower_bound(int l, int r, int val) {
while (l != r) {
int mid = (l + r) / 2;
if (query(mid, mid) >= val)
r = mid;
else {
l = mid + 1;
if (mid + 1 < h.size())
if (query(mid + 1, mid + 1) > val) {
l = mid;
break;
}
}
}
return l;
}
};
class span {
public:
vector<int> a;
span(){};
vector<int> max_left_border_without_equality() {
int n = a.size();
vector<int> ta, al(n);
for (long long int i = 0; i < n; i++) {
if (ta.size() == 0) {
ta.push_back(i);
al[i] = i;
} else {
while (a[i] > a[ta[ta.size() - 1]]) {
ta.pop_back();
if (ta.size() == 0) break;
}
if (ta.size() == 0) {
ta.push_back(i);
al[i] = 0;
} else {
al[i] = ta[ta.size() - 1] + 1;
ta.push_back(i);
}
}
}
return al;
}
vector<int> max_left_border_with_equality() {
int n = a.size();
vector<int> ta, al(n);
for (long long int i = 0; i < n; i++) {
if (ta.size() == 0) {
ta.push_back(i);
al[i] = i;
} else {
while (a[i] >= a[ta[ta.size() - 1]]) {
ta.pop_back();
if (ta.size() == 0) break;
}
if (ta.size() == 0) {
ta.push_back(i);
al[i] = 0;
} else {
al[i] = ta[ta.size() - 1] + 1;
ta.push_back(i);
}
}
}
return al;
}
vector<int> min_left_border_without_equality() {
int n = a.size();
vector<int> ta, al(n);
for (long long int i = 0; i < n; i++) {
if (ta.size() == 0) {
ta.push_back(i);
al[i] = i;
} else {
while (a[i] < a[ta[ta.size() - 1]]) {
ta.pop_back();
if (ta.size() == 0) break;
}
if (ta.size() == 0) {
ta.push_back(i);
al[i] = 0;
} else {
al[i] = ta[ta.size() - 1] + 1;
ta.push_back(i);
}
}
}
return al;
}
vector<int> min_left_border_with_equality() {
int n = a.size();
vector<int> ta, al(n);
for (long long int i = 0; i < n; i++) {
if (ta.size() == 0) {
ta.push_back(i);
al[i] = i;
} else {
while (a[i] <= a[ta[ta.size() - 1]]) {
ta.pop_back();
if (ta.size() == 0) break;
}
if (ta.size() == 0) {
ta.push_back(i);
al[i] = 0;
} else {
al[i] = ta[ta.size() - 1] + 1;
ta.push_back(i);
}
}
}
return al;
}
vector<int> max_right_border_without_equality() {
int n = a.size();
reverse(a.begin(), a.end());
vector<int> ans = max_left_border_without_equality();
reverse(ans.begin(), ans.end());
for (long long int i = 0; i < n; i++) ans[i] = n - 1 - ans[i];
reverse(a.begin(), a.end());
return ans;
}
vector<int> max_right_border_with_equality() {
int n = a.size();
reverse(a.begin(), a.end());
vector<int> ans = max_left_border_with_equality();
reverse(ans.begin(), ans.end());
for (long long int i = 0; i < n; i++) ans[i] = n - 1 - ans[i];
reverse(a.begin(), a.end());
return ans;
}
vector<int> min_right_border_without_equality() {
int n = a.size();
reverse(a.begin(), a.end());
vector<int> ans = min_left_border_without_equality();
reverse(ans.begin(), ans.end());
for (long long int i = 0; i < n; i++) ans[i] = n - 1 - ans[i];
reverse(a.begin(), a.end());
return ans;
}
vector<int> min_right_border_with_equality() {
int n = a.size();
reverse(a.begin(), a.end());
vector<int> ans = min_left_border_with_equality();
reverse(ans.begin(), ans.end());
for (long long int i = 0; i < n; i++) ans[i] = n - 1 - ans[i];
reverse(a.begin(), a.end());
return ans;
}
};
class merge_sort_tree {
public:
long long int cnt(long long int x, vector<int> &arr) {
long long int n = arr.size();
vector<int>::iterator low, high;
low = lower_bound(arr.begin(), arr.end(), x);
if (low == (arr.end()) || *low != x) return 0;
high = upper_bound(low, arr.end(), x);
return high - low;
}
long long int get_last_smaller(vector<int> &v, int x) {
long long int first = 0, last = v.size() - 1;
while (first <= last) {
long long int mid = (first + last) / 2;
if (v[mid] >= x)
last = mid - 1;
else
first = mid + 1;
}
return first - 1 < 0 ? -1 : first - 1;
}
struct node {
int l, r;
vector<int> arr;
};
vector<int> a;
vector<node> st;
merge_sort_tree(vector<int> b) {
st.resize(4 * b.size());
a = b;
build(0, b.size() - 1);
}
void build(int l, int r, int k = 0) {
st[k].l = l, st[k].r = r;
for (int i = l; i < r + 1; i++) st[k].arr.push_back(a[i]);
sort(st[k].arr.begin(), st[k].arr.end());
if (l == r) return;
build(l, (l + r) / 2, 2 * k + 1);
build((l + r) / 2 + 1, r, 2 * k + 2);
}
bool intersection(int l, int r, int ll, int rr) {
if (ll > r || l > rr) return 0;
return 1;
}
long long int count_val_in_range(int l, int r, int t, int k = 0) {
if (l > r) return 0;
int ll = st[k].l, rr = st[k].r, mid = (ll + rr) / 2;
if (ll >= l && rr <= r) return cnt(t, st[k].arr);
long long int ans = 0;
if (intersection(l, r, ll, mid) == 1)
ans += count_val_in_range(l, r, t, 2 * k + 1);
if (intersection(l, r, mid + 1, rr) == 1)
ans += count_val_in_range(l, r, t, 2 * k + 2);
return ans;
}
long long int count_vals_less_than_given_val(int l, int r, int t, int k,
vector<node> &st) {
if (l > r) return 0;
int ll = st[k].l, rr = st[k].r, mid = (ll + rr) / 2;
if (ll >= l && rr <= r) return get_last_smaller(st[k].arr, t) + 1;
long long int ans = 0;
if (intersection(l, r, ll, mid) == 1)
ans += count_vals_less_than_given_val(l, r, t, 2 * k + 1, st);
if (intersection(l, r, mid + 1, rr) == 1)
ans += count_vals_less_than_given_val(l, r, t, 2 * k + 2, st);
return ans;
}
};
void DEBUG_ARR(vector<int> a) {
for (long long int i = 0; i < a.size(); i++) cout << a[i] << " ";
cout << "\n";
}
long long int tmod(long long int x, long long int m) { return (x % m + m) % m; }
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y = y >> 1;
x = (x * x) % 1000000007;
}
if (res < 0) res += 1000000007;
return res;
}
long long int modInverse(long long int a, long long int m) {
long long int m0 = m;
long long int y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long int q = a / m;
long long int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
int cnt[200001];
int smallest_correct_prefix(int l, int r, int ccnt[], int knight_color[],
int m) {
int mid = (l + r) / 2;
for (long long int i = 1; i < m + 1; i++) cnt[i] = 0;
for (long long int i = 0; i < mid + 1; i++) cnt[knight_color[i]]++;
if (l == r) return l;
for (long long int i = 1; i < m + 1; i++)
if (cnt[i] < ccnt[i])
return smallest_correct_prefix(mid + 1, r, ccnt, knight_color, m);
return smallest_correct_prefix(l, mid, ccnt, knight_color, m);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int knight_color[n];
for (long long int i = 0; i < n; i++) cin >> knight_color[i];
int ccnt[m + 1];
for (long long int i = 0; i < m; i++) cin >> ccnt[i + 1];
int sum = 0;
for (long long int i = 1; i < m + 1; i++) sum += ccnt[i];
int l = 0, r;
int ans = 1000000000;
for (long long int i = 0; i < n; i++) cnt[knight_color[i]]++;
for (long long int i = 1; i < m + 1; i++) {
if (cnt[i] < ccnt[i]) {
cout << -1;
return 0;
}
}
r = smallest_correct_prefix(0, n - 1, ccnt, knight_color, m);
int bada_sum = 0;
for (long long int i = 1; i < m + 1; i++) bada_sum += cnt[i];
while (r != n) {
while (cnt[knight_color[l]] >= ccnt[knight_color[l]] + 1) {
cnt[knight_color[l]]--;
bada_sum--;
l++;
}
ans = min(ans, bada_sum - sum);
r++;
if (r == n) break;
cnt[knight_color[r]]++;
bada_sum++;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using llint = long long;
bool solve(llint a, llint b) {
if (a > b) swap(a, b);
if (!a) return false;
if (!solve(b % a, a)) return true;
return b / a % (a + 1) % 2 == 0;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
llint a, b;
scanf("%lld%lld", &a, &b);
puts(solve(a, b) ? "First" : "Second");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 201;
inline void NEXT(const char *T, int *next, int t_len) {
next[0] = -1;
for (int i = 1; i < t_len; i++) {
int j = next[i - 1];
while (j >= 0 && T[i - 1] != T[j]) j = next[j];
if (j >= 0 && T[i - 1] == T[j])
next[i] = j + 1;
else
next[i] = 0;
}
}
int COUNT_KMP(const char *S, const char *T, int s_len, int t_len) {
int next[t_len];
NEXT(T, next, t_len);
int index, count = 0;
for (index = 0; index < s_len; ++index) {
int pos = 0;
int iter = index;
while (pos < t_len && iter < s_len) {
if (S[iter] == T[pos]) {
++iter;
++pos;
} else {
if (pos == 0)
++iter;
else
pos = next[pos - 1] + 1;
}
}
if (pos == t_len && (iter - index) == t_len) ++count;
}
return count;
}
int my_substr(char *s, char *t, int pos, int len) {
int i;
for (i = 0; i < len; ++i) {
if (t[i + pos] == '\0') {
break;
}
s[i] = t[i + pos];
}
s[i] = '\0';
return i;
}
int64_t cal(const char *s, int n, int64_t k) {
int64_t sum[MAX_N];
memset(sum, 0, sizeof(sum));
char f[MAX_N][MAX_N * 10 + 1];
int len[MAX_N];
memset(len, 0, sizeof(len));
int s_len = strlen(s);
sprintf(f[0], "0");
sprintf(f[1], "1");
len[0] = len[1] = 1;
if (s_len == 1) {
if (s[0] == '0') {
sum[0]++;
} else if (s[0] == '1') {
sum[1]++;
}
}
int max_len = s_len - 1;
char tmp_str[MAX_N * 10 + 1];
for (int i = 2; i <= n; ++i) {
len[i] = len[i - 2] + len[i - 1];
sprintf(f[i], "%s%s", f[i - 2], f[i - 1]);
int start = 0;
if (len[i - 2] > max_len) {
start = len[i - 2] - max_len;
}
int my_len = my_substr(tmp_str, f[i - 2], start, max_len);
my_len += my_substr(tmp_str + my_len, f[i - 1], 0, max_len);
int64_t result = COUNT_KMP(tmp_str, s, my_len, s_len);
sum[i] = sum[i - 2] + sum[i - 1] + result;
if (sum[i] > k) {
return sum[i];
}
if (len[i] > max_len * 2) {
int del_num = len[i] - (max_len * 2);
for (int pos = max_len + del_num; pos < len[i]; ++pos) {
f[i][pos - del_num] = f[i][pos];
}
len[i] = max_len * 2;
f[i][len[i]] = '\0';
}
}
return sum[n];
}
int process() {
int n, m;
int64_t k;
char suffix[] =
"110101101011011010110101101101011011010110101101101011011010110101101101"
"011010110110101101101011010110110101101011011010110110101101011011010110"
"11010110101101101011010110110101101101011010110110101101";
int suffix_len = strlen(suffix);
cin >> n >> k >> m;
char s[MAX_N];
memset(s, '\0', sizeof(s));
for (int i = 0; i < m; ++i) {
int pos = suffix_len - i;
int s_pos = 0;
while (pos < suffix_len) {
if (s[s_pos] != suffix[pos]) {
break;
}
s_pos++;
pos++;
}
if (pos == suffix_len && i > 0) {
if (k == 1) {
break;
}
k--;
}
if (i > 0 && s[i - 1] == '0') {
s[i] = '1';
s[i + 1] = '\0';
continue;
}
s[i] = '0';
s[i + 1] = '\0';
int64_t count = cal(s, n, k);
if (count < k) {
k = k - count;
s[i] = '1';
}
}
printf("%s\n", s);
return 0;
}
int main(int argc, char *argv[]) {
char S[] = "abaabcacabaabcacabaabcacabaabcacabaabcac";
char T[] = "ab";
process();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
const int N = 200054;
int n, B, ans, mode;
int a[N], count[N];
int buc[2 * N];
int cur[N];
inline void up(int &x, const int y) { x < y ? x = y : 0; }
void solve(int x) {
int i, p = n;
memset(buc, -1, (2 * n + 1) << 2), buc[p] = 0;
for (i = 0; i < n; ++i) {
p += (a[i] == x) - (a[i] == mode);
if (~buc[p])
up(ans, i - buc[p] + 1);
else
buc[p] = i + 1;
}
}
void check(int L) {
int i, j = 0, Z = 0;
memset(cur, 0, (n + 1) << 2);
for (i = 0; i < n && j < n; ++i) {
for (; j < n; ++j)
if (++cur[a[j]] > L) {
--cur[a[j]];
break;
} else
Z += cur[a[j]] == L;
if (Z > 1) up(ans, j - i);
Z -= cur[a[i]]-- == L;
}
}
int main() {
int i;
bool multi = false;
std::ios::sync_with_stdio(false), cin.tie(NULL);
cin >> n, B = sqrt(n);
for (i = 0; i < n; ++i) cin >> a[i], ++count[a[i]];
for (i = 1; i <= n; ++i)
if (count[i] > count[mode])
mode = i, multi = false;
else if (count[i] == count[mode])
multi = true;
if (multi) return cout << n << '\n', 0;
for (i = 1; i <= n; ++i)
if (i != mode && count[i] >= B) solve(i);
for (i = 1; i <= B; ++i) check(i);
cout << ans << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int eps = 1e6 + 5;
const double pi = acos(-1.0);
const int inf = 1 << 29;
int f[1005];
int c[1005];
int n;
int vis[1005];
void dfs(int x) {
int sign = 0;
for (int i = 1; i <= n; i++) {
if (f[i] == x) {
dfs(i);
sign = 1;
}
}
if (!sign)
c[f[x]]++;
else
vis[x] = 1;
}
int main() {
int x;
cin >> n;
memset(f, 0, sizeof(f));
for (int i = 2; i <= n; i++) {
cin >> x;
f[i] = x;
}
dfs(1);
int sign = 1;
for (int i = 1; i <= n; i++) {
if (c[i] < 3 && vis[i]) {
sign = 0;
break;
}
}
if (sign)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int op(int y) {
if (y < 0) y = -y;
return y;
}
int n, pos, l, r;
int main() {
cin >> n >> pos >> l >> r;
if (l == 1 && r == n) {
cout << 0;
}
if (l == 1 && r != n) {
cout << op(r - pos) + 1;
}
if (l != 1 && r == n) {
cout << op(l - pos) + 1;
}
if (l != 1 && r != n) {
if (op(r - pos) < op(l - pos))
cout << r - l + op(r - pos) + 2;
else
cout << r - l + op(l - pos) + 2;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-8;
int sgn(double x) { return x < -eps ? -1 : x > eps; }
struct point {
double x, y;
point() : x(0), y(0) {}
point(double a, double b) : x(a), y(b) {}
point operator+(const point &b) const { return point(x + b.x, y + b.y); }
point operator-(const point &b) const { return point(x - b.x, y - b.y); }
point operator*(const double &b) const { return point(x * b, y * b); }
point operator/(const double &b) const { return point(x / b, y / b); }
bool operator==(const point &b) const {
return (sgn(y - b.y) == 0 && sgn(x - b.x) == 0);
}
double operator*(const point &b) const { return x * b.x + y * b.y; }
double X(const point &b) const { return x * b.y - y * b.x; }
point rot(const double &ta) const {
return point(cos(ta) * x - sin(ta) * y, sin(ta) * x + cos(ta) * y);
}
point rot90(const double &d) const { return point(-y, x) / len() * d; }
double dis(const point &b) const {
return sqrt(fabs((x - b.x) * (x - b.x) + (y - b.y) * (y - b.y)));
}
double len() const { return sqrt(x * x + y * y); }
};
struct polygon {
point p[20];
int n;
};
struct line {
double a, b, c;
};
line linefromsegment(point p1, point p2) {
line tmp;
tmp.a = p2.y - p1.y;
tmp.b = p1.x - p2.x;
tmp.c = p2.x * p1.y - p1.x * p2.y;
return tmp;
}
point lineinter(line l1, line l2) {
point tmp;
double a1 = l1.a, b1 = l1.b, c1 = l1.c, a2 = l2.a, b2 = l2.b, c2 = l2.c;
if (sgn(b1) == 0) {
tmp.x = -c1 / a1;
tmp.y = (-c2 - a2 * tmp.x) / b2;
} else {
tmp.x = (c1 * b2 - b1 * c2) / (b1 * a2 - b2 * a1);
tmp.y = (-c1 - a1 * tmp.x) / b1;
}
return tmp;
}
void cut_polygon(point p1, point p2, polygon &p) {
p.p[p.n] = p.p[0];
polygon new_polygon;
point interp;
line l1, l2;
double t1, t2;
new_polygon.n = 0;
for (int i = 0; i < p.n; i++) {
t1 = (p2 - p1).X(p.p[i] - p1);
t2 = (p2 - p1).X(p.p[i + 1] - p1);
if (sgn(t1) == 0) {
new_polygon.p[new_polygon.n++] = p.p[i];
if (sgn(t2) <= 0) new_polygon.p[new_polygon.n++] = p.p[i + 1];
} else if (sgn(t2) == 0) {
if (t1 < 0) new_polygon.p[new_polygon.n++] = p.p[i];
new_polygon.p[new_polygon.n++] = p.p[i + 1];
} else if (t1 < 0 && t2 < 0) {
new_polygon.p[new_polygon.n++] = p.p[i];
new_polygon.p[new_polygon.n++] = p.p[i + 1];
} else if (t1 * t2 < 0) {
l1 = linefromsegment(p1, p2);
l2 = linefromsegment(p.p[i], p.p[i + 1]);
interp = lineinter(l1, l2);
if (t1 < 0) {
new_polygon.p[new_polygon.n++] = p.p[i];
new_polygon.p[new_polygon.n++] = interp;
} else {
new_polygon.p[new_polygon.n++] = interp;
new_polygon.p[new_polygon.n++] = p.p[i + 1];
}
}
}
p.n = 0;
if (new_polygon.n == 0) return;
p.p[p.n++] = new_polygon.p[0];
for (int i = 1; i < new_polygon.n; i++)
if (!(new_polygon.p[i] == new_polygon.p[i - 1]))
p.p[p.n++] = new_polygon.p[i];
if (p.n != 1 && (p.p[p.n - 1] == p.p[0])) p.n--;
p.p[p.n] = p.p[0];
}
int n, h, f;
polygon a[550];
double cal(int th1, int th2) {
polygon gao = a[th1];
point cu[10];
for (int i = 0; i < 4; i++) {
cu[i] = a[th2].p[i];
cu[i].y = -cu[i].y;
}
for (int i = 0; i < 4; i++) {
cut_polygon(cu[(i + 1) % 4], cu[i], gao);
}
double s = 0;
for (int i = 1; i < gao.n - 1; i++)
s += (gao.p[i] - gao.p[0]).X(gao.p[i + 1] - gao.p[0]);
return fabs(s / 2);
}
int main() {
scanf("%d%d%d", &n, &h, &f);
double ans = 0;
for (int i = 1; i <= n; i++) {
double x, y;
scanf("%lf%lf", &x, &y);
line l1 = linefromsegment(point(0, f), point(x, h));
a[i].p[0] = point((h * l1.b - l1.c) / l1.a, -h);
a[i].p[1] = point((-h * l1.b - l1.c) / l1.a, h);
l1 = linefromsegment(point(0, f), point(y, h));
a[i].p[2] = point((-h * l1.b - l1.c) / l1.a, h);
a[i].p[3] = point((h * l1.b - l1.c) / l1.a, -h);
a[i].n = 4;
for (int j = 1; j < 3; j++)
ans += fabs((a[i].p[j] - a[i].p[0]).X(a[i].p[j + 1] - a[i].p[0]));
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) ans -= cal(i, j);
printf("%lf\n", ans);
}
| 9 |
#include <bits/stdc++.h>
int t1, t2;
int n;
std::map<int, int> m[2];
long long ans = 0;
int main() {
scanf("%d", &n);
m[0][0] = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &t2);
t1 ^= t2;
ans += m[i & 1][t1];
m[i & 1][t1]++;
}
printf("%I64d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e6 + 5;
long long p[4];
void solve() {
long long n, k;
cin >> n >> k;
long long m = (n - 1) * 6 + 5;
printf("%I64d\n", m * k);
for (long long i = 0; i < n; i++) {
p[0] = i * 6 + 1;
p[1] = i * 6 + 2;
p[2] = i * 6 + 3;
p[3] = i * 6 + 5;
for (int j = 0; j < 4; j++) {
printf("%I64d ", k * p[j]);
}
printf("\n");
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N;
int C[204];
vector<int> adj[204];
int go(int start, vector<queue<int> > q, vector<int> in_deg) {
int res = 0;
int h = start;
while (true) {
int d;
for (d = 0; d < 3 && q[h].empty(); ++d, h = (h + 1) % 3)
;
if (d >= 3) break;
res += d;
int u = q[h].front();
q[h].pop();
res++;
for (int j = 0; j < adj[u].size(); ++j) {
int v = adj[u][j];
if (--in_deg[v] == 0) q[C[v]].push(v);
}
}
return res;
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> C[i];
--C[i];
}
for (int v = 0; v < N; ++v) {
int k;
cin >> k;
while (k-- > 0) {
int u;
cin >> u;
--u;
adj[u].push_back(v);
}
}
vector<int> in_deg(N);
for (int u = 0; u < N; ++u) {
for (int j = 0; j < (int)adj[u].size(); ++j) {
int v = adj[u][j];
++in_deg[v];
}
}
vector<queue<int> > q(3);
for (int u = 0; u < N; ++u) {
if (in_deg[u] == 0) q[C[u]].push(u);
}
int res = 1000000000;
for (int start = 0; start < 3; ++start) {
int cur = go(start, q, in_deg);
res = min(res, cur);
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> V1[500005], V2[500005], ANS;
vector<int> RED(500005, 0), PL(500005, 0);
int DFS(int A, int L) {
int C = 0;
int CS = 0;
stack<int> S;
vector<int> VIS(500000, 0);
S.push(A);
VIS[A] = 1;
RED[A] = 0;
PL[A] = 0;
while (!S.empty()) {
int N = S.top();
S.pop();
C++;
VIS[N] = 1;
if (C == L) return CS;
for (int i = 0; i < V1[N].size(); i++)
if (!VIS[V1[N][i]]) {
PL[V1[N][i]] = PL[N] + 1;
RED[V1[N][i]] = RED[N];
S.push(V1[N][i]);
}
for (int i = 0; i < V2[N].size(); i++)
if (!VIS[V2[N][i]]) {
CS++;
PL[V2[N][i]] = PL[N] + 1;
RED[V2[N][i]] = RED[N] + 1;
S.push(V2[N][i]);
}
}
}
int DFS1(int A, int L) {
int C = 0;
int CS = 0;
stack<int> S;
vector<int> VIS(500000, 0);
S.push(A);
VIS[A] = 1;
while (!S.empty()) {
int N = S.top();
S.pop();
C++;
VIS[N] = 1;
if (C == L) return CS;
for (int i = 0; i < V1[N].size(); i++)
if (!VIS[V1[N][i]]) S.push(V1[N][i]);
for (int i = 0; i < V2[N].size(); i++)
if (!VIS[V2[N][i]]) {
CS++;
S.push(V2[N][i]);
}
}
}
int main() {
int L, A, B, TMP, T;
int M = 500005;
cin >> L;
for (int i = 1; i < L; i++) {
cin >> A >> B;
V1[A].push_back(B);
V2[B].push_back(A);
}
T = DFS(1, L);
for (int i = 1; i < L + 1; i++) {
TMP = T - 2 * RED[i] + PL[i];
if (M > TMP) {
ANS.clear();
ANS.push_back(i);
M = TMP;
} else if (M == TMP)
ANS.push_back(i);
}
cout << M << endl;
vector<int>::iterator it;
for (it = ANS.begin(); it != ANS.end(); it++) cout << *it << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
int s[100000];
void func(int n, int k) {
int i;
for (i = n - 2; i >= 0 && s[i] == s[i + 1]; i--)
;
i++;
if (k > i) {
printf("%d\n", i);
} else {
printf("-1\n");
}
}
int main() {
int n, k, i;
while (scanf("%d%d", &n, &k) == 2) {
for (i = 0; i < n; i++) {
scanf("%d", &s[i]);
}
func(n, k);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
inline long long MAX2(long long a, long long int b) {
return (a) > (b) ? (a) : (b);
}
inline long long MAX3(long long a, long long b, long long c) {
return (a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c));
}
inline long long MIN2(long long a, long long b) {
return (a) < (b) ? (a) : (b);
}
inline long long MIN3(long long a, long long b, long long c) {
return (a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c));
}
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int b, w;
cin >> b >> w;
vector<pair<int, int> > co;
if (b > w) {
if (b > 3 * w + 1) {
cout << "NO\n";
continue;
}
int x = 1e5 + 1, y = 1e5 + 1;
int i = 0;
while (i < w - 1) {
co.push_back(pair<int, int>(x, y));
y++;
co.push_back(pair<int, int>(x, y));
y++;
i++;
}
co.push_back(pair<int, int>(x, y));
y++;
int si = co.size();
int req = b - w + 1;
i = 0;
while (i < si && req > 0) {
co.push_back(pair<int, int>(co[i].first - 1, co[i].second));
req--;
if (req == 0) break;
co.push_back(pair<int, int>(co[i].first + 1, co[i].second));
req--;
i += 2;
}
if (req > 0) {
co.push_back(pair<int, int>(co[0].first, co[0].second - 1));
req--;
}
if (req > 0) {
co.push_back(
pair<int, int>(co[2 * (w - 1)].first, co[2 * (w - 1)].second + 1));
req--;
}
} else {
if (w > 3 * b + 1) {
cout << "NO\n";
continue;
}
int x = 1e5, y = 1e5 + 1;
int i = 0;
while (i < b - 1) {
co.push_back(pair<int, int>(x, y));
y++;
co.push_back(pair<int, int>(x, y));
y++;
i++;
}
co.push_back(pair<int, int>(x, y));
y++;
int si = co.size();
int req = w - b + 1;
i = 0;
while (i < si && req > 0) {
co.push_back(pair<int, int>(co[i].first - 1, co[i].second));
req--;
if (req == 0) break;
co.push_back(pair<int, int>(co[i].first + 1, co[i].second));
req--;
i += 2;
}
if (req > 0) {
co.push_back(pair<int, int>(co[0].first, co[0].second - 1));
req--;
}
if (req > 0) {
co.push_back(
pair<int, int>(co[2 * (b - 1)].first, co[2 * (b - 1)].second + 1));
req--;
}
}
cout << "YES\n";
int i, si = co.size();
for (i = 0; i < si; i++) cout << co[i].first << " " << co[i].second << '\n';
}
cerr << '\n'
<< "Time elapsed : " << clock() * 1000.0 / CLOCKS_PER_SEC << " ms"
<< '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long arr[200100];
vector<pair<long long, long long> > ans;
vector<long long> vec[3];
int main() {
long long t, n, i, j, k, l, m;
ios_base::sync_with_stdio(0);
cin.tie(0);
long long a, b;
t = 1;
while (t--) {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> arr[i];
vec[arr[i]].push_back(i);
}
for (i = 1; i <= 2; i++) sort(vec[i].begin(), vec[i].end());
for (i = 1; i <= n; i++) {
j = 1;
long long cnt1 = 0, cnt2 = 0, last_win = 1;
while (j <= n) {
long long idx1 =
lower_bound(vec[1].begin(), vec[1].end(), j) - vec[1].begin();
long long idx2 =
lower_bound(vec[2].begin(), vec[2].end(), j) - vec[2].begin();
long long op1 = n + 1, op2 = n + 1;
idx1 += i - 1;
idx2 += i - 1;
if (idx1 < vec[1].size()) op1 = vec[1][idx1];
if (idx2 < vec[2].size()) op2 = vec[2][idx2];
if (op1 > n && op2 > n) break;
if (op1 < op2)
j = op1 + 1, cnt1++, last_win = 1;
else
j = op2 + 1, cnt2++, last_win = 2;
}
if ((last_win == 1 && cnt1 < cnt2) || (last_win == 2 && cnt2 < cnt1))
continue;
if (j > n && cnt1 != cnt2)
ans.push_back(pair<long long, long long>(max(cnt1, cnt2), i));
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (pair<long long, long long> x : ans)
cout << x.first << ' ' << x.second << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 405;
const int inf = 0x3f3f3f3f;
int dp[maxn][maxn];
bool check(string s, string t1, string t2) {
memset(dp, -1, sizeof(dp));
int slen = s.size();
int t1len = t1.size();
dp[0][0] = 0;
for (int i = 0; i < slen; i++) {
for (int j = 0; j <= t1len && j <= i; j++) {
if (dp[i][j] != -1) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
if (s[i] == t1[j]) {
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j]);
}
if (s[i] == t2[dp[i][j]]) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + 1);
}
}
}
}
for (int i = t1len; i <= slen; i++) {
if (dp[i][t1len] == t2.size()) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
string s, t;
cin >> s >> t;
bool f = false;
for (int i = 0; i <= t.size(); i++) {
string t1 = t.substr(0, i);
string t2 = t.substr(i, t.size() - i);
if (check(s, t1, t2)) {
f = true;
break;
}
}
if (f) {
puts("YES");
} else {
puts("NO");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char str[110][110];
void fill(int x1, int y1, int x2, int y2, int t) {
int i, j;
char ch = 'a';
bool arr[30] = {0};
if (x1 > 0) arr[str[x1 - 1][y1] - 'a'] = 1;
if (y1 > 0) arr[str[x1][y1 - 1] - 'a'] = 1;
if (t == 1) {
if (x1 > 0) arr[str[x1 - 1][y1 + 1] - 'a'] = 1;
}
if (t == 2) {
if (y1 > 0) arr[str[x1 + 1][y1 - 1] - 'a'] = 1;
}
if (t == 3) {
if (x1 > 0) arr[str[x1 - 1][y1 + 1] - 'a'] = 1;
if (y1 > 0) arr[str[x1 + 1][y1 - 1] - 'a'] = 1;
}
for (i = 0; i <= 25; i++) {
if (arr[i] == 0) {
ch = i + 'a';
break;
}
}
for (i = x1; i <= x2; i++)
for (j = y1; j <= y2; j++) str[i][j] = ch;
}
int main() {
int n, m, x, y, n1, m1, a, b, c, c_c, a_c, b_c, f = 0, cn, i, j, x1, g, h;
cin >> n >> m >> a >> b >> c;
f = 0;
if (n % 2 == 1 && m % 2 == 1) {
f = 1;
} else if (a * 2 + b * 2 + c * 4 < n * m) {
f = 1;
} else if (n % 2 == 0 && m % 2 == 0) {
cn = 0;
a_c = 0;
b_c = 0;
c_c = 0;
for (i = 0; i < c; i++) {
if (cn < n * m) {
c_c++;
cn += 4;
} else
break;
}
if (cn < n * m) {
for (i = 0; i < b / 2; i++) {
if (cn < n * m) {
b_c += 2;
cn += 4;
} else
break;
}
}
if (cn < n * m) {
for (i = 0; i < a / 2; i++) {
if (cn < n * m) {
a_c += 2;
cn += 4;
} else
break;
}
}
if (cn < n * m) f = 1;
} else {
cn = 0;
a_c = 0;
b_c = 0;
c_c = 0;
n1 = n;
m1 = m;
if (n % 2 == 1) {
x = m / 2;
if (a < x)
f = 1;
else {
a -= x, a_c = x;
cn += m;
}
} else if (m % 2 == 1) {
x = n / 2;
if (b < x)
f = 1;
else {
b -= x, b_c = x;
cn += n;
}
}
for (i = 0; i < c; i++) {
if (cn < n * m) {
c_c++;
cn += 4;
} else
break;
}
if (cn < n * m) {
for (i = 0; i < b / 2; i++) {
if (cn < n * m) {
b_c += 2;
cn += 4;
} else
break;
}
}
if (cn < n * m) {
for (i = 0; i < a / 2; i++) {
if (cn < n * m) {
a_c += 2;
cn += 4;
} else
break;
}
}
if (cn < n * m) f = 1;
}
if (f == 1)
cout << "IMPOSSIBLE" << endl;
else {
n1 = n;
m1 = m;
x = 0, y = 0;
g = 0, h = 0;
if (n % 2 == 1) {
for (i = 0; i < m / 2; i++) {
fill(0, y, 0, y + 1, 1);
a_c--;
y = (y + 2);
}
g = 1;
}
if (m % 2 == 1) {
for (i = 0; i < n / 2; i++) {
fill(x, 0, x + 1, 0, 2);
b_c--;
x = (x + 2);
}
h = 1;
}
for (i = 0; i < n / 2; i++)
for (j = 0; j < m / 2; j++) {
x = i * 2 + g;
y = j * 2 + h;
if (c_c > 0) {
fill(x, y, x + 1, y + 1, 3);
c_c--;
} else if (b_c > 0) {
fill(x, y, x + 1, y, 2);
fill(x, y + 1, x + 1, y + 1, 2);
b_c -= 2;
} else {
fill(x, y, x, y + 1, 1);
fill(x + 1, y, x + 1, y + 1, 1);
a_c -= 2;
}
}
for (i = 0; i < n; i++, cout << endl)
for (j = 0; j < m; j++) {
assert(str[i][j] >= 'a' && str[i][j] <= 'z');
cout << str[i][j];
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
int x, y;
if (a % c == 0) {
x = a / c;
} else {
x = a / c + 1;
}
if (b % d == 0) {
y = b / d;
} else {
y = b / d + 1;
}
if (x + y > k) {
cout << -1;
return;
}
cout << x << " " << y;
}
int main() {
int t;
cin >> t;
while (t--) {
solve(), cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long x, y;
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
int main() {
ios_base::sync_with_stdio(0);
cin >> x >> y;
if (gcd(x, y) != 1) {
cout << "Impossible" << endl;
exit(0);
} else {
int cur = -1;
int sz = 0;
while (x != 1 && y != 1) {
if (x > y) {
if (cur == -1) cur = 1;
if (cur == 2) {
cout << sz << 'B';
cur = 1;
sz = 0;
}
x -= y;
sz++;
} else {
if (cur == -1) cur = 2;
if (cur == 1) {
cout << sz << 'A';
cur = 2;
sz = 0;
}
y -= x;
sz++;
}
}
if (cur == 1)
cout << sz << 'A';
else if (cur == 2)
cout << sz << 'B';
if (x > 1)
cout << x - 1 << 'A';
else
cout << y - 1 << 'B';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
set<long long> arr;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, d;
cin >> n >> m >> d;
long long arr1[n];
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
arr1[i] = x;
arr.insert(x);
}
long long day = 1;
map<long long, long long> ma;
set<long long>::iterator f;
long long cur;
while (arr.size() != 0) {
cur = *(arr.begin());
ma[cur] = day;
arr.erase(arr.begin());
while (true) {
f = arr.lower_bound(cur + d + 1);
if (f == arr.end()) break;
cur = *f;
arr.erase(f);
ma[cur] = day;
}
day++;
}
long long mx = LONG_MIN;
for (long long i = 0; i < n; i++) {
mx = max(mx, ma[arr1[i]]);
}
cout << mx << "\n";
for (long long i = 0; i < n; i++) {
cout << ma[arr1[i]] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[7] = {0, 2, 3, 5, 7, 11, 13};
int n, m, ans[1000000], s, maxx, nm;
void dfs(int x, int t) {
if (t > nm) {
ans[++m] = x;
return;
}
dfs(x, t + 1);
while (x * a[t] <= maxx) x *= a[t], dfs(x, t + 1);
}
int main() {
scanf("%d", &n);
maxx = n * n * 2;
do {
m = 0;
++nm;
dfs(1, 1);
} while (m < 2 * n);
sort(ans + 1, ans + m + 1);
for (int j = 0; j < n; j++) printf("%d ", ans[m - j]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, i;
cin >> n;
string A[n];
set<string> s;
for (i = 0; i < n; i++) cin >> A[i];
for (i = 0; i < n; i++) {
if (s.find(A[i]) == s.end()) {
s.insert(A[i]);
cout << "NO"
<< "\n";
} else
cout << "YES"
<< "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = INT_MAX;
const vector<vector<int> > adj4({{0, 1}, {0, -1}, {1, 0}, {-1, 0}});
const vector<vector<int> > adj8(
{{0, 1}, {0, -1}, {1, 0}, {-1, 0}, {-1, -1}, {1, -1}, {-1, 1}, {1, 1}});
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int powMod(int a, int b, int mod) {
int n = 1;
int p = a;
while (b > 0) {
if (b % 2 == 1) {
n *= p;
n %= mod;
}
p *= p;
p %= mod;
b /= 2;
}
return n;
}
int modularInverse(int a, int mod) { return powMod(a, mod - 2, mod); }
stringstream sss;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
sss << R"(
6
1 0 1 1 1 0
)";
int n;
cin >> n;
vector<bool> arr(n);
for (int i = 0; i < (n); ++i) {
int a;
cin >> a;
arr[i] = a;
}
int sz = n;
vector<bool> p(sz, false);
for (int i = (1); i < (sz); ++i) {
if (true) {
;
if (n % i != 0 || n < i * 3) continue;
vector<int> cnt(i, 0);
for (int k = 0; k < (n); ++k) {
if (arr[k]) {
++cnt[k % i];
}
};
for (int k = 0; k < (i); ++k) {
if (cnt[k] == n / i) {
cout << ("YES") << endl;
return 0;
}
}
}
}
cout << ("NO") << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> solve(vector<int> &A, vector<int> &B) {
vector<int> ans;
int n = (int)(A).size(), m = (int)(B).size();
if (n < m) return ans;
map<int, int> MA, MB;
for (int i = (0); i <= (m - 1); ++i) MA[A[i]]++;
for (int i = (0); i <= (m - 1); ++i) MB[B[i]]++;
int good = 0;
for (int i = (0); i <= (m - 1); ++i) good += (MA[B[i]] == MB[B[i]]);
for (int i = (0); i <= (n - m); ++i) {
if (good == m) ans.push_back(i);
if (i + m < n) {
int left = A[i], right = A[i + m];
if (MA[left] == MB[left]) good -= MB[left];
if (MA[right] == MB[right]) good -= MB[right];
MA[left]--;
MA[right]++;
if (MA[left] == MB[left]) good += MB[left];
if (MA[right] == MB[right]) good += MB[right];
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
int n, m, p;
cin >> n >> m >> p;
vector<vector<int> > A(p);
vector<int> B(m);
for (int i = (0); i <= (n - 1); ++i) {
int t;
cin >> t;
A[i % p].push_back(t);
}
for (int i = (0); i <= (m - 1); ++i) cin >> B[i];
vector<int> ans;
for (int i = (0); i <= (p - 1); ++i) {
vector<int> tmp = solve(A[i], B);
for (int j = (0); j <= ((int)(tmp).size() - 1); ++j)
ans.push_back(tmp[j] * p + i);
}
sort(ans.begin(), ans.end());
cout << (int)(ans).size() << '\n';
for (int i = (0); i <= ((int)(ans).size() - 1); ++i)
cout << ans[i] + 1 << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 500001;
int n, k;
int a[mxn];
int dfs(int c) {
int i = c - 1;
while (~i && (a[i] == c || a[i] == -2)) i = dfs(i);
a[c] = ++k;
return i;
}
void answer() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i], a[i]--;
k = 0;
if (~dfs(n)) {
cout << -1 << '\n';
} else {
cout << a[0];
for (int i = 1; i < n; i++) cout << " " << a[i];
cout << '\n';
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) answer();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
string garbage, weekOrMonth;
cin >> x >> garbage >> weekOrMonth;
if (weekOrMonth == "week") {
if (x != 5 && x != 6)
cout << 52;
else
cout << 53;
} else if (weekOrMonth == "month") {
if (x <= 29)
cout << 12;
else if (x == 30)
cout << 11;
else if (x == 31)
cout << 7;
}
return 0;
}
| 0 |
/*
* yaswanth phani kommineni
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define endl '\n';
void solve(){
ll n;
cin >> n;
n*=2;
vector <ll> v(n);
map <ll,ll> m;
for(ll i=0;i<n;i++){
cin >> v[i];
m[v[i]]++;
}
sort(v.begin(),v.end());
for(ll i=0;i<n-1;i++){
auto mp = m;
auto V = v;
vector <pair<ll,ll>> ans;
ans.push_back(make_pair(v[n-1],v[i]));
mp[v[n-1]]--;
mp[v[i]]--;
ll cur = v[n-1];
while(true){
while(!V.empty() && !mp[V.back()]){
V.pop_back();
}
if(V.empty()) break;
ll last = V.back();
mp[last]--;
if(!mp[cur-last]){
break;
}
ans.push_back(make_pair(last,cur-last));
mp[cur-last]--;
cur = last;
}
if((ll)ans.size()==n/2){
cout << "YES" << endl;
cout << ans.front().first + ans.front().second << endl;
for(auto x : ans){
cout << x.second << " " << x.first << endl;
}
return;
}
}
cout << "NO" << endl;
}
int main(){
//freopen("input.txt","r",stdin);
//freopen("output.txt","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tc;
tc = 1;
cin >> tc;
for(int i=1;i<=tc;i++){
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> g[N];
bool seen[N], type[N];
int t[N];
int solve(int cur);
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> type[i];
}
while (m--) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
}
int ans = 0;
for (int i = 0; i < n; ++i) {
ans = max(ans, solve(i));
}
cout << ans << endl;
}
int solve(int cur) {
if (seen[cur]) {
return t[cur];
}
seen[cur] = true;
t[cur] = type[cur];
for (auto &i : g[cur]) {
if (type[cur] == 1 and type[i] == 0) {
t[cur] = max(t[cur], solve(i) + 1);
} else {
t[cur] = max(t[cur], solve(i));
}
}
return t[cur];
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
map<string, int> m;
vector<string> vv;
int was[100];
long long h[100], w[100], border[100], spacing[100];
int type[100];
vector<int> v[100];
int pp;
void add(string name, int t, int x, int y) {
m[name] = pp;
vv.push_back(name);
type[pp] = t;
w[pp] = x;
h[pp] = y;
pp++;
}
void go(int p) {
if (was[p]) return;
was[p] = 1;
if (type[p] == 0) return;
long long ww = 0, hh = 0;
for (int i = 0; i < (((int)(v[p]).size())); i++) {
int u = v[p][i];
go(u);
if (type[p] == 1) {
ww += w[u];
hh = max(hh, h[u]);
} else {
hh += h[u];
ww = max(ww, w[u]);
}
}
if (((int)(v[p]).size())) {
if (type[p] == 1)
ww += (((int)(v[p]).size()) - 1) * spacing[p];
else
hh += (((int)(v[p]).size()) - 1) * spacing[p];
ww += 2 * border[p];
hh += 2 * border[p];
w[p] = ww;
h[p] = hh;
} else
w[p] = h[p] = 0;
}
int main() {
cin >> n;
char str[10000];
gets(str);
for (int o = 0; o < (n); o++) {
gets(str);
string s = str;
for (int i = 0; i < (((int)(s).size())); i++)
if (s[i] == '.' || s[i] == ')' || s[i] == '(' || s[i] == ',') s[i] = ' ';
stringstream sin(s);
string s1, s2, s3, s4;
int x, y;
sin >> s1;
if (s1 == "Widget") {
sin >> s2 >> x >> y;
add(s2, 0, x, y);
} else if (s1 == "HBox") {
sin >> s2;
add(s2, 1, 0, 0);
} else if (s1 == "VBox") {
sin >> s2;
add(s2, 2, 0, 0);
} else {
sin >> s2;
int p = m[s1];
if (s2 == "pack") {
sin >> s3;
int q = m[s3];
v[p].push_back(q);
} else {
sin >> x;
if (s2 == "set_border")
border[p] = x;
else
spacing[p] = x;
}
}
}
sort((vv).begin(), (vv).end());
for (int i = 0; i < (((int)(vv).size())); i++) {
int p = m[vv[i]];
go(p);
cout << vv[i] << ' ' << w[p] << ' ' << h[p] << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 55;
const int maxK = 20;
long long f[(1 << maxK) + 2];
long long bt[(1 << maxK) + 2];
string s[maxN];
long long val[maxK];
long double num[maxK];
bool bad[(1 << maxK) + 2];
int bits[(1 << maxK) + 2];
long double dp[(1 << maxK) + 2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
for (int i = 1; i < (1 << (20)); i++) {
for (int j = 0; j < 20; j++) {
if (i & (1 << j)) {
bt[i] = j;
bits[i] = bits[i ^ (1 << j)] + 1;
break;
}
}
}
int n;
cin >> n;
if (n == 1) {
cout << 0;
return 0;
}
for (int i = 0; i < n; i++) {
cin >> s[i];
}
int m = s[0].size();
num[0] = 1;
for (int i = 1; i <= m; i++) {
num[i] = (num[i - 1]) * ((1.0 * i) / (m - i + 1));
}
long double all = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
val[j] = 0;
for (int k = 0; k < n; k++) {
if (k == i) continue;
if (s[i][j] == s[k][j]) {
val[j] |= (1LL << k);
}
}
}
f[0] = (1LL << n) - 1;
long double ans = 0;
dp[0] = 1;
for (int mask = 1; mask < (1 << m); mask++) {
f[mask] = f[mask ^ (1 << bt[mask])] & val[bt[mask]];
if (f[mask] != 0) {
ans += num[bits[mask]];
}
}
all += (ans + 1) / n;
}
cout << fixed << setprecision(10) << all;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const long double PI = acos(0.0) * 2.0;
mt19937_64 rng((unsigned long long)new char);
const int mod = 1e9 + 7;
const long long INF = 9e18;
const int maxn = 510;
char s[maxn][maxn];
long long dp[2][maxn][maxn];
inline void add(long long& x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
int main() {
int n, m;
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = (1); i < (n + 1); ++i)
for (int j = (1); j < (m + 1); ++j) cin >> s[i][j];
if (s[1][1] != s[n][m]) return cout << 0, 0;
int now = 0;
dp[now][1][n] = 1;
int ls = (n + m) / 2;
for (int step = 2; step <= ls; ++step) {
now ^= 1;
memset(dp[now], 0, sizeof(dp[now]));
for (int x = max(1, step + 1 - m); x <= min(step, n); ++x)
for (int y = max(1, n + 1 - step); y <= min(n + m - step, n); ++y) {
if (s[x][step + 1 - x] != s[y][n + m - step + 1 - y]) continue;
long long& a = dp[now][x][y];
add(a, dp[now ^ 1][x][y]);
add(a, dp[now ^ 1][x - 1][y]);
add(a, dp[now ^ 1][x - 1][y + 1]);
add(a, dp[now ^ 1][x][y + 1]);
}
}
long long ans = 0;
int step = ls;
for (int x = max(1, step + 1 - m); x <= min(step, n); ++x)
for (int y = max(1, n + 1 - step); y <= min(n + m - step, n); ++y) {
if ((n + m) & 1) {
if (x == y || y == x + 1) add(ans, dp[now][x][y]);
} else {
if (x == y) add(ans, dp[now][x][y]);
}
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
static void redirect(int argc, const char **argv) {
ios::sync_with_stdio(false);
if (argc > 1) {
static filebuf f;
f.open(argv[1], ios::in);
cin.rdbuf(&f);
if (!cin) {
cerr << "Failed to open '" << argv[1] << "'" << endl;
exit(1);
}
}
if (argc > 2) {
static filebuf f;
f.open(argv[2], ios::out | ios::trunc);
cout.rdbuf(&f);
if (!cout) {
cerr << "Failed to open '" << argv[2] << "'" << endl;
}
}
}
static complex<double> read_ipnt() {
int x, y;
cin >> x >> y;
return complex<double>(x, y);
}
int main(int argc, const char **argv) {
redirect(argc, argv);
complex<double> start = read_ipnt();
complex<double> end = read_ipnt();
complex<double> travel = end - start;
double v, t;
cin >> v >> t;
complex<double> wind1 = read_ipnt();
complex<double> wind2 = read_ipnt();
double force_v = v - abs(wind2);
double lo = 0.0;
double hi = 1e18;
for (int i = 0; i < 2000; i++) {
double m = (lo + hi) * 0.5;
double m1 = min(m, t);
double m2 = m - m1;
if (abs(travel - (wind1 * m1 + wind2 * m2)) < v * m)
hi = m;
else
lo = m;
}
cout << fixed << setprecision(12) << lo << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main(void) {
int planes[5001], n, a;
scanf("%d", &n);
for (a = 1; a <= n; a = a + 1) {
scanf("%d", &planes[a]);
}
for (a = 1; a <= n; a = a + 1) {
if (planes[planes[planes[a]]] == a) {
puts("YES");
return 0;
}
}
puts("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long hpy, atky, defy;
long hpm, atkm, defm;
long thpy, tatky, tdefy;
long morehp, moreatk, moredef;
long res, nowm;
long h, a, d;
int main() {
cin >> hpy >> atky >> defy;
cin >> hpm >> atkm >> defm;
cin >> h >> a >> d;
res = 1000000000;
for (moredef = 0; moredef <= 10000; moredef++)
for (moreatk = 0; moreatk <= 10000; moreatk++) {
tdefy = defy + moredef;
tatky = atky + moreatk;
nowm = tatky - defm;
if (nowm <= 0) continue;
if (hpm % nowm == 0)
nowm = hpm / nowm;
else
nowm = hpm / nowm + 1;
long tt = nowm * (atkm - tdefy) + 1;
long ttt = moredef * d + moreatk * a + max(long(0), tt - hpy) * h;
if (ttt < res) res = ttt;
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, l, m, n, d;
cin >> k >> l >> m >> n >> d;
int count = d;
for (int i = 1; i <= d; i++) {
if (i % k == 0 || i % l == 0 || i % m == 0 || i % n == 0)
continue;
else
count--;
}
cout << count;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e4 + 1000;
const int sq = 256;
int a[maxn], cnt, h[maxn], par[maxn], parsq[maxn], nxt[maxn * 10][2],
gett[maxn][sq], ans[maxn][sq];
vector<int> g[maxn];
inline void dfs(int v, int pp = 0) {
h[v] = h[pp] + 1;
par[v] = pp;
for (auto u : g[v]) {
if (u != pp) {
dfs(u, v);
}
}
}
inline void deletetrie(int v) {
if (nxt[v][1]) {
deletetrie(nxt[v][1]);
}
if (nxt[v][0]) {
deletetrie(nxt[v][0]);
}
nxt[v][0] = nxt[v][1] = 0;
}
inline void add(int x) {
int v = 1;
for (int i = 7; i >= 0; --i) {
int b = (x >> i) & 1;
if (!nxt[v][b]) {
nxt[v][b] = cnt++;
}
v = nxt[v][b];
}
}
inline int query(int x) {
int v = 1;
int ans = 0;
for (int i = 7; i >= 0; --i) {
int b = (x >> i) & 1;
if (nxt[v][1 ^ b]) {
ans += (1 << i);
v = nxt[v][1 ^ b];
} else {
v = nxt[v][b];
}
}
return ans;
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
for (int i = 1; i <= n; ++i) {
if (h[i] >= sq) {
cnt = 2;
int now = i;
for (int j = 0; j < sq; ++j) {
ans[i][(a[now] >> 8)] =
max(ans[i][(a[now] >> 8)], (a[now] & (sq - 1)) ^ j);
add(a[now] >> 8);
now = par[now];
}
for (int j = 0; j < sq; ++j) {
gett[i][j] = query(j);
}
parsq[i] = now;
deletetrie(1);
}
}
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
int res = 0, num = 0, beginv = v;
while (h[v] - h[u] >= sq) {
int ame = gett[v][num];
res = max(res, (ame << 8) ^ ans[v][ame ^ num]);
num++;
v = parsq[v];
}
while (h[v] >= h[u]) {
res = max(res, a[v] ^ (-h[v] + h[beginv]));
v = par[v];
}
printf("%d\n", res);
}
return 0;
}
| 12 |
//#pragma GCC optimize("Ofast,unroll-loops,omit-frame-pointer,inline")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,arch=native,tune=native,no-zero-upper")
//#pragma GCC target("avx2,fma")
#include<bits/stdc++.h>
#define int long long
using namespace std;
#define rep(i,n) for (int i=0;i<(int)(n);++i)
#define rep1(i,n) for (int i=1;i<=(int)(n);++i)
#define range(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define pb push_back
#define F first
#define S second
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vi;
const ll mod = (119 << 23) + 1, root = 62; // = 998244353
// For p < 2^30 there is also e.g. 5 << 25, 7 << 26, 479 << 21
// and 483 << 21 (same root). The last two are > 10^9.
ll modpow(ll b, ll e) {
ll ans = 1;
for (; e; b = b * b % mod, e /= 2)
if (e & 1) ans = ans * b % mod;
return ans;
}
typedef vector<ll> vl;
void ntt(vl &a) {
int n = sz(a), L = 31 - __builtin_clz(n);
static vl rt(2, 1);
for (static int k = 2, s = 2; k < n; k *= 2, s++) {
rt.resize(n);
ll z[] = {1, modpow(root, mod >> s)};
for(int i=k;i<2*k;++i) rt[i] = rt[i / 2] * z[i & 1] % mod;
}
vi rev(n);
for(int i = 0; i < n; ++i) rev[i] = (rev[i / 2] | (i & 1) << L) / 2;
for(int i = 0; i < n; ++i) if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int k = 1; k < n; k *= 2)
for (int i = 0; i < n; i += 2 * k) for(int j = 0; j < k; ++j) {
ll z = rt[j + k] * a[i + j + k] % mod, &ai = a[i + j];
a[i + j + k] = ai - z + (z > ai ? mod : 0);
ai += (ai + z >= mod ? z - mod : z);
}
}
vl conv(const vl &a, const vl &b) {
if (a.empty() || b.empty()) return {};
int s = sz(a) + sz(b) - 1, B = 32 - __builtin_clz(s), n = 1 << B;
int inv = modpow(n, mod - 2);
vl L(a), R(b), out(n);
L.resize(n), R.resize(n);
ntt(L), ntt(R);
for (int i = 0; i < n; ++i) out[-i & (n - 1)] = (ll)L[i] * R[i] % mod * inv % mod;
ntt(out);
return {out.begin(), out.begin() + s};
}
const int maxn=1007;
int n,k;
int l[maxn];
struct polynomial{
int n,m;
vector<vi> poly;
polynomial(vector<vi> &po):poly(po){
n = sz(poly) - 1, m = sz(poly[0]) - 1;
}
vi rsz(int nn,int mm){
assert(nn>n&&mm>m);
vi ret;
ret.resize(nn*mm+1,0);
for (int i=0;i<=n;++i){
for (int j=0;j<=m;++j){
ret[i*mm+j]=poly[i][j];
assert(poly[i][j]<mod&&poly[i][j]>=0);
}
}
return ret;
}
friend polynomial operator*(polynomial l,polynomial r){
vector<vi> po;
po.clear();
po.resize(l.n+r.n+1,vi(l.m+r.m+1,0));
auto lpo=l.rsz(l.n+1,l.m+r.m+1),rpo=r.rsz(r.n+1,l.m+r.m+1),res=conv(lpo,rpo);
// for (auto c:res) cout<<c<<" ";
// cout<<endl;
// cout<<sz(lpo)<<" "<<sz(rpo)<<" "<<sz(res)<<endl;
for (int i=0;i<=l.n+r.n;++i){
for (int j=0;j<=l.m+r.m;++j){
po[i][j]=res[i*(l.m+r.m+1)+j];
}
}
// cout<<"hi"<<endl;
return po;
}
};
vector<polynomial> poly;
int f[5007];
signed main(){
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin>>n>>k;
f[0]=1;
rep1(i,5000) f[i]=f[i-1]*i%mod;
int L=0;
rep(i,n) cin>>l[i], L+=l[i];
rep(i,n){
vi res0,res1;
res0.clear(), res1.clear();
res0.pb(1), res1.pb(0);
int sgn=1;
rep1(j,l[i]/k){
int tmp0,tmp1;
sgn=-sgn;
if (l[i]==k*j) {
tmp0=tmp1=0;
}
else{
tmp0=(modpow((l[i]-k*j)*modpow(L,mod-2)%mod,j)%mod)*modpow(f[j],mod-2)%mod, tmp1=(modpow((l[i]-k*j)*modpow(L,mod-2)%mod,j-1)%mod)*modpow(f[j-1],mod-2)%mod;
if (sgn<0) tmp0=(tmp0?mod-tmp0:tmp0), tmp1=(tmp1?mod-tmp1:tmp1);
}
// cerr<<i<<" "<<j<<":"<<tmp0<<" "<<tmp1<<endl;
res0.pb(tmp0), res1.pb(tmp1);
}
vector<vi> p({res0,res1});
polynomial po(p);
poly.pb(po);
}
for (int k=1;k<=n;k<<=1){
for (int i=k;i<n;i+=2*k){
poly[i-k]=poly[i]*poly[i-k];
}
}
int ans=0;
// x^{j-i}exp((1-k*j/L)) -> (j-i)!/((k*j/L)^{j-i+1}) = (j-i)!L^{j-i+1}/(k*j)^{j-i+1}
rep(i,poly[0].n+1){
rep(j,poly[0].m+1){
if (i>j) {assert(poly[0].poly[i][j]==0); continue;}
if (j==0) {assert(poly[0].poly[i][j]==1); continue;}
if (k*j==L) {assert(poly[0].poly[i][j]==0); continue;}
int num=f[j-i]*modpow(L,j-i+1)%mod,den=modpow(k*j,j-i+1)%mod;
// cerr<<i<<","<<j<<":"<<poly[0].poly[i][j]<<" "<<num<<" "<<den<<endl;
ans=(ans+(num*modpow(den,mod-2)%mod)*poly[0].poly[i][j]%mod)%mod;
}
}
if (ans>0) cout<<mod-ans<<endl;
else cout<<0<<endl;
return 0;
} | 13 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void print(T v) {
cout << ((int)(v).size()) << endl;
for (auto x : v) cout << x << ' ';
cout << endl;
};
template <class T>
void print1(T v) {
cout << ((int)(v).size()) << endl;
for (auto x : v) cout << x + 1 << ' ';
cout << endl;
};
template <class T>
void printpair(T v) {
cout << ((int)(v).size()) << endl;
for (auto x : v) cout << '(' << v.first << ' ' << v.second << ')' << ' ';
cout << endl;
};
template <class T1, class T2>
ostream& operator<<(ostream& o, pair<T1, T2> x) {
return o << x.first << ' ' << x.second;
}
template <class T1, class T2>
istream& operator>>(istream& o, pair<T1, T2>& x) {
return o >> x.first >> x.second;
}
template <class T1, class T2>
pair<T1, T2> operator+(pair<T1, T2> a, pair<T1, T2> b) {
a.first += b.first;
a.second += b.second;
return a;
}
template <class T1, class T2>
pair<T1, T2> operator-(pair<T1, T2> a, pair<T1, T2> b) {
a.first -= b.first;
a.second -= b.second;
return a;
}
template <class T1, class T2>
void operator+=(pair<T1, T2>& a, pair<T1, T2> b) {
a.first += b.first;
a.second += b.second;
}
template <class T1, class T2>
void operator-=(pair<T1, T2>& a, pair<T1, T2> b) {
a.first -= b.first;
a.second -= b.second;
}
template <class T>
vector<T> operator+(vector<T> a, vector<T> b) {
a.insert(a.end(), b.begin(), b.end());
return a;
}
const int mod = 1000000000 + 7;
void solve();
signed main() {
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
};
int tc = 1;
cin >> tc;
for (int i = 0; i < (tc); i++) {
solve();
}
}
string s;
void solve() {
int n, left_pos = -1, right_pos = -1;
cin >> n;
cin >> s;
if (n % 2 == 0) {
for (int i = 0; i < (n / 2); i++) {
if (s[i] == '0') {
left_pos = i;
break;
}
}
if (left_pos != -1) {
cout << left_pos + 1 << ' ' << n << ' ' << left_pos + 2 << ' ' << n
<< endl;
return;
}
for (int i = n / 2; i < n; i++) {
if (s[i] == '0') {
right_pos = i;
break;
}
}
if (right_pos != -1) {
cout << 1 << ' ' << right_pos + 1 << ' ' << 1 << ' ' << right_pos << endl;
return;
}
cout << 1 << ' ' << n - 1 << " " << 2 << " " << n << endl;
} else {
for (int i = 0; i < (n / 2 + 1); i++) {
if (s[i] == '0') {
left_pos = i;
break;
}
}
if (left_pos != -1) {
cout << left_pos + 1 << ' ' << n << ' ' << left_pos + 2 << ' ' << n
<< endl;
return;
}
for (int i = n / 2; i < n; i++) {
if (s[i] == '0') {
right_pos = i;
break;
}
}
if (right_pos != -1) {
cout << 1 << ' ' << right_pos + 1 << ' ' << 1 << ' ' << right_pos << endl;
return;
}
cout << 1 << ' ' << n - 1 << " " << 2 << " " << n << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, t, a, b, da, db, i, j;
cin >> x >> t >> a >> b >> da >> db;
for (i = 0; i < t; i++) {
for (j = 0; j < t; j++) {
if (x == (a + b - i * da - j * db)) {
cout << "YES" << endl;
return 0;
}
}
if (x == (a - i * da)) {
cout << "YES" << endl;
return 0;
} else if (x == (b - i * db)) {
cout << "YES" << endl;
return 0;
} else if (x == 0) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5;
int T, n, m, k, f[N + 5], ans[N + 5];
struct People {
int a, r, d, u, id;
} p[N + 5];
struct Info {
int opt, l, r;
Info() {}
Info(int opt, int l, int r) : opt(opt), l(l), r(r) {}
};
template <int MAX>
struct BIT {
static const int N = MAX;
int b[N + 5];
void clear() { fill(b + 1, b + N + 1, 0); }
void modify(int x, int v) {
for (; x <= N; x += x & -x) b[x] += v;
}
int query(int x) {
int ans = 0;
for (; x > 0; x ^= x & -x) ans += b[x];
return ans;
}
int query(int l, int r) { return query(r) - query(l - 1); }
};
template <int MAX>
struct SegmentTree {
static const int N = MAX << 2;
int val[N + 5];
void clear() { fill(val + 1, val + N + 1, -1); }
void modify(int p, int l, int r, int x, int v) {
if (l == r) {
val[p] = max(val[p], v);
return;
}
int mid = (l + r) >> 1;
if (x <= mid) {
modify((p << 1), l, mid, x, v);
} else {
modify((p << 1 | 1), mid + 1, r, x, v);
}
val[p] = max(val[(p << 1)], val[(p << 1 | 1)]);
}
int query(int p, int l, int r, int x, int y) {
if (x == l && r == y) return val[p];
int mid = (l + r) >> 1;
if (y <= mid) {
return query((p << 1), l, mid, x, y);
} else if (x > mid) {
return query((p << 1 | 1), mid + 1, r, x, y);
} else {
return max(query((p << 1), l, mid, x, mid),
query((p << 1 | 1), mid + 1, r, mid + 1, y));
}
}
};
BIT<N> bit;
SegmentTree<N> seg;
vector<Info> que[N + 5];
void disc() {
vector<int> u, v;
for (int i = 1; i <= n; i++) {
u.push_back(p[i].r);
v.push_back(p[i].a);
v.push_back(p[i].d);
v.push_back(p[i].u);
}
sort(u.begin(), u.end());
sort(v.begin(), v.end());
u.erase(unique(u.begin(), u.end()), u.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (int i = 1; i <= n; i++) {
p[i].r = lower_bound(u.begin(), u.end(), p[i].r) - u.begin() + 1;
p[i].a = lower_bound(v.begin(), v.end(), p[i].a) - v.begin() + 1;
p[i].d = lower_bound(v.begin(), v.end(), p[i].d) - v.begin() + 1;
p[i].u = lower_bound(v.begin(), v.end(), p[i].u) - v.begin() + 1;
}
}
void calc() {
sort(p + 1, p + n + 1,
[](const People &x, const People &y) { return x.r < y.r; });
bit.clear();
for (int i = 1; i <= n;) {
int j = i - 1;
for (; j < n && p[j + 1].r == p[i].r; j++, bit.modify(p[j].a, 1))
;
for (int k = i; k <= j; k++) {
f[p[k].id] = bit.query(p[k].d, p[k].u);
}
i = j + 1;
}
sort(p + 1, p + n + 1,
[](const People &x, const People &y) { return x.id < y.id; });
}
void solve() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &p[i].r);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i].a);
p[i].d = p[i].a - k;
p[i].u = p[i].a + k;
p[i].id = i;
}
disc();
calc();
for (int i = 1; i <= n; i++) {
que[p[i].r].push_back(Info(0, p[i].a, f[i]));
}
scanf("%d", &m);
for (int u, v, i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
int l = max(p[u].d, p[v].d);
int r = min(p[u].u, p[v].u);
if (l > r) {
ans[i] = -1;
} else {
que[max(p[u].r, p[v].r)].push_back(Info(i, l, r));
}
}
seg.clear();
for (int i = n; i >= 1; i--) {
for (const auto &t : que[i]) {
if (t.opt == 0) {
seg.modify(1, 1, 3 * n, t.l, t.r);
} else {
ans[t.opt] = seg.query(1, 1, 3 * n, t.l, t.r);
}
}
que[i].clear();
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
int main() {
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void afify() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const double EPS = 1e-4;
const long long oo = (long long)10e9 + 7;
const long long N = 1e4 + 5;
int main() {
afify();
int n;
cin >> n;
string s;
cin >> s;
int cnt = 0;
for (int i = (0); i < n; i++) {
if (s[i] == '1') {
cnt++;
} else {
cout << cnt;
cnt = 0;
}
}
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 303;
map<int, int> dp[N];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> l(n), c(n);
for (auto &i : l) {
cin >> i;
}
for (auto &i : c) {
cin >> i;
}
for (int i = 0; i < n; ++i) {
dp[i + 1][l[i]] = c[i];
for (auto it = dp[i].begin(); it != dp[i].end(); ++it) {
int to = gcd(it->first, l[i]);
if (dp[i + 1].count(to)) {
dp[i + 1][to] = min(dp[i + 1][to], it->second + c[i]);
} else {
dp[i + 1][to] = it->second + c[i];
}
to = it->first;
if (dp[i + 1].count(to)) {
dp[i + 1][to] = min(dp[i + 1][to], it->second);
} else {
dp[i + 1][to] = it->second;
}
}
}
if (dp[n].count(1))
cout << dp[n][1] << '\n';
else
cout << "-1\n";
}
| 5 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
int t;cin>>t;
while(t--)
{
int n;cin>>n;
int r=0;
for(int i=0;i<n;i++)
{
ll x;cin>>x;
ll y=sqrt(x);
y*=y;
if(x!=y)r=1;
}
if(r)cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
int a, b;
scanf("%d %d", &a, &b);
printf("%d", a + b);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
void solve() {
int n, k;
cin >> n >> k;
vector<pair<int, int>> ans;
deque<int> dq;
for (int i = 1; i <= k; i++) ans.push_back({i, k + 1}), dq.push_back(i);
for (int i = k + 2; i <= n; i++)
ans.push_back({dq.front(), i}), dq.pop_front(), dq.push_back(i);
cout << 2 + 2 * ((n - k - 1) / k) + min(2, (n - k - 1) % k) << "\n";
for (auto i : ans) cout << i.first << " " << i.second << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e4 + 5;
inline int read() {
char c = getchar();
int x = 0, f = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = 0;
for (; c <= '9' && c >= '0'; c = getchar())
x = (x << 1) + (x << 3) + (c ^ 48);
return f ? x : -x;
}
inline int abs(int x) { return x > 0 ? x : -x; }
inline int min(int a, int b) { return a < b ? a : b; }
inline int max(int a, int b) { return a > b ? a : b; }
inline void swap(int &a, int &b) { a ^= b ^= a ^= b; }
int n, k, a[M], c[M], t1, t2;
int main() {
n = read(), k = read();
for (int i = 2; i <= n; i++) {
printf("and %d %d\n", i - 1, i);
fflush(stdout);
scanf("%d", &t1);
printf("or %d %d\n", i - 1, i);
fflush(stdout);
scanf("%d", &t2);
c[i] = t1 + t2;
}
printf("and 1 3\n");
fflush(stdout);
scanf("%d", &t1);
printf("or 1 3\n");
fflush(stdout);
scanf("%d", &t2);
a[2] = c[2] - t1 - t2 + c[3] >> 1, a[1] = c[2] - a[2];
for (register int i = 3; i <= n; i++) a[i] = c[i] - a[i - 1];
sort(a + 1, a + 1 + n);
printf("finish %d\n", a[k]);
fflush(stdout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
vector<int> v[105];
long long dp[105][105];
int n, k;
void dfs(int p) {
dp[p][0] = dp[p][k + 1] = 1;
long long tmp[105];
for (int t = 0; t < v[p].size(); t++) {
if (dp[v[p][t]][0] == 0) {
memset(tmp, 0, sizeof(tmp));
int u = v[p][t];
dfs(u);
for (int i = 0; i <= k * 2; i++)
for (int j = 0; j <= k * 2; j++) {
if ((i + j + 1) / 2 <= k)
tmp[min(i, j + 1)] =
(tmp[min(i, j + 1)] + (dp[p][i] * dp[u][j]) % mod) % mod;
else
tmp[max(i, j + 1)] =
(tmp[max(i, j + 1)] + (dp[p][i] * dp[u][j]) % mod) % mod;
}
for (int i = 0; i <= k * 2; i++) dp[p][i] = tmp[i];
}
}
}
int main() {
while (scanf("%d%d", &n, &k) == 2) {
for (int i = 1; i <= n; i++) v[i].clear();
for (int i = 1; i < n; i++) {
int uu, vv;
scanf("%d%d", &uu, &vv);
v[uu].push_back(vv);
v[vv].push_back(uu);
}
memset(dp, 0, sizeof(dp));
dfs(1);
long long ans = 0;
for (int i = 0; i <= k; i++) ans = (ans + dp[1][i]) % mod;
printf("%lld\n", ans);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct state {
char action;
int length;
state* prev;
int i;
int j;
};
const int MAX_N = 1000;
const int MAX_M = MAX_N;
char maze[MAX_N][MAX_M];
int shortestPath[MAX_N][MAX_M];
int directions[4][2] = {{1, 0}, {0, -1}, {0, 1}, {-1, 0}};
char directionsChar[4] = {'D', 'L', 'R', 'U'};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m, k;
cin >> n >> m >> k;
if (k % 2 != 0) {
cout << "IMPOSSIBLE\n";
return 0;
}
int x, y;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> maze[i][j];
shortestPath[i][j] = -1;
if (maze[i][j] == 'X') {
x = i;
y = j;
maze[i][j] = '.';
}
}
}
queue<pair<int, int>> q;
q.push(make_pair(x, y));
shortestPath[x][y] = 0;
while (!q.empty()) {
pair<int, int> poppedPair = q.front();
q.pop();
for (int d = 0; d < 4; ++d) {
int newDirectionI = directions[d][0] + poppedPair.first;
int newDirectionJ = directions[d][1] + poppedPair.second;
if (newDirectionI < n && newDirectionJ < m && newDirectionI >= 0 &&
newDirectionJ >= 0 && maze[newDirectionI][newDirectionJ] == '.') {
if (shortestPath[newDirectionI][newDirectionJ] == -1) {
shortestPath[newDirectionI][newDirectionJ] =
shortestPath[poppedPair.first][poppedPair.second] + 1;
q.push(make_pair(newDirectionI, newDirectionJ));
}
}
}
}
string result;
int length = 0;
int i = x;
int j = y;
do {
bool failed = true;
for (int d = 0; d < 4; ++d) {
int newDirectionI = directions[d][0] + i;
int newDirectionJ = directions[d][1] + j;
if (newDirectionI < n && newDirectionJ < m && newDirectionI >= 0 &&
newDirectionJ >= 0 &&
shortestPath[newDirectionI][newDirectionJ] != -1 &&
shortestPath[newDirectionI][newDirectionJ] + length <= k) {
i = newDirectionI;
j = newDirectionJ;
++length;
failed = false;
result += directionsChar[d];
break;
}
}
if (failed) {
cout << "IMPOSSIBLE\n";
return 0;
}
} while (length < k);
cout << result << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 400010;
inline long long read() {
long long s = 0, w = 1;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * w;
}
void print(long long x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
long long n, k;
long long a[N];
void MS(long long l, long long r) {
if (!k || r - l <= 1) return;
long long mid = (l + r >> 1);
k -= 2, swap(a[mid - 1], a[mid]);
MS(l, mid), MS(mid, r);
}
signed main() {
n = read(), k = read();
for (register long long i = 0; i < n; i++) a[i] = i;
if (!(k & 1ll)) {
puts("-1");
return 0;
}
if (k == 1) {
for (register long long i = 1; i <= n; i++) printf("%lld ", i);
puts("");
return 0;
}
k--;
MS(0, n);
if (!k) {
for (register long long i = 0; i < n; i++) printf("%lld ", a[i] + 1);
puts("");
} else
puts("-1");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
vector<long long int> a(n + 1);
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
}
if (n == 1) {
cout << "1 1\n0\n1 1\n0\n1 1\n" << (-1) * a[1] << "\n";
} else {
cout << "1 1\n" << (-1) * a[1] << "\n";
cout << "1 " << n << "\n";
for (long long int i = 1; i <= n; i++) {
cout << (i == 1 ? 0 : (-n) * a[i]) << " ";
}
cout << "\n";
cout << "2 " << n << "\n";
for (long long int i = 2; i <= n; i++) {
cout << (n - 1) * a[i] << " ";
}
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long p, q, r;
long long dp[112345][3];
long long a[112345];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> p >> q >> r;
for (int i = 1; i <= n; i++) {
cin >> a[i];
dp[i][0] = -1e18;
dp[i][1] = -1e18;
dp[i][2] = -1e18;
}
dp[1][0] = p * a[1];
dp[1][1] = p * a[1] + q * a[1];
dp[1][2] = p * a[1] + q * a[1] + r * a[1];
for (int i = 2; i <= n; i++) {
dp[i][0] = max(dp[i - 1][0], p * a[i]);
dp[i][1] = max(dp[i - 1][1], dp[i][0] + q * a[i]);
dp[i][2] = max(dp[i - 1][2], dp[i][1] + r * a[i]);
}
cout << dp[n][2];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int MOD = 1000000007;
long long n;
int solve() {
cin >> n;
map<pair<int, int>, bool> mp;
map<int, set<int>> ch;
long long ans = 0;
long long cur = 1, nxt = 1;
vector<pair<int, int>> v;
for (int i = 1; i < n; i++) {
v.push_back({i, i + 1});
mp[{i, i + 1}] = 1;
mp[{i + 1, i}] = 1;
ch[i].insert(i + 1);
ch[i + 1].insert(i);
ans++;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
if (mp[{i, j}]) continue;
if (ch[i].upper_bound(j - 2) != ch[i].end() &&
*ch[i].upper_bound(j - 2) == j - 1)
continue;
if (ch[i].upper_bound(j) != ch[i].end() && *ch[i].upper_bound(j) == j + 1)
continue;
mp[{i, j}] = 1;
mp[{j, i}] = 1;
ch[i].insert(j);
ch[j].insert(i);
ans++;
v.push_back({i, j});
}
}
sort(v.begin(), v.end());
cout << ans << endl;
for (int i = 0; i < ans; i++)
cout << v[i].first << " " << v[i].second << endl;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 5 |
/**
Failing doesn’t give you a reason to give up,
as long as you believe.
- Seventh Hokage
(COPIED TEXT FROM BABUMOSHAI)
**/
#include <bits/stdc++.h>
#include <algorithm>
#include <string>
using namespace std;
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
//template <typename T>
//using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define vi vector<ll>
#define mi map<ll,ll>
#define pi pair<ll,ll>
#define si set<ll>
#define endl "\n"
#define ins insert
#define hell 1000000007
#define PI 3.1415926535897932384
#define ll long long
#define f first
#define s second
#define pb push_back
#define pp pop_back
#define dash() cout<<"--------"<<endl
#define fr(n) for(ll i=0;i<n;i++)
#define FAST ios_base::sync_with_stdio(false); cin.tie(NULL);
#define narak 998244353
#define decimal(n) std::cout << std::fixed;std::cout << std::setprecision(n);
#define make make_pair
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define ALL(v) v.begin(), v.end()
#define SORT(v) sort(ALL(v))
#define REVERSE(v) reverse(ALL(v))
#define maxc(v) max_element(all(v))
#define minc(v) min_element(all(v))
#define GCD(m,n) __gcd(m,n)
#define LCM(m,n) m*(n/GCD(m,n))
#define sz(a) (ll)a.size()
#define loop(i,a,b) for(ll i=a;i<=b;i++)
// for debugging
#define see(x) cout<<#x<<" = "<<x<<endl
#define see2(x,y) cout<<#x<<" = "<<x<<"::"<<#y<<" = "<<y<<endl
//std::ifstream in("input.txt");
//std::ofstream out("output.txt");
/*
INT_MIN Minimum value for a variable of type int. -2147483647
INT_MAX Maximum value for a variable of type int. 2147483647
LLONG_MIN Minimum value for a variable of type long long. -9,223,372,036,854,775,807
LLONG_MAX Maximum value for a variable of type long long. 9,223,372,036,854,775,807
bool comp(ll a,ll b)
{ return (a < b); }
ll spf[1000005];
void build()
{
for(ll i=2;i<1000005;i++)
{
if(!spf[i])
{
for(ll j=1;j*i<1000005;j++)
{
if(!spf[i*j])
spf[i*j]=i;
}
}
}
}
map<ll,ll>allpowofno(ll n)
{
map<ll,ll>mp;
for(ll i=2;i*i<=n;i++)
{
if(n%i==0)
{
mp[i]++;
n/=i;
i--;
}
}
if(n!=1)
mp[n]++;
return mp;}
ll primepow(ll n,ll k)
{
ll res=0;
while(n)
{
n/=k;
res+=n;
}
return res;}
ll allpowofnocomp(ll n,ll k)
{
mi mp=allpowofno(k);
ll ans;
for(auto it=mp.begin();it!=mp.end();++it)
{
cout<<it->f<<" "<<it->s<<endl;
ll z=primepow(n,it->f);
ans=min(ans,z/(it->s));
}
return ans; }
ll spf[1000005];
void build()
{
for(ll i=2;i<1000005;i++)
{
if(!spf[i])
{
for(ll j=1;j*i<1000005;j++)
{
if(!spf[i*j])
spf[i*j]=i;
}
}
}
}
bool sortbysec(const pair<ll,ll> &a, const pair<ll,ll> &b)
{
return (a.second < b.second);
}
const int N=+1e+5+5;
const int LG=20;
vector<ll>g[N];
ll parent[LG][N];
ll timer=0;
ll tin[N],tout[N],level[N];
int __lca(int u,int v)
{
if(level[u]<level[v])
swap(u,v);
int diff=level[u]-level[v];
for(int i=LG-1;i>=0;i--)
{
if((1<<i) & diff){
u=parent[i][u];
}
}
if(u==v)
return u;
for(int i=LG-1;i>=0;i--)
{
if(parent[i][u] and parent[i][u]!=parent[i][v])
{
u=parent[i][u];
v=parent[i][v];
}
}
return parent[0][u];
}
void dfs(ll v,ll par,ll lvl)
{
arr[v]=cnt;
tin[v]=++timer;
parent[0][v]=par;
level[v]=lvl;
for(auto &u:g[v])
{
if(u==par)
continue;
dfs(u,v,lvl+1);
}
tout[v]=timer;
}
bool is_ancestor(int u,int v)
{
return (tin[u]<=tin[v] and tout[u]>=tout[v]);
}
void precompute()
{
for(int i=1;i<LG;i++)
{
for(int j=1;j<=n;j++)
{
if(parent[i-1][j])
{
parent[i][j]=parent[i-1][parent[i-1][j]];
}
}
}
}
ll kthancestor(ll v,ll p)
{
ll curr=v;
for(ll i=20;i>=0;i--)
{
if( 1<<i & p)
curr=parent[i][curr];
}
return curr;
}
void buildtree(ll *tree,ll *a,ll index,ll start,ll end)
{
if(start>end)
return ;
if(start==end)
{
tree[index]=a[start];
return;
}
ll mid=(start+end)/2;
buildtree(tree,a,2*index,start,mid);
buildtree(tree,a,2*index+1,mid+1,end);
ll left=tree[2*index];
ll right=tree[2*index+1];
tree[index]=min(left,right);
return ;
}
ll query(ll *tree,ll index,ll s,ll e,ll qs,ll qe)
{
// no overlap
if(qs>e||s>qe)
return INT_MAX;
if(qe>=e&&s>=qs)
{
return tree[index];
}
ll mid=(s+e)/2;
ll left=query(tree,2*index,s,mid,qs,qe);
ll right=query(tree,2*index+1,mid+1,e,qs,qe);
return min(left,right);
}
void updatenode(ll *tree,ll index,ll s,ll e,ll i,ll val)
{
if(i>e||i<s)
return ;
if(s==e)
{
tree[index]=val;
return ;
}
ll mid=(s+e)/2;
updatenode(tree,2*index,s,mid,i,val);
updatenode(tree,2*index+1,mid+1,e,i,val);
tree[index]=min(tree[2*index],tree[2*index+1]);
return ;
}
void updaterange(ll *tree,ll index,ll s,ll e,ll rs,ll re,ll val)
{
if(rs>e||s>re)
return ;
if(rs<=s and e<=re)
{
tree[index]=val;
return ;
}
ll mid=(s+e)/2;
updaterange(tree,2*index,s,mid,rs,re,val);
updaterange(tree,2*index+1,mid+1,e,rs,re,val);
ll left=tree[2*index];
ll right=tree[2*index+1];
tree[index]=min(left,right);
return ;
}
int main()
{
ll n;
n=6;
ll a[]={1,2,3,4,5,60};
ll *tree=new ll[4*n+1];
ll index=1;
ll start=0;
ll end=n-1;
buildtree(tree,a,index,start,end);
ll q;
cin>>q;
//updatenode(tree,1,0,n-1,1,18);
updaterange(tree,1,0,n-1,2,3,18);
while(q--)
{
ll qs,qe;
cin>>qs>>qe;
cout<<query(tree,1,0,n-1,qs,qe)<<" ";
}
return 0;
}SEGMENT TREE
buildtree(tree,s,1,0,n-1); // 1 based tree is formed but array is 0 based
query(tree,1,0,n-1,x,y); // x and y are indexss
ll n,m;
ll k;
const int K=+1e+5+5;
set<ll>v[K];
vector<ll>tree[K];
bool vis[K];
ll disc[K];
ll low[K];
ll t=0;
const int LG=20;
vector<ll>g[K];
ll parent[LG][K];
ll timer=0;
ll tin[K],tout[K],level[K];
map<pair<ll,ll>,ll>mp;
ll arr[K];
ll par[K];
void dfs(ll x)
{
vis[x]=true;
disc[x]=low[x]=++t;
for(ll z:v[x])
{
if(!vis[z])
{
par[z]=x;
dfs(z);
low[x]=min(low[x],low[z]);
if( low[z]>disc[x])
{
mp[{x,z}]=1;
mp[{z,x}]=1;
//cout<<x<<" "<<z<<endl;
}
}
else if(z!=par[x])
{
low[x]=min(low[x],disc[z]);
}
}
return ;
}
void fun(ll x,ll cnt)
{
vis[x]=1;
//tree[cnt].pb(x);
arr[x]=cnt;
for(ll y:v[x])
{
if(!vis[y])
fun(y,cnt);
}
}
int __lca(int u,int v)
{
if(level[u]<level[v])
swap(u,v);
int diff=level[u]-level[v];
for(int i=LG-1;i>=0;i--)
{
if((1<<i) & diff){
u=parent[i][u];
}
}
if(u==v)
return u;
for(int i=LG-1;i>=0;i--)
{
if(parent[i][u] and parent[i][u]!=parent[i][v])
{
u=parent[i][u];
v=parent[i][v];
}
}
return parent[0][u];
}
void dfs3(ll v,ll par,ll lvl)
{
//arr[v]=cnt;
tin[v]=++timer;
parent[0][v]=par;
level[v]=lvl;
for(auto &u:tree[v])
{
if(u==par)
continue;
dfs3(u,v,lvl+1);
}
tout[v]=timer;
}
bool is_ancestor(int u,int v)
{
return (tin[u]<=tin[v] and tout[u]>=tout[v]);
}
void precompute()
{
for(int i=1;i<LG;i++)
{
for(int j=1;j<=n;j++)
{
if(parent[i-1][j])
{
parent[i][j]=parent[i-1][parent[i-1][j]];
}
}
}
}
ll distance(ll u,ll v)
{
return level[u]+level[v]-2*level[__lca(u,v)];
}
void bfs(ll src,ll dest,ll ans )
{
vis[src]=1;
if(src==dest)
{
cout<<ans<<endl;
return ;
}
for(ll x:v[src])
{
if(!vis[x])
bfs(x,dest,ans+mp[{x,src}]);
}
return ;
}
void solve()
{
cin>>n>>m;
ll x,y;
fr(m)
{
cin>>x>>y;
v[x].ins(y);
v[y].ins(x);
mp[{x,y}]=0;
mp[{y,x}]=0;
}
for(ll i=1;i<=n;i++)
{
if(!vis[i])
dfs(i);
}
for(auto it=mp.begin();it!=mp.end();++it)
{
ll v1=it->f.f;
ll v2=it->f.s;
ll v3=it->s;
if(v3==1)
{
v[v1].erase(v2);
//tree[arr[v1]].pb(arr[v2]);
//tree[v2].pb(v1);
}
}
mem0(vis);
ll cnt=1;
for(ll i=1;i<=n;i++)
{
if(!vis[i])
{
fun(i,cnt);
cnt++;
}
}
for(auto it=mp.begin();it!=mp.end();++it)
{
ll v1=it->f.f;
ll v2=it->f.s;
ll v3=it->s;
if(v3==1)
{
//v[v1].erase(v2);
tree[arr[v1]].pb(arr[v2]);
//tree[v2].pb(v1);
}
}
dfs3(1,0,0);
precompute();
cin>>k;
for(ll i=1;i<=k;i++)
{
ll x,y;
cin>>x>>y;
//mem0(vis);
//bfs(x,y,0);
ll xx=arr[x];
ll yy=arr[y];
// cout<<xx<<" "<<yy<<endl;
// cout<<level[xx]<<" "<<level[yy]<<" "<<__lca(xx,yy)<<endl;
ll ans=distance(xx,yy);
cout<<ans<<endl;
}
return ;
}
ll getSum(ll BITree[], ll index)
{
ll sum = 0; // Initialize result
// Traverse ancestors of BITree[index]
while (index > 0)
{
// Add current element of BITree to sum
sum += BITree[index];
// Move index to parent node in getSum View
index -= index & (-index);
}
return sum;
}
void updateBIT(ll BITree[], ll n, ll index, ll val)
{
// Traverse all ancestors and add 'val'
while (index <= n)
{
// Add 'val' to current node of BI Tree
BITree[index] += val;
// Update index to that of parent in update View
index += index & (-index);
}
}
getline(cin, str); // to get a line as input
getline(cin, str);
#define M 2005
using namespace std;
int n,k,i,j,p,v[M][M],ff[M][M];
char s[M][M],mm;
int main()
{
cin>>n>>k;
for(i=1;i<=n;i++)scanf("%s",s[i]+1);
memset(ff,1,sizeof(ff));
ff[0][1]=0;
for(i=1;i<=n;i++)for(j=1;j<=n;j++){
ff[i][j]=min(ff[i-1][j],ff[i][j-1])+(s[i][j]=='a'?0:1);
if(ff[i][j]<=k)s[i][j]='a';
}
}
v[0][0]=1;
char mm;
for(ll p=0;p<=2*n-2;p++)
{
mm='z';
for(ll i=0;i<n;i++)
if(p-i>=0&&p-i<n&&v[i][p-i])
mm=min(mm,dp[i][p-i]); // saare reachable padosi me minimum
cout<<mm;
//cout<<endl;
for(ll i=0;i<n;i++)
if(p-i>=0&&p-i<n&&v[i][p-i]&&dp[i][p-i]==mm)
v[i+1][p-i]=v[i][p-i+1]=1; // jaha bhi min character aaya uske dono padosi hai usko visit kro
}
return 0;
}
const int N=+1e+5+5;
const int LG=20;
vector<ll>g[N];
ll parent[LG][N];
ll timer=0;
ll tin[N],tout[N],level[N];
ll a[N];
ll ans[N];
ll n,k;
ll vis[N];
map<pair<ll,ll>,ll>mp;
int __lca(int u,int v)
{
if(level[u]<level[v])
swap(u,v);
int diff=level[u]-level[v];
for(int i=LG-1;i>=0;i--)
{
if((1<<i) & diff){
u=parent[i][u];
}
}
if(u==v)
return u;
for(int i=LG-1;i>=0;i--)
{
if(parent[i][u] and parent[i][u]!=parent[i][v])
{
u=parent[i][u];
v=parent[i][v];
}
}
return parent[0][u];
}
void dfs(ll v,ll par,ll lvl)
{
tin[v]=++timer;
parent[0][v]=par;
level[v]=lvl;
for(auto &u:g[v])
{
if(u==par)
continue;
dfs(u,v,lvl+1);
}
tout[v]=timer;
}
bool is_ancestor(int u,int v)
{
return (tin[u]<=tin[v] and tout[u]>=tout[v]);
}
void precompute()
{
for(int i=1;i<LG;i++)
{
for(int j=1;j<=n;j++)
{
if(parent[i-1][j])
{
parent[i][j]=parent[i-1][parent[i-1][j]];
}
}
}
}
ll kthancestor(ll v,ll p)
{
ll curr=v;
for(ll i=20;i>=0;i--)
{
if( 1<<i & p)
curr=parent[i][curr];
}
return curr;
}
// No of cycles in a graph
const ll N= 100005;
vector<ll>graph[N];
int color[N];
int vis[N];
int cyclenumber = 0;
void dfs_cycle(int u,int color[])
{
if (color[u] == 2) {
return;
}
if (color[u] == 1)
{
cyclenumber++;
return;
}
color[u] = 1;
for (int v : graph[u])
{
if (vis[v])
continue;
dfs_cycle(v, color);
}
color[u] = 2;
return ;
}
ll phi(ll n)
{
// Initialize result as n
double result = n;
// Consider all prime factors of n
// and for every prime factor p,
// multiply result with (1 - 1/p)
for(ll p = 2; p * p <= n; ++p)
{
// Check if p is a prime factor.
if (n % p == 0)
{
// If yes, then update n and result
while (n % p == 0)
n /= p;
result *= (1.0 - (1.0 / p));
}
}
if (n > 1)
result *= (1.0 - (1.0 / n));
return (ll)result;
}
vi fac(200005);
void build()
{
fac[0]=1;
fac[1]=1;
for(ll i=2;i<=200000;i++)
{
fac[i]=fac[i-1]*i;
fac[i]%=hell;
}
}
ll power(ll x,ll y,ll p)
{
ll res = 1; // Initialize result
x = x % p; // Update x if it is more than or equal to p
while (y > 0)
{
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
ll modInverse(ll n,ll p)
{
return power(n, p - 2, p);
}
ll ncr(ll n,ll k,ll mod)
{
ll nom = fac[n];
ll den = (fac[n-k] * fac[k]) % mod;
return (nom * power(den, mod - 2,mod)) % mod;
}
*/
void solve()
{
ll n,k;
cin>>n>>k;
ll a[n];
fr(n) cin>>a[i];
ll ans=1;
ll lo=1,hi=n;
while(lo<=hi)
{
ll mid=(lo+hi)/2;
ll b[n];
for(ll i=0;i<n;i++)
{
if(a[i]>=mid)
b[i]=1;
else
b[i]=-1;
}
for(ll i=1;i<n;i++)
b[i]+=b[i-1];
ll mn=0,mx=b[k-1];
for(ll i=k;i<n;i++)
{
mn=min(mn,b[i-k]);
mx=max(mx,b[i]-mn);
}
if(mx>0)
{
ans=mid;
lo=mid+1;
}
else
{
hi=mid-1;
}
}
cout<<ans;
}
int main()
{
//decimal(15);
FAST;
//build();
ll t;
t=1;
//cin>>t;
while(t--)
solve();
return 0;
} | 6 |
#include <bits/stdc++.h>
bool check(const char* s) {
if (!*s) return false;
if (*s == '0') return !*(s + 1);
while (*s) {
if (*s < '0') return false;
if ('9' < *s) return false;
++s;
}
return true;
}
int main() {
char s[100001] = "";
std::vector<std::string> r[2];
int e, k;
bool f;
std::scanf("%s", s);
for (int i(0);; ++i) {
e = i;
while (s[e] && s[e] != ';' && s[e] != ',') ++e;
f = s[e] == '\0';
s[e] = '\0';
k = !check(s + i);
r[k].push_back(s + i);
if (f) break;
i = e;
}
for (int i(0); i < 2; ++i) {
if (r[i].empty()) {
std::puts("-");
} else {
std::printf("\"");
for (int j(0); j < r[i].size(); ++j) {
if (0 < j) std::printf(",");
std::printf("%s", r[i][j].c_str());
}
std::printf("\"\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long linf = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-6;
const double pi = 3.14159265358979;
const int maxn = 1e5 + 5;
const int maxm = 1e7 + 233;
const int mod = 998244353;
struct edge {
int to, nxt, w;
} edge[maxn << 1];
int tot, head[maxn << 1];
void init() {
tot = 0;
memset(head, -1, sizeof head);
}
void addedge(int u, int v, int w) {
edge[tot].to = v;
edge[tot].w = w;
edge[tot].nxt = head[u];
head[u] = tot++;
edge[tot].to = u;
edge[tot].w = w;
edge[tot].nxt = head[v];
head[v] = tot++;
}
int col[maxn];
bool dfs(int u, int w) {
col[u] = w;
for (int i = head[u]; ~i; i = edge[i].nxt) {
int v = edge[i].to;
if (col[v] != -1) {
if (col[v] != (edge[i].w ^ w)) return false;
} else if (!dfs(v, edge[i].w ^ w))
return false;
}
return true;
}
long long pow_(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
char s[1005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> (s + 1);
int n = strlen(s + 1);
reverse(s + 1, s + 1 + n);
int ans = 0;
for (int m = 1; m <= n - 1; ++m) {
init();
for (int i = 1; i <= n / 2; ++i) addedge(i, n - i + 1, 0);
for (int i = 1; i <= m / 2; ++i) addedge(n + i, n + m - i + 1, 0);
addedge(n + 1, n + n + 2, 0);
addedge(n + 1, n + m + 1, 1);
addedge(n + m, n + n + 2, 0);
addedge(n + m, n + m + 1, 1);
for (int i = 1; i <= m; ++i)
if (s[i] == '1')
addedge(i, n + i, 1);
else if (s[i] == '0')
addedge(i, n + i, 0);
for (int i = m + 1; i <= n; ++i)
if (s[i] == '1')
addedge(i, n + m + 2, 0), addedge(i, n + m + 1, 1);
else if (s[i] == '0')
addedge(i, n + m + 1, 0), addedge(i, n + m + 2, 1);
memset(col, -1, sizeof col);
int c = 0;
for (int i = 1; i <= n + m + 2; ++i) {
if (col[i] == -1) {
if (dfs(i, 0))
++c;
else {
c = 0;
break;
}
}
}
if (c) ans = (ans + pow_(2, c - 1)) % mod;
}
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
int a, b, r;
int main() {
scanf("%d%d%d", &a, &b, &r);
printf("%s\n", 2 * r > ((a) < (b) ? (a) : (b)) ? "Second" : "First");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N, n;
int main() {
while (~scanf("%d", &N)) {
n = N * N;
for (int i = 0; i < N; i++) {
for (int p = 1; p <= N / 2; p++) {
printf("%d %d ", i * (N / 2) + p, n - (i * (N / 2) + p) + 1);
}
printf("\n");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s[] = {"ABSINTH", "BEER", "BRANDY", "CHAMPAGNE", "GIN", "RUM",
"SAKE", "TEQUILA", "VODKA", "WHISKEY", "WINE"};
int main() {
int n;
scanf("%d", &n);
string ss;
int sol = 0;
for (int i = 0; i < n; i++) {
cin >> ss;
if (isalpha(ss[0])) {
for (int j = 0; j < 11; j++)
if (ss == s[j]) {
sol++;
break;
}
} else {
int age = 0;
for (int j = 0; j < ss.length(); j++) {
age *= 10;
age += (ss[j] - '0');
}
if (age < 18) sol++;
}
}
printf("%d\n", sol);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
const int MOD = 1e9 + 9;
int a[MAXN];
multiset<int> b;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
b.insert(x);
}
for (int i = 1; i <= n; i++) {
auto it = b.lower_bound(n - a[i]);
if (it == b.end()) it = b.begin();
cout << (a[i] + *it) % n << " ";
b.erase(it);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
vector<long long> v[100001];
bool compare(pair<long long, long long> x, pair<long long, long long> y) {
if (x.first < y.first) return 1;
if (x.first == y.first and x.second < y.second) return 1;
return 0;
}
void solve() {
long long n, m, i;
cin >> n >> m;
long long x, y;
long long a[n + 1], b[n + 1];
memset(a, 0, sizeof(a));
vector<pair<int, int> > v;
long long z = m;
while (m--) {
cin >> x >> y;
if (x > y) swap(x, y);
v.push_back(make_pair(x, y));
}
if (n < 2 or z == ((n * (n - 1)) / 2)) {
cout << "NO";
return;
}
sort(v.begin(), v.end(), compare);
x = 1, y = 2;
for (i = 0; i < v.size(); i++) {
if (x != y and (v[i].first != x or v[i].second != y)) break;
if (x == y) i--;
if (y == n) {
x++;
y = x + 1;
} else
y++;
}
b[x] = 1;
b[y] = 1;
a[x] = 1;
a[y] = 2;
long long k = 3;
for (i = 1; i <= n; i++) {
if (i != x and i != y) {
a[i] = k;
b[i] = k;
k++;
}
}
std::cout << "YES" << '\n';
for (i = 1; i <= n; i++) cout << a[i] << " ";
cout << '\n';
for (i = 1; i <= n; i++) cout << b[i] << " ";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int stala = 1e6;
int n;
int getRow(char c) { return (c == '0' ? 3 : (c - '1') / 3); }
int getCol(char c) { return (c == '0' ? 1 : (c - '1') % 3); }
int col_min = INF, col_max = -INF;
int row_min = INF, row_max = -INF;
int main() {
ios::sync_with_stdio(0);
cin >> n;
bool row = false, col = false, zero = false;
int spec_min = INF, spec_max = -INF;
for (int i = 0; i < n; ++i) {
char c;
cin >> c;
zero |= c == '0';
if (getCol(c) == 1) {
spec_min = min(spec_min, getRow(c));
spec_max = max(spec_max, getRow(c));
}
col_min = min(col_min, getRow(c));
row_min = min(row_min, getCol(c));
col_max = max(col_max, (getCol(c) == 1 ? -1 : 0) + getRow(c));
row_max = max(row_max, getCol(c));
}
if ((col_max - col_min == 2 && row_max - row_min == 2) ||
spec_max - spec_min == 3 || (zero && col_min == 0))
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, b, a1, b1, a2, b2;
int main() {
cin >> a >> b >> a1 >> b1 >> a2 >> b2;
if (max(a1, a2) <= a && b1 + b2 <= b)
cout << "YES";
else if (max(b1, a2) <= a && a1 + b2 <= b)
cout << "YES";
else if (max(b1, b2) <= a && a1 + a2 <= b)
cout << "YES";
else if (max(a1, b2) <= a && a2 + b1 <= b)
cout << "YES";
else if (max(a1, a2) <= b && b1 + b2 <= a)
cout << "YES";
else if (max(b1, a2) <= b && a1 + b2 <= a)
cout << "YES";
else if (max(b1, b2) <= b && a1 + a2 <= a)
cout << "YES";
else if (max(a1, b2) <= b && a2 + b1 <= a)
cout << "YES";
else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int x, y, k;
long long add[1000000];
long long a[1000000];
long long b[1000000];
struct node {
int left, right;
int mid() { return (left + right) / 2; }
long long sum;
long long maxx;
} tree[1000000 << 2], point;
int father[1000000 << 2];
void update(int o, int l, int r, int p, int val) {
if (l == r) {
tree[o].sum += val;
tree[o].maxx += val;
return;
}
tree[o].left = l;
tree[o].right = r;
int mid = (l + r) >> 1;
if (p <= mid)
update(o << 1, l, mid, p, val);
else
update(o << 1 | 1, mid + 1, r, p, val);
tree[o].sum = tree[o << 1].sum + tree[o << 1 | 1].sum;
tree[o].maxx =
max(tree[o << 1 | 1].maxx, tree[o << 1].maxx + tree[o << 1 | 1].sum);
}
long long query(int o, int l, int r, node p) {
if (l == r) {
return l;
}
int mid = (l + r) >> 1;
node tmp2;
tmp2.sum = tree[o << 1 | 1].sum + p.sum;
tmp2.maxx = tree[o << 1 | 1].maxx + p.sum;
if (tmp2.maxx > 0) {
return query(o << 1 | 1, mid + 1, r, p);
} else {
return query(o << 1, l, mid, tmp2);
}
}
int main() {
int n, m, q;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
update(1, 1, 1000000, a[i], 1);
}
for (int i = 1; i <= m; i++) {
scanf("%lld", &b[i]);
update(1, 1, 1000000, b[i], -1);
}
cin >> q;
long long type, postion, value;
for (int i = 1; i <= q; i++) {
scanf("%lld%lld%lld", &type, &postion, &value);
if (type == 1) {
update(1, 1, 1000000, a[postion], -1);
a[postion] = value;
update(1, 1, 1000000, a[postion], 1);
} else {
update(1, 1, 1000000, b[postion], 1);
b[postion] = value;
update(1, 1, 1000000, b[postion], -1);
}
point.sum = 0;
point.maxx = 0;
if (tree[1].maxx <= 0)
puts("-1");
else
cout << query(1, 1, 1000000, point) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200008];
int t, n, m, x, y, z[200008];
int main() {
for (scanf("%d", &t); t--; printf("\n")) {
for (scanf("%d%d", &n, &m), x = n + 1; --x; z[x] = 0, v[x].clear())
;
for (; m--; scanf("%d%d", &x, &y), v[x].push_back(y))
;
for (x = 0; x++ < n; m += z[x] == 2)
for (y = v[x].size(); y--; z[v[x][y]] = max(z[v[x][y]], (1 + z[x]) % 3))
;
for (printf("%d\n", m + 1); --x; z[x] == 2 ? printf("%d ", x) : 0)
;
}
exit(0);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
inline long long read() {
long long res = 0, f_f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f_f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
res = (res << 3) + (res << 1) + ch - '0';
ch = getchar();
}
return res * f_f;
}
int main() {
n = read(), m = read();
while (n && m) {
if (n >= m * 2)
n %= m * 2;
else if (m >= n * 2)
m %= n * 2;
else
break;
}
printf("%lld %lld\n", n, m);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int maxn = 6e5 + 5;
char s[maxn];
int a[maxn], b[maxn], n, tot, m, p[maxn], c[maxn], cnt[26], st[maxn], top;
bool vis[maxn];
vector<pair<int, int> > ans, res;
void add(int x, int y) {
while (x <= n * 2) b[x] += y, x += x & (-x);
}
int qry(int x) {
int ret = 0;
while (x) ret += b[x], x -= x & (-x);
return ret;
}
int nowid() {
for (int i = 0; i < 26; i++)
if (cnt[i] >= tot / 2) return i;
return -1;
}
void solve(int m) {
int id = -1;
tot = m;
top = 0;
int x = -1;
for (int i = 1; i <= m; i++) {
st[++top] = i;
if (x == -1) x = nowid();
if (x == -1) {
if (top > 1 && c[st[top - 1]] != c[st[top]]) {
int u = st[top - 1], v = st[top];
res.push_back((pair<int, int>){u, v});
cnt[c[u]]--;
cnt[c[v]]--;
top -= 2;
tot -= 2;
}
} else {
if (top > 1 && ((c[st[top - 1]] == x) ^ (c[st[top]] == x))) {
int u = st[top - 1], v = st[top];
res.push_back((pair<int, int>){u, v});
cnt[c[u]]--;
cnt[c[v]]--;
top -= 2;
tot -= 2;
}
}
}
while (top) res.push_back((pair<int, int>){st[top], -1}), top--;
}
void solve(int l, int r) {
int L = qry(l), R = qry(r);
add(r, L - R);
ans.push_back((pair<int, int>){L + 1, R});
}
int main() {
int _;
scanf("%d", &_);
while (_--) {
scanf("%s", s + 1);
n = strlen(s + 1);
m = 0;
res.clear();
ans.clear();
for (int i = 1; i < n; i++)
if (s[i] == s[i + 1]) p[++m] = i;
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= m; i++) c[i] = s[p[i]] - 'a', cnt[c[i]]++, vis[i] = 0;
solve(m);
for (int i = 1; i <= n * 2; i++) b[i] = 0;
for (int i = 1; i <= n; i++) add(i, 1);
for (auto x : res) {
if (x.second == -1)
solve(p[x.first], n);
else
solve(p[x.first], p[x.second]);
}
solve(0, n);
printf("%d\n", ans.size());
for (auto x : ans) printf("%d %d\n", x.first, x.second);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
const long long Lbig = 2e18;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline long long getnum() {
long long r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline char getreal() {
char c = _buff.get();
while (c <= 32) c = _buff.get();
return c;
}
int mod;
long long qpow(long long x, long long k) {
return k == 0 ? 1
: 1ll * qpow(1ll * x * x % mod, k >> 1) * (k & 1 ? x : 1) % mod;
}
int n, m, k;
int sx[1011], sy[1011], cx[1011], cy[1011];
int main() {
n = getnum(), m = getnum(), k = getnum();
for (int i = 0; i < k; i++) {
int x, y, v;
x = getnum(), y = getnum(), v = getnum();
x--;
y--;
sx[x] += v == -1;
sy[y] += v == -1;
cx[x]++;
cy[y]++;
}
mod = getnum();
bool ok = (n + m) % 2 == 0;
for (int i = 0; i < n; i++) ok &= cx[i] < m || (sx[i] & 1);
for (int i = 0; i < m; i++) ok &= cy[i] < n || (sy[i] & 1);
if (!ok) {
puts("0");
return 0;
}
int cnt = (n - 1) * (m - 1) - k;
for (int i = 0; i < n; i++) cnt += cx[i] == m;
for (int i = 0; i < m; i++) cnt += cy[i] == n;
cnt -= k == n * m;
cout << qpow(2, cnt) % mod << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<long long> a(n), b(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
long long c1, c2;
c1 = c2 = 0;
for (int i = n - 1; i >= 0; --i) {
if (i % 2 == 0)
b[i] = a[i] + c1 - c2;
else
b[i] = a[i] + c2 - c1;
if (i % 2 == 1)
c1 += b[i];
else
c2 += b[i];
}
for (int i = 0; i < n; ++i) cout << b[i] << ' ';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int64_t inf = 2e18;
struct Point {
double first, second, z;
Point() {}
Point(double a) : first(a), second(a), z(a) {}
Point(double a, double b, double c) : first(a), second(b), z(c) {}
};
double dist(Point const& p1, Point const& p2) {
return sqrt((p1.first - p2.first) * (p1.first - p2.first) +
(p1.second - p2.second) * (p1.second - p2.second) +
(p1.z - p2.z) * (p1.z - p2.z));
}
Point operator-(Point const& p1, Point const& p2) {
return {p2.first - p1.first, p2.second - p1.second, p2.z - p1.z};
}
Point operator+(Point const& p1, Point const& p2) {
return {p2.first + p1.first, p2.second + p1.second, p2.z + p1.z};
}
Point operator*(Point const& p, double q) {
return {p.first * q, p.second * q, p.z * q};
}
Point operator/(Point const& p, double q) {
return {p.first / q, p.second / q, p.z / q};
}
int32_t main() {
int64_t n, vp, vs;
cin >> n;
double sum = 0;
vector<double> ps(n + 1, 0);
Point beg;
vector<Point> p(n + 1);
for (int64_t i = 0; i < n + 1; i++)
cin >> p[i].first >> p[i].second >> p[i].z;
cin >> vp >> vs;
cin >> beg.first >> beg.second >> beg.z;
for (int64_t i = 0; i < n + 1; i++) {
if (i) {
sum += dist(p[i], p[i - 1]);
ps[i] = sum / vs;
}
}
Point loc;
double l = 0, r = sum / vs;
if (r < dist(beg, p[n]) / vp) return cout << "NO" << endl, 0;
for (; abs(l - r) > 1e-10;) {
int64_t ind = 0;
double t = (l + r) / 2;
for (; ps[ind + 1] < t; ind++)
;
loc =
(p[ind] - p[ind + 1]) / dist(p[ind + 1], p[ind]) * (t - ps[ind]) * vs +
p[ind];
if (dist(loc, beg) / vp <= t)
r = t;
else
l = t;
}
cout << setprecision(6) << fixed;
cout << "YES" << endl
<< l << endl
<< loc.first << ' ' << loc.second << ' ' << loc.z << ' ';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char a[1000100], b[1000100];
int nextt[1000100];
int n;
int ok;
void getnext() {
int i = -1;
int j = 0;
nextt[0] = -1;
while (j < n) {
if (i == -1 || a[i] == a[j])
i++, j++, nextt[j] = i;
else
i = nextt[i];
}
}
void kmp() {
int i = 0, j = 0;
while (i < n) {
if (j == -1 || b[i] == a[j])
i++, j++;
else
j = nextt[j];
}
if (j > 0)
ok = 0;
else
ok = 1;
}
int main() {
cin >> n;
n--;
scanf("%s%s", a, b);
for (int i = 0; i < n; i++) {
if (a[i] == 'N')
a[i] = 'S';
else if (a[i] == 'E')
a[i] = 'W';
else if (a[i] == 'S')
a[i] = 'N';
else if (a[i] == 'W')
a[i] = 'E';
}
reverse(a, a + n);
getnext();
ok = 0;
kmp();
if (!ok)
printf("NO\n");
else
printf("YES\n");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-8;
const int N = 1010;
struct point {
long double x, y;
point(long double x, long double y) : x(x), y(y) {}
point() : x(0), y(0) {}
};
point v[N];
bool eq(long double a, long double b) { return fabs(a - b) < EPS; }
long double sq(long double x) { return x * x; }
struct line {
long double a, b, c;
line(point p1, point p2) {
if (!eq(p1.y, p2.y)) {
a = 1;
b = (p1.x - p2.x) / (p2.y - p1.y);
} else {
b = 1;
a = (p2.y - p1.y) / (p1.x - p2.x);
}
c = -(a * p1.x + b * p1.y);
}
point projection(point p) {
long double t = -(a * p.x + b * p.y + c) / (sq(a) + sq(b));
return point(p.x + t * a, p.y + t * b);
}
};
long double dist(point a, point b) {
return sqrt(sq(a.x - b.x) + sq(a.y - b.y));
}
long double calc(point a, point b, point c) {
line l(a, c);
point x = l.projection(b);
return dist(x, b) / 2;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> v[i].x >> v[i].y;
}
long double ans = 1e18;
for (int i = 0; i < n; i++) {
ans = min(ans, calc(v[i], v[(i + 1) % n], v[(i + 2) % n]));
}
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
vector<int> occ[26];
int dupl[26];
int main() {
iostream::sync_with_stdio(0);
cin.tie(0);
string str;
cin >> str;
int n = str.size();
str += str;
for (int i = 0; i < n; i++) {
occ[str[i] - 'a'].emplace_back(i);
}
int win = 0;
int numpbs = 0;
int prob = 0;
for (vector<int> &occs : occ) {
if (occs.size() == 0) continue;
int mxndc = 0;
for (int i = 0; i < n; i++) {
int ndc = 0, wo = 0;
for (int loc : occs) {
int element = str[loc + i] - 'a';
dupl[element]++;
if (dupl[element] == 1) {
wo++;
}
if (dupl[element] == 2) {
wo--;
}
}
mxndc = max(mxndc, wo);
memset(dupl, 0, sizeof(dupl));
}
prob += mxndc;
}
cout.precision(15);
cout << fixed << double(prob) / n;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int g[100005];
bool used[100005];
int n;
int main() {
g[0] = 0;
g[1] = 0;
g[2] = 0;
scanf("%d", &n);
int ans = 0;
for (int m = 3; m <= max(n - 1, 3); m++) {
memset(used, false, sizeof used);
int ans = 0;
for (int k = 2; k * k <= 2 * m; k++) {
int a = ((2 * m / k) + 1 - k) / 2;
if (a > 0 && k * (2 * a + k - 1) == 2 * m) {
int tmp = g[a + k - 1] ^ g[a - 1];
used[tmp] = true;
}
}
while (used[ans]) ans++;
g[m] = g[m - 1] ^ ans;
}
memset(used, false, sizeof used);
ans = 0;
int jum = 0;
for (int k = 2; k * k <= 2 * n; k++) {
int a = ((2 * n / k) + 1 - k) / 2;
if (a > 0 && k * (2 * a + k - 1) == 2 * n) {
int tmp = g[a + k - 1] - g[a - 1];
used[tmp] = true;
if (jum == 0 && tmp == 0) jum = k;
}
}
while (used[ans]) ans++;
if (ans != 0)
cout << jum << endl;
else
cout << -1 << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int v[100000 + 5];
int main() {
int n, u;
cin >> n >> u;
int i, j, z, pas;
for (i = 0; i < n; i++) cin >> v[i];
double ans = -1.0;
for (i = 0; i < n; i++) {
for (z = -1, pas = (1 << 17); pas > 0; pas /= 2)
if (z + pas < n && v[z + pas] - v[i] <= u) z += pas;
if (z > i + 1)
ans = max(ans, (1.0 * (v[z] - v[i + 1])) / (1.0 * (v[z] - v[i])));
}
if (ans == -1.0)
cout << -1;
else
cout << fixed << setprecision(12) << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct que {
int op, x, y;
} q[200010];
int n, bin[200010], cnt, id;
map<int, int> M;
int F[200010], cur, ml[200010], mr[200010], tot, seq[200010], vis[200010];
int gf(int x) { return (F[x] == x) ? x : (F[x] = gf(F[x])); }
vector<int> s[200010 << 2];
void find(int pos, int l, int r, int x) {
while (!s[x].empty()) {
int y = s[x].back();
s[x].pop_back();
if (!vis[y]) vis[y] = 1, seq[++tot] = y;
}
if (l == r) return;
int mid = (l + r) >> 1;
if (pos <= mid)
find(pos, l, mid, (x << 1));
else
find(pos, mid + 1, r, (x << 1 | 1));
}
void cover(int ql, int qr, int v, int l, int r, int x) {
if (ql <= l && r <= qr) {
s[x].push_back(v);
return;
}
int mid = (l + r) >> 1;
if (ql <= mid) cover(ql, qr, v, l, mid, (x << 1));
if (mid < qr) cover(ql, qr, v, mid + 1, r, (x << 1 | 1));
}
void add(int l, int r) {
tot = 0;
find(l, 1, cnt, 1);
find(r, 1, cnt, 1);
++cur;
F[cur] = cur, ml[cur] = l, mr[cur] = r;
for (int i = 1; i <= tot; i++) {
ml[cur] = min(ml[cur], ml[seq[i]]);
mr[cur] = max(mr[cur], mr[seq[i]]);
F[gf(seq[i])] = cur;
}
if (ml[cur] + 1 <= mr[cur] - 1)
cover(ml[cur] + 1, mr[cur] - 1, cur, 1, cnt, 1);
}
int main() {
scanf("%d", &n);
register int i;
for (i = 1; i <= n; i++) {
scanf("%d%d%d", &q[i].op, &q[i].x, &q[i].y);
if (q[i].op & 1) bin[++cnt] = q[i].x, bin[++cnt] = q[i].y;
}
sort(bin + 1, bin + cnt + 1);
for (bin[0] = -1 << 30, i = 1; i <= cnt; ++i)
if (bin[i] != bin[i - 1]) M[bin[i]] = ++id;
cnt = id;
for (int i = 1; i <= n; i++) {
if (q[i].op == 1) q[i].x = M[q[i].x], q[i].y = M[q[i].y];
if (q[i].op == 1)
add(q[i].x, q[i].y);
else {
int x = gf(q[i].x), y = gf(q[i].y);
if (x == y || mr[x] > ml[y] && mr[x] < mr[y] ||
ml[x] > ml[y] && ml[x] < mr[y])
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a[1003], b[1003], i, m = 0, j;
cin >> n;
for (i = 0; i < n; ++i) {
cin >> a[i];
if (i > 0) a[i] |= a[i - 1];
}
for (i = 0; i < n; ++i) {
cin >> b[i];
if (i > 0) b[i] |= b[i - 1];
}
for (i = 0; i < n; ++i) {
m = max(m, b[i] + a[i]);
for (j = i + 1; j < n; ++j) m = max(m, b[j] & (!b[i]) + a[j] & (!a[i]));
}
cout << m;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, l, r, j, k, m, y, x, v, a[3005], b[10], rez, h, i, cnt;
long long Abs(long long x) {
if (x < 0) return -x;
return x;
}
int main() {
cin >> x >> y;
long long min2, max2;
long long min1 = min2 = (long long)1e+18, max1 = max2 = -(long long)1e+18;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x >> y;
min1 = min(min1, x + y);
max1 = max(max1, x + y);
min2 = min(min2, x - y);
max2 = max(max2, x - y);
}
cin >> m;
rez = (long long)1e+18;
j = 0;
for (i = 0; i < m; i++) {
cin >> x >> y;
long long tmp = max(max(Abs(x + y - min1), Abs(x + y - max1)),
max(Abs(x - y - min2), Abs(x - y - max2)));
if (rez > tmp) {
rez = tmp;
j = i + 1;
}
}
cout << rez << endl << j << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct dsu {
int f[300005], l[300005], r[300005];
inline void reset(int n) {
for (int i = 1; i <= n; i++) f[i] = l[i] = r[i] = i;
}
inline int getf(int x) { return x != f[x] ? f[x] = getf(f[x]) : x; }
inline void merge(int x, int y) {
x = getf(x), y = getf(y);
l[x] = min(l[x], l[y]);
r[x] = max(r[x], r[y]);
f[y] = x;
}
inline pair<int, int> query(int x) {
x = getf(x);
return pair<int, int>(l[x], r[x]);
}
} dsu;
struct segtree {
long long maxv[300005 << 2], minv[300005 << 2];
inline void build(int l, int r, int k, long long *val) {
if (l == r) {
maxv[k] = minv[k] = val[l];
return;
}
int mid = l + r >> 1;
build(l, mid, k << 1, val);
build(mid + 1, r, k << 1 | 1, val);
maxv[k] = max(maxv[k << 1], maxv[k << 1 | 1]);
minv[k] = min(minv[k << 1], minv[k << 1 | 1]);
}
inline long long querymax(int l, int r, int k, int L, int R) {
if (L <= l && r <= R) return maxv[k];
int mid = l + r >> 1;
long long ans = -1e18;
if (L <= mid) ans = max(ans, querymax(l, mid, k << 1, L, R));
if (mid < R) ans = max(ans, querymax(mid + 1, r, k << 1 | 1, L, R));
return ans;
}
inline long long querymin(int l, int r, int k, int L, int R) {
if (L <= l && r <= R) return minv[k];
int mid = l + r >> 1;
long long ans = 1e18;
if (L <= mid) ans = min(ans, querymin(l, mid, k << 1, L, R));
if (mid < R) ans = min(ans, querymin(mid + 1, r, k << 1 | 1, L, R));
return ans;
}
} sgt;
pair<int, int> d[300005];
long long c[300005];
int main() {
int n, a;
cin >> n >> a;
for (int i = 1; i <= n; i++) {
cin >> d[i].first >> c[i];
c[i] = a - c[i] + c[i - 1];
}
for (int i = 1; i < n; i++)
d[i] = pair<int, int>(abs(d[i].first - d[i + 1].first), i);
sort(d + 1, d + n);
dsu.reset(n);
sgt.build(0, n, 1, c);
long long ans = 0;
for (int i = 1; i <= n; i++) ans = max(ans, c[i] - c[i - 1]);
for (int i = 1; i < n; i++) {
int mid = d[i].second, l = dsu.query(mid).first,
r = dsu.query(mid + 1).second;
ans = max(ans, sgt.querymax(0, n, 1, mid + 1, r) -
sgt.querymin(0, n, 1, l - 1, mid - 1) -
(long long)d[i].first * d[i].first);
dsu.merge(mid, mid + 1);
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
class TC {
public:
void solve() {
ll a, b;
cin >> a >> b;
ll two = 0, three = 0, five = 0;
ll aa = f(a, 5, five);
aa = f(aa, 3, three);
aa = f(aa, 2, two);
ll bb = f(b, 5, five, -1);
bb = f(bb, 3, three, -1);
bb = f(bb, 2, two, -1);
if (aa != bb) {
cout << -1 << endl;
} else {
cout << abs(two) + abs(three) + abs(five) << endl;
}
}
ll f(ll no, ll num, ll &var, ll factor = 1) {
while (no % num == 0) {
no /= num;
var += (factor);
}
return no;
}
};
int main() {
ios_base::sync_with_stdio(false);
int testcases = 1;
for (int i = 1; i <= testcases; i++) {
TC tc;
tc.solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int expo(long long int base, long long int exponent,
long long int mod) {
long long int ans = 1;
while (exponent != 0) {
if (exponent & 1) ans = (1LL * ans * base) % mod;
base = (1LL * base * base) % mod;
exponent >>= 1;
}
return ans % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long int x, n;
cin >> x >> n;
long long int sx = sqrt(x) + 10;
map<long long int, long long int> ma;
for (long long int i = 2; i <= sx; i++) {
while (x % i == 0) {
x = x / i;
ma[i]++;
}
}
if (x != 1) ma[x]++;
vector<long long int> v;
for (auto i : ma) v.push_back(i.first);
long long int ans = 1;
for (auto i : v) {
long long int p = i;
long long int e = 0;
long long int nn = n;
for (long long int j = 1; true; j++) {
e += nn / p;
e = e % (1000000007 - 1);
nn = nn / p;
if (nn == 0) break;
}
long long int tmp = expo(i, e % (1000000007 - 1), 1000000007);
ans = (ans * tmp) % 1000000007;
}
cout << ans;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100000 + 10;
vector<int> G[maxN];
int n, m, k, ind[maxN];
bool vis[maxN];
vector<int> ans;
void dfs(int u) {
vis[u] = true;
ans.push_back(u);
ind[u] = ans.size() - 1;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (vis[v] == false)
dfs(v);
else {
if (ind[u] - ind[v] + 1 > k) {
cout << ind[u] - ind[v] + 1 << endl;
for (int i = ind[v]; i <= ind[u]; i++) {
cout << ans[i] + 1 << ' ';
}
cout << endl;
exit(0);
}
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
G[u].push_back(v);
G[v].push_back(u);
}
dfs(0);
cout << ans.size() << endl;
for (int i = 0; i < n; i++) {
cout << ans[i] << ' ';
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int a, b;
void foo() {
if (a == 0 || b == 0) return;
if (a >= 2 * b) {
a -= (2 * b * (1 + (a - 2 * b) / (2 * b)));
foo();
return;
}
if (b >= 2 * a) {
b -= (2 * a * (1 + (b - 2 * a) / (2 * a)));
foo();
return;
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin >> a >> b;
foo();
cout << a << " " << b << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, i, j;
cin >> n >> k;
i = n / k;
i++;
cout << k * i << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[2204], prefSum[2204];
int main() {
int n, k, i;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> arr[i];
}
sort(arr + 1, arr + n + 1);
prefSum[0] = 0;
for (i = 1; i <= n; i++) prefSum[i] = arr[i] + prefSum[i - 1];
cout << prefSum[k] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m, sumk;
int a[N];
int cnt[N], k[N];
bool pred(int x);
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= m; ++i) scanf("%d", &k[i]);
sumk = accumulate(k + 1, k + m + 1, 0);
for (int i = 1; i + sumk - 1 <= n; ++i)
if (pred(i)) {
puts("YES");
return 0;
}
puts("NO");
return 0;
}
bool pred(int x) {
copy(k + 1, k + m + 1, cnt + 1);
for (int i = 0; i < sumk; ++i) --cnt[a[i + x]];
return all_of(cnt + 1, cnt + m + 1, [](int q) { return q == 0; });
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_LENGTH = (1 << (10 + 1));
int arr[MAX_LENGTH], total, n, dp[MAX_LENGTH];
int check(int x) {
if (x >= total) {
return 0;
}
if (dp[x] != -1) {
return dp[x];
}
dp[x] = arr[x] + max(check(x << 1), check((x << 1) + 1));
return dp[x];
}
int answer(int x) {
if (x >= total) {
return 0;
}
int left = check(x << 1);
int right = check((x << 1) + 1);
return abs(left - right) + answer(x << 1) + answer((x << 1) + 1);
}
int main() {
for (int i = 0; i < MAX_LENGTH; i++) {
dp[i] = -1;
}
cin >> n;
total = pow(2, (n + 1));
for (int i = 2; i < total; ++i) {
cin >> arr[i];
}
cout << answer(1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
vector<pair<int, int>> g[N], ans[N];
long long dist[N];
priority_queue<pair<int, int>> pq;
bool vis[N];
void dijkstra(int s) {
fill(dist, dist + N, 1LL << 61);
memset(vis, false, sizeof(vis));
dist[s] = 0;
pq.push({0, s});
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
if (vis[u]) continue;
vis[u] = true;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, w = g[u][i].second;
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pq.push({-dist[v], v});
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
int x, y;
cin >> x >> y;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
for (int i = 1; i <= n; i++) {
long long ti, ci;
cin >> ti >> ci;
dijkstra(i);
for (int j = 1; j <= n; j++) {
if (dist[j] <= ti) {
ans[i].push_back({j, ci});
}
}
}
for (int i = 1; i <= n; i++) {
g[i] = ans[i];
}
dijkstra(x);
if (dist[y] == 1LL << 61)
cout << -1;
else
cout << dist[y];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool vis[1009];
int ok[1009];
string v[1009];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> v[i];
memset(vis, 0, sizeof(vis));
memset(ok, -1, sizeof(ok));
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n - 1; ++j) {
if (v[j][i] < v[j + 1][i] && (ok[j] == -1 || vis[ok[j]])) {
ok[j] = i;
}
if (v[j][i] > v[j + 1][i]) {
if (ok[j] != -1 && !vis[ok[j]]) continue;
vis[i] = 1;
}
}
}
int ans = 0;
for (int i = 0; i < m; ++i)
if (vis[i]) ++ans;
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using VS = vector<string>;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
using VL = vector<LL>;
using VVL = vector<VL>;
const int INF = 1e9;
const LL LINF = 1e16;
const LL MOD = 1000000007;
const double PI = acos(-1.0);
int DX[8] = {0, 0, 1, -1, 1, 1, -1, -1};
int DY[8] = {1, -1, 0, 0, 1, -1, 1, -1};
template <typename type>
struct BIT {
int N;
int nn;
vector<type> data;
BIT(int n) {
N = n + 1;
data = vector<type>(n + 1, 0);
nn = 1;
while (nn * 2 <= N) nn *= 2;
}
void add(int i, type w) {
for (int x = i; x <= N; x += x & -x) {
data[x] += w;
}
}
type sum(int i) {
type ret = 0;
for (int x = i; x > 0; x -= x & -x) {
ret += data[x];
}
return ret;
}
type sum(int l, int r) {
if (l > r) return 0;
return sum(r) - sum(l - 1);
}
};
LL gre(const VI& a, int M) {
int N = int((a).size());
LL ret = 0;
BIT<LL> bit(4e5 + 10);
int cur = 2e5 + 5;
for (int(i) = (0); (i) < (N); (i)++) {
bit.add(cur, 1);
if (a[i] < M) {
cur--;
} else {
cur++;
}
ret += bit.sum(cur - 1);
}
return ret;
}
void solve2() {
int N, M;
cin >> N >> M;
VI a(N);
for (int(i) = (0); (i) < (N); (i)++) cin >> a[i];
cout << gre(a, M) - gre(a, M + 1) << endl;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
solve2();
return 0;
}
| 8 |
#include <iostream>
#include <vector>
#include <map>
#define ll long long
using namespace std;
const ll MOD = 1e9+7;
void solve() {
map<ll,ll> dp;
dp[0] = 1;
ll offset = 0, sum = 0, ans = 1, n;
cin >> n;
vector<ll> b(n+1);
for(int i = 1; i <= n; ++i) {
cin >> b[i];
}
for(int i = 1; i <= n; ++i) {
ll save = ans;
ans = (2LL*ans - dp[offset] + MOD) % MOD;
dp[offset] = save;
offset -= b[i];
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0); cin.tie(0);
int t = 1;
cin >> t;
while(t--) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int N = 100010;
int tot = 0;
long long a[N];
map<long long, int> mp;
long long basis[100];
vector<array<long long, 3> > ans;
void show_ans() {
printf("%d\n", (int)ans.size());
for (auto x : ans) {
printf("%lld %c %lld\n", x[0], (x[2] ? '^' : '+'), x[1]);
}
}
int add(long long x) {
a[++tot] = x;
mp[x] = tot;
return tot;
}
void maintain_basis(long long num) {
int pos = -1;
long long x = num;
for (int j = 62; j >= 0; --j) {
if (((x >> j) & 1) == 0) continue;
if (basis[j] == 0) {
pos = j;
break;
}
x ^= basis[j];
}
if (pos == -1) return;
x = num;
for (int j = 62; j >= 0; --j) {
if (((x >> j) & 1) == 0) continue;
if (basis[j] == 0) {
basis[j] = x;
break;
}
ans.push_back({x, basis[j], 1});
add(x ^ basis[j]);
x ^= basis[j];
}
}
int rand_add(int x, int y, int op) {
if (x == -1) x = rand() % tot + 1;
if (y == -1) y = rand() % tot + 1;
if (INF - a[x] < a[y]) return -1;
if (op < 0 || op > 1) op = rand() % 2;
long long res = op ? a[x] ^ a[y] : a[x] + a[y];
int pos = mp[res];
if (pos != 0) return pos;
ans.push_back({a[x], a[y], op});
pos = add(res);
maintain_basis(res);
return pos;
}
void solve(long long n) {
ans.clear();
tot = 0;
memset(a, 0, sizeof(a[0]) * (tot + 3));
mp.clear();
memset(basis, 0, sizeof(basis));
mp[0] = true;
add(n);
maintain_basis(n);
int last = 1;
for (int k = 1; k <= 64; ++k) {
last = rand_add(last, 1, 0);
if (basis[0] != 0) break;
}
last = 1;
for (int k = 1; k <= 64; ++k) {
last = rand_add(last, last, 0);
if (basis[0] != 0) break;
}
int round = 0;
while (basis[0] == 0) {
round++;
rand_add(-1, -1, -1);
}
if (0) {
printf("%lld: round=%d tot=%d op=%zu\n", n, round, tot, ans.size());
} else {
show_ans();
}
}
int main() {
if (0) {
srand((unsigned)time(NULL));
for (int i = 1; i <= 25; ++i) {
for (int j = 1; j < 8; j += 2) {
solve((1LL << i) + j);
long long r = rand() % (1LL << (i / 2));
solve((1LL << i) + r * 2 + 1);
}
}
} else {
long long n;
scanf("%lld", &n);
if (n % 2 == 0) {
puts("invalid");
return 0;
}
solve(n);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[10000];
vector<int> ans;
int main() {
string s;
bool b = 0;
cin >> s;
int i, n = s.size();
for (i = 0; i < n - 1; i++) {
if ((!b) && s[i + 1] == 'a') a[i] = 1, b = 1;
if (b && s[i + 1] == 'b') a[i] = 1, b = 0;
}
if (b) a[i] = 1;
for (i = 0; i < n; i++) printf("%d ", a[i]);
getchar();
getchar();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> arr;
string s;
cin >> s;
for (int i = 0; i != s.size(); i++) {
if (s[i] != '+') arr.push_back(s[i] - '0');
}
sort(arr.begin(), arr.end());
for (int i = 0; i != arr.size(); ++i) {
if (i) cout << "+";
cout << arr[i];
}
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string e[30];
int u[30][30];
vector<string> v;
vector<int> v2;
int f(int a, int b) {
if (u[v2[a]][v2[b]]) return u[v2[a]][v2[b]];
int minimum = min(v[a].length(), v[b].length());
for (int i = 0; i < minimum; i++)
if (v[a][i] != v[b][i]) return u[v2[a]][v2[b]] = i;
return u[v2[a]][v2[b]] = minimum;
}
int main() {
int n, k;
vector<int> s;
memset(u, 0, sizeof u);
cin >> n >> k;
for (int i = 0; i < n - k; i++) s.push_back(0);
for (int i = 0; i < k; i++) s.push_back(1);
for (int i = 0; i < n; i++) cin >> e[i];
int maximum = -2147483647, m;
do {
v.clear();
v2.clear();
for (int i = 0; i < n; i++)
if (s[i]) {
v.push_back(e[i]);
v2.push_back(i);
}
m = 0;
for (int i = 0; i < v.size() - 1; i++)
for (int j = i + 1; j < v.size(); j++) m += f(i, j);
maximum = max(maximum, m);
} while (next_permutation(s.begin(), s.end()));
cout << maximum << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 0;
cin >> n;
for (int x1 = -(1 << 30), h1 = 0, x, h; cin >> x >> h; ++c, x1 = x, h1 = h) {
if (x1 + h1 >= x) --c, h1 = 0;
if (x - h > x1 + h1) h = 0;
}
cout << c << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 3e3 + 5;
int a[maxn], b[maxn];
long long dp[maxn][maxn];
void solve() {
int n;
cin >> n;
for (int i = 1; i < n + 1; i++) {
cin >> a[i];
a[i] -= i;
b[i] = a[i];
}
sort(b + 1, b + n + 1);
memset(dp, 0x3f, sizeof(dp));
dp[0][1] = 0;
for (int i = 1; i < n + 1; i++) {
long long mi = 1e18;
for (int j = 1; j < n + 1; j++) {
mi = min(mi, dp[i - 1][j]);
dp[i][j] = mi + abs(b[j] - a[i]);
}
}
long long ans = 1e18;
for (int i = 1; i < n + 1; i++) {
ans = min(ans, dp[n][i]);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int c = 0;
int t;
if (!c) {
t = 1;
} else {
cin >> t;
}
while (t--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
#define pb push_back
#define er erase
#define in insert
#define s(a, x, y) sort(a.begin()+x, a.begin()+y);
#define r(a, x, y) reverse(a.begin()+x, a.begin()+y);
#define mp make_pair
#define F first
#define S second
#define ll long long
#define ld long double
#define forn(i, a, b) for(int i=a; i<=b; i++)
#define form(i, a, b) for(int i=a; i>=b; i--)
#define PI 3.14159265358979
#define inf 2147483647
#define sp setprecision
#define pii pair <int, int>
using namespace std;
ll t;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> t;
while (t --){
cin >> s;
cout << s.size() << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline long long rand(long long x, long long y) {
return (rng() % (y + 1 - x)) + x;
}
string inline to_string(char c) {
string second(1, c);
return second;
}
template <typename T>
inline T gcd(T a, T b) {
return a == 0 ? b : gcd(b % a, a);
}
long long int q, n, A[(300006)], ans, memo[(300006)];
long long int b = 81953;
long long int qexp(long long int x, long long int e) {
if (e == 0) return 1;
long long int half = qexp(x, e >> 1);
half *= half;
if (e & 1) half *= x;
return half;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> q;
for (long long int i = (0); i <= (long long int)((300006) - 1); ++i)
memo[i] = qexp(b, i);
function<void(long long int, long long int)> dnc = [&](long long int x,
long long int y) {
if (x >= y) return;
long long int m = (x + y) >> 1;
stack<long long int> stk;
long long int hash = 0;
map<long long int, long long int> cnt;
for (long long int i = (m + 1); i <= (long long int)(y); ++i) {
if (stk.empty() || stk.top() != A[i]) {
hash += memo[stk.size()] * A[i];
stk.push(A[i]);
} else {
stk.pop();
hash -= memo[stk.size()] * A[i];
}
++cnt[hash];
}
while (stk.size()) stk.pop();
hash = 0;
for (long long int i = (m); i >= (long long int)(x); --i) {
if (stk.empty() || stk.top() != A[i]) {
hash += memo[stk.size()] * A[i];
stk.push(A[i]);
} else {
stk.pop();
hash -= memo[stk.size()] * A[i];
}
ans += cnt[hash];
}
dnc(x, m);
dnc(m + 1, y);
};
auto solve = [&]() {
cin >> n;
for (long long int i = (1); i <= (long long int)(n); ++i) cin >> A[i];
ans = 0;
dnc(1, n);
cout << ans << '\n';
};
while (q--) {
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[400020];
int ans[400020];
int subsize[400020];
int thr;
int calc_size(int v, int par) {
subsize[v] = 1;
for (auto ch : g[v])
if (ch != par) subsize[v] += calc_size(ch, v);
return subsize[v];
}
int find_centroid(int v, int par) {
for (auto ch : g[v]) {
if (ch != par && subsize[ch] > thr) return find_centroid(ch, v);
}
return v;
}
int dist[400020];
int adj[400020];
int ncentr[400020];
void dfs(int v, int centroid, int adjv) {
for (auto ch : g[v]) {
if (dist[v] + 1 < dist[ch]) {
ncentr[ch] = centroid;
dist[ch] = dist[v] + 1;
if (v == centroid) adjv = ch;
adj[ch] = adjv;
dfs(ch, centroid, adjv);
}
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d %d", &x, &y);
--x;
--y;
g[x].push_back(y);
g[y].push_back(x);
}
thr = n / 2;
calc_size(0, -1);
int c1 = find_centroid(0, -1);
calc_size(c1, -1);
int c2 = c1;
vector<pair<int, int> > cchild;
for (auto ch : g[c1]) {
cchild.push_back({subsize[ch], ch});
}
sort(cchild.rbegin(), cchild.rend());
for (int v = 0; v < n; ++v)
if (n - subsize[v] <= thr && v != c1) c2 = v;
for (int i = 0; i < n; ++i) dist[i] = 1000000000;
dist[c1] = 0;
dfs(c1, c1, -1);
for (int i = 0; i < n; ++i) {
if (c1 != c2) {
ans[i] = 1;
continue;
}
if (i == c1 || i == c2) {
ans[i] = 1;
continue;
}
int adjv = adj[i];
for (auto pr : cchild) {
if (pr.second == adjv) continue;
if (n - subsize[i] - pr.first <= thr) {
ans[i] = 1;
}
break;
}
}
for (int i = 0; i < n; ++i) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long double PI = acosl(-1);
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
struct point {
long double x, y;
point() {}
point(long double x, long double y) : x(x), y(y) {}
long double kampas() { return atan2l(y, x); }
};
point operator+(point a, point b) { return point(a.x + b.x, a.y + b.y); }
point operator-(point a, point b) { return point(a.x - b.x, a.y - b.y); }
point operator*(point a, long double k) { return point(a.x * k, a.y * k); }
long double cross(point a, point b) { return a.x * b.y - a.y * b.x; }
long double f(long double alfa, long double beta, pair<point, point> ab) {
point a = ab.first;
point b = ab.second;
point va(cosl(alfa), sinl(alfa));
point vb(cosl(beta), sinl(beta));
va = va * (cross(a, b) / cross(va, b - a));
vb = vb * (cross(a, b) / cross(vb, b - a));
return cross(va, vb) / 2;
}
long double calc(long double alfa, long double beta,
const vector<pair<point, point>>& A,
pair<point, point> mn = {point(1e10, 1e10), point(1e10, 1e10)},
pair<point, point> mn1 = {point(1e10, 1e10),
point(1e10, 1e10)}) {
if (A.empty()) {
if (mn1.first.x < 1e9) {
return f(alfa, beta, mn1) - f(alfa, beta, mn);
} else
return 0;
}
if (beta - alfa < 1e-9) return 0;
vector<pair<point, point>> L, R;
long double gamma = (alfa + beta) / 2;
bool ok = true;
for (pair<point, point> i : A) {
long double k1 = i.first.kampas();
long double k2 = i.second.kampas();
if (beta < k1 || k2 < alfa) continue;
if (beta - alfa < 0.2)
if (k1 < alfa + 1e-9 && beta < k2 + 1e-9) {
point v(cos(gamma), sin(gamma));
long double k1 =
abs(cross(mn.first, mn.second) / cross(v, mn.second - mn.first));
long double k2 = abs(cross(mn1.first, mn1.second) /
cross(v, mn1.second - mn1.first));
long double d =
abs(cross(i.first, i.second) / cross(v, i.second - i.first));
if (mn.first.x >= 1e9 || d <= k1) {
mn1 = mn;
mn = i;
} else if (mn1.first.x >= 1e9 || d <= k2) {
mn1 = i;
}
continue;
}
ok = false;
if (k1 < gamma) L.push_back(i);
if (k2 > gamma) R.push_back(i);
}
if (ok) return f(alfa, beta, mn1) - f(alfa, beta, mn);
return calc(alfa, gamma, L, mn, mn1) + calc(gamma, beta, R, mn, mn1);
}
int sgn(long double x) {
if (x < 0) return -1;
if (x > 0) return 1;
return 0;
}
int main() {
cout << fixed << setprecision(3);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<pair<point, point>> A;
while (n--) {
int k;
cin >> k;
point a0;
cin >> a0.x >> a0.y;
point aj = a0;
for (int i = 1; i < k; i++) {
point ai;
cin >> ai.x >> ai.y;
A.push_back({aj, ai});
aj = ai;
}
A.push_back({aj, a0});
}
n = A.size();
for (int i = 0; i < n; i++) {
if (abs(A[i].first.y) < 0.5 || abs(A[i].second.y) < 0.5) continue;
if ((A[i].first.y > 0) != (A[i].second.y > 0)) {
long double k = -A[i].first.y / (A[i].second - A[i].first).y;
point B = A[i].first + (A[i].second - A[i].first) * k;
A.push_back({B, A[i].second});
A[i].second = B;
}
}
vector<pair<point, point>> A_;
for (pair<point, point> b : A) {
if (abs(b.first.kampas() - b.second.kampas()) > 1e-8) {
A_.push_back(b);
}
}
for (pair<point, point>& i : A_) {
while (sgn(i.first.y) != sgn(i.second.y)) {
if (abs(i.first.y) < abs(i.second.y)) {
if (i.second.y > 0)
i.first.y = 1e-11;
else
i.first.y = -1e-11;
} else {
if (i.first.y > 0)
i.second.y = 1e-11;
else
i.second.y = -1e-11;
}
}
if (i.first.kampas() > i.second.kampas()) swap(i.first, i.second);
}
cout << fixed << setprecision(20) << calc(-PI - 0.001, PI + 0.001, A_)
<< "\n";
}
| 11 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.