solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, a, miejsce, ile_zostalo, wynik, result = 1000000000;
int poz[300], pom[300], ile[300];
vector<int> v[300], numer[4];
int main() {
scanf("%d", &n);
for (int i = 1; i <= (n); i++) scanf("%d", &poz[i]);
for (int i = 1; i <= (n); i++) {
scanf("%d", &ile[i]);
for (int j = 0; j < (ile[i]); j++) scanf("%d", &a), v[a].push_back(i);
}
for (int k = 1; k <= (3); k++) {
for (int i = 1; i <= (n); i++) numer[poz[i]].push_back(i);
for (int i = 1; i <= (n); i++) pom[i] = ile[i];
miejsce = k;
ile_zostalo = n;
wynik = 0;
while (ile_zostalo) {
bool zmiana = true;
while (zmiana) {
zmiana = false;
for (__typeof((numer[miejsce]).begin()) it = ((numer[miejsce]).begin());
it != (numer[miejsce]).end(); it++)
if (!pom[*it]) {
for (__typeof((v[*it]).begin()) it2 = ((v[*it]).begin());
it2 != (v[*it]).end(); it2++)
--pom[*it2];
*it = numer[miejsce].back();
numer[miejsce].pop_back();
--it;
--ile_zostalo;
zmiana = true;
}
}
++wynik;
++miejsce;
if (miejsce == 4) miejsce = 1;
}
result = min(result, wynik);
}
printf("%d\n", result - 1 + n);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string tos(T a) {
stringstream ss;
string ret;
ss << a;
ss >> ret;
return ret;
}
void read(int &_a) { int temp = scanf("%d", &_a); }
void read(int &_a, int &_b) { int temp = scanf("%d %d", &_a, &_b); }
void read(int &_a, int &_b, int &_c) {
int temp = scanf("%d %d %d", &_a, &_b, &_c);
}
const int SZ = 1e6 + 7;
const long long MOD = 1e9 + 7;
int memo[SZ][22][2];
int N;
long long cmult(long long x, long long y) {
long long d = 1ll << x;
if (y) d *= 3ll;
return N / d;
}
int main() {
while (cin >> N) {
int X = 0;
while (1 << X <= N) X++;
X--;
memset(memo, 0, sizeof memo);
;
memo[1][X][0] = 1;
if (((1 << X) / 2) * 3 <= N) memo[1][X - 1][1] = 1;
for (int(pos) = (1); (pos) < (N); (pos)++) {
for (int(x) = (0); (x) < (X + 1); (x)++)
for (int(y) = (0); (y) < (2); (y)++) {
long long v = (memo[pos][x][y] * (cmult(x, y) - pos)) % MOD;
memo[pos + 1][x][y] = (memo[pos + 1][x][y] + v) % MOD;
if (x) {
v = (memo[pos][x][y] * (cmult(x - 1, y) - cmult(x, y))) % MOD;
memo[pos + 1][x - 1][y] = (memo[pos + 1][x - 1][y] + v) % MOD;
}
if (y) {
v = (memo[pos][x][y] * (cmult(x, y - 1) - cmult(x, y))) % MOD;
memo[pos + 1][x][y - 1] = (memo[pos + 1][x][y - 1] + v) % MOD;
}
}
}
cout << memo[N][0][0] << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char s[10013];
int g = 0, ret = 0;
map<string, int> ma;
void wczyt() {
string a;
while (s[g] >= 'A' && s[g] <= 'Z') {
a += s[g++];
}
ret += ma[a];
ma[a]++;
while (s[g] != '.') {
g++;
wczyt();
}
g++;
ma[a]--;
}
int main() {
scanf("%s", s);
wczyt();
printf("%d\n", ret);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize( \
"Ofast,unroll-loops,no-stack-protector,unsafe-math-optimizations")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
template <typename T>
inline bool cmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool cmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
int inp() {
int x = 0, f = 1;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x * f;
}
struct comp {
double r, i;
inline comp() {}
inline comp(double a, double b) : r(a), i(b) {}
};
const int N = (1 << 19), MaxN = (N << 1) + 10;
const int K = 32767, L = 15;
int P;
inline comp add(comp a, comp b) { return comp(a.r + b.r, a.i + b.i); }
inline comp sub(comp a, comp b) { return comp(a.r - b.r, a.i - b.i); }
inline comp mul(comp a, comp b) {
return comp(a.r * b.r - a.i * b.i, a.r * b.i + a.i * b.r);
}
inline comp div(comp a, double b) { return comp(a.r / b, a.i / b); }
inline comp conj(comp x) { return comp(x.r, -x.i); }
inline int add(int x, int y) {
return x + (long long)y >= P ? x + (long long)y - P : x + y;
}
inline int sub(int x, int y) { return x >= y ? x - y : x - (long long)y + P; }
inline int mul(int x, int y) { return (long long)x * y % P; }
int exp(int x, long long n) {
int res = 1;
for (; n; n >>= 1) {
if (n & 1) res = mul(res, x);
x = mul(x, x);
}
return res;
}
comp eps[MaxN];
void init() {
double pi = acos(-1);
for (int i = 0; i < N; i++)
eps[i] = comp(cos(2 * pi * i / N), sin(2 * pi * i / N));
}
inline void trans(int n, comp x[], comp w[]) {
for (int i = 0, j = 0; i != n; i++) {
if (i < j) std::swap(x[i], x[j]);
for (int l = n >> 1; (j ^= l) < l; l >>= 1)
;
}
for (int i = 2; i <= n; i <<= 1) {
int l = i >> 1, d = N / i;
for (int j = 0; j != n; j += i)
for (int k = 0; k != l; k++) {
comp t = mul(x[j + k + l], w[d * k]);
x[j + k + l] = sub(x[j + k], t);
x[j + k] = add(x[j + k], t);
}
}
}
inline void dft(int n, comp x[]) { trans(n, x, eps); }
inline void idft(int n, comp x[]) {
trans(n, x, eps);
reverse(x + 1, x + n);
for (int i = 0; i < n; i++) x[i] = div(x[i], n);
}
int t[MaxN];
void conv(int na, int a[], int nb, int b[], int nc, int c[], int same = 0) {
int n, i, j;
if ((long long)na * nb <= 1e5) {
for (i = 0; i < nc; i++) t[i] = 0;
for (i = 0; i < na; i++)
for (j = 0; j < nb && j + i < nc; j++)
t[i + j] = add(t[i + j], mul(a[i], b[j]));
for (i = 0; i <= nc; i++) c[i] = t[i];
return;
}
static comp x[MaxN], y[MaxN], z[MaxN], w[MaxN];
for (n = 1; n < na + nb - 1; n <<= 1)
;
for (i = 0; i < n; i++) {
x[i] = i < na ? comp(a[i] & K, a[i] >> L) : comp(0, 0);
y[i] = i < nb ? comp(b[i] & K, b[i] >> L) : comp(0, 0);
}
dft(n, x);
if (!same)
dft(n, y);
else
for (i = 0; i < n; i++) y[i] = x[i];
comp r0(0.5, 0), r1(0, -0.5), r(0, 1);
for (i = 0; i < n; i++) {
int j = (n - i) & (n - 1);
comp x0, x1, y0, y1;
x0 = mul(add(x[i], conj(x[j])), r0);
x1 = mul(sub(x[i], conj(x[j])), r1);
y0 = mul(add(y[i], conj(y[j])), r0);
y1 = mul(sub(y[i], conj(y[j])), r1);
z[i] = mul(x0, add(y0, mul(y1, r)));
w[i] = mul(x1, add(y0, mul(y1, r)));
}
idft(n, z);
idft(n, w);
for (i = 0; i < nc; i++) {
int c00 = (long long)(z[i].r + 0.5) % P,
c01 = (long long)(z[i].i + 0.5) % P;
int c10 = (long long)(w[i].r + 0.5) % P,
c11 = (long long)(w[i].i + 0.5) % P;
c[i] = ((((long long)c11 << L) + c01 + c10 << L) + c00) % P;
}
}
int nL;
int n, l, r, x[MaxN], y[MaxN];
void pow(int x[], int y[], int n) {
y[0] = 1;
int sN = 3;
nL = 1;
for (; n; n >>= 1) {
if (n & 1)
conv(sN, x, nL, y, min(nL + sN, 2 * ::n + 3), y),
nL = min(nL + sN, 2 * ::n + 3);
conv(sN, x, sN, x, min(sN << 1, 2 * ::n + 3), x, 1);
sN = min(sN << 1, 2 * ::n + 3);
}
}
int res(int x) { return y[x + n]; }
int main() {
int ans;
init();
cin >> n >> P >> l >> r;
x[0] = x[1] = x[2] = 1;
pow(x, y, n);
ans = ((long long)res(l) + res(l + 1) - res(r + 1) - res(r + 2)) % P;
cout << ((long long)ans + P) % P << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long calc_m(long long n, long long x) {
long long ret = -1;
if ((6 * x - n + n * n * n) % (3 * n * (n + 1)) == 0) {
ret = (6 * x - n + n * n * n) / (3 * n * (n + 1));
}
return ret;
}
int main() {
long long x;
cin >> x;
long long n = 1;
vector<pair<long long, long long> > ans;
while (6 * x >= 2 * n * n * n + 3 * n * n + n) {
long long m = calc_m(n, x);
if (m != -1) ans.push_back(make_pair(n, m));
n++;
}
long long lim = ans.size();
if (ans[ans.size() - 1].first == ans[ans.size() - 1].second) lim--;
for (long long i = lim - 1; i >= 0; --i) {
ans.push_back(make_pair(ans[i].second, ans[i].first));
}
cout << ans.size() << endl;
for (long long i = 0; i < ans.size(); ++i) {
cout << ans[i].first << " " << ans[i].second << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double num[105];
int cmp(double a, double b) { return a > b; }
int main(void) {
double a, b, x, tmpb, tmpa;
int n, i;
a = 1, b = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%lf", &num[i]);
sort(num, num + n, cmp);
for (i = 0; i < n; i++) {
x = num[i];
tmpb = a * x + b * (1 - x);
tmpa = a * (1 - x);
if (tmpb > b) b = tmpb, a = tmpa;
}
printf("%.9f\n", b);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class A>
void pr(A a) {
cout << a;
cout << '\n';
}
template <class A, class B>
void pr(A a, B b) {
cout << a << ' ';
pr(b);
}
template <class A, class B, class C>
void pr(A a, B b, C c) {
cout << a << ' ';
pr(b, c);
}
template <class A, class B, class C, class D>
void pr(A a, B b, C c, D d) {
cout << a << ' ';
pr(b, c, d);
}
template <class A>
void PR(A a, long long n) {
for (int i = (int)(0); i < (int)(n); i++) {
if (i) cout << ' ';
cout << a[i];
}
cout << '\n';
}
long long check(long long n, long long m, long long x, long long y) {
return x >= 0 && x < n && y >= 0 && y < m;
}
const long long MAX = 1000000007, MAXL = 1LL << 61, dx[4] = {-1, 0, 1, 0},
dy[4] = {0, 1, 0, -1};
void Main() {
long long n, m;
cin >> n >> m;
long long a[n];
for (int i = (int)(0); i < (int)(n); i++) cin >> a[i];
map<pair<long long, long long>, long long> ma;
for (int i = (int)(0); i < (int)(m); i++) {
long long x, y, z;
cin >> x >> y >> z;
x--, y--;
ma[pair<long long, long long>(x, y)] = z;
}
double ans = 0;
for (int i = (int)(0); i < (int)(n); i++) {
for (int j = (int)(i + 1); j < (int)(n); j++) {
if (ma.count(pair<long long, long long>(i, j)))
ans = max(ans,
(double)(a[i] + a[j]) / ma[pair<long long, long long>(i, j)]);
}
}
printf("%.10f\n", ans);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
Main();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1e3 + 7;
int n, a[N], T;
int f[N];
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
fill(f + 1, f + n + 1, -1);
f[0] = 0;
a[0] = 1e9;
for (int i = 1; i <= n; i++) {
if (f[i - 1] > a[i]) break;
f[i] = max(a[i] - a[i - 1] + f[i - 1], f[i - 1]);
}
puts(f[n] != -1 ? "YES" : "NO");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n - 1; i++) cin >> arr[i];
int a, b;
cin >> a >> b;
int sum = 0;
for (int i = a - 1; i < b - 1; i++) sum += arr[i];
cout << sum << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
pair<int, int> a[4][N];
int nxt[4][N], pre[4][N];
void del(int p) {
for (int i = 0; i < 4; i++) {
int a = pre[i][p], b = nxt[i][p];
nxt[i][a] = b;
pre[i][b] = a;
}
}
bool dfs(vector<int> &left) {
if (left.size() <= 1) return 1;
for (int i = 0; i < 4; i++) {
sort(left.begin(), left.end(),
[&](int x, int y) { return a[i][x] < a[i][y]; });
int p = 0;
for (auto &j : left) {
nxt[i][p] = j;
pre[i][j] = p;
p = j;
}
nxt[i][p] = 0;
}
int num = left.size();
while (num > 1) {
bool fl = 0;
int head[4], target[4];
for (int i = 0; i < 4; i++)
head[i] = nxt[i][0], target[i] = a[i][head[i]].second;
for (int i = 1; i < num && !fl; i++)
for (int j = 0; j < 4; j++) {
head[j] = nxt[j][head[j]];
if (a[j][head[j]].first >= target[j]) {
vector<int> s;
for (int k = nxt[j][0]; k != head[j]; k = nxt[j][k]) s.push_back(k);
for (auto &k : s) del(k);
for (int k = 0; k < 4; k++) head[k] = nxt[k][0];
if (!dfs(s)) return 0;
num -= i;
for (int k = 0; k < 4; k++) nxt[k][0] = head[k];
fl = 1;
break;
} else
target[j] = max(target[j], a[j][head[j]].second);
}
if (!fl) return 0;
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
int t1, t2, t3, t4;
cin >> t1 >> t2 >> t3 >> t4;
a[0][i] = {t1, t3};
a[1][i] = {t2, t4};
a[2][i] = {-t3, -t1};
a[3][i] = {-t4, -t2};
}
vector<int> v;
for (int i = 1; i <= n; i++) v.push_back(i);
cout << (dfs(v) ? "YES" : "NO") << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f = (ch == 45), ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? (~x + 1) : x;
}
int n, m, k, ans = 0;
int f[20][20], num[20] = {0}, a[20][20];
const int md = 1e9 + 7;
int dfs(int x, int y) {
if (y == m + 1) x++, y = 1;
if (x == n + 1) return 1;
int ret = 0, d = -1, now = f[x - 1][y] | f[x][y - 1], c = 0;
for (register int i = now; i; i -= i & (-i)) c++;
if (m + n - x - y + 1 > k - c) return 0;
int can = (~now) & ((1 << k) - 1);
for (int i = can; i; i -= i & (-i)) {
int temp = i & (-i);
int t = log(temp + 0.5) / log(2.0) + 1;
if (a[x][y] == 0 || a[x][y] == t) {
f[x][y] = now | temp;
num[t]++;
if (num[t] == 1) {
if (d == -1) d = dfs(x, y + 1);
ret += d;
} else if (num[t])
ret += dfs(x, y + 1);
ret %= md;
num[t]--;
}
}
return ret;
}
int main() {
n = read();
m = read();
k = read();
if (n + m - 1 > k) {
cout << "0\n";
return 0;
}
for (register int i = 1; i <= n; i++)
for (register int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j]) num[a[i][j]]++;
}
cout << dfs(1, 1) % md << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int calc2(int x) {
int tmp = 1;
while (x >= tmp) {
x -= tmp;
tmp <<= 1;
}
return x;
}
int n, rest, tot;
pair<int, int> save[1000000];
void run(int index, int now, int flg) {
save[index] = make_pair(now, flg);
if ((index << 1) > tot) return;
if (now) {
if (flg) {
run(index << 1, 0, 0), run((index << 1) + 1, 0, 0);
} else {
run(index << 1, 1, 1), run((index << 1) + 1, 1, 0);
}
} else {
if (flg) {
run(index << 1, 0, 0), run((index << 1) + 1, 1, 0);
} else {
run(index << 1, 1, 1), run((index << 1) + 1, 0, 0);
}
}
}
bool check() {
int tmp = 0;
for (int i = tot; i * 2 > tot; i--) {
if (save[i].first) {
if (!save[i].second) return 0;
} else {
tmp++;
if (save[i].second == 1) return 0;
}
}
return (tmp == rest);
}
int main() {
cin >> n;
rest = calc2(n), tot = n - rest;
int res = 0;
run(1, n & 1, 1), res += check();
run(1, n & 1, 0), res += check();
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > good, piece, bad;
vector<string> a;
string s;
char b[110][110];
int main() {
cin >> n;
int cent = n - 1;
for (int i = 0; i < 2 * n - 1; ++i) {
for (int j = 0; j < 2 * n - 1; ++j) b[i][j] = 'x';
}
for (int i = 0; i < n; ++i) {
cin >> s;
for (int j = 0; j < n; ++j) {
if (s[j] == 'o')
piece.push_back(make_pair(i, j));
else if (s[j] == 'x')
bad.push_back(make_pair(i, j));
else
good.push_back(make_pair(i, j));
}
a.push_back(s);
}
b[cent][cent] = 'o';
for (pair<int, int> p : piece) {
for (pair<int, int> g : good) {
b[cent + g.first - p.first][cent + g.second - p.second] = '.';
}
}
for (pair<int, int> ba : bad) {
bool cantdo = true;
for (pair<int, int> p : piece) {
if (b[cent + ba.first - p.first][cent + ba.second - p.second] == 'x') {
cantdo = false;
}
}
if (cantdo) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (int i = 0; i < 2 * n - 1; ++i) {
for (int j = 0; j < 2 * n - 1; ++j) cout << b[i][j];
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 10;
int n, k, dp[maxn][maxn];
char s[maxn][maxn];
bool vis[maxn][maxn];
queue<pair<int, int>> q1, q2;
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
int mx = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i > 1 && j > 1) {
dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]);
} else if (i == 1 && j > 1)
dp[i][j] = dp[i][j - 1];
else if (i > 1 && j == 1)
dp[i][j] = dp[i - 1][j];
dp[i][j] += (s[i][j] == 'a' ? 0 : 1);
if (dp[i][j] <= k) {
mx = max(mx, i + j);
}
}
}
for (int i = 0; i < mx - 1; i++) printf("a");
if (mx == 0) q1.push({1, 1}), printf("%c", s[1][1]);
for (int i = 1; i <= n; i++) {
if (mx - i <= n && mx - i >= 1) {
if (dp[mx - i][i] <= k) {
q1.push({mx - i, i});
vis[mx - i][i] = true;
}
}
}
if (q1.empty()) return 0;
char fuck = '{';
bool ch = false;
for (int r = mx; r < 2 * n; r++) {
q2 = q1;
fuck = '{';
ch = false;
while (!q1.empty()) {
if (q1.front().first + 1 <= n) {
if (s[q1.front().first + 1][q1.front().second] <= fuck) {
fuck = s[q1.front().first + 1][q1.front().second];
ch = true;
}
}
if (q1.front().second + 1 <= n) {
if (s[q1.front().first][q1.front().second + 1] <= fuck) {
fuck = s[q1.front().first][q1.front().second + 1];
ch = true;
}
}
q1.pop();
}
if (ch && fuck != '{') printf("%c", fuck);
while (!q2.empty()) {
if (q2.front().first + 1 <= n) {
if (!vis[q2.front().first + 1][q2.front().second] &&
s[q2.front().first + 1][q2.front().second] == fuck)
q1.push({q2.front().first + 1, q2.front().second});
vis[q2.front().first + 1][q2.front().second] = true;
}
if (q2.front().second + 1 <= n) {
if (!vis[q2.front().first][q2.front().second + 1] &&
s[q2.front().first][q2.front().second + 1] == fuck)
q1.push({q2.front().first, q2.front().second + 1});
vis[q2.front().first][q2.front().second + 1] = true;
}
q2.pop();
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a(10);
for (int i = 0; i < 6; i++) {
int u;
cin >> u;
a[u]++;
}
int leg = 0;
int head = 0;
int body = 0;
for (int i = 1; i < 10; i++) {
if (a[i] == 4) {
leg = i;
} else if (a[i] == 5) {
leg = i;
body = i;
} else if (a[i] == 6) {
leg = i;
body = i;
head = i;
} else if (a[i] == 1) {
if (body == 0) {
body = i;
} else if (head == 0) {
head = i;
}
} else if (a[i] == 2) {
body = head = i;
}
}
if (leg == 0) {
cout << "Alien" << '\n';
return 0;
}
if (head == body) {
cout << "Elephant" << '\n';
} else {
cout << "Bear" << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class T>
inline T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
inline T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(a, max(b, c, d));
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(a, min(b, c, d));
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T gcd(T a, T b) {
T t;
if (a < b) {
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
} else {
while (b) {
t = b;
b = a % b;
a = t;
}
return a;
}
}
inline void judge() {
freopen("JHOSM.in", "r", stdin);
freopen("JHOSM.out", "w", stdout);
freopen("JHOSM.err", "w", stderr);
;
cout << setprecision(20) << fixed;
}
inline bool dig(char chr) { return (chr >= '0' && chr <= '9') ? true : false; }
const int mod = (int)(1e9) + 7;
const long long inf = 1e9 + 7;
const int dx[] = {0, 1, 0, -1, 0, 1, -1, 1, -1};
const int dy[] = {-1, 0, 1, 0, -1, 1, -1, -1, 1};
int n;
int g[110][110];
int vis[110];
int CantVertVis;
void dfs(int x) {
vis[x] = 1;
CantVertVis++;
for (int i = 1; i <= n; i++) {
if (!vis[i] && g[x][i]) dfs(i);
}
}
inline void JHOSM() {
int m;
cin >> n >> m;
int M = m;
memset(vis, 0, sizeof(vis));
int u, v;
while (M--) {
cin >> u >> v;
g[u][v] = g[v][u] = 1;
}
if (m == n) {
CantVertVis = 0;
dfs(1);
if (CantVertVis == n)
cout << "FHTAGN!" << '\n';
else
cout << "NO" << '\n';
} else
cout << "NO" << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
int T = 1;
while (T--) JHOSM();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
inline long long read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long powmod(long long a, long long b) {
long long ans = 1;
for (long long i = 1; i <= b; i++) ans *= a;
return ans;
}
long long a[200001];
long long dp[200001];
long long n;
void read_dfs(int x) {
if (x >= powmod(2, n)) return;
read_dfs(x * 2);
read_dfs(x * 2 + 1);
a[x * 2] += max(a[x * 2 * 2], a[x * 2 * 2 + 1]);
a[x * 2 + 1] += max(a[(x * 2 + 1) * 2], a[(x * 2 + 1) * 2 + 1]);
}
long long dfs(long long x) {
if (dp[x]) return dp[x];
if (x >= powmod(2, n)) return 0;
long long sum = 0;
dp[x] = dfs(x * 2) + dfs(x * 2 + 1) + abs(a[x * 2] - a[x * 2 + 1]);
return dp[x];
}
int main() {
cin >> n;
int k = powmod(2, n);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < powmod(2, i); j++) {
cin >> a[powmod(2, i) + j];
}
}
read_dfs(1);
cout << dfs(1) << endl;
}
| 3 |
#include <bits/stdc++.h>
inline void in(int &MAGNUS) { scanf("%d", &MAGNUS); }
inline void out(int MAGNUS) { printf("%d\n", MAGNUS); }
inline void in(int &MAGNUS, int &CLAR) { scanf("%d%d", &MAGNUS, &CLAR); }
inline void out(int MAGNUS, int CLAR) { printf("%d %d\n", MAGNUS, CLAR); }
inline void inl(long long &LIV) { scanf("%lld", &LIV); }
inline void inl(long long &LIV, long long &MART) {
scanf("%lld%lld", &LIV, &MART);
}
inline void outl(long long LIV) { printf("%lld\n", LIV); }
inline void outl(long long LIV, long long MART) {
printf("%lld %lld\n", LIV, MART);
}
using namespace std;
int main() {
int N;
in(N);
priority_queue<long long, vector<long long>, greater<long long> > q;
for (int i = 1; i <= N; i++) {
long long x;
inl(x);
q.push(x);
}
long long ans = 0;
while (q.size() > 1) {
if (q.size() % 2 == 0) {
q.push(0LL);
} else {
long long cur = 0;
for (int i = 1; i <= 3; i++) {
cur += q.top();
q.pop();
}
ans += cur;
q.push(cur);
}
}
outl(ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T sqr(T t) {
return t * t;
}
inline void files() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const long long MOD = 1e9 + 7;
long long dp[200100], n, ans;
long long pow(long long n, long long m) {
long long ans = 1;
while (m) {
if (m & 1) {
ans = (ans * n) % MOD;
m--;
} else {
n = (n * n) % MOD;
m >>= 1;
}
}
return ans;
}
long long C(long long n, long long k) {
long long ans = (dp[n] * pow(dp[n - k], MOD - 2)) % MOD;
ans = (ans * pow(dp[k], MOD - 2)) % MOD;
return ans;
}
long long f(int pos) {
if (n % 4 == 0) {
if (pos % 2 == 1)
return C((n - 2) / 2, (pos - 1) / 2);
else
return -C((n - 2) / 2, (pos - 1) / 2);
}
if (n % 4 == 1) {
if (pos % 2 == 1)
return C((n - 1) / 2, (pos - 1) / 2);
else
return 0;
}
if (n % 4 == 2) return C((n - 2) / 2, (pos - 1) / 2);
if (n % 4 == 3) {
if (pos % 2 == 1) {
return ((C((n - 3) / 2, pos / 2) - (C((n - 3) / 2, pos / 2 - 1))) + MOD) %
MOD;
} else
return ((C((n - 3) / 2, (pos - 1) / 2) + C((n - 3) / 2, (pos - 1) / 2)) +
MOD) %
MOD;
}
}
int main() {
files();
dp[0] = 1;
for (long long i = 1; i <= 200100; i++) dp[i] = (dp[i - 1] * i) % MOD;
cin >> n;
for (int i = 1; i <= n; i++) {
long long p;
cin >> p;
ans = (ans + (f(i) * p) % MOD + MOD) % MOD;
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
signed long long N, AA, CF, CM, M;
pair<signed long long, int> A[101010];
signed long long S[101010];
int R[101010];
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N >> AA >> CF >> CM >> M;
for (i = 0; i < (N); i++) cin >> A[i].first, A[i].second = i;
sort(A, A + N);
for (i = 0; i < (N); i++) S[i + 1] = S[i] + A[i].first;
int mi = 0, ma = 0;
signed long long lvv = 0;
signed long long V = 0;
if (N * AA - S[N] <= M) {
V = N * CF + AA * CM;
mi = 0, ma = N;
} else {
y = N;
for (x = N; x >= 0; x--) {
if (x < N) {
M -= AA - A[x].first;
if (M < 0) break;
}
while (y * A[y - 1].first - S[y] > M) y--;
y = min(y, x);
signed long long left = M - (y * A[y - 1].first - S[y]);
signed long long lv = min(A[y - 1].first + left / y, AA);
signed long long sc = (N - x) * CF + lv * CM;
if (sc > V) {
V = sc;
mi = y;
ma = N - x;
lvv = lv;
}
}
}
cout << V << endl;
for (i = 0; i < (N); i++) R[A[i].second] = A[i].first;
for (i = 0; i < (mi); i++) R[A[i].second] = lvv;
for (i = 0; i < (ma); i++) R[A[N - 1 - i].second] = AA;
for (i = 0; i < (N); i++) {
cout << R[i];
if (i < N - 1) cout << " ";
}
cout << endl;
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
vector<pair<int, int>> ans;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<bool> vis(n, false);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j != i && !vis[j] && a[j] != a[i]) {
ans.push_back(make_pair(i + 1, j + 1));
vis[i] = true;
vis[j] = true;
}
}
}
if (ans.size() < n - 1)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (auto x : ans) cout << x.first << " " << x.second << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 7;
int a[N];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
int l = -1, r = -1;
for (int i = 0; i < n; i++)
if (a[i] > k) {
l = i;
break;
}
for (int i = 0; i < n; i++)
if (a[i] > k) r = i;
if (l == -1)
cout << n << endl;
else
cout << n - (r - l + 1) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(1234);
const long long maxn = 200007;
const long long inf = LLONG_MAX / 4;
long long n;
long long a[maxn], b[maxn];
set<long long> s;
unordered_map<long long, long long> mp;
unordered_map<long long, long long> le[15], ri[15];
bool vis[maxn];
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.precision(15);
cin >> n;
for (long long i = 0; i < (long long)(n); ++i) cin >> a[i];
for (long long i = 0; i < (long long)(n); ++i) {
if (s.find(a[i]) != s.end()) {
cout << "YES\n0 ";
for (long long j = 0; j < (long long)(n); ++j) {
if (i == j) continue;
cout << a[j] << " ";
}
return 0;
}
s.insert(a[i]);
}
if (n >= 4) {
bool ok = 0;
for (long long i = 0; i < (long long)(n); ++i) {
if (a[i] & 1) continue;
ok = 1;
}
if (ok) {
long long x = -1, y = -1;
for (long long i = 0; i < (long long)(n); ++i) {
if (a[i] & 1)
x = i;
else
y = i;
}
long long s = -1, t = -1;
for (long long i = 0; i < (long long)(n); ++i) {
if (i == x || i == y) continue;
if (s == -1)
s = i;
else
t = i;
}
auto solve = [&](long long s, long long t, long long d) {
long long x = (a[s] + a[t] - a[d]) / 2;
cout << "YES\n" << x << " " << a[s] - x << " " << a[t] - x << " ";
for (long long i = 0; i < (long long)(n); ++i) {
if (i == s || i == t || i == d) continue;
cout << a[i] - x << " ";
}
};
if ((a[s] + a[t] + a[y]) % 2) {
solve(s, t, x);
} else {
solve(s, t, y);
}
return 0;
}
auto solve2 = [&](long long mask, long long mask2) {
cout << "YES\n";
vector<long long> L, R;
L.clear(), R.clear();
for (long long i = 0; i < (long long)(n); ++i) {
if (mask >> i & 1) L.push_back(a[i]), vis[i] = 1;
if (mask2 >> i & 1) R.push_back(a[i]), vis[i] = 1;
}
cout << 0 << " ";
long long ret = 0;
for (long long i = 0; i < (long long)((long long)(L).size()); ++i) {
ret = L[i] - ret;
cout << ret << " ";
ret = R[i] - ret;
if (ret) cout << ret << " ";
}
for (long long i = 0; i < (long long)(n); ++i) {
if (!vis[i]) cout << a[i] << " ";
}
};
long long m = min(n, 30ll), k = m / 2;
vector<long long> p;
p.clear();
for (long long i = 0; i < (long long)(m - k); ++i) p.push_back(0);
for (long long i = 0; i < (long long)(k); ++i) p.push_back(1);
do {
long long sum = 0, mask = 0;
for (long long i = 0; i < (long long)(m); ++i) {
if (p[i]) sum += a[i], mask |= (1 << i);
}
if (mp[sum]) {
long long mask2 = mp[sum], com = mask & mask2;
mask ^= com, mask2 ^= com;
solve2(mask, mask2);
return 0;
}
mp[sum] = mask;
} while (next_permutation(begin(p), end(p)));
cout << "NO\n";
return 0;
}
if (n == 3) {
if ((a[0] + a[1] + a[2]) % 2) {
cout << "NO";
return 0;
}
cout << "YES\n";
long long x = a[0] + a[1] - a[2];
x /= 2;
cout << x << " " << a[0] - x << " " << a[1] - x;
return 0;
}
cout << "NO\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
set<pair<pair<int, int>, int> > st;
pair<int, int> s[300005];
void init() { scanf("%d", &n); }
vector<pair<pair<int, int>, int> > v, t;
vector<int> ans;
set<pair<int, int> > aset;
void process() {
st.insert(pair<pair<int, int>, int>(pair<int, int>(0, 100000), -1));
st.insert(pair<pair<int, int>, int>(pair<int, int>(100000, 0), -1));
int a, b;
for (int i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
s[i] = pair<int, int>(a, b);
auto ptr =
st.lower_bound(pair<pair<int, int>, int>(pair<int, int>(a, b), 100000));
ptr--;
while (ptr != st.begin() && ptr->first.second <= b) {
auto tmp = ptr;
ptr--;
st.erase(tmp);
}
ptr++;
if (ptr->first.second >= b) continue;
st.insert(pair<pair<int, int>, int>(pair<int, int>(a, b), i + 1));
}
for (__typeof((st).begin()) it = (st).begin(); it != (st).end(); it++) {
if (it->second != -1) v.push_back(*it);
}
for (int i = 0; i < (int)v.size(); i++) {
pair<int, int> tmp = v[i].first;
while (t.size() >= 2) {
pair<int, int> t0 = t[t.size() - 1].first, t1 = t[t.size() - 2].first;
if ((long long)t1.first * (t0.second - t1.second) *
(t0.first * tmp.second - tmp.first * t0.second) >
(long long)tmp.first * (tmp.second - t0.second) *
(t1.first * t0.second - t0.first * t1.second))
t.pop_back();
else
break;
}
t.push_back(v[i]);
}
for (__typeof((t).begin()) it = (t).begin(); it != (t).end(); it++)
aset.insert(it->first);
for (int i = 0; i < n; i++) {
if (aset.count(s[i])) printf("%d ", i + 1);
}
puts("");
}
int main() {
init();
process();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9223372036854775807;
const long long N = 500005;
const long long mod = 1e9 + 7;
void start();
struct p {
long long a, b;
};
bool comp1(p p1, p p2) {
if (p1.a < p2.a) {
return true;
}
if (p1.a == p2.a) {
return (p1.b < p2.b);
}
};
struct CompareHeight {
bool operator()(struct p const& p1, struct p const& p2) {
return p1.a < p2.a;
}
};
long long vis[N], weight[N];
long long a[N], ans;
void dfs(long long node, long long target, long long m,
vector<pair<long long, long long> > adj[]) {
vis[node] = 1;
for (long long i = 0; i <= adj[node].size() - 1; i++) {
long long child = adj[node][i].first;
long long w = adj[node][i].second;
if (vis[child] == 1) {
continue;
}
vis[child] = 1;
weight[child] = weight[node] + w;
dfs(child, target, m + w, adj);
}
}
long long x;
void solve() {
long long n, m, o, p, q, r, t;
string second;
cin >> n;
cin >> second;
long long c = 0;
for (long long(i) = 0; (i) <= (n - 1); (i) += (1)) {
if (i + 1 < n && second[i] == '1' && second[i + 1] == '0') {
c++;
i++;
}
}
long long ans = c;
c = 0;
for (long long(i) = 0; (i) <= (n - 1); (i) += (1)) {
if (i + 1 < n && second[i] == '0' && second[i + 1] == '1') {
c++;
}
}
ans = max(ans, c);
n = n - 2 * ans;
cout << n / 2 << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
start();
long long query;
cin >> query;
while (query--) {
x++;
solve();
}
}
void start() {}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
struct fenwickTree {
int tree[MAXN];
fenwickTree() { this->Init(); }
void Init() { memset(this->tree, 0, sizeof(this->tree)); }
void update(int index, int value) {
index++;
while (index < MAXN) {
this->tree[index] += value;
index += index & (-index);
}
}
int query(int index) {
index++;
int sum = 0;
while (index > 0) {
sum += this->tree[index];
index -= index & (-index);
}
return sum;
}
int query(int l, int r) { return query(r) - query(l - 1); }
};
fenwickTree *T = new fenwickTree();
int n, m;
int parent[MAXN];
bool isWish[MAXN];
int treeSize[MAXN];
vector<int> graph[MAXN];
int dfsOrderIndex = 0;
int dfsOrder[MAXN];
int topSortIndex = 0;
int topSort[MAXN];
set<int> allWishes;
vector<int> wish2Nodes[MAXN];
bool fail = false;
vector<pair<int, int>> answer;
void DFSInit(int x) {
dfsOrder[x] = dfsOrderIndex;
dfsOrderIndex++;
treeSize[x] = 1;
for (int y : graph[x]) {
DFSInit(y);
treeSize[x] += treeSize[y];
}
topSort[x] = topSortIndex;
topSortIndex++;
}
void DFS(int x) {
if (isWish[x] == true &&
T->query(dfsOrder[x], dfsOrder[x] + treeSize[x] - 1) != 0) {
fail = true;
}
for (int u : wish2Nodes[x]) {
T->update(dfsOrder[u], 1);
}
for (int y : graph[x]) {
DFS(y);
}
for (int u : wish2Nodes[x]) {
T->update(dfsOrder[u], -1);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int p, q;
cin >> p >> q;
parent[q] = p;
graph[p].push_back(q);
}
for (int i = 1; i <= n; i++) {
if (parent[i] == 0) {
DFSInit(i);
}
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
isWish[x] = true;
allWishes.insert(x);
wish2Nodes[x].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (parent[i] == 0) {
DFS(i);
}
}
if (fail == true) {
cout << "-1" << '\n';
return 0;
}
for (auto it = allWishes.begin(); it != allWishes.end(); it++) {
answer.push_back({topSort[*it], *it});
}
sort(answer.begin(), answer.end());
cout << answer.size() << '\n';
for (int i = 0; i < answer.size(); i++) {
cout << answer[i].second << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100001;
const long long MOD = 1000000007;
const long long INF = LLONG_MAX;
long long bigmod(long long base, long long p) {
long long res = 1;
while (p) {
if (p & 1) res = (res * base) % MOD;
p >>= 1;
base = (base * base) % MOD;
}
return res;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int tc = 1, cs = 0;
while (tc--) {
long long n, i;
cin >> n;
cout << (bigmod(3, 3 * n) - bigmod(7, n) + MOD) % MOD << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 100;
const long long INF = 9 * (long long)(1e18);
const long double PI = 3.14159265358979323846;
long long int modexp(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
if (y == 0)
return 1;
else if (x == 0)
return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res % p;
}
vector<long long int> is_prime(N + 1, 1);
void sieve(long long int n) {
for (long long int i = 1; i <= n; i++) is_prime[i] = i;
for (long long int i = 2; i * i <= n; i++) {
if (is_prime[i] == i) {
for (long long int j = i * i; j <= n; j += i)
is_prime[j] = min(i, is_prime[j]);
}
}
}
string rem(string s, int flag) {
reverse((s).begin(), (s).end());
long long int n = s.length();
long long int idx = 0;
if (n == 0) {
if (flag)
return "0";
else
return s;
} else {
while (s[idx] == '0') idx++;
if (idx == n)
return "0";
else
return s.substr(idx);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
long long int n = s.length();
long long int sum = 0;
int flag = 0;
for (long long int i = 0; i <= n - 1; i++) {
sum += s[i] - '0';
if (s[i] == '0') flag = 1;
}
if (sum % 3 == 0) {
cout << s << "\n";
return 0;
} else {
long long int md = sum % 3;
int f = 0, f2 = 0;
string s1, s2;
for (long long int i = n - 1; i >= 0; i--) {
int num = s[i] - '0';
if (num % 3 != md)
s1 += s[i];
else {
if (f)
s1 += s[i];
else
f = 1;
}
if (num % 3 != 3 - md)
s2 += s[i];
else {
if (f2 == 2)
s2 += s[i];
else
f2++;
}
}
if (f != 1) s1.clear();
if (f2 != 2) s2.clear();
s1 = rem(s1, flag);
s2 = rem(s2, flag);
long long int n1 = s1.length(), n2 = s2.length();
if (n1 || n2) {
if (n1 >= n2)
cout << s1 << "\n";
else
cout << s2 << "\n";
} else
cout << "-1"
<< "\n";
}
}
| 6 |
#include <bits/stdc++.h>
long long fun(long long x) {
x++;
while (!(x % 10)) x /= 10;
return x;
}
int main() {
long long x, i;
scanf("%lld", &x);
if (x < 10) {
printf("9");
return 0;
}
for (i = 0;; i++) {
x = fun(x);
if (x < 10) {
i += 10;
break;
}
}
printf("%lld", i);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
long long s = 0, x = 0;
for (long long y : a) {
s += y;
x ^= y;
}
vector<long long> ans;
long long large = 1ll << 50;
if (s % 2) large++;
s += large;
x ^= large;
ans.push_back(large);
if (s < 2 * x) {
long long d = 2 * x - s;
ans.push_back(d / 2);
ans.push_back(d / 2);
}
cout << ans.size() << "\n";
for (long long x : ans) cout << x << " ";
cout << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed;
long long tc = 1;
cin >> tc;
while (tc--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
int compare(const void *a, const void *b) {
int ia = *(int *)a;
int ib = *(int *)b;
return ia - ib;
}
int main() {
int i, j, n, k, q, same, cnt, min, max, sum;
static int aa[100], used[100];
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) scanf("%d", &aa[i]);
scanf("%d", &q);
max = 0;
min = INT_MAX;
cnt = 0;
while (q-- > 0) {
sum = 0;
same = 1;
for (i = 0; i < n / k; i++) {
scanf("%d", &j);
j--;
if (!used[j]) {
same = 0;
used[j] = 1;
sum += aa[j];
}
}
if (!same) {
cnt++;
if (max < sum) max = sum;
if (min > sum) min = sum;
}
}
j = 0;
for (i = 0; i < n; i++)
if (!used[i]) aa[j++] = aa[i];
if (cnt < k) {
qsort(aa, j, sizeof(*aa), compare);
sum = 0;
for (i = 0; i < n / k; i++) sum += aa[i];
if (min > sum) min = sum;
sum = 0;
for (i = j - n / k; i < j; i++) sum += aa[i];
if (max < sum) max = sum;
}
printf("%.10lf %.10lf\n", (double)min / (n / k), (double)max / (n / k));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct art {
int t, d, p, id;
} a[101];
pair<int, int> go[101][2001];
bool cmp(art xx, art yy) { return xx.d < yy.d; }
int f[101][2001], num[101][2001], ans[1000], tt;
int main() {
int n;
cin >> n;
for (register int i = 1; i <= n; i++)
cin >> a[i].t >> a[i].d >> a[i].p, a[i].id = i;
sort(a + 1, a + n + 1, cmp);
for (register int i = 1; i <= n; i++)
for (register int k = 1; k <= 2000; k++) {
if (k <= a[i].d && k - a[i].t > 0) {
f[i][k] = f[i - 1][k - a[i].t] + a[i].p,
go[i][k] = make_pair(i - 1, k - a[i].t), num[i][k] = i;
}
if (f[i][k - 1] > f[i][k]) {
f[i][k] = f[i][k - 1];
go[i][k] = make_pair(i, k - 1), num[i][k] = -1;
}
if (f[i - 1][k] > f[i][k]) {
f[i][k] = f[i - 1][k];
go[i][k] = make_pair(i - 1, k), num[i][k] = -1;
;
}
}
cout << f[n][2000] << endl;
int n1 = n, n2 = 2000;
while (go[n1][n2].first) {
if (num[n1][n2] != -1) ans[++tt] = a[num[n1][n2]].id;
pair<int, int> cur = go[n1][n2];
n1 = cur.first;
n2 = cur.second;
}
if (num[n1][n2] != -1 && num[n1][n2] != 0) ans[++tt] = a[num[n1][n2]].id;
cout << tt << endl;
for (register int i = tt; i; i--) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int u[4] = {0, 0, -1, 1};
int v[4] = {-1, 1, 0, 0};
int n, m, c;
string a[55];
int bio[55][55];
void dfs(int x, int y, int prevx, int prevy) {
bio[x][y] = 1;
for (int i = 0; i < 4; i++) {
int nx = x + u[i];
int ny = y + v[i];
if (nx < 0 || ny < 0 || nx >= n || ny >= m || a[nx][ny] != a[x][y])
continue;
if (bio[nx][ny] && (prevx != nx || prevy != ny)) c = 1;
if (!bio[nx][ny]) dfs(nx, ny, x, y);
}
}
int main(void) {
std::ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
memset(bio, 0, sizeof bio);
dfs(i, j, -1, -1);
if (c) break;
}
if (c)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int h1[100110], h2[100110], h[100110];
int n;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> h[i];
int ans = 0;
h1[0] = 0;
for (int i = 1; i <= n; ++i) h1[i] = min(h[i], h1[i - 1] + 1);
h2[n + 1] = 0;
for (int i = n; i >= 1; --i) h2[i] = min(h[i], h2[i + 1] + 1);
for (int i = 1; i <= n; ++i) ans = max(ans, min(h1[i], h2[i]));
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int max = 0;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (a[i] >= max + 1) max++;
}
cout << max + 1 << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n++;
vector<int> x(n), y(n);
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
int way = 1;
int ans = 0;
for (int i = 2; i < n; i++) {
if (x[i] == x[i - 1]) {
if (y[i] > y[i - 1]) {
if (way == 2) ans++;
way = 1;
} else {
if (way == -2) ans++;
way = -1;
}
}
if (y[i] == y[i - 1]) {
if (x[i] > x[i - 1]) {
if (way == -1) ans++;
way = 2;
} else {
if (way == 1) ans++;
way = -2;
}
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long n, m;
long a, b;
long gcd(int a, int b) {
int c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
int main() {
cin >> m >> n;
cout << (5 + 6 * m - 6) * n << endl;
cout << 1 * n << ' ' << 2 * n << ' ' << 3 * n << ' ' << 5 * n << endl;
long pizd = 4, t = 7;
for (int k = 1; k <= m - 1; ++k) {
while (gcd(pizd, t) != 1 || gcd(pizd, t + 2) != 1 || gcd(pizd, t + 4) != 1)
pizd += 2;
cout << n * pizd << ' ' << n * t << ' ' << n * (t + 2) << ' ' << n * (t + 4)
<< endl;
pizd += 2;
t += 6;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int MOD = 1E9 + 7;
const long long N = 3e5 + 15;
const int maxn = 5e5 + 15;
const int letter = 130;
const int INF = 1e17;
const double pi = acos(-1.0);
const double eps = 1e-10;
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, k, a[N];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
int max1 = 0, maxid = 0;
int l = 1, r = 0, cnt = 0;
while (l <= n && r <= n) {
r++;
while (r <= n && cnt <= k) {
if (a[r] == 0 && cnt == k) {
break;
}
if (a[r] == 0) cnt++;
r++;
}
r--;
if (r - l + 1 > max1) max1 = r - l + 1, maxid = l;
if (a[l] == 0) cnt--;
l++;
}
printf("%d\n", max1);
if (max1 == 0) {
for (int i = 1; i <= n; i++) printf("0 ");
printf("\n");
return 0;
}
for (int i = 1; i < maxid; i++) printf("%d ", a[i]);
for (int i = maxid; i < maxid + max1; i++) printf("1 ");
for (int i = maxid + max1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int moves[][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
class Point {
public:
Point() {}
Point(double x, double y) {
this->x = x;
this->y = y;
}
double dist(Point p) {
double x = p.x - this->x;
double y = p.y - this->y;
return sqrt(x * x + y * y);
}
bool operator==(Point a) { return a.x == this->x && a.y == this->y; }
void read() { scanf("%lf%lf", &x, &y); }
void print() {
if (fabs(y) < 1e-5) y = 0.0;
if (fabs(x) < 1e-5) x = 0.0;
printf("%.5lf %.5lf\n", x, y);
}
double x, y;
};
class Circle {
public:
Circle() {}
Circle(Point c, double r) {
this->c = c;
this->r = r;
}
bool intersects(Circle k, Point &T1, Point &T2) {
double q2 = k.c.y, q1 = this->c.y;
double p2 = k.c.x, p1 = this->c.x;
double r2 = k.r, r1 = this->r;
double A = 2 * (q2 - q1);
double B = 2 * (p2 - p1);
double C = p1 * p1 - p2 * p2 + q1 * q1 - q2 * q2 + r2 * r2 - r1 * r1;
double AA = A * A + B * B;
double BB = 2 * A * C + 2 * A * p2 * B - 2 * q2 * B * B;
double CC = B * B * q2 * q2 - r2 * r2 * B * B + (C + p2 * B) * (C + p2 * B);
double D = BB * BB - 4 * AA * CC;
if (D < -1e-5) {
return false;
}
if (D < 1e-5) {
T1.y = -BB * .5 / AA;
T1.x = -(C + A * T1.y) / B;
T2 = T1;
} else {
double sqroot = sqrt(D);
T1.y = (-BB + sqroot) / (2.0 * AA);
T1.x = -(C + A * T1.y) / B;
T2.y = (-BB - sqroot) / (2.0 * AA);
T2.x = -(C + A * T2.y) / B;
}
return true;
}
bool contains(Point P) {
double X = P.x - c.x;
X *= X;
double Y = P.y - c.y;
Y *= Y;
return fabs(X + Y - r * r) < 1e-5;
}
void read() {
c.read();
scanf("%lf", &r);
}
Point c;
double r;
};
class Line {
public:
Line() {}
Line(double A, double B, double C) {
this->A = A;
this->B = B;
this->C = C;
}
Line(Point a, Point b) {
double x1 = a.x, x2 = b.x;
double y1 = a.y, y2 = b.y;
A = y1 - y2;
B = x2 - x1;
C = x1 * y2 - y1 * x2;
}
Line normalna(Point p) {
double D = B * p.x - A * p.y;
Line L(-B, A, D);
return L;
}
int intersects(Line p, Point &T) {
double det = A * p.B - B * p.A;
if (fabs(det) < 1e-5) return 0;
T.x = B * p.C - p.B * C;
T.x /= det;
T.y = p.A * C - p.C * A;
T.y /= det;
return 1;
}
bool intersects(Circle k, Point &T1, Point &T2) {
double p = k.c.x, q = k.c.y;
double r = k.r;
if (fabs(A) < 1e-5) {
T1.y = -C / B;
double BB = -2 * p;
double CC = (T1.y - q) * (T1.y - q) - r * r + p * p;
double D = BB * BB - 4 * CC;
if (D < -1e-5) {
return false;
} else if (D < 1e-5) {
double sqroot = sqrt(D);
T1.x = -BB * 0.5;
T2 = T1;
return true;
} else {
double sqroot = sqrt(D);
T1.x = (-BB - sqroot) * 0.5;
T2.x = (-BB + sqroot) * 0.5;
T2.y = T1.y;
return true;
}
}
double AA = B * B / (A * A) + 1;
double BB = 2 * B * C / (A * A) + 2 * B * p / A - 2 * q;
double CC = C * C / (A * A) + 2 * C * p / A + p * p + q * q - r * r;
double D = BB * BB - 4 * AA * CC;
if (D < -1e-5) {
return false;
} else if (D < 1e-5) {
T1.y = -BB / (2 * AA);
T1.x = -(C + B * T1.y) / A;
T2 = T1;
return true;
} else {
double sqroot = sqrt(D);
T1.y = (-BB + sqroot) / (2 * AA);
T1.x = -(C + B * T1.y) / A;
T2.y = (-BB - sqroot) / (2 * AA);
T2.x = -(C + B * T2.y) / A;
return true;
}
}
double A, B, C;
};
Circle makeCircle(Circle k1, Circle k2) {
double A = k2.r * k2.r - k1.r * k1.r;
double B = 2 * (k2.c.x * k1.r * k1.r - k1.c.x * k2.r * k2.r) / A;
double C = 2 * (k2.c.y * k1.r * k1.r - k1.c.y * k2.r * k2.r) / A;
double D = (k2.r * k2.r * k1.c.x * k1.c.x - k1.r * k1.r * k2.c.x * k2.c.x +
k2.r * k2.r * k1.c.y * k1.c.y - k1.r * k1.r * k2.c.y * k2.c.y) /
A;
double R = sqrt((B * B + C * C) * 0.25 - D);
return Circle(Point(-B * 0.5, -C * 0.5), R);
}
Line makeLine(Circle k1, Circle k2) {
Point m;
m.x = (k1.c.x + k2.c.x) * 0.5;
m.y = (k1.c.y + k2.c.y) * 0.5;
Line l(k1.c, k2.c);
return l.normalna(m);
}
Point getBetter(Point A, Point B, Circle k) {
double alpha1 = asin(k.r / A.dist(k.c));
double alpha2 = asin(k.r / B.dist(k.c));
if (alpha1 > alpha2) return A;
return B;
}
int main() {
Circle k[4];
for (int i = 1; i <= 3; i++) {
k[i].read();
}
if (k[1].r == k[2].r) {
Line l1 = makeLine(k[1], k[2]);
if (k[2].r == k[3].r) {
Line l2 = makeLine(k[2], k[3]);
Point T;
if (l1.intersects(l2, T)) {
T.print();
}
} else {
Circle k1 = makeCircle(k[2], k[3]);
Point T1, T2;
if (l1.intersects(k1, T1, T2)) {
getBetter(T1, T2, k[1]).print();
}
}
} else {
Circle k1 = makeCircle(k[1], k[2]);
if (k[2].r == k[3].r) {
Line l1 = makeLine(k[2], k[3]);
Point T1, T2;
if (l1.intersects(k1, T1, T2)) {
getBetter(T1, T2, k[1]).print();
}
} else {
Circle k2 = makeCircle(k[2], k[3]);
Point T1, T2;
if (k2.intersects(k1, T1, T2)) {
getBetter(T1, T2, k[1]).print();
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int t = 0;
int a[100100];
int n, m, o, q, v, x, y;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= m; i++) {
cin >> o;
if (o == 3) {
cin >> q;
cout << a[q] + t << endl;
}
if (o == 2) {
cin >> y;
t += y;
}
if (o == 1) {
cin >> v >> x;
a[v] = x - t;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mx(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long mn(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long cei(long long a, long long b) {
if (a % b == 0)
return a / b;
else
return (a / b + 1);
}
const int MOD = 1e9 + 7;
long long po(long long a, long long b) {
long long res = 1;
while (b > 0) {
res = (res * a);
res %= MOD;
b--;
}
return res;
}
long long ab(long long a, long long b) {
if (a > b)
return a - b;
else
return b - a;
}
int main() {
int n, x;
cin >> n >> x;
vector<pair<int, pair<int, pair<int, int>>>> v;
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
v.push_back(make_pair(c, make_pair(b, make_pair(a, a))));
}
sort(v.begin(), v.end());
long long sum = x;
int count = 0;
int p = 0;
int ans = 0;
for (int i = 0; i <= v.size(); i++) {
for (int j = v.size() - 1; j >= 0; j--) {
if (v[j].second.first <= sum && v[j].second.second.first != -1 &&
p != v[j].second.second.first) {
sum += v[j].first;
count++;
p = v[j].second.second.first;
v[j].second.second.first = -1;
break;
}
}
}
ans = count;
count = 0;
p = 1;
sum = x;
for (int i = 0; i <= v.size(); i++) {
for (int j = v.size() - 1; j >= 0; j--) {
if (v[j].second.first <= sum && v[j].second.second.second != -1 &&
p != v[j].second.second.second) {
sum += v[j].first;
count++;
p = v[j].second.second.second;
v[j].second.second.second = -1;
break;
}
}
}
if (count > ans) ans = count;
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int v[1100][1100];
int main() {
int n, k;
cin >> n >> k;
if (n > k + k) {
cout << n * k << endl;
for (int i = 1; i <= n; i++) {
int t = k;
for (int j = 1; j <= n; j++)
if (i != j && !v[i][j] && !v[j][i] && t) {
t--;
v[i][j] = v[j][i] = 1;
printf("%d %d\n", i, j);
}
}
} else
printf("-1\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
std::vector<string> v(n);
for (long long int i = 0; i < n; i++) {
cin >> v[i];
}
if (n > 3) {
cout << "-1\n";
return 0;
}
if (n == 1) {
cout << "0\n";
return 0;
}
std::vector<std::vector<int>> possible(1 << n);
for (long long int i = 0; i < (1 << n); i++) {
for (long long int j = 0; j < (1 << n); j++) {
bool poss = true;
for (long long int k = 0; k < n - 1; k++) {
bool chk = 0;
chk = chk ^ (bool)((1 << k) & j);
chk = chk ^ (bool)(1 << (k + 1) & j);
chk = chk ^ (bool)((1 << k) & i);
chk = chk ^ (bool)(1 << (k + 1) & i);
if (!chk) {
poss = false;
break;
}
}
if (poss) possible[i].push_back(j);
}
}
int dp[(1 << n)][m];
for (long long int i = 0; i < 1 << n; i++) {
for (long long int j = 0; j < m; j++) {
dp[i][j] = INT_MAX;
}
}
for (long long int i = 0; i < 1 << n; i++) {
int cur = 0;
for (long long int k = 0; k < n; k++) {
cur += (bool)(v[k][0] - '0') ^ (bool)(i & 1 << k);
}
dp[i][0] = cur;
}
for (long long int i = 0; i < m - 1; i++) {
for (long long int j = 0; j < 1 << n; j++) {
int cur = 0;
for (long long int k = 0; k < n; k++) {
cur += (bool)(v[k][i + 1] - '0') ^ (bool)(j & 1 << k);
}
for (auto x : possible[j]) {
dp[j][i + 1] = min(dp[x][i] + cur, dp[j][i + 1]);
}
}
}
int ans = INT_MAX;
for (long long int i = 0; i < 1 << n; i++) {
ans = min(ans, dp[i][m - 1]);
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x20202020;
const int mod = 1000000007;
template <class T>
inline void read(T &first) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (first = 0; c > 32; c = getchar()) first = first * 10 + c - '0';
if (fu) first = -first;
};
template <class T>
inline void read(T &first, T &second) {
read(first);
read(second);
}
template <class T>
inline void read(T &first, T &second, T &z) {
read(first);
read(second);
read(z);
}
template <class T>
inline void read(T &first, T &second, T &z, T &q) {
read(first);
read(second);
read(z);
read(q);
}
const int DX[] = {1, 0, -1, 0}, DY[] = {0, 1, 0, -1};
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;
}
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int N = 111111, M = 111111;
int l, m, n, t, C, p, b, tot;
int a[N], c[N], d[N], f[N];
inline bool cmp(const int &a, const int &b) { return a > b; }
int main() {
scanf("%d%d%d", &n, &m, &p);
b = p - 1;
for (int i = (1); i <= (n); ++i) scanf("%d", &a[i]);
for (int i = (1); i <= (m); ++i) scanf("%d", &t), b = gcd(b, t);
for (int i = 1; i * i <= p - 1; ++i)
if ((p - 1) % i == 0) {
c[++tot] = i;
if (i * i != p - 1) c[++tot] = (p - 1) / i;
}
sort(c + 1, c + 1 + tot);
for (int i = (1); i <= (n); ++i) {
a[i] = powmod(a[i], b, p);
for (int j = (1); j <= (tot); ++j)
if (powmod(a[i], c[j], p) == 1) {
d[i] = (p - 1) / c[j];
break;
}
}
sort(d + 1, d + 1 + n, cmp);
n = unique(d + 1, d + 1 + n) - d - 1;
int ans = 0;
for (int i = (1); i <= (n); ++i) {
f[i] = (p - 1) / d[i];
for (int j = (1); j <= (i - 1); ++j)
if (d[j] % d[i] == 0) f[i] -= f[j];
ans += f[i];
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
#include <queue>
#include <functional>
using namespace std;
typedef long long ll;
using pii = pair<int, int>;
const int inf = 0x3f3f3f3f;
const vector<pii> direction = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, w;
cin >> n >> m >> w;
vector<vector<int>> g(n, vector<int>(m));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
cin >> g[i][j];
auto bfs = [&](pii start) {
queue<pii> q;
q.push(start);
vector<vector<int>> d(n, vector<int>(m, inf));
d[start.first][start.second] = 0;
while(!q.empty())
{
auto f = q.front();
q.pop();
for(const auto&[dx, dy] : direction)
{
int tx = f.first + dx;
int ty = f.second + dy;
if(tx < 0 || tx >=n || ty<0 || ty>=m)
continue;
if(d[tx][ty] != inf || g[tx][ty] == -1)
continue;
d[tx][ty] = d[f.first][f.second] + 1;
q.push({tx, ty});
}
}
return d;
};
auto d1 = bfs({0, 0});
auto d2 = bfs({n - 1, m - 1});
ll ans = 1e18;
if(d1[n - 1][m - 1] != inf)
ans = 1LL * d1[n - 1][m - 1] * w;
ll dd1 = 1e18;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if(g[i][j] > 0 && d1[i][j] != inf)
dd1 = min(dd1, g[i][j] + 1LL * d1[i][j] * w);
ll dd2 = 1e18;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if(g[i][j] > 0 && d2[i][j] != inf)
dd2 = min(dd2, g[i][j] + 1LL * d2[i][j] * w);
ans = min(ans, dd1 + dd2);
if(ans == 1e18)
ans = -1;
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int dp1[500000 + 5];
int dp2[500000 + 5];
int dp3[500000 + 5];
int n, a, b, T;
char s[500000 + 5];
int main() {
while (~scanf("%d%d%d%d", &n, &a, &b, &T)) {
scanf("%s", s);
memset(dp1, 0, sizeof(dp1));
memset(dp2, 0, sizeof(dp2));
memset(dp3, 0, sizeof(dp3));
if (s[0] == 'w')
dp1[0] = dp2[0] = b + 1;
else
dp1[0] = dp2[0] = 1;
dp3[0] = dp1[0];
if (dp1[0] > T) {
cout << 0 << endl;
continue;
}
for (int i = 1; i < n; i++) {
dp1[i] = dp1[i - 1] + 1 + a;
if (s[i] == 'w') dp1[i] += b;
}
if (dp1[n - 1] <= T) {
cout << n << endl;
continue;
}
int pp = 1;
for (int i = n - 1; i > 0; i--) {
dp2[i] = dp2[(i + 1) % n] + 1 + a;
if (s[i] == 'w') dp2[i] += b;
dp3[pp++] = dp2[i];
}
int ans = 0;
int cnt = 0;
for (int i = 0;; i = (i - 1 + n) % n) {
if (dp2[i] > T) break;
int l = 1, r = (i - 1 + n) % n;
int step = (n - i) % n;
int left = T - a * step - dp2[i] + dp1[0];
int pos = lower_bound(dp1 + l, dp1 + r + 1, left) - dp1;
if (dp1[pos] > left) pos--;
ans = max(ans, step + pos + 1);
if (i == 0) {
cnt++;
if (cnt >= 2) break;
}
}
for (int i = 0; i < n; i++) {
if (dp1[i] > T) break;
int l = 1, r = n - i;
int step = i;
int left = T - a * step - dp1[i] + dp1[0];
int pos = lower_bound(dp3 + l, dp3 + r, left) - dp3;
if (dp3[pos] > left) pos--;
ans = max(ans, step + pos + 1);
}
if (ans > n) ans = n;
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
constexpr int mxn = 1e5;
int n, a, b, max_child[mxn][3], max_parent[mxn];
bool can_turn[mxn];
vector<int> adj[mxn], body;
int dfs1(int u, int p = -1) {
if (~p && (int)adj[u].size() < 2) return max_child[u][0] = 1;
for (int v : adj[u])
if (v != p) {
int len = dfs1(v, u) + 1;
if (len > max_child[u][0]) {
max_child[u][2] = max_child[u][1];
max_child[u][1] = max_child[u][0];
max_child[u][0] = len;
} else if (len > max_child[u][1]) {
max_child[u][2] = max_child[u][1];
max_child[u][1] = len;
} else if (len > max_child[u][2]) {
max_child[u][2] = len;
}
}
return max_child[u][0];
}
bool dfs2(int u, int p = -1, int mxp = 0) {
max_parent[u] = mxp + 1;
int ch[2][2] = {{-1, -2}, {-1, -3}};
for (int v : adj[u])
if (v != p) {
if (max_child[v][0] + 1 > ch[0][1]) {
ch[1][0] = ch[0][0];
ch[1][1] = ch[0][1];
ch[0][0] = v;
ch[0][1] = max_child[v][0] + 1;
} else if (max_child[v][0] + 1 > ch[1][1]) {
ch[1][0] = v;
ch[1][1] = max_child[v][0] + 1;
}
}
bool is_body = (u == b);
for (int v : adj[u])
if (v != p) {
if (v == ch[0][0]) {
is_body |= dfs2(v, u, max(max_parent[u], ch[1][1]));
} else {
is_body |= dfs2(v, u, max(max_parent[u], ch[0][1]));
}
}
if (is_body) body.push_back(u);
return is_body;
}
pair<int, bool> dfs3(int u, int p) {
if ((int)adj[u].size() < 2) return make_pair(1, can_turn[u]);
int mx = 0, ok = can_turn[u];
for (int v : adj[u])
if (v != p) {
pair<int, bool> pr = dfs3(v, u);
mx = max(mx, pr.first);
ok |= pr.second;
}
return make_pair(mx + 1, ok);
}
void solve() {
cin >> n >> a >> b;
--a, --b;
body.clear();
memset(can_turn, 0, n);
memset(max_child, -1, 12 * n);
memset(max_parent, -1, 4 * n);
for (int i = 0; i < n; i++) adj[i].clear();
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);
}
dfs1(a);
dfs2(a);
int body_length = body.size();
bool ok_3 = false;
for (int i = 0; i < n; i++) {
int cnt = (int)(max_parent[i] >= body_length);
cnt += (int)(max_child[i][0] >= body_length);
cnt += (int)(max_child[i][1] >= body_length);
cnt += (int)(max_child[i][2] >= body_length);
if (cnt >= 3) {
can_turn[i] = true;
ok_3 = true;
}
}
if (!ok_3) {
cout << "NO\n";
return;
}
vector<int> subtree(body_length);
for (int i = 0; i < body_length; i++) {
int pre = i > 0 ? body[i - 1] : -1;
int nxt = i + 1 < body_length ? body[i + 1] : -1;
for (int v : adj[body[i]]) {
if (v == pre || v == nxt) continue;
auto [len, has_turn] = dfs3(v, body[i]);
subtree[i] = max(subtree[i], len);
can_turn[body[i]] |= has_turn;
}
}
int l = 0, r = body_length - 1;
int lmax = subtree[r], rmin = r - subtree[l];
bool ok = can_turn[body[l]] || can_turn[body[r]];
while ((l < lmax || rmin < r) && l < r) {
if (l < lmax) l++, rmin = min(rmin, l + (body_length - 1 - subtree[l]));
if (rmin < r) r--, lmax = max(lmax, r - (body_length - 1 - subtree[r]));
if (can_turn[body[l]] || can_turn[body[r]]) {
ok = true;
break;
}
}
cout << (ok ? "YES\n" : "NO\n");
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt = 1;
cin >> tt;
while (tt--) solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e6 + 8;
const long long MOD = 1e9 + 7;
const long long sz = 1e5 + 5;
void f_io() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
}
long long power(long long a, long long b) {
if (!b) return 1;
if (b == 1) return a;
if (b & 1) return (power(a, b - 1) * a) % MOD;
long long q = power(a, b / 2);
return (q * q) % MOD;
}
map<long long, long long> F;
long long f(long long N) {
if (N == 1) return 1;
if (F.find(N) != F.end()) return F[N];
long long ret = power(2, N - 1) - 1;
for (long long i = 2; i * i <= N; i++) {
if (!(N % i)) {
ret -= f(i);
ret += MOD;
ret %= MOD;
if (i * i != N) {
ret -= f(N / i);
ret += MOD;
ret %= MOD;
}
}
}
return (F[N] = (1ll * ret + MOD) % MOD);
}
int32_t main() {
f_io();
long long tc = 1;
while (tc--) {
long long n, m;
cin >> n >> m;
if (m % n) return 0 * printf("0\n");
cout << f(m / n) << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define BUFF ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define rep(i,a,n) for(int i=a;i<=n;++i)
#define per(i,n,a) for(int i=n;i>=a;--i)
#define ll long long
inline ll read(){ll f=1;ll x=0;char ch=getchar();while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+ch-'0',ch=getchar();return x*f; }
inline ll quick_pow(ll a,ll b,ll mod) {ll ans=1,base=a;while(b){if(b&1)ans=ans*base%mod;base=base*base%mod;b>>=1;}return ans%mod;}
inline ll inv(ll x,ll p){return quick_pow(x,p-2,p);}
inline ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
inline ll lcm(ll a,ll b){return a*b/gcd(a,b);}
const double pi=acos(-1.0);
const ll inf = LONG_LONG_MAX;
const ll mod = 998244353;
const ll maxn = 2e5 + 10;
int v[maxn], dp[maxn], cnt[maxn];
void solve()
{
int n;
cin>>n;
int maxx = 0;
rep(i,1,n)
{
int tmp;
scanf("%d", &tmp);
v[i] = tmp;
maxx = max(maxx, tmp);
}
rep(i,1,maxx)
{
cnt[i] = 0;
dp[i] = 0;
}
rep(i,1,n)
{
++cnt[v[i]];
}
rep(i,1,maxx)
{
if(!cnt[i])
continue;
dp[i] += cnt[i];
for (int j = 2 * i; j <= maxx; j += i)
{
dp[j] = max(dp[i], dp[j]);
}
}
int res = 0;
rep(i, 1, maxx)
res = max(res, dp[i]);
cout << n - res << '\n';
}
int main()
{
int T;
cin >> T;
while (T--)
{
solve();
}
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int gcdExtended(long long int a, long long int b, long long int *x,
long long int *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
long long int x1, y1;
long long int gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long int mod = 1000000007;
long long int binpower(long long int a, long long int b) {
long long int ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
bool isPrime(int n) {
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0) return false;
}
return true;
}
struct segtree {
int sz;
vector<int> sums;
vector<int> mini;
void init(int n) {
sz = 1;
while (sz < n) {
sz *= 2;
}
sums.resize(2 * sz);
mini.resize(2 * sz);
}
int single(long long int v) { return v; }
int join(int a, int b, bool maxi = false) {
if (maxi)
return max(a, b);
else
return min(a, b);
}
void sett(int i, long long int v, int x, int lx, int rx) {
if (rx - lx == 1) {
sums[x] = single(v);
mini[x] = single(v);
return;
}
int m = (lx + rx) / 2;
if (i < m)
sett(i, v, 2 * x + 1, lx, m);
else
sett(i, v, 2 * x + 2, m, rx);
sums[x] = join(sums[2 * x + 1], sums[2 * x + 2], true);
mini[x] = join(mini[2 * x + 1], mini[2 * x + 2]);
}
void sett(int i, long long int v) { sett(i, v, 0, 0, sz); }
int calc(int l, int r, int x, int lx, int rx) {
if (lx >= r || l >= rx) return INT_MIN;
if (lx >= l && rx <= r) return sums[x];
int m = (lx + rx) / 2;
int s1 = calc(l, r, 2 * x + 1, lx, m);
int s2 = calc(l, r, 2 * x + 2, m, rx);
return join(s1, s2, true);
}
int calcmin(int l, int r, int x, int lx, int rx) {
if (lx >= r || l >= rx) return INT_MAX;
if (lx >= l && rx <= r) return mini[x];
int m = (lx + rx) / 2;
int s1 = calcmin(l, r, 2 * x + 1, lx, m);
int s2 = calcmin(l, r, 2 * x + 2, m, rx);
return join(s1, s2);
}
int calc(int l, int r) { return calc(l, r, 0, 0, sz); }
int calcmin(int l, int r) { return calcmin(l, r, 0, 0, sz); }
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int test = 1;
while (test--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
stack<pair<int, int> > s;
s.push({a[0], n});
int ans = 0;
for (int i = 1; i < n; ++i) {
int p = 0;
while (!s.empty()) {
if (s.top().first < a[i]) {
p = s.top().second + 1;
s.pop();
continue;
}
ans = max(ans, p + 1);
while (!s.empty()) {
if (p != s.top().second) break;
s.pop();
}
s.push({a[i], p});
break;
}
if (s.empty()) s.push({a[i], n});
}
cout << ans;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using ld = long double;
using ll = long long;
using uint = unsigned int;
using ull = unsigned long long;
using namespace std;
using pii = pair<int, int>;
using pld = pair<ld, ld>;
using pll = pair<ll, ll>;
template <class T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using maxpq = priority_queue<T, vector<T>>;
const int INTMAX = 2147483647;
const int INTMIN = -2147483647;
const ll LLMAX = 9223372036854775807;
const ll LLMIN = -9223372036854775807;
const ll MOD = 1000000007;
const ll MOD998 = 998224353;
const ld pi = 3.1415926535897932385;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
template <typename K, typename V>
using umap = unordered_map<K, V, custom_hash>;
template <typename K, typename V>
using umultimap = unordered_multimap<K, V, custom_hash>;
template <typename T>
using uset = unordered_set<T, custom_hash>;
template <typename T>
using umultiset = unordered_multiset<T, custom_hash>;
void open(const string &s) {
string a = s + ".in";
string b = s + ".out";
freopen(a.c_str(), "r", stdin);
freopen(b.c_str(), "w", stdout);
}
template <typename A, typename B>
ostream &operator<<(ostream &out, pair<A, B> const &pair);
template <typename T>
ostream &operator<<(ostream &out, uset<T> const &s);
template <typename T>
ostream &operator<<(ostream &out, set<T> const &s);
template <typename T>
ostream &operator<<(ostream &out, multiset<T> const &s);
template <typename T>
ostream &operator<<(ostream &out, umultiset<T> const &s);
template <typename K, typename V>
ostream &operator<<(ostream &out, multimap<K, V> const &m);
template <typename K, typename V>
ostream &operator<<(ostream &out, umultimap<K, V> const &m);
template <typename T>
ostream &operator<<(ostream &out, vector<T> const &v);
template <typename K, typename V>
ostream &operator<<(ostream &out, map<K, V> const &m);
template <typename K, typename V>
ostream &operator<<(ostream &out, umap<K, V> const &m);
template <typename A, typename B>
ostream &operator<<(ostream &out, pair<A, B> const &pair) {
out << "(" << pair.first << ", " << pair.second;
return out << ")";
}
template <typename T>
ostream &operator<<(ostream &out, uset<T> const &s) {
out << "[";
int c = 0;
for (T i : s) {
if (c) out << ", ";
out << i;
c++;
}
return out << "]";
}
template <typename T>
ostream &operator<<(ostream &out, set<T> const &s) {
out << "[";
int c = 0;
for (T i : s) {
if (c) out << ", ";
out << i;
c++;
}
return out << "]";
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> const &v) {
out << "[";
for (int i = 0; i < v.size(); i++) {
if (i) out << ", ";
out << v[i];
}
return out << "]";
}
template <typename K, typename V>
ostream &operator<<(ostream &out, map<K, V> const &m) {
out << "{";
int c = 0;
for (const auto &pair : m) {
if (c) out << ", ";
out << pair.first << "=" << pair.second;
c++;
}
return out << "}";
}
template <typename K, typename V>
ostream &operator<<(ostream &out, umap<K, V> const &m) {
out << "{";
int c = 0;
for (const auto &pair : m) {
if (c) out << ", ";
out << pair.first << "=" << pair.second;
c++;
}
return out << "}";
}
template <typename T>
ostream &operator<<(ostream &out, multiset<T> const &s) {
out << "[";
int c = 0;
for (T i : s) {
if (c) out << ", ";
out << i;
c++;
}
return out << "]";
}
template <typename T>
ostream &operator<<(ostream &out, umultiset<T> const &s) {
out << "[";
int c = 0;
for (T i : s) {
if (c) out << ", ";
out << i;
c++;
}
return out << "]";
}
template <typename K, typename V>
ostream &operator<<(ostream &out, multimap<K, V> const &m) {
out << "{";
int c = 0;
for (const auto &pair : m) {
if (c) out << ", ";
out << pair.first << "=" << pair.second;
c++;
}
return out << "}";
}
template <typename K, typename V>
ostream &operator<<(ostream &out, umultimap<K, V> const &m) {
out << "{";
int c = 0;
for (const auto &pair : m) {
if (c) out << ", ";
out << pair.first << "=" << pair.second;
c++;
}
return out << "}";
}
template <typename T>
void next_vec(vector<T> &vec, int l) {
vec = vector<T>(l);
for (int i = 0; i < l; i++) cin >> vec[i];
}
template <typename A, typename B>
void next_vec(vector<pair<A, B>> &vec, int l) {
vec = vector<pair<A, B>>(l);
for (int i = 0; i < l; i++) {
A a;
B b;
cin >> a >> b;
vec[i].first = a;
vec[i].second = b;
}
}
template <typename T>
void next_graph(vector<vector<T>> &adj, int l) {
adj = vector<vector<int>>(l);
for (int i = 0; i < l; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
}
string join(vector<string> &vec, string &t) {
int l = vec.size();
string s;
for (int i = 0; i < l; i++) {
s += vec[i];
if (i != l - 1) s += t;
}
return s;
}
ll combo(ll n, ll d) {
if (d > n) return 0;
if (d * 2 > n) d = n - d;
if (d == 0) return 1;
ll res = n;
for (ll i = 2; i <= d; i++) {
res *= (n - i + 1);
res /= i;
}
return res;
}
template <typename T>
void shuffle_vec(vector<T> &vec) {
shuffle(vec.begin(), vec.end(), mt19937(random_device()()));
}
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
vector<string> split(const string &str, const string &delim = " ") {
vector<string> tokens;
size_t prev = 0, pos = 0;
do {
pos = str.find(delim, prev);
if (pos == string::npos) pos = str.length();
string token = str.substr(prev, pos - prev);
if (!token.empty()) tokens.push_back(token);
prev = pos + delim.length();
} while (pos < str.length() && prev < str.length());
return tokens;
}
ll pow(ll a, ll b) {
ll c = 1;
for (ll i = 0; i < b; i++) c *= a;
return c;
}
template <typename T>
int binary_search(vector<T> &vec, T &n) {
int l = vec.size();
int left = 0;
int right = l - 1;
while (left != right) {
int mid = (left + right + 1) / 2;
if (vec[mid] > n)
right = mid - 1;
else
left = mid;
}
return vec[left] == n ? left : -1;
}
template <typename T>
vector<ll> prefix(vector<T> &vec) {
int l = vec.size();
assert(l);
vector<ll> pre(l);
pre[0] = vec[0];
for (int i = 1; i < l; i++) pre[i] = pre[i - 1] + vec[i];
return pre;
}
template <typename T>
vector<ll> suffix(vector<T> &vec) {
int l = vec.size();
assert(l);
vector<ll> suf(l);
suf[l - 1] = vec[l - 1];
for (int i = l - 2; i >= 0; i--) suf[i] = suf[i + 1] + vec[i];
return suf;
}
ll bs_lowest(const function<bool(ll)> &f, ll lo, ll hi) {
while (lo < hi) {
ll mid = (lo + hi) / 2;
f(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
ll bs_highest(const function<bool(ll)> &f, ll lo, ll hi) {
ll a = lo;
for (ll i = hi; i >= a; i /= 2) {
while (f(lo + i)) lo += i;
}
return lo;
}
template <typename T>
T min(vector<T> &vec) {
assert(!vec.empty());
T a = vec[0];
for (T &i : vec) a = min(a, i);
return a;
}
template <typename T>
T max(vector<T> &vec) {
assert(!vec.empty());
T a = vec[0];
for (T &i : vec) a = max(a, i);
return a;
}
template <typename T>
ll sum(vector<T> &vec) {
ll sum = 0;
for (T &i : vec) sum += i;
return sum;
}
vector<bool> sieve(int n) {
vector<bool> vec(n + 1, true);
vec[0] = false;
vec[1] = false;
for (int i = 2; i <= n; i++) {
if (vec[i]) {
for (int j = i; j <= n; j += i) vec[i] = false;
}
}
return vec;
}
void solve() {
int l;
cin >> l;
vector<int> vec;
next_vec(vec, l);
vector<umap<int, int>> v(l);
int mex = max(vec);
vector<int> divisor(mex + 1);
for (int i = 2; i <= mex; i++) {
if (!divisor[i]) {
for (int j = i; j <= mex; j += i) divisor[j] = i;
}
}
for (int i = 0; i < l; i++) {
while (vec[i] > 1) {
int j = divisor[vec[i]];
while (vec[i] % j == 0) {
v[i][j]++;
vec[i] /= j;
}
}
}
map<int, vector<int>> m;
for (auto &um : v) {
for (auto &pair : um) {
m[pair.first].push_back(pair.second);
}
}
for (auto &pair : m) sort(pair.second.begin(), pair.second.end());
ll c = 1;
for (auto &pair : m) {
if (pair.second.size() + 2 <= l) continue;
if (pair.second.size() == 1 || pair.second.size() + 1 == l) {
for (int i = 0; i < pair.second[0]; i++) c *= pair.first;
} else {
for (int i = 0; i < pair.second[1]; i++) c *= pair.first;
}
}
cout << c << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int ans[2000005];
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
vector<pair<int, int>> vec;
for (int i = 0; i < n; i++) {
vec.push_back({s[i], i});
}
sort(vec.begin(), vec.end());
bool fail;
for (int mid = '0'; mid <= '9'; mid++) {
for (int i = 0; i < n; i++) ans[i] = 0;
int mx1 = -1, mx2 = -1;
int mxv1 = -1, mxv2 = -1;
fail = false;
for (int i = 0; i < n; i++) {
int val = vec[i].first;
int idx = vec[i].second;
if (val <= mid && !ans[idx] && idx > mx1) {
mx1 = idx;
ans[idx] = 1;
}
}
for (int i = 0; i < n; i++) {
int val = vec[i].first;
int idx = vec[i].second;
if (val >= mid && !ans[idx] && idx > mx2) {
mx2 = idx;
ans[idx] = 2;
}
}
for (int i = 0; i < n; i++) {
int idx = vec[i].second;
if (!ans[idx]) {
fail = true;
}
}
if (!fail) break;
}
if (fail)
cout << "-\n";
else {
for (int i = 0; i < n; i++) cout << ans[i];
cout << "\n";
}
for (int i = 0; i < n; i++) ans[i] = 0;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int tasks[2010], taskd[2010], taskc[2010], n, k;
inline void scanint(int &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
struct data {
int to, cap, cost, flow, rev;
};
vector<data> edge[2010];
data pack(int a, int b, int c, int d, int e) {
data tmp;
tmp.to = a, tmp.cap = b, tmp.cost = c, tmp.flow = d, tmp.rev = e;
return tmp;
}
void addedge(int frm, int to, int cap, int cost) {
edge[frm].push_back(pack(to, cap, cost, 0, edge[to].size()));
edge[to].push_back(pack(frm, 0, -cost, 0, edge[frm].size() - 1));
}
void buildmap() {
for (int i = 1; i <= n; i++) addedge(i, n + i, 1, -taskc[i]);
for (int i = 1; i <= n; i++) {
addedge(0, i, 1, 0);
addedge(n + i, n + n + 1, 1, 0);
for (int j = 1; j <= n; j++)
if (tasks[j] > tasks[i] + taskd[i] - 1) addedge(n + i, j, 1, 0);
}
}
int dist[2010], par[2010], pare[2010], Q[2000000];
bool in[2010];
bool spfa() {
memset(dist, 0x3f, sizeof dist);
memset(in, 0, sizeof in);
dist[0] = 0;
int tail = 0, head = 0;
Q[tail++] = 0;
in[0] = 1;
while (head != tail) {
int cur = Q[head++];
in[cur] = 0;
for (int i = 0; i < edge[cur].size(); i++) {
data tmp = edge[cur][i];
if (tmp.cap > tmp.flow && dist[tmp.to] > dist[cur] + tmp.cost) {
par[tmp.to] = cur;
pare[tmp.to] = i;
dist[tmp.to] = dist[cur] + tmp.cost;
if (!in[tmp.to]) Q[tail++] = (tmp.to), in[tmp.to] = 1;
}
}
}
return (dist[n + n + 1] != dist[2007]);
}
int mcmf() {
int Mcost = 0;
for (int i = 1; i <= k; i++) {
if (!spfa()) break;
for (int cur = n + n + 1; cur != 0; cur = par[cur]) {
edge[par[cur]][pare[cur]].flow++;
edge[cur][edge[par[cur]][pare[cur]].rev].flow--;
Mcost += edge[par[cur]][pare[cur]].cost;
}
}
return -Mcost;
}
int main() {
scanint(n);
scanint(k);
for (int i = 1; i <= n; i++) {
scanint(tasks[i]);
scanint(taskd[i]);
scanint(taskc[i]);
}
buildmap();
mcmf();
for (int i = 1; i <= n; i++)
if (edge[i][0].flow == 1)
putchar('1'), putchar(' ');
else
putchar('0'), putchar(' ');
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<pair<int, int>> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first;
v[i].second = i;
}
string s;
cin >> s;
sort(v.begin(), v.end());
int result = n;
for (int i = n - 1; i >= 0; i--) {
if (s[v[i].second] == '1') {
v[i].first = result;
result--;
}
}
for (int i = n - 1; i >= 0; i--) {
if (s[v[i].second] == '0') {
v[i].first = result;
result--;
}
}
for (int i = n - 1; i >= 0; i--) swap(v[i].first, v[i].second);
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
cout << v[i].second << " ";
}
cout << endl;
}
int main() {
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct P {
int first, second, index;
};
const int Max = 3e5 + 10;
P seg[Max];
bool cmp(P a, P b) {
if (a.first <= b.first) {
if (a.first == b.first)
return a.second > b.second;
else
return 1;
} else
return 0;
}
int main() {
ios::sync_with_stdio(false);
int n, flag = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> seg[i].first >> seg[i].second;
seg[i].index = i + 1;
}
sort(seg, seg + n, cmp);
for (int i = 1; i < n; i++) {
if (seg[i].second <= seg[i - 1].second) {
flag = 1;
cout << seg[i].index << " " << seg[i - 1].index << endl;
break;
}
}
if (!flag) cout << "-1 -1" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int INF = 0x3f3f3f3f;
template <class T>
inline bool RD(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1, ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
template <class T>
inline void PT(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) PT(x / 10);
putchar(x % 10 + '0');
}
int K;
struct node {
int maxn[11], minn[11];
int sz;
bool operator<(const node &a) const {
for (int i = 1; i <= K; i++) {
if (maxn[i] >= a.minn[i]) return false;
}
return true;
}
};
set<node> st;
vector<node> vec;
int main() {
int n;
cin >> n >> K;
node now;
for (int i = 1; i <= n; i++) {
now.sz = 1;
for (int j = 1; j <= K; j++) {
scanf("%d", &now.maxn[j]);
now.minn[j] = now.maxn[j];
}
auto it = st.lower_bound(now);
if (it == st.end()) {
st.insert(now);
} else {
vec.clear();
while (it != st.end() && (now < *it) == false) {
vec.push_back(*it);
for (int i = 1; i <= K; i++) {
now.maxn[i] = max(now.maxn[i], (*it).maxn[i]);
now.minn[i] = min(now.minn[i], (*it).minn[i]);
}
now.sz += (*it).sz;
it++;
}
for (node u : vec) st.erase(u);
st.insert(now);
}
printf("%d\n", st.rbegin()->sz);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= k + 1; i++)
cout << ((i % 2) == 0 ? (k + 1 - i / 2) : (i / 2)) + 1 << " ";
for (int i = k + 2; i <= n; i++) cout << i << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5, L = 18;
int a[MAXN], N, Q;
pair<int, int> t[MAXN][L];
pair<int, int> query(int i, int j) {
j++;
int l = 31 - __builtin_clz(j - i);
return max(t[i][l], t[j - (1 << l)][l]);
}
long long solve(int i, int j) {
if (i > j) return 0;
int k = query(i, j).second;
return 1ll * (k - i + 1) * (j - k + 1) * a[k] + solve(i, k - 1) +
solve(k + 1, j);
}
int main() {
scanf("%d%d", &N, &Q);
for (int i = 0; i < N; i++) scanf("%d", &a[i]);
N--;
for (int i = 0; i < N; i++) {
a[i] = abs(a[i + 1] - a[i]);
t[i][0] = {a[i], i};
}
for (int l = 1; l < L; l++)
for (int i = 0; i < N; i++)
t[i][l] = max(t[i][l - 1], t[i + (1 << (l - 1))][l - 1]);
for (int i, j; Q--;) {
scanf("%d%d", &i, &j);
printf("%I64d\n", solve(i - 1, j - 2));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2000010;
long long A[22][100010], a[maxn], n, m, f[maxn], g[maxn], len;
void FWTxor(long long *A, long long ty) {
for (long long mid = 1; mid < len; mid <<= 1)
for (long long j = 0, R = mid << 1; j < len; j += R)
for (long long k = 0; k < mid; ++k) {
long long x = A[j + k], y = A[j + k + mid];
A[j + k] = x + y;
A[j + k + mid] = x - y;
if (ty == -1) A[j + k] >>= 1, A[j + k + mid] >>= 1;
}
}
char s[maxn];
signed main() {
cin >> n >> m;
for (long long i = (1); i <= (n); ++i) {
scanf("%s", s + 1);
for (long long j = (1); j <= (m); ++j) A[i][j] = s[j] - '0';
}
for (long long i = (1); i <= (m); ++i) {
long long now = 0;
for (long long j = (1); j <= (n); ++j)
if (A[j][i]) now += (1 << (j - 1));
a[i] = now;
}
for (long long i = (0); i <= ((1 << n) - 1); ++i) {
long long x = __builtin_popcount(i), y = n - x;
f[i] = min(x, y);
}
for (long long i = (1); i <= (m); ++i) ++g[a[i]];
len = (1 << n);
FWTxor(f, 1);
FWTxor(g, 1);
for (long long i = (0); i <= (len - 1); ++i) f[i] = f[i] * g[i];
FWTxor(f, -1);
long long ans = 0x3f3f3f3f3f3f3f3f;
for (long long i = (0); i <= (len - 1); ++i) ans = min(ans, f[i]);
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
const int N = 63;
long long dp[N * N][2];
int cnt, n, m, x[N], y[N];
std::map<int, int> f;
int solve(long long x) {
int res = 0;
while (x) res += x & 1, x >>= 1;
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", x + i);
for (int i = 0; i < m; i++) scanf("%d", y + i);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int t = x[i] + y[j];
auto it = f.find(t);
if (it == f.end()) f[t] = ++cnt;
t = f[t];
dp[t][0] |= 1LL << i;
dp[t][1] |= 1LL << j;
}
int ans = 0;
for (int i = 1; i <= cnt; i++)
for (int j = i; j <= cnt; j++)
ans = std::max(ans,
solve(dp[i][0] | dp[j][0]) + solve(dp[i][1] | dp[j][1]));
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long solve();
vector<long long> a;
string s;
long long n;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
long long in(vector<long long> &a, long long n) {
long long i = 0, x, sum = 0;
for (i = 0; i < n; i++) {
cin >> x;
a.push_back({x});
}
return sum;
}
long long solve() {
a.clear();
s.clear();
long long i = 0, j = 0, k = 0;
long long flag = 0;
long long x = 0, y = 0, z = 0;
long long m;
cin >> m;
cin >> n;
in(a, n);
long long ans = 0;
for (i = 0; i < n; i++) {
for (j = i - 1; j >= 0; j--) {
if (a[j] < a[i]) ans++;
}
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000 + 3, MAX_Q = 100000 + 3;
struct Edge {
int from, to;
Edge(int from, int to) : from(min(from, to)), to(max(from, to)) {}
bool operator<(const Edge &e) const {
return from < e.from || (from == e.from && to < e.to);
}
};
struct Data {
int idx;
int fa, rank;
Data() {}
Data(int idx, int fa, int rank) : idx(idx), fa(fa), rank(rank) {}
};
struct DisjointSet {
static const int MAX_NODE = MAX_N * 2;
Data stk[MAX_NODE * 4];
int fa[MAX_NODE], rank[MAX_NODE], sz;
void init(int n) {
for (int i = 0; i < n; ++i) fa[i] = i, rank[i] = 1;
sz = 0;
}
int find(int x) { return fa[x] == x ? x : find(fa[x]); }
inline void unite(int u, int v) {
u = find(u), v = find(v);
if (u == v) return;
stk[sz++] = Data(u, fa[u], rank[u]);
stk[sz++] = Data(v, fa[v], rank[v]);
if (rank[u] > rank[v]) swap(u, v);
fa[u] = v;
if (rank[u] == rank[v]) ++rank[v];
}
inline bool same(int u, int v) { return find(u) == find(v); }
inline int now() { return sz; }
void backTo(int t) {
for (int i = sz - 1; i >= t; --i) {
Data dat = stk[i];
fa[dat.idx] = dat.fa, rank[dat.idx] = dat.rank;
}
sz = t;
}
} ds;
struct SegmentTree {
vector<Edge> edges[4 * MAX_N];
bool ans[MAX_Q];
inline bool addEdge(int u, int v) {
ds.unite(u * 2, v * 2 + 1);
ds.unite(u * 2 + 1, v * 2);
return !ds.same(u * 2, u * 2 + 1) && !ds.same(v * 2, v * 2 + 1);
}
void add(int o, int l, int r, int a, int b, const Edge &e) {
if (r <= a || l >= b) return;
if (l >= a && r <= b) return edges[o].push_back(e);
add((((o) << 1) + 1), l, (((l) + (r)) >> 1), a, b, e);
add((((o) << 1) + 2), (((l) + (r)) >> 1), r, a, b, e);
}
void dfs(int o, int l, int r) {
int t = ds.now();
bool flag = true;
for (auto &e : edges[o]) {
if (!addEdge(e.from, e.to)) {
flag = false;
break;
}
}
if (r - l == 1 || !flag) {
for (int i = l; i < r; ++i) ans[i] = flag;
ds.backTo(t);
return;
}
dfs((((o) << 1) + 1), l, (((l) + (r)) >> 1));
dfs((((o) << 1) + 2), (((l) + (r)) >> 1), r);
ds.backTo(t);
}
} st;
map<Edge, int> ti;
int n, q;
int main() {
cin >> n >> q;
for (int i = 0; i < q; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
Edge e = Edge(u, v);
if (ti.count(e)) {
st.add(0, 0, q, ti[e], i, e);
ti.erase(ti.find(e));
} else
ti[e] = i;
}
for (auto pi : ti) st.add(0, 0, q, pi.second, q, pi.first);
ds.init(n * 2);
st.dfs(0, 0, q);
for (int i = 0; i < q; ++i) cout << (st.ans[i] ? "YES" : "NO") << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 1000010, LOG = 20;
int n, m, k, u, v, x, y, t, a, b, ans = 1;
int ps[MAXN];
int f[MAXN];
int Y[MAXN];
bool good[MAXN];
string S;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> S;
k = S.size();
for (int i = 1; i <= m; i++) {
cin >> Y[i];
ps[Y[i]]++;
ps[Y[i] + k]--;
}
int curr = 0;
for (int i = 1; i < k; i++) {
while (curr && S[curr] != S[i]) curr = f[curr];
f[i + 1] = curr += (S[curr] == S[i]);
}
for (curr = k; curr; curr = f[curr]) good[curr] = 1;
for (int i = 1; i < m; i++)
if (Y[i + 1] - Y[i] < k && !good[k - (Y[i + 1] - Y[i])])
return cout << 0 << '\n', 0;
for (int i = 1; i <= n; i++)
if (!(ps[i] += ps[i - 1])) ans = ans * 26ll % mod;
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
long long x;
scanf("%lld", &x);
int y = x % 10;
if (y >= 5) {
int more = 10 - y;
x += more;
} else if (y < 5 && y != 0) {
x -= y;
}
printf("%lld", x);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool arr[100001];
int main() {
string s;
cin >> s;
int n = s.length();
memset(arr, false, sizeof(arr));
int i;
for (i = 0; i < n - 1; i++) {
if (s[i] == 'A' && s[i + 1] == 'B') {
arr[i] = true;
arr[i + 1] = true;
break;
}
}
if (i == n - 1) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < n - 1; i++) {
if (s[i] == 'B' && s[i + 1] == 'A' && !arr[i] && !arr[i + 1]) {
cout << "YES" << endl;
return 0;
}
}
memset(arr, false, sizeof(arr));
for (i = 0; i < n - 1; i++) {
if (s[i] == 'B' && s[i + 1] == 'A') {
arr[i] = true;
arr[i + 1] = true;
break;
}
}
if (i == n - 1) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < n - 1; i++) {
if (s[i] == 'A' && s[i + 1] == 'B' && !arr[i] && !arr[i + 1]) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
int n;
char s[maxn + 1];
int main(void) {
scanf("%d%s", &n, s);
int x = 0, y = 0, side = -1, ans = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == 'U') {
++y;
} else {
++x;
}
if (x > y) {
if (side == 1) {
++ans;
}
side = 0;
} else if (x < y) {
if (side == 0) {
++ans;
}
side = 1;
}
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int x = 0, y = 0, a, b, sum = 0, t = 1, i;
scanf("%d%d", &a, &b);
if (a == b && b == 0 || a == 1 && b == 0)
printf("0\n");
else {
for (i = 1;; i++) {
if (x + t == a && y == b || x + t > a && y == b && a > x) {
printf("%d\n", sum);
break;
} else {
x += t;
sum++;
}
if (x == a && y + t == b || x == a && y < b && (y + t) > b) {
printf("%d\n", sum);
break;
} else {
y += t;
sum++;
}
if (y == b && x - t - 1 == a || x > a && y == b && x - t - 1 < a) {
printf("%d\n", sum);
break;
} else {
x -= (t + 1);
sum++;
}
if (x == a && y - t - 1 == b || x == a && y > b && y - t - 1 < b) {
printf("%d\n", sum);
break;
} else {
y -= (t + 1);
sum++;
}
t += 2;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
double med, aux, n, soma, i;
scanf("%d", &q);
while (q > 0) {
soma = 0;
scanf("%lf", &n);
for (i = 0; i < n; i++) {
scanf("%lf", &aux);
soma = soma + aux;
}
med = ceil(soma / n);
printf("%.0lf\n", med);
q--;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int n, m, d, a[MAXN], b[MAXN], t[MAXN];
long long dp[2][MAXN], lt;
long long r[MAXN];
void getmini(bool c, long long mv) {
deque<pair<int, long long> > mn;
for (int i = 0; i < n; i++) {
while (!mn.empty() && i - mn.front().first > mv) mn.pop_front();
while (!mn.empty() && mn.back().second <= dp[c][i]) mn.pop_back();
mn.push_back({i, dp[c][i]});
r[i] = mn.front().second;
}
}
int main() {
cin >> n >> m >> d;
for (int i = 0; i < m; i++) cin >> a[i] >> b[i] >> t[i];
lt = t[m - 1];
for (int o = m - 1; o >= 0; o--) {
long long mv = (lt - t[o]) * d;
bool c = o % 2;
lt = t[o];
getmini(!c, mv);
for (int i = 0; i < n; i++) dp[c][i] = r[i];
reverse(dp[!c], dp[!c] + n);
getmini(!c, mv);
reverse(r, r + n);
for (int i = 0; i < n; i++) dp[c][i] = max(dp[c][i], r[i]);
for (int i = 0; i < n; i++) dp[c][i] += b[o] - abs(a[o] - (i + 1));
}
int ind = 0;
for (int i = 0; i < n; i++)
if (dp[0][i] > dp[0][ind]) ind = i;
cout << dp[0][ind];
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
inline int read() {
int x = 0, neg = 1;
char op = getchar();
while (!isdigit(op)) {
if (op == '-') neg = -1;
op = getchar();
}
while (isdigit(op)) {
x = 10 * x + op - '0';
op = getchar();
}
return neg * x;
}
inline void print(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
const int N = 1000005;
long long f[N], g[N];
int k, q, mul = 1;
void ckmax(long long &a, long long b) {
if (a < b) a = b;
}
void work() {
int tmp = k, t = 1, x;
x = read();
memset(g, 192, sizeof(g));
for (int v = 0; v < 10; v++) {
long long cost = 1ll * mul * v;
long long w = v % 3 == 0 ? 1ll * (v / 3) * x : 0;
for (int i = 0; i < N - cost; i++) {
ckmax(g[i + cost], f[i] + w);
}
}
memcpy(f, g, sizeof(g));
while (tmp > t) {
tmp -= t;
long long cost = 1ll * mul * t;
cost *= 3;
long long w = 1ll * x * t;
if (cost < N) {
for (int i = N - 1; i >= cost; i--) {
ckmax(f[i], f[i - cost] + w);
}
}
t <<= 1;
}
long long cost = 1ll * mul * tmp;
cost *= 3;
long long w = 1ll * x * tmp;
if (cost < N) {
for (int i = N - 1; i >= cost; i--) {
ckmax(f[i], f[i - cost] + w);
}
}
mul *= 10;
}
int main() {
k = (read() - 1) * 3;
memset(f, 192, sizeof(f)), f[0] = 0;
for (int i = 1; i <= 6; i++) work();
q = read();
while (q--) {
int x = read();
printf("%lld\n", f[x]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string pas;
int n;
cin >> pas >> n;
set<char> b, e;
string aux;
for (int i = 0; i < n; i++) {
cin >> aux;
if (aux == pas) {
cout << "YES\n";
return 0;
}
b.insert(aux[0]);
e.insert(aux[1]);
}
if (b.find(pas[1]) != b.end() && e.find(pas[0]) != e.end()) {
cout << "YES\n";
} else
cout << "NO\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000000")
using namespace std;
const int INF = 1000000007;
const long long INF2 = 1000000000000000007;
const long long MOD = 1000000007;
const long long MOD1 = 1864463441;
const int SIZE = 200010;
const double eps = 1e-9;
const long double pi = acos(-1.0);
long long n, m, k, x, y, z, v, v1, sum, med, a, b, cnt, c, rs, ind, ind1, q, l,
r, d, sz, mx, mi, bf, bf1;
long long ar[SIZE], kekw[SIZE], pref[SIZE];
bool fl, fl1, lose, used[1010][1010];
string s, t, strr[1010];
vector<pair<pair<int, int>, int> > ans;
bool cmp(int a, int b) { return a > b; }
char ch;
void pepega(int x, int y) {
if (strr[x][y] == '*') {
d = 1;
while (x + d < n && x - d >= 0 && y + d < m && y - d >= 0 &&
strr[x + d][y] == '*' && strr[x - d][y] == '*' &&
strr[x][y + d] == '*' && strr[x][y - d] == '*') {
used[x + d][y] = used[x - d][y] = used[x][y + d] = used[x][y - d] = 1;
d++;
}
d--;
if (d > 0) {
ans.push_back(make_pair(make_pair(x + 1, y + 1), d));
used[x][y] = 1;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> strr[i];
}
for (int i = 1; i < n - 1; ++i) {
for (int j = 1; j < m - 1; ++j) {
pepega(i, j);
}
}
lose = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (strr[i][j] == '*' && !used[i][j]) lose = 1;
}
}
if (lose)
cout << -1;
else {
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i].first.first << " " << ans[i].first.second << " "
<< ans[i].second << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int arr[100][100];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> arr[i][j];
}
}
int counter = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int column = j;
int sum_column = 0;
int sum_row = 0;
int row = 1;
while (row <= n) {
sum_column += arr[row][column];
row++;
}
row = i;
column = 1;
while (column <= n) {
sum_row += arr[row][column];
column++;
}
if (sum_column > sum_row) {
counter++;
}
}
}
cout << counter << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
int main() {
long long q, op, u, v, w, ans;
for (cin >> q; q--;) {
cin >> op >> u >> v;
if (op == 1) {
cin >> w;
while (u != v) {
if (u < v) swap(u, v);
mp[u] = mp[u] + w;
u /= 2;
}
} else {
ans = 0;
while (u != v) {
if (u < v) swap(u, v);
ans += mp[u];
u /= 2;
}
cout << ans << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200019;
int n, m, N, ans, base;
bool appear[maxn];
int cnt[maxn];
int factor[200];
int f[200];
int pre[200];
vector<int> num[maxn];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
void init() {
int temp;
cin >> n >> m;
for (int i = 0; i <= m; i++) appear[i] = false, cnt[i] = 0;
for (int i = 1; i <= n; i++) scanf("%d", &temp), appear[temp] = true;
for (int i = 1; i < m; i++)
if (!appear[i]) cnt[gcd(m, i)]++, num[gcd(m, i)].push_back(i);
num[0].push_back(0);
temp = m;
N = 0;
for (int i = 1; i <= m / i; i++)
if (m % i == 0) {
factor[++N] = i;
if (i != m / i) factor[++N] = m / i;
}
factor[0] = 0;
sort(factor + 1, factor + 1 + N);
N--;
for (int i = 1; i <= N; i++) f[i] = cnt[factor[i]];
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
long long r = exgcd(b, a % b, y, x);
y -= x * (a / b);
return r;
}
int linear_equation(int a, int b, int c) {
long long x, y;
long long d = exgcd(a, b, x, y);
if (c % d) return false;
int k = c / d;
x *= k;
y *= k;
int adda = b / d;
int addb = a / d;
x = (x % adda + adda) % adda;
return x;
}
void out(int gcd_pos) {
if (gcd_pos == -1) return;
out(pre[gcd_pos]);
for (int i = 0; i < num[factor[gcd_pos]].size(); i++) {
int u = num[factor[gcd_pos]][i];
ans--;
printf("%d%c", linear_equation(base, m, u), ans ? ' ' : '\n');
base = u;
}
}
void solve() {
for (int i = 1; i <= N; i++)
if (f[i]) {
int mm = f[i];
pre[i] = -1;
for (int j = 1; j <= i - 1; j++)
if (factor[i] % factor[j] == 0) {
if (mm < f[i] + f[j]) {
pre[i] = j;
mm = f[i] + f[j];
}
}
f[i] = mm;
}
int now = -1, ans = 0;
for (int i = 1; i <= N; i++)
if (f[i] > ans) {
ans = f[i], now = i;
}
if (!appear[0]) pre[0] = now, now = 0, ans++;
cout << ans << endl;
base = 1;
out(now);
}
int main() {
init();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(int a, int b) { return a > b; }
int main() {
int n;
cin >> n;
int *a = new int[n];
int sum = 0;
for (int i = 0; i != n; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + n, cmp);
int x = 0;
for (int i = 0; i != n; i++) {
x += a[i];
if (x > sum - x) {
cout << i + 1 << endl;
return 0;
}
}
delete[] a;
}
| 0 |
#include <bits/stdc++.h>
const long long INF = 2000000005;
const long long BIG_INF = 2000000000000000005;
const long long mod = 1000000007;
const long long P = 31;
const long double PI = 3.141592653589793238462643;
const double eps = 1e-9;
using namespace std;
vector<pair<long long, long long> > dir = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
bool valid(long long x, long long y, long long n, long long m) {
return x >= 0 && y >= 0 && x < n && y < m;
}
mt19937 rng(1999999973);
long long dp[35][2][2][2][2];
void clear_all() {
for (long long i = 0; i < 35; i++) {
for (long long j = 0; j < 2; j++) {
for (long long k = 0; k < 2; k++) {
for (long long t1 = 0; t1 < 2; t1++) {
for (long long t2 = 0; t2 < 2; t2++) {
dp[i][j][k][t1][t2] = 0;
}
}
}
}
}
}
long long l, r;
void doshit() {
clear_all();
long long ans = 0;
dp[30][1][1][1][1] = 1;
for (long long i = 30; i >= 0; i--) {
for (long long pl1 = 0; pl1 < 2; pl1++) {
for (long long pr1 = 0; pr1 < 2; pr1++) {
for (long long pl2 = 0; pl2 < 2; pl2++) {
for (long long pr2 = 0; pr2 < 2; pr2++) {
for (long long bit1 = 0; bit1 < 2; bit1++) {
for (long long bit2 = 0; bit2 < 2; bit2++) {
if (bit1 == 1 && bit2 == 1) continue;
if (pl1 == 1 && bit1 < (l >> i) % 2) continue;
if (pl2 == 1 && bit2 < (l >> i) % 2) continue;
if (pr1 == 1 && bit1 > (r >> i) % 2) continue;
if (pr2 == 1 && bit2 > (r >> i) % 2) continue;
long long npl1 = 0;
if (pl1 == 1 && bit1 == (l >> i) % 2) npl1 = 1;
long long npl2 = 0;
if (pl2 == 1 && bit2 == (l >> i) % 2) npl2 = 1;
long long npr1 = 0;
if (pr1 == 1 && bit1 == (r >> i) % 2) npr1 = 1;
long long npr2 = 0;
if (pr2 == 1 && bit2 == (r >> i) % 2) npr2 = 1;
if (i == 0)
ans += dp[i][pl1][pr1][pl2][pr2];
else
dp[i - 1][npl1][npr1][npl2][npr2] +=
dp[i][pl1][pr1][pl2][pr2];
}
}
}
}
}
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
cin >> l >> r;
doshit();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool isrange(int second, int first, int n, int m) {
if (0 <= second && second < n && 0 <= first && first < m) return true;
return false;
}
int dy[4] = {1, 0, -1, 0}, dx[4] = {0, 1, 0, -1},
ddy[8] = {1, 0, -1, 0, 1, 1, -1, -1}, ddx[8] = {0, 1, 0, -1, 1, -1, 1, -1};
int dp[1111111];
int main(void) {
string s;
cin >> s;
long long int ans = 0;
long long int f1 = 0, f2 = 0;
for (int e = (int)s.size() - 1; e >= 0; e--) {
if (s[e] == 'v') {
dp[e] = dp[e + 1] + 1;
if (dp[e] >= 2) f2++;
} else {
dp[e] = 0;
}
}
int ll = 0;
for (int e = 0; e < (int)s.size(); e++) {
if (s[e] == 'v') {
ll++;
if (ll >= 2) f1++;
if (dp[e] >= 2) f2--;
dp[e]--;
} else {
ll = 0;
ans += (f1 * f2);
}
}
printf("%lld", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
const double PI = acos(-1.0);
using namespace std;
int a[100010];
int main() {
int CASE;
scanf("%d", &CASE);
while (CASE--) {
long long n, k, d1, d2;
scanf("%I64d %I64d %I64d %I64d", &n, &k, &d1, &d2);
if (n % 3 != 0) {
printf("no\n");
continue;
}
if ((k - 2 * d1 - d2) % 3 == 0) {
long long a, b, c;
a = (k - 2 * d1 - d2) / 3;
b = a + d1;
c = b + d2;
if (min(a, min(b, c)) >= 0 && max(a, max(b, c)) <= n / 3) {
printf("yes\n");
continue;
}
}
if ((k - 2 * d1 + d2) % 3 == 0) {
long long a, b, c;
a = (k - 2 * d1 + d2) / 3;
b = a + d1;
c = b - d2;
if (min(a, min(b, c)) >= 0 && max(a, max(b, c)) <= n / 3) {
printf("yes\n");
continue;
}
}
if ((k + 2 * d1 - d2) % 3 == 0) {
long long a, b, c;
a = (k + 2 * d1 - d2) / 3;
b = a - d1;
c = b + d2;
if (min(a, min(b, c)) >= 0 && max(a, max(b, c)) <= n / 3) {
printf("yes\n");
continue;
}
}
if ((k + 2 * d1 + d2) % 3 == 0) {
long long a, b, c;
a = (k + 2 * d1 + d2) / 3;
b = a - d1;
c = b - d2;
if (min(a, min(b, c)) >= 0 && max(a, max(b, c)) <= n / 3) {
printf("yes\n");
continue;
}
}
printf("no\n");
}
return 0;
}
| 4 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<cmath>
#include<iomanip>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define pb push_back
#define pll pair<ll,ll>
#define mll map<ll,ll>
#define pii pair<int,int>
#define vpii vector<pii>
#define rep(i,n) for(int i=0; i<n; i++)
#define All(x,v) for(auto x:v)
#define arrin(a,n) ll a[n]; rep(i,n) cin>>a[i]
#define vi vector<int>
#define nl "\n"
#define print(arr) All(x,arr) cout<<x<<" "; cout<<nl
#define sz(x) (int)x.size()
#define all(v) v.begin(),v.end()
#define ing(m,ad) rep(i,m){ int u,v; cin>>u>>v; u--;v--; ad[u].pb(v); ad[v].pb(u);}
#define vdsort(v) sort(v.begin(),v.end(),greater<int>())
#define F first
#define S second
#define mod 1000000007
const int MAXN=100005;
int spf[MAXN];
ll fac1[MAXN],fac2[MAXN],inv[MAXN];
ll gcd(ll x, ll y){ return y?gcd(y,x%y):x; }
void sieve(){
spf[1] = 1;
for (int i=2; i<MAXN; i++) spf[i] = i;
for (int i=4; i<MAXN; i+=2) spf[i] = 2;
for (int i=3; i*i<MAXN; i++) {
if (spf[i] == i)
for (int j=i*i; j<MAXN; j+=i)
if (spf[j]==j) spf[j] = i;
}
}
vector<int> getFactorization(int x){
vector<int> ret;
while (x != 1) {
ret.push_back(spf[x]);
x = x / spf[x];
}
return ret;
}
ll exp(ll n, ll m){
ll a = 1;
while (m){
if (m & 1) a = (a * n % mod) % mod;
m /= 2;
n = (n*n) % mod;
}
return a;
}
void pre(){
fac1[0]=fac2[0]=inv[1]=1;
for(int i=1;i<MAXN;i++){
fac1[i]=(fac1[i-1]*i)%mod;
if(i>1) inv[i]=( mod - ((ll)(mod/i)*inv[mod%i])%mod ) %mod;
}
for(int i=1;i<MAXN;i++) fac2[i]=(fac2[i-1]*inv[i])%mod;
}
ll C(int n,int k){
if(n<k) return 0;
return ((fac1[n]*fac2[n-k]%mod)*fac2[k]%mod);
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
// freopen("input.txt","r",stdin); freopen("output.txt","w",stdout);
ll n,k,t=1;
cin>>t;
while(t--){
cin>>n>>k;
arrin(a,n);
ll sum = a[0],ans=0;
for(int i=1;i<n;i++){
if(100*a[i] > sum*k){
if((100*a[i]-sum*k)%k==0){
ll temp = (100*a[i]-sum*k)/k;
sum += temp;
ans += temp;
}
else{
ll temp = (100*a[i]-sum*k)/k+1;
sum += temp;
ans += temp;
}
}
// cout<<ans<<nl;
sum += a[i];
}
cout<<ans<<nl;
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x;
cin >> x;
for (int i = 0; i < x.size(); i++) {
if (x[i] == 'H' || x[i] == 'Q' || x[i] == '9') {
cout << "YES";
return 0;
}
}
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<int, int> pos1;
map<int, int> pos2;
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
pos1[a[i]] = i;
}
for (int i = 0; i < n; i++) {
cin >> b[i];
pos2[b[i]] = i;
}
map<int, int> h;
for (int i = 1; i <= n; i++) {
if (pos1[i] <= pos2[i]) {
h[pos2[i] - pos1[i]]++;
} else {
h[n - pos1[i] + pos2[i]]++;
}
}
int mx = 0;
for (int i = 0; i <= 2 * n; i++) {
if (h[i] > mx) mx = h[i];
}
cout << mx;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long int calculations[n], ans = 1, mini = INT_MAX;
for (int i = 0; i < n; i++) {
long long int x = ((long long int)(a[i] - i + n - 1) / n) + 1ll;
calculations[i] = (long long int)(i + (x - 1) * n);
if (calculations[i] < mini) {
mini = calculations[i];
ans = (long long int)(i + 1);
}
}
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
int x = 0;
char c = getchar();
bool f = 0;
while (c < '0' && c != '-') c = getchar();
if (c == '-') f = 1, c = getchar();
while (c >= '0') x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return f ? -x : x;
}
const int SIZE = 5e5 + 100;
int n, m;
int C, C0;
int N, T[SIZE];
long long sum[SIZE];
vector<int> V[SIZE];
struct Node {
int t, a, b;
bool operator<(const Node& x1) const { return t < x1.t; }
} x[SIZE];
struct Tree {
int L, R;
int Mi, lazy;
} tree[SIZE << 2];
struct cmp {
bool operator()(const int& x1, const int& x2) const {
return x[x1].b > x[x2].b;
}
};
priority_queue<int, vector<int>, cmp> Q;
void Up(int p) { tree[p].Mi = min(tree[(p << 1)].Mi, tree[(p << 1 | 1)].Mi); }
void Down(int p) {
if (tree[p].lazy == 0) return;
tree[(p << 1)].lazy += tree[p].lazy;
tree[(p << 1)].Mi += tree[p].lazy;
tree[(p << 1 | 1)].lazy += tree[p].lazy;
tree[(p << 1 | 1)].Mi += tree[p].lazy;
tree[p].lazy = 0;
}
void Build(int L, int R, int p) {
tree[p].L = L, tree[p].R = R;
tree[p].lazy = 0;
if (L == R) {
tree[p].Mi = T[L] + C - C0;
return;
}
int mid = (L + R) >> 1;
Build(L, mid, (p << 1)), Build(mid + 1, R, (p << 1 | 1));
Up(p);
}
int Upd;
void Update(int L, int R, int p) {
if (tree[p].L == L && tree[p].R == R) {
tree[p].Mi -= Upd;
tree[p].lazy -= Upd;
return;
}
Down(p);
int mid = (tree[p].L + tree[p].R) >> 1;
if (R <= mid)
Update(L, R, (p << 1));
else if (L > mid)
Update(L, R, (p << 1 | 1));
else
Update(L, mid, (p << 1)), Update(mid + 1, R, (p << 1 | 1));
Up(p);
}
int Query(int L, int R, int p) {
if (tree[p].L == L && tree[p].R == R) return tree[p].Mi;
Down(p);
int mid = (tree[p].L + tree[p].R) >> 1;
if (R <= mid)
return Query(L, R, (p << 1));
else if (L > mid)
return Query(L, R, (p << 1 | 1));
else
return min(Query(L, mid, (p << 1)), Query(mid + 1, R, (p << 1 | 1)));
}
void _main() {
int Case = rd();
while (Case--) {
n = rd(), m = rd(), C = rd(), C0 = rd();
for (register int i = 1, _n = n; i <= _n; ++i) {
x[i].t = rd();
x[i].a = rd();
x[i].b = rd();
T[i] = x[i].t;
}
N = n;
T[++N] = m - 1;
sort(T + 1, T + N + 1);
N = unique(T + 1, T + N + 1) - T - 1;
for (register int i = 1, _n = n; i <= _n; ++i) {
x[i].t = lower_bound(T + 1, T + N + 1, x[i].t) - T;
V[x[i].t].push_back(i);
}
Build(1, N, 1);
bool OK = 1;
long long ans = 0;
if (T[1] - 1 >= C0) {
OK = 0;
} else {
T[N + 1] = T[N] + 1;
for (register int i = 1, _n = N; i <= _n; ++i) {
for (int id : V[i]) Q.push(id);
sum[i] = sum[i - 1];
while (T[i + 1] - 1 - C0 >= sum[i]) {
if (Q.empty()) break;
int u = Q.top();
long long tot = Query(x[u].t, i, 1);
long long tmp =
min(tot, min(T[i + 1] - C0 - sum[i], (long long)x[u].a));
ans += tmp * x[u].b;
sum[i] += tmp;
x[u].a -= tmp;
Upd = tmp;
Update(x[u].t, N, 1);
if (tmp == tot || x[u].a == 0) Q.pop();
}
if (T[i + 1] - 1 - C0 >= sum[i]) {
OK = 0;
break;
}
}
}
while (!Q.empty()) Q.pop();
for (register int i = 1, _n = N; i <= _n; ++i) V[i].clear();
if (OK)
printf("%lld\n", ans);
else
puts("-1");
}
}
int main() {
_main();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 200 + 10, MOD = 1e9 + 7;
vector<int> g[MAXn];
int n, cnt[MAXn], h[MAXn], p[MAXn];
long long dp[MAXn][MAXn], res, invN, inv2;
vector<int> dfsStack;
void dfs(int v, int par, int height) {
cnt[v] = 1;
h[v] = height;
p[v] = par;
for (int u : g[v]) {
if (u != par) {
dfs(u, v, height+1);
cnt[v] += cnt[u];
}
}
}
void dfs2(int v, int origin) {
dfsStack.push_back(v);
if (origin > v) {
for (int i = 0; i < (int)(dfsStack.size() - 1); i++) {
long long tmp = cnt[dfsStack[i]] - cnt[dfsStack[i+1]];
tmp = (tmp * invN) % MOD;
tmp = (tmp * dp[i][dfsStack.size() - 1 - i]) % MOD;
res = (tmp + res) % MOD;
}
}
for (int u : g[v]) {
if (u != p[v]) {
dfs2(u, origin);
}
}
dfsStack.pop_back();
}
long long pw(long long a, long long b) {
long long res = 1;
while(b) {
if (b & 1) {
res = (res * a) % MOD;
}
a = (a * a)%MOD;
b /= 2;
}
return res;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;u--;v--;
g[u].push_back(v);
g[v].push_back(u);
}
inv2=pw(2, MOD-2), invN = pw(n, MOD-2);
for (int i = 1; i < MAXn; i++)
dp[0][i] = 1;
for (int i = 1; i < MAXn; i++)
for (int j = 1; j < MAXn; j++) {
dp[i][j] = (inv2 * ((dp[i-1][j] + dp[i][j-1]) % MOD)) % MOD;
}
for (int i = 0; i < n; i++) {
dfs(i, -1, 0);
dfs2(i, i);
}
cout << res;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int arr[51][51] = {0};
int main() {
int n, r, a, b, ct = 0, flag = 0, p, i, j;
scanf("%d%d", &n, &p);
for (i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
arr[a][b]++;
}
for (i = 50; i >= 0; i--) {
for (j = 0; j < 51; j++) {
ct += arr[i][j];
if (ct >= p) {
printf("%d", arr[i][j]);
flag = 1;
break;
}
}
if (flag == 1) break;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool ans = true;
char cur = 'a';
for (auto it : s) {
if (it > cur) {
ans = false;
break;
} else if (it == cur)
cur++;
}
if (ans)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 120;
bitset<MAXN + 6> s;
int ans;
int cntv[MAXN + 6];
int t, m, n;
void DFS(bitset<MAXN + 6> a, int cur, long long mulv) {
ans = (ans + mulv) % MOD;
for (int i = cur; i <= m >> 1; ++i)
if (cntv[i] && !a[i] && !a[m - i])
DFS(a | a << i | a >> i | a << m - i | a >> m - i, i + 1,
mulv * cntv[i] % MOD);
return;
}
int main() {
scanf("%d%d%d", &t, &m, &n);
for (register int i = n, j; i >= 1; --i) {
scanf("%d", &j);
j %= m;
cntv[min(j, m - j)]++;
}
s[0] = 1;
DFS(s, 1, 1);
printf("%lld", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
char s[(100000 + 10)], x[(100 + 10)], y[(100 + 10)];
int ch[(100000 + 10)][10], val[(100000 + 10)];
int nxt[(100000 + 10)];
int tot;
int dp[55][(100000 + 10)][2][2][2];
void init() {
memset(ch[0], -1, sizeof ch[0]);
tot = 0;
}
void insert(char *s, int len) {
int u = 0;
for (int i = 0; i < len; ++i) {
int c = s[i] - '0';
if (ch[u][c] == -1) {
ch[u][c] = ++tot;
memset(ch[tot], -1, sizeof ch[tot]);
val[tot] = 0;
}
u = ch[u][c];
}
val[u] = 1;
}
void build() {
queue<int> que;
nxt[0] = 0;
for (int i = 0; i < 10; ++i) {
int &u = ch[0][i];
if (u == -1)
u = 0;
else {
que.push(u);
nxt[u] = 0;
}
}
while (!que.empty()) {
int now = que.front();
que.pop();
for (int i = 0; i < 10; ++i) {
int &u = ch[now][i];
if (u == -1) {
u = ch[nxt[now]][i];
} else {
nxt[u] = ch[nxt[now]][i];
que.push(u);
}
}
}
}
void add(int &u, int v) {
u += v;
if (u >= 1000000007) u -= 1000000007;
}
bool check(int x) {
int t[(100 + 10)];
int len = 0;
while (x) {
t[len++] = x % 10;
x /= 10;
}
reverse(t, t + len);
int u = 0;
bool e = 0;
for (int i = 0; i < len; ++i) {
u = ch[u][t[i]];
e |= val[u];
}
return e;
}
int gao(int d) {
int s = 0;
for (int i = 0; i < d; ++i) s = s * 10 + x[i] - '0';
int t = 0;
for (int i = 0; i < d; ++i) t = t * 10 + y[i] - '0';
int ans = 0;
for (int i = s; i <= t; ++i) {
if (check(i)) ++ans;
}
return ans;
}
int main() {
scanf("%s", s);
scanf("%s%s", x, y);
int d = strlen(x);
int len = strlen(s);
init();
for (int i = 0; i < len; ++i) {
for (int j = d / 2; j <= d; ++j) {
if (i + j <= len) insert(s + i, j);
}
}
build();
dp[0][0][1][1][0] = 1;
for (int i = 0; i < d; ++i) {
for (int j = 0; j <= tot; ++j) {
for (int e = 0; e < 2; ++e) {
for (int f = 0; f < 2; ++f) {
for (int g = 0; g < 2; ++g) {
if (dp[i][j][e][f][g] == 0) continue;
int st = 0, ed = 9;
if (e) ed = y[i] - '0';
if (f) st = x[i] - '0';
for (int k = st; k <= ed; ++k) {
int jj = ch[j][k];
add(dp[i + 1][jj][e && k == (y[i] - '0')][f && k == (x[i] - '0')]
[g || val[jj]],
dp[i][j][e][f][g]);
}
}
}
}
}
}
int ans = 0;
for (int j = 0; j <= tot; ++j) {
for (int e = 0; e < 2; ++e) {
for (int f = 0; f < 2; ++f) {
add(ans, dp[d][j][e][f][1]);
}
}
}
printf("%d\n", ans);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
const double pi = acos(-1.0), eps = 1e-8;
const int maxm = 1100000, inf = 0x3f3f3f3f;
bool f[maxm];
vector<int> v[maxm];
int top, st[maxm];
int a[maxm];
void dfs(int x, int pre) {
f[x] = true;
int i;
a[x] ^= 1;
st[top++] = x;
for (i = 0; i < v[x].size(); i++) {
if (f[v[x][i]] == false) {
dfs(v[x][i], x);
st[top++] = x;
a[x] ^= 1;
}
}
if (a[x] != 0 && pre != -1) {
st[top++] = pre;
a[pre] ^= 1;
st[top++] = x;
a[x] ^= 1;
}
}
int main() {
int n, m, i, x, y, begin;
while (scanf("%d%d", &n, &m) == 2) {
for (i = 1; i <= n; i++) v[i].clear();
while (m--) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
f[i] = false;
}
top = 0;
for (i = 1; i <= n; i++) {
if (a[i] == 1) {
dfs(i, -1);
begin = i;
break;
}
}
if (i == n + 1) {
printf("0\n");
continue;
}
for (i = begin + 1; i <= n; i++) {
if (a[i] != 0) {
printf("-1\n");
break;
}
}
if (i <= n) continue;
if (a[begin] == 1)
begin = 1;
else
begin = 0;
printf("%d\n", top - begin);
for (i = begin; i < top; i++) {
printf("%d", st[i]);
if (i == top - 1)
printf("\n");
else
printf(" ");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5, M = 1e5 + 5;
int a, b, m, d, cnt, degree[N << 1], last[N << 1], used[N << 1][N << 1];
struct edge {
int y, last;
} E[M << 1];
struct node {
int x, y, color;
} nd[M];
void link(int x, int y) {
E[cnt] = (edge){y, last[x]}, last[x] = cnt++, ++degree[y];
E[cnt] = (edge){x, last[y]}, last[y] = cnt++, ++degree[x];
}
void modify(int pos, int c1, int c2) {
int x = used[pos][c1], y = E[x].y;
if (!~used[y][c2])
used[y][c1] = -1;
else
modify(y, c2, c1);
nd[(x >> 1) + 1].color = c2, used[y][c2] = x ^ 1, used[pos][c2] = x;
}
int main() {
ios::sync_with_stdio(0);
memset(used, -1, sizeof(used)), memset(last, -1, sizeof(last)),
cin >> a >> b >> m;
for (int i = 1; i <= m; ++i)
cin >> nd[i].x >> nd[i].y, nd[i].y += a, link(nd[i].x, nd[i].y);
for (int i = 1; i <= a + b; ++i)
if (degree[i] > d) d = degree[i];
for (int i = 1; i <= m; ++i) {
for (int j = 1; !nd[i].color && j <= d; ++j)
if (!~used[nd[i].x][j] && !~used[nd[i].y][j])
used[nd[i].x][j] = i * 2 - 2, used[nd[i].y][j] = i * 2 - 1,
nd[i].color = j;
if (!nd[i].color) {
int c1, c2;
for (c1 = 1; ~used[nd[i].x][c1] && c1 <= d; ++c1)
;
for (c2 = 1; ~used[nd[i].y][c2] && c2 <= d; ++c2)
;
modify(nd[i].y, c1, c2), used[nd[i].x][c1] = i * 2 - 2,
used[nd[i].y][c1] = i * 2 - 1, nd[i].color = c1;
}
}
cout << d << endl;
for (int i = 1; i <= m; ++i) cout << nd[i].color << ' ';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
list<int> l;
list<int>::iterator it = l.end();
int n;
scanf("%d", &n);
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
l.insert(it, i + 1);
if (s[i] == 'l') it--;
}
for (it = l.begin(); it != l.end(); it++) printf("%d\n", *it);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[100004];
int main() {
int n;
cin >> n;
string s;
cin >> s;
int a = 1;
int i = 2;
vector<char> v;
while (1) {
if ((a - 1) >= s.size()) break;
v.push_back(s[a - 1]);
cout << s[a - 1];
a = a + i;
i++;
}
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, q;
int a[200000];
int cnt[1000001] = {};
int mul[1000001];
bool p[2000];
vector<int> pr;
const int MOD = 1e9 + 7;
vector<int> di[1000001];
int f[2000005], rf[2000005];
int binPow(long long x, int p) {
long long res = 1;
while (p) {
if (p & 1) res = res * x % MOD;
p >>= 1;
if (p) x = x * x % MOD;
}
return (int)res;
}
int c(int n, int k) { return (long long)f[n] * rf[k] % MOD * rf[n - k] % MOD; }
int cc[200005];
bool used[1000001] = {};
int main() {
f[0] = rf[0] = 1;
for (int i = 1; i < 2000005; ++i) {
f[i] = (long long)f[i - 1] * i % MOD;
rf[i] = binPow(f[i], MOD - 2);
}
for (int i = 0; i < (int)(2000); ++i) p[i] = true;
p[0] = p[1] = false;
for (int i = 0; i < (int)(2000); ++i)
if (p[i]) {
for (int j = i * i; j < 2000; j += i) {
p[j] = false;
}
}
for (int i = 0; i < (int)(2000); ++i)
if (p[i]) pr.push_back(i);
scanf("%d%d%d", &n, &k, &q);
for (int i = 0; i < (int)(n + q); ++i) scanf("%d", a + i), used[a[i]] = true;
for (int i = 1; i <= 1000000; ++i) {
int rem = i;
mul[i] = i;
vector<int> v;
for (int x : pr) {
if (x * x > rem) break;
if (rem % x == 0) {
v.push_back(x);
rem /= x;
while (rem % x == 0) {
rem /= x;
}
}
}
if (rem > 1) {
v.push_back(rem);
}
for (int mask = 0; mask < (int)(1 << v.size()); ++mask)
if (mask) {
int rem = i;
for (int j = 0; j < (int)(v.size()); ++j)
if (mask & (1 << j)) {
rem /= v[j];
}
if (__builtin_popcount(mask) & 1) {
mul[i] -= rem;
} else {
mul[i] += rem;
}
}
int j;
if (used[i]) {
for (j = 1; j * j < i; ++j)
if (i % j == 0) {
di[i].push_back(j);
di[i].push_back(i / j);
}
if (j * j == i) {
di[i].push_back(j);
}
}
mul[i] %= MOD;
if (mul[i] < 0) mul[i] += MOD;
}
for (int i = 1; i <= 12; ++i) {
}
int ans = 0;
for (int i = k; i < 200005; ++i) cc[i] = c(i, k);
for (int i = 0; i < (int)(n + q); ++i) {
int val = a[i];
for (int x : di[val]) {
if (cnt[x] >= k) {
ans = (ans - (long long)mul[x] * cc[cnt[x]]) % MOD;
if (ans < 0) ans += MOD;
}
if (++cnt[x] >= k) {
ans = (ans + (long long)mul[x] * cc[cnt[x]]) % MOD;
}
}
if (i >= n) {
printf("%d\n", ans);
}
}
return 0;
}
| 8 |
#include<bits/stdc++.h>
#define For(a,b,c) for(int a=b;a<=c;++a)
#define Dor(a,b,c) for(int a=b;a>=c;--a)
#define CC(_...) fprintf(stderr,_)
using namespace std;
typedef long long LL;
enum{N=18,M=1<<N,oo=3<<28};
int n,m,W[N],E[M],F[M],G[M],S[M],O[M];
int main() {
scanf("%d%d",&n,&m);
For(i,1,m) {
int x,y,z;
scanf("%d%d%d",&x,&y,&z),--x,--y;
S[1<<x]+=z,S[1<<y]-=z;
E[1<<x]|=1<<y;
}
For(i,1,(1<<n)-1) E[i]=E[i&(i-1)]|E[i&-i],S[i]=S[i&(i-1)]+S[i&-i];
For(i,1,(1<<n)-1) {
O[i]=1;
For(j,0,n-1) if((i&1<<j)&&(E[1<<j]&i)) {O[i]=0; break;}
if(O[i]) continue;
F[i]=oo;
for(int j=i&(i-1);j;--j&=i) {
if(E[j]&(j^i)||!O[j]) continue;
int f=F[j]+F[i^j]+S[i^j];
if(f<F[i]) F[i]=f,G[i]=i^j;
}
}
int x=(1<<n)-1,c=0;
while(x) {
For(i,0,n-1) if(x&1<<i) W[i]=c;
x=G[x],++c;
}
For(i,0,n-1) printf("%d ",W[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
;
}
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
namespace std {
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
} // namespace std
long long int readL() {
long long int res;
scanf("%I64d", &res);
return res;
}
void printL(long long int res) { printf("%I64d", res); }
template <long long int mod>
struct Int_ {
unsigned x;
unsigned mpow(Int_ a, unsigned k) {
Int_ res = 1;
while (k) {
if (k & 1) res = res * a;
a = a * a;
k >>= 1;
}
return res.x;
}
unsigned inverse(Int_ a) { return mpow(a, mod - 2); }
Int_() : x(0) {}
Int_(long long sig) {
if (sig < 0)
x = sig % mod + mod;
else
x = sig % mod;
}
unsigned get() const { return (unsigned)x; }
Int_& operator+=(Int_ that) {
if ((x += that.x) >= mod) x -= mod;
return *this;
}
Int_& operator-=(Int_ that) {
if ((x += mod - that.x) >= mod) x -= mod;
return *this;
}
Int_& operator*=(Int_ that) {
x = (unsigned long long)x * that.x % mod;
return *this;
}
Int_& operator=(Int_ that) {
x = that.x;
return *this;
}
Int_& operator/=(Int_ that) {
x = (unsigned long long)x * inverse(that.x) % mod;
return *this;
}
bool operator==(Int_ that) const { return x == that.x; }
bool operator!=(Int_ that) const { return x != that.x; }
Int_ operator-() const { return Int_(0) - Int_(*this); }
Int_ operator+(Int_ that) const { return Int_(*this) += that; }
Int_ operator-(Int_ that) const { return Int_(*this) -= that; }
Int_ operator*(Int_ that) const { return Int_(*this) *= that; }
Int_ operator/(Int_ that) const { return Int_(*this) /= that; }
};
namespace std {
template <long long int mod>
ostream& operator<<(ostream& out, const Int_<mod>& a) {
out << a.get();
return out;
}
template <long long int mod>
istream& operator>>(istream& in, Int_<mod>& a) {
in >> a.x;
return in;
}
}; // namespace std
vector<vector<Int_<1000000007> > > matpow(
const vector<vector<Int_<1000000007> > >& a,
const vector<vector<Int_<1000000007> > >& b) {
int n = a.size();
vector<vector<Int_<1000000007> > > res(n, vector<Int_<1000000007> >(n));
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (n); ++j)
for (int k = 0; k < (n); ++k) {
res[i][j] += a[i][k] * b[k][j];
}
return res;
}
vector<vector<Int_<1000000007> > > mpow(vector<vector<Int_<1000000007> > > a,
long long int k) {
int n = a.size();
vector<vector<Int_<1000000007> > > res(n, vector<Int_<1000000007> >(n));
for (int i = 0; i < (n); ++i) res[i][i] = 1;
while (k) {
if (k & 1) res = matpow(res, a);
a = matpow(a, a);
k >>= 1;
}
return res;
}
int w[10];
int main() {
for (int i = 0; i < (7); ++i) cin >> w[i + 1];
vector<Int_<1000000007> > ever(2);
ever[1] = 1;
for (int i = 1; i <= 7; ++i) {
int n = (1 << i);
vector<vector<Int_<1000000007> > > M(n, vector<Int_<1000000007> >(n));
for (int j = 0; j < (n); ++j)
for (int k = 0; k < (n); ++k)
for (int l = 0; l < (n / 2); ++l) {
int l2 = (l << 1) | 1 | (1 << i);
int fail = 0;
for (int i2 = 0; i2 < (i); ++i2)
if (j >> i2 & 1 && k >> i2 & 1 && l2 >> i2 & 1 &&
l2 >> (i2 + 1) & 1) {
fail = 1;
break;
}
if (!fail) M[j][k] += 1;
}
vector<vector<Int_<1000000007> > > M2 = mpow(M, w[i]);
vector<Int_<1000000007> > nxt(n);
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (n); ++j) {
nxt[j] += ever[i] * M2[i][j];
}
ever.clear();
if (i == 7)
ever = nxt;
else {
ever.resize(2 * n);
for (int j = 0; j < (n); ++j) ever[j | n] = nxt[j];
}
}
Int_<1000000007> res = ever[(1 << 7) - 1];
cout << res << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
template <class T>
inline void umin(T &x, T y) {
x = x < y ? x : y;
}
template <class T>
inline void umax(T &x, T y) {
x = x > y ? x : y;
}
inline unsigned int R() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
long long n, k;
long long getblock(long long n) { return (n - 1) / (k * k + 1); }
long long getend(long long i, long long t) {
return i * (k * k + 1) + t * k + k;
}
long long getans(long long x) {
if (!x) return k * (k + 1) / 2;
long long i = x / k, t = x % k;
long long pos = getans(i);
long long off = max(min(getend(i, t) - pos + 1, k), 0LL);
return (i * k + t) * (k * k + 1) - t + k * (k + 1) / 2 + off;
}
long long getcnt(long long x) { return x + (x - 1) / k; }
int main() {
int T;
read(T);
while (T--) {
read(n);
read(k);
long long x = getblock(n);
long long pos = getans(x);
long long res;
if (pos == n)
res = (x / k * k + x % k + 1) * (k + 1);
else
res = x * k * (k + 1) + getcnt(n - x * (k * k + 1) - (pos < n));
printf("%lld\n", res);
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int D[4][2] = {{1, 0}, {0, 1}, {0, -1}, {-1, 0}};
struct pt {
int x, y;
bool in() { return 0 <= x && x <= 300 && 0 <= y && y <= 300; }
} a[405], P[4], s, t, q[91005];
bool operator==(const pt& a, const pt& b) { return a.x == b.x && a.y == b.y; }
int n, p[91005], way[91005], pre[91005];
bool c[305][305], v[305][305];
bool bfs() {
q[1] = s, v[s.x][s.y] = 1;
for (int l = 1, r = 1; l <= r; l++)
for (int i = 0; i < 4; i++) {
pt u = {q[l].x + D[i][0], q[l].y + D[i][1]};
if (u.in() && !v[u.x][u.y]) {
q[++r] = u, way[r] = i, pre[r] = l, v[u.x][u.y] = 1;
if (u == t) {
for (; r > 1; r = pre[r]) p[++p[0]] = way[r];
reverse(p + 1, p + 1 + p[0]);
return 1;
}
}
}
return 0;
}
bool move(int i) {
s.x += D[i][0], s.y += D[i][1];
t.x += D[i][0], t.y += D[i][1];
putchar("RUDL"[i]);
if (t.in() && c[t.x][t.y]) {
t.x -= D[i][0], t.y -= D[i][1];
return 0;
}
return 1;
}
void out() {
while ((0 <= s.x && s.x <= 300) || (0 <= t.x && t.x <= 300)) move(0);
while ((0 <= s.y && s.y <= 300) || (0 <= t.y && t.y <= 300)) move(1);
}
void ud(int d) {
out();
while ((d == 2 && t.y >= 0) || (d == 1 && t.y <= 300)) move(d);
while (t.x != P[d].x) move(t.x < P[d].x ? 0 : 3);
while (t.y != s.y) move(3 - d);
}
void lr(int d) {
out();
while ((d == 3 && t.x >= 0) || (d == 0 && t.x <= 300)) move(d);
while (t.y != P[d].y) move(t.y < P[d].y ? 1 : 2);
while (t.x != s.x) move(3 - d);
}
int main() {
cin >> s.x >> s.y >> t.x >> t.y >> n;
if (!n) return puts("-1"), 0;
s.x += 150, s.y += 150, t.x += 150, t.y += 150;
P[0].x = P[1].y = -1e9, P[2].y = P[3].x = 1e9;
for (int i = 1; i <= n; i++) {
cin >> a[i].x >> a[i].y;
a[i].x += 150, a[i].y += 150;
v[a[i].x][a[i].y] = c[a[i].x][a[i].y] = 1;
if (a[i].x < P[3].x) P[3] = a[i];
if (a[i].x > P[0].x) P[0] = a[i];
if (a[i].y < P[2].y) P[2] = a[i];
if (a[i].y > P[1].y) P[1] = a[i];
}
if (!bfs()) return puts("-1"), 0;
for (int i = 1; i <= p[0]; i++) {
if (move(p[i])) p[++p[0]] = p[i];
if (s == t) return puts(""), 0;
if (!s.in()) break;
}
if (s.y < t.y) ud(2);
if (s.y > t.y) ud(1);
if (s.x < t.x) lr(3);
if (s.x > t.x) lr(0);
puts("");
}
| 11 |
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using P = pair<int, int>;
using PL = pair<lint, lint>;
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--)
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
#define ALL(a) (a).begin(),(a).end()
constexpr int MOD = 1000000007;
constexpr lint B1 = 1532834020;
constexpr lint M1 = 2147482409;
constexpr lint B2 = 1388622299;
constexpr lint M2 = 2147478017;
constexpr int INF = 2147483647;
void yes(bool expr) {cout << (expr ? "Yes" : "No") << "\n";}
template<class T>void chmax(T &a, const T &b) { if (a<b) a=b; }
template<class T>void chmin(T &a, const T &b) { if (b<a) a=b; }
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while(T--) {
int n;
cin >> n;
vector<int> x(n);
REP(i, n) cin >> x[i];
vector<int> y(n);
int last = x[0];
FOR(i, 1, n) {
REP(k, 30) if((x[i]>>k&1) == 0 && (last>>k&1) == 1) y[i] += 1<<k;
last = x[i] ^ y[i];
}
REP(i, n) cout << y[i] << (i!=n-1 ? " " : "");
cout << "\n";
}
} | 2 |
#include <bits/stdc++.h>
using namespace std;
long long int tc, cnt = 0, number, many, total = 0;
int rmove[4] = {0, 0, -1, 1};
int cmove[4] = {1, -1, 0, 0};
long long int power(long long int x, long long int y, long long int mod) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return (power(x, y / 2, mod) % mod * power(x, y / 2, mod) % mod) % mod;
else
return x * (power(x, y / 2, mod) % mod * power(x, y / 2, mod) % mod) % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> tc;
while (tc--) {
cin >> many;
int arr[many];
for (int i = 0; i < many; i++) cin >> arr[i];
int color[many], now = 1;
memset(color, -1, sizeof(color));
for (int i = 2; i <= 1000; i++) {
bool condition = false;
for (int j = 0; j < many; j++) {
if (color[j] == -1 && arr[j] % i == 0) {
color[j] = now;
condition = true;
}
}
if (condition) now++;
}
cout << now - 1 << endl;
for (int i = 0; i < many; i++) cout << color[i] << " ";
cout << endl;
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << " ms\n";
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.