solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, a, b;
scanf("%lld%lld%lld", &t, &a, &b);
if (t == a && b == a && t == 1) {
puts("inf");
} else if (t != 1 && t != a && a == b) {
puts("1");
} else if (t == a && b == a && t > 1) {
puts("2");
} else if (a == 1) {
puts("0");
} else {
long long sum = 0, powT = 1;
bool one = b == 1;
while (b > 0) {
sum += b % a * powT;
b /= a;
powT *= t;
}
if (sum == a || (t == 1 && sum == 1 && !one))
puts("1");
else
puts("0");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
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;
}
int best = 0;
vector<int> sol;
map<pair<int, int>, pair<int, int> > dp;
void check(int a, int b, int c, int pos) {
if (dp.count({a, b}) == 0) {
return;
}
auto p = dp[{a, b}];
int now = min(min(a, b), p.first + c);
if (best < now) {
best = now;
sol = {p.second, pos};
}
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
if (a < b) {
swap(a, b);
}
if (a < c) {
swap(a, c);
}
if (b < c) {
swap(b, c);
}
if (best < c) {
best = c;
sol = {i};
}
check(a, b, c, i);
dp[{a, b}] = max(dp[{a, b}], {c, i});
dp[{a, c}] = max(dp[{a, c}], {b, i});
dp[{b, c}] = max(dp[{b, c}], {a, i});
}
cout << sol.size() << "\n";
for (int i = 0; i < sol.size(); i++) {
if (i != 0) {
cout << " ";
}
cout << (sol[i] + 1);
}
cout << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
int k;
k = pow(2, (n / 2) + 1) - 2;
cout << k << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
int n, m;
long long A[555];
long long findrt(long long num, int P) {
long long lft = 0, rgt = (P == 2 ? 2000000000LL : (P == 3 ? 2000000 : 37700));
while (lft + 1 < rgt) {
long long mid = (lft + rgt) / 2;
long long C = 1;
for (int(j) = 0; (j) < (P); (j)++) C *= mid;
if (C <= num) {
lft = mid;
} else {
rgt = mid;
}
}
long long C = 1;
for (int(j) = 0; (j) < (P); (j)++) C *= lft;
if (C == num) return lft;
return -1;
}
long long gcd(long long a, long long b) {
while (b != 0) {
long long r = a % b;
a = b;
b = r;
}
return a;
}
int main() {
scanf("%d", &n);
for (int(i) = 0; (i) < (n); (i)++) scanf("%lld", A + i);
map<long long, int> M;
map<long long, int> M2;
vector<int> rem;
for (int(i) = 0; (i) < (n); (i)++) {
if (A[i] == 1) continue;
long long x = findrt(A[i], 4);
long long y = findrt(A[i], 3);
long long z = findrt(A[i], 2);
if (x != -1) {
M[x] += 4;
} else if (y != -1) {
M[y] += 3;
} else if (z != -1) {
M[z] += 2;
} else {
bool found = false;
for (int(j) = 0; (j) < (n); (j)++) {
long long G = gcd(A[i], A[j]);
if (G > 1 && G < A[i]) {
long long p1 = G;
long long p2 = A[i] / G;
M[p1]++;
M[p2]++;
found = true;
break;
}
}
if (!found) {
M2[A[i]]++;
}
}
}
long long divs = 1;
const long long mod = 998244353;
for (auto p : M) {
divs = (divs * (p.second + 1)) % mod;
}
for (auto p : M2) {
divs = (divs * (p.second + 1)) % mod;
divs = (divs * (p.second + 1)) % mod;
}
printf("%lld\n", divs);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long double t[120001], v[120001], ans[120001], a, d;
int n, i;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> d;
cout << setprecision(10) << fixed;
for (i = 1; i <= n; i++) cin >> t[i] >> v[i];
for (i = 1; i <= n; i++) {
ans[i] = t[i];
if (v[i] * v[i] / a / 2. < d)
ans[i] += v[i] / a + (d - v[i] * v[i] / a / 2.) / v[i];
else
ans[i] += sqrt(d * 2. / a);
}
for (i = 1; i <= n; i++) ans[i] = max(ans[i], ans[i - 1]);
for (i = 1; i <= n; i++) cout << ans[i] << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y;
char a[510][510];
bool b[510][510];
int xx[4] = {0, 1, 0, -1};
int yy[4] = {1, 0, -1, 0};
void rec(int i, int j) {
b[i][j] = 1;
for (int g = 0; g < 4; g++) {
if (a[i + xx[g]][j + yy[g]] == '.' && !b[i + xx[g]][j + yy[g]]) {
rec(i + xx[g], j + yy[g]);
}
}
if (k != 0) {
k--;
a[i][j] = 'X';
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == '.') {
x = i;
y = j;
}
b[i][j] = 0;
}
}
for (int i = 0; i <= n + 1; i++) {
a[i][0] = '#';
a[i][m + 1] = '#';
}
for (int j = 0; j <= m + 1; j++) {
a[0][j] = '#';
a[n + 1][j] = '#';
}
rec(x, y);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << a[i][j];
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int MAXx = 1e7 + 7;
const long long int MOD = 1000000007;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
void read(long long int n, vector<long long int> &v) {
for (long long int i = 0; i < n; i++) cin >> v[i];
}
long long int n;
string s;
int main() {
fast();
long long int TEST_CASES = 1;
while (TEST_CASES--) {
int p, q, l, r;
cin >> p >> q >> l >> r;
vector<pair<int, int>> vp(p), vq(q);
for (int i = 0; i < p; i++) cin >> vp[i].first >> vp[i].second;
for (int i = 0; i < q; i++) cin >> vq[i].first >> vq[i].second;
long long int tot = 0;
for (int i = l; i <= r; i++) {
for (auto [fp, sp] : vp) {
bool f = 0;
for (auto [fq, sq] : vq) {
fq += i;
sq += i;
if (sq < fp || fq > sp)
continue;
else {
tot++;
f = 1;
break;
}
}
if (f) break;
}
}
cout << tot << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
if (y == 0) return 1;
long long int s = power(x, y / 2);
s *= s;
if (y % 2 == 1) s *= x;
return s;
}
long long int fac(long long int x) {
long long int pppp = 1;
for (int i = 2; i <= x; i++) {
pppp *= i;
}
return pppp;
}
char ALPH[26] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
int main() {
int h1, a1, c1;
int h2, a2;
cin >> h1 >> a1 >> c1 >> h2 >> a2;
vector<string> v;
while (h2 > 0) {
if (a1 >= h2) {
v.push_back("STRIKE");
break;
} else if (h1 > a2) {
h2 -= a1;
v.push_back("STRIKE");
if (h2 < 0) {
break;
}
} else {
h1 += c1;
v.push_back("HEAL");
}
h1 -= a2;
}
cout << v.size() << '\n';
for (int i = 0; i < v.size(); i++) {
cout << v[i] << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000010;
const int MAXN = 51000;
const int SQ = 300;
int n, m;
int go[MAX];
int a[MAXN];
int gn[MAXN];
bool cmp(tuple<int, int, int> a, tuple<int, int, int> b) {
int x = get<0>(a);
int y = get<0>(b);
x /= SQ;
y /= SQ;
if (x < y) return 1;
if (x > y) return 0;
return get<1>(a) < get<1>(b);
}
vector<tuple<int, int, int> > qq;
int ans[MAXN];
int nowmem = 0;
struct node {
int go[2];
int mn;
int mx;
node() {
go[0] = go[1] = 0;
mn = 1000010;
mx = -1;
}
};
node mem[MAXN * 22];
void clear() {
nowmem = 1;
mem[0] = node();
}
int newn() {
mem[nowmem] = node();
return nowmem++;
}
void add(int x) {
int now = 0;
int y = go[x - 1];
for (int i = 19; i >= 0; --i) {
mem[now].mn = min(mem[now].mn, x);
int g = (y >> i) & 1;
if (mem[now].go[g])
now = mem[now].go[g];
else
now = mem[now].go[g] = newn();
}
mem[now].mn = min(mem[now].mn, x);
now = 0;
y = go[x];
for (int i = 19; i >= 0; --i) {
mem[now].mx = max(mem[now].mx, x);
int g = (y >> i) & 1;
if (mem[now].go[g])
now = mem[now].go[g];
else
now = mem[now].go[g] = newn();
}
mem[now].mx = max(mem[now].mx, x);
}
int get(int x) {
int aa = 0;
int now = 0;
int y = go[x];
if (mem[now].mn <= x) {
for (int i = 19; i >= 0; --i) {
int g = (y >> i) & 1;
g ^= 1;
if (mem[now].go[g] && mem[mem[now].go[g]].mn <= x)
now = mem[now].go[g], y |= (1 << i);
else {
y ^= (y & (1 << i));
now = mem[now].go[g ^ 1];
}
}
aa = max(aa, y);
}
now = 0;
y = go[x - 1];
if (mem[now].mx >= x) {
for (int i = 19; i >= 0; --i) {
int g = (y >> i) & 1;
g ^= 1;
if (mem[now].go[g] && mem[mem[now].go[g]].mx >= x)
now = mem[now].go[g], y |= (1 << i);
else {
y ^= (y & (1 << i));
now = mem[now].go[g ^ 1];
}
}
aa = max(aa, y);
}
return aa;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
for (int i = 1; i <= 1000000; ++i) go[i] = go[i - 1] ^ i;
for (int i = 0; i <= n; i += SQ) {
clear();
int nowans = 0;
for (int j = i - 1; j >= 0 && j + SQ >= i; --j) {
add(a[j]);
nowans = max(nowans, get(a[j]));
gn[j] = nowans;
}
}
for (int i = 0; i < m; ++i) {
int l, r;
scanf("%d%d", &l, &r);
--l;
qq.push_back(make_tuple(l, r, i));
}
sort(qq.begin(), qq.end(), cmp);
int lst = 0;
int now = 0;
int nowans = 0;
for (int i = 0; i < (int)qq.size(); ++i) {
int l = get<0>(qq[i]);
int r = get<1>(qq[i]);
int q = get<2>(qq[i]);
int nx = SQ * (l / SQ + 1);
if (nx != lst) clear(), lst = nx, now = lst, nowans = 0;
if (r < nx) {
clear();
nowans = 0;
now = nx;
int aa = 0;
for (int j = l; j < r; ++j) add(a[j]), aa = max(aa, get(a[j]));
clear();
ans[q] = aa;
} else {
int aa = gn[l];
while (now < r) add(a[now]), nowans = max(nowans, get(a[now])), ++now;
aa = max(nowans, aa);
for (int j = l; j < nx; ++j) aa = max(aa, get(a[j]));
ans[q] = aa;
}
}
for (int i = 0; i < m; ++i) cout << ans[i] << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int cnt[1010];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d %d", &x, &y);
if (y != n) {
puts("NO");
return 0;
}
cnt[x]++;
}
int cur = 0;
for (int i = 1; i < n; i++) {
cur += cnt[i];
if (cur > i) {
puts("NO");
return 0;
}
}
int last = -1;
puts("YES");
set<int> unused;
for (int i = 1; i < n; i++) unused.insert(i);
for (int i = 1; i < n; i++) {
if (cnt[i] > 0) {
unused.erase(i);
if (last != -1) printf("%d %d\n", last, i);
last = i;
cnt[i]--;
}
while (cnt[i] > 0) {
printf("%d %d\n", last, *unused.begin());
last = *unused.begin();
cnt[i]--;
unused.erase(unused.begin());
}
}
printf("%d %d\n", last, n);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long lucky[1111];
int cnt, k;
void dfs(int digit, int i, int Lnumber) {
if (i == digit) {
++cnt;
lucky[cnt] = Lnumber;
return;
}
dfs(digit, i + 1, Lnumber * 10 + 4);
dfs(digit, i + 1, Lnumber * 10 + 7);
}
long long intersection(long long x1, long long y1, long long x2, long long y2) {
long long l = max(x1, x2);
long long r = min(y1, y2);
if (r - l + 1 > 0)
return r - l + 1;
else
return 0;
}
int main() {
for (int digit = 1; digit <= 9; digit++) dfs(digit, 0, 0);
lucky[0] = 0;
++cnt;
lucky[cnt] = 1000000000;
long long Pl, Pr, Vl, Vr;
scanf("%lld%lld%lld%lld%d", &Pl, &Pr, &Vl, &Vr, &k);
long long sum = 0;
for (int i = 1; i <= 1022 - k + 1; i++) {
int j = i + k - 1;
sum += intersection(lucky[i - 1] + 1, lucky[i], Pl, Pr) *
intersection(lucky[j], lucky[j + 1] - 1, Vl, Vr);
if (lucky[i] > Pr) break;
}
for (int i = 1; i <= 1022 - k + 1; i++) {
int j = i + k - 1;
sum += intersection(lucky[i - 1] + 1, lucky[i], Vl, Vr) *
intersection(lucky[j], lucky[j + 1] - 1, Pl, Pr);
if (lucky[i] > Vr) break;
}
if (k == 1) {
for (int i = 1; i <= 1022; i++) {
sum -= (intersection(lucky[i], lucky[i], Pl, Pr) *
intersection(lucky[i], lucky[i], Vl, Vr));
}
}
cout << fixed << setprecision(10)
<< (sum * 1.0) / (Vr - Vl + 1) / (Pr - Pl + 1) << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int nxt() {
int res;
scanf("%d", &res);
return res;
}
const int N = 100000;
char c[N + 1][10];
int len[N + 1];
int ans[N + 1];
int pw[10];
int getNum(int pos) {
vector<int> q;
for (int i = 0; i < len[pos]; ++i) {
if (c[pos][i] == '?') {
q.push_back(i);
}
}
if (q.empty()) {
int ret = atoi(c[pos]);
if (ret <= ans[pos - 1]) {
return -1;
}
return ret;
}
int l = 0, r = pw[q.size()] - 1;
if (q[0] == 0) {
l = pw[(int)q.size() - 1];
}
while (l < r) {
int m = (l + r) >> 1;
int xx = m;
for (int i = (int)q.size() - 1; i >= 0; --i) {
c[pos][q[i]] = xx % 10 + '0';
xx /= 10;
}
int val = atoi(c[pos]);
if (val <= ans[pos - 1]) {
l = m + 1;
} else {
r = m;
}
}
int xx = l;
for (int i = (int)q.size() - 1; i >= 0; --i) {
c[pos][q[i]] = xx % 10 + '0';
xx /= 10;
}
int val = atoi(c[pos]);
if (val <= ans[pos - 1]) {
return -1;
} else {
return val;
}
}
inline void solve() {
int n = nxt();
for (int i = 1; i <= n; ++i) {
scanf("%s", c[i]);
len[i] = strlen(c[i]);
}
pw[0] = 1;
for (int i = 1; i < 10; ++i) {
pw[i] = pw[i - 1] * 10;
}
ans[0] = 0;
for (int i = 1; i <= n; ++i) {
ans[i] = getNum(i);
if (ans[i] == -1) {
puts("NO");
return;
}
}
puts("YES");
for (int i = 1; i <= n; ++i) {
printf("%d\n", ans[i]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int l = 0, n = 0;
string s;
while (getline(cin, s)) {
if (s[0] == '+')
n++;
else if (s[0] == '-')
n--;
else
l += n * (s.size() - s.find(':') - 1);
}
cout << l;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t, n, x[4005];
set<int> s;
bool dp[4005];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 0; i < n * 2; i++) {
scanf("%d", x + i);
s.insert(i + 1);
}
memset(dp, 0, n * 2 + 1);
dp[0] = 1;
for (int i = n * 2 - 1, cnt = 0, hv = 0; i >= 0; i--) {
cnt++;
if (x[i] == *s.rbegin()) {
for (int j = hv; j >= 0; j--)
if (dp[j]) dp[j + cnt] = 1;
hv += cnt;
cnt = 0;
}
s.erase(x[i]);
}
puts(dp[n] ? "YES" : "NO");
}
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:67108864")
using namespace std;
const long double EPS = 1e-9;
const int INF = 1 << 28;
const long double PI = fabsl(atan2l(0.0, -1.0));
const int MAXCHIPS = 5005;
int n;
int b[101][101];
void load() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) scanf("%d", &b[i][j]);
}
}
void solve() {
vector<int> a(n, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
a[i] |= b[i][j];
a[j] |= b[i][j];
}
}
for (int i = 0; i < n; i++) {
if (i > 0) printf(" ");
printf("%d", a[i]);
}
printf("\n");
}
int main() {
load();
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int a[] = {0, 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1,
14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1,
51, 1, 2, 1, 14, 1, 2, 2, 14, 1, 6, 1, 4, 2, 2, 1,
52, 2, 5, 1, 5, 1, 15, 2, 13, 2, 2, 1, 13, 1, 2, 4,
267, 1, 4, 1, 5, 1, 4, 1, 50, 1, 2, 3, 4, 1, 6, 1,
52, 15, 2, 1, 15, 1, 2, 1, 12, 1, 10, 1, 4, 2};
int main() {
int n;
scanf("%d", &n);
printf("%d", a[n]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e5 + 5;
void re(int &x) { scanf("%d", &x); }
void re(long long &x, long long &y) { scanf("%lld%lld", &x, &y); }
long long A[N], B[N];
long long F[N], T[N], X[N], V[N], n, w, i, j;
long long asd;
void up(int x, int t) {
for (; x < N; x += x & -x) F[x] += t;
}
int qry(int x) {
int t = 0;
for (; x; x -= x & -x) t += F[x];
return t;
}
bool cma(int i, int j) { return X[i] * abs(V[j] + w) < X[j] * abs(V[i] + w); }
bool cmb(int i, int j) { return X[i] * abs(V[j] - w) < X[j] * abs(V[i] - w); }
int main() {
re(n, w);
for (i = 1; i <= n; i++) {
re(X[i], V[i]);
A[i] = B[i] = i;
X[i] = abs(X[i]);
}
sort(A + 1, A + n + 1, cma);
sort(B + 1, B + n + 1, cmb);
for (i = j = 1; i <= n; i++) {
if (cmb(B[i - 1], B[i])) j++;
T[B[i]] = j;
}
for (i = j = n; i; i--) {
asd += qry(T[A[i]]);
if (i == 1 || cma(A[i - 1], A[i])) {
asd += (j - i) * (j - i + 1) / 2;
for (; j >= i; j--) up(T[A[j]], 1);
}
}
cout << asd;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long in() {
long long a;
scanf("%lld", &a);
return a;
}
double din() {
double a;
scanf("%lf", &a);
return a;
}
long long bigmod(long long b, long long p, long long md) {
if (p == 0) return 1;
if (p % 2 == 1) {
return ((b % md) * bigmod(b, p - 1, md)) % md;
} else {
long long y = bigmod(b, p / 2, md);
return (y * y) % md;
}
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long getRandom(long long a, long long b) {
long long ret = (long long)rand() * (long long)rand();
ret %= (b - a + 1);
ret += a;
return ret;
}
int ar1[100005], ar2[100005], col[100005], pos1, pos2;
vector<int> adj[100005];
void dfs(int u) {
if (col[u] == 1)
ar1[pos1++] = u;
else
ar2[pos2++] = u;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (col[v] == 0) {
if (col[u] == 1)
col[v] = 2;
else
col[v] = 1;
dfs(v);
}
}
}
map<pair<int, int>, int> mpp;
int main() {
int n = in(), m = in();
for (int i = 0; i < m; i++) {
int u = in(), v = in();
adj[u].push_back(v);
adj[v].push_back(u);
mpp[pair<int, int>(u, v)] = 1;
mpp[pair<int, int>(v, u)] = 1;
}
int ar[n + 5];
for (int i = 0; i < n; i++) ar[i] = i + 1;
int cnt = 500;
while (cnt--) {
random_shuffle(ar, ar + n);
bool hobe = 1;
for (int i = 0; i < m && hobe; i++) {
if (mpp.find(pair<int, int>(ar[i], ar[(i + 1) % n])) != mpp.end())
hobe = 0;
}
if (hobe) {
for (int i = 0; i < m; i++) {
printf("%d %d\n", ar[i], ar[(i + 1) % n]);
}
return 0;
}
}
puts("-1");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int modpow(long long int a, long long int n, long long int temp) {
long long int res = 1, y = a;
while (n > 0) {
if (n & 1) res = (res * y) % temp;
y = (y * y) % temp;
n /= 2;
}
return res % temp;
}
int leftit[1000006], rightit[1000006], arr[1000006];
int main() {
int n, ans = -(int)(1e9 + 7), i;
scanf("%d", &n);
leftit[0] = rightit[n + 1] = 0;
for (i = 1; i < n + 1; ++i) scanf("%d", &arr[i]);
for (i = 1; i < n + 1; ++i)
leftit[i] =
((leftit[i - 1] + 1) < (arr[i]) ? (leftit[i - 1] + 1) : (arr[i]));
for (i = n; i >= 1; i--)
rightit[i] =
((rightit[i + 1] + 1) < (arr[i]) ? (rightit[i + 1] + 1) : (arr[i]));
for (i = 1; i < n + 1; ++i)
ans = ((ans) > (((leftit[i]) < (rightit[i]) ? (leftit[i]) : (rightit[i])))
? (ans)
: (((leftit[i]) < (rightit[i]) ? (leftit[i]) : (rightit[i]))));
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
clock_t __stt;
inline void TStart() { __stt = clock(); }
inline void TReport() {
cerr << fixed << setprecision(3) << "\nCurrent Case Taken Time : "
<< (double)(clock() - __stt) / CLOCKS_PER_SEC << "sec\n";
}
template <typename T>
T MIN(T a, T b) {
return a < b ? a : b;
}
template <typename T>
T MAX(T a, T b) {
return a > b ? a : b;
}
template <typename T>
T ABS(T a) {
return a > 0 ? a : (-a);
}
template <typename T>
void UMIN(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
void UMAX(T &a, T b) {
if (b > a) a = b;
}
char readch() {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
int n, m, c[4005][4005], segs;
int w(int l, int r) {
return (c[r][r] - (l ? (c[l - 1][r] + c[r][l - 1] - c[l - 1][l - 1]) : 0)) /
2;
}
pair<long long, int> dp[4005];
int deq[4005], pl, pr, EXT;
pair<long long, int> eval(int s, int t) {
return make_pair(dp[s].first + (long long)w(s, t - 1) + (long long)EXT,
dp[s].second - 1);
}
int overtake(int A, int B) {
int R = n + 1, i;
for (i = 12; i >= 0; --i) {
int nR = R - (1 << i);
if (nR > A && nR > B && eval(A, nR) < eval(B, nR)) R = nR;
}
return R;
}
long long check(int ext) {
int i, j, k;
EXT = ext;
dp[0] = make_pair(0ll, 0);
pl = 0;
pr = 1;
deq[0] = 0;
for (i = 1; i <= n; ++i) {
while (pr > pl + 1) {
if (eval(deq[pl], i) >= eval(deq[pl + 1], i))
++pl;
else
break;
}
dp[i] = eval(deq[pl], i);
while (pr > pl + 1) {
if (overtake(i, deq[pr - 1]) <= overtake(deq[pr - 1], deq[pr - 2]))
--pr;
else
break;
}
if (eval(i, n) < eval(deq[pr - 1], n)) deq[pr++] = i;
}
segs = -dp[n].second;
return dp[n].first;
}
int main() {
int i, j, k;
scanf("%d%d", &n, &m);
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
c[i][j] = readch() - '0';
}
}
for (i = 0; i < n; ++i) {
for (j = 1; j < n; ++j) {
c[i][j] += c[i][j - 1];
}
}
for (i = 1; i < n; ++i) {
for (j = 0; j < n; ++j) {
c[i][j] += c[i - 1][j];
}
}
int low = 0, high = 2e8, mid;
long long res = 0ll;
while (low < high) {
mid = (low + high + 1) / 2;
long long R = check(mid);
if (segs < m)
high = mid - 1;
else {
low = mid;
UMAX(res, R);
}
}
printf("%lld\n", res - (long long)low * (long long)m);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, n, l, t, m;
int main() {
scanf("%I64d%I64d%I64d", &a, &b, &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d%I64d%I64d", &l, &t, &m);
if (t < a + (l - 1) * b) {
puts("-1");
continue;
}
long long low = 1, high = 5000000;
while (low <= high) {
long long mid = (low + high) / 2;
if ((2 * a + (l + mid - 2) * b) * (mid - l + 1) > t * m * 2)
high = mid - 1;
else
low = mid + 1;
}
printf("%I64d\n", min(high, (t - a + b) / b));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool v[105];
int ara[105];
int main() {
int T;
cin >> T;
for (int t = 1; t <= T; t++) {
int N;
memset(v, 0, sizeof(v));
cin >> N;
for (int i = 0; i < N; i++) {
cin >> ara[i];
}
for (int i = N - 2; i >= 0; i--) {
if (ara[i] > ara[i + 1]) {
swap(ara[i], ara[i + 1]);
v[i] = 1;
}
}
while (1) {
bool b = 0;
for (int i = 0; i < N - 1; i++) {
if (!v[i] && ara[i] > ara[i + 1]) {
swap(ara[i], ara[i + 1]);
v[i] = 1;
b = 1;
}
}
if (!b) {
break;
}
}
for (int i = 0; i < N; i++) {
cout << ara[i] << ' ';
}
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> adj[200005];
map<int, int> card;
set<int> s[200005];
bool vis[200005];
vector<int> ans;
int dfs(int node, int p) {
vis[node] = true;
int ret = 0;
for (auto x : adj[node]) {
if (x.first != p) {
int t = dfs(x.first, node);
if (t == 0 && x.second == 2) {
ans.push_back(x.first);
ret = 1;
} else
ret += t;
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
int col[n + 1];
map<int, int> mp;
for (int i = 1; i <= n; i++) {
cin >> col[i];
mp[col[i]]++;
}
for (int i = 1; i <= m; i++) {
int x, y, t;
cin >> x >> y;
if (col[x] != col[y]) {
s[col[x]].insert(col[y]);
s[col[y]].insert(col[x]);
}
}
int mx = -1, mn = INT_MAX;
for (auto x : mp) {
if (mx < int(s[x.first].size())) {
mx = s[x.first].size();
mn = x.first;
}
}
cout << mn << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int m, n, nums[1010][35], P[1010] = {0}, nCr[1010][1010], basis[1010][35],
sz = 0, pivots[1010];
char buf[1010];
int main() {
int mask = 0x1F, shift = 5;
scanf("%d%d", &m, &n);
for (int i = 0; i < n; i++) {
scanf("%s", buf);
for (int j = 0; j < m; j++) {
nums[i][j >> shift] |= (buf[j] == '1') << (j & mask);
}
}
nCr[0][0] = 1;
for (int i = 1; i <= m; i++) {
nCr[i][0] = nCr[i][i] = 1;
for (int j = 1; j < i; j++) {
nCr[i][j] = (nCr[i - 1][j - 1] + nCr[i - 1][j]) % 1000000007;
}
}
P[0] = 1;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= i; j++) {
P[i] = (P[i] + 1LL * nCr[i - 1][j - 1] * P[i - j]) % 1000000007;
}
}
for (int i = 0; i < m >> shift; i++) nums[n][i] = 0xFFFFFFFF;
nums[n][m >> shift] = (1 << (m & mask)) - 1;
for (int i = 0; i < m; i++) pivots[i] = -1;
for (int i = 0; i < m; i++) {
int idx = 0;
while (idx <= n && ((nums[idx][i >> shift] >> (i & mask)) & 1) == 0) {
idx++;
}
if (idx == n + 1) continue;
for (int i = 0; i < 35; i++) {
basis[sz][i] = nums[idx][i];
}
for (int j = idx; j <= n; j++) {
if ((nums[j][i >> shift] >> (i & mask)) & 1) {
for (int i = 0; i < 35; i++) {
nums[j][i] ^= basis[sz][i];
}
}
}
pivots[i] = sz;
sz++;
}
for (int i = 0; i < m; i++) {
if (pivots[i] != -1) {
int u = pivots[i];
for (int j = 0; j < sz; j++) {
if (j != u && ((basis[j][i >> shift] >> (i & mask)) & 1))
for (int z = 0; z < 35; z++) {
basis[j][z] ^= basis[u][z];
}
}
}
}
for (int i = 0; i < m; i++) {
if (pivots[i] == -1) {
int u = -1, v = -1;
for (int j = 0; j < sz; j++) {
if ((basis[j][i >> shift] >> (i & mask)) & 1) {
v = u;
u = j;
}
}
if (v != -1) {
for (int z = 0; z < 35; z++) {
basis[sz][z] = basis[u][z] & basis[v][z];
}
for (int j = i + 1; j < m; j++) {
if (pivots[j] != -1 && ((basis[sz][j >> shift] >> (j & mask)) & 1)) {
int u = pivots[j];
for (int k = 0; k < 35; k++) basis[sz][k] ^= basis[u][k];
}
}
for (int j = 0; j < sz; j++) {
if (basis[j][i >> shift] >> (i & mask) & 1) {
for (int k = 0; k < 35; k++) {
basis[j][k] ^= basis[sz][k];
}
}
}
pivots[i] = sz;
sz++;
}
}
}
int ans = 1, num_ones = 0;
for (int i = 0; i < sz; i++) {
int no = 0;
for (int j = 0; j < m; j++) {
no += (basis[i][j >> shift] >> (j & mask)) & 1;
}
num_ones += no;
ans = 1LL * ans * P[no] % 1000000007;
}
ans = 1LL * ans * P[m - num_ones] % 1000000007;
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MN = 1111;
long long t[MN][2];
long long used[MN];
int main() {
long long n;
cin >> n;
for (long long i = 0; i < n; ++i) {
cin >> t[i][0] >> t[i][1];
}
long long ans = 1e18;
for (long long i = 1; i <= 1000; ++i) {
long long q = n / 2;
memset(used, 0, sizeof used);
for (long long j = 0; j < n; ++j) {
if (t[j][1] > i) {
if (t[j][0] > i) goto ohi;
used[j] = 1;
--q;
}
}
if (q >= 0) {
vector<long long> v;
for (long long j = 0; j < n; ++j) {
if (!used[j] && t[j][1] < t[j][0] && t[j][0] <= i) {
v.push_back(t[j][0] - t[j][1]);
}
}
sort(v.begin(), v.end());
long long totWidth = 0;
for (long long j = 0; j < n; ++j) {
if (used[j]) {
totWidth += t[j][1];
} else
totWidth += t[j][0];
}
while (q && v.size()) {
totWidth -= v.back();
--q;
v.pop_back();
}
ans = min(ans, totWidth * i);
}
ohi:;
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i = 0, j = 0, k = 0, tmp = 0, tmp1 = 0, tmp2 = 0, tmp3 = 0, tmp4 = 0,
tmp5 = 0, flag = 0, T = 0, N = 0, Q = 0;
cin >> N;
vector<int> rate(2001, 0), rank(2001, 1);
for (i = 1; i < N + 1; i++) {
cin >> rate[i];
int cur = 0;
for (j = 1; j < i; j++)
if (rate[j] < rate[i])
rank[j]++;
else if (rate[j] > rate[i])
cur++;
rank[i] = cur;
}
int min = 1;
for (i = 1; i < N + 1; i++)
if (rank[i] < min) min = rank[i];
int er = 1 - min;
for (i = 1; i < N + 1; i++) rank[i] += er;
for (i = 1; i < N + 1; i++) cout << rank[i] << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, m, q, cnt;
int a[maxn];
int val[maxn];
int lit[maxn], rit[maxn];
int lazy[maxn << 2];
int vis[maxn];
vector<int> v[maxn];
bitset<1005> prime;
bitset<1005> resta;
bitset<1005> tr[maxn << 2];
void pushdown(int num) {
lazy[num] %= m;
if (lazy[num] == 0) return;
lazy[(num << 1)] = (lazy[(num << 1)] + lazy[num]) % m;
lazy[(num << 1 | 1)] = (lazy[(num << 1 | 1)] + lazy[num]) % m;
tr[(num << 1)] = (tr[(num << 1)] & resta);
tr[(num << 1 | 1)] = (tr[(num << 1 | 1)] & resta);
tr[(num << 1)] =
(tr[(num << 1)] << lazy[num]) | (tr[(num << 1)] >> (m - lazy[num]));
tr[(num << 1 | 1)] = (tr[(num << 1 | 1)] << lazy[num]) |
(tr[(num << 1 | 1)] >> (m - lazy[num]));
tr[(num << 1)] = (tr[(num << 1)] & resta);
tr[(num << 1 | 1)] = (tr[(num << 1 | 1)] & resta);
lazy[num] = 0;
return;
}
void pushup(int num) {
tr[num] = (tr[num] & resta);
tr[num] = (tr[(num << 1)] | tr[(num << 1 | 1)]);
tr[num] = (tr[num] & resta);
return;
}
void build(int l, int r, int num) {
lazy[num] = 0;
if (l == r) {
tr[num][val[l]] = 1;
return;
}
int mid = (l + r) >> 1;
build(l, mid, (num << 1));
build(mid + 1, r, (num << 1 | 1));
pushup(num);
return;
}
void modify(int l, int r, int num, int le, int ri, int mods) {
if (ri < l || r < le) return;
if (le <= l && r <= ri) {
lazy[num] = (lazy[num] + mods) % m;
tr[num] = (tr[num] & resta);
tr[num] = (tr[num] << mods) | (tr[num] >> (m - mods));
tr[num] = (tr[num] & resta);
return;
}
int mid = (l + r) >> 1;
pushdown(num);
if (mid >= le) modify(l, mid, (num << 1), le, ri, mods);
if (mid < ri) modify(mid + 1, r, (num << 1 | 1), le, ri, mods);
pushup(num);
}
void quriy(int l, int r, int num, int le, int ri, bitset<1005>& ans) {
if (ri < l || r < le) return;
if (le <= l && r <= ri) {
ans = (ans | tr[num]);
return;
}
int mid = (l + r) >> 1;
pushdown(num);
if (mid >= le) quriy(l, mid, (num << 1), le, ri, ans);
if (mid < ri) quriy(mid + 1, r, (num << 1 | 1), le, ri, ans);
pushup(num);
return;
}
int dfs(int now) {
vis[now] = 1;
int le = n + 1;
for (int i = 0; i < v[now].size(); i++) {
int node = v[now][i];
if (vis[node] == 1) continue;
le = min(le, dfs(node));
}
if (le == n + 1) {
lit[now] = rit[now] = ++cnt;
val[cnt] = a[now];
return cnt;
} else {
lit[now] = le;
rit[now] = ++cnt;
val[cnt] = a[now];
return le;
}
}
int main() {
prime.set();
resta.set();
prime[0] = 0;
prime[1] = 0;
for (int i = 2; i <= 1000; i++) {
if (prime[i] == 0) continue;
for (int j = i * i; j <= 1000; j += i) {
prime[j] = 0;
}
}
cnt = 0;
scanf("%d%d", &n, &m);
for (int i = m; i < 1005; i++) resta[i] = 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] %= m;
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
dfs(1);
build(1, n, 1);
scanf("%d", &q);
while (q--) {
int op, x;
scanf("%d%d", &op, &x);
if (op == 1) {
int mods;
scanf("%d", &mods);
if (mods % m != 0) modify(1, n, 1, lit[x], rit[x], mods % m);
} else {
bitset<1005> ans;
ans.reset();
quriy(1, n, 1, lit[x], rit[x], ans);
ans = ans & resta;
printf("%d\n", (ans & prime).count());
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int i;
stringstream(s) >> i;
return i;
}
inline string toString(int i) {
string s;
stringstream ss;
ss << i;
ss >> s;
return s;
}
vector<vector<int> > cat;
void f(int n, vector<int> x) {
if (n == 0) {
vector<int> c(3, 0);
for (auto i : x) c[i + 1]++;
if (c[2] <= 1 && c[1] >= 1 && c[1] + c[2] >= 2) cat.push_back(x);
} else {
x.push_back(-1);
f(n - 1, x);
x[x.size() - 1] = 0;
f(n - 1, x);
x[x.size() - 1] = 1;
f(n - 1, x);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
double ans = 0, p;
vector<vector<int> > a(n, vector<int>(2));
for (int i = 0; i < n; i++) cin >> a[i][0] >> a[i][1];
f(n, vector<int>());
for (int k = 1; k <= 10000; k++) {
for (auto c : cat) {
p = 1;
for (int i = 0; i < n; i++) {
if (c[i] == -1) {
p *=
max(0, min(k, a[i][1] + 1) - a[i][0]) / (a[i][1] - a[i][0] + 1.0);
} else if (c[i] == 0) {
p *= (a[i][0] <= k && k <= a[i][1]) / (a[i][1] - a[i][0] + 1.0);
} else {
p *= max(0, a[i][1] - max(k + 1, a[i][0]) + 1) /
(a[i][1] - a[i][0] + 1.0);
}
}
ans += k * p;
}
}
cout << setprecision(10) << fixed << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0;
char c = getchar();
bool f = 0;
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
if (f) return -sum;
return sum;
}
const int N = 100005;
int n, K;
struct ex {
int x, r, f;
inline void in() { x = read(), r = read(), f = read(); }
} st[N];
inline bool operator<(const ex &a, const ex &b) { return a.r > b.r; }
struct bianry_serach {
int X[N], len;
inline void INIT() {
sort(X + 1, X + n + 1);
X[0] = -1;
for (int i = 1; i <= n; i++)
if (X[i] != X[i - 1]) X[++len] = X[i];
}
inline int b1(int x) {
int l = 1, r = len, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (X[mid] <= x)
l = mid + 1;
else
r = mid - 1;
}
return r;
}
inline int b2(int x) {
int l = 1, r = len, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (X[mid] >= x)
r = mid - 1;
else
l = mid + 1;
}
return l;
}
} fx, ff;
namespace Tree {
const int M = 20000000;
int ls[M], rs[M], t[M], rt[N], inc, num, n, ps;
inline int ask(int p, int l, int r, int L, int R) {
if (!p) return 0;
if (l == L && r == R) return t[p];
int mid = (l + r) >> 1;
if (R <= mid)
return ask(ls[p], l, mid, L, R);
else if (L > mid)
return ask(rs[p], mid + 1, r, L, R);
else
return ask(ls[p], l, mid, L, mid) + ask(rs[p], mid + 1, r, mid + 1, R);
}
inline void ch(int &p, int l, int r) {
if (!p) p = ++inc;
t[p]++;
if (l == r) return;
int mid = (l + r) >> 1;
if (ps <= mid)
ch(ls[p], l, mid);
else
ch(rs[p], mid + 1, r);
}
inline int ask(int ID, int l, int r) { return ask(rt[ID], 1, n, l, r); }
inline void up(int ID, int x) {
ps = x;
ch(rt[ID], 1, n);
}
} // namespace Tree
int main() {
int i, j, L, R, X, x, r, f, s;
long long ans = 0;
n = read();
K = read();
for (i = 1; i <= n; i++) st[i].in();
for (i = 1; i <= n; i++) fx.X[i] = st[i].x;
fx.INIT();
for (i = 1; i <= n; i++) ff.X[i] = st[i].f;
ff.INIT();
Tree::n = fx.len;
Tree::num = s = ff.len;
sort(st + 1, st + n + 1);
for (i = 1; i <= n; i++) {
x = st[i].x;
r = st[i].r;
f = st[i].f;
R = fx.b1(x + r);
L = fx.b2(x - r);
X = ff.b1(f);
for (j = X; j && f - ff.X[j] <= K; j--) ans += Tree::ask(j, L, R);
for (j = X + 1; j <= s && ff.X[j] - f <= K; j++) ans += Tree::ask(j, L, R);
L = fx.b1(x);
Tree::up(X, L);
}
printf("%I64d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> G;
vector<vector<int>> E;
vector<pair<pair<int, int>, float>> xs;
bool error_found = false;
vector<pair<int, float>> dfs(int v, int p, int flow) {
if (p != -1 && G[v].size() == 1) {
vector<pair<int, float>> leafs;
leafs.push_back(make_pair(v, flow * 1.));
return leafs;
}
vector<pair<int, float>> all_leafs;
vector<pair<int, float>> single_leafs;
int forks = 0;
for (int i = 0; i < G[v].size(); i++) {
int v_next = G[v][i];
if (v_next == p) continue;
int edge = E[v][i];
vector<pair<int, float>> leafs = dfs(v_next, v, edge);
if (leafs.size() == 0) {
return all_leafs;
}
if (single_leafs.size() < 2) {
single_leafs.push_back(leafs[leafs.size() - 1]);
leafs.pop_back();
}
all_leafs.insert(all_leafs.end(), leafs.begin(), leafs.end());
}
if (p == -1) {
for (auto l : all_leafs) {
xs.push_back(make_pair(make_pair(v, l.first), l.second));
}
for (auto l : single_leafs) {
xs.push_back(make_pair(make_pair(v, l.first), l.second));
}
return all_leafs;
}
vector<pair<int, float>> new_leafs;
for (int i = 2; i < single_leafs.size(); i++) {
flow -= single_leafs[i].second;
new_leafs.push_back(single_leafs[i]);
}
for (int i = 0; i < all_leafs.size(); i++) {
flow -= all_leafs[i].second;
new_leafs.push_back(all_leafs[i]);
}
if (single_leafs.size() >= 2) {
int f1 = flow, f2 = single_leafs[0].second, f3 = single_leafs[1].second;
xs.push_back(
make_pair(make_pair(single_leafs[0].first, single_leafs[1].first),
(f2 + f3 - f1) / 2));
single_leafs[0].second = (f1 + f2 - f3) / 2.;
single_leafs[1].second = (f1 - f2 + f3) / 2.;
new_leafs.push_back(single_leafs[0]);
new_leafs.push_back(single_leafs[1]);
return new_leafs;
} else {
int f = single_leafs[0].second;
if (f == flow) {
new_leafs.push_back(single_leafs[0]);
return new_leafs;
} else {
error_found = true;
all_leafs.clear();
return all_leafs;
}
}
}
int solve() {
int n;
scanf("%d", &n);
G.clear();
G.resize(n + 1);
E.clear();
E.resize(n + 1);
error_found = false;
xs.clear();
for (int i = 0; i < n - 1; i++) {
int v, u, a;
scanf("%d%d%d", &u, &v, &a);
G[v].push_back(u);
E[v].push_back(a);
G[u].push_back(v);
E[u].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (G[i].size() == 1) {
dfs(i, -1, -1);
break;
}
}
if (error_found) {
printf("NO\n");
return 1;
}
printf("YES\n");
printf("%d\n", xs.size());
for (auto a : xs) {
int u = a.first.first, v = a.first.second, f = int(a.second);
if (f != 0 || 1) {
printf("%d %d %d\n", u, v, f);
}
}
return 0;
}
int main() {
solve();
return 0;
freopen("in.1.txt", "r", stdin);
int n_tests;
scanf("%d", &n_tests);
for (int i = 0; i < n_tests; i++) {
solve();
printf("\n-----\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
bool p[n];
for (int i = 0; i < n; i++) {
cout << m << '\n';
fflush(stdout);
int d;
cin >> d;
if (d == 0) {
return 0;
}
if (d == 1) {
p[i] = false;
} else {
p[i] = true;
}
}
int l = 1, r = m;
int i = 0;
while (l + 1 < r) {
int m = (l + r) / 2;
cout << m << '\n';
fflush(stdout);
int d;
cin >> d;
if (d == 0) {
return 0;
}
if (!p[i]) {
d = -d;
}
if (d == -1) {
r = m;
} else {
l = m;
}
if (i < n - 1) {
i++;
} else {
i = 0;
}
}
cout << l << '\n';
fflush(stdout);
int d;
cin >> d;
if (d == 0) {
return 0;
} else {
cout << r << '\n';
fflush(stdout);
return 0;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool used[30000 + 5][605 + 5];
int memo[30000 + 5][605 + 5];
int v[30000 + 5];
int D;
int dp(int pos, int dx) {
if (pos > 30000) return 0;
if (used[pos][300 + dx]) return memo[pos][300 + dx];
used[pos][300 + dx] = 1;
int &dev = memo[pos][300 + dx] = 0;
int L = D + dx;
if (L - 1 > 0) dev = max(dev, v[pos] + dp(pos + L - 1, dx - 1));
if (L > 0) dev = max(dev, v[pos] + dp(pos + L, dx));
if (L + 1 > 0) dev = max(dev, v[pos] + dp(pos + L + 1, dx + 1));
return dev;
}
int main() {
int n;
while (scanf("%d", &n) == 1) {
scanf("%d", &D);
memset(v, 0, sizeof(v));
for (int i = 0; i < n; ++i) {
int p;
scanf("%d", &p);
v[p]++;
}
memset(used, 0, sizeof(used));
for (int i = 30000; i >= 0; --i) dp(i, 0);
printf("%d\n", dp(D, 0));
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
if (n == 1 && k)
s[0] = '0';
else
for (int i = 0; k && i < n; i++)
if (s[i] > '0' + !i) {
s[i] = '0' + !i;
k--;
}
cout << s << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N;
int x[100010], y;
double a[100010], b[100010];
double dist(double x, double y) { return sqrt(x * x + y * y); }
double calc(int low, int high, int K) {
double d1 = dist(x[N] - x[low], y);
double d2 = dist(x[N] - x[high], y);
if (K >= low && K <= high)
return x[high] - x[low] + min(x[high] - x[K] + d1, x[K] - x[low] + d2);
return x[high] - x[low] + min(d1, d2);
}
int main(void) {
int K2, K, i;
scanf("%d%d", &N, &K2);
K2--;
for ((i) = 0; (i) < (int)(N + 1); (i)++) scanf("%d", &x[i]);
scanf("%d", &y);
int initx = x[K2];
sort(x, x + N);
if (K2 == N) {
K = N;
} else {
for ((i) = 0; (i) < (int)(N); (i)++)
if (x[i] == initx) break;
K = i;
}
for (i = 1; i <= N; i++) a[i] = calc(0, i - 1, K);
for ((i) = 0; (i) < (int)(N); (i)++) b[i] = calc(i, N - 1, K);
double ans = 1.0E+9;
if (K == N) {
ans = a[N];
} else {
for ((i) = 0; (i) < (int)(N + 1); (i)++) ans = min(ans, a[i] + b[i]);
}
printf("%.9f\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
const long long N = 2e5 + 5;
const long long NN = 1e3 + 3;
const long long MOD = (1e9 + 7);
const long long MOD1 = 998244353;
const double PI = 3.14159265;
const int INF32 = 2e9;
const long long INF64 = 2e18;
void KEK() {
long long n, x, a = 0, b = 0, c = 0, ans = 0;
cin >> n >> x;
for (long long i = 0, y; i < n; i++) {
cin >> y;
a = max(0ll, a + y);
b = max(a, b + y * x);
c = max(b, c + y);
ans = max(ans, c);
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
KEK();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int num;
int a[N][N];
int main() {
scanf("%d", &num);
for (int i(1); i <= (100); ++i) {
int s = 0;
for (int j = 1; j < i && s <= num; ++j) {
num -= s;
++s;
a[i][j] = a[j][i] = 1;
}
}
puts("100");
for (int i(1); i <= (100); ++i) {
for (int j(1); j <= (100); ++j) putchar(a[i][j] + 48);
putchar(10);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector<int> ma(m);
vector<vector<int>> a(n, vector<int>(m));
for (int i = (int)(0); i < (int)(n); ++i) {
for (int j = (int)(0); j < (int)(m); ++j) {
cin >> a[i][j];
ma[j] = max(ma[j], a[i][j]);
}
}
vector<int> ord(m);
iota(ord.begin(), ord.end(), 0);
sort(ord.begin(), ord.end(), [&](int p, int q) { return ma[p] > ma[q]; });
if (ord.size() > 12) ord.resize(12);
m = ord.size();
vector<int> dp(1 << n, -inf);
dp[0] = 0;
for (auto idx : ord) {
vector<int> ndp(1 << n, -inf);
vector<int> memo(1 << n, -inf);
for (int i = (int)(0); i < (int)(n); ++i) {
for (int mask = (int)(0); mask < (int)(1 << n); ++mask) {
int res = 0;
for (int j = (int)(0); j < (int)(n); ++j) {
if (mask & (1 << j)) {
res += a[(i + j) % n][idx];
}
}
memo[mask] = max(memo[mask], res);
}
}
for (int mask = (int)(0); mask < (int)(1 << n); ++mask) {
for (int i = mask; i >= 0; i--) {
i &= mask;
ndp[mask] = max(ndp[mask], memo[i] + dp[mask ^ i]);
}
}
dp.swap(ndp);
}
cout << dp[(1 << n) - 1] << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100005], h[100005], b[100005], f[100005], ff1[100005], ff2[100005],
a1[100005];
bool maximize(int &a, int b) {
if (a < b)
a = b;
else
return false;
return true;
}
void LIS(int nn) {
int answer = 0;
memset(f, 0, sizeof f);
memset(b, 0, sizeof b);
for (int i = 1; i <= nn; i++) {
f[i] = upper_bound(b + 1, b + answer + 1, a1[i]) - b;
maximize(answer, f[i]);
b[f[i]] = a1[i];
}
}
int solve(int u, int v) {
if (u > v) return 0;
int sizelen = 0;
for (int i = u; i <= v; i++) a1[++sizelen] = a[i];
LIS(sizelen);
memcpy(ff1, f, sizeof f);
reverse(a1 + 1, a1 + sizelen + 1);
LIS(sizelen);
memcpy(ff2, f, sizeof ff2);
reverse(ff2 + 1, ff2 + sizelen + 1);
int res = 0;
for (int i = 1; i <= sizelen; i++) res = max(res, ff1[i] + ff2[i] - 1);
return res;
}
void nhap() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int u, v;
cin >> u >> v;
a[u]++;
a[v + 1]--;
}
}
int main() {
nhap();
for (int i = 1; i <= m; i++) a[i] += a[i - 1];
a[m + 1] = 0;
int res = 0;
int j = 1;
int dem0 = 0;
int lenmax = 0;
for (int i = 1; i <= m; i++)
if (a[i] == 0) dem0++;
for (int i = 1; i <= m + 1; i++)
if (a[i] == 0) {
res = max(res, solve(j, i - 1));
j = i + 1;
}
cout << dem0 + res;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec[200005];
int A[200005], B[200005];
int to[200005];
int f[200005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--, b--;
vec[a / 2].push_back(b / 2);
vec[b / 2].push_back(a / 2);
A[i] = a, B[i] = b;
}
memset(to, -1, sizeof(to));
for (int i = 0; i < n; i++) {
if (to[i] == -1) {
int now = i;
while (to[now] == -1) {
int f = vec[now][0];
if (to[f] != -1) {
f = vec[now][1];
if (to[f] != -1) f = i;
}
to[now] = f;
now = f;
}
}
}
for (int i = 0; i < n; i++) {
if (to[A[i] / 2] == B[i] / 2) {
if (A[i] / 2 == B[i] / 2 || to[B[i] / 2] != A[i] / 2)
puts("1 2");
else {
int a = min(A[i], B[i]);
bool up = f[a / 2] == 0;
if (a == A[i]) up = !up;
if (up)
puts("1 2");
else
puts("2 1");
f[a / 2]++;
}
} else
puts("2 1");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int i, j, k, l, n, a[52][52], flag[2510] = {0};
while (cin >> n) {
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) cin >> a[i][j];
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
for (k = 0; k < n; k++)
for (l = 0; l < n; l++) {
if (a[i][j] == 1) flag[j + i * n] = 1;
if (a[i][j] == a[i][k] + a[l][j] && k != j && l != i)
flag[j + i * n] = 1;
}
for (i = 0; i < n * n; i++)
if (flag[i] == 0) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x1, y1, x2, y2;
cin >> n >> x1 >> y1 >> x2 >> y2;
int r = 0;
while (x1 != x2 || y1 != y2) {
if (x1 == 0 && y1 != n) {
y1++;
} else if (y1 == 0 && x1 != 0) {
x1--;
} else if (x1 == n && y1 != 0) {
y1--;
} else {
x1++;
}
r++;
}
cout << min(r, 4 * n - r) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool vis[1010][1010];
vector<pair<int, int> > res;
int d[310];
int main() {
memset(vis, 0, sizeof(vis));
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &d[i]);
int L = 1, R = n;
int l = 1, r = d[n] + 1;
while (1) {
if (L == R) {
for (int i = l; i <= r; i++)
for (int j = l; j <= r; j++) vis[i][j] = 1;
break;
} else if (L == R - 1) {
for (int i = l; i < l + d[L]; i++)
for (int j = l; j <= r; j++) vis[i][j] = 1;
break;
}
for (int i = l; i < l + d[L]; i++)
for (int j = l; j <= r; j++) vis[i][j] = 1;
for (int i = L + 1; i < R; i++) d[i] -= d[L];
l += d[L];
r = l + d[R - 1];
L++;
R--;
}
res.clear();
for (int i = 1; i <= d[n] + 1; i++)
for (int j = i + 1; j <= d[n] + 1; j++)
if (vis[i][j] || vis[j][i]) res.push_back(pair<int, int>(i, j));
printf("%d\n", (int)res.size());
for (auto x : res) printf("%d %d\n", x.first, x.second);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy[] = {-1, 0, 1, -1, 1, -1, 0, 1};
void testCase() {
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int boxes[k];
for (int i = 0; i < k; i++) {
boxes[i] = arr[n - 1 - i];
}
int ans = arr[n - 1];
int c = k - 1;
for (int i = n - k - 1; i >= 0; i--) {
boxes[c] += arr[i];
ans = max(ans, boxes[c]);
c--;
if (c == -1) {
break;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t != 0) {
t--;
testCase();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int((a)[(n)]);
for (int i = 0; i < (n); i++) cin >> ((a)[i]);
sort(a, a + n);
reverse(a, a + n);
long long q[n];
long long sm[n + 1];
sm[0] = 0;
for (int(i) = 0; (i) < (n); (i)++) sm[i + 1] = a[i] + sm[i];
for (int(i) = (1); (i) < (n); (i)++) {
long long ans = 0;
int nc = n;
long long v = 0, mf = 1;
while (nc > 0) {
if (mf > nc) mf = nc;
ans += (sm[n - nc + mf] - sm[n - nc]) * v;
nc -= mf;
mf *= i;
v += 1;
}
q[i] = ans;
}
long long tmp, pnk;
cin >> tmp;
for (int(i) = 0; (i) < (tmp); (i)++) {
cin >> pnk;
if (pnk >= n) pnk = n - 1;
if (pnk == 0)
cout << 0 << " ";
else
cout << q[pnk] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long n;
cin >> n;
int num[5] = {1, 5, 10, 20, 100};
long long count[5] = {0};
for (int i = 4; i >= 0; i--) {
count[i] += n / num[i];
n -= count[i] * num[i];
}
cout << accumulate(count, count + 5, 0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[1001];
int main() {
long long l, sum = 0, x = 0, flag = 1;
cin >> s;
l = strlen(s);
for (int i = 0; i < l; ++i) {
if (s[i] < '0' || s[i] > '9') {
sum += x * flag;
x = 0;
if (s[i] == '+') {
flag = 1;
}
if (s[i] == '-') {
flag = -1;
}
x = x * 10 + (s[i] - '0');
}
if (s[i] >= '0' && s[i] <= '9') {
x *= 10;
x += (s[i] - '0');
}
}
sum += x * flag;
printf("%lld\n", sum);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int r, g, b, mx, i;
int main() {
cin >> r >> g >> b;
r += r % 2;
g += g % 2;
b += b % 2;
mx = max(r, max(g, b));
i = mx == b ? 2 : mx == g ? 1 : 0;
cout << 30 + (mx / 2 - 1) * 3 + i;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
vector<pair<long long, long long> > q;
long long n, qc;
long long cnt[10005];
bool can[10005];
signed main() {
ios::sync_with_stdio(false);
cin >> n >> qc;
for (long long i = 1; i <= qc; i++) {
long long l, r, v;
cin >> l >> r >> v;
q.push_back({l, v});
q.push_back({r + 1, -v});
}
sort(q.begin(), q.end());
{
for (long long iz = 0; iz < q.size(); iz++) {
if (q[iz].second > 0) {
long long cac = q[iz].second;
can[cac] = true;
for (long long i = n - cac; i >= 1; i--) {
if (cnt[i] >= 1) {
cnt[i + cac] += cnt[i];
cnt[i + cac] += mod;
cnt[i + cac] %= mod;
can[i + cac] = true;
}
}
cnt[cac]++;
} else {
long long cac = -q[iz].second;
cnt[cac]--;
for (long long i = 1; i <= n - cac; i++) {
if (cnt[i] >= 1) {
cnt[i + cac] -= cnt[i];
cnt[i + cac] += mod;
cnt[i + cac] %= mod;
}
}
}
}
}
long long hv = 0;
queue<long long> ans;
for (long long i = 1; i <= n; i++) {
if (can[i]) {
hv++;
ans.push(i);
}
}
cout << hv << endl;
while (ans.size()) {
cout << ans.front() << " ";
ans.pop();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> v1[n + m + 5], v2[n + m + 5];
int a[n + 1][m + 1], b[n + 1][m + 1];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> b[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
v1[i + j].push_back(a[i][j]);
v2[i + j].push_back(b[i][j]);
}
}
for (int i = 0; i < n + m - 1; i++) {
sort(v1[i].begin(), v1[i].end());
sort(v2[i].begin(), v2[i].end());
}
for (int i = 0; i < n + m - 1; i++) {
int sz = v1[i].size();
for (int j = 0; j < sz; j++) {
if (v1[i][j] != v2[i][j]) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a - (a / b * b));
}
long long mypow(long long a, long long b) {
long long p = 1;
if (b == 0) return 1;
for (long long i = 0; i < b; i++) p *= a;
return p;
}
long long zero(long long a) {
long long za = 0;
long long temp = a;
long long tens = 0;
while (temp > 0) {
if (temp % 10 != 0) {
za += ((temp % 10) * (mypow(10, tens)));
tens++;
}
temp /= 10;
}
return za;
}
int main() {
string st;
while (getline(cin, st)) {
int i = st.length() - 2;
while (st[i] == ' ') i--;
if (st[i] < 97) st[i] += 32;
if (st[i] == 'a' || st[i] == 'e' || st[i] == 'i' || st[i] == 'o' ||
st[i] == 'u' || st[i] == 'y')
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0)->sync_with_stdio(0);
int n;
cin >> n;
vector<vector<int>> adj(n);
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v, --u, --v;
adj[u].push_back(v), adj[v].push_back(u);
}
array<int, 2> cnt{};
function<void(int, int, int)> dfs = [&](int u, int p, int c) {
++cnt[c];
for (auto v : adj[u]) {
if (v != p) {
dfs(v, u, !c);
}
}
};
dfs(0, 0, 0);
cout << min(cnt[0], cnt[1]) - 1 << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using std::max;
long long tree[1001000], n, m, a[400100], ans[400100];
void modify(long long t, long long l, long long r, long long pos,
long long val) {
if (l == r) {
tree[t] = val;
return;
}
long long mid = (l + r) / 2;
if (pos <= mid)
modify(t * 2, l, mid, pos, val);
else
modify(t * 2 + 1, mid + 1, r, pos, val);
tree[t] = max(tree[t * 2], tree[t * 2 + 1]);
}
long long query(long long t, long long l, long long r, long long L,
long long R) {
if (L > r || l > R) return -1e18;
if (L <= l && r <= R) return tree[t];
long long mid = (l + r) / 2;
return max(query(t * 2, l, mid, L, R), query(t * 2 + 1, mid + 1, r, L, R));
}
signed main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i < 2 * n; i++) scanf("%lld", &a[i]), a[i] += a[i - 1];
long long now = 0;
for (long long i = 1; i <= n; i++) {
for (; now < i && a[2 * i - 1] - a[2 * now] > m; now++)
;
if (now > 0) ans[i] = ans[now - 1] + m;
if (now < i)
ans[i] = max(ans[i], a[i * 2 - 1] + query(1, 0, n, now, i - 1));
modify(1, 0, n, i, ans[i] - a[i << 1]);
}
printf("%lld\n", ans[n]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x;
cin >> n;
vector<long long int> v, v1;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
long long int idx = 0;
sort(v.begin(), v.end());
long long int l = 0, r = 0;
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
if (l >= n or r >= n) {
break;
}
if (v[r] <= v[l]) {
r++;
} else {
ans++;
l++;
r++;
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int mod1 = 1000000007;
long long int mod2 = 67280421310721;
long long int mod3 = 998244353;
long long int INF = 1e18;
long long int binpow1(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long int binpow2(long long int a, long long int b, long long int m) {
a %= m;
long long int res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
map<long long int, long long int> fact(long long int n) {
map<long long int, long long int> factorization;
long long int c = 0;
while (n % 2 == 0) {
c++;
n /= 2;
}
if (c > 0) {
factorization.insert({2, c});
}
c = 0;
for (long long int d = 3; d * d <= n; d += 2) {
while (n % d == 0) {
c++;
n /= d;
}
if (c > 0) {
factorization.insert({d, c});
}
c = 0;
}
if (n > 1) {
factorization.insert({n, 1});
}
return factorization;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
set<long long int> s;
long long int f = 0;
long long int sum = 0;
long long int a[n];
for (int i = (1); i < (n + 1); i++) {
s.insert(i);
}
for (int i = (0); i < (n); i++) {
cin >> a[i];
sum = sum + a[i];
}
if (sum != m) {
cout << "NO" << '\n';
} else {
cout << "YES" << '\n';
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b, s, e, r;
scanf("%d %d %d %d", &n, &m, &a, &b);
s = (a - 1) % m;
e = (b - 1) % m;
if (e - s == b - a) {
printf("1\n");
} else {
r = ((b - a + 1) - (m - s) - (e + 1)) / m;
if (s == 0 && e == m - 1 || s == 0 && b == n) {
printf("1\n");
} else if (s == 0 || e == m - 1 || e + 1 == s || r == 0 || b == n) {
printf("2\n");
} else {
printf("3\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 105;
vector<int> g[MX], tsort;
string s[MX];
int n, vis[MX], use[MX];
void dfs(int x) {
vis[x] = use[x] = 1;
for (int i = 0; i < g[x].size(); i++) {
if (use[g[x][i]]) {
puts("Impossible");
exit(0);
} else if (!vis[g[x][i]]) {
dfs(g[x][i]);
}
}
use[x] = 0;
tsort.push_back(x);
}
void func(int id) {
for (int i = 0; i < s[id].size() && i < s[id + 1].size(); i++) {
if (s[id + 1][i] != s[id][i]) {
g[s[id + 1][i] - 'a'].push_back(s[id][i] - 'a');
return;
}
}
if (s[id].size() > s[id + 1].size()) {
puts("Impossible");
exit(0);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i < n; i++) func(i);
for (int i = 0; i < 26; i++)
if (!vis[i]) dfs(i);
for (int i = 0; i < 26; i++) putchar(tsort[i] + 'a');
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:336777216")
using namespace std;
int IT_MAX = 1 << 17;
const long long MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double ERR = 1e-10;
int Co[25][25];
int cnt[25];
long long getans(int s) {
if (cnt[0] < 0) return 0;
long long rv = 1;
int cur = 0;
for (int i = s + 1; i >= 2; i--) {
cur++;
rv *= Co[cur][cnt[i - 1]];
cur -= cnt[i - 1];
if (cur < 0) return 0;
}
return rv;
}
int main() {
for (int i = 0; i <= 22; i++) {
Co[i][0] = Co[i][i] = 1;
for (int j = 1; j < i; j++) Co[i][j] = Co[i - 1][j - 1] + Co[i - 1][j];
}
int T;
scanf("%d", &T);
while (T--) {
long long t;
scanf("%lld", &t);
vector<int> Vl;
for (int i = 2; t; i++) {
Vl.push_back(t % i);
t /= i;
}
long long ans = 0;
long long s = Vl.size();
for (auto it : Vl) cnt[it]++;
ans = getans(s);
if (cnt[0] != 0 && cnt[s] == 0) {
cnt[0]--;
ans -= getans(s - 1);
}
printf("%lld\n", ans - 1);
memset(cnt, 0, sizeof(cnt));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, l, wmax;
cin >> n >> l >> wmax;
vector<int> plus, minus;
for (int i = 0; i < n; i++) {
int x, v;
cin >> x >> v;
if (v == 1)
plus.push_back(x);
else
minus.push_back(x);
}
sort(plus.begin(), plus.end());
sort(minus.begin(), minus.end());
long long cnt = 0;
auto it = minus.begin();
for (int x : plus) {
while (it != minus.end() &&
(*it < x || wmax * (long long)(*it - x + l) <= abs(*it + x + l)))
++it;
cnt += minus.end() - it;
}
cout << cnt << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int te;
cin >> te;
long long int sa = 0, sg = 0;
while (te--) {
int a, g;
cin >> a >> g;
if (abs((sa + a) - sg) > 500) {
cout << "G";
sg = sg + g;
} else {
cout << "A";
sa = sa + a;
}
}
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int s[n];
int zerosin = 0;
int unodest = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
if (s[i] == 1) {
unodest++;
}
}
int somma = zerosin + unodest;
for (int i = 0; i < n; i++) {
if (s[i] == 0) {
zerosin++;
} else {
unodest--;
}
somma = max(somma, zerosin + unodest);
}
cout << somma;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
bool read() {
if (!getline(cin, s)) {
return 0;
}
return 1;
}
int id(char c) {
const string C = "RBYG";
int res = find(begin(C), end(C), c) - C.begin();
assert(res < ((int)(C).size()));
return res;
}
bool was[4];
void solve() {
vector<int> perm(4);
iota(begin(perm), end(perm), 0);
do {
vector<int> cur;
for (int c : perm) {
cur.push_back(c);
}
for (int ___ = 0; ___ < int(((int)(s).size()) - 4); ++___) {
memset(was, 0, sizeof was);
for (int it = 0; it < int(3); ++it) {
was[cur[((int)(cur).size()) - 1 - it]] = 1;
}
for (int c = 0; c < int(4); ++c) {
if (!was[c]) {
cur.push_back(c);
break;
}
}
}
bool ok = 1;
for (int i = 0; i < int(((int)(cur).size())); ++i) {
if (s[i] != '!') {
if (cur[i] != id(s[i])) {
ok = 0;
break;
}
}
}
if (ok) {
vector<int> cnt(4, 0);
for (int i = 0; i < int(((int)(cur).size())); ++i) {
if (s[i] == '!') {
++cnt[cur[i]];
}
}
for (int i = 0; i < int(4); ++i) {
printf("%d ", cnt[i]);
}
puts("");
return;
}
} while (next_permutation(begin(perm), end(perm)));
assert(0);
}
int main() {
while (read()) {
solve();
break;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[100005], sumb[100005], n, A, cf, cm, m,
summ = 0, newmi = 0, newcoun = 0, temp[100005];
vector<long long int> vec;
vector<pair<long long int, long long int> > a;
vector<long long int>::iterator it;
int main() {
cin >> n >> A >> cf >> cm >> m;
for (int i = 0; i < n; i++) {
cin >> arr[i];
a.push_back({arr[i], i});
temp[i] = arr[i];
}
sort(arr, arr + n);
sort(a.begin(), a.end());
vec.push_back(0);
for (int i = 0; i < n - 1; i++) {
summ = summ + (arr[i + 1] - arr[i]) * (long long int)(i + 1);
vec.push_back(summ);
}
sumb[0] = 0;
for (int i = 1; i <= n; i++) sumb[i] = A - arr[n - i] + sumb[i - 1];
long long int coun = 0, ans = 0;
for (int i = 0; i <= n; i++) {
long long int kp = m;
long long int lef = sumb[i];
if (lef <= kp) {
kp = kp - lef;
it = upper_bound(vec.begin(), vec.end(), kp);
if (it == vec.end()) it--;
if (*it > kp) it--;
if (it + 1 != vec.end() && *(it + 1) <= kp) it++;
int pos = it - vec.begin();
if (pos > n - 1 - i) pos = n - 1 - i;
if (pos < 0) break;
long long int mi = arr[pos];
kp = kp - vec[pos];
mi = mi + kp / (pos + 1);
if (mi >= A) {
cout << n * cf + cm * A << endl;
for (int i = 0; i < n; i++) cout << A << " ";
cout << endl;
return 0;
}
if (cf * i + mi * cm >= ans) {
newmi = mi;
newcoun = i;
ans = cf * i + mi * cm;
}
} else
break;
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
if (temp[i] <= newmi) temp[i] = newmi;
}
int lll = n - 1;
while (newcoun--) {
int pos = a[lll].second;
temp[pos] = A;
lll--;
}
for (int i = 0; i < n; i++) cout << temp[i] << " ";
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void setmax(long long &a, const long long &b) {
if (a < b) a = b;
}
struct node {
node *children[2];
bool value;
int depth;
node(const bool &b = false, const int &d = 43) {
children[0] = NULL;
children[1] = NULL;
value = b;
depth = d;
}
} t;
void insert(node *root, long long s) {
int i = root->depth - 1;
while (i >= 0) {
bool mod = (s >> i) & 1ll;
if (!(root->children[mod])) break;
root = root->children[mod];
i--;
}
while (i >= 0) {
bool mod = (s >> i) & 1ll;
root->children[mod] = new node(mod, i);
root = root->children[mod];
i--;
}
}
long long maxval(node *root, long long s) {
long long retval = 0;
for (;;) {
retval += ((long long)root->value) << root->depth;
if (!(root->depth)) return retval;
int newdepth = root->depth - 1;
bool bestind = !((s >> newdepth) & 1);
if (root->children[bestind])
root = root->children[bestind];
else if (root->children[!bestind])
root = root->children[!bestind];
}
}
int N;
long long arr[100003];
long long partxor[100003], suffixor;
long long ans;
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%I64d", &arr[i]);
partxor[i] = partxor[i - 1] ^ arr[i];
}
insert(&t, 0LL);
for (int i = N; i; i--) {
suffixor ^= arr[i];
insert(&t, suffixor);
long long x = maxval(&t, partxor[i - 1]);
setmax(ans, x ^ partxor[i - 1]);
}
setmax(ans, partxor[N]);
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[1005];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int cnt = 0;
for (int i = 1; i < n - 1; i++) {
if (a[i] < a[i - 1] && a[i] < a[i + 1]) cnt++;
if (a[i] > a[i - 1] && a[i] > a[i + 1]) cnt++;
}
cout << cnt;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
stringstream output;
inline void eOP();
inline void solve() {
int n;
cin >> n;
string a, b;
cin >> a >> b;
vector<vector<bool>> m(20, vector<bool>(20));
for (int i = 0; i < n; ++i) {
int f = a[i] - 'a';
int t = b[i] - 'a';
if (f > t) {
cout << "-1\n";
return;
}
if (t > f) {
m[f][t] = true;
}
}
int result = 0;
for (int i = 0; i < 20; ++i) {
int j;
for (j = i + 1; j < 20; ++j) {
if (m[i][j]) {
break;
}
}
if (j == 20) {
continue;
}
++result;
for (int k = j + 1; k < 20; ++k) {
m[j][k] = m[j][k] || m[i][k];
}
}
cout << result << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
size_t t = 1;
cin >> t;
for (int i = 0; i < t; ++i) {
solve();
}
eOP();
}
inline void eOP() {
cout << output.str();
output.str(string());
exit(0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, mod = 1e9 + 7;
struct atom {
double x, y;
atom(double _x = 0, double _y = 0) { x = _x, y = _y; }
atom operator+(const atom &ch) { return atom(x + ch.x, y + ch.y); }
atom operator-(const atom &ch) { return atom(x - ch.x, y - ch.y); }
atom operator*(const atom &ch) {
return atom(x * ch.x - y * ch.y, x * ch.y + y * ch.x);
}
} A[N], B[N], C[N], D[N], w, w0, tmp, wi[16][65536];
;
long long n;
int M, l, k, b, r[N], f[N], g[N], fac[N], inv[N], ans;
void FFT(atom *A, int f) {
for (int i = 0; i < M; i++)
if (r[i] > i) swap(A[r[i]], A[i]);
int gg = 0;
for (int i = 1; i < M; i <<= 1) {
w.x = cos(acos(-1.0) / i), w.y = sin(acos(-1.0) / i) * f;
for (int j = 0; j < M; j += (i << 1)) {
for (int k = 0; k < i; k++) {
w0 = wi[gg][k], w0.y *= f;
atom x = A[j + k], y = w0 * A[i + j + k];
A[j + k] = x + y, A[i + j + k] = x - y;
}
}
gg++;
}
if (f == -1)
for (int i = 0; i < M; i++) A[i].x /= M;
}
void init() {
fac[0] = fac[1] = inv[0] = inv[1] = 1;
for (int i = 2; i < N; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
for (int i = 2; i < N; i++)
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
for (int i = 2; i < N; i++) inv[i] = 1ll * inv[i] * inv[i - 1] % mod;
for (int i = 2, k = 0; i <= N; i <<= 1, k++)
for (int j = 0; j < i; j++)
wi[k][j] =
atom(cos(j * acos(-1.0) / (i / 2)), sin(j * acos(-1.0) / (i / 2)));
}
void doit(int *a, int *b, int n) {
memset(A, 0, sizeof(A));
memset(B, 0, sizeof(B));
memset(C, 0, sizeof(C));
memset(D, 0, sizeof(D));
for (int i = 0; i < M; i++) {
A[i].x = a[i] >> 15;
B[i].x = a[i] & 32767;
C[i].x = b[i] >> 15;
D[i].x = b[i] & 32767;
}
FFT(A, 1), FFT(B, 1), FFT(C, 1), FFT(D, 1);
for (int i = 0; i < M; i++) {
tmp = A[i] * D[i] + B[i] * C[i];
A[i] = A[i] * C[i];
C[i] = B[i] * D[i];
B[i] = tmp;
}
FFT(A, -1), FFT(B, -1), FFT(C, -1), memset(a, 0, sizeof(a));
for (int i = 0; i <= n; i++)
a[i] = ((llround(A[i].x) % mod << 30) + (llround(B[i].x) % mod << 15) +
llround(C[i].x) % mod) %
mod;
}
int c[N];
void work(int *a, int *b, int n, int p) {
int t = 1;
memset(c, 0, sizeof(c));
for (int i = 0; i <= n; i++)
c[i] = 1ll * a[i] * t % mod, t = 1ll * t * p % mod;
doit(c, b, n);
memcpy(a, c, sizeof c);
}
int Calc(int n, int m) {
return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
}
int main() {
cin >> n >> k;
if (n > k) {
puts("0");
return 0;
}
for (M = 1; M <= k + k; M <<= 1, l++)
;
for (int i = 0; i < M; i++) r[i] = (r[i >> 1] >> 1) | ((i & 1) << (l - 1));
init(), g[0] = 1, b = 2;
for (int i = 1; i <= k; i++) f[i] = inv[i];
for (; n; n >>= 1, work(f, f, k, b), b = 1ll * b * b % mod)
if (n & 1) work(g, f, k, b);
for (int i = n; i <= k; i++)
(ans += 1ll * g[i] * fac[i] % mod * Calc(k, i) % mod) %= mod;
printf("%d\n", ans);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long mpow(long long c, long long n) {
long long rt = 1;
for (long long ii = 0; ii < n; ii++) {
rt *= c;
}
return rt;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long h, n;
cin >> h >> n;
long long ans = mpow(2, h + 1) - 1;
long long dir = 1;
while (h--) {
long long tdir;
if (mpow(2, h) >= n) {
tdir = -1;
} else {
tdir = 1;
n -= mpow(2, h);
}
if (tdir * dir == -1) ans -= mpow(2, h + 1) - 1;
dir = tdir;
}
cout << ans - 1 << endl;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const int inf = INT_MAX;
const int nmax = 1e5 + 5;
const int mod = 1e9 + 7;
using namespace std;
int k, nr, ans[101][101], i, j, ed;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> k;
for (i = 3; i * (i - 1) * (i - 2) / 6 <= k; i++) nr = i;
for (i = 1; i <= nr; i++)
for (j = i + 1; j <= nr; j++) ans[i][j] = ans[j][i] = 1;
k -= nr * (nr - 1) * (nr - 2) / 6;
while (k) {
ed = 0;
while (ed * (ed - 1) / 2 <= k) ed++;
ed--, nr++;
for (i = 1; i <= ed; i++) ans[i][nr] = ans[nr][i] = 1;
k -= ed * (ed - 1) / 2;
}
cout << nr << endl;
for (i = 1; i <= nr; i++) {
for (j = 1; j <= nr; j++) cout << ans[i][j];
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> mp;
int main() {
int n, k;
cin >> n >> k;
int l = 1, r = 2;
int fl = 0;
for (int i = 0; i < k; i++) {
l = 1;
r = i + 2;
for (int j = 0; j < n; j++) {
pair<int, int> p = make_pair(l, r);
if (mp[p]) {
fl = 1;
break;
} else {
mp[p] = 1;
}
r++;
r %= (n + 1);
if (r == 0) r = 1;
l++;
l %= (n + 1);
if (l == 0) l = 1;
}
}
if (fl == 1 || (mp.size() > (n * (n - 1) / 2)))
cout << "-1" << endl;
else {
cout << mp.size() << endl;
for (map<pair<int, int>, int>::iterator iter = mp.begin(); iter != mp.end();
iter++) {
pair<int, int> p = iter->first;
printf("%d %d\n", p.first, p.second);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int res = 0, w = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') c = getchar(), w = -1;
while (isdigit(c)) res = (res << 1) + (res << 3) + c - '0', c = getchar();
return res * w;
}
int a1, b1, a2, b2, a3, b3, a4, b4, a5, b5, a6, b6;
bool cover(int a1, int b1, int a2, int b2, int a3, int b3, int a4, int b4) {
return a3 <= a1 && b3 <= b1 && a4 >= a2 && b4 >= b2;
}
bool cross(int a, int b, int c, int d) {
if (b < c || d < a) return 0;
return 1;
}
int main() {
cin >> a1 >> b1 >> a2 >> b2 >> a3 >> b3 >> a4 >> b4 >> a5 >> b5 >> a6 >> b6;
if (cover(a1, b1, a2, b2, a3, b3, a4, b4)) {
puts("No");
return 0;
};
if (cover(a1, b1, a2, b2, a5, b5, a6, b6)) {
puts("No");
return 0;
};
if (a1 >= a3 && a2 <= a4 && a1 >= a5 && a2 <= a6) {
if (cross(b3, b4, b5, b6) &&
cover(a1, b1, a2, b2, a1, min(b3, b5), a2, max(b4, b6))) {
puts("No");
return 0;
};
}
if (b1 >= b3 && b2 <= b4 && b1 >= b5 && b2 <= b6) {
if (cross(a3, a4, a5, a6) &&
cover(a1, b1, a2, b2, min(a3, a5), b1, max(a4, a6), b2)) {
puts("No");
return 0;
};
}
{
puts("Yes");
return 0;
};
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const int MOD = 1000000007;
const long long INFLL = 1e18;
const int INF = 1e9;
const int NMAX = 2e5 + 5;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int n;
array<int, 2> a[NMAX];
struct BIT {
long long aib[NMAX];
void update(int pos, int val) {
for (int i = pos + 1; i <= n; i += (i & (-i))) {
aib[i] += val;
}
}
long long query(int pos) {
long long sum = 0;
for (int i = pos; i >= 1; i -= (i & (-i))) {
sum += aib[i];
}
return sum;
}
} f0, f1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i][0];
}
vector<int> v;
for (int i = 0; i < n; ++i) {
cin >> a[i][1];
v.push_back(a[i][1]);
}
long long ans = 0;
sort(v.begin(), v.end());
sort(a, a + n);
for (int i = 0; i < n; ++i) {
int pos = lower_bound(v.begin(), v.end(), a[i][1]) - v.begin();
ans += f0.query(pos + 1) * a[i][0] - f1.query(pos + 1);
f0.update(pos, 1);
f1.update(pos, a[i][0]);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, n;
cin >> n;
for (i = 1;; ++i) {
if ((i * (i + 1)) / 2 >= n) break;
}
cout << n - (i * (i - 1)) / 2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int isprime(int n) {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return 0;
}
return 1;
}
long long ispalindrome(string s, long long n) {
long long l = 0, h = n - 1;
while (l < h) {
if (s[l++] != s[h--]) return 0;
}
return 1;
}
int issorted(long long a[], long long n) {
for (int i = 0; i < n - 1; i++) {
if (a[i] > a[i + 1]) return 0;
}
return 1;
}
int main() {
long long n, a, c = 0, s = 0;
cin >> n;
vector<long long> v;
for (int i = 0; i < n; i++) {
cin >> a;
s += (a - 1);
if (s & 1)
cout << 1 << endl;
else
cout << 2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long INFLL = 1e12;
const int MOD = 1000000007;
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
int main() {
fast_io();
int t;
cin >> t;
while (t--) {
string s1, s2;
cin >> s1 >> s2;
vector<int> kek(26, 0);
for (char c : s1) kek[c - 'a']++;
bool ok = true;
for (char c : s2) {
if (kek[c - 'a'] != 0) {
cout << "YES"
<< "\n";
ok = false;
break;
}
}
if (ok)
cout << "NO"
<< "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string st;
long long h1, h2, h3, n1, n2, n3, p1, p2, p3, l, r, m, money;
long long gett(long long x) {
long long res, need;
res = 0;
need = n1 * x;
if (h1 >= need)
res += 0;
else
res += (need - h1) * p1;
need = n2 * x;
if (h2 >= need)
res += 0;
else
res += (need - h2) * p2;
need = n3 * x;
if (h3 >= need)
res += 0;
else
res += (need - h3) * p3;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> st;
for (int i = 0; i < st.size(); i++) {
if (st[i] == 'B')
n1++;
else if (st[i] == 'S')
n2++;
else if (st[i] == 'C')
n3++;
}
cin >> h1 >> h2 >> h3;
cin >> p1 >> p2 >> p3;
cin >> money;
l = 0;
r = 1e14;
while (l < r) {
m = l + r + 1;
m /= 2;
if (gett(m) > money) {
r = m - 1;
} else
l = m;
}
cout << l << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, z, u, r, l, s, h, k, y, x, t, a[1091001], b[1234567],
e[1234567];
long long i, j;
long long c[1234567], d[986667];
map<long long, vector<long long>> f;
string p[978685], q, w;
int main() {
cin >> n >> k;
cin >> x >> y;
for (i = 0; i < n; i++) {
cin >> a[i] >> b[i];
c[i] = a[i] * x + b[i] * y;
f[c[i]].push_back(i + 1);
m += c[i];
}
sort(c, c + n);
if (m <= k) {
cout << n << endl;
for (i = 0; i < n; i++) {
cout << i + 1 << ' ';
}
return 0;
}
i = 0;
while (s <= k) {
l++;
s += c[i];
i++;
}
i = 0;
cout << l - 1 << endl;
while (r <= k) {
r += c[i];
if (r <= k) {
cout << f[c[i]][0] << ' ';
}
f[c[i]].erase(f[c[i]].begin());
i++;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b > a) {
long long int temp = a;
a = b;
b = temp;
}
if (a % b) {
return gcd(b, a % b);
} else
return b;
}
void solve() {
long long int n, x, y, a, b, pb, pa;
cin >> x >> y >> n;
float optim = 100000000;
for (b = 1; b <= n; b++) {
float rem = (float((x * b) % y)) / b;
if (optim > rem) {
pb = b;
pa = (x * b) / y;
optim = rem;
}
rem = (y - (float((x * b) % y))) / b;
if (optim > rem) {
pb = b;
pa = ((x * b) / y) + 1;
optim = rem;
}
}
long long int g = 1;
if (pa != 0) g = gcd(pa, pb);
cout << (pa / g) << "/" << (pb / g) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long delbit(long long a, long long k) { return a & (~(1 << k)); }
int delbit(int a, int k) { return a & (~(1 << k)); }
bool getbit(long long a, long long k) { return 1 & (a >> k); }
bool getbit(int a, int k) { return 1 & (a >> k); }
long long setbit(long long a, long long k) { return a |= (1 << k); }
int setbit(int a, int k) { return a |= (1 << k); }
inline long long mulmod(long long first, long long n, long long _mod) {
long long res = 0;
while (n) {
if (n & 1) res = (res + first) % _mod;
first = (first + first) % _mod;
n >>= 1;
}
return res;
}
inline long long powmod(long long first, long long n, long long _mod) {
long long res = 1;
while (n) {
if (n & 1) res = (res * first) % _mod;
first = (first * first) % _mod;
n >>= 1;
}
return res;
}
inline long long gcd(long long a, long long b) {
long long t;
while (b) {
a = a % b;
t = a;
a = b;
b = t;
}
return a;
}
inline int gcd(int a, int b) {
int t;
while (b) {
a = a % b;
t = a;
a = b;
b = t;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long gcd(long long a, long long b, long long c) {
return gcd(gcd(a, b), c);
}
inline int gcd(int a, int b, int c) { return gcd(gcd(a, b), c); }
double dist(double ax, double ay, double bx, double by) {
return sqrt(((ax - bx) * (ax - bx)) + ((ay - by) * (ay - by)));
}
template <typename T, typename T2>
void printarr(T a[], T2 sz, T2 beg = 0) {
for (T2 i = beg; i < sz; i++) cout << a[i] << " ";
cout << endl;
}
long long dp[1 << 21];
struct S {
int t;
long long first;
long long k;
} f[111];
bool comp(S a, S b) { return a.k < b.k; }
const long long inf = 1e11 + 10002;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
long long b;
cin >> n >> m >> b;
for (register int(i) = (0); (i) < (n); (i)++) {
cin >> f[i].first >> f[i].k;
int l;
cin >> l;
while (l--) {
int a;
cin >> a;
f[i].t |= (1 << (a - 1));
}
}
for (register int(j) = (0); (j) < (1 << m); (j)++) {
dp[j] = 1000111000111000111LL;
}
dp[0] = 0;
sort(f, f + n, comp);
long long ans = 1000111000111000111LL;
for (register int(i) = (0); (i) < (n); (i)++) {
for (register int(j) = (0); (j) < (1 << m); (j)++) {
dp[j | f[i].t] = min(dp[j | f[i].t], dp[j] + f[i].first);
}
ans = min(ans, dp[(1 << m) - 1] + f[i].k * b);
}
if (ans != 1000111000111000111LL)
cout << ans << endl;
else
cout << "-1\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
inline long long int rl() {
long long int res = 0, neg = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') neg = 1, c = getchar();
while (c >= '0' && c <= '9') {
res = (res << 1) + (res << 3) + c - 48;
c = getchar();
}
return neg ? -res : res;
}
inline void read(string &s) {
s = "";
char c = getchar();
while (c != '\n') {
s += c;
c = getchar();
}
}
int main() {
vector<std::vector<char> > a(9);
for (int i = 0; i < 9; ++i) {
for (int j = 0; j < 9; ++j) {
char c;
cin >> c;
a[i].push_back(c);
}
}
long long int x = rl() - 1, y = rl() - 1;
int i;
for (i = 3 * (x % 3); i < 3 * (x % 3 + 1); ++i)
for (int j = 3 * (y % 3); j < 3 * (y % 3 + 1); ++j) {
if (a[i][j] == '.') goto exit;
}
exit:;
if (i == 3 * (x % 3 + 1)) {
for (int i = 0; i < 9; ++i) {
for (int j = 0; j < 9; ++j) {
if (a[i][j] == '.')
cout << '!';
else
cout << a[i][j];
if (j % 3 == 2 && j != 8) cout << ' ';
}
cout << '\n';
if (i % 3 == 2 && i != 8) cout << '\n';
}
} else {
for (i = 3 * (x % 3); i < 3 * (x % 3 + 1); ++i)
for (int j = 3 * (y % 3); j < 3 * (y % 3 + 1); ++j) {
if (a[i][j] == '.') a[i][j] = '!';
}
for (int i = 0; i < 9; ++i) {
for (int j = 0; j < 9; ++j) {
cout << a[i][j];
if (j % 3 == 2 && j != 8) cout << ' ';
}
cout << '\n';
if (i % 3 == 2 && i != 8) cout << '\n';
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
string s;
cin >> s;
long long a = 0;
long long b = 0;
for (long long i = 0; i < n; ++i) {
if (s[i] == s[0])
++a;
else
break;
}
for (long long i = n - 1; i >= 0; --i) {
if (s[i] == s[n - 1])
++b;
else
break;
}
long long x2 = n - 1;
if (a == n) {
cout << (n * (n - 1) / 2 + n) % 998244353;
return 0;
}
if (s[0] == s[n - 1]) {
cout << (a + 1) * (b + 1) % 998244353;
} else {
cout << (a + b + 1) % 998244353 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
char buf[1000];
string nextLine(int length = 100) {
cin.getline(buf, length);
string s(buf);
return s;
}
string next(int length = 100) {
string tmp;
cin >> tmp;
return tmp;
}
int nextInt() {
int tmp;
scanf("%d", &tmp);
return tmp;
}
const int MAXN = 100100;
int ar[MAXN];
int ans[MAXN];
int main() {
int n = nextInt();
for (int i = 0, _i = (n); i < _i; ++i) ar[i] = nextInt();
for (int i = 0, _i = (n); i < _i; ++i) {
ans[ar[i] - 1] = nextInt();
}
string sep;
for (int i = 0, _i = (n); i < _i; ++i) {
cout << sep << ans[i];
sep = " ";
}
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100003;
int a[maxn], b[maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(a, a + n);
int c = 0;
for (int i = 0; i < n; i++) c += (a[i] != b[i]);
cout << (c <= 2 ? "YES" : "NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, y, maxi = 0;
long long arr[1000], arr1[1000];
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) cin >> arr1[i];
for (int i = 0; i < n; i++) {
x = arr[i];
y = arr1[i];
for (int j = i + 1; j < n; j++) {
x = (x | arr[j]);
y = (y | arr1[j]);
maxi = max(maxi, (x + y));
}
maxi = max(maxi, (x + y));
}
cout << maxi << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N;
string S;
int f(char a) {
if (a == 'A') return 0;
if (a == 'T') return 1;
if (a == 'G') return 2;
if (a == 'C') return 3;
}
struct node {
int cnt[4];
};
node mrg(node a, node b) {
node ret;
for (int i = 0; i < 4; i++) {
ret.cnt[i] = a.cnt[i] + b.cnt[i];
}
return ret;
}
struct BIT {
int a, rem;
int T;
vector<node> tree;
void init(int a_, int rem_, int T_) {
a = a_;
rem = rem_;
T = T_;
tree = vector<node>(4 * T);
build(0, T - 1, 1);
}
void build(int l, int r, int n) {
if (l > r) return;
if (l == r) {
for (int i = 0; i < 4; i++) tree[n].cnt[i] = 0;
if (N <= a * l + rem) return;
tree[n].cnt[f(S[a * l + rem])]++;
return;
}
int m = (l + r) >> 1;
build(l, m, 2 * n);
build(m + 1, r, 2 * n + 1);
tree[n] = mrg(tree[2 * n], tree[2 * n + 1]);
}
void upd(int idx, node val, int l, int r, int n) {
if (idx < l || r < idx) return;
if (l == r) {
tree[n] = val;
return;
}
int m = (l + r) >> 1;
upd(idx, val, l, m, 2 * n);
upd(idx, val, m + 1, r, 2 * n + 1);
tree[n] = mrg(tree[2 * n], tree[2 * n + 1]);
}
node quer(int a, int b, int l, int r, int n) {
if (b < l || r < a) {
node tmp;
for (int i = 0; i < 4; i++) tmp.cnt[i] = 0;
return tmp;
}
if (a <= l && r <= b) return tree[n];
int m = (l + r) >> 1;
node L = quer(a, b, l, m, 2 * n);
node R = quer(a, b, m + 1, r, 2 * n + 1);
return mrg(L, R);
}
void upd(int idx, node val) { upd(idx, val, 0, T - 1, 1); }
node quer(int a, int b) { return quer(a, b, 0, T - 1, 1); }
};
vector<vector<BIT> > E;
int main() {
cin >> S;
N = S.size();
E.resize(11);
for (int i = 1; i <= 10; i++) {
E[i].resize(i);
for (int j = 0; j < i; j++) {
E[i][j].init(i, j, max(0, (N - j)) / i + 1);
}
}
int Q;
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int x;
scanf("%d", &x);
char c;
scanf(" %c", &c);
x--;
for (int a = 1; a <= 10; a++) {
int r = x % a;
node tmp;
for (int j = 0; j < 4; j++) tmp.cnt[j] = 0;
tmp.cnt[f(c)]++;
E[a][r].upd((x - r) / a, tmp);
}
}
if (t == 2) {
int l, r;
scanf("%d %d", &l, &r);
string t;
cin >> t;
l--;
r--;
int len = t.size();
int ans = 0;
for (int j = 0; j < len; j++) {
if (r < l + j) break;
int rem = (l + j) % len;
int q1 = (l + j - rem) / len;
int q2 = (r - rem) / len;
ans += E[len][rem].quer(q1, q2).cnt[f(t[j])];
}
printf("%d\n", ans);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5050;
char s[N];
int n, vis[N], V, sg[N];
int a[N], m, l[N], r[N], sv[N], svt;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
if (n == 1) {
printf("Second\n");
return 0;
}
sg[1] = 1;
for (int i = 2; i <= n; ++i) {
++V;
vis[sg[i - 2]] = V;
for (int j = 2; j <= i - 1; ++j)
vis[min(sg[j - 2] ^ sg[i - (j + 1)], n + 1)] = V;
int x = 0;
while (vis[x] == V) ++x;
sg[i] = x;
}
for (int i = 1; i <= n; ++i) {
a[i] = (s[i - 1] == s[i + 1]);
}
for (int i = 1; i <= n; ++i) {
if (a[i] && !a[i - 1]) l[++m] = i;
if (a[i] && !a[i + 1]) r[m] = i;
}
int tot = 0;
for (int i = 1; i <= m; ++i) {
tot ^= sg[r[i] - l[i] + 1];
}
for (int i = 1; i <= m; ++i) {
int cur = tot ^ sg[r[i] - l[i] + 1], tz;
if (l[i] == r[i]) {
if (!cur) sv[++svt] = l[i];
} else {
for (int j = l[i]; j <= r[i]; ++j) {
if (j == l[i] || j == r[i])
tz = sg[r[i] - l[i] - 1];
else
tz = sg[(j - 1) - l[i]] ^ sg[r[i] - (j + 1)];
if ((cur ^ tz) == 0) sv[++svt] = j;
}
}
}
if (svt) {
printf("First\n%d\n", sv[1]);
} else {
printf("Second\n");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void Read(T& x) {
x = 0;
bool flag = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') {
flag = 1;
ch = getchar();
break;
}
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - 48;
ch = getchar();
}
if (flag) x = -x;
}
const int MAXN = 1000010;
struct node {
int to, next;
} E[MAXN];
int line[MAXN] = {0}, tot = 0;
inline void Insert(int x, int y) {
tot++;
E[tot].to = y;
E[tot].next = line[x];
line[x] = tot;
}
int q = 0, n = 0, cnt = 0;
int pos[MAXN] = {0};
int S[MAXN] = {0}, T[MAXN] = {0}, v[MAXN << 1] = {0};
bool used[MAXN] = {0};
struct TRIE {
int next[MAXN][26], fail[MAXN];
int L, root;
int newnode() {
for (int i = 0; i < 26; ++i) next[L][i] = -1;
L++;
return L - 1;
}
void init() {
L = 0;
root = newnode();
}
int insert(char* buf) {
int len = strlen(buf), now = root;
for (int i = 0; i < len; ++i) {
if (next[now][buf[i] - 'a'] == -1) next[now][buf[i] - 'a'] = newnode();
now = next[now][buf[i] - 'a'];
}
return now;
}
void build() {
queue<int> Q;
fail[root] = root;
for (int i = 0; i < 26; ++i) {
if (next[root][i] == -1)
next[root][i] = root;
else {
fail[next[root][i]] = root;
Q.push(next[root][i]);
}
}
while (!Q.empty()) {
int now = Q.front();
Q.pop();
for (int i = 0; i < 26; ++i) {
if (next[now][i] == -1)
next[now][i] = next[fail[now]][i];
else {
fail[next[now][i]] = next[fail[now]][i];
Q.push(next[now][i]);
}
}
}
}
} AC;
inline void dfs(int x) {
S[x] = ++tot;
for (int i = line[x]; i > 0; i = E[i].next) dfs(E[i].to);
T[x] = ++tot;
}
inline void change(int x, int w) {
while (x <= 2 * (cnt + 1)) {
v[x] += w;
x += x & -x;
}
}
inline int query(int x) {
int res = 0;
while (x > 0) {
res += v[x];
x -= x & -x;
}
return res;
}
char buf[MAXN];
int main() {
Read(q);
Read(n);
AC.init();
for (int i = 1; i <= n; ++i) {
scanf("%s", buf);
pos[i] = AC.insert(buf);
used[i] = true;
}
AC.build();
cnt = AC.L - 1;
int x = 0, y = 0;
for (int i = cnt; i >= 1; --i) {
int x = AC.fail[i], y = i;
Insert(x, y);
}
tot = 0;
dfs(0);
for (int i = 1; i <= n; ++i) {
change(S[pos[i]], 1);
change(T[pos[i]], -1);
}
int k = 0;
for (int i = 1; i <= q; ++i) {
char ch = getchar();
while (ch != '?' && ch != '-' && ch != '+') ch = getchar();
if (ch == '+') {
Read(x);
if (!used[x]) {
used[x] = true;
change(S[pos[x]], 1);
change(T[pos[x]], -1);
}
} else {
if (ch == '-') {
Read(x);
if (used[x]) {
used[x] = false;
change(S[pos[x]], -1);
change(T[pos[x]], 1);
}
} else {
if (ch == '?') {
scanf("%s", buf + 1);
x = strlen(buf + 1);
k = AC.root;
long long ans = 0;
for (int i = 1; i <= x; ++i) {
k = AC.next[k][buf[i] - 'a'];
ans += query(S[k]);
}
printf("%I64d\n", ans);
}
}
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, nxt, id;
long long w;
} a[300000 * 2 + 5];
int ecnt, pre[300000 + 5], res[300000 + 5];
int n, m, S;
long long dist[1 + 1][300000 + 5], val[300000 + 5];
void add(int u, int v, long long w, int id) {
a[++ecnt].to = v;
a[ecnt].nxt = pre[u];
a[ecnt].id = id;
a[ecnt].w = w;
pre[u] = ecnt;
}
void Dij(int s, int kdf) {
for (int i = 1; i <= n; i++)
dist[kdf][i] = 1000000000000000000, val[i] = 1000000000000000000;
dist[kdf][s] = 0;
val[s] = 0;
priority_queue<pair<long long, int> > Q;
Q.push(make_pair(0, s));
while (!Q.empty()) {
int x = Q.top().second;
long long di = -Q.top().first;
Q.pop();
if (di != dist[kdf][x]) continue;
for (int i = pre[x]; i != -1; i = a[i].nxt) {
int xnt = a[i].to;
if (dist[kdf][x] + a[i].w < dist[kdf][xnt]) {
dist[kdf][xnt] = dist[kdf][x] + a[i].w;
Q.push(make_pair(-dist[kdf][xnt], xnt));
val[xnt] = a[i].w;
res[xnt] = a[i].id;
} else if (dist[kdf][x] + a[i].w == dist[kdf][xnt] && a[i].w < val[xnt]) {
val[xnt] = a[i].w;
res[xnt] = a[i].id;
}
}
}
}
int main() {
memset(pre, -1, sizeof(pre));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
add(u, v, w, i);
add(v, u, w, i);
}
scanf("%d", &S);
Dij(S, 0);
long long ans = 0;
for (int i = 1; i <= n; i++) ans += val[i];
printf("%lld\n", ans);
for (int i = 1; i <= n; i++)
if (i != S) printf("%d ", res[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000;
map<pair<string, int>, int> mmap;
map<string, pair<int, int> > ans;
vector<pair<string, int> > v[maxn];
pair<string, int> name[maxn];
vector<int> g[maxn];
int d[maxn];
vector<pair<string, int> > res;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
string s;
int k;
cin >> s >> k;
mmap[{s, k}] = i;
name[i] = {s, k};
int m;
cin >> m;
for (int j = 0; j < m; ++j) {
string t;
int x;
cin >> t >> x;
v[i].push_back({t, x});
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < (int)v[i].size(); ++j) {
g[i].push_back(mmap[v[i][j]]);
}
}
vector<int> q1, q2;
for (int i = 0; i < n; ++i) d[i] = -1;
d[0] = 0;
q1.push_back(0);
while (q1.size() > 0) {
for (int i = 0; i < (int)q1.size(); ++i) {
if (ans.find(name[q1[i]].first) == ans.end()) {
ans[name[q1[i]].first] = {-d[q1[i]], name[q1[i]].second};
} else {
ans[name[q1[i]].first] =
max(ans[name[q1[i]].first], {-d[q1[i]], name[q1[i]].second});
}
}
vector<int> q;
for (int i = 0; i < (int)q1.size(); ++i) {
if (ans[name[q1[i]].first] > make_pair(-d[q1[i]], name[q1[i]].second)) {
d[q1[i]] = -1;
} else {
q.push_back(q1[i]);
}
}
for (int i = 0; i < (int)q.size(); ++i) {
int v = q[i];
for (int j = 0; j < (int)g[v].size(); ++j) {
int x = g[v][j];
if (d[x] == -1) {
d[x] = d[v] + 1;
q2.push_back(x);
}
}
}
q1.resize(q2.size());
for (int i = 0; i < (int)q1.size(); ++i) {
q1[i] = q2[i];
}
q2.clear();
}
for (int i = 0; i < n; ++i) {
if (d[i] > 0) {
res.push_back(name[i]);
}
}
sort(res.begin(), res.end());
cout << res.size() << endl;
for (int i = 0; i < (int)res.size(); ++i) {
cout << res[i].first << ' ' << res[i].second << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const long long LL_INF = 1ll * INF * INF;
const int MAX_N = 1000 + 7;
const int mod = INF;
template <typename T>
inline void addmod(T& a, const long long& b, const int& MOD = mod) {
a = (a + b) % MOD;
if (a < 0) a += MOD;
}
int n;
int a[MAX_N][MAX_N];
int res;
int p[MAX_N];
bool check[MAX_N];
vector<vector<int>> get_permutation() {
vector<vector<int>> res;
for (int i = 0; i < n; ++i)
if (!check[i]) {
vector<int> cur;
int j = i;
while (!check[j]) {
check[j] = true;
cur.push_back(j);
j = p[j];
}
res.push_back(cur);
}
return res;
}
void direct(int& row, int u, int v, int k = -1) {
if (u < v) {
a[row][u] = a[row][v] = 1;
} else {
a[row][v] = a[row][u] = 2;
}
if (k != -1) {
a[row][u] = a[row][v] = a[row][k] = 2;
}
++row;
}
void calc(vector<vector<int>>& perm) {
vector<int> f = perm[0];
{
cerr << "f"
<< " ";
for (int i = (0), _b = ((int)(f).size()); i < _b; ++i) cerr << f[i] << " ";
cerr << '\n';
};
int row = 0;
if (f.size() == 1) {
a[row++][0] = 1;
} else {
int t = 1;
a[row++][f[t]] = 1;
int m = (int)(f).size();
for (int i = (t + 1) % m; i != t; i = (i + 1) % m) {
direct(row, f[i], f[(i - 1 + (int)(f).size()) % (int)(f).size()]);
}
}
for (int j = 1; j < perm.size(); ++j) {
auto& f = perm[j];
if (f.size() == 1) {
++row;
continue;
}
int t = 0;
int m = (int)(f).size();
while (f[t] > f[(t + 1) % m]) t = (t + 1) % m;
direct(row, f[(t + 1) % m], f[t], 0);
cerr << "t"
<< ": " << (t) << '\n';
;
for (int j = (t + 2) % m; j != t; j = (j + 1) % m) {
direct(row, f[j], f[(j - 1 + m) % m]);
}
direct(row, 0, f[(t - 1 + m) % m]);
}
}
void solve() {
cin >> n;
for (int i = (0), _b = (n); i < _b; ++i) {
cin >> p[i];
--p[i];
}
auto perms = get_permutation();
if (perms.size() == n) {
res = n;
} else {
res = n - 1;
calc(perms);
}
cout << res << '\n';
for (int i = (0), _b = (n); i < _b; ++i) {
for (int j = (0), _b = (n); j < _b; ++j)
if (a[i][j] == 0)
cout << '.';
else if (a[i][j] == 1)
cout << '\\';
else
cout << '/';
cout << '\n';
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const bool multiple_test = false;
int test = 1;
if (multiple_test) cin >> test;
for (int i = 0; i < test; ++i) {
solve();
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110000;
char txt[MAXN], rtxt[MAXN], patt[MAXN], rpatt[MAXN];
int n, sol, tc, pf[MAXN], sp;
int suff[MAXN], pref[MAXN], z[MAXN];
void PF() {
int k = 0;
for (int i = 1; patt[i]; i++) {
pf[i] = 0;
while (k && patt[k] != patt[i]) k = pf[k - 1];
if (patt[k] == patt[i]) k++;
pf[i] = k;
}
}
void kmp() {
int len = strlen(patt);
int k = 0;
for (int i = 0; txt[i]; i++) {
while (k && txt[i] != patt[k]) k = pf[k - 1];
if (patt[k] == txt[i]) k++;
pref[i] = i > 0 ? max(k, pref[i - 1]) : k;
if (k == len) k = pf[k - 1];
}
}
void Z_Function(char* p) {
int l = 0, r = 0, size = strlen(p);
z[0] = 0;
for (int i = 1; i < size; i++) {
if (i > r) {
int j;
for (j = 0; i + j < size && p[i + j] == p[j]; j++)
;
z[i] = j, l = i, r = i + j - 1;
} else {
if (z[i - l] < r - i + 1)
z[i] = z[i - l];
else {
int j;
for (j = 1; r + j < size && p[r + j] == p[r - i + j]; j++)
;
z[i] = r - i + j;
l = i;
r = r + j - 1;
}
}
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> txt;
n = strlen(txt);
strcpy(rtxt, txt);
reverse(rtxt, rtxt + n);
for (cin >> tc; tc; tc--) {
cin >> patt;
sp = strlen(patt);
if (sp == 1) continue;
strcpy(rpatt, patt);
reverse(rpatt, rpatt + sp);
PF();
kmp();
strcat(rpatt, "$");
strcat(rpatt, rtxt);
Z_Function(rpatt);
for (int i = 0; i < n; i++) suff[i] = z[sp + 1 + i];
memcpy(suff, z + sp + 1, n * sizeof(int));
for (int i = 0; i < n; i++) {
int pos = i + suff[i];
pos = n - pos - 1;
if (pref[pos] + suff[i] >= sp) {
sol++;
break;
}
}
}
cout << sol << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
pair<bool, int> A[210];
int n, k, theorems, q, x, cards;
int lowPerf = 210 * 210, highPerf = -1, curPerf;
int main() {
cin >> n >> k;
theorems = n / k;
cards = k;
for (int i = 0; i < n; i++) {
cin >> x;
A[i].first = 1;
A[i].second = x;
}
cin >> q;
for (int i = 0; i < q; i++) {
curPerf = 0;
for (int j = 0; j < theorems; j++) {
cin >> x;
x--;
if (j == 0 && A[x].first == 1) cards--;
A[x].first = 0;
curPerf += A[x].second;
}
lowPerf = min(lowPerf, curPerf);
highPerf = max(highPerf, curPerf);
}
sort(A, A + n);
if (cards > 0) {
for (int i = 0; i < n; i++) {
if (A[i].first == 1) {
curPerf = 0;
for (int j = i; j < i + theorems; j++) {
if (j >= n) break;
curPerf += A[j].second;
if (j == i + theorems - 1) {
lowPerf = min(lowPerf, curPerf);
highPerf = max(highPerf, curPerf);
break;
}
}
break;
}
}
curPerf = 0;
for (int i = n - 1; i >= 0; i--) {
if (A[i].first == 0) break;
curPerf += A[i].second;
if (i == n - theorems) {
lowPerf = min(lowPerf, curPerf);
highPerf = max(highPerf, curPerf);
break;
}
}
}
printf("%.10lf %.10lf\n", ((double)(lowPerf)) / theorems,
((double)(highPerf)) / theorems);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, ans;
cin >> n >> k;
string st, nextst, temp, temp1;
cin >> st;
queue<string> q;
set<string> s;
q.push(st);
s.insert(st);
ans = st.size();
k -= 1;
while (!q.empty() && k > 0) {
nextst = q.front();
q.pop();
for (int i = 0; i < nextst.size(); i++) {
temp1 = nextst;
temp = nextst.erase(i, 1);
nextst = temp1;
if (s.count(temp) == 0 && k > 0) {
q.push(temp);
s.insert(temp);
ans += temp.size();
k -= 1;
}
}
}
if (k > 0)
cout << -1 << endl;
else
cout << (s.size() * st.size() - ans) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n;
long long cf, cm;
long long mAns = -1;
int szAns = -1;
pair<long long, int> a[N];
long long A;
long long sumPref[N], sumSuff[N];
long long m;
long long b[N];
void read() {
scanf("%d%lld%lld%lld%lld", &n, &A, &cf, &cm, &m);
for (int i = 0; i < n; i++) {
a[i].second = i;
scanf("%lld", &a[i].first);
}
sort(a, a + n);
sumPref[0] = 0;
for (int i = 0; i < n; i++) sumPref[i + 1] = sumPref[i] + a[i].first;
sumSuff[n] = 0;
for (int i = n - 1; i >= 0; i--) sumSuff[i] = sumSuff[i + 1] + A - a[i].first;
return;
}
void solve() {
if (sumSuff[0] <= m) {
printf("%lld\n", cf * n + cm * A);
for (int i = 0; i < n; i++) printf("%lld ", A);
printf("\n");
return;
}
int idx = 1;
for (int i = 0; i <= n; i++) {
if (sumSuff[i] > m) continue;
long long lft = m - sumSuff[i];
while (idx < i) {
long long x = (sumPref[idx] + lft) / idx;
if (x > a[idx].first)
idx++;
else
break;
}
long long x = (sumPref[idx] + lft) / idx;
long long val = cf * (n - i) + cm * x;
if (val > mAns) {
mAns = val;
szAns = i;
}
}
printf("%lld\n", mAns);
idx = 1;
while (idx < szAns) {
long long x = (sumPref[idx] + m - sumSuff[szAns]) / idx;
if (x > a[idx].first)
idx++;
else
break;
}
long long x = (sumPref[idx] + m - sumSuff[szAns]) / idx;
for (int i = 0; i < idx; i++) a[i].first = x;
for (int i = szAns; i < n; i++) a[i].first = A;
for (int i = 0; i < n; i++) b[a[i].second] = a[i].first;
for (int i = 0; i < n; i++) printf("%lld ", b[i]);
printf("\n");
return;
}
int main() {
read();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n;
double a[101];
cin >> n;
double sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum = sum + a[i];
}
cout << (sum / (n * 100)) * 100 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 305;
long long flag[305];
long long n, p, x;
int main() {
cin >> p >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
if (flag[x % p]) {
cout << i;
return 0;
}
flag[x % p] = 1;
}
cout << -1;
return 0;
}
| 0 |
/*
* @file C.cpp
* @path D:\code\ACM\codeforces\EDU_101\C.cpp
* @author Xiuchen
* @date 2020-12-28 23:08:11
*/
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<cmath>
#include<math.h>
#include<iostream>
#include<algorithm>
#include<unordered_map>
//#define DEBUG
#define M_PI 3.14159265358979323846
#define dbg(x) cout << #x << " = "<< (x) << endl
#define dbg2(x1,x2) cout << #x1 << " = " << x1 << " " << #x2 << " = " << x2 << endl
#define dbg3(x1,x2,x3) cout<< #x1 << " = " << x1 << " " << #x2 << " = " << x2 << " " << #x3 << " = " << x3 <<endl
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3fLL;
const int maxn = 2e5 + 100;
int gcd(int a, int b){
return b ? gcd(b, a % b) : a;
}
int t, n;
ll k, h[maxn];
int main(){
#ifdef DEBUG
freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#endif
scanf("%d", &t);
while(t--){
scanf("%d%lld", &n, &k);
for(int i = 1; i <= n; i++) scanf("%lld", &h[i]);
ll curl = h[1], curr = h[1];
bool flag = true;
for(int i = 2; i <= n - 1; i++){
ll tmp1l = curl + 1 - k, tmp1r = curr + k - 1;
ll tmp2l = h[i], tmp2r = h[i] + k - 1;
ll tmpl = max(tmp1l, tmp2l), tmpr = min(tmp1r, tmp2r);
if(tmpl > tmpr) {
flag = false;
break;
} else curl = tmpl, curr = tmpr;
// dbg2(curl, curr);
}
if(flag){
ll tmp1l = curl + 1 - k, tmp1r = curr + k - 1;
ll tmp2l = h[n], tmp2r = h[n];
ll tmpl = max(tmp1l, tmp2l), tmpr = min(tmp1r, tmp2r);
if(tmpl > tmpr) flag = false;
}
if(flag) printf("YES\n");
else printf("NO\n");
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[1005];
pair<pair<int, int>, int> p[1005];
int dfs(int first, int f) {
if (v[first].size() == 1) {
return first;
}
for (auto it : v[first]) {
if (it.first != f) {
return dfs(it.first, first);
}
}
}
int degree[1005];
bool cmp(const pair<pair<int, int>, int> &p,
const pair<pair<int, int>, int> &q) {
return min(degree[p.first.first], degree[p.first.second]) >
min(degree[q.first.first], degree[q.first.second]);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int first, second, val;
scanf("%d %d %d", &first, &second, &val);
p[i] = make_pair(make_pair(first, second), val);
degree[first]++;
degree[second]++;
v[first].push_back(make_pair(second, i));
v[second].push_back(make_pair(first, i));
}
for (int i = 1; i <= n; i++) {
if (v[i].size() == 2) {
printf("NO\n");
return 0;
}
}
vector<pair<pair<int, int>, int> > ans;
for (int i = 1; i < n; i++) {
vector<int> left, right;
if (v[p[i].first.second].size() == 1) {
left.push_back(p[i].first.second);
left.push_back(p[i].first.second);
} else {
if (v[p[i].first.second][0].first != p[i].first.first)
left.push_back(dfs(v[p[i].first.second][0].first, p[i].first.second));
else
left.push_back(
dfs(v[p[i].first.second].back().first, p[i].first.second));
if (v[p[i].first.second][1].first != p[i].first.first)
left.push_back(dfs(v[p[i].first.second][1].first, p[i].first.second));
else
left.push_back(
dfs(v[p[i].first.second].back().first, p[i].first.second));
}
if (v[p[i].first.first].size() == 1) {
right.push_back(p[i].first.first);
right.push_back(p[i].first.first);
} else {
if (v[p[i].first.first][0].first != p[i].first.second)
right.push_back(dfs(v[p[i].first.first][0].first, p[i].first.first));
else
right.push_back(
dfs(v[p[i].first.first].back().first, p[i].first.first));
if (v[p[i].first.first][1].first != p[i].first.second)
right.push_back(dfs(v[p[i].first.first][1].first, p[i].first.first));
else
right.push_back(
dfs(v[p[i].first.first].back().first, p[i].first.first));
}
ans.push_back(make_pair(make_pair(left[0], right[0]), p[i].second / 2));
ans.push_back(make_pair(make_pair(left[1], right[1]), p[i].second / 2));
if (left[0] != left[1]) {
ans.push_back(make_pair(make_pair(left[0], left[1]), -p[i].second / 2));
}
if (right[0] != right[1]) {
ans.push_back(make_pair(make_pair(right[0], right[1]), -p[i].second / 2));
}
}
printf("YES\n");
printf("%d\n", ans.size());
for (auto it : ans)
printf("%d %d %d\n", it.first.first, it.first.second, it.second);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx[5] = {0, -1, 1, 0, 0};
int dy[5] = {0, 0, 0, -1, 1};
int main() {
int arr[102], n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
int sum = 1001, ind1, ind2;
for (int i = 0; i < n - 1; i++) {
if (sum > abs(arr[i] - arr[i + 1])) {
sum = abs(arr[i] - arr[i + 1]);
ind1 = i + 1, ind2 = i + 2;
}
}
if (sum > abs(arr[0] - arr[n - 1])) {
sum = abs(arr[0] - arr[n - 1]);
ind1 = n;
ind2 = 1;
}
cout << ind1 << " " << ind2;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 210;
const int inf = 0x3f3f3f3f;
using namespace std;
long long n, m, k, I;
int a[N], d[N];
char s[N];
long long dp[N][N];
bool cmp(const int &x, const int &y) { return a[x] < a[y]; }
int main() {
cin >> n >> m >> k;
I = n + m - 1;
for (int i = 0; i < I; i++) a[i] = m * n, d[i] = i;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int x;
cin >> x;
if (x < a[i + j]) a[i + j] = x;
}
sort(d, d + I, cmp);
for (int l = 0; l < I; l++) {
s[d[l]] = '(';
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 0; i < I; i++)
for (int j = 0; j <= i; j++) {
if (dp[i][j] == 0) continue;
if (dp[i][j] > k) dp[i][j] = k;
if (s[i] != '(' && j) dp[i + 1][j - 1] += dp[i][j];
if (s[i] != ')') dp[i + 1][j + 1] += dp[i][j];
}
if (dp[I][0] < k) s[d[l]] = ')', k -= dp[I][0];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%c", s[i + j]);
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 4;
const int inf = (int)1e9 + 7;
const long double eps = 1e-7;
const int K = 21;
const int M = 1001;
struct cell {
int val, x, y;
cell() { x = 0, y = 0, val = 0; }
cell(int val, int x, int y) : val(val), x(x), y(y) {}
bool operator<(const cell &arg) const {
if (val == arg.val) {
if (x == arg.x) {
return y < arg.y;
}
return x < arg.x;
}
return val < arg.val;
}
};
vector<vector<vector<cell> > > g;
vector<vector<bool> > u;
vector<vector<int> > comp;
int sz;
int ans[N];
vector<vector<int> > an;
set<int> row[N], col[N];
vector<pair<vector<cell>, int> > comps;
void dfs(const cell &a) {
u[a.x][a.y] = 1;
comp[a.x][a.y] = sz;
row[a.x].insert(sz);
col[a.y].insert(sz);
comps.back().first.push_back(a);
for (cell &to : g[a.x][a.y]) {
if (!u[to.x][to.y]) {
dfs(to);
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<vector<cell> > a(n, vector<cell>(m));
vector<vector<cell> > aa(m, vector<cell>(n));
vector<cell> b(n * m);
for (int i = 0; i < n; ++i) {
g.push_back(vector<vector<cell> >(0));
u.push_back(vector<bool>(m, 0));
comp.push_back(vector<int>(m, 0));
an.push_back(vector<int>(m, 0));
for (int j = 0; j < m; ++j) {
g[i].push_back(vector<cell>(0));
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j].val);
a[i][j].x = i, a[i][j].y = j;
aa[j][i] = a[i][j];
b[i * m + j] = a[i][j];
}
}
for (int i = 0; i < n; ++i) {
sort(a[i].begin(), a[i].end());
for (int j = 0; j < m; ++j) {
if (j > 0 && a[i][j].val == a[i][j - 1].val) {
g[a[i][j].x][a[i][j].y].push_back(a[i][j - 1]);
}
if (j < m - 1 && a[i][j].val == a[i][j + 1].val) {
g[a[i][j].x][a[i][j].y].push_back(a[i][j + 1]);
}
}
}
for (int i = 0; i < m; ++i) {
sort(aa[i].begin(), aa[i].end());
for (int j = 0; j < n; ++j) {
if (j > 0 && aa[i][j].val == aa[i][j - 1].val) {
g[aa[i][j].x][aa[i][j].y].push_back(aa[i][j - 1]);
}
if (j < n - 1 && aa[i][j].val == aa[i][j + 1].val) {
g[aa[i][j].x][aa[i][j].y].push_back(aa[i][j + 1]);
}
}
}
sort(b.begin(), b.end());
for (int i = 0; i < n * m; ++i) {
if (!u[b[i].x][b[i].y]) {
comps.push_back(make_pair(vector<cell>(0), b[i].val));
dfs(b[i]);
sz++;
}
}
for (int i = 0; i < sz; ++i) {
int w = 0;
for (cell &v : comps[i].first) {
auto it = row[v.x].lower_bound(i);
if (it != row[v.x].begin()) {
--it;
w = max(w, ans[*it]);
}
it = col[v.y].lower_bound(i);
if (it != col[v.y].begin()) {
--it;
w = max(w, ans[*it]);
}
}
ans[i] = w + 1;
for (cell &v : comps[i].first) {
an[v.x][v.y] = ans[i];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
printf("%d ", an[i][j]);
}
puts("");
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.