solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmax(T& x, T y) {
return x < y ? x = y, 1 : 0;
}
template <class T>
bool ckmin(T& x, T y) {
return x > y ? x = y, 1 : 0;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
const int N = 500005;
const int S = N << 1;
int n, a[N];
string str[N];
int trans[S][26], mxlen[S], link[S], rt[S], tot = 1;
vector<int> e[S];
long long s[S], ans = -1e18;
int extend(int c, int lst, int id) {
if (trans[lst][c]) {
int p = lst, q = trans[p][c];
if (mxlen[p] + 1 == mxlen[q])
return s[q] += a[id], q;
else {
int nq = ++tot;
mxlen[nq] = mxlen[p] + 1;
for (int i = 0; i < 26; ++i) trans[nq][i] = trans[q][i];
link[nq] = link[q], link[q] = nq;
for (; p && trans[p][c] == q; p = link[p]) trans[p][c] = nq;
return s[nq] += a[id], nq;
}
}
int p = lst, np = ++tot;
mxlen[np] = mxlen[p] + 1;
for (; p && !trans[p][c]; p = link[p]) trans[p][c] = np;
if (!p)
link[np] = 1;
else {
int q = trans[p][c];
if (mxlen[p] + 1 == mxlen[q])
link[np] = q;
else {
int nq = ++tot;
mxlen[nq] = mxlen[p] + 1;
for (int i = 0; i < 26; ++i) trans[nq][i] = trans[q][i];
link[nq] = link[q], link[q] = link[np] = nq;
for (; p && trans[p][c] == q; p = link[p]) trans[p][c] = nq;
}
}
return s[np] += a[id], np;
}
void dfs(int u) {
for (int v : e[u]) dfs(v), s[u] += s[v];
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1, iend = n; i <= iend; ++i) cin >> str[i];
for (int i = 1, iend = n; i <= iend; ++i) cin >> a[i];
for (int i = 1, iend = n; i <= iend; ++i) {
int lst = 1, len = (int)(str[i]).size();
for (int j = 0; j < len; ++j) lst = extend(str[i][j] - 'a', lst, i);
}
for (int i = 1; i <= tot; ++i) e[link[i]].push_back(i);
dfs(1);
for (int i = 1; i <= tot; ++i) ckmax(ans, 1ll * mxlen[i] * s[i]);
cout << ans << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
bool d = 0;
vector<string> v;
while (getline(cin, s)) {
bool ok = 1;
int n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] == ' ') {
continue;
}
if (s[i] == '#') {
ok = 0;
break;
} else {
break;
}
}
if (!ok) {
if (d) v.push_back(t);
v.push_back(s);
t = "";
} else {
for (int i = 0; i < n; i++)
if (s[i] != ' ') t += s[i];
}
d = ok;
}
if (d) {
v.push_back(t);
}
for (int i = 0; i < v.size(); i++) cout << v[i] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
string s;
cin >> s;
int len = s.size();
while (t--) {
for (int i = len - 1; i >= 1; i--) {
if (s[i] == 'G' && s[i - 1] == 'B') {
swap(s[i], s[i - 1]);
i--;
}
}
}
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[5005][5005];
int main() {
int n, m, k;
cin >> n >> m >> k;
set<pair<int, int> > se;
for (int i = 0; i < k; i++) {
int u, v, p;
cin >> u >> v >> p;
if (u == 1) {
a[v][0].first = p;
a[v][0].second = i + 1;
} else {
a[0][v].first = p;
a[0][v].second = i + 1;
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
a[j][i].first = a[0][i].first;
a[j][i].second = a[0][i].second;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][0].second > 0 && (a[i][j].second < a[i][0].second)) {
a[i][j].first = a[i][0].first;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << a[i][j].first << " ";
}
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<string> s(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'S') {
if (j < m - 1 && s[i][j + 1] == 'W') {
cout << "No";
return 0;
}
if (j && s[i][j - 1] == 'W') {
cout << "No";
return 0;
}
if (i < n - 1 && s[i + 1][j] == 'W') {
cout << "No";
return 0;
}
if (i && s[i - 1][j] == 'W') {
cout << "No";
return 0;
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') s[i][j] = 'D';
}
}
cout << "Yes\n";
for (int i = 0; i < n; i++) cout << s[i] << "\n";
}
| 0 |
#include <bits/stdc++.h>
int n;
char s[5];
char a[200010];
int b[200010];
std::stack<int> sta;
int ans[100010];
int main() {
scanf("%d", &n);
for (int i = 0; i < 2 * n; ++i) {
scanf("%s", s);
if (s[0] == '+') {
a[i] = '+';
} else {
a[i] = '-';
int x;
scanf("%d", &x);
b[i] = x;
}
}
while (!sta.empty()) {
sta.pop();
}
bool flag = true;
int cnt = 0;
for (int i = 2 * n - 1; i >= 0; --i) {
if (a[i] == '+') {
if (sta.empty()) {
flag = false;
break;
} else {
ans[cnt++] = sta.top();
sta.pop();
}
} else if (a[i] == '-') {
if (!sta.empty() && b[i] > sta.top()) {
flag = false;
break;
} else {
sta.push(b[i]);
}
}
}
if (!sta.empty()) {
flag = false;
}
if (!flag) {
printf("NO\n");
} else {
printf("YES\n");
for (int i = n - 1; i >= 0; --i) {
printf("%d", ans[i]);
if (!i) {
printf("\n");
} else {
printf(" ");
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxi = 1e6 + 7;
const int inf = 0x3f3f3f3f;
int tree[6 * maxi][2], sz = 1, L[6 * maxi], R[6 * maxi];
long long a[maxi * 6];
void insert(long long x, long long num) {
int c = 0;
for (int i = 32; i >= 0; i--) {
if (!tree[c][(x >> i) & 1]) tree[c][(x >> i) & 1] = sz++;
c = tree[c][(x >> i) & 1];
if (!L[c]) L[c] = num;
R[c] = num;
}
}
long long query(int p, int pos, long long x) {
long long sum = 0;
for (int i = pos; i >= 0; i--) {
int c = (x >> i) & 1;
if (tree[p][c])
p = tree[p][c];
else {
p = tree[p][c ^ 1];
sum += (1 << i);
}
}
return sum;
}
long long divide(int p, int pos) {
if (tree[p][0] && tree[p][1]) {
int x = tree[p][0], y = tree[p][1];
long long minn = inf;
for (int i = L[x]; i <= R[x]; i++)
minn = min(minn, query(y, pos - 1, a[i]) + (1 << pos));
return minn + divide(tree[p][0], pos - 1) + divide(tree[p][1], pos - 1);
} else if (tree[p][0])
return divide(tree[p][0], pos - 1);
else if (tree[p][1])
return divide(tree[p][1], pos - 1);
return 0;
}
int main() {
long long n;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) insert(a[i], i);
printf("%lld\n", divide(0, 32));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x[505], y[505], p[505][4], sx, sy, xx[1005], yy[1005],
r[1005][1005], wx, wy, lo, hi, mi, ta, tb, tc, td;
pair<int, int> ex[1005], ey[1005];
void go(int a, int b) {
ta = max(ta, a - mi);
tb = min(tb, a + mi);
tc = max(tc, b - mi);
td = min(td, b + mi);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < k; i++) scanf("%d%d", x + i, y + i);
lo = 0, hi = max(n, m);
while (lo < hi) {
mi = (lo + hi) / 2;
sx = sy = wx = wy = 0;
for (int i = 0; i < k; i++) {
ex[sx++] = make_pair(max(1, x[i] - mi), i * 4);
ex[sx++] = make_pair(min(n, x[i] + mi) + 1, i * 4 + 1);
ey[sy++] = make_pair(max(1, y[i] - mi), i * 4 + 2);
ey[sy++] = make_pair(min(m, y[i] + mi) + 1, i * 4 + 3);
}
sort(ex, ex + sx);
xx[wx++] = 1;
for (int i = 0; i < sx; i++) {
if (xx[wx - 1] != ex[i].first) xx[wx++] = ex[i].first;
p[ex[i].second / 4][ex[i].second % 4] = wx - 1;
}
if (xx[wx - 1] != n + 1) xx[wx++] = n + 1;
sort(ey, ey + sy);
yy[wy++] = 1;
for (int i = 0; i < sy; i++) {
if (yy[wy - 1] != ey[i].first) yy[wy++] = ey[i].first;
p[ey[i].second / 4][ey[i].second % 4] = wy - 1;
}
if (yy[wy - 1] != m + 1) yy[wy++] = m + 1;
for (int i = 0; i < wx; i++) memset(r[i], 0, 4 * wy);
for (int i = 0; i < k; i++)
for (int j = p[i][0]; j < p[i][1]; j++) {
r[j][p[i][2]]++;
r[j][p[i][3]]--;
}
ta = tc = INT_MIN;
tb = td = INT_MAX;
wx--;
wy--;
for (int i = 0; i < wx; i++)
for (int j = 0; j < wy; j++) {
if (j) r[i][j] += r[i][j - 1];
if (!r[i][j]) {
go(xx[i], yy[j]);
go(xx[i + 1] - 1, yy[j + 1] - 1);
}
}
if (ta <= tb && tc <= td)
hi = mi;
else
lo = mi + 1;
}
printf("%d\n", lo);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[300000], dp[300000];
int main() {
int n, a;
cin >> n;
set<int> q;
q.insert(0);
for (int i = 0; i < n; i++) {
cin >> a;
if (q.find(a) != q.end()) {
q.erase(a);
}
q.insert(i + 1);
}
cout << q.size();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long k, d, t;
int main() {
double ans = 0;
scanf("%I64d%I64d%I64d", &k, &d, &t);
long long t0 = k / d;
if (k % d) ++t0;
t0 *= d;
long long s0 = (k << 1) - k + t0;
long long t1 = (t << 1) / s0 * t0;
ans = 1.0 * t1;
long long s1 = (t << 1) - t1 / t0 * s0;
if ((k << 1) >= s1)
ans += s1 / 2.0;
else {
ans += 1.0 * k;
s1 -= (k << 1);
ans += s1;
}
printf("%lf\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
void dump_reverse(const std::map<int, int>& map, int s, char c) {
int counter = 0;
for (auto it = map.rbegin(), end_it = map.rend(); it != end_it && counter < s;
++it) {
std::cout << c << ' ' << it->first << ' ' << it->second << std::endl;
++counter;
}
}
void dump_offset(const std::map<int, int>& map, int s, char c) {
size_t size = map.size();
if (s >= size) {
dump_reverse(map, s, c);
return;
}
auto it = map.rbegin();
while (size > s) {
++it;
--size;
}
for (auto end_it = map.rend(); it != end_it; ++it) {
std::cout << c << ' ' << it->first << ' ' << it->second << std::endl;
}
}
int main() {
std::ios::sync_with_stdio(false);
int n;
int s;
std::cin >> n;
std::cin >> s;
std::map<int, int> map_s;
std::map<int, int> map_b;
for (int i = 0; i < n; i++) {
char c;
int p;
int q;
std::cin >> c;
std::cin >> p;
std::cin >> q;
switch (c) {
case 'S': {
map_s[p] += q;
} break;
case 'B': {
map_b[p] += q;
} break;
default:
break;
}
}
dump_offset(map_s, s, 'S');
dump_reverse(map_b, s, 'B');
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vl = vector<ll>;
using pii = pair<int, int>;
using vpii = vector<pair<int, int>>;
template <typename T>
using pque = priority_queue<T, vector<T>, greater<T>>;
vi g[112345];
int d[112345];
int mxans;
void dfs(int a, int p = -1) {
if (~p) d[a] = d[p] + 1;
int k = 0;
for (int &i : g[a]) {
if (i == p) continue;
dfs(i, a);
if (g[i].size() == 1) k++;
};
if (k) mxans -= k - 1;
}
int main() {
int n;
scanf("%d", &n);
for (int i = (0); i < ((n - 1)); i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].emplace_back(b);
g[b].emplace_back(a);
}
int r;
for (int i = (0); i < ((112345)); i++)
if ((int)g[i].size() > 1) r = i;
mxans = n - 1;
dfs(r);
int mians = 1;
bool ex[2] = {};
for (int i = (1); i < (n + 1); i++)
if (g[i].size() == 1) ex[d[i] % 2] = true;
if (ex[0] && ex[1]) mians = 3;
printf("%d %d\n", mians, mxans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int arr[3];
int a[4001];
int n;
int f(int sum) {
if (sum == n) return 0;
if (sum > n) return -1;
if (a[sum] > -2) return a[sum];
int max = -2;
for (int i = 0; i < 3; ++i) {
int ss = f(arr[i] + sum) + 1;
if (ss == 0) ss = -1;
if (max < ss) max = ss;
}
return a[sum] = max;
}
int main() {
while (cin >> n >> arr[0] >> arr[1] >> arr[2]) {
memset(a, -2, sizeof a);
cout << f(0) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
scanf("%d%d", &m, &n);
int t = m / n + 1;
if (t <= 1)
printf("-1\n");
else {
if (t % 2 == 1) t--;
double ans = (double)(m + n) / (double)t;
printf("%.12lf\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<char> pre, suf;
int r = n;
int c = n;
while (r - 2 + c - 1 >= n - 1) {
printf("? %d %d %d %d\n", 1, 1, r - 1, c);
fflush(stdout);
char s[5];
scanf("%s", s);
if (s[0] == 'Y') {
r--;
suf.push_back('D');
} else {
c--;
suf.push_back('R');
}
}
r = 1;
c = 1;
while (n - r + n - (c + 1) >= n - 1) {
printf("? %d %d %d %d\n", r, c + 1, n, n);
fflush(stdout);
char s[5];
scanf("%s", s);
if (s[0] == 'Y') {
c++;
pre.push_back('R');
} else {
r++;
pre.push_back('D');
}
}
printf("! ");
reverse(suf.begin(), suf.end());
for (char c : pre) printf("%c", c);
for (char c : suf) printf("%c", c);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
long long sets = n / 2;
pair<long long, long long> pr[sets];
for (int i = 0; i < sets; i++) pr[i].first = arr[i];
for (int i = 0; i < sets; i++) pr[i].second = arr[n - i - 1];
long long ans = 0;
for (int i = 0; i < sets; i++) {
long long temp = pr[i].first + pr[i].second;
ans += temp * temp;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N;
long long A[200005], B[200005];
int any;
map<pair<long long, long long>, int> cnt;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void findd(long long a, long long b) {
if (a == 0) {
if (b == 0) any++;
return;
}
long long g = gcd(a, b);
b /= g, a /= g;
if (a * b < 0) {
b = -1 * llabs(b);
a = llabs(a);
cnt[make_pair(b, a)]++;
} else {
cnt[make_pair(b, a)]++;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (int i = 1; i <= N; i++) cin >> A[i];
for (int i = 1; i <= N; i++) cin >> B[i];
for (int i = 1; i <= N; i++) findd(A[i], B[i]);
int mx = 0;
for (auto ci : cnt) mx = max(mx, ci.second);
cout << mx + any << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 110;
int c[MAX];
int main() {
int n, t, ans = 0, minn = 0x3f3f3f3f, s, d;
scanf("%d %d", &n, &t);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &s, &d);
if (t <= s)
c[i] = s - t;
else {
if ((t - s) % d == 0)
ans = i;
else
c[i] = (((t - s) / d + 1) * d + s) - t;
}
}
if (ans == 0)
for (int i = 1; i <= n; i++)
if (minn > c[i]) ans = i, minn = c[i];
printf("%d\n", ans);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
string a,b;
cin>>t;
for(int i=0;i<t;i++){
int n;
cin>>n;
cin>>a>>b;
int blue=0,red=0;
for(int j=0;j<n;j++){
if(a[j]>b[j]) red++;
else if(a[j]<b[j]) blue++;
}
if(red>blue){
printf("RED\n");
continue;
}
else if(red==blue){
printf("EQUAL\n");
continue;
}
else{
printf("BLUE\n");
continue;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
long long cnt = 0, a[100000 + 1] = {0};
scanf("%I64d", &n);
for (int i = 0; i < n; ++i) scanf("%I64d", &a[i]);
int idx = 0;
for (long long i = 1; i < n; ++i) {
if (a[i] != a[i - 1]) {
cnt += (i - idx) * (i - idx + 1) / 2;
idx = i;
}
}
cnt += (n - idx) * (n - idx + 1) / 2;
printf("%I64d\n", cnt);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int k;
cin >> k;
string s, t;
cin >> s >> t;
vector<ll> inc(k);
for (ll i = k - 1; i >= 0; --i) {
ll d = ll(t[i] - 'a') - ll(s[i] - 'a');
inc[i] = d;
}
for (ll i = k - 1; i >= 0; --i) {
while (inc[i] < 0) {
inc[i] += 26;
assert(i);
--inc[i - 1];
}
}
for (ll i = 0; i < k; ++i) {
if (inc[i] & 1) {
if (i + 1 < k) inc[i + 1] += 26;
}
inc[i] /= 2;
}
ll carry = 0;
for (ll i = k - 1; i >= 0; --i) {
ll d = ll(s[i] - 'a') + inc[i] + carry;
s[i] = 'a' + (d % 26);
carry = d / 26;
}
cout << s << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, a[100001], b[100001], q[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) b[i] = a[i] + b[i - 1];
cin >> m;
for (int i = 0; i < m; i++) {
long long int first = 1, last = n, mid, ans = 0;
cin >> q[i];
while (first <= last) {
mid = (first + last) / 2;
if (q[i] <= b[mid])
ans = mid, last = mid - 1;
else
first = mid + 1;
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const long long N = 1000006;
using namespace std;
const long long MOD = 1000000007LL;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T power(T x, T y, long long m = MOD) {
T ans = 1;
while (y > 0) {
if (y & 1LL) ans = (ans * x) % m;
y >>= 1LL;
x = (x * x) % m;
}
return ans % m;
}
long long minprime[N];
vector<long long> primes;
void pre() {
for (long long i = 2; i * i < N; i++) {
if (minprime[i] == 0) {
for (long long j = i * i; j < N; j += i)
if (minprime[j] == 0) minprime[j] = i;
}
}
for (long long(i) = (2); i < (N); i++) {
if (minprime[i] == 0) {
minprime[i] = i;
primes.emplace_back(i);
}
}
}
map<vector<long long>, long long> dp;
long long brute(vector<long long> v) {
set<long long> vs;
for (auto i : v) vs.insert(i);
v.clear();
for (auto i : vs) v.emplace_back(i);
if (dp[v]) return dp[v];
bool f = 0;
for (auto i : v)
if (i) f = 1;
if (!f) return dp[v] = 0;
long long n = v.size();
long long maxi = v.back();
set<long long> s;
for (long long(i) = (1); i < (maxi + 1); i++) {
vector<long long> temp = v;
for (auto &x : temp) {
if (x >= i) x -= i;
}
s.insert(brute(temp));
}
long long ct = 0;
while (s.find(ct) != s.end()) ++ct;
return dp[v] = ct;
}
long long a[N];
map<long long, long long> ipr;
long long isprime(long long n) {
if (n == 1) return -1;
if (ipr[n]) return ipr[n];
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return ipr[n] = -1;
}
return ipr[n] = 1;
}
map<long long, vector<long long> > vs;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
pre();
long long ans = 0;
long long n;
cin >> n;
set<long long> act;
for (long long(i) = (0); i < (n); i++) {
cin >> a[i];
for (long long j = 1; j * j <= a[i]; j++) {
if (a[i] % j != 0) continue;
long long x = a[i] / j, y = j;
if (isprime(x) > 0) {
long long ct = 0;
long long temp = a[i];
while (temp % x == 0) {
temp /= x;
++ct;
}
vs[x].emplace_back(ct);
act.insert(x);
}
if (isprime(y) > 0) {
long long ct = 0;
long long temp = a[i];
while (temp % y == 0) {
temp /= y;
++ct;
}
vs[y].emplace_back(ct);
act.insert(y);
}
}
}
for (auto x : act) {
ans ^= brute(vs[x]);
}
if (ans)
cout << "Mojtaba";
else
cout << "Arpa";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int testcases;
cin >> testcases;
while (testcases--) {
long long n;
cin >> n;
string s;
cin >> s;
string req = "abacaba";
long long present = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == 'a') {
long long c = 1;
while (c < 7) {
if (i + c >= n) break;
if (s[i + c] != req[c]) break;
c++;
}
if (c == 7) present++;
}
}
if (present > 1) {
cout << "No\n";
continue;
}
if (present == 1) {
cout << "Yes\n";
for (long long i = 0; i < n; i++) {
if (s[i] == '?') s[i] = 'z';
}
cout << s << "\n";
} else {
long long complete = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == '?' || s[i] == 'a') {
string t = s;
t[i] = 'a';
long long c = 1;
while (c < 7) {
if (i + c >= n) break;
if (t[i + c] != req[c]) {
if (t[i + c] == '?') {
t[i + c] = req[c];
} else
break;
}
c++;
}
if (c != 7) continue;
c = 10;
if (i + c < n) {
string temp = t.substr(i + 4, 7);
if (temp == req) continue;
}
c = i - 4;
if (c >= 0) {
string temp = t.substr(c, 7);
if (temp == req) continue;
}
c = i - 6;
if (c >= 0) {
string temp = t.substr(c, 7);
if (temp == req) continue;
}
c = 12;
if (i + c < n) {
string temp = t.substr(i + 6, 7);
if (temp == req) continue;
}
s = t;
complete = 1;
break;
}
}
if (complete) {
cout << "Yes\n";
for (long long i = 0; i < n; i++) {
if (s[i] == '?') s[i] = 'z';
}
cout << s << "\n";
} else {
cout << "No\n";
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long long int n, k, d;
cin >> n >> k;
d = n / (2 * (k + 1));
cout << d << " " << k * d << " " << n - d * (k + 1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
ll n;
cin >> n;
int T[10];
for (int i = 0; i < 10; ++i) T[i] = 1;
int len = 2;
while (n > 0) {
len++;
T[n % 10]++;
n /= 10;
}
ll dp[len][11];
ll takes[len + 1][len + 1];
for (int i = 0; i < len; ++i) takes[i][0] = takes[i][i] = 1;
for (int i = 2; i < len; ++i)
for (int j = 1; j < i; ++j)
takes[i][j] = takes[i - 1][j] + takes[i - 1][j - 1];
int alr = 0;
for (int i = 0; i < len; ++i) dp[i][0] = (i == 0);
for (int i = 1; i < 10; ++i) {
if (T[i] == 1) {
for (int j = 0; j < len; ++j) dp[j][i] = dp[j][i - 1];
} else {
for (int j = 0; j < len; ++j) dp[j][i] = 0;
for (int j = 1; j < T[i]; ++j) {
for (int k = alr + j; k < len; ++k) {
dp[k][i] += dp[k - j][i - 1] * takes[k][j];
}
}
alr++;
}
}
int idx = 9;
if (T[0] > 1) {
idx = 10;
for (int j = 0; j < len; ++j) dp[j][10] = 0;
for (int j = 1; j < T[0]; ++j) {
for (int k = alr + j; k < len; ++k) {
dp[k][10] += dp[k - j][9] * takes[k - 1][j];
}
}
}
ll ans = 0;
for (int i = 0; i < len; ++i) ans += dp[i][idx];
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> map1;
vector<long long> getPathRoot(long long u) {
vector<long long> ans;
while (u) {
ans.push_back(u);
u /= 2;
}
reverse(ans.begin(), ans.end());
return ans;
}
vector<long long> getPath(long long u, long long v) {
vector<long long> path1 = getPathRoot(u), path2 = getPathRoot(v);
vector<long long> ans;
int index = -1;
for (int i = 0; i < min(path1.size(), path2.size()); i++) {
if (path1[i] != path2[i]) {
index = i;
break;
}
}
if (index == -1) index = min(path1.size(), path2.size());
for (int j = path1.size() - 1; j >= index; j--) {
ans.push_back(path1[j]);
}
ans.push_back(path1[index - 1]);
for (int j = index; j <= (path2.size() - 1); j++) {
ans.push_back(path2[j]);
}
return ans;
}
void printVector(vector<long long> df) {
for (int i = 0; i < df.size(); i++) {
printf("%d ", df[i]);
}
printf("\n");
}
void update(vector<long long> &path, long long w) {
for (int i = 1; i < path.size(); i++) {
long long max1 = max(path[i], path[i - 1]);
map1[max1] += w;
}
}
void query(vector<long long> &path) {
long long sum1 = 0;
for (int i = 1; i < path.size(); i++) {
long long max1 = max(path[i], path[i - 1]);
sum1 += map1[max1];
}
printf("%I64d\n", sum1);
}
int main() {
int q;
scanf("%d", &q);
while (q--) {
int type;
scanf("%d", &type);
if (type == 1) {
long long v, u, w;
scanf("%I64d %I64d %I64d", &v, &u, &w);
vector<long long> path = getPath(u, v);
update(path, w);
} else {
long long v, u;
scanf("%I64d %I64d", &v, &u);
vector<long long> path = getPath(u, v);
query(path);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> from(n - 1);
int c = 0;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
if (x != 0) from[c++] = x;
}
vector<int> to(n - 1);
c = 0;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
if (x != 0) to[c++] = x;
}
int st = 0;
while (st < n - 1 && from[0] != to[st]) ++st;
if (st == n - 1) {
cout << "NO\n";
return 0;
}
for (int i = 0; i < n - 1; ++i)
if (from[i] != to[(st + i) % (n - 1)]) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_SIZE = 500000;
int data[MAX_SIZE + 10], n;
int s[MAX_SIZE + 10], top;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", data + i);
long long ans = 0;
for (int i = 1; i <= n; i++) {
while (top > 1 && s[top - 2] >= s[top - 1] && data[i] >= s[top - 1]) {
ans += min(s[top - 2], data[i]);
--top;
}
s[top++] = data[i];
}
sort(s, s + top);
for (int i = 0; i < top - 2; i++) ans += s[i];
printf(
"%I64d"
"\n",
ans);
return 0;
}
| 8 |
//JSD
#include<iostream>
using namespace std;
int main(){
int t;
ios_base::sync_with_stdio(false); cin.tie(nullptr);
cin>>t;
while(t--){
int n;
cin>>n;
string s;
cin>>s;
bool res=0;
for(int i=0;i<=4;i++){
string s1=s.substr(0, i);
string s2=s.substr(n-1-(3-i), 4-i);
if(n-1-(3-i)>i-1){
if(s1+s2=="2020")
res=1;
}
}
if(res)
cout<<"YES\n";
else
cout<<"NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int fa[105];
struct node {
int x, y;
} a[105];
int fin(int u) {
if (fa[u] == u) return u;
return fa[u] = fin(fa[u]);
}
void un(int u, int v) {
int x = fin(u);
int y = fin(v);
fa[x] = y;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].x;
cin >> a[i].y;
}
for (int i = 0; i < 105; i++) {
fa[i] = i;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if ((a[i].x == a[j].x) || (a[i].y == a[j].y)) {
un(i, j);
}
}
}
int cnt = -1;
for (int i = 0; i < n; i++) {
if (fa[i] == i) cnt++;
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void cmin(T &a, T b) {
((a > b) && (a = b));
}
template <class T>
inline void cmax(T &a, T b) {
((a < b) && (a = b));
}
char IO;
template <class T = int>
T rd() {
T s = 0;
int f = 0;
while (!isdigit(IO = getchar())) f |= IO == '-';
do s = (s << 1) + (s << 3) + (IO ^ '0');
while (isdigit(IO = getchar()));
return f ? -s : s;
}
const int N = 5e5 + 10, P = 1e9 + 7;
int n, m;
struct Node {
int x, y, z;
Node() {}
Node(int x, int y, int z) : x(x), y(y), z(z) {}
Node operator*(const Node t) const {
return Node(1ll * x * t.x % P, (1ll * y * t.x + 1ll * t.y * x) % P,
(1ll * z * t.x + 1ll * t.z * x + 2ll * y * t.y) % P);
}
Node operator+(const Node t) const {
return Node((x + t.x) % P, (y + t.y) % P, (z + t.z) % P);
}
Node operator+(const int t) const {
return Node(x, (y + 1ll * t * x) % P,
(z + 2ll * y * t + 1ll * x * t % P * t % P) % P);
}
Node operator*(const int t) const {
return Node(1ll * x * t % P, 1ll * y * t % P, 1ll * z * t % P);
}
} dp[N][2], f[N][2][3];
struct Edge {
int to, nxt;
} e[N << 1];
int head[N], ecnt;
void AddEdge(int u, int v) {
e[++ecnt] = (Edge){v, head[u]};
head[u] = ecnt;
}
int low[N], t[N], dfn, stk[N], top;
int A[N], C;
void dfs(int u) {
low[u] = t[u] = ++dfn, stk[++top] = u;
dp[u][0] = Node(1, 0, 0), dp[u][1] = Node(1, 0, 0);
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (t[v]) {
cmin(low[u], t[v]);
continue;
}
dfs(v), cmin(low[u], low[v]);
if (low[v] < t[u]) continue;
A[C = 1] = u;
while (t[stk[top]] >= t[v]) A[++C] = stk[top--];
for (int i = 1, iend = C; i <= iend; ++i)
for (int a = 0, aend = 1; a <= aend; ++a)
for (int b = 0, bend = 2; b <= bend; ++b) f[i][a][b] = Node(0, 0, 0);
f[1][0][0] = dp[u][0], f[1][1][2] = dp[u][1];
for (int i = 2, iend = C; i <= iend; ++i) {
for (int a = 0, aend = 1; a <= aend; ++a)
for (int b = 0, bend = 2; b <= bend; ++b) {
for (int c = 0, cend = 1; c <= cend; ++c) {
int d = c == 1 && b == 2 ? b : c;
f[i][a][d] =
f[i][a][d] + (f[i - 1][a][b] * dp[A[i]][c] + (b == 1 && !c));
}
}
}
dp[u][0] = dp[u][1] = Node(0, 0, 0);
for (int a = 0, aend = 1; a <= aend; ++a)
for (int b = 0, bend = 2; b <= bend; ++b) {
dp[u][a] = dp[u][a] + (f[C][a][b] + (b == 1 && !a));
}
}
}
int main() {
n = rd(), m = rd();
for (int i = 1, iend = m; i <= iend; ++i) {
int u = rd(), v = rd();
AddEdge(u, v), AddEdge(v, u);
}
dfs(1);
int base = 1;
for (int i = 1, iend = n; i <= iend; ++i) base = 1ll * base * (P + 1) / 2 % P;
Node ans = dp[1][0] + (dp[1][1] + 1);
ans = ans * base;
int D = ((ans.z - 1ll * ans.y * ans.y) % P + P) % P;
printf("%d\n", D);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105, M = N * N * N;
int n, pos, l, r, i, j, k, f[N][N][N], h, t, q[M][3], ans;
inline void ext(int x, int y, int z, int d) {
if (y > z) return;
if (y > l || z < r) return;
if (x < y || x > z) return;
if (~f[x][y][z]) return;
f[x][y][z] = d;
q[++t][0] = x;
q[t][1] = y;
q[t][2] = z;
}
int main() {
scanf("%d%d%d%d", &n, &pos, &l, &r);
for (i = 1; i <= n; i++)
for (j = 1; j <= l; j++)
for (k = r; k <= n; k++) f[i][j][k] = -1;
h = 1;
t = 0;
ext(pos, 1, n, 0);
while (h <= t) {
int x, y, z, w;
x = q[h][0];
y = q[h][1];
z = q[h++][2];
w = f[x][y][z] + 1;
ext(x - 1, y, z, w);
ext(x + 1, y, z, w);
ext(x, x, z, w);
ext(x, y, x, w);
}
ans = ~0U >> 1;
for (i = 1; i <= n; i++)
if (~f[i][l][r]) ans = min(ans, f[i][l][r]);
printf("%d", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mini(long long a, long long b) { return (a <= b) ? a : b; }
long long maxi(long long a, long long b) { return (a >= b) ? a : b; }
int main() {
ios_base::sync_with_stdio(false);
int a[26];
char x[1000];
for (int I = 0; I < 26; I++) a[I] = 0;
int tb, tf;
cin >> tb >> tf;
cin >> x;
for (int I = 0; I < strlen(x); I++) {
a[(int)x[I] - 97]++;
}
bool flag = true;
for (int I = 0; I < tf; I++) {
for (int J = 0; J < 26; J++) {
if (a[J] > 0) a[J]--;
}
}
for (int I = 0; I < 26; I++) {
if (a[I] > 0) flag = false;
}
if (flag)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long d = n / (2 * (k + 1));
cout << d << " " << k * d << " " << n - (k * d + d);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[405], ans[25][25], maxx, num[1005];
struct node {
int num, id;
};
queue<int> q[1005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n * n; i++) {
scanf("%d", &a[i]);
num[a[i]]++;
maxx = max(maxx, a[i]);
}
for (int i = 1; i <= maxx; i++)
if (num[i]) q[num[i]].push(i);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (ans[i][j]) continue;
int x1 = i, y = j;
int x2 = i, y2 = n - j + 1;
int x3 = n - i + 1, y3 = j;
int x4 = n - i + 1, y4 = n - j + 1;
if (x1 == x2 && y == y2 && x3 == x1 && y3 == y) {
int f = 0;
for (int k = 1; k <= n * n; k++) {
if (q[k].size()) {
f = 1;
int t = q[k].front();
q[k].pop(), num[t]--;
q[num[t]].push(t);
ans[i][j] = t;
break;
}
}
if (!f) {
printf("NO\n");
return 0;
}
} else if (x1 == x2 && y == y2) {
int f = 0;
for (int k = 2; k <= n * n; k++) {
if (q[k].size()) {
f = 1;
int t = q[k].front();
q[k].pop(), num[t] -= 2;
q[num[t]].push(t);
ans[i][j] = t, ans[x3][y3] = t;
break;
}
}
if (!f) {
printf("NO\n");
return 0;
}
} else if (x1 == x3 && y == y3) {
int f = 0;
for (int k = 2; k <= n * n; k++) {
if (q[k].size()) {
f = 1;
int t = q[k].front();
q[k].pop(), num[t] -= 2;
q[num[t]].push(t);
ans[i][j] = t, ans[x2][y2] = t;
break;
}
}
if (!f) {
printf("NO\n");
return 0;
}
} else {
int f = 0;
for (int k = 4; k <= n * n; k++) {
if (q[k].size()) {
f = 1;
int t = q[k].front();
q[k].pop(), num[t] -= 4;
q[num[t]].push(t);
ans[i][j] = t, ans[x2][y2] = t, ans[x3][y3] = t, ans[x4][y4] = t;
break;
}
}
if (!f) {
printf("NO\n");
return 0;
}
}
}
}
printf("YES\n");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
printf("%d ", ans[i][j]);
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int SIZE = 1 << 20;
char buf[SIZE + 10], *iS, *iT;
inline char Getc() {
return iS == iT && (iT = (iS = buf) + fread(buf, 1, SIZE, stdin), iS == iT)
? EOF
: *iS++;
}
template <class TT>
inline void Read(TT &x) {
x = 0;
register char cc = '\0';
TT fff = 1;
for (; cc < '0' || cc > '9'; cc = Getc())
if (cc == '-') fff = -1;
for (; cc >= '0' && cc <= '9'; cc = Getc())
x = (x << 1) + (x << 3) + (cc & 15);
x *= fff;
}
} // namespace IO
using IO::Read;
const int N = 1e5 + 10;
int n, K, fans, Top, Stack[N], a[N], b[N];
long long f[N], g[N];
namespace Seg {
long long Tree[N * 4 + 10], Original[N * 4 + 10], Lazy[N * 4 + 10];
inline void Pushup(int x) {
if (x) Tree[x] = max(Tree[(x << 1)], Tree[(x << 1 | 1)]);
}
inline void Pushdown(int x) {
if (!Lazy[x]) return;
Lazy[(x << 1)] += Lazy[x], Tree[(x << 1)] += Lazy[x];
Lazy[(x << 1 | 1)] += Lazy[x], Tree[(x << 1 | 1)] += Lazy[x];
Lazy[x] = 0;
}
void Build(long long *A, int x = 1, int nl = 1, int nr = n) {
if (nl == nr) {
Tree[x] = Original[x] = A[nl];
return;
}
int nm = (nl + nr) >> 1;
Build(A, (x << 1), nl, nm), Build(A, (x << 1 | 1), nm + 1, nr);
Original[x] = max(Original[(x << 1)], Original[(x << 1 | 1)]), Pushup(x);
}
void Update(int el, int er, long long ad, int x = 1, int nl = 1, int nr = n) {
if (el <= nl && nr <= er) {
Tree[x] += ad, Lazy[x] += ad;
return;
}
int nm = (nl + nr) >> 1;
Pushdown(x);
if (el <= nm) Update(el, er, ad, (x << 1), nl, nm);
if (er > nm) Update(el, er, ad, (x << 1 | 1), nm + 1, nr);
Pushup(x);
}
int wantx, wantnl, wantnr;
long long premaxh, wantmaxh;
int FinalFind(int x, int nl, int nr, long long lim) {
if (nl == nr) {
return nr;
}
int nm = (nl + nr) >> 1;
Pushdown(x);
if (max(lim, Tree[(x << 1)]) <= Original[(x << 1 | 1)] + K) {
return FinalFind((x << 1 | 1), nm + 1, nr, max(lim, Tree[(x << 1)]));
}
return FinalFind((x << 1), nl, nm, lim);
}
void PreFind(int el, int er, int x = 1, int nl = 1, int nr = n) {
if (el <= nl && nr <= er) {
if (premaxh <= Original[x] + K)
wantmaxh = premaxh, wantx = x, wantnl = nl, wantnr = nr;
premaxh = max(premaxh, Tree[x]);
return;
}
int nm = (nl + nr) >> 1;
Pushdown(x);
if (el <= nm) PreFind(el, er, (x << 1), nl, nm);
if (er > nm) PreFind(el, er, (x << 1 | 1), nm + 1, nr);
}
long long Query(int ed, int x = 1, int nl = 1, int nr = n) {
if (nl == nr) return Tree[x];
int nm = (nl + nr) >> 1;
Pushdown(x);
if (ed <= nm)
return Query(ed, (x << 1), nl, nm);
else
return Query(ed, (x << 1 | 1), nm + 1, nr);
}
} // namespace Seg
int main() {
Read(n), Read(K);
for (int i = 1; i < n; ++i) Read(b[i]);
for (int i = 1; i <= n; ++i) Read(a[i]);
f[0] = f[1] = g[0] = g[1] = 0;
for (int i = 2; i <= n; ++i) {
f[i] = f[i - 1] + (a[i - 1] - b[i - 1]);
g[i] = g[i - 1] + (a[i] - b[i - 1]);
}
Seg::Build(g);
Stack[++Top] = n, fans = 1;
for (int i = n - 1; i >= 1; --i) {
while (Top > 0 && f[Stack[Top]] >= f[i]) {
if (Top != 1)
Seg::Update(Stack[Top - 1] - 1, n,
-(f[Stack[Top]] - f[Stack[Top - 1]]));
--Top;
}
if (Top != 0) Seg::Update(Stack[Top] - 1, n, f[i] - f[Stack[Top]]);
Stack[++Top] = i;
int L = 1, R = Top, mid = 0, fps = n + 1;
while (L <= R) {
mid = (L + R) >> 1;
if (f[i] - f[Stack[mid]] > K)
fps = Stack[mid], L = mid + 1;
else
R = mid - 1;
}
Seg::premaxh = Seg::wantmaxh = -0x3f3f3f3f3f3f3f3fLL;
Seg::wantx = 1, Seg::wantnl = 1, Seg::wantnr = n;
Seg::PreFind(i, fps - 1);
int rightpos =
Seg::FinalFind(Seg::wantx, Seg::wantnl, Seg::wantnr, Seg::wantmaxh);
fans = max(fans, rightpos - i + 1);
}
printf("%d\n", fans);
return 0;
}
| 12 |
#include<bits/stdc++.h>
using namespace std;
const int N=1000005;
int T,n,x,a[N],cnt[N],q;
long long k;
int main(){
scanf("%d",&T);
while (T--){
scanf("%d",&n);
for (int i=1;i<=n;i++){
scanf("%d",&x);
a[i]=1;
for (int j=2;j*j<=x;j++)
if (x%j==0){
int flag=0;
while (x%j==0)x/=j,flag^=1;
if (flag)a[i]*=j;
}
a[i]*=x;
cnt[a[i]]++;
}
int ans1=0,ans2=0;
for (int i=1;i<=n;i++)ans1=max(ans1,cnt[a[i]]);
for (int i=1;i<=n;i++)
if (a[i]!=1&&cnt[a[i]]%2==0)cnt[1]+=cnt[a[i]],cnt[a[i]]=0;
for (int i=1;i<=n;i++)ans2=max(ans2,cnt[a[i]]);
ans2=max(ans2,cnt[1]);
for (int i=1;i<=n;i++)cnt[a[i]]=0;
cnt[1]=0;
scanf("%d",&q);
while (q--){
scanf("%lld",&k);
if (k==0)printf("%d\n",ans1);
else printf("%d\n",ans2);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200;
int n, t, i, a[maxn], dem[maxn], s, d[maxn], ans, j, dem1[maxn];
int main() {
cin >> t;
for (int l = 1; l <= t; ++l) {
cin >> n;
memset(dem, 0, sizeof(dem));
for (i = 1; i <= n; ++i) {
cin >> a[i];
++dem[a[i]];
}
memset(d, 0, sizeof(d));
memset(dem1, 0, sizeof(dem1));
ans = 0;
for (j = 2; j <= 105; ++j) {
for (i = 1; i <= n; ++i) dem1[a[i]] = dem[a[i]];
for (i = 1; i <= n; ++i)
if ((dem1[a[i]] > 0) && (j - a[i]) > 0 && (dem1[j - a[i]] > 0)) {
if (a[i] != (j - a[i])) {
++d[j];
--dem1[a[i]];
--dem1[j - a[i]];
} else {
if (dem1[a[i]] >= 2) {
++d[j];
dem1[a[i]] -= 2;
}
}
}
ans = max(ans, d[j]);
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline bool isLow(char ch) {
if (ch >= 'a' && ch <= 'z') return true;
return false;
}
inline bool isUpp(char ch) {
if (ch >= 'A' && ch <= 'Z') return true;
return false;
}
inline bool isDig(char ch) {
if (ch >= '0' && ch <= '9') return true;
return false;
}
inline bool are_equal(double a, double b) {
return fabs(a - b) < numeric_limits<double>::epsilon();
}
inline bool greater_than(double a, double b) {
return (a - b) > ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) *
numeric_limits<double>::epsilon());
}
inline bool less_than(double a, double b) {
return (b - a) > ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) *
numeric_limits<double>::epsilon());
}
template <typename T>
string toString(T x) {
stringstream ss;
ss << x;
return ss.str();
}
template <typename T>
T SOD(T n) {
__typeof(n) sum = 0, i = 1;
for (; i * i <= n; i++)
sum += (n % i) ? 0 : ((((i) * (i)) == n) ? i : i + n / i);
return sum;
}
template <typename T>
T stringToT(string s, T a) {
T p;
istringstream ss(s);
ss >> p;
return p;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (int i = 0; i < v.size(); i++) {
os << v[i];
if (i != (int)v.size() - 1) os << ", ";
}
os << "]";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[";
for (auto it : v) {
os << it;
if (it != *v.rbegin()) os << ", ";
}
os << "]";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const map<T, S>& v) {
for (auto it : v) os << it.first << " : " << it.second << '\n';
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
os << "(" << v.first << ", " << v.second << ")";
return os;
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res *= a;
a = ((a) * (a));
b >>= 1;
}
return res;
}
long long bigmod(long long a, long long b, long long m) {
long long res = 1;
while (b) {
if (b & 1) {
res = ((res % m) * (a % m)) % m;
}
a = ((a % m) * (a % m)) % m;
b >>= 1;
}
return res;
}
long long modInverse(long long a, long long m) { return bigmod(a, m - 2, m); }
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
int n;
int r1, r2, c1, c2;
char s[55][55];
int b[55][55];
int flag = 0;
void dfs(int i, int j, int k) {
b[i][j] = k;
for (__typeof(4 - 1) it = (0); it <= (4 - 1); it++) {
int ii = i + dx[it];
int jj = j + dy[it];
if (ii >= 0 && ii < n && jj >= 0 && jj < n) {
if (k > 1 && b[ii][jj] == 1) {
flag = 1;
return;
}
if (s[ii][jj] == '0' && b[ii][jj] == 0) dfs(ii, jj, k);
}
}
}
int main() {
scanf("%d", &n);
scanf("%d %d", &r1, &c1);
scanf("%d %d", &r2, &c2);
r1--;
c1--;
r2--;
c2--;
for (__typeof(n - 1) i = (0); i <= (n - 1); i++) scanf("%s", s[i]);
dfs(r1, c1, 1);
dfs(r2, c2, 2);
if (flag || (r1 == r2 && c1 == c2))
puts("0");
else {
vector<pair<int, int> > vs;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (b[i][j] == 2) vs.push_back({i, j});
int ans = INT_MAX;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (b[i][j] == 1) {
for (int k = 0; k < (int)vs.size(); k++)
ans = min(ans, ((i - vs[k].first) * (i - vs[k].first)) +
((j - vs[k].second) * (j - vs[k].second)));
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[100010];
int main() {
long long n, pos;
while (cin >> n >> pos) {
for (long long i = 0; i < n; i++) scanf("%I64d", &a[i]);
sort(a, a + n);
long long res1 = 0, res2, res;
if (pos < a[0])
res1 = a[n - 2] - pos;
else if (a[0] <= pos && pos <= a[n - 2])
res1 = min((pos - a[0]) * 2 + a[n - 2] - pos,
(a[n - 2] - pos) * 2 + pos - a[0]);
else if (pos > a[n - 2])
res1 = pos - a[0];
if (pos < a[1])
res2 = a[n - 1] - pos;
else if (a[1] <= pos && pos <= a[n - 1])
res2 = min((pos - a[1]) * 2 + a[n - 1] - pos,
(a[n - 1] - pos) * 2 + pos - a[1]);
else if (pos > a[n - 1])
res2 = pos - a[1];
res = min(res1, res2);
if (n == 1) res = 0;
printf("%I64d\n", res);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 82;
vector<pair<int, int> > g[N];
int dp[N][N][N][N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
int m;
cin >> m;
for (int i = 0; (i) < (m); ++i) {
int u, v, c;
cin >> u >> v >> c;
g[u].push_back(make_pair(v, c));
}
for (int i = 0; (i) < (N); ++i)
for (int j = 0; (j) < (N); ++j)
for (int k = 0; (k) < (N); ++k)
for (int q = 0; (q) < (N); ++q) dp[i][j][k][q] = -1;
for (int i = (1); (i) < (n + 1); ++i) dp[1][i][0][n + 1] = 0;
for (int vis = (1); (vis) < (k); ++vis) {
for (int pos = (1); (pos) < (n + 1); ++pos) {
for (int mn = 0; (mn) < (N); ++mn) {
for (int mx = (mn + 2); (mx) < (N); ++mx) {
if (dp[vis][pos][mn][mx] == -1) continue;
int c = dp[vis][pos][mn][mx];
for (pair<int, int> nxt : g[pos]) {
int to = nxt.first, cost = nxt.second + c;
if (to > mn && to < mx) {
if (to > pos) {
if (dp[vis + 1][to][pos][mx] == -1 ||
dp[vis + 1][to][pos][mx] > cost) {
dp[vis + 1][to][pos][mx] = cost;
}
} else {
if (dp[vis + 1][to][mn][pos] == -1 ||
dp[vis + 1][to][mn][pos] > cost) {
dp[vis + 1][to][mn][pos] = cost;
}
}
}
}
}
}
}
}
int best = 1000000000;
for (int i = 0; (i) < (N); ++i) {
for (int j = 0; (j) < (N); ++j) {
for (int q = 0; (q) < (N); ++q) {
if (dp[k][i][j][q] != -1) best = min(best, dp[k][i][j][q]);
}
}
}
if (best == 1000000000)
cout << -1 << '\n';
else
cout << best << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct point {
ll x, y;
};
struct line {
ll a, b, c;
line(point A, point B) {
a = B.y - A.y;
b = A.x - B.x;
c = -(a * A.x + b * A.y);
}
bool up(point P) { return a * P.x + b * P.y + c > 0; }
};
int n;
vector<point> p;
vector<line> l;
ll S(point a, point b, point c) {
return abs((b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
ll x, y;
cin >> x >> y;
p.push_back({x, y});
}
ll ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
ll up = -1e9 - 7, down = -1e9 - 7;
line li = line(p[i], p[j]);
for (int k = 0; k < i; ++k) {
if (li.up(p[k]))
up = max(up, S(p[i], p[j], p[k]));
else
down = max(down, S(p[i], p[j], p[k]));
}
for (int k = i + 1; k < j; ++k) {
if (li.up(p[k]))
up = max(up, S(p[i], p[j], p[k]));
else
down = max(down, S(p[i], p[j], p[k]));
}
for (int k = j + 1; k < n; ++k) {
if (li.up(p[k]))
up = max(up, S(p[i], p[j], p[k]));
else
down = max(down, S(p[i], p[j], p[k]));
}
ans = max(ans, up + down);
}
}
cout << ans / 2;
if (ans % 2) cout << ".5";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int rela[2000][2000];
int par[2000];
bool dislike[2000][2000];
void init_par(int n) {
for (int i = 0; i < (n); i++) par[i] = i;
}
int root(int x) { return (par[x] == x ? x : par[x] = root(par[x])); }
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
(y < x ? par[x] = y : par[y] = x);
}
}
bool same(int x, int y) { return (root(x) == root(y)); }
int main() {
memset(rela, 0, sizeof(rela));
memset(dislike, false, sizeof(dislike));
int n;
scanf("%d", &n);
init_par(n);
int k;
scanf("%d", &k);
for (int i = 0; i < (k); i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
unite(a, b);
}
int m;
scanf("%d", &m);
for (int i = 0; i < (m); i++) {
int c, d;
scanf("%d %d", &c, &d);
c--;
d--;
dislike[c][d] = true;
dislike[d][c] = true;
}
map<int, int> group;
vector<int> acqu(n);
for (int i = 0; i < (n); i++) {
group[root(i)]++;
acqu[i] = root(i);
}
int res = 0;
map<int, int>::iterator it = group.begin();
for (; it != group.end(); it++) {
int g = (*it).first;
bool found = false;
if ((*it).second > res) {
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++)
if (i != j && g == acqu[i] && g == acqu[j]) {
if (dislike[i][j]) {
found = true;
break;
}
}
if (!found) {
res = (*it).second;
}
}
}
printf("%d\n", res);
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define ld long double
#define ll long long
#define pb push_back
#define mp make_pair
#define f(i,n) for(ll i=0;i<n;i++)
#define fa(i,a,b) for(ll i=a;i<=b;i++)
#define fr(i,n) for(ll i=n-1;i>=0;i--)
#define fi first
#define se second
#define vll vector<ll>
#define mll map<ll,ll>
#define sll set<ll>
#define pll pair<ll,ll>
#define endl "\n"
#define all(a) a.begin(),a.end()
#define en cout<<endl;
#define deb(x) cout<<#x<<" "<<x<<" ";
#define csp(x) cout<<fixed<<setprecison(x)
#define setbits(x) __builtin_popcount(x)
#define an ll n;cin>>n;ll a[n];f(i,n)cin>>a[i];
int main()
{
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll t;
cin>>t;
while(t--)
{
int x;
cin>>x;
if(x>45)cout<<-1;
else
{
vector<ll>ans;
fa(i,1,9)
{
map<ll,ll>m;
ll temp=x;
ll c=i;
while(temp>0)
{
if(temp>=c)
{ if(c>9)
break;
temp-=c;
m[c]++;
c++;
}
else
{
if(temp<=9&&m.find(temp)==m.end())
m[temp]++, temp-=temp;
else break;
}
}
if(temp==0)
{
ll s=0;
for(auto x:m)
s=s*10+x.fi;
ans.pb(s);
//cout<<s<<" "<<i<<endl;
}
}
cout<<*min_element(all(ans));
}
en
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void fileioe() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("error.txt", "w", stderr);
}
const int maxr = 1e6 + 5;
vector<long long int> adj[maxr];
bool visited[maxr];
long long int dfs(long long int start) {
visited[start] = true;
long long int ans = 0;
for (auto x : adj[start]) {
if (visited[x]) {
continue;
}
ans += dfs(x);
}
return ans + 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
1;
long long int n;
cin >> n;
long long int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
adj[i + 1].push_back(arr[i]);
adj[arr[i]].push_back(i + 1);
}
memset(visited, 0, sizeof(visited));
long long int ans = 0;
for (int i = 0; i < n; i++) {
if (!visited[i + 1]) {
ans += dfs(i + 1) - 1;
}
}
if (ans % 2 == (3 * n) % 2) {
cout << "Petr" << endl;
} else {
cout << "Um_nik" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a;
int n, cnt[26] = {0};
bool OK = true;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
if (a >= 'A' && a <= 'Z') a += 32;
if (a >= 'a' && a <= 'z') cnt[a - 97]++;
}
for (int i = 0; i < 26; i++) {
if (cnt[i] == 0) {
OK = false;
break;
}
}
if (!OK)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e17;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
const char dir[4] = {'U', 'R', 'D', 'L'};
inline int mabs(int x) { return (x > 0 ? x : -x); }
const int N = 400010;
int arr[N];
long long when[N], dist[N], qt[N];
int pv[55][N];
long long pt[55][N];
int xa[N], ya[N], xb[N], yb[N], arrd[N];
int wx[N], wy[N], wd[N];
int n, b, q;
bool swapx[N], swapy[N];
int ke;
int e[N], el[N], er[N], en[N], rght[N];
bool good[N];
void Sort(int l, int r) {
int i = l, j = r;
int x = e[(l + r) >> 1];
int xx = el[(l + r) >> 1];
do {
while (e[i] < x || e[i] == x && el[i] > xx) i++;
while (x < e[j] || x == e[j] && xx > el[j]) j--;
if (i <= j) {
int tmp = e[i];
e[i] = e[j];
e[j] = tmp;
tmp = el[i];
el[i] = el[j];
el[j] = tmp;
tmp = er[i];
er[i] = er[j];
er[j] = tmp;
tmp = en[i];
en[i] = en[j];
en[j] = tmp;
i++;
j--;
}
} while (i <= j);
if (l < j) Sort(l, j);
if (i < r) Sort(i, r);
}
bool push[N];
int tree[N];
void build(int x, int l, int r) {
push[x] = false;
tree[x] = 0;
if (l < r) {
build(x + x, l, (l + r) >> 1);
build(x + x + 1, ((l + r) >> 1) + 1, r);
}
}
void put(int x, int l, int r, int ll, int rr, int v) {
if (l >= ll && r <= rr) {
push[x] = true;
tree[x] = v;
return;
}
if (push[x]) {
push[x + x] = true;
push[x + x + 1] = true;
tree[x + x] = tree[x];
tree[x + x + 1] = tree[x];
push[x] = false;
}
int y = (l + r) >> 1;
if (ll <= y) put(x + x, l, y, ll, rr, v);
if (rr > y) put(x + x + 1, y + 1, r, ll, rr, v);
}
int get(int x, int l, int r, int p) {
if (l == r || push[x]) return tree[x];
int y = (l + r) >> 1;
if (p <= y) return get(x + x, l, y, p);
return get(x + x + 1, y + 1, r, p);
}
void get_next_all() {
for (int i = 1; i <= n; i++) {
swapx[i] = false;
swapy[i] = false;
if (xa[i] > xb[i]) {
int tmp = xa[i];
xa[i] = xb[i];
xb[i] = tmp;
swapx[i] = true;
}
if (ya[i] > yb[i]) {
int tmp = ya[i];
ya[i] = yb[i];
yb[i] = tmp;
swapy[i] = true;
}
}
for (int i = 1; i <= n + q; i++) {
if (wx[i] < 0 || wy[i] < 0 || wx[i] > b || wy[i] > b) {
good[i] = false;
arr[i] = 0;
} else
good[i] = true;
}
{
for (int i = 1; i <= n; i++) {
e[i - 1] = xa[i];
el[i - 1] = ya[i];
er[i - 1] = yb[i];
en[i - 1] = i;
rght[i] = xb[i];
}
ke = n;
for (int i = 1; i <= n + q; i++) {
if (wd[i] == 3 && good[i]) {
e[ke] = wx[i];
el[ke] = ~wy[i];
en[ke] = i;
ke++;
}
}
Sort(0, ke - 1);
build(1, 0, b);
for (int i = 0; i < ke; i++)
if (el[i] >= 0) {
put(1, 0, b, el[i], er[i], en[i]);
} else {
int num = get(1, 0, b, ~el[i]);
arr[en[i]] = num;
when[en[i]] = e[i] - rght[num];
}
}
{
for (int i = 1; i <= n; i++) {
e[i - 1] = -xb[i];
el[i - 1] = ya[i];
er[i - 1] = yb[i];
en[i - 1] = i;
rght[i] = -xa[i];
}
ke = n;
for (int i = 1; i <= n + q; i++) {
if (wd[i] == 1 && good[i]) {
e[ke] = -wx[i];
el[ke] = ~wy[i];
en[ke] = i;
ke++;
}
}
Sort(0, ke - 1);
build(1, 0, b);
for (int i = 0; i < ke; i++)
if (el[i] >= 0) {
put(1, 0, b, el[i], er[i], en[i]);
} else {
int num = get(1, 0, b, ~el[i]);
arr[en[i]] = num;
when[en[i]] = e[i] - rght[num];
}
}
{
for (int i = 1; i <= n; i++) {
e[i - 1] = ya[i];
el[i - 1] = xa[i];
er[i - 1] = xb[i];
en[i - 1] = i;
rght[i] = yb[i];
}
ke = n;
for (int i = 1; i <= n + q; i++) {
if (wd[i] == 2 && good[i]) {
e[ke] = wy[i];
el[ke] = ~wx[i];
en[ke] = i;
ke++;
}
}
Sort(0, ke - 1);
build(1, 0, b);
for (int i = 0; i < ke; i++)
if (el[i] >= 0) {
put(1, 0, b, el[i], er[i], en[i]);
} else {
int num = get(1, 0, b, ~el[i]);
arr[en[i]] = num;
when[en[i]] = e[i] - rght[num];
}
}
{
for (int i = 1; i <= n; i++) {
e[i - 1] = -yb[i];
el[i - 1] = xa[i];
er[i - 1] = xb[i];
en[i - 1] = i;
rght[i] = -ya[i];
}
ke = n;
for (int i = 1; i <= n + q; i++) {
if (wd[i] == 0 && good[i]) {
e[ke] = -wy[i];
el[ke] = ~wx[i];
en[ke] = i;
ke++;
}
}
Sort(0, ke - 1);
build(1, 0, b);
for (int i = 0; i < ke; i++)
if (el[i] >= 0) {
put(1, 0, b, el[i], er[i], en[i]);
} else {
int num = get(1, 0, b, ~el[i]);
arr[en[i]] = num;
when[en[i]] = e[i] - rght[num];
}
}
for (int i = 1; i <= n + q; i++) {
if (arr[i] == 0) when[i] = inf;
if (when[i] < 0) when[i] = 0;
}
for (int i = 1; i <= n; i++) {
if (swapx[i]) {
int tmp = xa[i];
xa[i] = xb[i];
xb[i] = tmp;
}
if (swapy[i]) {
int tmp = ya[i];
ya[i] = yb[i];
yb[i] = tmp;
}
}
}
int main() {
scanf("%d %d", &n, &b);
for (int i = 1; i <= n; i++) {
scanf("%d %d %d %d", xa + i, ya + i, xb + i, yb + i);
if (yb[i] > ya[i])
arrd[i] = 0;
else if (xb[i] > xa[i])
arrd[i] = 1;
else if (yb[i] < ya[i])
arrd[i] = 2;
else
arrd[i] = 3;
wx[i] = xb[i] + dx[arrd[i]];
wy[i] = yb[i] + dy[arrd[i]];
wd[i] = arrd[i];
}
scanf("%d", &q);
for (int i = n + 1; i <= n + q; i++) {
char foo;
scanf("%d %d %c %I64d", wx + i, wy + i, &foo, qt + i);
wd[i] = 0;
for (int j = 0; j < 4; j++)
if (foo == dir[j]) wd[i] = j;
}
get_next_all();
for (int i = 1; i <= n + q; i++)
if (arr[i] == 0)
dist[i] = inf;
else
dist[i] = mabs(wx[i] - xb[arr[i]]) + mabs(wy[i] - yb[arr[i]]);
arr[0] = 0;
when[0] = inf;
dist[0] = inf;
for (int i = 0; i <= n; i++) pv[0][i] = arr[i], pt[0][i] = dist[i] + 1;
for (int j = 1; j <= 50; j++)
for (int i = 0; i <= n; i++) {
pv[j][i] = pv[j - 1][pv[j - 1][i]];
pt[j][i] = pt[j - 1][i] + pt[j - 1][pv[j - 1][i]];
if (pt[j][i] > inf) pt[j][i] = inf;
}
for (int i = n + 1; i <= n + q; i++) {
if (qt[i] <= dist[i]) {
if (qt[i] <= when[i]) {
long long ax = wx[i] + dx[wd[i]] * qt[i];
long long ay = wy[i] + dy[wd[i]] * qt[i];
if (ax < 0) ax = 0;
if (ay < 0) ay = 0;
if (ax > b) ax = b;
if (ay > b) ay = b;
printf("%d %d\n", (int)ax, (int)ay);
continue;
}
long long ax = wx[i] + dx[wd[i]] * when[i];
long long ay = wy[i] + dy[wd[i]] * when[i];
ax += dx[arrd[arr[i]]] * (qt[i] - when[i]);
ay += dy[arrd[arr[i]]] * (qt[i] - when[i]);
if (ax < 0) ax = 0;
if (ay < 0) ay = 0;
if (ax > b) ax = b;
if (ay > b) ay = b;
printf("%d %d\n", (int)ax, (int)ay);
continue;
}
qt[i] -= dist[i];
int where = arr[i];
for (int j = 50; j >= 0; j--)
if (pt[j][where] <= qt[i]) {
qt[i] -= pt[j][where];
where = pv[j][where];
}
if (arr[where] == 0 || qt[i] <= when[where] + 1) {
long long ax = xb[where] + dx[arrd[where]] * qt[i];
long long ay = yb[where] + dy[arrd[where]] * qt[i];
if (ax < 0) ax = 0;
if (ay < 0) ay = 0;
if (ax > b) ax = b;
if (ay > b) ay = b;
printf("%d %d\n", (int)ax, (int)ay);
continue;
}
int ax = xb[where] + dx[arrd[where]] * (when[where] + 1);
int ay = yb[where] + dy[arrd[where]] * (when[where] + 1);
ax += dx[arrd[arr[where]]] * (qt[i] - (when[where] + 1));
ay += dy[arrd[arr[where]]] * (qt[i] - (when[where] + 1));
printf("%d %d\n", ax, ay);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
string s;
int n, k;
cin >> n >> k >> s;
vector<int> a(n);
int ne = n / 2 - k;
for (int i = 0, ThxDem = 2 * (k - 1); i < ThxDem; ++i) a[i] = i % 2;
for (int i = 2 * (k - 1), ThxDem = n; i < ThxDem; ++i)
a[i] = i - 2 * (k - 1) > ne;
cout << n << "\n";
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
int wh = -1;
if (!a[i]) {
for (int j = i, ThxDem = n; j < ThxDem; ++j)
if (s[j] == '(' && wh == -1) wh = j;
} else {
for (int j = i, ThxDem = n; j < ThxDem; ++j)
if (s[j] == ')' && wh == -1) wh = j;
}
cout << i + 1 << " " << wh + 1 << "\n";
reverse(s.begin() + i, s.begin() + wh + 1);
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const double PI = 3.14159265358979323846264338f;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const int MAXN = 1005;
inline int read() {
int c = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
c = c * 10 + ch - '0';
ch = getchar();
}
return c * f;
}
struct node {
int w, h;
} e[MAXN];
int n;
int ans = inf;
bool vis[MAXN];
int main() {
n = read();
for (int i = 1; i <= n; i++) {
e[i].w = read();
e[i].h = read();
}
auto solve = [](int x) -> void {
memset(vis, false, sizeof(vis));
priority_queue<int> q;
int tot = 0;
int w = 0;
for (int i = 1; i <= n; i++) {
if (e[i].h > x) {
vis[i] = true;
tot++;
w += e[i].h;
if (e[i].w > x) return;
}
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
if (e[i].w <= x) q.push(e[i].w - e[i].h);
w += e[i].w;
}
}
while (tot < n / 2 && !q.empty()) {
int ww = q.top();
q.pop();
if (ww > 0) {
w -= ww;
tot++;
} else
break;
}
if (tot <= n / 2) ans = min(ans, w * x);
};
for (int i = 1; i <= 1000; i++) {
solve(i);
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
double second, x1, x2, t1, t2, p, d, ans;
int main() {
cin >> second >> x1 >> x2;
cin >> t1 >> t2;
cin >> p >> d;
int y = d;
ans = abs(x2 - x1) * t2;
for (int i = 0; i <= second; i += 1) {
double cur1 = abs(x1 - i) * t2;
double cur2 = 0;
double res = 0;
d = y;
if (p > i) {
if (d == 1) {
cur2 = (second - p) * t1 + (second - i) * t1;
d = -1;
} else {
cur2 = abs(i - p) * t1;
}
} else {
if (d == 1) {
cur2 = abs(i - p) * t1;
} else {
cur2 = p * t1 + i * t1;
d = 1;
}
}
if (p == i) cur2 = 0, d = y;
if (cur2 < cur1) continue;
if (d == 1) {
if (x2 > i) {
res = (x2 - i) * t1;
} else {
res = (second - i) * t1 + (second - x2) * t1;
}
} else {
if (x2 > i) {
res = (i + x2) * t1;
} else {
res = (i - x2) * t1;
}
}
ans = min(ans, cur2 + res);
}
cout << (int)ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, a, b, k;
cin >> n >> a >> b;
set<int> c;
for (int i = 0; i < a; i++) {
cin >> k;
c.insert(k);
}
for (int i = 1; i <= n; i++) {
if (c.find(i) != c.end())
cout << 1 << " ";
else
cout << 2 << " ";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int dim;
int val[5];
};
struct Node {
int mx, mn;
};
struct SegmentTree {
int operationMask;
int n;
Node data[1 << 20];
inline int lc(int x) { return x * 2; }
inline int rc(int x) { return x * 2 + 1; }
inline int mid(int x, int y) { return (x + y) / 2; }
inline void pull(int idx) {
data[idx].mx = max(data[lc(idx)].mx, data[rc(idx)].mx);
data[idx].mn = min(data[lc(idx)].mn, data[rc(idx)].mn);
}
void init(int _n, Point points[]) {
n = _n;
init(points, 1, 0, n);
}
int getVal(const Point &point) {
int val = 0;
for (int i = 0; i < point.dim; i++) {
if ((operationMask >> i) & 1)
val += 1 * point.val[i];
else
val += -1 * point.val[i];
}
return val;
}
void init(Point points[], int idx, int lb, int rb) {
if (rb - lb == 1) {
int val = getVal(points[lb]);
data[idx].mx = data[idx].mn = val;
return;
}
int m = mid(lb, rb);
init(points, lc(idx), lb, m);
init(points, rc(idx), m, rb);
pull(idx);
}
void update(int who, int idx, int lb, int rb, const Point &newPoint) {
if (rb - lb == 1 && who == lb) {
int val = getVal(newPoint);
data[idx].mx = data[idx].mn = val;
return;
}
if (who < mid(lb, rb))
update(who, lc(idx), lb, mid(lb, rb), newPoint);
else
update(who, rc(idx), mid(lb, rb), rb, newPoint);
pull(idx);
}
void update(int who, const Point &newPoint) {
update(who, 1, 0, n, newPoint);
}
int query(int l, int r, int idx, int lb, int rb, bool isGetMin) {
if (rb <= l || r <= lb) return isGetMin ? INT_MAX : INT_MIN;
if (l <= lb && rb <= r) {
if (isGetMin) return data[idx].mn;
return data[idx].mx;
}
int m = mid(lb, rb);
int ret1 = query(l, r, lc(idx), lb, m, isGetMin);
int ret2 = query(l, r, rc(idx), m, rb, isGetMin);
if (isGetMin) return min(ret1, ret2);
return max(ret1, ret2);
}
int getMin(int l, int r) { return query(l, r, 1, 0, n, true); }
int getMax(int l, int r) { return query(l, r, 1, 0, n, false); }
void print() {
printf("mask %d\n", operationMask);
for (int i = 1; i <= 4 * n; i++)
printf("%d -> %d %d\n", i, data[i].mx, data[i].mn);
}
} segmentTree[32];
int main() {
int n, k;
scanf("%d %d", &n, &k);
Point points[n];
for (int i = 0; i < n; i++) {
points[i].dim = k;
for (int j = 0; j < k; j++) scanf("%d", &points[i].val[j]);
}
for (int i = 0; i < 32; i++) {
segmentTree[i].operationMask = i;
segmentTree[i].init(n, points);
}
int q;
scanf("%d", &q);
while (q--) {
int command;
scanf("%d", &command);
if (command == 1) {
int which;
scanf("%d", &which);
which--;
Point newPoint;
for (int i = 0; i < k; i++) scanf("%d", &newPoint.val[i]);
newPoint.dim = k;
for (int i = 0; i < 32; i++) {
segmentTree[i].update(which, newPoint);
}
} else {
int l, r;
scanf("%d %d", &l, &r);
l--;
int mx = 0;
for (int i = 0; i < 32; i++) {
int res =
abs(segmentTree[i].getMax(l, r) - segmentTree[i].getMin(l, r));
mx = max(mx, res);
}
printf("%d\n", mx);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class BidirIt>
BidirIt prev(BidirIt it,
typename iterator_traits<BidirIt>::difference_type n = 1) {
advance(it, -n);
return it;
}
template <class ForwardIt>
ForwardIt next(ForwardIt it,
typename iterator_traits<ForwardIt>::difference_type n = 1) {
advance(it, n);
return it;
}
const double EPS = 1e-9;
const double PI = 3.141592653589793238462;
template <typename T>
inline T sq(T a) {
return a * a;
}
const int MAXN = 2e5 + 5;
vector<int> gr[MAXN];
pair<int, int> dfs(int u, int par = -1) {
pair<int, int> ans = make_pair(-1, u);
for (auto v : gr[u])
if (v != par) ans = max(ans, dfs(v, u));
ans.first++;
return ans;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
queue<int> last;
for (int i = 1 + 1; i <= min(k + 1, n - k); i++) {
gr[i].push_back(1);
gr[1].push_back(i);
last.push(i);
}
for (int i = min(k + 1, n - k) + 1; i <= n - k; i++) {
gr[last.front()].push_back(i);
gr[i].push_back(last.front());
last.pop();
last.push(i);
}
int who = n - k + 1;
while (k--) {
if (last.empty()) {
gr[1].push_back(who);
gr[who].push_back(1);
} else {
gr[last.front()].push_back(who);
gr[who].push_back(last.front());
last.pop();
}
who++;
}
pair<int, int> res = dfs(1);
printf("%d\n", dfs(res.second).first);
for (int u = 1; u <= n; u++)
for (auto v : gr[u])
if (v < u) printf("%d %d\n", v, u);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int chh;
const int N = 1000005;
int n, e, h;
string s, tmp;
pair<int, int> sa[N];
int ans[N];
vector<string> res[N];
string b[N];
int main() {
int i, j, sum, id, maxi;
while (cin >> s) {
n = (s).size(), e = h = maxi = 0;
for (i = 0; i < n; i++) {
tmp.clear();
while ((s[i] >= 'a' && s[i] <= 'z') || ((s[i] >= 'A' && s[i] <= 'Z')))
tmp += s[i++];
b[++e] = tmp;
id = e;
sum = 0, i++;
while (s[i] >= '0' && s[i] <= '9') sum = sum * 10 + (s[i++] - '0');
sa[++h] = make_pair(sum, 1);
ans[id] = h;
maxi = max(maxi, h);
if (sa[h].first == 0) {
h--;
while (h > 0 && (sa[h].first == sa[h].second)) h--;
sa[h].second++;
}
}
for (int i = (1); i <= (maxi); i++) res[i].clear();
for (int i = (1); i <= (e); i++) res[ans[i]].push_back(b[i]);
cout << maxi << '\n';
for (int i = (1); i <= (maxi); i++) {
for (__typeof__((res[i]).begin()) it = (res[i]).begin();
it != (res[i]).end(); it++)
cout << *it << ' ';
puts("");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> pr(n);
for (int i = 0; i < n; i++) cin >> pr[i];
map<int, int> f;
map<int, int> s;
map<int, int> t;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x == 1) {
if (!f.count(pr[i])) f.insert({pr[i], pr[i]});
} else if (x == 2) {
if (!s.count(pr[i])) s.insert({pr[i], pr[i]});
} else {
if (!t.count(pr[i])) t.insert({pr[i], pr[i]});
}
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x == 1) {
if (!f.count(pr[i])) f.insert({pr[i], pr[i]});
} else if (x == 2) {
if (!s.count(pr[i])) s.insert({pr[i], pr[i]});
} else {
if (!t.count(pr[i])) t.insert({pr[i], pr[i]});
}
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (x == 1) {
if (f.size() != 0) {
auto it = f.begin();
int y = it->second;
cout << y << " ";
if (s.count(y)) s.erase(y);
if (t.count(y)) t.erase(y);
f.erase(y);
} else
cout << "-1 ";
} else if (x == 2) {
if (s.size() != 0) {
auto it = s.begin();
int y = it->second;
cout << y << " ";
if (f.count(y)) f.erase(y);
if (t.count(y)) t.erase(y);
s.erase(y);
} else
cout << "-1 ";
} else {
if (t.size() != 0) {
auto it = t.begin();
int y = it->second;
cout << y << " ";
if (s.count(y)) s.erase(y);
if (f.count(y)) f.erase(y);
t.erase(y);
} else
cout << "-1 ";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
long long mod = 1000000007;
using namespace std;
int n;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
multiset<long long, greater<long long> > S[62];
long long a[100005];
long long z = 1;
int main() {
int i, j, fl, test;
scanf("%d", &n);
long long cur = 0;
for (i = 0; i < n; i++) {
scanf("%lld", &a[i]);
cur = cur ^ a[i];
for (j = 62; j >= 0; j--) {
if ((z << j) <= a[i]) {
break;
}
}
S[j].insert(a[i]);
}
vector<long long> G;
for (i = 0; i < n; i++) {
fl = 0;
for (j = 0; j <= 62; j++) {
if ((z << j) & cur) {
if (S[j].size()) {
G.push_back(*(S[j].begin()));
cur = cur ^ (*(S[j].begin()));
S[j].erase(S[j].begin());
fl = 1;
break;
}
}
}
if (!fl) {
printf("No\n");
return 0;
}
}
printf("Yes\n");
for (i = G.size() - 1; i >= 0; i--) {
printf("%lld ", G[i]);
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int pw(long long int a, long long int p,
long long int m = 1000000007) {
if (p == 1) return a;
long long int t = pw(a, p / 2);
t = (m + (t * t) % m) % m;
if (p % 2 != 0) t *= a;
return (t + m) % m;
}
vector<long long int> uniq(vector<long long int> arr) {
vector<long long int> brr;
sort((arr).begin(), (arr).end());
brr.push_back(arr[0]);
for (auto i : arr)
if (brr.back() != i) brr.push_back(i);
return brr;
}
void solve() {
long long int n, k;
cin >> n >> k;
string a;
cin >> a;
for (long long int i = 0; i < (a.size() - 1); i++) {
if (k == 0) {
cout << a << endl;
return;
}
if (i % 2 == 0) {
if ((i < a.size() - 2) &&
(a[i] == '4' && a[i + 1] == '7' && a[i + 2] == '7')) {
if (k % 2 == 1) a[i + 1] = '4';
cout << a << endl;
return;
}
if ((i < a.size() - 2) &&
(a[i] == '4' && a[i + 1] == '4' && a[i + 2] == '7')) {
if (k % 2 == 1) a[i + 1] = '7';
cout << a << endl;
return;
}
if (a[i] == '4' && a[i + 1] == '7') {
a[i + 1] = '4';
k--;
}
} else {
if (a[i] == '4' && a[i + 1] == '7') {
a[i] = '7';
k--;
}
}
}
cout << a << endl;
return;
}
int main() {
ios::sync_with_stdio(0);
long long int t = 1;
for (long long int i = 0; i < (t); i++) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926535;
int main() {
long long n, r;
scanf("%I64d%I64d", &n, &r);
double t1 = tan(PI / (2 * n));
double t2 = tan(PI / n);
double res = ((double)r * r * n * t1 * t2) / (t1 + t2);
printf("%.12lf\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e5), mod = int(1e9) + 7;
int n, m, k, r;
priority_queue<pair<long long, pair<int, int> > > q;
unordered_map<int, int> was[N];
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
long long get(int x, int y) {
int xx = max(1, x - r + 1);
int yy = max(1, y - r + 1);
if (x + r - 1 > n) {
xx = (n - r + 1) - xx + 1;
} else
xx = x - xx + 1;
if (y + r - 1 > m) {
yy = (m - r + 1) - yy + 1;
} else
yy = y - yy + 1;
return 1ll * xx * yy;
}
int main() {
cin >> n >> m >> r >> k;
q.push(make_pair(get(r, r), make_pair(r, r)));
was[r][r] = 1;
int cnt = 0;
long double ans = 0;
long long all = 1ll * (n - r + 1) * (m - r + 1);
while (!q.empty()) {
long long v = q.top().first;
int x = q.top().second.first;
int y = q.top().second.second;
q.pop();
ans += (v + 0.0) / all;
cnt++;
if (cnt == k) break;
for (int i = 0; i < 4; i++) {
int xx = dx[i] + x;
int yy = dy[i] + y;
if (xx > 0 && xx <= n && yy > 0 && yy <= m && !was[xx].count(yy)) {
was[xx][yy] = 1;
q.push(make_pair(get(xx, yy), make_pair(xx, yy)));
}
}
}
printf("%.12lf", double(ans));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
string a[2];
int n;
int len(int l, int r) { return r - l + 1; }
string minstr(int l, int r, int i) {
if (l == r) {
return a[i].substr(l, 1);
}
int mid = (l + r) >> 1;
if (len(l, mid) != len(mid + 1, r)) return a[i].substr(l, r - l + 1);
string t1 = minstr(l, mid, i);
string t2 = minstr(mid + 1, r, i);
if (t2 + t1 < t1 + t2) return t2 + t1;
return t1 + t2;
}
int main() {
cin >> a[0] >> a[1];
n = a[0].size();
a[0] = ' ' + a[0];
a[1] = ' ' + a[1];
string t1 = minstr(1, n, 0);
string t2 = minstr(1, n, 1);
if (t1 == t2)
cout << "YES";
else
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> n >> m;
vector<string> strings;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
strings.push_back(s);
}
int todelete = 0;
for (int i = 1; i < n;) {
if (strings[i] < strings[i - 1]) {
string a = strings[i - 1], b = strings[i];
int j = -1;
for (j = 0; j < m && a[j] <= b[j]; ++j)
;
for (int k = 0; k < n; ++k) {
strings[k][j] = '0';
}
++todelete;
i = 1;
} else
++i;
}
cout << todelete << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 555555, mod = 998244353;
inline long long read() {
char ch = getchar();
long long x = 0, f = 0;
while (ch < '0' || ch > '9') f |= ch == '-', ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
int n, k, f[maxn][2][2], ans;
bool isf[maxn];
inline void chkmax(int &x, int y) { x = max(x, y); }
void DP(int o, int l, int r) {
if (l + 1 == r) {
f[o][isf[l]][isf[r]] = f[o][isf[r]][isf[l]] = isf[l] | isf[r];
return;
}
int mid = (l + r) >> 1;
DP(o << 1, l, mid);
DP(o << 1 | 1, mid + 1, r);
for (int w = (0); w <= (1); w++)
for (int x = (0); x <= (1); x++)
for (int y = (0); y <= (1); y++)
for (int z = (0); z <= (1); z++)
for (int a = (0); a <= (1); a++)
for (int b = (0); b <= (1); b++)
for (int c = (0); c <= (1); c++) {
int winup = a ? w : y, loseup = a ? y : w;
int windn = b ? x : z, losedn = b ? z : x;
int winre = c ? loseup : windn, losere = c ? windn : loseup;
chkmax(f[o][winup][winre],
f[o << 1][w][x] + f[o << 1 | 1][y][z] +
(winup | loseup) + (windn | losedn) +
(winre | losere));
}
}
int main() {
n = read();
k = read();
while (k--) isf[read()] = true;
memset(f, ~0x3f, sizeof(f));
DP(1, 1, 1 << n);
for (int i = (0); i <= (1); i++)
for (int j = (0); j <= (1); j++) chkmax(ans, f[1][i][j] + (i | j));
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long mod = 998244353;
const long long inf = 1e9 + 7;
vector<int> order;
vector<pair<int, int> > v;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
v.resize(k);
for (int i = 0; i < k; ++i) {
cin >> v[i].first >> v[i].second;
v[i].first--;
v[i].second--;
}
vector<vector<int> > g(n);
for (int i = 0; i < k; ++i) {
g[v[i].first].push_back(i);
g[v[i].second].push_back(i);
}
vector<bool> used(n, true);
vector<int> rem(k, 2);
set<pair<int, int> > s;
for (int i = 0; i < k; ++i) s.insert({rem[i], i});
int ans = 0;
while (!s.empty()) {
auto i = s.begin()->second;
if (rem[i] == 0) ans++;
rem[i] -= 2;
s.erase(s.begin());
if (used[v[i].first]) {
for (int j : g[v[i].first]) {
s.erase({rem[j], j});
rem[j]--;
s.insert({rem[j], j});
}
used[v[i].first] = false;
}
if (used[v[i].second]) {
for (int j : g[v[i].second]) {
s.erase({rem[j], j});
rem[j]--;
s.insert({rem[j], j});
}
used[v[i].second] = false;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010, p = 1e9 + 7;
int Pow(long long x, int pow) {
int res = 1;
while (pow) {
if (pow & 1) res = (res * x) % p;
x = (x * x) % p;
pow >>= 1;
}
return res;
}
int inv(int x) { return Pow(x, p - 2); }
int Prime[maxn], Not_Prime[maxn], PToNum[maxn], Primes;
int C[maxn], CSum[maxn], CSSum[maxn];
int t[maxn];
int a[maxn][20];
int ans;
int n;
void Get_Prime() {
for (int i = 2; i < maxn; i++) {
if (!Not_Prime[i]) Prime[++Primes] = i, PToNum[i] = Primes;
for (int j = 1, temp; j <= Primes && (temp = Prime[j] * i) < maxn; j++) {
Not_Prime[temp] = 1;
if (i % Prime[j] == 0) break;
}
}
}
void Init_Comb() {
C[0] = CSum[0] = CSSum[0] = 1;
for (int i = 1; i < n; i++)
C[i] = ((long long)C[i - 1] * (n - i) % p) * inv(i) % p;
for (int i = 1; i < n; i++) CSum[i] = (CSum[i - 1] + C[i]) % p;
for (int i = 1; i < n; i++) CSSum[i] = (CSSum[i - 1] + CSum[i]) % p;
}
void Init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
Get_Prime();
Init_Comb();
for (int i = 1; i <= Primes; i++) a[i][0] = n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= Primes && Prime[j] * Prime[j] <= t[i]; j++)
if (t[i] % Prime[j] == 0) {
int cnt = 0;
while (t[i] % Prime[j] == 0) cnt++, t[i] /= Prime[j];
a[j][cnt]++;
a[j][0]--;
}
if (t[i] > 1) a[PToNum[t[i]]][1]++, a[PToNum[t[i]]][0]--;
}
}
void Solve() {
for (int i = 1; i <= Primes; i++)
if (a[i][0] < n) {
int cnt = a[i][0];
for (int j = 1; cnt < n; cnt += a[i][j++]) {
int res = 0;
res = (long long)a[i][j] * CSum[n - 1] % p;
res = ((res + CSum[n - cnt - 1] - 2 * CSSum[n - cnt - 1]) % p + p) % p;
if (cnt + a[i][j] < n)
res = ((res - CSum[n - cnt - a[i][j] - 1] +
2 * CSSum[n - cnt - a[i][j] - 1] % p) %
p +
p) %
p;
res = (long long)res * j % p;
ans = (ans + res) % p;
}
}
}
int main() {
Init();
Solve();
printf("%d\n", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int _w;
char A[N], B[N];
int n, ans[N], res, l, r, t;
int get(int p) {
if (l <= r)
return A[l + p - 1] ^ t;
else
return A[l - p + 1] ^ t;
}
inline void solve(void) {
_w = scanf("%d%s%s", &n, A + 1, B + 1), res = 0;
l = 1, r = n, t = 0;
for (int i = n; i; --i) {
if (get(i) ^ B[i]) {
if ((A[l] ^ t) == B[i]) ans[++res] = 1;
swap(l, r), t ^= 1, ans[++res] = i;
}
if (r > l)
--r;
else
++r;
}
printf("%d ", res);
for (int i = 1; i <= res; ++i) printf("%d ", ans[i]);
puts("");
}
int main(void) {
int T;
_w = scanf("%d", &T);
while (T--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int MAX = 1e18;
long long int MOD = 998244353;
long long int MIN = -1e17;
long long int power(long long int x, long long int n) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return power(((x % MOD) * (x % MOD)) % MOD, n / 2);
else
return ((x % MOD) *
(power(((x % MOD) * (x % MOD)) % MOD, (n - 1) / 2) % MOD)) %
MOD;
}
long long int sub(long long int x, long long int y) {
return (x % MOD - y % MOD + MOD) % MOD;
}
long long int add(long long int x, long long int y) {
return (x % MOD + y % MOD) % MOD;
}
long long int multiply(long long int a, long long int b) {
return ((a % MOD) * (b % MOD)) % MOD;
}
long long int divide(long long int x, long long int y) {
return multiply(x % MOD, power(y, MOD - 2)) % MOD;
}
long long int fact[1000000 + 1];
void comb() {
fact[0] = 1;
for (long long int i = 1; i <= 1000000; i++) {
fact[i] = multiply(fact[i - 1], i);
}
}
long long int ncr(long long int n, long long int r) {
if (r > n || n < 0 || r < 0) return 0;
if (n == 0 || r == 0) {
return 1;
}
long long int ans = fact[n];
ans = divide(ans, fact[r]);
ans = divide(ans, fact[n - r]);
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int tc = 1;
comb();
for (long long int tt = 1; tt <= tc; tt++) {
long long int n, k;
cin >> n >> k;
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
ans = add(ans, ncr(n / i - 1, k - 1));
}
cout << ans << "\n";
}
cerr << "Time taken: " << int((clock() * 1000.) / CLOCKS_PER_SEC) << "ms"
<< "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 2e5, bs = 300, mxM = 1 << 14;
int n, k, q, a[mxN + 1], b[mxN + 1], c[mxN + 1], a2, d[mxN], e[mxN], s, l[mxN],
r[mxN], pi, vi, bc[(mxN - 1) / bs + 1][mxM], lz[(mxN - 1) / bs + 1];
char qt;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> q;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) {
cin >> b[i];
c[i - 1] = a[i] ^ a[i - 1] ^ b[i] ^ b[i - 1];
if (i > k) c[i - 1] ^= c[i - 1 - k];
}
c[n] = c[n - k] ^ a[n] ^ b[n];
for (int i = 0; i < k; ++i) {
for (int j = i; j <= n - k; j += k) {
e[s] = c[j];
++bc[s / bs][e[s]];
l[j] = s++;
r[j] = l[j] + (n - k - j) / k;
}
}
for (int i = n - k + 1; i <= n; ++i) {
a2 += c[i] > 0;
d[i % k] = c[i];
}
auto a1 = [&]() {
int r = s;
for (int i = 0; i <= (s - 1) / bs; ++i) r -= bc[i][lz[i]];
return r;
};
cout << (a2 ? -1 : a1()) << "\n";
while (q--) {
cin >> qt >> pi >> vi, --pi;
if (qt == 'a') {
vi ^= a[pi + 1];
a[pi + 1] ^= vi;
} else {
vi ^= b[pi + 1];
b[pi + 1] ^= vi;
}
for (int i = pi; i <= pi + 1; ++i) {
if (i <= n - k) {
int li = l[i];
auto ue = [&]() {
--bc[li / bs][e[li]];
e[li] ^= vi;
++bc[li / bs][e[li]];
};
for (; li % bs && li <= r[i]; ++li) ue();
for (; li + bs <= r[i]; li += bs) lz[li / bs] ^= vi;
for (; li <= r[i]; ++li) ue();
}
a2 += !d[i % k];
d[i % k] ^= vi;
a2 -= !d[i % k];
}
cout << (a2 ? -1 : a1()) << "\n";
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
const int p[] = {2, 3, 5, 7, 11, 13, 17, 19};
int n;
int main() {
cin >> n;
ans.push_back(1);
for (int i = 0;; i++) {
for (int j = 0; j < ans.size(); j++) {
int t = ans[j];
if (t * p[i] <= n * n * 2) ans.push_back(t * p[i]);
}
if (ans.size() > n) break;
}
for (int i = ans.size() - n; i < ans.size(); i++) cout << ans[i] << ' ';
cout << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[100010];
int now = 0;
int main() {
cin >> s;
int n = strlen(s);
for (int i = 0; i < n; i++) {
if (now >= 26) break;
if (s[i] - 'a' <= now) s[i] = now + 'a', now++;
}
if (now < 26)
cout << -1 << endl;
else
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
long long i, j;
long long const size = 1e5;
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
long long modd(string num, long long a) {
int res = 0;
for (int i = 0; i < num.length(); i++)
res = (res * 10 + (int)num[i] - '0') % a;
return res;
}
int check_xor(int n) {
if ((n % 4) == 0)
return n;
else if ((n % 4) == 1)
return 1;
else if ((n % 4) == 2)
return n + 1;
else
return 0;
}
vector<long long> sieve(long long n) {
vector<bool> prime(n + 1, true);
prime[0] = false;
prime[1] = false;
long long range = sqrt(n);
for (i = 2; i <= range; i++) {
if (prime[i]) {
for (j = i * 2; j <= n; j = j + i) {
prime[j] = false;
}
}
}
vector<long long> ans;
for (i = 0; i < n; i++) {
if (prime[i]) ans.push_back(i);
}
return ans;
}
bool iszero(long long n) { return n == 0; }
vector<long long> sieve_range(long long s, long long e) {
vector<long long> v1 = sieve(s);
vector<long long> v2 = sieve(e);
vector<long long> ans(e - s);
set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), ans.begin());
auto it = remove_if(ans.begin(), ans.end(), iszero);
ans.resize(it - ans.begin());
return ans;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
;
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
if (n * 2 <= m)
cout << n << " " << 2 * n << '\n';
else
cout << -1 << " " << -1 << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[100004], wh[100004];
int conv(string s) {
string n = s.substr(1);
stringstream ss(n);
int m;
ss >> m;
if (s[0] == '+') return m;
return -1 * m;
}
int main() {
int N, M;
cin >> N >> M;
int cnt = 0;
string s;
for (int i = 0; i < N; ++i) {
cin >> s;
int n = conv(s);
if (n > 0) {
arr[n]++;
wh[i + 1] = n;
} else {
cnt++;
arr[-1 * n]--;
wh[i + 1] = n;
}
}
vector<int> V;
for (int i = 1; i <= N; ++i) {
int tot = cnt + arr[i];
if (tot == M) V.push_back(i);
}
sort(V.begin(), V.end());
for (int i = 1; i <= N; ++i) {
if (wh[i] > 0) {
bool f = binary_search(V.begin(), V.end(), wh[i]);
if (!f) {
cout << "Lie" << endl;
} else {
if (V.size() == 1) {
cout << "Truth" << endl;
} else
cout << "Not defined" << endl;
}
} else {
bool f = binary_search(V.begin(), V.end(), -1 * wh[i]);
if (f) {
if (V.size() == 1) {
cout << "Lie" << endl;
} else
cout << "Not defined" << endl;
} else {
cout << "Truth" << endl;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long N = 1e6 + 7, lg = 22;
long long a[N], dp[1 << lg];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, i, j, mask;
memset(dp, -1, sizeof dp);
cin >> n;
for ((i) = (0); (i) < (n) + (0); (i)++) cin >> a[i];
;
for (i = 0; i < n; i++) dp[a[i]] = a[i];
for (i = 0; i < lg; i++)
for (mask = 0; mask < (1 << lg); mask++)
if (dp[mask] != -1) dp[mask | (1 << i)] = dp[mask];
for (i = 0; i < n; i++) {
j = a[i] ^ ((1 << lg) - 1);
cout << dp[j] << " ";
}
cout << endl;
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 5;
const int M = 3 * N * N;
int cnt;
pair<int, int> p[M];
int a[N][N], b[N][N];
void addans(int i, int j) {
p[++cnt] = {i, j};
b[i][j] = a[i][j] ^ 1;
}
void cp(int i, int j) {
for (int x = 0; x <= 1; x++)
for (int y = 0; y <= 1; y++) b[i + x][j + y] = a[i + x][j + y];
}
void pc(int i, int j) {
for (int x = 0; x <= 1; x++)
for (int y = 0; y <= 1; y++) a[i + x][j + y] = b[i + x][j + y];
}
int main(void) {
int kase;
scanf("%d", &kase);
while (kase--) {
cnt = 0;
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%1d", &a[i][j]);
for (int i = 1; i + 1 < n; i++)
for (int j = 1; j + 1 <= m; j++) {
cp(i, j);
if (j + 1 != m) {
if (a[i][j] == 1)
addans(i, j);
else
addans(i, j + 1);
addans(i + 1, j);
addans(i + 1, j + 1);
} else {
if (a[i][j] == 1) addans(i, j);
if (a[i][j + 1] == 1) addans(i, j + 1);
if (cnt % 3 == 0) continue;
if (cnt % 3 != 0) addans(i + 1, j);
if (cnt % 3 != 0) addans(i + 1, j + 1);
}
pc(i, j);
}
for (int i = n - 1, j = 1; j + 1 <= m; j++) {
cp(i, j);
if (j + 1 != m) {
if (a[i][j] == 1) addans(i, j);
if (a[i + 1][j] == 1) addans(i + 1, j);
if (cnt % 3 == 0) continue;
if (cnt % 3 != 0) addans(i, j + 1);
if (cnt % 3 != 0) addans(i + 1, j + 1);
for (int x = 0; x <= 1; x++)
for (int y = 0; y <= 1; y++) a[i + x][j + y] = b[i + x][j + y];
pc(i, j);
} else {
while (true) {
cp(i, j);
int s = a[i][j] + a[i + 1][j] + a[i][j + 1] + a[i + 1][j + 1];
if (s == 4) {
addans(i, j);
addans(i + 1, j);
addans(i + 1, j + 1);
} else if (s == 3) {
for (int x = 0; x <= 1; x++)
for (int y = 0; y <= 1; y++)
if (a[i + x][j + y] != 0) addans(i + x, j + y);
} else if (s == 2) {
for (int x = 0; x <= 1; x++)
for (int y = 0; y <= 1; y++)
if (a[i + x][j + y] == 0) addans(i + x, j + y);
for (int x = 0; x <= 1; x++)
for (int y = 0; y <= 1; y++)
if (a[i + x][j + y] != 0 && cnt % 3 != 0) addans(i + x, j + y);
} else if (s == 1) {
for (int x = 0; x <= 1; x++)
for (int y = 0; y <= 1; y++)
if (a[i + x][j + y] != 0) addans(i + x, j + y);
for (int x = 0; x <= 1; x++)
for (int y = 0; y <= 1; y++)
if (a[i + x][j + y] == 0 && cnt % 3 != 0) addans(i + x, j + y);
} else {
break;
}
pc(i, j);
}
}
}
printf("%d\n", cnt / 3);
for (int i = 1; i <= cnt; i += 3) {
printf("%d %d ", p[i].first, p[i].second);
printf("%d %d ", p[i + 1].first, p[i + 1].second);
printf("%d %d\n", p[i + 2].first, p[i + 2].second);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, q;
long long a = 0, b = 1;
cin >> n >> q;
while (q--) {
long long ty, k;
cin >> ty;
if (ty == 1) {
cin >> k;
a += k, b += k;
} else
a ^= 1, b ^= 1;
}
((a %= n) -= n) %= n;
((b %= n) -= n) %= n;
for (long long i = 0; i < n; ++i) {
if (i - b & 1)
cout << (i - a) % n + 1 << ' ';
else
cout << (i - b + 1) % n + 1 << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {+1, -1, 0, 0};
int dy[] = {0, 0, +1, -1};
int dx2[] = {+1, -1, 0, 0, +1, +1, -1, -1};
int dy2[] = {0, 0, +1, -1, +1, -1, -1, +1};
inline long long squ(long long x) { return (x * x); }
inline long long power(long long bs, long long k) {
long long x = 1LL, y = bs;
if (k == 0) return 1LL;
while (k > 0) {
if (k % 2) x *= y;
y *= y;
k /= 2;
}
return x;
}
int a[100100], n, pr[100100];
pair<int, int> cld[100100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cout.unsetf(ios::floatfield);
cout.precision(6);
cout.setf(ios::fixed, ios::floatfield);
;
int i, j;
cin >> n;
set<int> st;
cin >> j;
st.insert(j);
map<int, int> mp;
mp[j] = 0;
for (i = 0; i < n; i++) {
cld[i].first = -1;
cld[i].second = -1;
}
for (i = 1; i < n; i++) {
cin >> a[i];
mp[a[i]] = i;
st.insert(a[i]);
auto it = st.find(a[i]);
if (it != st.begin()) {
it--;
if (cld[mp[*it]].second == -1) {
cld[mp[*it]].second = a[i];
pr[i] = *it;
} else {
it++;
it++;
if (cld[mp[*it]].first == -1) {
cld[mp[*it]].first = a[i];
pr[i] = *it;
}
}
continue;
}
it++;
cld[mp[*it]].first = a[i];
pr[i] = *it;
}
for (i = 1; i < n; i++) cout << pr[i] << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const int MAXM = 2e5 + 5;
inline int rnd(void) { return (rand() << 15) | rand(); }
struct Treap {
struct Node {
int val, num, fix, tval, tnum;
Node *son[2];
Node(int val, Node *emp) : val(val), num(0), fix(rnd()), tval(0), tnum(0) {
son[0] = son[1] = emp;
}
} * emp, *root;
Treap(void) : emp(new Node(-1, 0)), root(emp) {}
inline Node *new_Node(int val) { return new Node(val, emp); }
inline void del_Node(Node *&u, Node *to) {
delete u;
u = to;
}
inline void mark(Node *u, int tval, int tnum) {
if (~u->val) {
u->val -= tval;
u->num += tnum;
u->tval += tval;
u->tnum += tnum;
}
}
inline void push_down(Node *u) {
if (u->tnum) {
mark(u->son[0], u->tval, u->tnum);
mark(u->son[1], u->tval, u->tnum);
u->tval = u->tnum = 0;
}
}
void split(Node *u, Node *&l, Node *&r, int k) {
if (u->val == -1) {
l = r = emp;
return;
}
push_down(u);
if (u->val <= k)
l = u, split(u->son[1], l->son[1], r, k);
else
r = u, split(u->son[0], l, r->son[0], k);
}
void merge(Node *&u, Node *l, Node *r) {
if (l->val == -1) {
u = r;
return;
}
if (r->val == -1) {
u = l;
return;
}
push_down(l);
push_down(r);
if (l->fix < r->fix)
u = l, merge(u->son[1], l->son[1], r);
else
u = r, merge(u->son[0], l, r->son[0]);
}
void insert_all(Node *u, Node *&v) {
if (u->val == -1) return;
if (v->val == -1) {
v = u;
return;
}
push_down(u);
Node *l, *r;
split(v, l, r, u->val);
insert_all(u->son[0], l);
insert_all(u->son[1], r);
u->son[0] = u->son[1] = emp;
merge(v, l, u);
merge(v, v, r);
}
Node *insert(int val) {
Node *l, *r, *mid = new_Node(val);
split(root, l, r, mid->val);
merge(root, l, mid);
merge(root, root, r);
return mid;
}
void update(int val) {
Node *l, *r, *mid;
split(root, l, r, val - 1);
mark(r, val, 1);
split(r, mid, r, val * 2);
insert_all(mid, l);
merge(root, l, r);
}
void calc_all(Node *u) {
if (u->val == -1) return;
push_down(u);
calc_all(u->son[0]);
calc_all(u->son[1]);
}
inline void calc_all(void) { calc_all(root); }
} tree;
pair<int, int> a[MAXN];
int b[MAXN];
Treap::Node *p[MAXM];
int main(void) {
srand((unsigned long long)new char);
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int c, q;
scanf("%d%d", &c, &q);
a[i] = make_pair(-q, c);
}
sort(a + 1, a + n + 1);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
scanf("%d", &b[i]);
p[i] = tree.insert(b[i]);
}
for (int i = 1; i <= n; ++i) tree.update(a[i].second);
tree.calc_all();
for (int i = 1; i <= m; ++i) printf("%d ", p[i]->num);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
string s;
int rev(int n) {
int res = 0;
string t = "";
while (n) {
if (n & 1)
t += "1";
else
t += "0";
n >>= 1;
}
for (int i = t.size(); i < 8; i++) {
t += "0";
}
reverse(t.begin(), t.end());
for (int i = 0; i < (int)t.size(); i++) {
if (t[i] == '1') res += pow(2, i);
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
getline(cin, s);
int prev = 0;
for (int i = 0; i < (int)s.length(); i++) {
int curr = rev(s[i]);
int ans = (256 + prev - curr) % 256;
cout << ans << '\n';
prev = curr;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 300 * 1000 + 7;
const long long MOD = 998244353;
const double PI = 2 * acos(0.0);
long long n;
vector<long long> adj[5050];
long long sz[5050];
bool ans[5050], temp[5050];
long long tot = 0;
void dfs(long long cur, long long par) {
long long num_Bro = adj[cur].size();
sz[cur] = 1;
for (long long i0 = 0; i0 < num_Bro; i0++) {
long long bro = adj[cur][i0];
if (bro == par) continue;
dfs(bro, cur);
sz[cur] += sz[bro];
}
return;
}
void dfs1(long long cur, long long par) {
long long num_Bro = adj[cur].size();
vector<long long> kobe;
for (long long i0 = 0; i0 < num_Bro; i0++) {
long long bro = adj[cur][i0];
if (bro == par) {
kobe.push_back(n - sz[cur]);
continue;
}
dfs1(bro, cur);
kobe.push_back(sz[bro]);
}
long long SIZE = kobe.size();
for (long long i0 = 0; i0 <= n; i0++) temp[i0] = false;
temp[0] = true;
for (long long i0 = 0; i0 < SIZE; i0++) {
long long james = kobe[i0];
for (long long k = n - 2; k >= james; k--)
if (temp[k - james]) temp[k] = true;
}
for (long long i0 = 1; i0 <= n - 2; i0++) {
if (temp[i0]) {
ans[i0] = true;
}
}
return;
}
int main(void) {
cin >> n;
for (long long i0 = 0; i0 < n - 1; i0++) {
long long i, j;
cin >> i >> j;
adj[i].push_back(j);
adj[j].push_back(i);
}
dfs(1, 1);
dfs1(1, 1);
for (long long i0 = 1; i0 <= n - 2; i0++) {
if (ans[i0] || ans[n - 1 - i0]) tot++;
}
cout << tot << endl;
for (long long i0 = 1; i0 <= n - 2; i0++) {
if (ans[i0] || ans[n - 1 - i0]) {
cout << i0 << " " << n - 1 - i0 << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, L = 20;
int n, k, stamp, now;
int fa[N][L];
int ver[N], bg[N], dep[N];
vector<int> e[N];
set<int> s;
void dfs(int v, int f) {
dep[v] = dep[f] + 1;
bg[v] = ++stamp;
ver[stamp] = v;
fa[v][0] = f;
for (int i = 1; i < L; ++i) fa[v][i] = fa[fa[v][i - 1]][i - 1];
for (auto u : e[v])
if (u != f) {
dfs(u, v);
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int d = dep[x] - dep[y];
for (int i = L - 1; i >= 0; --i)
if (d >> i & 1) x = fa[x][i];
if (x == y) return x;
for (int i = L - 1; i >= 0; --i) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i], y = fa[y][i];
}
}
return fa[x][0];
}
int dis(int x, int y) {
x = ver[x], y = ver[y];
return dep[x] + dep[y] - 2 * dep[lca(x, y)];
}
void add(int i) {
i = bg[i];
if (!s.empty()) {
auto lhs = i < *s.begin() ? --s.end() : --s.lower_bound(i);
auto rhs = i > *--s.end() ? s.begin() : s.lower_bound(i);
int tmp = dis(*lhs, i) + dis(*rhs, i) - dis(*lhs, *rhs);
now += tmp / 2;
} else {
now += 1;
}
s.insert(i);
}
void remove(int i) {
i = bg[i];
s.erase(i);
if (!s.empty()) {
auto lhs = i < *s.begin() ? --s.end() : --s.lower_bound(i);
auto rhs = i > *--s.end() ? s.begin() : s.lower_bound(i);
int tmp = dis(*lhs, i) + dis(*rhs, i) - dis(*lhs, *rhs);
now -= tmp / 2;
} else {
now -= 1;
}
}
void run() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
e[a].push_back(b);
e[b].push_back(a);
}
dfs(1, 0);
int ans = 1;
int qh = 1;
for (int qt = 1; qt <= n; ++qt) {
add(qt);
while (now > k) {
remove(qh++);
}
ans = max(ans, qt - qh + 1);
}
printf("%d\n", ans);
}
int main() {
run();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
vector<int> g[N];
int in[N], out[N], dfs_t;
void dfs_prec(int u, int p) {
in[u] = ++dfs_t;
for (int v : g[u])
if (v != p) dfs_prec(v, u);
out[u] = dfs_t;
}
int lz[4 * N];
pair<int, int> st[4 * N];
pair<int, int> comb(pair<int, int> a, pair<int, int> b) {
if (a.first < b.first) return a;
if (a.first > b.first) return b;
return {a.first, a.second + b.second};
}
void build(int p, int L, int R) {
st[p].second = R - L + 1;
if (L == R) return;
int mid = (L + R) / 2;
build(2 * p, L, mid);
build(2 * p + 1, mid + 1, R);
}
void prop(int p, int L, int R) {
if (lz[p]) {
st[p].first += lz[p];
if (L < R) {
lz[2 * p] += lz[p];
lz[2 * p + 1] += lz[p];
}
lz[p] = 0;
}
}
void upd(int p, int L, int R, int i, int j, int val) {
prop(p, L, R);
if (i > R or j < L) return;
if (L >= i and R <= j) {
lz[p] = val;
prop(p, L, R);
return;
}
int mid = (L + R) / 2;
upd(2 * p, L, mid, i, j, val);
upd(2 * p + 1, mid + 1, R, i, j, val);
st[p] = comb(st[2 * p], st[2 * p + 1]);
}
vector<pair<int, int>> to_add[N];
int ans[N];
void dfs(int u, int p) {
for (auto [l, r] : to_add[u]) {
upd(1, 1, n, l, r, 1);
}
ans[u] = st[1].first ? n : n - st[1].second;
for (int v : g[u])
if (v != p) {
dfs(v, u);
}
for (auto [l, r] : to_add[u]) {
upd(1, 1, n, l, r, -1);
}
}
int main() {
int m;
scanf("%d %d", &n, &m);
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_prec(1, 1);
while (m--) {
int a, b;
scanf("%d %d", &a, &b);
to_add[a].emplace_back(in[a], out[a]);
to_add[a].emplace_back(in[b], out[b]);
to_add[b].emplace_back(in[a], out[a]);
to_add[b].emplace_back(in[b], out[b]);
}
build(1, 1, n);
dfs(1, 1);
for (int i = 1; i <= n; i++) {
if (ans[i] > 0) ans[i]--;
printf("%d%c", ans[i], " \n"[i == n]);
}
}
| 8 |
#include <bits/stdc++.h>
struct buf {
template <typename _nt>
operator _nt() {
register int c = getchar();
register _nt x = 0;
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); c = getchar()) x = x * 10 - '0' + c;
return x;
}
} fio;
int n, m, q, i, j, k, l, r, p[(1000000 * 2) + 1], ans;
long long b, s[(1000000 * 2) + 1];
int main() {
n = fio, q = fio, m = n << 1;
for (i = 1; i <= n; ++i) s[i] = fio, s[i] += s[i - 1];
for (i = 1; i <= n; ++i) s[i + n] = s[i] + s[n];
while (q--) {
b = fio;
for (i = 0, j = 1; i < m; p[++i] = j)
while (j <= m && s[j] - s[i] <= b) ++j;
l = 1;
for (i = 2; i <= n; ++i)
if (p[l] - l > p[i] - i) l = i;
r = (p[l] - 1) % n + 1;
ans = n;
for (i = l;; i = i < n ? i + 1 : 1) {
for (j = i, k = 0; j < i + n; j = p[j], ++k)
;
ans = std::min(ans, k);
if (i == r) break;
}
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[110];
for (int i = 0; i < n; ++i) scanf("%d", a + i);
bool ans = true, d = true;
int i;
for (i = 1; i < n && a[i] > a[i - 1]; ++i)
;
if (a[i] == a[i - 1])
while (i + 1 < n && a[i + 1] == a[i]) ++i;
for (++i; i < n && a[i] < a[i - 1]; ++i)
;
printf("%s\n", i >= n ? "YES" : "NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char c = getchar();
bool f = 0;
for (; c > '9' || c < '0'; f = c == '-', c = getchar())
;
for (; c >= '0' && c <= '9'; x = (x << 1) + (x << 3) + c - '0', c = getchar())
;
return f ? -x : x;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
}
const int N = 5000 + 10;
int n, q, a[N], f1[N][N], f2[N][N];
int dfs1(int l, int r) {
if (f1[l][r] != -1) return f1[l][r];
if (l == r) return f1[l][r] = a[l];
return f1[l][r] = dfs1(l, r - 1) ^ dfs1(l + 1, r);
}
int dfs2(int l, int r) {
if (f2[l][r] != -1) return f2[l][r];
f2[l][r] = f1[l][r];
if (l == r) return f2[l][r];
int tmp = max(dfs2(l, r - 1), dfs2(l + 1, r));
return f2[l][r] = max(f2[l][r], tmp);
}
int main() {
memset(f1, -1, sizeof f1);
memset(f2, -1, sizeof f2);
n = read();
for (int i = 1, _y = n; i <= _y; ++i) a[i] = read();
q = read();
for (int i = 1, _y = q; i <= _y; ++i) {
int l = read(), r = read();
dfs1(l, r);
write(dfs2(l, r));
puts("");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isValid(char c) { return (isalnum(c) || c == '_'); }
int main() {
char acc[105];
memset(acc, 0, sizeof(acc));
scanf("%s", acc);
int Pjg = strlen(acc);
int PjgKata = 0;
bool bisa = true;
int pos;
for (pos = 0; pos < Pjg && bisa && acc[pos] != '@' && PjgKata <= 16; pos++) {
if (isValid(acc[pos]))
PjgKata++;
else
bisa = false;
}
if (PjgKata < 0 || pos == Pjg || acc[pos] != '@')
bisa = false;
else
pos++;
int Total = 0;
PjgKata = 0;
for (; pos < Pjg && bisa && acc[pos] != '/' && PjgKata <= 16 && Total <= 32;
pos++) {
if (isValid(acc[pos]))
PjgKata++;
else if (acc[pos] == '.') {
if (PjgKata == 0) bisa = false;
PjgKata = 0;
} else
bisa = false;
if (bisa) Total++;
}
if (PjgKata < 1 || Total < 1)
bisa = false;
else
pos++;
PjgKata = 0;
for (; pos < Pjg && bisa && PjgKata <= 16; pos++) {
if (isValid(acc[pos]))
PjgKata++;
else
bisa = false;
}
if (acc[Pjg - 1] == '/') bisa = false;
if (bisa)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, x, y;
cin >> a >> b;
x = min(a, b);
y = max(a, b);
cout << x << " " << (y - x) / 2;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef double DB;
const int MAXN = 1e5 + 15;
struct Edge{int to, nxt;}g[MAXN << 5];
map <string, int> mp;
int n, m, k, head[MAXN], cnt = 0, d[MAXN], ans[MAXN], cfa = 0;
void add(int u, int v){g[++ cnt] = (Edge){v, head[u]}; head[u] = cnt;}
inline int read(){
int r = 0, z = 1; char ch = getchar();
while(ch < '0' || ch > '9'){if(ch == '-') z = -1; ch = getchar();}
while(ch >= '0' && ch <= '9'){r = r * 10 + ch - '0'; ch = getchar();}
return r * z;
}
void topsort(){
priority_queue <int> q;
for(int i = 1; i <= n; i ++) if(!d[i]) q.push(i);
while(!q.empty()){
int u = q.top(); q.pop(); ans[++ cfa] = u;
for(int i = head[u]; i; i = g[i].nxt){
int v = g[i].to; d[v] --;
if(!d[v]) q.push(v);
}
}
}
int main(){
n = read(), m = read(), k = read();
for(int i = 1; i <= n; i ++){
string str;
cin >> str;
mp[str] = i;
}
for(int i = 1; i <= m; i ++){
string str; int mk; bool ff = false;
cin >> str >> mk;
for(int j = 0; j < (1 << k); j ++){
string str1 = str;
for(int t = 0; t < k; t ++) if((j >> t) & 1) str1[t] = '_';
if(mp.count(str1)){
if(mp[str1] != mk){add(mk, mp[str1]); d[mp[str1]] ++;}
else ff = true;
}
}
if(!ff){puts("NO"); exit(0);}
}
topsort();
if(!(cfa == n)){puts("NO"); exit(0);}
puts("YES");
for(int i = 1; i <= n; i ++) printf("%d ", ans[i]); puts("");
return 0;
} | 7 |
#include <bits/stdc++.h>
const long long INF = 4e18L + 1;
const int IINF = 2e9 + 1;
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
unsigned long long DOTESTU[6] = {61, 2, 3, 5, 7, 11};
unsigned long long mnozenie(unsigned long long x, unsigned long long y,
unsigned long long MOD) {
unsigned long long maska = 15, wynik = 0;
while (y > 0) {
wynik = (wynik + (maska & y) * x) % MOD;
x = (x << 4) % MOD;
y >>= 4;
}
return wynik;
}
long long sito[10000001 + 1];
vector<pair<unsigned long long, int> > rozloz(long long M) {
vector<long long> V = {M};
vector<pair<unsigned long long, int> > Odp;
while (V.size()) {
long long pom = V.back(), dz;
V.pop_back();
if (pom == 1) continue;
dz = sito[pom];
if (dz == pom) {
int ile = 1;
for (auto &el : V) {
while (el % dz == 0) {
ile++;
el /= dz;
}
}
Odp.push_back({dz, ile});
} else {
V.push_back(max(dz, pom / dz));
V.push_back(min(dz, pom / dz));
}
}
return Odp;
}
void sito_eratostenesa() {
for (int i = 2; i <= 10000001; i++) sito[i] = i;
for (int i = 2; i * i <= 10000001; i++)
if (sito[i] == i)
for (int j = 2 * i; j <= 10000001; j += i)
if (sito[j] == j) sito[j] = i;
}
int wej_n;
int tab[100];
long long ile1(long long n) {
long long n2 = n;
long long roz = 0;
while (n2 > 1) {
long long akt = sito[n2];
tab[roz] = akt;
roz++;
while (n2 % akt == 0) n2 /= akt;
}
long long res = 0;
for (int i = 1; i < (1 << roz); i++) {
long long mnoz = -1;
if (__builtin_popcount(i) & 1) mnoz = 1;
long long co = 1;
for (int j = 0; j < roz; j++)
if (i & (1 << j)) co *= tab[j];
res += (n / co) * mnoz;
}
return res;
}
const int pot = (1 << 24);
int drzewo[2 * pot];
void dodaj(int gdzie) {
gdzie += pot;
drzewo[gdzie]++;
while (gdzie > 0) {
gdzie >>= 1;
drzewo[gdzie]++;
}
}
int suma(int a, int b) {
a += pot, b += pot;
if (a == b) return drzewo[a];
int wyn = drzewo[a] + drzewo[b];
while ((a >> 1) != (b >> 1)) {
if ((a & 1) == 0) wyn += drzewo[a + 1];
if ((b & 1) == 1) wyn += drzewo[b - 1];
a >>= 1;
b >>= 1;
}
return wyn;
}
long long pierwsze_pref[10000007];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
wej_n = n;
sito_eratostenesa();
for (int i = 2; i <= 10000000; i++) {
pierwsze_pref[i] = pierwsze_pref[i - 1];
if (sito[i] == i) pierwsze_pref[i]++;
}
long long odp = 0;
long long zli = 1;
for (int i = 2; i <= n; i++) {
long long temp;
long long najmniejsza;
long long pomm;
long long w_trzech;
long long wcale;
long long w_dwoch;
if (sito[i] != i) {
temp = ile1(i) - 1;
najmniejsza = sito[i];
pomm = min(n / najmniejsza, (long long)i - 1);
w_trzech = pierwsze_pref[min(n / 2, i - 1)] - pierwsze_pref[pomm];
wcale = 1;
if (i > n / 2) wcale += pierwsze_pref[i - 1] - pierwsze_pref[n / 2];
w_dwoch = i - 1 - temp - w_trzech - wcale;
}
if (sito[i] == i) {
temp = 0;
w_dwoch = suma(0, n / i);
(i, n / i);
wcale = zli;
if (i * 2 > n) wcale = i - 1;
w_trzech = i - 1 - temp - w_dwoch - wcale;
}
dodaj(sito[i]);
(i, sito[i]);
if (sito[i] == i && i * 2 > n) zli++;
odp += temp + 2ll * w_dwoch + 3ll * w_trzech;
(i, temp, w_dwoch, w_trzech, wcale);
}
cout << odp;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
set<long long int> s;
set<long long int>::iterator it;
map<long long int, long long int> m1, m2;
int main() {
long long int i, j, k, l, n, m;
cin >> n;
for (i = 0; i < n; i++) {
cin >> j >> k;
s.insert(j);
s.insert(k);
if (j != k) {
m1[j]++;
m2[k]++;
} else
m1[j]++;
}
long long int ans = 9999999999;
for (it = s.begin(); it != s.end(); it++) {
if (m1[*it] >= (n / 2 + n % 2)) {
cout << 0;
return 0;
}
if (m1[*it] + m2[*it] >= (n / 2 + n % 2))
ans = min(ans, (n / 2 + n % 2) - m1[*it]);
}
if (ans != 9999999999)
cout << ans;
else
cout << -1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout.setf(ios::fixed);
cout.precision(15);
long long int n, l, v1, v2;
cin >> n >> l >> v1 >> v2;
vector<long long int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < n; i++) v.push_back(v[i] + 2 * l);
for (int i = 0; i < n; i++) v.push_back(v[i] + 4 * l);
int i1 = 0, i2 = 0;
int amount = 0;
while (l * v2 >= (v1 + v2) * v[i2]) {
amount++;
i2++;
}
double d = l * v2 / double(v1 + v2);
vector<double> p(n + 1);
double pos = 0;
while (pos < 2 * l) {
if (i1 < i2 and (v1 + v2) * (v[i2] - v[i1]) > l * v2) {
double nextpos = v[i1];
double dist = min(nextpos, double(2 * l)) - pos;
p[amount] += dist;
amount--;
i1++;
pos = nextpos;
} else {
double nextpos = v[i2] - d;
double dist = min(nextpos, double(2 * l)) - pos;
p[amount] += dist;
amount++;
i2++;
pos = nextpos;
}
}
for (int i = 0; i < n + 1; i++) cout << p[i] / (2 * l) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
pair<bool, int> eq(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first && a.second != b.second) {
return {true, a.first};
} else if (a.first == b.second && a.second != b.first) {
return {true, a.first};
} else if (a.second == b.first && a.first != b.second) {
return {true, a.second};
} else if (a.second == b.second && a.first != b.first) {
return {true, a.second};
}
return {false, 0};
}
bool operator==(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first && a.second == b.second) {
return true;
}
return false;
}
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int> > a(n), b(m);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
for (int i = 0; i < m; i++) {
cin >> b[i].first >> b[i].second;
}
bool different = false;
for (int i = 0; i < n; i++) {
int last_common = -1;
for (int j = 0; j < m; j++) {
pair<bool, int> info = eq(a[i], b[j]);
if (info.first) {
if (last_common == -1) {
last_common = info.second;
} else {
int common = info.second;
if (last_common != common) {
different = true;
}
}
}
}
}
if (different) {
cout << -1;
return 0;
}
vector<int> commons;
int cnt = 0;
for (int i = 0; i < n; i++) {
int cmn;
for (int j = 0; j < m; j++) {
pair<bool, int> info = eq(a[i], b[j]);
if (info.first) {
commons.emplace_back(info.second);
cnt++;
}
}
}
if (commons.size() == 0) {
cout << -1;
return 0;
} else if (commons.size() == 1) {
cout << commons.back();
return 0;
} else if (commons.size() > 1) {
bool equals = true;
int tmp = commons[0];
for (int i = 0; i < commons.size(); i++) {
if (commons[i] != tmp) {
equals = false;
}
}
if (equals) {
cout << commons[0];
return 0;
}
vector<pair<int, int> > matches;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] == b[j]) {
matches.emplace_back(a[i]);
}
}
}
for (int i = 0; i < n; i++) {
bool first_cipher = false, second_cipher = false;
for (int j = 0; j < commons.size(); j++) {
bool exit = false;
for (int k = 0; k < matches.size(); k++) {
if (a[i] == matches[k]) {
exit = true;
}
}
if (exit) {
continue;
}
if (a[i].first == commons[j]) {
first_cipher = true;
} else if (a[i].second == commons[j]) {
second_cipher = true;
}
}
if (first_cipher && second_cipher) {
cout << -1;
return 0;
}
}
for (int i = 0; i < m; i++) {
bool first_cipher = false, second_cipher = false;
for (int j = 0; j < commons.size(); j++) {
bool exit = false;
for (int k = 0; k < matches.size(); k++) {
if (b[i] == matches[k]) {
exit = true;
}
}
if (exit) {
continue;
}
if (b[i].first == commons[j]) {
first_cipher = true;
} else if (b[i].second == commons[j]) {
second_cipher = true;
}
}
if (first_cipher && second_cipher) {
cout << -1;
return 0;
}
}
for (int i = 0; i < n; i++) {
int common1 = -1, common2 = -1;
for (int j = 0; j < m; j++) {
if (a[i] == b[j]) {
continue;
}
pair<bool, int> info = eq(a[i], b[j]);
if (info.first) {
if (common1 == -1) {
common1 = info.second;
continue;
}
if (common2 == -1 && info.second != common1) {
common2 = info.second;
continue;
}
}
}
if (common1 != -1 && common2 != -1 && common1 != common2) {
cout << -1;
return 0;
}
}
for (int i = 0; i < m; i++) {
int common1 = -1, common2 = -1;
for (int j = 0; j < n; j++) {
if (a[i] == b[j]) {
continue;
}
pair<bool, int> info = eq(b[i], a[j]);
if (info.first) {
if (common1 == -1) {
common1 = info.second;
continue;
} else if (common2 == -1 && info.second != common1) {
common2 = info.second;
continue;
}
}
}
if (common1 != -1 && common2 != -1 && common1 != common2) {
cout << -1;
return 0;
}
}
cout << 0;
return 0;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cout.tie(nullptr);
cin.tie(nullptr);
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (i) a[i] += a[i - 1];
}
long long tmp = a[n - 1];
vector<long long> p;
if (tmp == 1) {
cout << -1 << '\n';
return 0;
}
for (int i = 2; i <= sqrt(tmp); ++i) {
if (tmp % i) continue;
while (tmp % i == 0) {
tmp /= i;
}
p.push_back(i);
}
if (tmp > 1) p.push_back(tmp);
long long ans = LLONG_MAX;
for (auto x : p) {
long long cur = 0;
for (int i = 0; i < n; ++i) {
cur += min(a[i] % x, x - a[i] % x);
}
ans = min(ans, cur);
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
long long a[55], b[55], m[55];
bool prime[40005];
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long extgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
long long xx, yy;
long long d = extgcd(b, a % b, xx, yy);
x = yy, y = xx - (a / b) * yy;
return d;
}
long long mod_inverse(long long a, long long m) {
long long x, y;
if (extgcd(a, m, x, y) != 1) return -1;
return (x % m + m) % m;
}
pair<long long, long long> congruence(long long a, long long b, long long m) {
long long d = gcd(a, m);
if (b % d) return make_pair(0, -1);
a /= d, b /= d, m /= d;
return make_pair(b * mod_inverse(a, m) % m, m);
}
pair<long long, long long> SimultaneousCongruence(long long a[], long long b[],
long long m[], long long n) {
long long x = 0, M = 1;
for (int i = 1; i <= n; i++) {
pair<long long, long long> res =
congruence(a[i] * M, (b[i] - a[i] * x % m[i] + m[i]) % m[i], m[i]);
if (res.second == -1) return res;
x += M * res.first, M *= res.second;
}
return make_pair(x, M);
}
const int FACT_MAX = 4000005;
long long q[FACT_MAX], e[FACT_MAX];
long long modpow(long long a, long long n, long long mod) {
if (n == 0) return 1;
if (n % 2) {
return ((a % mod) * (modpow(a, n - 1, mod) % mod)) % mod;
} else {
return modpow((a * a) % mod, n / 2, mod) % mod;
}
}
void make_fact(long long p, long long mod) {
long long qval = 1, eval = 0;
q[0] = 1, e[0] = 0;
for (int i = 1; i < FACT_MAX; i++) {
long long t = i;
while (t % p == 0) {
eval++;
t /= p;
}
qval *= t, qval %= mod;
q[i] = qval, e[i] = eval;
}
}
long long comb(long long n, long long k, long long p, long long ex,
long long mod) {
long long eval = e[n] - e[k] - e[n - k];
if (eval >= ex) return 0;
long long ret = q[n] * mod_inverse(q[k] * q[n - k] % mod, mod) % mod;
ret *= modpow(p, eval, mod), ret %= mod;
return ret;
}
long long n, M, l, r;
long long get(long long n, long long r, long long p, long long ex,
long long mod) {
if (n % 2 != r % 2) r++;
if (r > n) return 0;
long long h = (n - r) / 2;
long long ret = comb(n, h, p, ex, mod);
return ret;
}
long long calc(long long p, long long ex, long long mod) {
make_fact(p, mod);
long long ret = 0;
for (long long(i) = (0); (i) <= (n); (i)++) {
long long tmp =
get(n - i, l, p, ex, mod) - get(n - i, r + 1, p, ex, mod) + mod;
tmp *= comb(n, i, p, ex, mod), tmp %= mod;
ret += tmp, ret %= mod;
}
return ret;
}
int main(void) {
cin >> n >> M >> l >> r;
for (int i = 2; i < 40005; i++) {
if (prime[i]) continue;
for (int j = 2 * i; j < 40005; j += i) prime[j] = true;
}
for (int i = 2; i < 40005; i++) {
if (prime[i]) continue;
while (M % i == 0) {
mp[i]++;
M /= i;
}
}
if (M > 1) mp[M]++;
long long id = 0;
for (auto it = mp.begin(); it != mp.end(); it++) {
id++;
long long mod = 1;
for (int i = 0; i < it->second; i++) mod *= it->first;
a[id] = 1, b[id] = calc(it->first, it->second, mod), m[id] = mod;
}
cout << SimultaneousCongruence(a, b, m, id).first << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 998244353LL;
vector<long long int> fact(200005), inv_fact(200005);
long long int bin_exp(long long int a, long long int b) {
a = a % mod;
long long int ans = 1;
while (b > 0) {
if (b & 1 == 1) ans = (a * ans) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return ans;
}
long long int mod_inv(long long int n) {
long long int a = bin_exp(n, mod - 2);
return a;
}
void calc() {
fact[0] = 1;
inv_fact[0] = 1;
for (long long int i = 1; i < 200005; i++) {
fact[i] = (fact[i - 1] * i) % mod;
inv_fact[i] = (inv_fact[i - 1] * mod_inv(i)) % mod;
}
}
long long int nCr(long long int n, long long int r) {
long long int ans = (fact[n] * ((inv_fact[n - r] * inv_fact[r]) % mod)) % mod;
return ans;
}
void solve() {
long long int n;
cin >> n;
if (n == 1) {
cout << 10 << "\n";
return;
}
vector<long long int> v(n + 1, 0);
for (long long int i = 1; i < n + 1; i++) {
long long int temp = 10;
long long int rem = max(0LL, n - i);
if (rem > 0) (temp *= 18LL) %= mod;
rem = max(0LL, rem - 1);
(temp *= bin_exp(10, rem)) %= mod;
long long int temp2 = 1;
temp2 = max(0LL, n - 2 - i + 1);
(temp2 *= (10 * 9 * 9)) %= mod;
rem = max(0LL, n - i - 2);
(temp2 *= bin_exp(10, rem)) %= mod;
v[i] = (temp + temp2) % mod;
}
for (long long int i = 1; i < n + 1; i++) cout << v[i] << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
for (long long int i = 0; i < t; i++) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
int32_t main() {
long long int t, k;
cin >> t >> k;
vector<pair<long long int, long long int> > q;
long long int maxi = 0;
for (long long int i = 0; i < t; i++) {
long long int a, b;
cin >> a >> b;
maxi = max(maxi, max(a, b));
q.push_back({a, b});
}
vector<long long int> a(maxi + 1);
for (long long int i = 0; i < maxi + 1; i++) a[i] = 1;
for (long long int i = k; i <= maxi; i++) {
a[i] = (a[i - 1] % mod + a[i - k] % mod) % mod;
}
for (long long int i = 1; i <= maxi; i++) {
a[i] = (a[i - 1] % mod + a[i] % mod) % mod;
}
for (long long int i = 0; i < t; i++) {
long long int ans =
(a[q[i].second] % mod - a[q[i].first - 1] % mod + mod) % mod;
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
if (a == b) {
cout << a;
} else {
cout << 1;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c;
cin >> n >> a >> b >> c;
long long ma = n / a, mb = 0;
if (b <= n) mb = 1 + (n - b) / (b - c) + ((n - b) % (b - c) + c) / a;
cout << max(ma, mb) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename C>
void MA(C& a, C b) {
if (a < b) a = b;
}
template <typename C>
void MI(C& a, C b) {
if (a > b) a = b;
}
long long wyn;
int n, m;
char z[100010];
long long licz(long long a) { return (a * a + a) / 2; }
int main() {
scanf("%d%d", &n, &m);
if (n == 1) {
printf("%d\n", m - 1);
return 0;
}
scanf("%s", z);
char ost = 0;
int il = 0;
vector<int> blo;
vector<char> lit;
for (int i = 0; i < n; i++) {
if (ost != z[i]) {
if (i) {
blo.push_back(il);
lit.push_back(ost);
}
il = 0;
ost = z[i];
}
il++;
}
blo.push_back(il);
lit.push_back(ost);
int wne = n - ((int)(blo).size());
for (int i = 0; i < blo.size(); i++) {
if (blo[i] == 1) {
if (i != 0 && i != ((int)(blo).size()) - 1 && lit[i - 1] == lit[i + 1]) {
wyn += (2 * m - 2);
wyn += (m - 2) * 1ll * (((int)(blo).size()) - 3);
wyn += ((int)(blo).size()) - 2;
wyn += (wne + 1) * 1ll * (m - 1);
wyn--;
} else {
wyn += (2 * m - 2);
wyn += (m - 2) * 1ll * (((int)(blo).size()) - 2);
wyn += ((int)(blo).size()) - 1;
wyn += wne * 1ll * (m - 1);
wyn--;
}
} else {
wyn += (2 * m - 2);
wyn += (m - 2) * 1ll * (((int)(blo).size()) - 1);
wyn += ((int)(blo).size()) - 1;
wyn += (wne - 1) * 1ll * (m - 1);
}
}
int i = 0;
while (1) {
while (z[i] == z[i + 1]) i++;
if (i == n - 1) break;
int j = i + 1;
while (z[j + 1] == z[j - 1]) j++;
wyn -= licz(j - i);
i = j;
}
printf("%lld\n", wyn);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long block_size;
bool cmp(const pair<pair<long long, long long>, long long> &a,
const pair<pair<long long, long long>, long long> &b) {
long long bl_a = a.first.first / block_size;
long long bl_b = b.first.first / block_size;
if (bl_a == bl_b) {
if (a.first.second == b.first.second) {
if (a.first.first == b.first.first) {
return a.second < b.second;
}
return a.first.first < b.first.first;
}
return a.first.second < b.first.second;
}
return bl_a < bl_b;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, i, t;
cin >> n >> t;
vector<long long> a(n);
vector<long long> answer(t);
vector<pair<pair<long long, long long>, long long>> queries(t);
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < t; i++) {
cin >> queries[i].first.first >> queries[i].first.second;
queries[i].first.first--;
queries[i].first.second--;
queries[i].second = i;
}
block_size = sqrt(n);
sort(queries.begin(), queries.end(), cmp);
long long l = 0, r = -1, *cnt = new long long[(long long)1e6 + 1];
long long ans = 0;
for (i = 0; i < t; i++) {
while (l > queries[i].first.first) {
l--;
ans -= cnt[a[l]] * cnt[a[l]] * a[l];
cnt[a[l]]++;
ans += cnt[a[l]] * cnt[a[l]] * a[l];
}
while (r < queries[i].first.second) {
r++;
ans -= cnt[a[r]] * cnt[a[r]] * a[r];
cnt[a[r]]++;
ans += cnt[a[r]] * cnt[a[r]] * a[r];
}
while (l < queries[i].first.first) {
ans -= cnt[a[l]] * cnt[a[l]] * a[l];
cnt[a[l]]--;
ans += cnt[a[l]] * cnt[a[l]] * a[l];
l++;
}
while (r > queries[i].first.second) {
ans -= cnt[a[r]] * cnt[a[r]] * a[r];
cnt[a[r]]--;
ans += cnt[a[r]] * cnt[a[r]] * a[r];
r--;
}
answer[queries[i].second] = ans;
}
for (auto it : answer) {
cout << it << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 210;
const int MAXA = 20100;
int N;
int evens = 0, odds = 0;
int A[MAXN];
int cap[MAXN][MAXN];
bool vis[MAXN];
vector<int> adj[MAXN];
bool is_prime[MAXA];
void primes() {
memset(is_prime, true, sizeof(is_prime));
for (int i = 2; i < MAXA; ++i)
if (is_prime[i])
for (int k = i * 2; k < MAXA; k += i) is_prime[k] = false;
}
bool dfs(int cur) {
if (cur == (N + 1)) return true;
if (vis[cur]) return false;
vis[cur] = true;
for (int i = 0; i <= N + 1; ++i)
if (cap[cur][i] && dfs(i)) {
--cap[cur][i];
++cap[i][cur];
return true;
}
return false;
}
void build() {
memset(cap, 0, sizeof(cap));
for (int i = 0; i < N; ++i) {
if (A[i] & 1)
cap[(N)][i] = 2;
else
cap[i][(N + 1)] = 2;
}
for (int i = 0; i < N; ++i)
for (int k = 0; k < N; ++k)
if ((A[i] & 1) && is_prime[A[i] + A[k]]) cap[i][k] = 1;
}
int max_flow() {
memset(vis, false, sizeof(vis));
int flow = 0;
while (dfs((N))) {
++flow;
memset(vis, false, sizeof(vis));
}
return flow;
}
void dfs2(int cur, vector<int>& ref) {
if (vis[cur]) return;
vis[cur] = true;
ref.push_back(cur + 1);
for (int nxt : adj[cur]) dfs2(nxt, ref);
}
int main() {
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> A[i];
if (A[i] & 1)
++odds;
else
++evens;
}
if (odds != evens) {
cout << "Impossible\n";
return 0;
}
primes();
build();
int flow = max_flow();
if (flow != N) {
cout << "Impossible\n";
return 0;
}
for (int i = 0; i < N; ++i)
for (int k = 0; k < N; ++k)
if ((A[i] & 1) && is_prime[A[i] + A[k]] && cap[i][k] == 0) {
adj[i].push_back(k);
adj[k].push_back(i);
}
vector<vector<int>> res;
memset(vis, false, sizeof(vis));
for (int i = 0; i < N; ++i)
if (!vis[i]) {
res.push_back(vector<int>());
dfs2(i, res.back());
}
cout << res.size() << '\n';
for (vector<int>& v : res) {
cout << v.size() << ' ';
for (int x : v) cout << x << ' ';
cout << '\n';
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.