solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
int main() {
int n, k;
while (scanf("%d %d", &n, &k) == 2) {
int i;
for (i = 1; i <= n - k - 1; i++) printf("%d ", i);
for (i = n; i > n - k; i--) printf("%d ", i);
printf("%d\n", n - k);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long i, m, n;
int main() {
string s, e;
cin >> s;
n = s.length();
long long c = 0, co = 0;
for (i = 0; i < n; i++) {
e = s.substr(i, 5);
if (e == "heavy")
c++;
else if (e == "metal")
co += c;
}
cout << co;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 10;
const int maxl = (1 << 18);
const int INF = 1e9;
int dp[maxn][maxl];
int par[maxn][maxl];
int n;
int a[maxn];
int val[70];
int prime[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59};
int ms[70];
int Solve(int pos, int mask) {
int &ret = dp[pos][mask];
if (ret != -1) return ret;
if (pos == n + 1) return ret = 0;
ret = INF;
for (int i = 1; i <= 60; i++) {
if ((ms[i] & mask) == 0) {
if (ret > Solve(pos + 1, (mask | ms[i])) + abs(a[pos] - i)) {
ret = min(ret, Solve(pos + 1, (mask | ms[i])) + abs(a[pos] - i));
par[pos][mask] = i;
}
}
}
return ret;
}
int main() {
cin >> n;
val[2] = 0;
val[3] = 1;
val[5] = 2;
val[7] = 3;
val[11] = 4;
val[13] = 5;
val[17] = 6;
val[19] = 7;
val[23] = 8;
val[29] = 9;
val[31] = 10;
val[37] = 11;
val[41] = 12;
val[43] = 13;
val[47] = 14;
val[53] = 15;
val[59] = 16;
for (int i = 1; i <= 60; i++) {
for (int j = 0; j < 17; j++) {
if (i % prime[j] == 0) {
ms[i] += (1 << val[prime[j]]);
}
}
}
for (int i = 1; i <= n; i++) cin >> a[i];
memset(dp, -1, sizeof(dp));
memset(par, -1, sizeof(par));
int pos = 1, mask = 0;
Solve(1, 0);
while (par[pos][mask] != -1) {
cout << par[pos][mask] << " ";
mask |= ms[par[pos][mask]];
pos++;
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1, b1, a2, b2, a3, b3;
cin >> a1 >> b1 >> a2 >> b2 >> a3 >> b3;
int sum1 = a1 + a3 + a2;
int sum2 = b1 + b3 + b2;
printf("3\n");
printf("%d %d\n", sum1 - 2 * a1, sum2 - 2 * b1);
printf("%d %d\n", sum1 - 2 * a2, sum2 - 2 * b2);
printf("%d %d\n", sum1 - 2 * a3, sum2 - 2 * b3);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, a, b, c, d, start, len;
int t[N], q[N];
long long sum[N];
int main() {
scanf("%d%d%d%d%d%d%d", &n, &a, &b, &c, &d, &start, &len);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &t[i], &q[i]);
if (q[i])
sum[i] = sum[i - 1] + c;
else
sum[i] = sum[i - 1] - d;
}
set<pair<long long, int>> s;
t[0] = -1;
s.insert(make_pair(0, 0));
long long x = start;
for (int i = 0, j = 1; i <= n; i++) {
if (i) {
if (q[i])
x += a;
else
x -= b;
s.erase(make_pair(sum[i], i));
}
if (x < 0) {
cout << -1 << endl;
break;
}
while (j <= n && t[j] <= t[i] + len) {
s.insert(make_pair(sum[j], j));
j++;
}
long long y = s.begin()->first - sum[i];
if (x + y >= 0) {
cout << t[i] + 1 << endl;
break;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double res = 0;
int n;
cin >> n;
vector<double> vec(n + 1);
for (long long i = 0; i < ((long long)n + 1); i++) cin >> vec[i];
for (long long i = 0; i < ((long long)(n - 1) / 2 + 1); i++)
for (int j = n / 2 + 1; j <= n; j++) {
int a = (n - i) - i;
int b = j - (n - j);
res = max(res, (double)(b * vec[i] + a * vec[j]) / (double)(a + b));
}
if (n % 2 == 0) res = max(res, vec[n / 2]);
cout << res << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
double x, v, m;
};
int n;
double t;
node a[12];
double b[12][12];
pair<vector<int>, double> timMin() {
pair<vector<int>, double> c;
c.second = 101;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (abs(b[i][j] - c.second) < 1e-6) {
c.first.push_back(i);
c.first.push_back(j);
} else if (b[i][j] < c.second) {
c.first.clear();
c.first.push_back(i);
c.first.push_back(j);
c.second = b[i][j];
}
}
}
return c;
}
void capnhat(double t) {
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
b[i][j] = 100001;
if ((a[i].x - a[j].x) * (a[i].v - a[j].v) < 0) {
b[i][j] = -(a[i].x - a[j].x) / (a[i].v - a[j].v);
}
}
}
pair<vector<int>, double> c = timMin();
if (t > c.second) {
for (int i = 0; i < n; i++) a[i].x += a[i].v * c.second;
for (int i = 0; i < c.first.size(); i += 2) {
int k = c.first[i], l = c.first[i + 1];
double v1 = (a[k].m - a[l].m) * a[k].v + 2 * a[l].m * a[l].v;
v1 /= a[k].m + a[l].m;
double v2 = (a[l].m - a[k].m) * a[l].v + 2 * a[k].m * a[k].v;
v2 /= a[k].m + a[l].m;
a[k].v = v1;
a[l].v = v2;
a[k].x = a[l].x;
}
capnhat(t - c.second);
} else {
for (int i = 0; i < n; i++) a[i].x += a[i].v * t;
}
}
int main() {
cin >> n >> t;
for (int i = 0; i < n; i++) {
cin >> a[i].x >> a[i].v >> a[i].m;
}
capnhat(t);
for (int i = 0; i < n; i++) cout << a[i].x << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[1000];
int t, n;
bool kt;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n;
kt = true;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 2; i <= n; i++)
if (abs(a[i] - a[i - 1]) > 1) {
kt = false;
break;
}
if (kt)
cout << "YES";
else
cout << "NO";
cout << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int maxt = (1 << 19) + 20;
vector<pair<pair<int, int>, int> > ad[maxn];
vector<pair<pair<int, int>, int> > qs[maxn];
set<pair<int, int> > st;
set<pair<int, int> >::iterator it1, it2, it3;
int n, q;
long long val[maxt], taga[maxt], tagb[maxt];
void update(int x) {
val[x] = val[x * 2] + val[x * 2 + 1];
if (val[x] >= 998244353) val[x] -= 998244353;
}
void build(int x, int l, int r) {
val[x] = tagb[x] = 0;
taga[x] = 1;
if (l == r) return;
int mid = (l + r) >> 1;
build(x * 2, l, mid);
build(x * 2 + 1, mid + 1, r);
}
void taketag(int x, int l, int r) {
if (l == r) {
taga[x] = 1;
tagb[x] = 0;
return;
}
int mid = (l + r) >> 1;
val[x * 2] = (val[x * 2] * taga[x]) % 998244353;
val[x * 2] = (val[x * 2] + tagb[x] * (mid - l + 1)) % 998244353;
val[x * 2 + 1] = (val[x * 2 + 1] * taga[x]) % 998244353;
val[x * 2 + 1] = (val[x * 2 + 1] + tagb[x] * (r - mid)) % 998244353;
taga[x * 2] = (taga[x * 2] * taga[x]) % 998244353;
tagb[x * 2] = (tagb[x * 2] * taga[x]) % 998244353;
tagb[x * 2] = tagb[x * 2] + tagb[x];
if (tagb[x * 2] >= 998244353) tagb[x * 2] -= 998244353;
taga[x * 2 + 1] = (taga[x * 2 + 1] * taga[x]) % 998244353;
tagb[x * 2 + 1] = (tagb[x * 2 + 1] * taga[x]) % 998244353;
tagb[x * 2 + 1] = tagb[x * 2 + 1] + tagb[x];
if (tagb[x * 2 + 1] >= 998244353) tagb[x * 2 + 1] -= 998244353;
taga[x] = 1;
tagb[x] = 0;
}
void modify(int x, int l, int r, int tl, int tr, long long a, long long b) {
if (l > tr || r < tl) return;
if (tl <= l && r <= tr) {
val[x] = (val[x] * a) % 998244353;
val[x] = (val[x] + b * (r - l + 1)) % 998244353;
taga[x] = (taga[x] * a) % 998244353;
tagb[x] = (tagb[x] * a + b) % 998244353;
taketag(x, l, r);
return;
}
taketag(x, l, r);
int mid = (l + r) >> 1;
modify(x * 2, l, mid, tl, tr, a, b);
modify(x * 2 + 1, mid + 1, r, tl, tr, a, b);
update(x);
}
long long query(int x, int l, int r, int tl, int tr) {
if (l > tr || r < tl) return 0;
if (tl <= l && r <= tr) return val[x];
taketag(x, l, r);
int mid = (l + r) >> 1;
long long ans =
(query(x * 2, l, mid, tl, tr) + query(x * 2 + 1, mid + 1, r, tl, tr)) %
998244353;
return ans;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= q; i++) {
int t, l, r, x;
scanf("%d%d%d", &t, &l, &r);
if (t == 1) {
scanf("%d", &x);
ad[x].push_back(make_pair(make_pair(l, r), i));
} else
qs[i].push_back(make_pair(make_pair(l, r), 0));
}
for (int i = 1; i <= n; i++)
if (!ad[i].empty()) {
st.clear();
st.insert(make_pair(1, 0));
st.insert(make_pair(n, 1));
for (int j = 0; j < ad[i].size(); j++) {
int l = ad[i][j].first.first;
int r = ad[i][j].first.second;
if (st.empty()) {
qs[ad[i][j].second].push_back(make_pair(ad[i][j].first, 2));
} else {
it1 = st.lower_bound(make_pair(l, -1));
if ((*it1).second == 1) {
st.insert(make_pair(l - 1, 1));
}
int pre = l;
bool beg = 0, ed = 0;
for (it2 = it1; it2 != st.end();) {
int cur = (*it2).first;
int op = (*it2).second;
if (cur > r) break;
if (op == 0) {
if (pre <= cur - 1) {
qs[ad[i][j].second].push_back(
make_pair(make_pair(pre, cur - 1), 2));
}
pre = cur;
} else {
qs[ad[i][j].second].push_back(make_pair(make_pair(pre, cur), 1));
pre = cur + 1;
}
it1 = it2;
++it2;
st.erase(it1);
}
if (pre <= r) {
int op = 0;
if (it2 != st.end()) op = (*it2).second;
if (op == 0) {
if (pre <= r) {
qs[ad[i][j].second].push_back(make_pair(make_pair(pre, r), 2));
}
} else {
qs[ad[i][j].second].push_back(make_pair(make_pair(pre, r), 1));
st.insert(make_pair(r + 1, 0));
}
}
}
}
}
build(1, 1, n);
for (int i = 1; i <= q; i++)
for (int j = 0; j < qs[i].size(); j++) {
if (qs[i][j].second == 0) {
printf("%I64d\n",
query(1, 1, n, qs[i][j].first.first, qs[i][j].first.second));
} else if (qs[i][j].second == 1) {
modify(1, 1, n, qs[i][j].first.first, qs[i][j].first.second, 1, 1);
} else {
modify(1, 1, n, qs[i][j].first.first, qs[i][j].first.second, 2, 0);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(const int& num) {
for (int i = 2; i <= ceil(sqrt(num)); i++)
if (num % i == 0) return false;
return true;
}
vector<vector<int>> tree;
vector<bool> visited;
int ans = 0;
int aux = 0;
int main() {
int n;
cin >> n;
vector<int> tree(n + 1);
vector<int> ans;
tree[1] = -1;
for (int i = 2; i <= n; i++) {
cin >> tree[i];
}
int k = n;
while (k != -1) {
ans.push_back(k);
k = tree[k];
}
for (int i = ans.size() - 1; i >= 0; i--) cout << ans[i] << " ";
cout << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, sum = 0, cnt = 0, c;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = n - 1; i >= 0; i--) {
sum = sum + a[i];
if (sum > cnt) {
cnt = sum;
}
}
cout << cnt << endl;
}
}
| 1 |
#include <bits/stdc++.h>
int main() {
double xA, yA, xB, yB, xC, yC;
scanf("%lf %lf\n%lf %lf\n%lf %lf\n", &xA, &yA, &xB, &yB, &xC, &yC);
double result = (xB - xA) * (yC - yB) - (xC - xB) * (yB - yA);
if (result == 0) {
puts("TOWARDS");
} else if (result < 0) {
puts("RIGHT");
} else {
puts("LEFT");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> wyn;
int tab[1000002];
int it = 0;
void erastotenes(int n) {
for (int i = 2; i <= n; i++) {
if (tab[i] == 0) {
for (int j = 2 * i; j <= n; j += i) {
tab[j] = 1;
}
int j = i * i;
wyn.push_back(i);
while (j <= n) {
wyn.push_back(j);
j *= i;
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
erastotenes(n);
cout << wyn.size() << "\n";
for (int i = 0; i < wyn.size(); i++) {
cout << wyn[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int case1(string str1, int n) {
char ch0 = 'r';
char ch1 = 'b';
int oddiff = 0, evendiff = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (str1[i] != ch0) {
evendiff++;
}
} else {
if (str1[i] != ch1) {
oddiff++;
}
}
}
return max(evendiff, oddiff);
}
int case2(string str1, int n) {
char ch0 = 'b';
char ch1 = 'r';
int oddiff = 0, evendiff = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (str1[i] != ch0) {
evendiff++;
}
} else {
if (str1[i] != ch1) {
oddiff++;
}
}
}
return max(evendiff, oddiff);
}
int main() {
int n;
cin >> n;
string str;
cin >> str;
int temp1, temp2;
temp1 = case1(str, n);
temp2 = case2(str, n);
int ans = min(temp1, temp2);
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, l = 0, p = 0, i, flag = 0, k, j, r = 0, q = 0, t, d;
cin >> n;
long long a[n];
vector<long long> v;
for (long long i = 0; i < n; i++) {
cin >> a[i];
v.push_back(a[i]);
}
cin >> m;
long long b[m];
for (long long i = 0; i < m; i++) {
cin >> b[i];
v.push_back(b[i]);
}
v.push_back(0);
v.push_back(1000000007);
sort((v).begin(), (v).end());
sort(a, a + n);
sort(b, b + m);
long long ans = (-1) * 1e18;
long long ans1 = 0;
long long ans2 = 0;
for (long long i = 0; i < (long long)v.size(); i++) {
p = 0;
q = 0;
t = (upper_bound(a, a + n, v[i]) - a);
k = (upper_bound(b, b + m, v[i]) - b);
p = 3 * (n - t) + 2 * t;
q = 3 * (m - k) + 2 * k;
if (p - q > ans) {
ans1 = p;
ans2 = q;
ans = p - q;
} else if (p - q == ans) {
if (p > ans1) {
ans = p - q;
ans1 = p;
ans2 = q;
}
}
}
cout << ans1 << ":" << ans2;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
int m;
cin >> s >> m;
vector<int> cnt(26);
for (char c : s) {
cnt[c - 'a']++;
}
vector<int> b(m);
for (int i = 0; i < m; i++) {
cin >> b[i];
}
vector<char> str(m);
vector<int> dist(m);
set<int> pos, filled;
int largest = 26;
while (filled.size() < m) {
pos.clear();
int amt = 0;
for (int i = 0; i < m; i++) {
if (dist[i] == b[i] && !filled.count(i)) {
amt++;
pos.insert(i);
filled.insert(i);
}
}
for (int i = 0; i < m; i++) {
if (!filled.count(i)) {
for (int j : pos) {
dist[i] += abs(j - i);
}
}
}
for (int i = largest - 1; i >= 0; i--) {
if (cnt[i] >= amt) {
largest = i;
break;
}
}
for (int i : pos) {
str[i] = 'a' + largest;
}
}
for (int i = 0; i < m; i++) {
cout << str[i];
}
cout << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
const int MN = 50;
const long long inf = (1ll << 63) - 1;
long long dp[MN][MN];
int arr[MN], n;
long long solve(int x, int y) {
if (x < 0 || y < 0) return -inf;
if (!x && !y) return 0ll;
if (dp[x][y] != -1ll) return dp[x][y];
long long ans1 = solve(x - 1, y);
if (ans1 != -inf)
ans1 += (long long)pow(10.0, n - x + 0.0) * (long long)arr[x + y];
long long ans2 = solve(x, y - 1);
if (ans2 != -inf)
ans2 += (long long)pow(10.0, n - y + 0.0) * (long long)arr[x + y];
return dp[x][y] = max(ans1, ans2);
}
void get_path(int x, int y) {
if (x < 0 || y < 0 || (!x && !y)) return;
long long ans = solve(x, y);
long long ans1 = solve(x - 1, y);
if (ans1 != -inf) ans1 += (long long)pow(10.0, n - x + 0.0) * arr[x + y];
long long ans2 = solve(x, y - 1);
if (ans2 != -inf) ans2 += (long long)pow(10.0, n - y + 0.0) * arr[x + y];
if (ans == ans1) {
get_path(x - 1, y);
cout << "H";
} else if (ans == ans2) {
get_path(x, y - 1);
cout << "M";
}
}
int main() {
fill(&dp[0][0], &dp[0][0] + MN * MN, -1ll);
cin >> n;
for (int i = 1; i <= 2 * n; i++) {
char ch;
cin >> ch;
arr[i] = ch - '0';
}
long long ans = solve(n, n);
get_path(n, n);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
string alp = "abcdefghijklmnopqrstuvwxyz";
set<char> st;
st.insert('a');
int idx = 0;
for (int i = 0; i < s.size(); i++) {
if (st.find(s[i]) == st.end()) {
cout << "NO"
<< "\n";
return 0;
} else {
if (s[i] == alp[idx]) {
idx++;
st.insert(alp[idx]);
continue;
}
}
}
cout << "YES"
<< "\n";
}
| 1 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
int a[4];
char ans[40][50];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
for (int i = 0; i < 40; i++) {
for (int j = 0; j < 50; j++) {
ans[i][j] = '#';
}
}
for (int i = 0; i < 4; i++) cin >> a[i], a[i]--;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 50; j++) {
ans[i * 10][j] = i + 'A';
}
}
for (int i = 1; i < 10; i++) {
for (int j = 0; j < 50; j += 2) {
if (i % 2 == 0) continue;
if (a[2]) {
ans[i][j] = 'C';
a[2]--;
}
}
for (int j = 0; j < 50; j++)
if (ans[i][j] == '#') ans[i][j] = 'A';
}
for (int i = 11; i < 20; i++) {
for (int j = i % 2; j < 50; j += 2) {
if (i % 2 == 0) continue;
if (a[3]) {
ans[i][j] = 'D';
a[3]--;
}
}
for (int j = 0; j < 50; j++)
if (ans[i][j] == '#') ans[i][j] = 'B';
}
for (int i = 21; i < 30; i++) {
for (int j = i % 2; j < 50; j += 2) {
if (i % 2 == 0) continue;
if (a[0]) {
ans[i][j] = 'A';
a[0]--;
}
}
for (int j = 0; j < 50; j++)
if (ans[i][j] == '#') ans[i][j] = 'C';
}
for (int i = 31; i < 40; i++) {
for (int j = i % 2; j < 50; j += 2) {
if (i % 2 == 0) continue;
if (a[1]) {
ans[i][j] = 'B';
a[1]--;
}
}
for (int j = 0; j < 50; j++)
if (ans[i][j] == '#') ans[i][j] = 'D';
}
cout << "40 50" << endl;
for (int i = 0; i < 40; i++) {
for (int j = 0; j < 50; j++) {
cout << ans[i][j];
}
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int x;
cin >> x;
cout << x / 2 << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
struct p {
int x, y;
} c[MAX * 5];
int n, m, num, ans, top, cnt, tot, Ans, ANS;
int pos[MAX], pre[MAX], vis[MAX], sum[MAX], ww[MAX], w[MAX], h[MAX], st[MAX],
dfn[MAX], low[MAX], siz[MAX];
bool use[MAX], Use[MAX];
void add(int x, int y) { c[++num] = (p){h[x], y}, h[x] = num; }
void dfs(int x) {
if (tot || x == Ans) return;
vis[x] = -1;
for (int i = h[x]; i && !tot; i = c[i].x)
if (c[i].y != Ans) {
if (vis[c[i].y] == -1) {
int tt = x;
while (tt != c[i].y) ww[++tot] = tt, tt = pre[tt];
return (void)(ww[++tot] = c[i].y);
} else if (!vis[c[i].y])
pre[c[i].y] = x, dfs(c[i].y);
}
vis[x] = 1;
}
void dfs1(int x, int f) {
if (x == Ans) return;
use[x] = 1;
for (int i = h[x]; i; i = c[i].x) {
int y = c[i].y;
if (y == Ans) continue;
if (!Use[y]) {
if (!use[y]) dfs1(y, f);
} else if (!Use[x] && pos[f] < pos[y])
++ANS, ++sum[1], --sum[pos[f] + 1], ++sum[pos[y]], --sum[tot + 1];
}
}
void dfs2(int x, int f) {
if (x == Ans) return;
use[x] = 1;
for (int i = h[x]; i; i = c[i].x) {
int y = c[i].y;
if (y == Ans) continue;
if (!Use[y]) {
if (!use[y]) dfs2(y, f);
} else if (!Use[x] && pos[f] >= pos[y])
++ANS, --sum[pos[f] + 1], ++sum[pos[y]];
}
}
bool solve() {
tot = 0, ANS = 0;
memset(vis, 0, sizeof(vis));
memset(sum, 0, sizeof(sum));
for (int i = 1; i <= n; ++i)
if (!tot)
dfs(i);
else
break;
memset(Use, 0, sizeof(Use));
memset(pos, 0, sizeof(pos));
for (int i = 1; i <= tot; ++i)
w[i] = ww[tot - i + 1], Use[w[i]] = 1, pos[w[i]] = i;
memset(use, 0, sizeof(use));
for (int i = 1; i <= tot; ++i) dfs1(w[i], w[i]);
memset(use, 0, sizeof(use));
for (int i = tot; i >= 1; --i) dfs2(w[i], w[i]);
for (int i = 1; i <= tot; ++i)
if ((sum[i] += sum[i - 1]) == ANS) return Ans = w[i];
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, x, y; i <= m; ++i) scanf("%d%d", &x, &y), add(x, y);
if (!solve()) return printf("-1"), 0;
if (solve()) return printf("-1"), 0;
return printf("%d", Ans), 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, a[100001], max = -1;
int d[100001] = {0};
a[0] = 0;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
d[1] = 1;
d[2] = 2;
for (i = 3; i <= n; i++)
if (a[i] == a[i - 1] + a[i - 2]) {
if (d[i - 1] > 1)
d[i] = d[i - 1] + 1;
else
d[i] = 3;
} else
d[i] = 1;
for (i = 1; i <= n; i++)
if (d[i] > max) max = d[i];
cout << max;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e4 + 10;
const int maxm = 1010;
const int base = 31337;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int logo = 16;
const int off = 1 << logo;
const int treesiz = off << 1;
const int rn = 1e7 + 19;
int n, k, q;
int tour[treesiz];
vector<int> v[treesiz];
int val[maxn], w[maxn];
bool bio[maxn];
int f[maxn];
int sol[maxn];
int mul(int a, int b) {
long long out = (long long)a * b;
return out % mod;
}
void update(int a, int b, int l, int r, int node, int x) {
if (l > b || r < a) return;
if (l >= a && r <= b) {
v[node].push_back(x);
return;
}
int mid = (l + r) / 2;
update(a, b, l, mid, node * 2, x);
update(a, b, mid + 1, r, node * 2 + 1, x);
}
void build(int node, vector<int> dp) {
if (node >= treesiz) return;
for (int i = 0; i < v[node].size(); i++) {
int va = val[v[node][i]];
int we = w[v[node][i]];
for (int j = k; j >= we; j--) {
dp[j] = max(dp[j], dp[j - 1]);
dp[j] = max(dp[j], dp[j - we] + va);
}
}
if (tour[node] != -1) {
int s = 0;
int pot = 1;
for (int i = 1; i <= k; i++) {
s += mul(dp[i], pot);
pot = mul(pot, rn);
s %= mod;
}
sol[tour[node]] = s;
}
build(node * 2, dp);
build(node * 2 + 1, dp);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d%d", val + i, w + i);
f[i] = i;
}
int ptr = n, qq = 0;
memset(bio, false, sizeof bio);
memset(tour, -1, sizeof tour);
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int x, y;
scanf("%d%d", &x, &y);
val[i + n] = x, w[i + n] = y;
f[ptr++] = i + n;
} else if (type == 2) {
int x;
scanf("%d", &x);
x--;
x = f[x];
bio[x] = true;
update(x, i + n, 0, off - 1, 1, x);
} else {
tour[i + n + off] = qq++;
}
}
for (int i = 0; i < n + q; i++) {
if (!bio[i] && w[i] > 0) {
update(i, n + q, 0, off - 1, 1, i);
}
}
vector<int> dp;
for (int i = 0; i <= k; i++) dp.push_back(0);
build(1, dp);
for (int i = 0; i < qq; i++) printf("%d\n", sol[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int n, i, ilk = 1;
scanf("%d", &n);
for (i = 1; i < n; i++) {
ilk += i;
if (ilk > n) ilk %= n;
printf("%d ", ilk);
}
printf("\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int g[1000005], pos[1000005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &g[i]), pos[g[i]] = i;
int cnt = 0;
for (int i = 1; i <= n; i++)
if (g[i] != i) {
swap(pos[i], pos[g[i]]);
swap(g[i], g[pos[g[i]]]);
cnt++;
}
if (3 * n % 2 == cnt % 2)
puts("Petr");
else
puts("Um_nik");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct Point {
T x, y;
Point() {}
Point(T xx, T yy) : x(xx), y(yy) {}
bool operator==(const Point<T> &p2) { return x == p2.x && y == p2.y; }
bool operator!=(const Point<T> &p2) { return x != p2.x || y != p2.y; }
bool operator<(const Point<T> &p2) {
return x < p2.x || x == p2.x && y < p2.y;
}
Point<T> operator+(const Point<T> &p2) {
return Point<T>(x + p2.x, y + p2.y);
}
Point<T> operator-(const Point<T> &p2) {
return Point<T>(x - p2.x, y - p2.y);
}
};
vector<int> v, suf, pre;
int main() {
int n;
cin >> n;
v.resize(n);
suf.resize(n);
pre.resize(n);
for (int(i) = 0; (i) < n; i++) {
cin >> v[i];
}
int res = 0, ires = 0;
for (int(i) = 0; (i) < n; i++) {
res += v[i];
ires -= v[i];
if (ires > res) res = ires;
pre[i] = res;
}
res = 0;
ires = 0;
for (int i = n - 1; i >= 0; i--) {
res += v[i];
ires -= v[i];
if (ires > res) res = ires;
suf[i] = res;
}
int maxs = suf[0];
for (int(i) = 0; (i) < n - 1; i++) {
maxs = max(maxs, pre[i] + suf[i + 1]);
}
maxs = max(maxs, pre[n - 1]);
cout << maxs;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct node {
int minstep = 0x3f3f3f3f, cnt;
} stat[5005];
int endstep[5005];
inline int dis(int cur, int dst) {
if (dst >= cur)
return dst - cur;
else
return n - cur + dst;
}
int main() {
cin >> n >> m;
int s, d;
for (int i = 0; i < m; ++i) {
cin >> s >> d;
int redis = dis(s - 1, d - 1);
if (stat[s - 1].minstep > redis) stat[s - 1].minstep = redis;
++stat[s - 1].cnt;
}
for (int i = 0; i < n; ++i) {
if (stat[i].cnt) endstep[i] = n * (stat[i].cnt - 1) + stat[i].minstep;
}
for (int i = 0; i < n; ++i) {
int maxa = 0;
int ans;
for (int j = 0; j < n; ++j) {
if (endstep[j]) {
ans = dis(i, j) + endstep[j];
if (ans > maxa) maxa = ans;
}
}
cout << maxa << ' ';
}
}
| 4 |
#include <bits/stdc++.h>
const int N = 2010, p = 998244353;
int n, l, k, ans, f[2 * N][N][2];
inline void ad(int &x, int y) { x = (x + y) % p; }
inline int fp(int x, int y, int z = 1) {
for (; y; y >>= 1, x = 1LL * x * x % p)
if (y & 1) z = 1LL * z * x % p;
return z;
}
int main() {
f[0][0][0] = 1;
scanf("%d%d%d", &n, &k, &l);
for (int i = 1; i <= 2 * n + 1; ++i)
for (int j = 0; j <= n; ++j) {
if (j >= k) ad(f[i][j][1], f[i - 1][j][0]);
for (int k = 0; k < 2; ++k) {
if (j && i + j - k <= 2 * n) ad(f[i][j][k], f[i - 1][j - 1][k]);
ad(f[i][j][k], 1LL * (j + 1) * f[i - 1][j + 1][k] % p);
}
}
ans = 1LL * l * f[2 * n + 1][0][1] % p;
for (int i = 1; i <= n; ++i) ans = 2LL * ans * i % p;
for (int i = 1; i <= 2 * n + 1; ++i) ans = 1LL * ans * fp(i, p - 2) % p;
printf("%d", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (n % 4 == 0)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 654;
const long double eps = 1e-10;
struct vec2 {
long double x, y;
vec2(long double x0 = 0.0, long double y0 = 0.0) : x(x0), y(y0) {}
vec2 *read() {
scanf("%Lf%Lf", &x, &y);
return this;
}
inline vec2 operator*(long double k) const { return vec2(x * k, y * k); }
inline long double operator^(const vec2 &B) const {
return x * B.y - y * B.x;
}
};
struct line {
long double A, B, C;
line(long double A0 = 0.0, long double B0 = 0.0, long double C0 = 0.0)
: A(A0), B(B0), C(C0) {}
line(const vec2 &u, const vec2 &v) : A(u.y - v.y), B(v.x - u.x), C(u ^ v) {}
inline line operator-() const { return line(-A, -B, -C); }
inline vec2 normVec() const { return vec2(A, B); }
inline long double norm2() const { return A * A + B * B; }
inline long double operator()(const vec2 &P) const {
return A * P.x + B * P.y + C;
}
};
inline vec2 intersection(const line u, const line v) {
long double Det = 1.0 / (u.A * v.B - u.B * v.A);
return vec2(u.B * v.C - u.C * v.B, u.C * v.A - u.A * v.C) * Det;
}
inline line angle_bisector(const line u, const line v) {
long double U = sqrtl(u.norm2()), V = sqrtl(v.norm2());
return line(u.A * V + v.A * U, u.B * V + v.B * U, u.C * V + v.C * U);
}
inline long double dis2(const vec2 P, const line l) {
return l(P) * l(P) / l.norm2();
}
int n;
vec2 p[N], center[N][N];
line v[N];
long double weight[N][N];
int main() {
int i, j, k;
vec2 mp, bp, lp;
long double ans = INFINITY, cur;
scanf("%d", &n);
for (i = 0; i < n; ++i) p[i].read();
std::copy(p, p + n, p + n), p[2 * n] = *p;
for (i = 0; i < 2 * n; ++i) v[i] = line(p[i], p[i + 1]);
for (i = 0; i < n; ++i) std::fill(weight[i], weight[i] + n, INFINITY);
for (i = 0; i < n; ++i) {
center[i][i] = p[i], weight[i][i] = 0.;
k = i + 1;
for (j = i + 1; ((v[i].normVec() ^ v[j].normVec()) >= (0) - eps); ++j) {
for (; k < j && ((dis2(p[k + 1], v[i])) <= (dis2(p[k + 1], v[j])) + eps);
++k)
;
mp = intersection(v[k], angle_bisector(v[i], -v[j]));
center[i][j % n] = mp;
weight[i][j % n] = 0.5 * (dis2(mp, v[i]) + dis2(mp, v[j]));
}
}
for (i = 0; i < n; ++i)
for (k = (i + n - 1) % n, j = i; j < i + n - 1; ++j) {
cur = std::max(weight[i][j % n], weight[(j + 1) % n][k]);
if (cur < ans)
ans = cur, bp = center[i][j % n], lp = center[(j + 1) % n][k];
}
assert(std::isfinite(ans));
if (ans < eps) ans = 0.;
printf("%.16Lg\n%.16Lg %.16Lg\n%.16Lg %.16Lg\n", sqrtl(ans), bp.x, bp.y, lp.x,
lp.y);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
char s[200100];
int f[200100], nxt[200100], head[200100], ed[200100], len[200100];
int find(int x) {
if (head[x] == x) return x;
return head[x] = find(head[x]);
}
void link(int a, int b) {
nxt[a] = b + 1;
head[b + 1] = a;
}
int sum(int x) {
int r = 0;
while (x) {
r += f[x];
x -= x & -x;
}
return r;
}
void del(int x) {
while (x < 200100) {
f[x]--;
x += x & -x;
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%s", s + 1);
int n = strlen(s + 1);
vector<int> v;
for (int i = 1; i <= n; i++) {
head[i] = i;
f[i] = i & -i;
nxt[i] = 0;
}
int c[26] = {};
for (int i = 1; i < n; i++) {
if (s[i] != s[i + 1]) {
link(i, i);
} else {
v.push_back(i);
c[s[i] - 'a']++;
}
}
int half = v.size() / 2;
char mx = -1;
vector<int> stk;
for (auto x : v) {
if (mx < 0) {
for (int i = 0; i < 26; i++) {
if (c[i] >= half) {
mx = 'a' + i;
break;
}
}
}
if (!stk.empty() && s[stk.back()] != s[x] &&
(mx < 0 || s[stk.back()] == mx || s[x] == mx)) {
link(stk.back(), x);
c[s[stk.back()] - 'a']--;
c[s[x] - 'a']--;
stk.pop_back();
half--;
} else {
stk.push_back(x);
}
}
set<int> alive;
int op = 0;
priority_queue<int> q;
for (int i = 1; i <= n; i++) {
alive.insert(i);
if (head[i] == i) {
op++;
len[i] = 1;
ed[i] = i;
for (int j = i; nxt[j]; j = nxt[j]) {
ed[i] = nxt[j];
len[i]++;
}
if (ed[i] - i + 1 == len[i]) q.push(i);
}
}
printf("%d\n", op);
for (int i = 0; i < op; i++) {
int h = q.top();
q.pop();
printf("%d %d\n", sum(h), sum(ed[h]));
for (int j = h; j > 0; j = nxt[j]) {
alive.erase(j);
del(j);
}
auto it = alive.upper_bound(ed[h]);
if (it != alive.end()) {
int ph = find(*it);
if (ph < h) {
len[ph] += ed[h] - h + 1;
if (len[ph] == ed[ph] - ph + 1) q.push(ph);
}
}
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
int n, m;
vector<int> adj[MAXN], ans;
set<int> rem;
bool use[MAXN];
void dfs(int u) {
rem.erase(u);
for (int i = 0; i < (int)adj[u].size(); i++) rem.erase(adj[u][i]);
if (!rem.empty()) dfs(*rem.begin());
if (!use[u]) {
use[u] = true;
for (int i = 0; i < (int)adj[u].size(); i++) use[adj[u][i]] = true;
ans.push_back(u);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
adj[a].push_back(b);
}
for (int i = 1; i <= n; i++) rem.insert(i);
dfs(1);
printf("%d\n", (int)ans.size());
for (int i = 0; i < (int)ans.size(); i++) printf("%d ", ans[i]);
puts("");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
string s;
vector<string> str;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
str.push_back(s);
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < n - i; j++) {
if (str[j].size() > str[j + 1].size()) {
s = str[j + 1];
str[j + 1] = str[j];
str[j] = s;
}
}
}
bool f = true;
s = str[0];
for (int i = 1; i < n; i++) {
if (str[i].find(s) >= str[i].size()) {
f = false;
break;
}
s = str[i];
}
if (f) {
cout << "YES\n";
for (int i = 0; i < n; i++) {
cout << str[i] << "\n";
}
} else
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
int n1, n2, n3;
cin >> n1 >> n2 >> n3;
vector<int> v[n + 1];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
auto out = []() {
cout << "NO\n";
exit(0);
};
if (n2 == 0) {
if (m == 0) {
cout << "YES\n";
cout << string(n1, '1') + string(n3, '3') << "\n";
exit(0);
} else
out();
}
vector<int> vis(n + 1, 0);
vector<vector<int>> one;
vector<vector<int>> two;
vector<vector<array<int, 2>>> dp(n + 1, vector<array<int, 2>>(n + 1, {0, 0}));
dp[0][0] = {-1, 1};
int comp = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] != 0) continue;
comp++;
queue<int> q;
q.push(i);
vis[i] = 1;
vector<int> d[3];
vector<int> cnt(3, 0);
d[1].push_back(i);
cnt[1] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int to : v[x]) {
if (vis[to] == 0) {
q.push(to);
vis[to] = 3 - vis[x];
d[vis[to]].push_back(to);
cnt[vis[to]]++;
} else if (vis[to] == vis[x])
out();
}
}
one.push_back(d[1]);
two.push_back(d[2]);
for (int j = 0; j <= n; j++) {
if (dp[comp - 1][j][1] == 0) continue;
for (int k = 1; k <= 2; k++)
if (dp[comp][j + cnt[k]][1] == 0)
dp[comp][j + cnt[k]] = {(int)one.size() - 1, k};
}
}
if (dp[comp][n2][1] == 0) out();
string res(n + 1, '0');
int c = comp;
int now = n2;
while (now > 0) {
if (dp[c][now][1] == 1) {
for (int x : one[dp[c][now][0]]) res[x] = '2';
now -= one[dp[c][now][0]].size();
} else {
for (int x : two[dp[c][now][0]]) res[x] = '2';
now -= two[dp[c][now][0]].size();
}
c--;
}
for (int i = 1; i <= n; i++) {
if (res[i] == '2') continue;
if (n1 > 0) {
res[i] = '1';
n1--;
} else
res[i] = '3';
}
cout << "YES\n";
cout << res.substr(1, n) << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, mod = 998244353, proot = 3,
fft_maxn = (1 << 18) | 10;
vector<int> g[maxn];
int n, k, ans, f[maxn], fac[maxn], ifac[maxn], siz[maxn];
inline int pow_mod(int x, int n) {
int y = 1;
while (n) {
if (n & 1) {
y = (long long)y * x % mod;
}
x = (long long)x * x % mod;
n >>= 1;
}
return y;
}
inline void dft(int n, int *a, bool rev) {
for (int i = 0, j = 0; i < n; ++i) {
if (i < j) {
swap(a[i], a[j]);
}
for (int k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
for (int hl = 1, l = 2; l <= n; hl = l, l <<= 1) {
int wn = pow_mod(proot, (mod - 1) / l);
if (rev) {
wn = pow_mod(wn, mod - 2);
}
for (int i = 0; i < n; i += l) {
int *x = a + i, *y = x + hl, w = 1;
for (int j = 0; j < hl; ++j, ++x, ++y, w = (long long)w * wn % mod) {
int t = (long long)w * *y % mod;
*y = (*x - t) % mod;
*x = (*x + t) % mod;
}
}
}
if (rev) {
int inv = pow_mod(n, mod - 2);
for (int i = 0; i < n; ++i) {
a[i] = (long long)a[i] * inv % mod;
}
}
return;
}
inline void mul(vector<int> &a, vector<int> &b, vector<int> &c) {
static int A[fft_maxn], B[fft_maxn];
int sa = a.size(), sb = b.size(), sc = sa + sb - 1, N = 1;
if (sa <= 20 && sb <= 20 || sa <= 5 || sb <= 5) {
static long long C[fft_maxn];
memset(C, 0, sizeof(C[0]) * sc);
for (int i = 0; i < sa; ++i) {
int &x = a[i];
long long *c = C + i;
for (int j = 0; j < sb; ++j) {
c[j] += (long long)x * b[j];
if ((j & 7) == 7) {
c[j] %= mod;
}
}
}
c.resize(sc);
for (int i = 0; i < sc; ++i) {
c[i] = C[i] % mod;
}
return;
}
while (N <= sc - 1) {
N <<= 1;
}
for (int i = 0; i < N; ++i) {
A[i] = (i < sa ? a[i] : 0);
B[i] = (i < sb ? b[i] : 0);
}
dft(N, A, 0);
dft(N, B, 0);
for (int i = 0; i < N; ++i) {
A[i] = (long long)A[i] * B[i] % mod;
}
dft(N, A, 1);
c.resize(sc);
for (int i = 0; i < sc; ++i) {
c[i] = A[i];
}
return;
}
inline void dfs(int u, int par) {
vector<vector<int> > p;
int sum = 0;
siz[u] = 1;
p.push_back(vector<int>{1});
for (int &v : g[u]) {
if (v != par) {
dfs(v, u);
ans = ((long long)sum * f[v] + ans) % mod;
sum = (sum + f[v]) % mod;
p.push_back(vector<int>{1, siz[v]});
siz[u] += siz[v];
while (p.size() > 1 && p.back().size() >= p[p.size() - 2].size()) {
mul(p.back(), p[p.size() - 2], p[p.size() - 2]);
p.pop_back();
}
}
}
while (p.size() > 1) {
mul(p.back(), p[p.size() - 2], p[p.size() - 2]);
p.pop_back();
}
auto &P = p[0];
for (int i = 0, i_end = min(k, (int)P.size() - 1); i <= i_end; ++i) {
f[u] = ((long long)P[i] * ifac[k - i] + f[u]) % mod;
}
f[u] = ((long long)f[u] * fac[k] + sum) % mod;
if (siz[u] < n) {
vector<int> foo = vector<int>{1, n - siz[u]};
mul(P, foo, P);
}
sort(g[u].begin(), g[u].end(), [&](int u, int v) {
if (u == par) {
return true;
}
if (v == par) {
return false;
}
return siz[u] < siz[v];
});
int SZ = P.size();
vector<int> nP(SZ - 1);
for (int i = 0; i < g[u].size(); ++i) {
if (g[u][i] != par) {
int &sz = siz[g[u][i]], val = 0;
nP[0] = P[0];
for (int j = 1; j < SZ - 1; ++j) {
nP[j] = ((long long)P[j] - (long long)nP[j - 1] * sz) % mod;
}
for (int j = 0, j_end = min(k, (int)nP.size() - 1); j <= j_end; ++j) {
val = ((long long)nP[j] * ifac[k - j] + val) % mod;
}
val = (long long)val * fac[k] % mod;
--i;
while (i + 1 < g[u].size() && siz[g[u][i + 1]] == sz) {
++i;
ans = ((long long)val * f[g[u][i]] + ans) % mod;
}
}
}
return;
}
int main() {
scanf("%d%d", &n, &k);
if (k == 1) {
printf("%d\n", ((long long)n * (n - 1) >> 1) % mod);
return 0;
}
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);
}
int N = max(n, k);
fac[0] = 1;
for (int i = 1; i <= N; ++i) {
fac[i] = (long long)fac[i - 1] * i % mod;
}
ifac[N] = pow_mod(fac[N], mod - 2);
for (int i = N; i; --i) {
ifac[i - 1] = (long long)ifac[i] * i % mod;
}
dfs(1, 0);
printf("%d\n", (ans + mod) % mod);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct SegTree {
int size;
vector<long long> seg;
SegTree() {}
SegTree(int size) {
this->size = size;
seg.resize(1 << (size + 1));
}
void init() {
for (int i = 0; i < (1 << (size + 1)); i++) seg[i] = 1e18;
}
void update(int i, long long val) {
i += (1 << size);
seg[i] = val;
while (i > 1) {
i /= 2;
seg[i] = min(seg[i * 2], seg[i * 2 + 1]);
}
}
long long query(int a, int b, int k, int l, int r) {
if (b < l || r < a) return 1e18;
if (a <= l && r <= b) return seg[k];
long long lval = query(a, b, k * 2, l, (l + r) / 2);
long long rval = query(a, b, k * 2 + 1, (l + r) / 2 + 1, r);
return min(lval, rval);
}
long long query(int a, int b) {
if (a > b) return 1e18;
return query(a, b, 1, 0, (1 << size) - 1);
}
};
long long n, a, b, c, d, s, len;
long long t[300005], q[300005];
long long h[300005], h2[300005];
SegTree seg(19), seg2(19);
void make(long long a, long long b, long long h[]) {
for (long long(i) = (1); (i) <= (n); (i)++) {
h[i] = h[i - 1];
if (q[i] == 1)
h[i] += a;
else
h[i] -= b;
}
}
bool check(long long x) {
long long l = lower_bound(t + 1, t + n + 1, x) - t;
long long r = lower_bound(t + 1, t + n + 1, x + len) - t - 1;
long long H = s;
if (seg.query(0, l - 1) + H < 0) return false;
H += h[l - 1];
if (seg2.query(l, r) - h2[l - 1] + H < 0) return false;
return true;
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> b >> c >> d >> s >> len;
for (long long(i) = (1); (i) <= (n); (i)++) cin >> t[i] >> q[i];
make(a, b, h);
make(c, d, h2);
seg.init(), seg2.init();
for (long long(i) = (0); (i) <= (n); (i)++)
seg.update(i, h[i]), seg2.update(i, h2[i]);
set<long long> S;
S.insert(0);
for (long long(i) = (1); (i) <= (n); (i)++)
S.insert(max(0LL, t[i] - len + 1));
for (long long(i) = (1); (i) <= (n); (i)++) S.insert(max(0LL, t[i] + 1));
for (auto x : S) {
if (check(x)) {
cout << x << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int N = 2e5 + 2, M = 2e5 + 2;
int n, m, s, w[N];
vector<pii> a[N];
pii e[M];
bool b[M];
int no[N];
ll ww[N];
bool re[N];
vector<int> aa[N];
int tmr = 0, tin[N], fup[N], lab[N], cnt;
bool used[M];
stack<int> stk;
void dfs(int u) {
tin[u] = fup[u] = ++tmr;
stk.push(u);
for (int i = 0; i < (int)a[u].size(); ++i) {
int v = a[u][i].first;
int p = a[u][i].second;
if (used[p]) continue;
used[p] = true;
if (tin[v] > 0) {
fup[u] = min(fup[u], tin[v]);
} else {
dfs(v);
fup[u] = min(fup[u], fup[v]);
}
}
if (fup[u] == tin[u]) {
++cnt;
while (true) {
int t = stk.top();
stk.pop();
lab[t] = cnt;
++no[cnt];
ww[cnt] += w[t];
if (u == t) break;
}
}
}
ll f[N][2];
void dfs1(int u, int p = 0) {
re[u] = no[u] > 1;
f[u][0] = f[u][1] = ww[u];
for (int v : aa[u])
if (v != p) {
dfs1(v, u);
f[u][0] += f[v][0];
re[u] |= re[v];
}
for (int v : aa[u])
if (v != p) {
f[u][1] = max(f[u][1], f[u][0] - f[v][0] + f[v][1]);
}
if (!re[u]) {
f[u][0] = 0;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> w[i];
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
a[u].emplace_back(v, i);
a[v].emplace_back(u, i);
e[i] = {u, v};
}
cin >> s;
dfs(s);
for (int i = 1; i <= m; ++i)
if (lab[e[i].first] != lab[e[i].second]) {
aa[lab[e[i].first]].push_back(lab[e[i].second]);
aa[lab[e[i].second]].push_back(lab[e[i].first]);
}
dfs1(lab[s]);
ll ans = max(f[lab[s]][0], f[lab[s]][1]);
cout << ans << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long arr[n];
vector<long long> a, b;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (int i = 0; i < n; i++) {
if (arr[i] == arr[i + 1] && arr[i + 1] == arr[i + 2]) {
cout << "NO\n";
return;
} else if (arr[i] == arr[i + 1]) {
a.push_back(arr[i]);
b.push_back(arr[i + 1]);
i++;
} else {
a.push_back(arr[i]);
}
}
cout << "YES\n";
reverse(b.begin(), b.end());
cout << a.size() << "\n";
for (auto i : a) {
cout << i << " ";
}
cout << "\n";
cout << b.size() << "\n";
for (auto i : b) {
cout << i << " ";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T;
T = 1;
for (int t = 0; t < T; t++) {
solve();
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define it register int
#define ct const int
#define il inline
using namespace std;
typedef long long ll;
#define rll register ll
#define cll const ll
const int N=1000005;
int n,m;
ll a[N],b[N],d,x;
il ll gcd(cll a,cll b){return !b?a:gcd(b,a%b);}
int main(){
scanf("%d%d",&n,&m);it i;
for(i=1;i<=n;++i) scanf("%lld",&a[i]);
std::sort(a+1,a+1+n);
for(i=2;i<=n;++i) d=gcd(a[i]-a[i-1],d);
for(i=1;i<=m;++i) scanf("%lld",&x),printf("%lld ",gcd(d,x+a[1]));
return 0;
}
//gcd(a+b,b)=gcd(a,b)
//gcd(a+x,b+x) = gcd(a-b,b+x) | 4 |
#include <bits/stdc++.h>
using namespace std;
bool double_equals(double a, double b, double epsilon = 0.001) {
return std::abs(a - b) < epsilon;
}
int main() {
long double a, b;
cin >> a >> b;
cout << std::setprecision(15);
cout << fixed;
long double l1 = pow(a, 1 / a) * (10000000000);
long double l2 = pow(b, 1 / b) * (10000000000);
if (l1 < l2) {
cout << "<";
} else if (l1 > l2) {
cout << ">";
} else {
cout << "=";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long a[600010];
map<long long, vector<pair<int, int>>> possiblex;
long long p2[600010];
void genp2() {
p2[0] = 1;
for (int i = 0; i++ < 600010 - 1;) {
p2[i] = p2[i - 1] * 2 % ((long long)1e9 + 7);
}
}
int dsu[600010];
int setcnt;
int findp(int u) {
if (dsu[u] == u) return u;
return dsu[u] = findp(dsu[u]);
}
void join(int u, int v) {
if (rand() & 1) swap(u, v);
u = findp(u);
v = findp(v);
if (u == v) return;
dsu[u] = v;
setcnt--;
}
int main() {
genp2();
srand((unsigned)time(0));
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i++ < n;) {
cin >> a[i];
dsu[i] = i;
}
for (int i = -1; ++i < m;) {
int u, v;
cin >> u >> v;
possiblex[a[u] ^ a[v]].push_back(pair<int, int>(u, v));
}
long long ans = (p2[k] - ((int)possiblex.size()) + ((long long)1e9 + 7)) %
((long long)1e9 + 7) * p2[n] % ((long long)1e9 + 7);
for (auto& i : possiblex) {
setcnt = n;
for (auto& f : i.second) {
join(f.first, f.second);
}
(ans += p2[setcnt]) %= ((long long)1e9 + 7);
for (auto& f : i.second) {
dsu[f.first] = f.first;
dsu[f.second] = f.second;
}
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, t;
bool ok(long long x) { return k <= (x * (x + 1)) / 2ll; }
long long bsrh() {
long long l = 1, r = n - 2;
while (l < r) {
long long mid = (l + r) / 2;
if (ok(mid)) {
r = mid;
} else {
l = mid + 1;
}
}
return l;
}
int main() {
cin >> t;
while (t--) {
string s = "";
cin >> n >> k;
if (k == 1) {
for (int i = 0; i < n - 2; i++) cout << "a";
cout << "bb\n";
continue;
} else if (k > (n - 2) * (n - 1) / 2ll) {
k -= ((n - 2) * (n - 1) / 2ll);
for (int i = 0; i < k - 1; i++) {
s += 'a';
}
s += 'b';
while (s.size() < n - 1) {
s += 'a';
}
s += 'b';
reverse(s.begin(), s.end());
} else {
long long ans = bsrh();
k -= (ans * (ans - 1)) / 2ll;
int blah = n - 2;
for (int i = 0; i <= blah - ans; i++) {
s += 'a';
}
s += 'b';
while (k < ans) {
k++;
s += 'a';
}
s += 'b';
while (s.size() != n) {
s += 'a';
}
}
cout << s << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
double p[1010][1010];
double du(int x) { return x; }
void f(int n, int m) {
if (p[n][m] > 0) return;
if (n == 0) {
p[0][m] = 1 / du(m + 1);
return;
}
if (m == 0) {
p[n][0] = 1;
return;
}
f(m - 1, n);
f(m, n - 1);
double a, b, c, d, pr;
a = m / du(m + 1) * (1. - p[m - 1][n]);
b = m / du(m + 1) * (1. - p[m - 1][n]) + 1. / du(m + 1);
c = 1.;
d = 1. - p[m][n - 1];
pr = (d - c) / (a + d - b - c);
p[n][m] = pr * a + (1. - pr) * c;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
f(n, m);
printf("%.9lf %.9lf", p[n][m], 1. - p[n][m]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; ++i) cin >> A.at(i);
int ans = 0, j = 1;
sort(A.begin(), A.end());
for (int i = 0; i < n; ++i) {
if (j >= n) break;
while (true) {
if (A.at(i) < A.at(j)) {
++j;
++ans;
break;
} else {
++j;
if (j >= n) break;
}
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100;
char s[maxn][maxn];
int main() {
int T;
cin >> T;
while (T--) {
int r, c;
cin >> r >> c;
for (int i = 1; i <= r; i++) scanf("%s", s[i] + 1);
int cnt = 0;
for (int i = 1; i <= r; i++)
for (int j = 1; j <= c; j++) {
if (s[i][j] == 'A') cnt++;
}
if (cnt == r * c) {
cout << "0" << endl;
continue;
}
if (cnt == 0) {
cout << "MORTAL" << endl;
continue;
}
int a = 0, b = 0, cc = 0, d = 0;
for (int i = 1; i <= c; i++) {
if (s[1][i] == 'A') a++;
if (s[r][i] == 'A') b++;
}
for (int i = 1; i <= r; i++) {
if (s[i][1] == 'A') cc++;
if (s[i][c] == 'A') d++;
}
if (a == c || b == c || cc == r || d == r) {
cout << 1 << endl;
continue;
} else if (s[1][1] == 'A' || s[1][c] == 'A' || s[r][c] == 'A' ||
s[r][1] == 'A') {
cout << 2 << endl;
continue;
}
int flag = 0;
for (int i = 2; i < r; i++) {
int cnt = 0;
if (flag) break;
for (int j = 1; j <= c; j++) {
if (s[i][j] == 'A') cnt++;
}
if (cnt == c) {
flag = 1;
break;
}
}
for (int i = 2; i < c; i++) {
int cnt = 0;
if (flag) break;
for (int j = 1; j <= r; j++) {
if (s[j][i] == 'A') cnt++;
}
if (cnt == r) {
flag = 1;
break;
}
}
if (flag) {
cout << 2 << endl;
continue;
}
for (int i = 1; i <= c; i++) {
if (s[1][i] == 'A' || s[r][i] == 'A') {
flag = 1;
break;
}
}
for (int i = 1; i <= r; i++) {
if (s[i][1] == 'A' || s[i][c] == 'A') {
flag = 1;
break;
}
}
if (flag) {
cout << "3" << endl;
continue;
}
cout << 4 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, tot, ans, lim;
char s[50];
int g[50][50], fa[50], size[50], id[50], p[50];
vector<int> a[50];
int lg[(1 << 23) + 5], f[(1 << 23) + 5], G[(1 << 23) + 5];
int find(int x) {
if (x != fa[x]) fa[x] = find(fa[x]);
return fa[x];
}
void link(int x, int y) {
int rx = find(x), ry = find(y);
fa[ry] = rx, size[rx] += size[ry];
}
int power(int x, int k) {
int res = 1;
while (k) {
if (k & 1) res = res * x;
x = x * x, k >>= 1;
}
return res;
}
void FWT(int *A, int opt) {
for (int mid = 1; mid < lim; mid <<= 1)
for (int R = mid << 1, j = 0; j < lim; j += R)
for (int k = 0; k < mid; k++)
if (opt == 1)
A[j + mid + k] = A[j + k] + A[j + mid + k];
else
A[j + mid + k] = A[j + mid + k] - A[j + k];
}
int IFWT(int i, int Lim) {
if (Lim == 1) return G[i];
return IFWT(i, Lim >> 1) - IFWT(i - Lim / 2, Lim >> 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) fa[i] = i, size[i] = 1;
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= n; j++)
if (i != j) {
if (s[j] == 'A') g[i][j] = 0, link(i, j);
if (s[j] == 'O') g[i][j] = 1;
if (s[j] == 'X') g[i][j] = 2;
}
}
for (int i = 1; i <= n; i++) {
fa[i] = find(fa[i]);
if (fa[i] == i) {
if (size[i] == 1) continue;
id[i] = ++tot;
}
}
if (tot == 0) return printf("%d", n - 1), 0;
for (int i = 1; i <= n; i++) a[id[fa[i]]].push_back(i);
for (int i = 1; i <= tot; i++) {
for (int u : a[i])
for (int v : a[i])
if (u != v)
if (g[u][v] == 2) return puts("-1"), 0;
for (int u : a[i])
for (int j = 1; j <= n; j++)
if (i != id[fa[j]] && g[u][j] == 2) p[i - 1] |= 1 << (id[fa[j]] - 1);
}
lim = 1 << tot;
for (int i = 2; i < lim; i++) lg[i] = lg[i >> 1] + 1;
f[0] = 1;
for (int i = 1; i < lim; i++) {
int u = lg[i & -i];
f[i] = f[i ^ (1 << u)] & (!(i & p[u]));
}
FWT(f, 1);
memcpy(G, f, sizeof(f));
for (int k = 1; k <= tot; k++) {
FWT(G, -1);
if (G[lim - 1] != 0) return printf("%d", n - 1 + k), 0;
FWT(G, 1);
for (int i = 0; i < lim; i++) G[i] = G[i] * f[i];
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n;
long long a[211111], t[211111];
void inc(int i, long long d) {
for (; i < n; i = (i | (i + 1))) t[i] += d;
}
long long get(int i) {
long long res = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) res += t[i];
return res;
}
long long sum(int l, int r) { return get(r) - get(l - 1); }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%I64d", a + i);
inc(i, a[i]);
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
if (a[i]) {
int k = n - i - 1;
ans += k - sum(i + 1, n - 1);
}
}
long long res = 0;
for (int i = n - 1; i >= 0; i--) {
if (!a[i]) {
res += sum(0, i - 1);
}
}
printf("%I64d", max(ans, res));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
class TOWER {
public:
int index;
int height;
bool operator<(const TOWER& Y) const { return height < Y.height; }
};
multiset<TOWER> s;
TOWER smallest, largest;
int main() {
ios_base::sync_with_stdio(0);
int n, k, x;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> x;
s.insert({i, x});
}
int m = 0;
vector<int> ans;
while (m < k) {
auto last = s.end();
last--;
smallest = *s.begin(), largest = *last;
if (smallest.height == largest.height ||
largest.height - smallest.height == 1) {
break;
} else {
s.erase(s.begin());
s.erase(last);
ans.push_back(largest.index);
ans.push_back(smallest.index);
smallest.height++;
largest.height--;
s.insert(smallest);
s.insert(largest);
m++;
}
}
auto last = s.end();
last--;
smallest = *s.begin(), largest = *last;
cout << largest.height - smallest.height << " " << m << "\n";
for (int i = 0; i < (int)ans.size(); i += 2) {
cout << ans[i] + 1 << " " << ans[i + 1] + 1 << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300000 + 5;
int mod = 998244353;
void add(long long &x, long long y) { (x += y) %= mod; }
void mul(long long &x, long long y) { (x *= y) %= mod; }
long long power(long long a, long long n) {
long long b = 1;
for (; n; n /= 2, mul(a, a)) {
if (n & 1) {
mul(b, a);
}
}
return b;
}
long long f[N][3];
vector<int> g[N];
void dfs(int u, int fa) {
long long prod02 = 1, prod0 = 1;
if (g[u].size() == 1 && fa != 0) {
f[u][1] = 1;
f[u][0] = 1;
return;
}
for (int v : g[u]) {
if (v != fa) {
dfs(v, u);
mul(prod02, (f[v][0] + f[v][2]) % mod);
mul(prod0, f[v][0]);
}
}
f[u][0] = prod0;
f[u][1] = prod02;
for (int v : g[u]) {
if (v != fa) {
add(f[u][2], prod02 * power((f[v][0] + f[v][2]) % mod, mod - 2) % mod *
f[v][1] % mod);
}
}
add(f[u][0], f[u][2]);
}
int main() {
int n;
scanf("%d", &n);
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, 0);
printf("%lld\n", f[1][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long ret = -1000000000000000000LL;
long long rv = ret;
long long dp[1000005];
int a[1000005];
long long get(int n) {
if (n < 0) return 0;
return dp[n];
}
void solve() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; ++i) {
ret = max(ret, get(i - 1) - a[i]);
rv = max(rv, get(i - 1) + a[i]);
dp[i] = max(0LL, ret + a[i]);
dp[i] = max(dp[i], rv - a[i]);
}
cout << dp[n - 1] << endl;
}
int main() {
ios::sync_with_stdio(false);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
void solve() {
string s;
cin >> s;
vector<long long> v(26, 0);
for (long long i = 0; i < s.size(); i++) v[s[i] - 'a']++;
long long cnt1 = 0, cnt2 = 0;
for (long long i = 0; i < 26; i++) {
if (v[i] >= 2)
cnt2++;
else if (v[i] == 1)
cnt1++;
}
long long ans = cnt1 / 2 + cnt2;
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1e5 + 10;
struct node {
string ss;
char cnt;
int num;
void change(char c) {
num++;
int len = ss.size();
if (len < 10) {
ss = c + ss;
} else {
if (ss[5] == '.') {
for (int i = 4; i >= 1; --i) {
ss[i] = ss[i - 1];
}
ss[0] = c;
} else {
for (int i = 4; i >= 1; --i) {
ss[i] = ss[i - 1];
}
ss[0] = c;
for (int i = 5; i <= 7; ++i) {
ss[i] = '.';
}
}
}
}
void push_front(char c) {
if (ss.empty()) {
return;
} else {
if (ss[0] < c) {
return;
} else if (ss[0] > c) {
cnt = ss[0];
change(c);
change(c);
} else {
if (cnt != 'A' && cnt > c) {
change(c);
change(c);
}
}
}
}
};
node ans[max_n];
int main() {
string s;
cin >> s;
int len = s.size();
ans[len].cnt = 'A';
ans[len].ss = "";
ans[len].num = 0;
ans[len - 1].ss.push_back(s[len - 1]);
ans[len - 1].cnt = 'A';
ans[len - 1].num = 1;
for (int i = len - 2; i >= 0; --i) {
if (s[i] == s[i + 1]) {
ans[i] = ans[i + 2];
ans[i].push_front(s[i]);
} else {
ans[i] = ans[i + 1];
if (ans[i + 1].ss[0] != s[i]) {
ans[i].cnt = ans[i + 1].ss[0];
}
ans[i].change(s[i]);
}
}
for (int i = 0; i < len; ++i) {
printf("%d ", ans[i].num);
cout << ans[i].ss << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
int b[100005];
int buscar(int len, int p) {
int l, r, mid;
l = 1, r = len, mid = (l + r) >> 1;
while (l <= r) {
if (p > b[mid])
l = mid + 1;
else if (p < b[mid])
r = mid - 1;
else
return mid;
mid = (l + r) >> 1;
}
return l;
}
int tmp() {
int i, j, len = 1;
b[1] = a[0];
for (i = 1; i < n; i++) {
j = buscar(len, a[i]);
b[j] = a[i];
if (j >= len) len = j;
}
return len;
}
int main() {
int i;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
cout << tmp();
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 110, TOF = 550000;
long long n, m, k, u, v, x, y, t, a, b, ans;
long long A[MAXN];
int dp[MAXN][TOF];
long long solve(int i, long long j) {
if (j < TOF && dp[i][j] != -1) return dp[i][j];
if (i == 0) return j;
if (j <= 1) return j;
long long ans = solve(i - 1, j) - solve(i - 1, j / A[i]);
if (j < TOF) dp[i][j] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(dp, -1, sizeof(dp));
cin >> n >> k;
for (int i = 1; i <= k; i++) cin >> A[i];
sort(A + 1, A + k + 1);
if (A[1] == 1) return cout << 0 << '\n', 0;
cout << solve(k, n);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long k, m, n, a, j = 1, i, b;
vector<int> v;
set<int> s;
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> a;
s.insert(a);
}
i = 0;
while (b + j <= m) {
if (s.find(j) != s.end()) {
j++;
continue;
}
v.push_back(j);
b += j;
j++;
}
cout << v.size() << endl;
for (auto I : v) cout << I << " ";
}
| 2 |
#include <bits/stdc++.h>
long long n, ans, num, sum;
const long long mod = 1000000007ll;
long long pow(long long a, long long b) {
long long r = 1ll;
while (b) {
if (b & 1) r = r * a % mod;
a = a * a % mod;
b >>= 1;
}
return r % mod;
}
int main() {
scanf("%I64d", &n);
num = pow(27ll, n);
sum = pow(7ll, n);
if (num < sum) num = num + mod;
printf("%I64d\n", (num - sum) % mod);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool flg;
int l, r, q, n, ans[100];
char b[200];
string a;
void solve(string s) {
int cp = 0, dp = 1, len = (int)s.length() - 1;
while (0 <= cp && cp <= len) {
flg = 0;
if ('0' <= s[cp] && s[cp] <= '9') {
int x = s[cp] - '0';
s[cp]--;
ans[x]++;
if ('0' > s[cp]) flg = 1;
} else {
if (s[cp] == '<')
dp = -1;
else if (s[cp] == '>') {
dp = 1;
}
if (cp + dp >= 0 && cp + dp < s.length() &&
(s[cp + dp] == '<' || s[cp + dp] == '>') &&
(s[cp] == '<' || s[cp] == '>'))
flg = 1;
}
if (flg) {
s.erase(cp, 1);
if (dp == -1) cp--;
} else
cp += dp;
}
for (int i = 0; i < 10; i++) {
cout << ans[i] << " ";
ans[i] = 0;
}
cout << endl;
}
int main(int argc, const char* argv[]) {
cin >> n >> q;
cin >> a;
for (int i = 0; i < q; i++) {
cin >> l >> r;
cerr << a.substr(l - 1, r - l + 1) << endl;
solve(a.substr(l - 1, r - l + 1));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,a,b;
string s;
cin>>n>>a>>b>>s;
vector<char> aa(n);
for(int i=0;i<n;i++)
aa[i]=s[i];
sort(aa.begin(),aa.end());
aa.erase(unique(aa.begin(),aa.end()),aa.end());
int m=aa.size();
vector<int> v(n);
for(int i=0;i<n;i++)
v[i]=lower_bound(aa.begin(),aa.end(),s[i])-aa.begin();
vector<int> l(m,n),r(m),cnt(m),p(m);
for(int i=0;i<n;i++)
{
l[v[i]]=min(l[v[i]],i);
r[v[i]]=i;
cnt[v[i]]++;
}
iota(p.begin(),p.end(),0);
sort(p.begin(),p.end(),[&](int i,int j)
{
return l[i]<l[j];
});
vector<bool> f(1<<m);
f[0]=1;
for(int s=1;s<(1<<m);s++)
{
int high=-1,low=n,cc=0;
bool ff=0;
for(int i=0;i<m;i++)
if(s>>i&1)
{
ff=ff or f[s^(1<<i)];
high=max(high,r[i]);
low=min(low,l[i]);
cc+=cnt[i];
}
if(ff and a*(high-low+1)<=cc*b)
f[s]=1;
int type=0;
for(int i=0;i<m;i++)
if(s>>p[i]&1)
{
type|=1<<p[i];
f[s]=f[s] or (f[type] and f[s^type]);
}
}
vector<char> ans;
for(int i=0;i<m;i++)
if(f[(1<<m)-(1<<i)-1])
ans.push_back(aa[i]);
cout<<ans.size()<<' ';
for(auto x:ans)
cout<<x<<' ';
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
double ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (i - 1 >= 0) ans += pow(a[i], 2) - pow(a[i - 1], 2);
i--;
}
if (n % 2 != 0) ans += pow(a[0], 2);
cout << fixed << setprecision(10) << 3.1415926536 * ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long MAX = 1e7 + 5;
const long long INF = 1e9 + 5;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
bool b[2 * 10005][11];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> b[i][j];
}
int arr[2 * 10005];
memset(arr, 0, sizeof arr);
int chat[11];
memset(chat, 0, sizeof chat);
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
arr[x - 1]--;
chat[y - 1]++;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (b[i][j]) arr[i] += chat[j];
}
}
for (int i = 0; i < n; i++) cout << arr[i] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const long long int MAX = 1e9 + 7;
void array_show(int *array, int array_n, char middle = ' ') {
for (int i = 0; i < array_n; i++)
printf("%d%c", array[i], (i != array_n - 1 ? middle : '\n'));
}
void array_show(long long int *array, int array_n, char middle = ' ') {
for (int i = 0; i < array_n; i++)
printf("%lld%c", array[i], (i != array_n - 1 ? middle : '\n'));
}
void array_show(vector<int> &vec_s, int vec_n = -1, char middle = ' ') {
if (vec_n == -1) vec_n = vec_s.size();
for (int i = 0; i < vec_n; i++)
printf("%d%c", vec_s[i], (i != vec_n - 1 ? middle : '\n'));
}
void array_show(vector<long long int> &vec_s, int vec_n = -1,
char middle = ' ') {
if (vec_n == -1) vec_n = vec_s.size();
for (int i = 0; i < vec_n; i++)
printf("%lld%c", vec_s[i], (i != vec_n - 1 ? middle : '\n'));
}
int t[110000];
int num[1100000];
int main() {
int n, m;
int i, j, k;
int a, b, c;
cin >> n >> m;
int cnt = 0;
for (i = 0; i < n; i++) {
cin >> t[i];
}
for (i = n - 1; i >= 0; i--) {
if (t[i] == m) {
cnt++;
continue;
}
if (num[t[i]] < cnt) num[t[i]]++;
}
for (i = 1; i <= 1e6; i++) {
if (i == m) continue;
if (num[i] >= cnt) {
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[1010], b[1010], dp[1010];
struct ro {
int w, b;
vector<int> t;
} c[1010];
int father[1010];
int find(int x) {
if (father[x] == x) return x;
return father[x] = find(father[x]);
}
void Union(int x, int y) {
x = find(x);
y = find(y);
if (x > y) father[x] = y;
if (x < y) father[y] = x;
}
int main() {
int n, m, w;
scanf("%d%d%d", &n, &m, &w);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
int x, y;
for (int i = 1; i <= n; i++) father[i] = i;
while (m--) {
scanf("%d%d", &x, &y);
Union(x, y);
}
for (int i = 1; i <= n; i++) c[i].b = 0, c[i].w = 0;
for (int i = 1; i <= n; i++) {
x = find(i);
c[x].b += b[i];
c[x].w += a[i];
c[x].t.push_back(i);
}
vector<ro> p;
for (int i = 1; i <= n; i++)
if (c[i].b != 0) p.push_back(c[i]);
memset(dp, 0, sizeof(dp));
for (int i = 0; i < p.size(); i++) {
for (int j = w; j >= 0; j--) {
if (j - p[i].w >= 0) dp[j] = max(dp[j], dp[j - p[i].w] + p[i].b);
x = p[i].t.size();
for (int k = 0; k < x; k++) {
y = p[i].t[k];
if (j - a[y] >= 0) dp[j] = max(dp[j], dp[j - a[y]] + b[y]);
}
}
}
printf("%d\n", dp[w]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int maxn = 100505;
long long ans[maxn][3];
long long ansr[maxn][3];
int ansp[maxn][3][5];
struct node1 {
int c, s, z;
} a[maxn], b[maxn];
bool cmp1(node1 a, node1 b) {
if (a.s != b.s)
return a.s < b.s;
else
return a.c < b.c;
}
void work() {
int k, j = 1;
for (int i = 1; i <= n; i++) {
if (ans[i][0] < ans[i - 1][0]) {
ans[i][0] = ans[i - 1][0];
ansp[i][0][2] = i - 1;
ansp[i][0][3] = 0;
ansp[i][0][4] = ansp[i - 1][0][4];
}
if (ans[i][0] < ans[i - 1][1]) {
ans[i][0] = ans[i - 1][1];
ansp[i][0][2] = i - 1;
ansp[i][0][3] = 1;
ansp[i][0][4] = ansp[i - 1][1][4];
}
if (ans[i][0] < ans[i - 1][2]) {
ans[i][0] = ans[i - 1][2];
ansp[i][0][2] = i - 1;
ansp[i][0][3] = 2;
ansp[i][0][4] = ansp[i - 1][2][4];
}
while (a[i].s - 1 > b[j].s) j++;
for (k = j; k <= m && a[i].s - 1 == b[k].s; k++)
if (a[i].c <= b[k].c) {
if (ans[i][1] < ans[i - 1][0] + a[i].c) {
ans[i][1] = ans[i - 1][0] + a[i].c;
ansr[i][1] = k;
ansp[i][1][0] = b[k].z;
ansp[i][1][1] = a[i].z;
ansp[i][1][2] = i - 1;
ansp[i][1][3] = 0;
ansp[i][1][4] = ansp[i - 1][0][4] + 1;
}
if (ans[i][1] < ans[i - 1][1] + a[i].c) {
ans[i][1] = ans[i - 1][1] + a[i].c;
ansr[i][1] = k;
ansp[i][1][0] = b[k].z;
ansp[i][1][1] = a[i].z;
ansp[i][1][2] = i - 1;
ansp[i][1][3] = 1;
ansp[i][1][4] = ansp[i - 1][1][4] + 1;
}
if (k != ansr[i - 1][2] && ans[i][1] < ans[i - 1][2] + a[i].c) {
ans[i][1] = ans[i - 1][2] + a[i].c;
ansr[i][1] = k;
ansp[i][1][0] = b[k].z;
ansp[i][1][1] = a[i].z;
ansp[i][1][2] = i - 1;
ansp[i][1][3] = 2;
ansp[i][1][4] = ansp[i - 1][2][4] + 1;
}
}
j = k;
for (k = j; k <= m && a[i].s == b[k].s; k++)
if (a[i].c <= b[k].c) {
if (ans[i][2] < ans[i - 1][0] + a[i].c) {
ans[i][2] = ans[i - 1][0] + a[i].c;
ansr[i][2] = k;
ansp[i][2][0] = b[k].z;
ansp[i][2][1] = a[i].z;
ansp[i][2][2] = i - 1;
ansp[i][2][3] = 0;
ansp[i][2][4] = ansp[i - 1][0][4] + 1;
}
if (ans[i][2] < ans[i - 1][1] + a[i].c) {
ans[i][2] = ans[i - 1][1] + a[i].c;
ansr[i][1] = k;
ansp[i][2][0] = b[k].z;
ansp[i][2][1] = a[i].z;
ansp[i][2][2] = i - 1;
ansp[i][2][3] = 1;
ansp[i][2][4] = ansp[i - 1][1][4] + 1;
}
if (ans[i][2] < ans[i - 1][2] + a[i].c) {
ans[i][2] = ans[i - 1][2] + a[i].c;
ansr[i][1] = k;
ansp[i][2][0] = b[k].z;
ansp[i][2][1] = a[i].z;
ansp[i][2][2] = i - 1;
ansp[i][2][3] = 2;
ansp[i][2][4] = ansp[i - 1][2][4] + 1;
}
}
}
}
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].c, &a[i].s);
a[i].z = i;
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &b[i].c, &b[i].s);
b[i].z = i;
}
sort(a + 1, a + n + 1, cmp1);
sort(b + 1, b + 1 + m, cmp1);
}
int main() {
init();
work();
long long mm = 0;
int m1 = 0, m2 = 0;
for (int i = 0; i < 3; i++)
if (ans[n][i] > mm) {
mm = ans[n][i];
m1 = n;
m2 = i;
}
printf("%I64d\n", mm);
if (mm != 0) {
int l = ansp[m1][m2][4];
printf("%d\n", l);
while (l) {
if (m2 != 0) {
l--;
printf("%d %d\n", ansp[m1][m2][0], ansp[m1][m2][1]);
}
int i, j;
i = ansp[m1][m2][2];
j = ansp[m1][m2][3];
m1 = i;
m2 = j;
}
} else
printf("%d\n", 0);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000 + 100;
const int maxm = 2000000 + 100;
const int maxt = 3000000 + 100;
const int maxk = 10 + 3;
const long long unit = 1LL;
const int INF = 0x3f3f3f3f;
const long long Inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-3;
const double inf = 1e15;
const double pi = acos(-1.0);
const long long mod = 1000000007LL;
inline long long read() {
long long x = 0;
bool t = false;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = true, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return t ? -x : x;
}
int a, b;
char str[maxn];
int main() {
int T;
T = read();
while (T--) {
a = read(), b = read();
scanf("%s", str + 1);
int n = strlen(str + 1);
bool ok = true;
int cnt = 0, cnt1 = 0, x = 0;
for (int i = 1; i <= n; ++i) {
if (str[i] == '.') {
int j = i;
while (j <= n && str[j] == '.') ++j;
--j;
int len = j - i + 1;
if (len < b) continue;
if ((len < a) || (a + 4 * b - 1 <= len)) {
ok = false;
break;
}
if (a <= len && len < b + b) ++cnt1;
if (len >= b + b && len >= a) ++cnt, x = len;
i = j;
}
}
if (!ok || (cnt >= 2)) {
printf("NO\n");
continue;
}
if (cnt == 0) {
if (cnt1 & 1)
printf("YES\n");
else
printf("NO\n");
} else {
ok = false;
for (int l = 0; l <= x && l < 2 * b; ++l) {
if (b <= l && l < a) continue;
int r = x - l - a;
if (b <= r && r < a) continue;
if (r < 0) break;
if (r >= 2 * b) continue;
int tmp = cnt1;
if (a <= l) ++tmp;
if (a <= r) ++tmp;
if (!(tmp & 1)) {
ok = true;
break;
}
}
if (ok)
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e6 + 10;
const int mod = 1e9 + 7;
const long long int inf = 1LL << 62;
int fq[300];
int main() {
int n, k;
string str;
cin >> n >> k >> str;
for (char ch : str) {
fq[ch]++;
if (fq[ch] > k) {
printf("NO\n");
goto outer;
}
}
printf("YES\n");
outer:;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const double PI = acos(-1.0);
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
inline T Min(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline T Max(T a, T b) {
return a > b ? a : b;
}
using namespace std;
int n, m;
int mmin[3], mmax[3];
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < 3; i++) {
scanf("%d%d", &mmin[i], &mmax[i]);
n -= mmin[i];
mmax[i] -= mmin[i];
}
for (int i = 0; i < 3; i++) {
if (n < mmax[i]) {
mmin[i] += n;
n = 0;
} else {
n -= mmax[i];
mmin[i] += mmax[i];
}
printf("%d ", mmin[i]);
}
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int query(int y) {
cout << y << "\n";
fflush(stdout);
int t;
cin >> t;
if (t == 0 || t == -2) exit(0);
return t;
}
int main() {
int m, n;
cin >> m >> n;
int p[n];
for (int i = 0; i < n; i++) {
int t = query(1);
p[i] = t == 1;
}
int l = 2, r = m;
for (int q = 0;; q++) {
int y = (l + r) / 2;
int t = query(y);
if (!p[q % n]) t *= -1;
if (t == 1)
l = y + 1;
else
r = y - 1;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long abs1(long long x) {
if (x < 0) {
return -x;
}
return x;
}
int main() {
long long n, k, p, i, j, answer = 0, answer2 = 1e18, cnt, places[10005],
keys[10005];
cin >> n >> k >> p;
for (i = 0; i < n; i++) {
cin >> places[i];
}
for (i = 0; i < k; i++) {
cin >> keys[i];
}
sort(places, places + n);
sort(keys, keys + k);
for (i = 0; i <= k - n; i++) {
answer = 0;
cnt = 0;
for (j = i; j < (i + n); j++) {
answer = max(answer, (abs1(places[cnt] - keys[j]) + abs1(keys[j] - p)));
;
cnt++;
}
answer2 = min(answer2, answer);
}
cout << answer2;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 11;
int main() {
int n, k;
cin >> n >> k;
int stat = 0;
deque<pair<int, int> > d;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
stat += a / 10;
d.push_back(make_pair(a % 10, a));
}
sort(d.begin(), d.end());
reverse(d.begin(), d.end());
while (k > 0 and d.size() > 0) {
if (k >= 10 - d[0].first) {
stat++;
k -= 10 - d[0].first;
d[0].second += 10 - d[0].first;
d[0].first = 0;
d.push_back(d[0]);
d.pop_front();
} else
break;
if (d[0].second == 100) d.pop_front();
}
if (stat > 10 * n) stat = 10 * n;
cout << stat << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000 + 5;
int d[maxn], n, m;
int to[maxn * 2], head[maxn], nex[maxn * 2], tol;
void insert(int u, int v) {
++tol, to[tol] = v, nex[tol] = head[u], head[u] = tol;
++tol, to[tol] = u, nex[tol] = head[v], head[v] = tol;
}
int p, ans[maxn * 2], vis[maxn], cnt;
int dfs(int u) {
vis[u] = 1;
for (int i = head[u]; i; i = nex[i]) {
if (!vis[to[i]]) {
if (dfs(to[i])) {
ans[i] = 1;
cnt++;
if (d[u] != 2) {
d[u] ^= 1;
}
}
}
}
return d[u];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1, x; i <= n; i++) {
cin >> x;
if (x == -1) p = i;
if (x == -1)
d[i] = 2;
else
d[i] = x;
}
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
insert(u, v);
}
if (p)
dfs(p);
else if (dfs(1) & 1) {
cout << -1 << "\n";
return 0;
}
cout << cnt << "\n";
for (int i = 1; i <= tol; i += 2)
if (ans[i] || ans[i + 1]) cout << (i + 1) / 2 << ' ';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string out(int sum) {
string s;
s = "";
while (sum > 0) {
s.push_back('0' + sum % 10);
sum /= 10;
}
reverse(s.begin(), s.end());
return s;
}
string tall;
int ans;
bool back(string s, int p, int sum, vector<bool> add, int last) {
if (p == s.size()) {
sum += last;
int csum = sum;
int sumd = 0;
while (csum > 0) {
sumd += csum % 10;
csum /= 10;
}
if (sumd < 10) {
cout << tall << endl;
for (int i = 0; i < int(s.size()); ++i) {
cout << s[i];
if (add[i]) cout << "+";
}
cout << endl;
string s = out(sum);
for (int i = 0; i < int(s.size()); ++i) {
if (i) cout << "+";
cout << s[i];
sum += s[i] - '0';
}
cout << endl;
exit(0);
}
return false;
}
if (back(s, p + 1, sum, add, last * 10 + (s[p] - '0'))) return true;
if (p != s.size() - 1) {
add[p] = true;
return back(s, p + 1, sum + last * 10 + (s[p] - '0'), add, 0);
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int sum = 0;
string s;
cin >> s;
srand(12345);
while (true) {
int cnt = 0;
int sum = 0, last = 0;
tall = "";
for (int i = 0; i < int(s.size()); ++i) {
last = last * 10 + s[i] - '0';
tall.push_back(s[i]);
if ((cnt >= 2 or rand() % 2 == 1) and i != s.size() - 1) {
tall.push_back('+');
sum += last;
cnt = 0;
last = 0;
} else
++cnt;
}
sum += last;
back(out(sum), 0, 0, vector<bool>(s.size(), false), 0);
}
return 0;
for (int i = 0; i < n; ++i) {
if (i) cout << "+";
cout << s[i];
sum += s[i] - '0';
}
cout << endl;
s = out(sum);
sum = 0;
for (int i = 0; i < int(s.size()); ++i) {
if (i) cout << "+";
cout << s[i];
sum += s[i] - '0';
}
cout << endl;
s = "";
while (sum > 0) {
s.push_back('0' + sum % 10);
sum /= 10;
}
reverse(s.begin(), s.end());
for (int i = 0; i < int(s.size()); ++i) {
if (i) cout << "+";
cout << s[i];
sum += s[i] - '0';
}
cout << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double e = 2.718281828;
void ox90() {
ios_base::sync_with_stdio(false);
cin.tie(0);
}
vector<string> G;
const int di[]{1, 0, -1, 0};
const int dj[]{0, 1, 0, -1};
bool visit[1501][1501];
int n, m, win = 0, a, b, xplane[1501][1501], yplane[1501][1501];
void dfs(int I, int J, int a, int b) {
if (I == -1) I = n - 1;
if (I == n) I = 0;
if (J == -1) J = m - 1;
if (J == m) J = 0;
if (G[I][J] == '#') return;
if (visit[I][J]) {
if (xplane[I][J] != a or yplane[I][J] != b) {
win = 1;
return;
}
return;
}
visit[I][J] = 1;
xplane[I][J] = a, yplane[I][J] = b;
for (int k = 0; k < 4; k++) dfs(I + di[k], J + dj[k], a + di[k], b + dj[k]);
}
int main() {
ox90();
char c;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
for (int j = 0; j < m; j++) {
cin >> c;
if (isalpha(c)) {
a = i;
b = j;
}
s += c;
}
G.push_back(s);
}
dfs(a, b, a, b);
if (win)
printf("YES\n");
else
printf("NO\n");
}
| 6 |
#include <bits/stdc++.h>
int flag[50000];
char s[10];
int n, res;
int x, y, t;
int main() {
memset(flag, 0, sizeof(flag));
res = 0;
scanf("%d", &n);
while (n--) {
scanf("%d", &x);
scanf("%d", &y);
t = x * 100 + (y % 10) * 10 + y / 10;
if (flag[t] == 0) {
for (int i = 0; i < 4; i++) {
flag[t] = 1;
t = (t % 1000) * 10 + t / 1000;
}
res++;
}
if (n != 0) scanf("%s", s);
}
printf("%d", res);
scanf("%d");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const long long MOD = 1e9 + 7;
void solve() {
int k;
cin >> k;
if (k % 2 == 0) {
cout << (1ll << k / 2) << "\n";
return;
}
cout << 0 << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
multiset<long long int> ans;
stack<long long int> table;
int main() {
std::ios::sync_with_stdio(false);
string s = "";
string str;
long long int i = 0;
while (cin >> str) {
s += str;
i++;
if (i == 10) break;
}
long long int l = 0;
long long int si = s.size();
while (l < si) {
if (s[l + 1] == '/') {
if (s.substr(l, 5) == "</td>")
l += 5;
else if (s.substr(l, 5) == "</tr>")
l += 5;
else if (s.substr(l, 8) == "</table>") {
l += 8;
ans.insert(table.top());
table.pop();
}
} else {
if (s.substr(l, 4) == "<td>") {
l += 4;
table.top()++;
} else if (s.substr(l, 4) == "<tr>")
l += 4;
else if (s.substr(l, 7) == "<table>") {
table.push(0);
l += 7;
}
}
}
for (auto e : ans) cout << e << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int to[2 * N], nxt[2 * N], head[N], size[N], ans[N][5], n, u, v, rt, cnt, flag,
tot, id, ii, a, b, c, m, d;
inline void add(int u, int v) {
to[++cnt] = v;
nxt[cnt] = head[u];
head[u] = cnt;
}
inline void dfs1(int u, int fa) {
size[u] = 1;
int flag = 1;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
dfs1(v, u);
size[u] += size[v];
if (size[v] > n / 2) flag = 0;
}
if (n - size[u] > n / 2) flag = 0;
if (flag) rt = u;
}
inline void dfs2(int u, int fa) {
size[u] = 1;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
dfs2(v, u);
size[u] += size[v];
}
}
inline void print1(int u, int fa) {
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
ans[++m][1] = u, ans[m][2] = v, ans[m][3] = c * (a + 1) - d, d += ans[m][3],
c++;
int t = ans[m][3];
print1(v, u);
d -= t;
}
}
inline void print2(int u, int fa) {
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
ans[++m][1] = u, ans[m][2] = v, ans[m][3] = c - d, d += ans[m][3], c++;
int t = ans[m][3];
print2(v, u);
d -= t;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
dfs1(1, 0);
dfs2(rt, 0);
for (int i = head[rt]; i; i = nxt[i]) {
if (size[to[i]] >= (n + 1) / 3) {
flag = 1;
id = to[i];
break;
}
tot += size[to[i]];
if (tot >= (n + 1) / 3) {
flag = 2;
id = to[i];
break;
}
}
if (flag == 1) {
b = size[id];
a = n - b - 1;
ans[++m][1] = rt, ans[m][2] = id, ans[m][3] = a + 1;
c = 2;
d = a + 1;
print1(id, rt);
c = 1;
d = 0;
for (int i = head[rt]; i; i = nxt[i]) {
int v = to[i];
if (v == id) continue;
ans[++m][1] = rt, ans[m][2] = v, ans[m][3] = c - d, d += ans[m][3], c++;
int t = ans[m][3];
print2(v, rt);
d -= t;
}
} else {
a = tot;
b = n - tot - 1;
c = 1;
d = 0;
for (int i = head[rt]; i; i = nxt[i]) {
int v = to[i];
ans[++m][1] = rt, ans[m][2] = v, ans[m][3] = c - d, d += ans[m][3], c++;
int t = ans[m][3];
print2(v, rt);
d -= t;
if (v == id) {
ii = nxt[i];
break;
}
}
c = 1;
d = 0;
for (int i = ii; i; i = nxt[i]) {
int v = to[i];
ans[++m][1] = rt, ans[m][2] = v, ans[m][3] = c * (a + 1) - d,
d += ans[m][3], c++;
int t = ans[m][3];
print1(v, rt);
d -= t;
}
}
for (int i = 1; i <= m; i++)
printf("%d %d %d\n", ans[i][1], ans[i][2], ans[i][3]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int N = 2e5 + 10;
const int mod = 998244353;
using namespace std;
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
if (a.first < b.first) {
if (a.second > b.first) a.second = b.first;
return a;
} else {
if (b.second > a.first) b.second = a.first;
return b;
}
}
struct Seg {
static const int N = ::N << 2;
pair<int, int> mi[N], ans;
void init(int n) {
for (int i = n << 2 | 1; i >= 0; --i) mi[i] = {0x3f3f3f3f, 0x3f3f3f3f};
}
void Query(int L, int R, int l, int r, int rt) {
if (L <= l && R >= r) {
ans = mi[rt] + ans;
return;
}
int mid = (l + r) >> 1;
if (L <= mid) Query(L, R, l, mid, rt << 1);
if (R > mid) Query(L, R, mid + 1, r, rt << 1 | 1);
}
pair<int, int> query(int L, int R, int l, int r, int rt) {
ans = {0x3f3f3f3f, 0x3f3f3f3f};
Query(L, R, l, r, rt);
return ans;
}
void update(int p, int val, int l, int r, int rt) {
if (l == r) {
mi[rt] = {val, 0x3f3f3f3f};
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
update(p, val, l, mid, rt << 1);
else
update(p, val, mid + 1, r, rt << 1 | 1);
mi[rt] = mi[rt << 1] + mi[rt << 1 | 1];
}
} seg[9];
int n, m;
void update(int p, int x) {
for (int i = 0, k = x; i < 9; ++i, k /= 10) {
if (k % 10)
seg[i].update(p, x, 1, n, 1);
else
seg[i].update(p, 0x3f3f3f3f, 1, n, 1);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < 9; ++i) seg[i].init(n);
for (int i = 1, x; i <= n; ++i) scanf("%d", &x), update(i, x);
while (m--) {
int op, x, y;
scanf("%d%d%d", &op, &x, &y);
if (op == 1)
update(x, y);
else {
int ans = 0x3f3f3f3f + 0x3f3f3f3f;
for (int i = 0; i < 9; ++i) {
pair<int, int> p = seg[i].query(x, y, 1, n, 1);
if (p.first != 0x3f3f3f3f && p.second != 0x3f3f3f3f)
ans = min(ans, p.first + p.second);
}
if (ans != 0x3f3f3f3f + 0x3f3f3f3f)
printf("%d\n", ans);
else
puts("-1");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool cmp_pair_F_2(pair<int, int> x, pair<int, int> y) {
return x.first > y.first;
}
bool cmp_pair_S_2(pair<int, int> x, pair<int, int> y) {
return x.second > y.second;
}
bool cmp_pair_S_1(pair<int, int> x, pair<int, int> y) {
return x.second < y.second;
}
bool cmp(int x, int y) { return x > y; }
int lis(vector<int> v) {
int n = v.size();
vector<int> dp(n + 10, 1e6);
for (int i = 0; i < n; i++) {
vector<int>::iterator it = upper_bound(dp.begin(), dp.end(), v[i]);
dp[it - dp.begin()] = min(dp[it - dp.begin()], v[i]);
}
return lower_bound(dp.begin(), dp.end(), 1e6) - dp.begin();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int i, j;
int n, t;
cin >> n >> t;
int a[n];
vector<int> m(500, 0);
for (i = 0; i < n; i++) cin >> a[i], m[a[i]]++;
vector<int> v;
for (i = 0; i < min(t, 100); i++)
for (j = 0; j < n; j++) v.push_back(a[j]);
if (t <= 100)
cout << lis(v);
else {
int num = 0;
for (i = 0; i < 500; i++)
if (m[i] > num) num = max(m[i], num);
cout << lis(v) + (t - 100) * num;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int xx[4][5] = {
{0, 0, 0, 1, 2}, {0, 1, 1, 1, 2}, {0, 1, 2, 2, 2}, {0, 1, 1, 1, 2}};
int yy[4][5] = {
{0, 1, 2, 1, 1}, {2, 0, 1, 2, 2}, {1, 1, 0, 1, 2}, {0, 0, 1, 2, 0}};
struct num {
int x, y, z;
};
int l[(20 * 20 * 25)], r[(20 * 20 * 25)], d[(20 * 20 * 25)], u[(20 * 20 * 25)],
c[(20 * 20 * 25)], add[(20 * 20 * 25)], s[(20 * 20)], tmp[(20 * 20)];
num o[100], name[(20 * 20 * 25)], best[100];
int bb[20][20];
char out[20][20];
int n, m, i, j, k, i1, len = 0, ans = 0, ss = 0;
inline int calc(int x, int y) { return (x - 1) * m + y; }
void remove(int x) {
l[r[x]] = l[x];
r[l[x]] = r[x];
for (int i = d[x]; i != x; i = d[i]) {
for (int j = r[i]; j != i; j = r[j]) {
u[d[j]] = u[j];
d[u[j]] = d[j];
s[c[j]]--;
ss++;
}
}
}
void resume(int x) {
for (int i = u[x]; i != x; i = u[i])
for (int j = l[i]; j != i; j = l[j]) {
u[d[j]] = j;
d[u[j]] = j;
s[c[j]]++;
ss++;
}
l[r[x]] = x;
r[l[x]] = x;
}
void dfs(int t) {
if (ss > 70000000) return;
if (!r[0]) {
if (t > ans) {
ans = t;
memcpy(best, o, sizeof(o));
}
return;
}
int x = 0, min = 100000;
for (int i = r[0]; i; i = r[i])
if (s[i] < min) min = s[i], x = i;
remove(x);
for (int i = d[x]; i != x; i = d[i]) {
for (int j = r[i]; j != i; j = r[j]) remove(c[j]);
if (add[i] == 1) o[t + 1] = name[i];
dfs(t + add[i]);
for (int j = l[i]; j != i; j = l[j]) resume(c[j]);
}
resume(x);
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
r[len] = len + 1;
++len;
l[len] = len - 1;
c[len] = len;
tmp[len] = len;
add[len] = 1;
s[len] = 1;
}
for (i = 1; i <= n - 2; i++)
for (j = 1; j <= m - 2; j++)
for (k = 0; k < 4; k++)
for (i1 = 0; i1 < 5; i1++) {
int x = i + xx[k][i1], y = j + yy[k][i1];
++len;
add[len] = 1;
name[len].x = i;
name[len].y = j;
name[len].z = k;
s[calc(x, y)]++;
c[len] = calc(x, y);
if (i1 == 0)
l[len] = len + 4;
else
l[len] = len - 1;
if (i1 == 4)
r[len] = len - 4;
else
r[len] = len + 1;
u[len] = tmp[calc(x, y)];
d[tmp[calc(x, y)]] = len;
tmp[calc(x, y)] = len;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
len++;
c[len] = calc(i, j);
r[len] = l[len] = len;
u[len] = tmp[calc(i, j)];
d[tmp[calc(i, j)]] = len;
u[calc(i, j)] = len;
d[len] = calc(i, j);
s[calc(i, j)]++;
}
dfs(0);
printf("%d\n", ans);
for (i = 1; i <= ans; i++)
for (j = 0; j < 5; j++)
bb[best[i].x + xx[best[i].z][j]][best[i].y + yy[best[i].z][j]] = i;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
if (bb[i][j] == 0)
out[i][j] = '.';
else
out[i][j] = 'A' + bb[i][j] - 1;
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) printf("%c", out[i][j]);
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> m;
map<string, int> m2;
int main() {
int n, score, maxi = -1000000;
string best = "", name;
bool flag = true;
scanf("%d", &n);
vector<pair<string, int> > rounds;
rounds.reserve(1002);
for (int i = 0; i < n; i++) {
cin >> name;
cin >> score;
m[name] += score;
rounds.push_back(make_pair(name, score));
}
map<string, int>::iterator it;
for (it = m.begin(); it != m.end(); it++) maxi = max(maxi, it->second);
for (it = m.begin(); it != m.end(); it++)
if (it->second == maxi) m2[it->first] = 0;
if (m2.size() == 1) {
cout << m2.begin()->first;
return 0;
}
for (int i = 0; i < rounds.size(); i++) {
if (m2.count(rounds[i].first) > 0) m2[rounds[i].first] += rounds[i].second;
for (it = m2.begin(); it != m2.end(); it++) {
if (it->second >= maxi) {
cout << it->first;
return 0;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
int norm(int a) {
while (a >= MOD) a -= MOD;
while (a < 0) a += MOD;
return a;
}
int mul(int a, int b) { return int(a * 1ll * b % MOD); }
int n, k;
vector<int> a;
inline bool read() {
if (!(cin >> n >> k)) return false;
a.resize(n);
for (int i = int(0); i < int(n); i++) cin >> a[i];
return true;
}
pair<int, int> calc(int len) {
if (len == 0) return {0, 1};
if (len & 1) {
auto res = calc(len >> 1);
return {norm(mul(res.first, res.first) +
mul(k - 1, mul(res.second, res.second))),
norm(mul(2, mul(res.first, res.second)) +
mul(k - 2, mul(res.second, res.second)))};
}
auto res = calc(len - 1);
return {mul(k - 1, res.second), norm(res.first + mul(k - 2, res.second))};
}
vector<int> curArray;
int calcSeg(int l, int r) {
if (r >= int((curArray).size())) {
int len = r - l - 1, cf = 1;
if (l < 0) len--, cf = k;
if (len == 0) return cf;
auto res = calc(len - 1);
return mul(cf, norm(res.first + mul(k - 1, res.second)));
}
if (l < 0) {
if (r - l == 1) return 1;
auto res = calc(r - l - 2);
return norm(res.first + mul(k - 1, res.second));
}
auto res = calc(r - l - 1);
return curArray[l] == curArray[r] ? res.first : res.second;
}
inline void solve() {
int ans = 1;
for (int k = int(0); k < int(2); k++) {
curArray.clear();
for (int i = 0; 2 * i + k < n; i++) curArray.push_back(a[2 * i + k]);
int lst = -1;
for (int i = int(0); i < int(int((curArray).size())); i++) {
if (curArray[i] == -1) continue;
ans = mul(ans, calcSeg(lst, i));
lst = i;
}
ans = mul(ans, calcSeg(lst, int((curArray).size())));
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
if (read()) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXFACE = 100000;
struct Face {
int nside, id;
};
bool operator<(const Face &a, const Face &b) { return a.nside > b.nside; }
int nface;
Face face[MAXFACE];
int ansn;
vector<int> ans[MAXFACE];
int perim[MAXFACE];
int overlap[MAXFACE];
void solve() {
sort(face, face + nface);
perim[0] = face[0].nside, overlap[0] = 0;
for (int i = (1); i < (nface); ++i) {
assert(perim[i - 1] >= face[i].nside);
int lim = i + 1 < nface ? face[i + 1].nside : 3;
overlap[i] =
min(face[i].nside - 1, (perim[i - 1] + face[i].nside - lim) / 2);
perim[i] = perim[i - 1] + face[i].nside - 2 * overlap[i];
}
ansn = 0;
for (int i = (0); i < (nface); ++i) ans[i].clear();
vector<int> cur(perim[0]);
for (int i = (0); i < (((int)(cur).size())); ++i) cur[i] = ansn++;
ans[face[0].id] = cur;
for (int i = (1); i < (nface); ++i) {
assert(overlap[i] < face[i].nside && overlap[i] < ((int)(cur).size()) &&
((int)(cur).size()) + face[i].nside - 2 * overlap[i] >= 3);
vector<int> me;
me.push_back(cur[0]);
for (int j = (0); j < (overlap[i] - 1); ++j) {
int x = cur.back();
cur.pop_back();
me.push_back(x);
}
me.push_back(cur.back());
for (int j = (0); j < (face[i].nside - overlap[i] - 1); ++j) {
int x = ansn++;
me.push_back(x);
cur.push_back(x);
}
ans[face[i].id] = me;
assert(((int)(cur).size()) == perim[i]);
assert(((int)(me).size()) == face[i].nside);
if (perim[i - 1] == 3 && overlap[i] == 1)
rotate(cur.begin(), cur.begin() + ((int)(cur).size()) - 1, cur.end());
}
}
void run() {
scanf("%d", &nface);
for (int i = (0); i < (nface); ++i)
scanf("%d", &face[i].nside), face[i].id = i;
solve();
printf("%d\n", ansn);
for (int i = (0); i < (nface); ++i) {
for (int j = (0); j < (((int)(ans[i]).size())); ++j) {
if (j != 0) printf(" ");
printf("%d", ans[i][j] + 1);
}
puts("");
}
}
int main() {
run();
return 0;
}
| 12 |
#include <bits/stdc++.h>
int matrix[1001][1001];
int row, column, rowl[1001], coll[1001];
int main(void) {
int req;
char type;
int n1, n2;
scanf("%d %d %d", &row, &column, &req);
for (int i = 1; i <= row; i++) {
for (int j = 1; j <= column; j++) {
scanf("%d", &matrix[i][j]);
}
}
for (int i = 1; i <= row; i++) {
rowl[i] = i;
}
for (int j = 1; j <= column; j++) {
coll[j] = j;
}
for (int i = 1; i <= req; i++) {
getchar();
scanf("%c", &type);
scanf("%d %d", &n1, &n2);
if (type == 'g')
printf("%d\n", matrix[rowl[n1]][coll[n2]]);
else if (type == 'r') {
int temp = rowl[n1];
rowl[n1] = rowl[n2];
rowl[n2] = temp;
} else {
int temp = coll[n1];
coll[n1] = coll[n2];
coll[n2] = temp;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, l = 0, r;
long long h[100005], d[100005];
bool check(long long x) {
long long cur = 1;
for (long long i = 1; i <= n; ++i) {
long long next = 0;
if (h[i] <= d[cur])
next = h[i] + x;
else {
long long now = h[i] - d[cur];
if (now > x) return false;
next = max(next, h[i] + x - now * 2);
next = max(next, h[i] + (x - now) / 2);
}
while (d[cur] <= next && cur <= m) cur++;
if (cur > m) return true;
}
if (cur > m)
return true;
else
return false;
}
int main() {
long long ans, mid;
bool flag = false;
cin >> n >> m;
for (long long i = 1; i <= n; ++i) cin >> h[i];
for (long long i = 1; i <= m; ++i) cin >> d[i];
r = max(d[m] * 2, h[n] * 2);
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid)) {
r = mid - 1;
ans = min(mid, ans);
} else
l = mid + 1;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
constexpr int MAXN = 500005;
int n;
string var[MAXN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
cin >> var[i];
}
for (int i = n - 1; i >= 1; --i) {
if (var[i] > var[i + 1]) {
int j = 0;
for (; j < min((int)var[i + 1].size(), (int)var[i].size()) &&
var[i + 1][j] >= var[i][j];
++j)
;
j = var[i].size() - j;
while (j--) {
var[i].pop_back();
}
}
}
for (int i = 1; i <= n; ++i) {
cout << var[i] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
inline long long read() {
long long x = 0;
char c = getchar(), f = 1;
for (; c < '0' || '9' < c; c = getchar())
if (c == '-') f = -1;
for (; '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
return x * f;
}
inline void write(long long x) {
static char buf[20];
int len = 0;
if (x < 0) putchar('-'), x = -x;
for (; x; x /= 10) buf[len++] = x % 10 + '0';
if (!len)
putchar('0');
else
while (len) putchar(buf[--len]);
}
inline void writesp(long long x) {
write(x);
putchar(' ');
}
inline void writeln(long long x) {
write(x);
putchar('\n');
}
int deg[3010], to[3010][1010], id[3010][1010];
int col[1010];
int w[110], cur1[110], cur2[110];
int n, m, k, cnt;
void adjust(int x, int c1, int c2) {
while (x) {
col[id[x][c1]] = c2;
std::swap(to[x][c1], to[x][c2]);
std::swap(id[x][c1], id[x][c2]);
x = to[x][c2];
std::swap(c1, c2);
}
}
int main() {
n = read();
m = read();
k = read();
for (int i = 1; i <= n; i++) w[i] = read();
deg[0] = k;
cnt = 0;
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
if (deg[cur1[x]] == k) cur1[x] = ++cnt, deg[cur1[x]] = 0;
if (deg[cur2[y]] == k) cur2[y] = ++cnt, deg[cur2[y]] = 0;
++deg[cur1[x]];
++deg[cur2[y]];
int cx = 0, cy = 0;
for (int j = 1; j <= k; j++)
if (!to[cur1[x]][j]) {
cx = j;
break;
}
if (to[cur2[y]][cx]) {
for (int j = 1; j <= k; j++)
if (!to[cur2[y]][j]) {
cy = j;
break;
}
adjust(cur2[y], cx, cy);
}
to[cur1[x]][cx] = cur2[y];
id[cur1[x]][cx] = i;
to[cur2[y]][cx] = cur1[x];
id[cur2[y]][cx] = i;
col[i] = cx;
}
for (int i = 1; i <= m; i++) writeln(col[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, a...);
}
int t[5007];
int dp[5007];
int first[5007];
int last[5007];
bool b[5007];
int32_t main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &t[i]);
if (first[t[i]] == 0) first[t[i]] = i;
last[t[i]] = i;
}
for (int i = 1; i <= n; ++i) {
int x = 0, F = i, L = i;
for (int j = i; j >= 1; --j) {
if (b[t[j]] == 0) {
x ^= t[j];
b[t[j]] = 1;
}
L = max(L, last[t[j]]);
F = min(F, first[t[j]]);
if (L <= i && F >= j) dp[i] = max(dp[i], x + dp[j - 1]);
}
dp[i] = max(dp[i], dp[i - 1]);
for (int j = 0; j <= 5000; ++j) b[j] = 0;
}
printf("%d", dp[n]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 222222;
vector<int> all;
set<int> occ;
set<int>::iterator it, it2;
map<int, int> here, wh;
set<pair<int, int> > s;
int nn, t, q, len, st, p, le, ri, i;
int z, x, v, ans, ll, rr, xx, low, high;
int id[maxn], il[maxn], ir[maxn];
int cr[maxn], a[maxn], h[maxn];
int main() {
scanf("%d%d", &nn, &t);
s.clear();
s.insert(make_pair(-nn, -1));
here.clear();
occ.clear();
occ.insert(0);
occ.insert(nn + 1);
all.clear();
for (q = 0; q < t; q++) {
scanf("%d", &id[q]);
if (id[q] == 0)
scanf("%d%d", &il[q], &ir[q]);
else if (!here[id[q]]) {
len = -(*(s.begin())).first;
st = -(*(s.begin())).second;
s.erase(s.begin());
p = st + (len >> 1);
cr[q] = p;
all.push_back(p);
occ.insert(p);
if (st <= p - 1) s.insert(make_pair(-(p - st), -st));
if (p + 1 <= st + len - 1)
s.insert(make_pair(-(st + len - p - 1), -(p + 1)));
here[id[q]] = p;
} else {
p = here[id[q]];
cr[q] = -p;
it = occ.find(p);
it2 = it;
it2--;
le = *it2;
it++;
ri = *it;
occ.erase(p);
if (le + 1 <= p - 1) s.erase(make_pair(-(p - le - 1), -(le + 1)));
if (p + 1 <= ri - 1) s.erase(make_pair(-(ri - p - 1), -(p + 1)));
s.insert(make_pair(-(ri - le - 1), -(le + 1)));
here[id[q]] = 0;
}
}
sort(all.begin(), all.end());
all.erase(unique(all.begin(), all.end()), all.end());
wh.clear();
z = all.size();
for (i = 0; i < z; i++) wh[all[i]] = i + 1;
for (i = 1; i <= z; i++) h[i] = all[i - 1];
for (i = 1; i <= z; i++) a[i] = 0;
for (q = 0; q < t; q++)
if (id[q] == 0) {
ll = 1;
rr = z + 1;
while (ll < rr) {
xx = (ll + rr) >> 1;
if (h[xx] >= il[q])
rr = xx;
else
ll = xx + 1;
}
low = ll;
ll = 0;
rr = z;
while (ll < rr) {
xx = (ll + rr + 1) >> 1;
if (h[xx] <= ir[q])
ll = xx;
else
rr = xx - 1;
}
high = ll;
ans = 0;
if (low <= high) {
x = high;
while (x > 0) {
ans += a[x];
x &= x - 1;
}
x = low - 1;
while (x > 0) {
ans -= a[x];
x &= x - 1;
}
}
printf("%d\n", ans);
} else {
x = cr[q];
v = 1;
if (x < 0) {
x = -x;
v = -1;
}
x = wh[x];
while (x <= z) {
a[x] += v;
x = (x | (x - 1)) + 1;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, i, n;
double sum, temp;
cin >> m >> n;
sum = 0.00000000000;
for (i = 1; i <= m; i++) {
temp = i * (pow(((double)i / m), n) - pow(((double)(i - 1) / m), n));
sum = sum + temp;
}
printf("%.12lf", sum);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = (int)1e6 + 100;
const int M = (int)2e6 + 100;
const int inf = (int)1e9 + 100;
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
srand(time(0));
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, t;
cin >> s >> t;
int i, j;
int ans = t.length();
if (s.length() >= t.length()) {
for (i = 1 - (int)t.length(); i < (int)s.length(); i++) {
int tans = 0;
for ((j) = 0; (j) < (t.length()); (j)++) {
if (i + j < 0 || i + j >= (int)s.length() || t[j] != s[i + j]) tans++;
}
ans = min(ans, tans);
}
} else {
for (i = 1 - (int)s.length(); i < (int)t.length(); i++) {
int tans = 0;
for ((j) = 0; (j) < (s.length()); (j)++) {
if (i + j < 0 || i + j >= (int)t.length() || s[j] != t[i + j]) tans++;
}
ans = min(ans, tans + (int)t.length() - (int)s.length());
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int matchings[2001];
int pref[2001][2001];
int revpos[2001][2001];
void cpp_wrapper_irving(int N) {
int proposal_to[N];
int proposal_from[N];
int proposed_to[N];
for (int i = 0; i < N; i++) proposal_to[i] = N;
for (int i = 0; i < N; i++) proposal_from[i] = N;
for (int i = 0; i < N; i++) proposed_to[i] = 0;
bool stable = false;
while (!stable) {
stable = true;
for (int n = 0; n < N; n++) {
if (proposed_to[n] >= N - 1) {
return;
}
if (proposal_to[n] == N) {
int proposee = pref[n][proposed_to[n]];
int op = revpos[proposee][n];
int op_curr = N;
if (proposal_from[proposee] != N) {
op_curr = revpos[proposee][proposal_from[proposee]];
}
if (op < op_curr) {
proposal_to[n] = proposee;
if (proposal_from[proposee] != N) {
proposal_to[proposal_from[proposee]] = N;
stable = false;
}
proposal_from[proposee] = n;
} else {
stable = false;
}
proposed_to[n]++;
}
}
}
std::vector<std::deque<int> > table(N, std::deque<int>(N - 1));
for (int n = 0; n < N; ++n) {
for (int i = 0; i < N - 1; i++) {
table[n][i] = pref[n][i];
}
}
for (int n = 0; n < N; n++) {
for (int i = table[n].size() - 1; i >= 0; i--) {
if (table[n][i] == proposal_from[n]) {
break;
} else {
if (table[n].size() == 0) {
return;
}
bool erased = false;
for (int j = 0; j < table[table[n].back()].size(); j++) {
if (table[table[n].back()][j] == n) {
table[table[n].back()].erase(table[table[n].back()].begin() + j);
erased = true;
break;
}
}
if (!erased) {
return;
}
table[n].pop_back();
}
}
}
stable = false;
while (!stable) {
stable = true;
for (int n = 0; n < N; n++) {
if (table[n].size() > 1) {
stable = false;
std::vector<int> x;
std::vector<int> index;
int new_index = n;
int rot_tail = static_cast<int>(-1);
while (rot_tail == (int)(index.end() - index.begin() - 1)) {
int new_x = table[new_index][1];
new_index = table[new_x].back();
rot_tail =
find(index.begin(), index.end(), new_index) - index.begin();
x.push_back(new_x);
index.push_back(new_index);
}
for (int i = rot_tail + 1; i < index.size(); i++) {
while (table[x[i]].back() != index[i - 1]) {
int tab_size = table[table[x[i]].back()].size();
table[table[x[i]].back()].erase(
std::remove(table[table[x[i]].back()].begin(),
table[table[x[i]].back()].end(), x[i]),
table[table[x[i]].back()].end());
if (tab_size == table[table[x[i]].back()].size()) {
return;
}
if (table[x[i]].size() == 1) {
return;
}
table[x[i]].pop_back();
}
}
}
}
}
for (int i = 0; i < table.size(); i++) {
if (table[i].empty()) {
return;
}
}
for (int n = 0; n < N; n++) {
matchings[n] = table[n][0];
}
return;
}
int n;
int a[2001][2001];
int exi[2001], ans[2001];
vector<pair<int, int> > V;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j) scanf("%d", &a[i][j]);
if (n % 2) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) {
V.clear();
for (int j = 1; j <= n; j++)
if (i != j) V.push_back(make_pair(a[i][j], j));
sort(V.begin(), V.end());
for (int j = 0; j < V.size(); j++) {
int id = V[j].second;
pref[i - 1][j] = id - 1;
revpos[i - 1][id - 1] = j;
}
}
cpp_wrapper_irving(n);
int ok = 0;
for (int i = 1; i <= n; i++)
if (matchings[i] != 0) ok = 1;
if (!ok) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) {
printf("%d\n", matchings[i - 1] + 1);
}
}
| 13 |
#include <bits/stdc++.h>
int main() {
char a[105], b[105], ans[105];
gets(a);
gets(b);
int i, len = strlen(a);
for (i = 0; i < len; i++) {
if (a[i] != b[i]) {
ans[i] = '1';
} else
ans[i] = '0';
}
ans[len] = '\0';
printf("%s", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 200000000;
struct Point {
int x, y;
Point(int _x, int _y) {
x = _x;
y = _y;
}
};
bool operator<(const Point a, const Point b) { return a.x < b.x; }
long long solve(vector<Point> v) {
int n = (int)v.size();
vector<int> MINI(n + 1);
vector<int> MAXI(n + 1);
MINI[n] = inf;
MAXI[n] = -inf;
for (int i = n - 1; i >= 0; i--) {
MINI[i] = min(v[i].y, MINI[i + 1]);
MAXI[i] = max(v[i].y, MAXI[i + 1]);
}
long long lo = 0, hi = 1LL * inf * inf, mi;
int mini2, maxi2;
while (lo <= hi) {
mi = (lo + hi) / 2;
bool ok = 0;
int mini = inf, maxi = -inf;
for (int i = 0, j = -1; i < n; i++) {
ok = 1;
while (j + 1 <= i) {
if (1LL * (v[j + 1].x - v[i].x) * (v[j + 1].x - v[i].x) > mi) {
mini = min(mini, v[j + 1].y);
maxi = max(maxi, v[j + 1].y);
j++;
} else {
break;
}
}
mini2 = min(mini, MINI[i + 1]), maxi2 = max(maxi, MAXI[i + 1]);
if (maxi2 < mini2) {
ok = 1;
} else {
if (1LL * (maxi2 - mini2) * (maxi2 - mini2) > mi) ok = 0;
if (1LL * mini2 * mini2 + 1LL * v[i].x * v[i].x > mi) {
ok = 0;
}
if (1LL * maxi2 * maxi2 + 1LL * v[i].x * v[i].x > mi) {
ok = 0;
}
if (1LL * mini2 * mini2 + 1LL * v[j + 1].x * v[j + 1].x > mi) {
ok = 0;
}
if (1LL * maxi2 * maxi2 + 1LL * v[j + 1].x * v[j + 1].x > mi) {
ok = 0;
}
}
if (!ok) {
} else {
ok = 1;
break;
}
}
if (ok)
hi = mi - 1;
else
lo = mi + 1;
}
return lo;
}
int main() {
int n;
vector<Point> v;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
v.push_back(Point(x, y));
}
sort(v.begin(), v.end());
long long ans = solve(v);
ans = min(1LL * (v[0].x - v[n - 1].x) * (v[0].x - v[n - 1].x), ans);
for (int i = 0; i < n; i++) {
swap(v[i].x, v[i].y);
}
sort(v.begin(), v.end());
ans = min(1LL * (v[0].x - v[n - 1].x) * (v[0].x - v[n - 1].x), ans);
ans = min(ans, solve(v));
cout << ans << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[10000], sum, L[10000], apr[100100], tot[10000], dp[502][5002], v[510];
int main() {
int n, m, i, j, k;
scanf("%d%d", &n, &m);
for (i = 1; i <= n * m; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (!apr[x]) {
sum++;
apr[x] = sum;
}
v[apr[x]]++;
}
for (i = 1; i <= m; i++) scanf("%d", &L[i]);
for (i = 1; i <= n * m; i++)
if (apr[a[i]]) tot[apr[a[i]]]++;
int ans = 0;
for (int _ = 1; _ <= sum; _++) {
memset(dp, -0x3f, sizeof(dp));
dp[0][0] = 0;
int t = v[_];
for (i = 1; i <= t; i++)
for (j = 0; j <= min(tot[_], i * m); j++)
for (k = 0; k <= min(j, m); k++)
dp[i][j] = max(dp[i][j], dp[i - 1][j - k] + L[k]);
ans += dp[t][min(tot[_], t * m)];
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
char s[100];
int m = 0, x = 0;
for (int i = 97; i <= 122; i++) {
s[m] = i;
m++;
k--;
if (k == 0) break;
}
for (int i = m; i < n; i++) {
s[i] = s[x];
x++;
}
for (int i = 0; i < n; i++) cout << s[i];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int cheak(int x) {
int sum = x;
while (x) {
sum += x / k;
x /= k;
}
if (sum >= n) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &k);
int head = 1, tail = n;
while (head <= tail) {
int mid = (head + tail) / 2;
if (cheak(mid))
tail = mid - 1;
else
head = mid + 1;
}
printf("%d\n", head);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q1;
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q2;
long long dap, cnt, ch[300010], n, w, a[300010], b[300010], ans[300010],
ch2[300010];
int main() {
long long i, t;
pair<long long, long long> s1, s2, s3;
scanf("%lld %lld", &n, &w);
for (i = 1; i <= n; i++) {
scanf("%lld %lld", &a[i], &b[i]);
q1.push(make_pair(a[i], i));
q2.push(make_pair(b[i], i));
}
while (1) {
if (cnt == w) break;
while (q2.size() && ch2[q2.top().second]) q2.pop();
while (q1.size() && q1.top().second > 0 && ch[q1.top().second]) q1.pop();
if (cnt == w - 1) {
dap += q1.top().first;
ans[abs(q1.top().second)]++;
break;
}
s1 = q1.top();
q1.pop();
while (q1.size() && q1.top().second > 0 && ch[q1.top().second]) q1.pop();
s2 = q1.top();
if (q2.size()) s3 = q2.top();
if (q2.size() && s1.first + s2.first >= s3.first) {
ans[s3.second] = 1;
cnt++;
dap += a[s3.second];
q1.push(s1);
s1.first = s3.first - a[s3.second];
s1.second = -s3.second;
ch[s3.second] = 1;
q2.pop();
q1.push(s1);
continue;
}
cnt++;
dap += s1.first;
ans[abs(s1.second)]++;
ch2[abs(s1.second)] = 1;
if (s1.second > 0) {
s1.first = b[s1.second] - s1.first;
s1.second = -s1.second;
q1.push(s1);
}
}
printf("%lld\n", dap);
for (i = 1; i <= n; i++) printf("%d", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
long* a;
long gcd(long a, long b) {
if (a == 0 || b == 0)
return a + b;
else
return gcd(b % a, a);
}
int main() {
cin >> n;
a = new long[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long g = 0;
long max = 0;
for (int i = 0; i < n; i++) {
g = gcd(g, a[i]);
if (a[i] > max) max = a[i];
}
if (max / g % 2 - n % 2 == 0)
cout << "Bob";
else
cout << "Alice";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[101], base = 1e9 + 7;
long long check(long long x) {
long long res = 0;
while (x > 0) {
res += x % 2;
x /= 2;
}
return res % 3;
}
struct node {
long long c[101][101], sum;
void khoitao(bool tt) {
sum = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) c[i][j] = 0;
if (tt == 1) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (check(a[i] ^ a[j]) == 0) c[i][j]++, sum++;
}
}
};
node mul(node x, node y) {
node res;
res.khoitao(0);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
res.c[i][j] = (res.c[i][j] + x.c[i][k] * y.c[k][j]) % base;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) res.sum = (res.sum + res.c[i][j]) % base;
return res;
}
node power(node x, long long y) {
if (y == 1) return x;
node res = power(x, y / 2);
res = mul(res, res);
if (y % 2 == 0) return res;
return mul(res, x);
}
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
node res;
res.khoitao(1);
if (k == 1)
cout << n;
else
cout << power(res, k - 1).sum;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
const int maxn = 100000 + 10;
char t(char c) {
if (c == 'L') return 'U';
if (c == 'U') return 'L';
if (c == 'R') return 'D';
if (c == 'D') return 'R';
}
vector<string> transpose(vector<string> A) {
int n = (int)A.size(), m = (int)A[0].length();
string s = "";
for (int i = 0; i < n; ++i) s += '0';
vector<string> T(m, s);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
T[j][i] = t(A[i][j]);
}
return T;
}
void apply(vector<string> &A, pair<int, int> p) {
if (A[p.first][p.second] == 'U') {
A[p.first][p.second] = 'L';
A[p.first + 1][p.second] = 'L';
A[p.first][p.second + 1] = 'R';
A[p.first + 1][p.second + 1] = 'R';
} else {
A[p.first][p.second] = 'U';
A[p.first][p.second + 1] = 'U';
A[p.first + 1][p.second] = 'D';
A[p.first + 1][p.second + 1] = 'D';
}
}
vector<pair<int, int> > solve(vector<string> &A) {
int n = (int)A.size(), m = (int)A[0].length();
vector<pair<int, int> > seq;
for (int i = 0; i < n; i += 2) {
for (int j = 0; j < m; ++j) {
if (A[i][j] == 'U') continue;
int x = i, y = j;
int c = 0;
vector<pair<int, int> > cur(1, pair<int, int>(x, y));
while (true) {
if (c == 0) {
x++;
if (A[x][y] == 'L') break;
} else {
y++;
if (A[x][y] == 'U') break;
}
cur.push_back(pair<int, int>(x, y));
c ^= 1;
}
reverse(cur.begin(), cur.end());
for (auto p : cur) {
seq.push_back(p);
apply(A, p);
}
}
}
return seq;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<string> A(n), B(n);
for (int i = 0; i < n; ++i) cin >> A[i];
for (int i = 0; i < n; ++i) cin >> B[i];
bool t = false;
if (n & 1) {
t = true;
A = transpose(A);
B = transpose(B);
}
vector<pair<int, int> > seqA = solve(A);
vector<pair<int, int> > seqB = solve(B);
reverse(seqB.begin(), seqB.end());
cout << seqA.size() + seqB.size() << endl;
for (auto p : seqA) {
if (t) swap(p.first, p.second);
cout << p.first + 1 << " " << p.second + 1 << endl;
}
for (auto p : seqB) {
if (t) swap(p.first, p.second);
cout << p.first + 1 << " " << p.second + 1 << endl;
}
return 0;
}
| 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.