solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
double d;
int n, m, k;
double a[222222];
double b[222222];
double ans = 0;
int main() {
cin >> n >> m >> k;
if (k >= m) {
cout << "1\n";
return 0;
}
for (int i = 0; i < n; ++i) a[i] = i + 1;
for (int i = n; i < n + m; ++i) a[i] = i + 1 - n;
for (int i = 0; i < m - k - 1; ++i) b[i] = i + 1;
for (int i = m - k - 1; i < m - k - 1 + n + k + 1; ++i)
b[i] = i + 1 - (m - k - 1);
d = 1;
for (int i = 0, j = 0; i < n + m || j < n + m;)
if (i == n + m || (d > 1 && j != (n + m)))
d = d / b[j++];
else
d = d * a[i++];
cout << max(0.0, 1.0 - d) << endl;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) {
scanf("%d", a + i);
}
vector<int> res;
int bs = 0;
while (true) {
bool need = false;
for (int k = (0); k < (n); k++)
if (a[k]) need = true;
if (!need) break;
int j;
for (j = 0;; j++) {
int mod = 1 << (j + 1);
int l = 0, r = 0;
for (int k = (0); k < (n); k++) {
int vl = (a[k] + (1 << 25)) & (mod - 1);
if (vl >= mod / 2) vl -= mod;
l = min(l, vl);
r = max(r, vl);
}
if (r - l + 1 <= (1 << j)) {
for (int k = (0); k < (j); k++) {
if (r & (1 << k)) {
res.push_back(1 << (k + bs));
} else {
res.push_back(-(1 << (k + bs)));
}
}
for (int k = (0); k < (n); k++) {
int vl = (a[k] + (1 << 25)) & (mod - 1);
if (vl >= mod / 2) vl -= mod;
a[k] -= vl;
a[k] /= mod;
}
break;
}
}
bs += j + 1;
}
printf("%d\n", int(res.size()));
for (int x : res) printf("%d ", x);
printf("\n");
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
namespace yetanother {
int n;
int a[100100];
int dpfor[100100][61];
int dpbac[100100][61];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i <= 60; i++) {
if (a[0] + 30 <= i) {
dpbac[0][i] = a[0];
} else {
dpbac[0][i] = -1e9;
}
}
for (int i = 1; i < n; i++) {
for (int j = 0; j <= 60; j++) {
if (a[i] + 30 > j) {
dpbac[i][j] = -1e9;
continue;
}
dpbac[i][j] = a[i];
if (dpbac[i - 1][j] != -1e9) {
dpbac[i][j] = max(dpbac[i][j], a[i] + dpbac[i - 1][j]);
}
}
}
for (int i = 0; i <= 60; i++) {
if (a[n - 1] + 30 <= i) {
dpfor[n - 1][i] = a[n - 1];
} else {
dpfor[n - 1][i] = -1e9;
}
}
for (int i = n - 2; i >= 0; i--) {
for (int j = 0; j <= 60; j++) {
if (a[i] + 30 > j) {
dpfor[i][j] = -1e9;
continue;
}
dpfor[i][j] = a[i];
if (dpfor[i + 1][j] != -1e9) {
dpfor[i][j] = max(dpfor[i][j], dpfor[i + 1][j] + a[i]);
}
}
}
int m = 0;
for (int i = 0; i < n; i++) {
m = max(m, dpfor[i][a[i] + 30] + dpbac[i][a[i] + 30] - 2 * a[i]);
}
cout << m << endl;
return 0;
}
} // namespace yetanother
int main() {
yetanother::main();
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
long long N, A[(1 << 17)], d, a, b, c, B, H, f;
long long pc(long long M) { return M / a; }
int main(void) {
scanf("%lld%lld%lld%lld", &N, &a, &b, &c);
B = pc(N);
if (N >= b) {
H = N - b;
f = H / (b - c);
H = b + (H % (b - c));
B = max(B, f + pc(H));
while (H >= b) {
H -= (b - c);
++f;
B = max(B, f + pc(H));
}
B = max(B, f + pc(H));
}
printf("%lld\n", B);
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i <= n; i += 1234567) {
for (int j = 0; i + j <= n; j += 123456) {
if ((n - i - j) % 1234 == 0) {
puts("YES");
return 0;
}
}
}
puts("NO");
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0)
return b;
else
return gcd(b, b % a);
}
long long cnk(long long n, long long k, long long mod) {
if (k > n) return 0;
double result = 1;
long long lal = 0;
for (long long lol = n; lol > n - k; lol--) {
result *= lol;
result /= (n - lol + 1);
}
return (long long)result;
}
vector<long long> graph[100000];
vector<long long> vec;
vector<long long> vecis;
vector<pair<pair<int, int>, int> > vec3;
long long log4(long long val) {
long long lol = 1;
long long ii = 0;
if (val == 1) {
return 1;
}
while (lol < val) {
ii++;
lol *= 4;
}
return ii;
}
bool comp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
return a.first.first > b.first.first;
}
string tostr(long long a) {
ostringstream out;
out << a;
return out.str();
}
long long power(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
return power(a, b / 2) * power(a, b / 2);
} else
return a * power(a, b - 1);
}
long long tobig(string str) {
long long res = 0;
for (long long lol = 0; lol < str.size(); lol++) {
res += (str[lol] - 48) * power(10, str.size() - 1 - lol);
}
return res;
}
int t[1000000][26];
int h;
void update(int v, int tl, int tr, int newval, int pos, int sym) {
if (tl == tr) {
t[v][sym] = newval;
return;
} else {
int tm = (tl + tr) >> 1;
if (pos <= tm) {
update(v * 2, tl, tm, newval, pos, sym);
} else {
update(v * 2 + 1, tm + 1, tr, newval, pos, sym);
}
}
t[v][sym] = t[v * 2][sym] + t[v * 2 + 1][sym];
}
int sum(long long v, int tl, int tr, int l, int r, int sym) {
cout << v << "\n";
if (l > r) return 0;
if (l == tl && r == tr) return t[v][sym];
int tm = (tl + tr) / 2;
return sum(v * 2, tl, tm, l, min(r, tm), sym) +
sum(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, sym);
}
long long su[100];
vector<bool> prime(200005, true);
vector<int> razn(100005);
long long cel(long long a, long long b) {
long long res = a / b;
if (a % b != 0) res++;
return res;
}
long long mas[10000];
long long mas1[50], mas2[50];
long long a, b, c, d;
bool check(long long m) {
long long res = 0;
for (int lol = 0; lol < a; lol++) {
if (vec[lol] > m) return true;
res += m - vec[lol];
}
return res < m;
}
vector<long long> pauk(100001, 0);
long long kolvo[1000];
int main() {
long long n, k, r1, r2;
cin >> n;
for (int lol = 0; lol < n; lol++) {
cin >> k;
long long res = 0;
while (k != 0) {
res += k % 2;
k /= 2;
}
kolvo[res]++;
}
long long res = 0;
for (int lol = 0; lol < 1000; lol++) {
res += kolvo[lol] * (kolvo[lol] - 1) / 2;
}
cout << res;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
struct Fenwick {
int a[101010], n;
void init(int sz) {
n = sz;
memset(a, 0, (n + 1) * sizeof(a[0]));
}
void add(int j) {
for (int k = j; k <= n; k += k & -k) a[k]++;
}
int calc(int j) {
int rlt = 0;
for (int k = j; k; k -= k & -k) rlt += a[k];
return rlt;
}
} Fen;
int id[101010], tmp[101010];
int *cmp_pos;
bool cmp(int i, int j) { return cmp_pos[i] < cmp_pos[j]; }
struct Problem {
int n, m;
pair<int, int> p[101010], q[101010];
void add_pnt(pair<int, int> a) { p[++n] = a; }
void add_query(pair<int, int> a) { q[++m] = a; }
long long solve() {
sort(p + 1, p + n + 1);
sort(q + 1, q + m + 1);
int mx = 0;
for (int i = 1; i <= n; i++) mx = max(mx, p[i].second);
Fen.init(mx);
long long rlt = 0;
for (int e = 1, f = 1; f <= m; f++) {
while (e <= n && p[e].first <= q[f].first) Fen.add(p[e++].second);
rlt += Fen.calc(min(q[f].second, mx));
}
return rlt;
}
} P;
vector<int> v[101010], w[101010];
int n, X, Y;
bool del[101010];
vector<pair<int, int> > S, TMP;
void DFS(int x, int fa, int len, int wei) {
if (len > X || wei > Y) return;
TMP.push_back(make_pair(len, wei));
for (int i = 0, y, z; i < v[x].size(); i++) {
y = v[x][i], z = w[x][i];
if (y == fa || del[y]) continue;
DFS(y, x, len + 1, wei + z);
}
}
long long query(vector<pair<int, int> > &v) {
P.n = P.m = 0;
for (int i = 0; i < v.size(); i++)
P.add_pnt(make_pair(v[i].second, v[i].first + 1)),
P.add_query(make_pair(Y - v[i].second, 1 + X - v[i].first));
return P.solve();
}
long long ans;
void calc(int x) {
S.clear();
for (int i = 0, y, z; i < v[x].size(); i++) {
y = v[x][i], z = w[x][i];
if (del[y]) continue;
TMP.clear();
DFS(y, x, 1, z);
ans -= query(TMP);
for (int j = 0; j < TMP.size(); j++) S.push_back(TMP[j]);
}
ans += query(S);
ans += S.size() * 2;
}
int nodes, node[101010], ms[101010], sz[101010];
void dfs(int x, int fa = 0) {
node[++nodes] = x;
ms[x] = 0, sz[x] = 1;
for (int i = 0, y; i < v[x].size(); i++) {
y = v[x][i];
if (y == fa || del[y]) continue;
dfs(y, x);
sz[x] += sz[y];
ms[x] = max(ms[x], sz[y]);
}
}
void solve(int x) {
nodes = 0;
dfs(x);
int rt = 0;
for (int i = 1, tmp; i <= nodes; i++) {
if (max(ms[node[i]], nodes - sz[node[i]]) <= nodes / 2) {
rt = node[i];
break;
}
}
del[rt] = 1;
calc(rt);
for (int i = 0, y; i < v[rt].size(); i++) {
y = v[rt][i];
if (del[y]) continue;
solve(y);
}
}
int main() {
scanf("%d %d %d", &n, &X, &Y);
for (int i = 2, j, z; i <= n; i++) {
scanf("%d %d", &j, &z);
v[i].push_back(j);
v[j].push_back(i);
w[i].push_back(z);
w[j].push_back(z);
}
ans = 0;
solve(1);
printf("%I64d\n", ans / 2);
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
const int mod = 1000000007;
const long long Lbig = 2e18;
inline long long getnum() {
register long long r = 0;
register bool ng = 0;
register char c;
c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') ng = 1, c = getchar();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = getchar();
if (ng) r = -r;
return r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline void putsp() { putchar(' '); }
inline void putendl() { putchar('\n'); }
inline char mygetchar() {
register char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
pair<long long, int> dp[2211][2211];
long long a[2211], b[2211];
int n, k;
long long calc(long long coef) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]);
if (i <= j)
dp[i][j] =
min(dp[i][j], make_pair(dp[i - 1][j - 1].first + a[i] + b[j] + coef,
dp[i - 1][j - 1].second + 1));
}
}
return dp[n][n].second;
}
int main() {
n = getnum(), k = getnum();
for (int i = 1; i <= n; i++) a[i] = getnum();
for (int i = 1; i <= n; i++) b[i] = getnum();
long long l = -Imx, r = Imx;
while (l <= r) {
long long m = l + r >> 1;
int curk = calc(m);
if (curk >= k)
l = m + 1;
else
r = m - 1;
}
calc(r);
cout << dp[n][n].first - r * k << endl;
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int k = 1;
int all = 0;
int s = 0;
while (all + k <= n) {
n -= k;
s++;
if (k == 1)
k = 2;
else
k = 1;
}
cout << s << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500008;
int fa[maxn], a[maxn], n;
int p[maxn][21], cnt[maxn];
struct Tseg {
int size, s[maxn << 2], n;
inline int update(int i, int j) { return a[i] < a[j] ? i : j; }
void init(int len, int a[]) {
n = len;
size = 1;
while (size < n + 2) size <<= 1;
memset(s, 0, sizeof(s));
for (int i = 1; i <= n; i++) s[size + i] = i;
for (int i = size - 1; i >= 1; i--) s[i] = update(s[i << 1], s[i << 1 ^ 1]);
}
int ask(int l, int r) {
l += size - 1;
r += size + 1;
int ans = 0;
while (l ^ r ^ 1) {
if (l & 1 ^ 1) ans = update(s[l ^ 1], ans);
if (r & 1) ans = update(s[r ^ 1], ans);
l >>= 1;
r >>= 1;
}
return ans;
}
} Seg_Tree;
struct Tprogram {
void open() {
freopen("1.in", "r", stdin);
freopen("1.out", "w", stdout);
}
void close() {}
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) a[i + n] = a[i];
for (int i = 1; i <= 2 * n; i++) a[i] = (i - a[i] > 1 ? i - a[i] : 1);
a[0] = 1e9;
Seg_Tree.init(2 * n, a);
}
void work() {
for (int i = 2 * n; i >= 1; i--) fa[i] = Seg_Tree.ask(a[i], i - 1);
for (int i = 1; i <= 2 * n; i++) {
p[i][0] = fa[i];
for (int j = 1; j <= 19; j++) {
p[i][j] = p[p[i][j - 1]][j - 1];
if (!p[i][j]) break;
}
}
long long ans = 0;
for (int i = 2 * n; i >= n + 1; i--) {
int u = i;
for (int j = 19; j >= 0; j--) {
if (!p[u][j]) continue;
if (a[p[u][j]] > i - n + 1) ans += 1 << j, u = p[u][j];
}
if (a[u] <= i - n + 1)
ans++;
else
ans += 2;
}
printf("%I64d\n", ans);
}
} Program;
int main() {
Program.init();
Program.work();
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using tpl = tuple<int, int, int>;
using pcc = pair<char, char>;
const int inf = 9999999;
const ll mod = 1e9 + 7;
int dr[] = {-1, 0, 1, 0};
int dc[] = {0, 1, 0, -1};
int kr[] = {-1, 1, -2, -2, -1, 1, 2, 2};
int kc[] = {-2, -2, -1, 1, 2, 2, -1, 1};
vector<ll> ans;
void solve(ll num) {
ans.push_back(num);
if (num > 1e9) return;
solve(num * 10 + 4);
solve(num * 10 + 7);
}
int main() {
int n;
cin >> n;
solve(0);
sort(begin(ans), end(ans));
cout << lower_bound(begin(ans), end(ans), n) - ans.begin() << endl;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, t = 1;
register char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = -1, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return x * t;
}
int p[111111], a[111111], n, m, q[111111], nt[111111], lt[111111];
set<pair<int, int> > S;
bool cmp(int a, int b) { return p[a] < p[b]; }
int calc(int x, int y) {
if (x == y) return 1e9;
int d = (p[y] - p[x] + m) % m;
if (y < x) d = (d + a[y]) % m;
if (d <= a[x]) return 1;
if (a[x] <= a[y]) return 1e9;
return (d - a[y] - 1) / (a[x] - a[y]) + 1;
}
int main() {
n = read();
m = read();
for (int i = 1; i <= n; ++i) p[i] = read() - 1, a[i] = read(), q[i] = i;
sort(&q[1], &q[n + 1], cmp);
for (int i = 1; i <= n; ++i) nt[q[i]] = q[i + 1], lt[q[i]] = q[i - 1];
nt[q[n]] = q[1];
lt[q[1]] = q[n];
for (int i = 1; i <= n; ++i) S.insert(make_pair(calc(i, nt[i]), i));
while (233) {
pair<int, int> u = *S.begin();
if (u.first == 1e9) break;
int v = u.second;
S.erase(S.begin());
S.erase(make_pair(calc(nt[v], nt[nt[v]]), nt[v]));
if (!S.empty()) S.erase(make_pair(calc(lt[v], v), lt[v]));
p[v] += calc(v, nt[v]);
p[v] %= m;
--a[v];
nt[v] = nt[nt[v]];
lt[nt[v]] = v;
S.insert(make_pair(calc(lt[v], v), lt[v]));
S.insert(make_pair(calc(v, nt[v]), v));
}
printf("%d\n", S.size());
for (set<pair<int, int> >::iterator it = S.begin(); it != S.end(); ++it)
printf("%d ", it->second);
puts("");
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
int num[205];
int main() {
ios::sync_with_stdio(false);
int T, n;
set<int> ss;
cin >> T;
while (T--) {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> num[i];
}
ss.clear();
for (int i = 0; i < n; ++i) {
ss.insert(num[i] - num[(i + 1) % n]);
}
if (ss.size() < 2) {
cout << "YES\n";
} else if (ss.size() == 2) {
auto it = ss.begin();
int a = abs(*it) == 1 ? *it : (*ss.rbegin());
int b = abs(*it) != 1 ? *it : (*ss.rbegin());
if (abs(a) != 1 || abs(b) != n - 1 || a * b >= 0)
cout << "NO\n";
else
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
| 2
|
#include <bits/stdc++.h>
double t[5], temp;
double x_1, y_1, r1, x2, y2, r2, x3, y3, r3, X = 0.0, Y = 0.0;
int f = 0;
double check(double dx, double dy) {
double ret = 0.0;
t[0] = sqrt(((dx - x_1) * (dx - x_1)) + ((dy - y_1) * (dy - y_1))) / r1;
t[1] = sqrt(((dx - x2) * (dx - x2)) + ((dy - y2) * (dy - y2))) / r2;
t[2] = sqrt(((dx - x3) * (dx - x3)) + ((dy - y3) * (dy - y3))) / r3;
ret += ((t[0] - t[1]) * (t[0] - t[1]));
ret += ((t[1] - t[2]) * (t[1] - t[2]));
ret += ((t[2] - t[0]) * (t[2] - t[0]));
return ret;
}
int main() {
double s;
scanf("%lf%lf%lf", &x_1, &y_1, &r1);
scanf("%lf%lf%lf", &x2, &y2, &r2);
scanf("%lf%lf%lf", &x3, &y3, &r3);
X = (x2 + x3 + x_1) / 3 + 0.1;
Y = (y2 + y3 + y_1) / 3 + 0.1;
for (s = 1; s > (1e-6); f = 0) {
temp = check(X, Y);
if (temp > check(X + s, Y))
X += s, f = 1;
else if (temp > check(X - s, Y))
X -= s, f = 1;
else if (temp > check(X, Y + s))
Y += s, f = 1;
else if (temp > check(X, Y - s))
Y -= s, f = 1;
if (!f) s *= 0.7;
}
if (check(X, Y) < (1e-5)) printf("%.5lf %.5lf\n", X, Y);
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << (n - 2) * (n - 2) << endl;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const int M = 5e3 + 3;
int n, p, dp[M][M], ans[M], cnt[M], now;
string s;
bool mark[M][M], markp[M][M], palin[M][M];
bool ispal(int l, int r) {
if (l == r || l > r) return true;
if (markp[l][r]) return palin[l][r];
markp[l][r] = true;
if (s[l] == s[r] && ispal(l + 1, r - 1)) palin[l][r] = true;
return palin[l][r];
}
int mem(int l, int r) {
if (mark[l][r]) return dp[l][r];
mark[l][r] = true;
if (!ispal(l, r)) return dp[l][r] = 0;
if (r <= l) return dp[l][r] = 1;
int mid, mid2;
if ((r - l + 1) % 2) {
mid = (l + r) / 2 - 1;
mid2 = mid + 2;
} else {
mid = (l + r) / 2;
mid2 = mid + 1;
}
return dp[l][r] = min(mem(l, mid), mem(mid2, r)) + 1;
}
int main() {
cin >> s;
n = s.size();
s = "0" + s;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) cnt[mem(i, j)]++;
for (int i = n; i >= 1; i--) {
now += cnt[i];
ans[i] = now;
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int n, x, y, result;
int discover(int vals[], int size) {
int from = 0, to = size;
while (from + 1 < to) {
int mid = (from + to) / 2;
cout << "? " << (mid - from);
for (int i = from; i < mid; i++) {
cout << " " << vals[i];
}
cout << "\n";
cin >> result;
if ((mid - from) % 2 == 1) {
if (result == x) {
from = mid;
} else {
to = mid;
}
} else {
if (result == 0) {
from = mid;
} else {
to = mid;
}
}
fflush(stdout);
}
return vals[from];
}
int main() {
cin >> n >> x >> y;
int pom = 0;
int differ[1001], sizeDiff = 0;
while ((1 << pom) <= n) {
int size = 0;
int mem = (1 << pom);
for (int i = 1; i <= n; i++) {
if (i & mem) size++;
}
cout << "? " << size;
for (int i = 1; i <= n; i++) {
if (i & mem) cout << " " << i;
}
cout << "\n";
cin >> result;
if (size % 2 == 1) {
if (result != x) differ[sizeDiff++] = pom;
} else {
if (result != 0) differ[sizeDiff++] = pom;
}
fflush(stdout);
pom++;
}
int size = 0, vals[1001];
for (int i = 1; i <= n; i++) {
if (i & (1 << differ[0])) vals[size++] = i;
}
int p1 = discover(vals, size), p2;
p2 = p1;
for (int j = 0; j < sizeDiff; j++) {
p2 ^= (1 << differ[j]);
}
if (p1 > p2) swap(p1, p2);
cout << "! " << p1 << " " << p2 << "\n";
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1234567;
int fenw[N];
void modify(int x, int v) {
while (x < N) {
fenw[x] += v;
x = (x | (x - 1)) + 1;
}
}
int find_sum(int x) {
int v = 0;
while (x > 0) {
v += fenw[x];
x &= x - 1;
}
return v;
}
int a[N], b[N], dir[N];
int k;
vector<int> ret;
vector<int> g[N];
void solve(int root, int to) {
if (root > to) {
return;
}
if (root == to) {
ret.push_back(root);
return;
}
int sz = g[root].size();
int sfrom = root;
int sto = to;
for (int q = 0; q < sz; q++) {
int j = g[root][q];
if (dir[j] == 0) {
if (b[j] > sfrom) {
sfrom = b[j];
}
}
if (dir[j] == 1) {
if (b[j] - 1 < sto) {
sto = b[j] - 1;
}
}
modify(a[j], -1);
modify(b[j], 1);
}
int parity = 0;
while (sfrom <= sto) {
if (parity) {
if (find_sum(sfrom) == 0) {
solve(root + 1, sfrom);
ret.push_back(root);
solve(sfrom + 1, to);
return;
}
sfrom++;
} else {
if (find_sum(sto) == 0) {
solve(root + 1, sto);
ret.push_back(root);
solve(sto + 1, to);
return;
}
sto--;
}
parity ^= 1;
}
puts("IMPOSSIBLE");
exit(0);
}
int main() {
int n;
scanf("%d %d", &n, &k);
char foo[42];
for (int i = 1; i <= n; i++) {
fenw[i] = 0;
g[i].clear();
}
for (int i = 0; i < k; i++) {
scanf("%d %d %s", a + i, b + i, foo);
if (a[i] < 1 || a[i] > n || b[i] < 1 || b[i] > n || b[i] <= a[i]) {
puts("IMPOSSIBLE");
return 0;
}
dir[i] = (foo[0] == 'L' ? 0 : 1);
modify(a[i], 1);
modify(b[i], -1);
g[a[i]].push_back(i);
}
ret.clear();
solve(1, n);
for (int i = 0; i < n - 1; i++) {
printf("%d ", ret[i]);
}
printf("%d\n", ret[n - 1]);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while(t--) {
int r, c;
cin >> r >> c;
char b[r][c+1];
for(int i=0; i<r; i++) cin >> b[i];
int ll[r][c], rl[r][c];
for(int i=0; i<r; i++) {
int lcntr=0, rcntr=0;
for(int j=0; j<c; j++) {
lcntr += ((b[i][j] == '*') ? 1 : -lcntr);
rcntr += ((b[i][c-1-j] == '*') ? 1 : -rcntr);
ll[i][j] = lcntr;
rl[i][c-j-1] = rcntr;
}
}
long long int ans=0;
for(int i=0; i<r; i++) {
for(int j=0; j<c; j++) {
if(b[i][j] == '*') {
for(int k=1; i+k-1<r && (ll[i+k-1][j] >= k && rl[i+k-1][j] >= k); k++) {
ans++;
}
}
}
}
cout << ans << endl;
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
long long ans = 0, powi[52];
long long mytree(long long h, long long n, bool lft) {
if (h == 0) return 0;
if (n <= powi[h - 1]) {
if (lft) {
return mytree(h - 1, n, false) + 1;
} else {
return mytree(h - 1, n, false) + powi[h];
}
} else {
if (lft) {
return mytree(h - 1, n - powi[h - 1], true) + powi[h];
} else {
return mytree(h - 1, n - powi[h - 1], true) + 1;
}
}
}
int main() {
long long n, h;
powi[0] = 1;
for (int i = 1; i <= 51; i++) {
powi[i] = powi[i - 1] * 2;
}
cin >> h >> n;
ans = mytree(h, n, true);
cout << ans << endl;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
long long k, a, b;
int M = 1e9 + 7;
int d[2001][2001];
void exgcd(int a, int b, int &x, int &y) {
if (b == 0) {
x = 1;
y = 0;
} else {
exgcd(b, a % b, y, x);
y -= a / b * x;
}
}
int inv(int t, int m) {
int x, y;
exgcd(t, m, x, y);
return (x + m) % m;
}
int main() {
cin >> k >> a >> b;
int ab = inv(a + b, M);
for (int i = 1999; i >= 1; i--)
for (int j = 1999; j >= 0; j--) {
d[i][j] = (j >= k) ? j
: (i + j >= k)
? (a * inv(b, M) + i + j) % M
: (a * ab % M * d[i + 1][j] + b * ab % M * d[i][i + j]) % M;
}
cout << d[1][0] << endl;
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-12;
inline int sgn(long double u) {
if (u > eps)
return 1;
else if (u < -eps)
return -1;
else
return 0;
}
long double x, y, z;
long double a[12];
string ans[12];
pair<long double, int> u[12];
int main() {
while (cin >> x >> y >> z) {
ans[0] = "x^y^z";
ans[1] = "x^z^y";
ans[2] = "(x^y)^z";
ans[3] = "(x^z)^y";
ans[4] = "y^x^z";
ans[5] = "y^z^x";
ans[6] = "(y^x)^z";
ans[7] = "(y^z)^x";
ans[8] = "z^x^y";
ans[9] = "z^y^x";
ans[10] = "(z^x)^y";
ans[11] = "(z^y)^x";
a[0] = exp(z * log(y)) * log(x);
a[1] = exp(y * log(z)) * log(x);
a[2] = y * z * log(x);
a[3] = y * z * log(x);
a[4] = exp(z * log(x)) * log(y);
a[5] = exp(x * log(z)) * log(y);
a[6] = x * z * log(y);
a[7] = x * z * log(y);
a[8] = exp(y * log(x)) * log(z);
a[9] = exp(x * log(y)) * log(z);
a[10] = x * y * log(z);
a[11] = x * y * log(z);
for (int i = 0; i < 12; i++) {
u[i].first = -a[i];
u[i].second = i;
}
sort(u, u + 12);
cout << ans[u[0].second] << endl;
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, ans = 0, c = 0;
cin >> n >> m;
long long books[n], upay[m];
for (long long i = 0; i < n; i++) {
cin >> books[i];
}
sort(books, books + n);
for (long long i = 1; i < m; i++) {
long long k = 0;
for (long long j = 0; j < n; j++) {
if (i == books[j]) {
c++;
k++;
}
}
ans += k * (n - c);
}
cout << ans << endl;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int N, QAQ, k, s[maxn];
long long nu[maxn << 2], a, b;
struct Node {
int le, ri;
long long nua, nub;
} A[maxn << 2];
void Build(int i, int le, int ri) {
A[i].le = le, A[i].ri = ri;
A[i].nua = A[i].nub = 0LL;
if (le == ri) {
s[le] = i;
return;
}
int mid = (A[i].le + A[i].ri) >> 1;
Build((i << 1), le, mid);
Build((i << 1 | 1), mid + 1, ri);
}
inline void Update(int p, long long c) {
p = s[p];
nu[p] += c;
A[p].nua = (nu[p] < a ? nu[p] : a);
A[p].nub = (nu[p] < b ? nu[p] : b);
p >>= 1;
while (p) {
A[p].nua = A[p << 1].nua + A[p << 1 | 1].nua;
A[p].nub = A[p << 1].nub + A[p << 1 | 1].nub;
p >>= 1;
}
}
long long Query(int i, int le, int ri, int tc) {
if (A[i].le <= le && le <= ri && ri <= A[i].ri) {
if (A[i].le == le && A[i].ri == ri) return tc == 1 ? A[i].nua : A[i].nub;
int mid = (A[i].le + A[i].ri) >> 1;
if (ri <= mid)
return Query((i << 1), le, ri, tc);
else if (le > mid)
return Query((i << 1 | 1), le, ri, tc);
else {
return (Query((i << 1), le, mid, tc) +
Query((i << 1 | 1), mid + 1, ri, tc));
}
} else
return 0LL;
}
int main() {
scanf("%d%d%I64d%I64d%d", &N, &k, &a, &b, &QAQ);
for (int i = 0; i <= N * 4 + 1; ++i) nu[i] = 0LL;
Build(1, 1, N);
int tc;
long long vl;
while (QAQ--) {
scanf("%d", &tc);
if (tc == 1) {
scanf("%d%I64d", &tc, &vl);
Update(tc, vl);
} else if (tc == 2) {
scanf("%d", &tc);
printf("%I64d\n", Query(1, 1, tc - 1, 2) + Query(1, tc + k, N, 1));
}
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
long long dp[maxn][35];
long long sum[maxn][35];
int f[maxn][35];
int n;
long long k;
void init() {
for (int i = 0; i < maxn - 1; i++) {
for (int j = 0; j < 35; j++) {
dp[i][j] = 1e18;
}
}
}
void DP() {
for (long long j = 1; (1LL << j) <= k; j++) {
for (int i = 0; i < n; i++) {
int p = f[i][j - 1];
f[i][j] = f[p][j - 1];
dp[i][j] = min(dp[i][j], min(dp[i][j - 1], dp[p][j - 1]));
sum[i][j] += sum[i][j - 1] + sum[p][j - 1];
}
}
}
int main() {
init();
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
f[i][0] = x;
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
dp[i][0] = x;
sum[i][0] = x;
}
DP();
for (int i = 0; i < n; i++) {
long long T = k;
long long ans1 = 1e18;
long long ans2 = 0;
int pre = i;
for (int j = 34; j >= 0; j--) {
if ((1LL << j) <= T) {
ans1 = min(ans1, dp[pre][j]);
ans2 += sum[pre][j];
pre = f[pre][j];
T -= (1LL << j);
}
if (T == 0) break;
}
cout << ans2 << " " << ans1 << endl;
}
}
| 13
|
#include <bits/stdc++.h>
inline int read() {
int data = 0, w = 1;
char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (ch >= '0' && ch <= '9') data = data * 10 + (ch ^ 48), ch = getchar();
return data * w;
}
const int N(20), M(1 << 16);
int n, m, a[N], ans[N];
long long Y, f[M];
int main() {
n = read(), scanf("%lld", &Y), Y -= 2000, m = read();
for (int i = 1, a, b; i <= m; i++)
a = read() - 1, b = read() - 1, ::a[b] |= (1 << a);
for (int i = 0; i < n; i++) ans[i] = -1;
long long q = 0;
for (int p = 0; p < n; p++)
for (ans[p] = 0;; ++ans[p]) {
if (ans[p] >= n) return puts("The times have changed"), 0;
int fl = 1;
for (int i = 0; i < p; i++)
if (ans[p] == ans[i]) {
fl = 0;
break;
}
if (!fl) continue;
std::memset(f, 0, sizeof f), f[0] = 1;
for (int i = 0; i < (1 << n) - 1; i++)
if (f[i])
for (int j = 0, c = __builtin_popcount(i); j < n; j++)
if ((!(i >> j & 1)) && (ans[j] == -1 || ans[j] == c) &&
((a[j] & i) == a[j]))
f[i | (1 << j)] += f[i];
if (q + f[(1 << n) - 1] >= Y) break;
q += f[(1 << n) - 1];
}
for (int i = 0; i < n; i++) printf("%d%c", ans[i] + 1, " \n"[i == n - 1]);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k, l, m, n, h;
cin >> n;
j = 0;
vector<long long> v(n);
for (i = 0; i < n; i++) {
cin >> v[i];
j += v[i];
}
string s1 = "";
i = 0;
while (j > 0) {
if (v[i] > 0 && i + 1 < n) {
j--;
s1 += "P";
v[i]--;
if (v[i] > 0) {
if (v[i + 1] > 0 && i + 1 < n) {
j--;
s1 += "RPL";
v[i + 1]--;
} else if (v[i + 1] == 0) {
s1 += "RL";
}
}
} else if (v[i] > 0 && i + 1 == n) {
s1 += "P";
v[i]--;
j--;
if (v[i] > 0) s1 += "LR";
} else {
s1 += "R";
i++;
}
}
cout << s1;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s = "<3";
cin >> n;
string temp;
while (n--) {
cin >> temp;
s += temp;
s += "<3";
}
string comp;
cin >> comp;
int j = 0;
for (int i = 0; i < comp.size() && j < s.size();) {
if (s[j] == comp[i]) {
i++;
j++;
} else
i++;
}
if (j < s.size())
cout << "no";
else
cout << "yes";
return 0;
}
| 7
|
#include <bits/stdc++.h>
double t1, t2, t0;
int dblcmp(double n) { return n < -1e-12 ? -1 : n > 1e-12; }
double fun(int y1, int y2) { return (t1 * y1 + t2 * y2) / (y1 + y2); }
int main() {
int x1, x2;
while (scanf("%lf %lf %d %d %lf", &t1, &t2, &x1, &x2, &t0) != EOF) {
if (dblcmp(t1 - t2) == 0) {
printf("%d %d\n", x1, x2);
} else if (dblcmp(t1 - t0) == 0) {
printf("%d %d\n", x1, 0);
} else if (dblcmp(t2 - t0) == 0) {
printf("%d %d\n", 0, x2);
} else {
int y1 = -1;
int y2 = -1;
double delta = 1e30;
for (int j = 1; j <= x2; j++) {
int i = 0;
double delta_tmp = fun(i, j) - t0;
if (dblcmp(delta_tmp) < 0) {
continue;
} else if (dblcmp(delta_tmp - delta) < 0) {
delta = delta_tmp;
y1 = i;
y2 = j;
} else if (dblcmp(delta_tmp - delta) == 0) {
if (i + j > y1 + y2) {
y1 = i;
y2 = j;
}
}
}
for (int i = 1; i <= x1; i++) {
int j = (int)((t0 - t1) / (t2 - t0) * i) - 1;
if (j < 0) {
j = 0;
}
while (j <= x2 && dblcmp(fun(i, j) - t0) < 0) {
j++;
}
if (j > x2) {
continue;
}
double delta_tmp = fun(i, j) - t0;
if (dblcmp(delta_tmp - delta) < 0) {
delta = delta_tmp;
y1 = i;
y2 = j;
} else if (dblcmp(delta_tmp - delta) == 0) {
if (i + j > y1 + y2) {
y1 = i;
y2 = j;
}
}
}
printf("%d %d\n", y1, y2);
}
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int x[110];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
int ans = 1;
for (int i = 1; i <= n; i++) {
if (i > 1 && x[i - 1] && x[i])
ans += 5;
else if (x[i])
ans++;
if (i > 1 && !x[i - 1] && !x[i]) {
ans = -1;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
template <typename T>
T gcd(T a, T b) {
if (b <= a) std::swap(a, b);
while (a) {
T a0 = a;
a = b % a0;
b = a0;
}
return b;
}
using namespace std;
int main() {
long long w, h, x, y, a, b;
{
cin >> w >> h >> x >> y >> a >> b;
long long d = gcd(a, b);
a /= d;
b /= d;
}
long long t = min(w / a, h / b);
long long p = x, q = y;
auto x1 = [&]() -> long long { return p - (a * t + 1) / 2; };
auto y1 = [&]() -> long long { return q - (b * t + 1) / 2; };
auto x2 = [&]() -> long long { return p + a * t / 2; };
auto y2 = [&]() -> long long { return q + b * t / 2; };
p -= min(0ll, x1());
q -= min(0ll, y1());
p -= max(0ll, x2() - w);
q -= max(0ll, y2() - h);
cout << x1() << " " << y1() << " " << x2() << " " << y2() << endl;
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int sz = 1500000;
const long long MAX = 10000000000000000;
template <typename T>
T abs(T a) {
return a < 0 ? -a : a;
}
struct point {
long double y, len;
long long ind;
point(long double cy = 0, long long cind = 0, long double clen = 0)
: y(cy), ind(cind), len(clen) {}
bool operator<(const point& b) const { return this->y < b.y; }
bool operator>(const point& b) const { return this->y > b.y; }
bool operator==(const point& b) const { return this->y < b.y; }
};
int main() {
long long n, k;
cin >> n >> k;
vector<int> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> preobr;
preobr.reserve(n);
preobr.push_back(a[0]);
vector<int> stress(k, 0);
for (int i = 1; i < n; i++) {
if (preobr.back() != a[i]) {
preobr.push_back(a[i]);
}
}
for (long long i = 0; i < preobr.size(); i++) {
if (i == 0 || i == preobr.size() - 1) {
stress[preobr[i] - 1]++;
} else {
if (preobr[i - 1] == preobr[i + 1])
stress[preobr[i] - 1] += 2;
else
stress[preobr[i] - 1]++;
}
}
int maxV = 0, ind;
for (long long i = 0; i < k; i++) {
if (maxV < stress[i]) {
ind = i;
maxV = stress[i];
}
}
cout << ind + 1 << endl;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > vec[100000];
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
long long int visited[100000];
long long int dfs(long long int i, long long int ma) {
visited[i] = 1;
long long int ans = 0;
long long int mark = 0;
for (long long int j = 0; j < vec[i].size(); j++) {
if (visited[vec[i][j].first] == 0) {
visited[vec[i][j].first] = 1;
int l = dfs(vec[i][j].first, vec[i][j].second);
mark = 1;
ans = max(ans, l + vec[i][j].second);
}
}
if (mark == 0)
return 0;
else
return ans;
}
int main() {
std::ios::sync_with_stdio(false);
long long int n, a, b, c, sum = 0;
cin >> n;
for (long long int i = 0; i < n - 1; i++) {
cin >> a >> b >> c;
vec[a].push_back(make_pair(b, c));
vec[b].push_back(make_pair(a, c));
sum = sum + 2 * c;
}
long long int ans = dfs(1, 0);
cout << sum - ans;
}
| 10
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
map<int,long long>x;
long long ans=0;
for(int i=1;i<=n;i++)
{
int v;
cin>>v;
ans += x[v] * (n-i+1);
x[v]+=i;
//cout<<ans<<endl;
}
cout<<ans<<endl;
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
char x = getchar();
long long ans = 0, flag = 1;
while (!isdigit(x))
if (x == '-')
flag = -1, x = getchar();
else
x = getchar();
while (isdigit(x)) ans = ans * 10 + x - '0', x = getchar();
return ans * flag;
}
const long long p = 233, mod = 1e9 + 7;
char s[1000005];
long long n, sum[1000005], cf[1000005], dp[1000005];
signed main() {
memset(dp, -1, sizeof(dp));
scanf("%lld%s", &n, s + 1);
cf[0] = 1;
for (long long i = 1; i <= n; i++) cf[i] = cf[i - 1] * p % mod;
for (long long i = 1; i <= n; i++)
sum[i] = (sum[i - 1] * p % mod + s[i]) % mod;
for (long long i = 1; i <= (n + 1) / 2; i++) {
long long l = 0, r = i - 1, mid, ans = -1;
if (i == (n + 1) / 2 && (n & 1)) break;
while (l <= r) {
mid = (l + r) >> 1;
long long tmp1 =
(sum[i] - sum[i - mid - 1] * cf[mid + 1] % mod + mod) % mod;
long long tmp2 =
(sum[i + mid] - sum[i - 1] * cf[mid + 1] % mod + mod) % mod;
long long tmpp1 =
(sum[n - i + 1] - sum[n - i - mid] * cf[mid + 1] % mod + mod) % mod;
long long tmpp2 =
(sum[n - i + 1 + mid] - sum[n - i] * cf[mid + 1] % mod + mod) % mod;
if (tmp1 == tmpp1 && tmp2 == tmpp2) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
dp[i - ans] = max(dp[i - ans], ans * 2 + 1);
}
for (long long i = 1; i <= (n + 1) / 2; i++) {
dp[i] = max(dp[i], dp[i - 1] - 2);
if (dp[i] <= 0)
cout << -1 << ' ';
else
cout << dp[i] << ' ';
}
return 0;
}
| 19
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x7fffffffffffffff;
const double eps = 1e-8;
unsigned int seed = 19260817;
const unsigned int _RAND_MAX_ = 4294967295u;
__inline__ __attribute__((always_inline)) unsigned int Rand() {
return seed = seed * 998244353u + 1000000007u;
}
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
return a > 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) {
return a < b ? b : a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) {
return a < b ? a : b;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
(a > b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) bool _cmp(const _Tp &a,
const _Tp &b) {
return abs(a - b) <= eps;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
register char ch(getchar());
bool f(false);
while (ch < 48 || ch > 57) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (ch >= 48 && ch <= 57)
x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
if (f) x = -x;
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
register char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
register char *tar = s;
*tar = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 2005;
const int mod = 1000000007;
char s[N][N];
int dp[N][N];
int cnt1[N][N], cnt2[N][N];
__inline__ __attribute__((always_inline)) void _add(int &A, const int &B) {
(A += B) >= mod && (A -= mod);
}
__inline__ __attribute__((always_inline)) void _sub(int &A, const int &B) {
(A -= B) < 0 && (A += mod);
}
struct BIT {
int c[N];
__inline__ __attribute__((always_inline)) void add(int x, const int &C) {
for (; x <= 2000; x += ((x) & (-x))) {
_add(c[x], C);
}
}
__inline__ __attribute__((always_inline)) void sub(int x, const int &C) {
for (; x <= 2000; x += ((x) & (-x))) {
_sub(c[x], C);
}
}
__inline__ __attribute__((always_inline)) int sum(int x) {
int ans = 0;
for (; x; x -= ((x) & (-x))) {
_add(ans, c[x]);
}
return ans;
}
} tr1[N], tr2[N];
__inline__ __attribute__((always_inline)) void Upd1(int x, int l, int r,
const int &C) {
tr1[x].add(l, C);
tr1[x].sub(r + 1, C);
}
__inline__ __attribute__((always_inline)) void Upd2(int x, int l, int r,
const int &C) {
tr2[x].add(l, C);
tr2[x].sub(r + 1, C);
}
int main() {
int n, m;
read(n, m);
if (n == 1 && m == 1) {
printf("1\n");
return 0;
}
for (int i = 1; i <= n; ++i) {
read_str(s[i] + 1);
int cnt = 0;
for (int j = 1; j <= m; ++j) {
cnt += s[i][j] == 'R';
cnt1[i][j] = cnt;
}
}
for (int i = 1; i <= m; ++i) {
int cnt = 0;
for (int j = 2; j <= n; ++j) {
cnt += s[j][i] == 'R';
cnt2[j][i] = cnt;
}
}
Upd1(1, 1, 1, 1);
Upd2(1, 1, 1, 1);
int a = 0, b = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
a = tr1[i].sum(j);
b = tr2[j].sum(i);
int sum = cnt2[n][j] - cnt2[i][j];
Upd2(j, i + 1, n - sum, a);
sum = cnt1[i][m] - cnt1[i][j];
Upd1(i, j + 1, m - sum, b);
}
}
_add(a, b);
printf("%d\n", a);
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int t;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
for (int q = 0; q < t; q++) {
string a;
int len;
cin >> len >> a;
bool palin = true;
for (int i = 0; i < len / 2; i++) {
if (a[i] != a[len - i - 1] && abs((int)a[i] - a[len - i - 1]) != 2) {
palin = false;
break;
}
}
string res = (palin) ? "YES" : "NO";
cout << res << '\n';
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, j, k, count;
string s = "";
cin >> s;
bool f = 1;
for (i = 0; i < s.size(); i++) {
bool flag[26] = {0};
f = 1;
count = 0;
for (j = i; j < i + 26; j++) {
if (s[j] == '?') continue;
if (!flag[s[j] - 'A']) {
flag[s[j] - 'A'] = 1;
count++;
} else {
f = 0;
count = 0;
break;
}
}
if (f) {
for (j = i; j < i + 26; j++) {
if (s[j] == '?') {
for (k = 0; k < 26; k++) {
if (!flag[k]) {
flag[k] = 1;
s[j] = k + 'A';
break;
}
}
}
}
for (j = 0; j < s.length(); j++) {
if (s[j] == '?')
cout << "A";
else
cout << s[j];
}
break;
}
}
if (!f) cout << "-1" << endl;
}
| 5
|
#include <bits/stdc++.h>
inline int Time(int a, int b, int m) {
return (b < a) ? 2 * m - 2 + b - a : b - a;
}
inline int min(int a, int b) { return (a < b) ? a : b; }
inline int mirror(int a, int m) { return m - 1 - (a - m + 1); }
inline int state(int t, int m) { return t % (2 * m - 2); }
int main() {
int n = 0;
int m = 0;
int s = 0;
int f = 0;
int t = 0;
char* line = (char*)malloc(30 * sizeof(char));
gets(line);
sscanf(line, "%d %d", &n, &m);
while (gets(line)) {
sscanf(line, "%d %d %d", &s, &f, &t);
if (s == f) {
printf("%d\n", t);
} else {
--s;
--f;
int boardTime =
t + min(Time(state(t, m), s, m), Time(state(t, m), mirror(s, m), m));
int boardState = state(boardTime, m);
printf("%d\n", boardTime + min(Time(boardState, f, m),
Time(boardState, mirror(f, m), m)));
}
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
long long q, n;
void solve() {
long long n, k;
cin >> n >> k;
long long left = 1, right = 2e9 + 1e6;
while (left <= right) {
long long mid = (left + right) / 2;
if (mid % n == 0) {
if (mid - (mid / n) < k) {
left = mid + 1;
} else {
right = mid - 1;
}
} else {
if (mid - (mid / n) < k) {
left = mid + 1;
} else if (mid - (mid / n) > k) {
right = mid - 1;
} else {
cout << mid << "\n";
;
return;
}
}
}
return;
}
int main() {
int q;
cin >> q;
while (q--) {
solve();
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
class Forest {
public:
int n, m;
vector<vector<int> > adj, par;
vector<int> dep, tin;
int timer;
Forest(int n_, int m_, vector<pair<int, int> > edge) {
n = n_;
m = m_;
adj.resize(n);
for (int i = 0; i < m; i++) {
int u = edge[i].first;
int v = edge[i].second;
adj[u].push_back(v);
adj[v].push_back(u);
}
}
void dfs(int u, int p) {
tin[u] = timer++;
par[0][u] = p;
for (int i = 1; i < 20; i++) {
int t = par[i - 1][u];
if (t == -1) break;
par[i][u] = par[i - 1][t];
}
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == p) continue;
dep[v] = dep[u] + 1;
dfs(v, u);
}
}
void proc() {
par = vector<vector<int> >(20, vector<int>(n, -1));
dep = vector<int>(n);
tin = vector<int>(n, -1);
timer = 0;
for (int i = 0; i < n; i++)
if (tin[i] == -1) {
dep[i] = 0;
dfs(i, -1);
}
}
int lca(int a, int b) {
if (dep[a] < dep[b]) swap(a, b);
int diff = dep[a] - dep[b];
for (int i = 0; i < 20; i++)
if (diff & (1 << i)) a = par[i][a];
if (a == b) return a;
for (int i = 20; i--;) {
if (par[i][a] != par[i][b]) {
a = par[i][a];
b = par[i][b];
}
}
return par[0][a];
}
Forest compress(vector<int> X) {
int Xn = X.size();
unordered_map<int, int> dx;
for (int i = 0; i < Xn; i++) dx[X[i]] = i;
vector<pair<int, int> > ord;
for (int i = 0; i < X.size(); i++)
ord.push_back(pair<int, int>(tin[X[i]], X[i]));
sort(ord.begin(), ord.end());
stack<int> stk;
vector<int> Y = X;
unordered_map<int, int> dy = dx;
vector<pair<int, int> > edge;
for (int i = 1; i < ord.size(); i++) {
int p = ord[i - 1].second;
int u = ord[i].second;
int x = lca(p, u);
if (x == -1) continue;
if (dy.find(x) == dy.end()) {
dy[x] = Y.size();
Y.push_back(x);
}
}
int p = ord[0].second;
stk.push(p);
for (int i = 1; i < ord.size(); i++) {
int u = ord[i].second;
int x = lca(p, u);
if (x == -1) {
int la = -1;
while (!stk.empty()) {
int t = stk.top();
stk.pop();
if (la != -1) edge.push_back(pair<int, int>(la, t));
la = t;
}
p = u;
stk.push(u);
continue;
}
int la = -1;
while (!stk.empty() && tin[stk.top()] >= tin[x]) {
int t = stk.top();
stk.pop();
if (la != -1) edge.push_back(pair<int, int>(la, t));
la = t;
}
if (la != x && la != -1) edge.push_back(pair<int, int>(la, x));
stk.push(x);
stk.push(u);
p = u;
}
int la = -1;
while (!stk.empty()) {
int t = stk.top();
stk.pop();
if (la != -1) edge.push_back(pair<int, int>(la, t));
la = t;
}
for (int i = 0; i < edge.size(); i++) {
int u = edge[i].first;
int v = edge[i].second;
u = dy[u];
v = dy[v];
edge[i] = {u, v};
}
Forest ret(Y.size(), edge.size(), edge);
return ret;
}
vector<pair<int, int> > get_edge() {
vector<pair<int, int> > ret;
for (int u = 0; u < n; u++) {
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (u < v) ret.push_back(pair<int, int>(u, v));
}
}
return ret;
}
};
class Graph {
public:
int n, m;
vector<vector<int> > adj;
vector<int> U, V;
vector<int> tin, bck, id;
stack<int> stk;
int timer, bcnt;
Graph(int n_, int m_, vector<pair<int, int> > edge) {
n = n_;
m = m_;
adj.resize(n);
for (int i = 0; i < m; i++) {
int u = edge[i].first;
int v = edge[i].second;
adj[u].push_back(i);
adj[v].push_back(i);
U.push_back(u);
V.push_back(v);
}
}
void dfs(int u, int fe) {
tin[u] = timer++;
bck[u] = tin[u];
stk.push(u);
for (int i = 0; i < adj[u].size(); i++) {
int e = adj[u][i];
int v = U[e] + V[e] - u;
if (e == fe) continue;
if (tin[v] == -1) {
dfs(v, e);
bck[u] = min(bck[u], bck[v]);
} else
bck[u] = min(bck[u], tin[v]);
}
if (bck[u] == tin[u]) {
while (1) {
int t = stk.top();
stk.pop();
id[t] = bcnt;
if (t == u) break;
}
bcnt++;
}
}
Forest bcc() {
tin = vector<int>(n, -1);
bck = vector<int>(n);
id = vector<int>(n);
timer = 0;
bcnt = 0;
for (int i = 0; i < n; i++)
if (tin[i] == -1) {
dfs(i, -1);
}
vector<pair<int, int> > edge;
for (int u = 0; u < n; u++) {
for (int i = 0; i < adj[u].size(); i++) {
int e = adj[u][i];
int v = U[e] + V[e] - u;
if (id[u] < id[v]) {
edge.push_back(pair<int, int>(id[u], id[v]));
}
}
}
Forest ret(bcnt, edge.size(), edge);
return ret;
}
};
int N, M, Q;
vector<pair<int, int> > edge;
int rotate(int u, int R) { return (u + R) % N; }
int main() {
scanf("%d %d %d", &N, &M, &Q);
for (int i = 0; i < M; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
edge.push_back(pair<int, int>(u, v));
}
Graph G(N, M, edge);
Forest F = G.bcc();
F.proc();
int R = 0;
for (int q = 1; q <= Q; q++) {
int n, m;
scanf("%d %d", &n, &m);
vector<int> vertex;
vector<pair<int, int> > edge;
int Xn;
vector<int> X;
unordered_map<int, int> dx;
for (int i = 0; i < n; i++) {
int u;
scanf("%d", &u);
u--;
u = rotate(u, R);
u = G.id[u];
vertex.push_back(u);
X.push_back(u);
}
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
u = rotate(u, R);
v = rotate(v, R);
u = G.id[u];
v = G.id[v];
edge.push_back(pair<int, int>(u, v));
X.push_back(u);
X.push_back(v);
}
sort(X.begin(), X.end());
X.resize(unique(X.begin(), X.end()) - X.begin());
Xn = X.size();
for (int i = 0; i < Xn; i++) dx[X[i]] = i;
Forest F2 = F.compress(X);
vector<pair<int, int> > edge2 = F2.get_edge();
for (int i = 0; i < edge.size(); i++) {
int u = edge[i].first;
int v = edge[i].second;
u = dx[u];
v = dx[v];
edge2.push_back(pair<int, int>(u, v));
}
Graph G2(F2.n, edge2.size(), edge2);
G2.bcc();
int ans = 1;
int la = -1;
for (int i = 0; i < vertex.size(); i++) {
int u = vertex[i];
u = dx[u];
if (la == -1)
la = G2.id[u];
else if (la != G2.id[u]) {
ans = 0;
break;
}
}
if (ans) {
printf("YES\n");
R += q;
R %= N;
} else
printf("NO\n");
}
}
| 25
|
#include <bits/stdc++.h>
const int N = 5005;
char s[N];
int main() {
int i, j, n, lb, clb, qm, ans;
gets(s);
n = strlen(s);
ans = 0;
for (i = 0; i < n; i++) {
clb = lb = qm = 0;
for (j = i; j < n; j++) {
if (s[j] == '(')
lb++, clb++;
else {
if (s[j] == ')')
lb--;
else
qm++;
if (clb) clb--;
}
if (lb + qm < 0) break;
if (!clb && (j - i) % 2 && lb <= qm) ans++;
}
}
printf("%d", ans);
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int> > v;
while (n--) {
int x, y;
cin >> x >> y;
v.push_back(make_pair(y, x));
}
int ans = 0, c = 0;
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
if (v[i].second > c) {
ans++;
c = v[i].first;
}
}
cout << ans;
}
| 8
|
#include <bits/stdc++.h>
char num[300010];
int main() {
int n, t, c, m;
scanf("%d%d%s", &n, &t, num + 1);
for (c = 1; num[c] != '.'; c++)
;
for (m = c + 1; m < n + 1 && num[m] < '5'; m++)
;
if (m == n + 1)
puts(num + 1);
else {
while (t--) {
if (m == c + 1) {
num[c] = 0;
int i = c - 1;
while (i) {
if (num[i] < '9') {
num[i]++;
break;
} else
num[i] = '0', i--;
}
if (i == 0) num[0] = '1';
break;
} else {
num[m - 1]++;
num[m] = 0;
for (m--; m > c && num[m] < '5'; m--)
;
if (m == c) break;
}
}
puts(num[0] == '1' ? num : num + 1);
}
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
long long en, cap, flow, next;
} edge[1000000];
long long head[50005], tot, now[50005];
long long source, sink, tot_num;
long long pre[50005], dis[50005], gap[50005];
void add_edge(long long st, long long en, long long cap) {
edge[tot].en = en;
edge[tot].cap = cap;
edge[tot].flow = 0;
edge[tot].next = head[st];
head[st] = tot++;
edge[tot].en = st;
edge[tot].cap = 0;
edge[tot].flow = 0;
edge[tot].next = head[en];
head[en] = tot++;
}
void augment(long long flow) {
for (long long i = source; i != sink; i = edge[now[i]].en) {
edge[now[i]].flow += flow;
edge[now[i] ^ 1].flow -= flow;
}
}
long long sap() {
memset(dis, 0, sizeof(dis));
memset(gap, 0, sizeof(gap));
memset(pre, -1, sizeof(pre));
for (long long i = 0; i < tot_num; i++) now[i] = head[i];
gap[0] = tot_num;
long long poLL = source, flow = 0, min_flow = 0x3fffffff;
while (dis[source] < tot_num) {
bool fg = false;
for (long long i = now[poLL]; i != -1; i = edge[i].next)
if (edge[i].cap - edge[i].flow > 0 && dis[poLL] == dis[edge[i].en] + 1) {
min_flow = min(min_flow, edge[i].cap - edge[i].flow);
now[poLL] = i;
pre[edge[i].en] = poLL;
poLL = edge[i].en;
if (poLL == sink) {
flow += min_flow;
augment(min_flow);
poLL = source;
min_flow = 0x3fffffff;
}
fg = true;
break;
}
if (fg) continue;
if (--gap[dis[poLL]] == 0) break;
long long Min = tot_num;
for (long long i = head[poLL]; i != -1; i = edge[i].next)
if (edge[i].cap - edge[i].flow > 0 && Min > dis[edge[i].en]) {
Min = dis[edge[i].en];
now[poLL] = i;
}
gap[dis[poLL] = Min + 1]++;
if (poLL != source) poLL = pre[poLL];
}
return flow;
}
long long sum;
void build(long long n) {
memset(head, -1, sizeof(head));
tot = 0;
source = 0;
sink = n * 2 + 1;
tot_num = n * 2 + 2;
long long a, b, c;
long long m;
long long j;
for (long long i = 1; i <= n; i++)
for (j = 1, cin >> m; j <= m; j++) {
cin >> a;
add_edge(i, n + a, 0x3fffffff);
}
sum = 0;
for (long long i = 1; i <= n; i++) {
add_edge(n + i, sink, 0x3fffffff);
cin >> a;
sum += a;
add_edge(source, i, 0x3fffffff - a);
}
}
int main() {
long long n, m;
while (cin >> n) {
build(n);
long long ans = sap();
cout << sum + ans - n * 0x3fffffff << endl;
}
return 0;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, m;
cin >> n >> m;
map<long long int, long long int> mp;
vector<long long int> v;
vector<long long int> u;
long long int x;
for (long long int i = 0; i < m; i++) {
for (long long int j = 0; j < n; j++) {
cin >> x;
v.push_back(x);
}
u = v;
sort(v.begin(), v.end());
for (long long int j = 0; j < n; j++) {
if (u[j] == v[v.size() - 1]) {
mp[j + 1]++;
break;
}
}
v.clear();
u.clear();
}
long long int mx = 0;
long long int pos = 0;
for (auto it = mp.begin(); it != mp.end(); it++) {
if (it->second > mx) {
mx = it->second;
pos = it->first;
}
}
cout << pos << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int la[8][8] = {0}, cnt = 0;
vector<int> ans[8][8];
int ten[9] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000};
int k, m;
inline bool merge(int st, int ed, int i) {
int t1, t2, tmp;
t1 = ans[st][ed - i].size();
t2 = ans[ed - i + 1][ed].size();
int cntt = m - ans[st][ed].size();
for (int j = 0; j < t1; j++)
for (int p = 0; p < t2; p++) {
if (!cntt) return 1;
ans[st][ed].push_back(ans[st][ed - i][j] * ten[i] +
ans[ed - i + 1][ed][p]);
cntt--;
}
return 0;
}
inline void di(int st, int ed, int val) {
ans[st][ed].clear();
ans[st][ed].push_back(val);
if (st == ed) return;
int len = ed - st + 1;
for (int i = 1; i < len; ++i) {
for (int j = 0; j <= val && j < ten[i] && val - j < ten[len - i]; j++) {
di(st, ed - i, val - j), di(ed - i + 1, ed, j);
if (merge(st, ed, i)) return;
}
for (int j = 1; j < ten[i] && val + j < ten[len - i]; j++) {
di(st, ed - i, val + j), di(ed - i + 1, ed, j);
if (merge(st, ed, i)) return;
}
for (int j = 1; j < ten[len - i] && val + j < ten[i]; j++) {
di(st, ed - i, j), di(ed - i + 1, ed, val + j);
if (merge(st, ed, i)) return;
}
}
for (int i = 1; i * i <= val; i++)
if (!(val % i))
for (int j = 1; j < len; j++) {
if (i < ten[j] && val / i < ten[len - j]) {
di(st, st + j - 1, i), di(st + j, ed, val / i);
if (merge(st, ed, len - j)) return;
}
if (val / i < ten[j] && i < ten[len - j]) {
di(st, st + j - 1, val / i), di(st + j, ed, i);
if (merge(st, ed, len - j)) return;
}
}
}
bool vis[100000000] = {0};
inline void print(int i) {
int t1, t2, tmp;
t1 = ans[0][7 - i].size();
t2 = ans[7 - i + 1][7].size();
for (int j = 0; j < t1; j++)
for (int p = 0; p < t2; p++) {
if (cnt == m) return;
tmp = ans[0][7 - i][j] * ten[i] + ans[7 - i + 1][7][p];
if (vis[tmp]) continue;
cnt++;
vis[tmp] = 1;
printf("%08d\n", tmp);
}
}
int main() {
scanf("%d%d", &k, &m);
for (int i = 1; i < 8; ++i) {
for (int j = 0; j <= k && j < ten[i] && k - j < ten[8 - i]; j++) {
di(0, 7 - i, k - j), di(7 - i + 1, 7, j);
print(i);
if (cnt == m) return 0;
}
for (int j = 1; j < ten[i] && k + j < ten[8 - i]; j++) {
di(0, 7 - i, k + j), di(7 - i + 1, 7, j);
print(i);
if (cnt == m) return 0;
}
for (int j = 1; j < ten[8 - i] && k + j < ten[i]; j++) {
di(0, 7 - i, j), di(7 - i + 1, 7, k + j);
print(i);
if (cnt == m) return 0;
}
}
for (int i = 1; i * i <= k; i++)
if (!(k % i))
for (int j = 1; j < 8; j++) {
if (i < ten[j] && k / i < ten[8 - j]) {
di(0, j - 1, i), di(j, 7, k / i);
print(8 - j);
if (cnt == m) return 0;
}
if (k / i < ten[j] && i < ten[8 - j]) {
di(0, j - 1, k / i), di(j, 7, i);
print(8 - j);
if (cnt == m) return 0;
}
}
return 0;
}
| 19
|
#include <bits/stdc++.h>
#define f first
#define s second
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
const int N = 1505, K = 11;
struct kek
{
int sz = 0;
pii val[K];
void add(int c, int k)
{
for (int i = 0; i < sz; i++)
if (val[i].f == c)
{
for (int j = i; j + 1 < sz; j++)
val[j] = val[j + 1];
sz--;
}
if (sz == K)
{
for (int j = 0; j + 1 < sz; j++)
val[j] = val[j + 1];
sz--;
}
val[sz++] = {c, k};
}
void add(pii x)
{
add(x.f, x.s);
}
};
int n, q, a[N][N];
kek b[N][N], c[N][N];
int was[N * N], timer;
int ans[N];
kek f(kek a, kek b)
{
kek res;
int i = 0, j = 0;
while (i < a.sz || j < b.sz)
{
if (i == a.sz)
res.add(b.val[j++]);
else if (j == b.sz)
res.add(a.val[i++]);
else if (a.val[i].s > b.val[j].s)
res.add(a.val[i++]);
else
res.add(b.val[j++]);
}
return res;
}
kek g(kek a, int x)
{
for (int i = 0; i < a.sz; i++)
a.val[i].s += x;
return a;
}
void F(kek a, int mx)
{
timer++;
int cnt = 0;
int res = 1e9;
for (int i = 0; i < a.sz; i++)
{
int k = a.val[a.sz - 1 - i].s;
int c = a.val[a.sz - 1 - i].f;
if (was[c] == timer)
continue;
was[c] = timer;
cnt++;
if (cnt > q)
{
res = k;
break;
}
}
res = min(res, mx);
ans[res]++;
}
int main()
{
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
scanf("%d", &a[i][j]);
for (int i = 0; i < n; i++)
for (int j = n - 1; j >= 0; j--)
{
b[i][j] = b[i][j + 1];
c[j][i] = c[j + 1][i];
b[i][j].add(a[i][j], j);
c[j][i].add(a[j][i], j);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
b[i][j] = f(g(b[i][j], -j), g(c[i][j], -i));
for (int i = n - 1; i >= 0; i--)
for (int j = n - 1; j >= 0; j--)
b[i][j] = f(b[i][j], g(b[i + 1][j + 1], 1));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
F(b[i][j], n - max(i, j));
for (int i = n; i >= 1; i--)
ans[i] += ans[i + 1];
for (int i = 1; i <= n; i++)
printf("%d\n", ans[i]);
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
int p[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47};
int main() {
string s;
vector<int> m;
for (int i = 0; i < 15; i++) {
cout << p[i] << endl;
cin >> s;
if (s == "yes") m.push_back(p[i]);
}
if (m.size() == 0) cout << "prime";
if (m.size() >= 2) cout << "composite";
if (m.size() == 1) {
if (m[0] * m[0] <= 100) {
cout << m[0] * m[0] << endl;
cin >> s;
if (s == "yes")
cout << "composite";
else
cout << "prime";
} else
cout << "prime";
}
cout << endl;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long base, long long exp) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base);
base = (base * base);
exp /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
long long n = s.length();
long long n1 = n;
long long cnt = 0;
for (long long i = 0; i < n1; i++) {
if (s[i] == '1') {
cnt++;
}
}
if (cnt == 0) {
cout << 0 << "\n";
} else {
if (cnt == 1) {
n--;
}
if (n % 2 == 0) {
cout << n / 2 << "\n";
} else {
cout << (n / 2) + 1 << "\n";
}
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int LogN = 21;
int n, q, all, leaf;
struct Edge {
int to, val;
};
vector<Edge> G[N];
template <typename _Tp>
inline void IN(_Tp& x) {
char ch;
bool flag = 0;
x = 0;
while (ch = getchar(), !isdigit(ch))
if (ch == '-') flag = 1;
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
if (flag) x = -x;
}
inline void addedge(int u = 0, int v = 0, int w = 0) {
IN(u), IN(v), IN(w), all += w;
G[u].push_back((Edge){v, w}), G[v].push_back((Edge){u, w});
}
struct Algorithm_Tree {
int rt, f[N][LogN], g[N][LogN];
int dis[N], son[N], sum[N], top[N], mx[N], rank[N];
int m, nod[N], val[N];
void getdist(int u, int fa) {
for (auto t : G[u])
if (t.to != fa) dis[t.to] = dis[u] + t.val, getdist(t.to, u);
}
void pre(int u, int fa, int v = 0) {
for (auto t : G[u])
if ((v = t.to) != fa) {
f[v][0] = u, g[v][0] = t.val;
for (int i = 0; f[v][i]; ++i)
f[v][i + 1] = f[f[v][i]][i], g[v][i + 1] = g[v][i] + g[f[v][i]][i];
dis[v] = dis[u] + t.val, pre(v, u);
if (mx[v] + t.val > mx[u]) mx[u] = mx[v] + t.val, son[u] = v;
}
for (auto t : G[u])
if ((v = t.to) != fa && v != son[u]) val[nod[++m] = v] = mx[v] + t.val;
}
inline void getroot(int now) {
getdist(rt = now, 0);
for (int i = 1; i <= n; ++i)
if (dis[i] > dis[rt]) rt = i;
dis[rt] = 0, pre(rt, 0), val[nod[++m] = rt] = mx[rt];
sort(nod + 1, nod + 1 + m, [&](int x, int y) { return val[x] > val[y]; });
for (int i = 1; i <= m; ++i) sum[i] = sum[i - 1] + val[nod[i]];
for (int i = 1; i <= m; ++i) {
int tmp = nod[i];
while (tmp) top[tmp] = nod[i], rank[tmp] = i, tmp = son[tmp];
}
}
inline int calc1(int x, int y) {
int res = mx[x];
for (int i = LogN - 1; ~i; --i)
if (rank[f[x][i]] >= y) res += g[x][i], x = f[x][i];
return sum[y - 1] + res + g[x][0];
}
inline int calc2(int x, int y) {
int res = mx[x];
for (int i = LogN - 1; ~i; --i)
if (rank[f[x][i]] > y) res += g[x][i], x = f[x][i];
return sum[y] - mx[f[x][0]] + res + g[x][0];
}
inline int query(int x, int y) {
y = (y << 1) - 1;
return rank[x] <= y ? sum[y] : max(calc1(x, y), calc2(x, y));
}
} T1, T2;
int main() {
IN(n), IN(q);
for (int i = 2; i <= n; ++i) addedge();
for (int i = 1; i <= n; ++i) leaf += (int)(G[i].size()) == 1;
T1.getroot(1), T2.getroot(T1.rt);
int x, y, lastans = 0;
while (q--) {
IN(x), IN(y);
x = (x + lastans - 1) % n + 1, y = (y + lastans - 1) % n + 1;
printf("%d\n",
lastans =
((y << 1) >= leaf ? all : max(T1.query(x, y), T2.query(x, y))));
}
return 0;
}
| 25
|
#include <bits/stdc++.h>
const int N = 1e5 + 100, M = 1e6 + 100, SQ = sqrt(2e5), LG = 23, base = 2,
second = 1e2 + 100;
const long long mod = 1e9 + 7, MOD = 1e9 + 9;
const long long INF = 1e9, inf = 1e18, super_inf = ~0ull / 4;
using namespace std;
long long n, k, a[N], sum;
vector<long long> v, ans;
bool flag[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i], v.push_back(a[i]);
sort(v.begin(), v.end(), greater<int>());
for (int i = 0; i < k; i++) {
for (int j = 0; j < n; j++) {
if (!flag[j] and a[j] == v[i]) {
ans.push_back(j + 1), sum += v[i], flag[j] = 1;
break;
}
}
}
cout << sum << endl;
long long last = 0;
sort(ans.begin(), ans.end());
for (int i = 0; i < k - 1; i++) {
cout << ans[i] - last << ' ';
last = ans[i];
}
return cout << n - last << endl, 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int bs1 = 17680321;
const int bs2 = 19260817;
const int bs3 = 19491001;
int n, m, LR, BT, LT, TR, RB, BL, a[400100], col[400100], p;
bool vis[400100];
vector<int> v[400100], u[400100];
char s[10];
void V(int x, int y) { v[x].push_back(y), v[y].push_back(x); }
void U(int x, int y) { u[x].push_back(y), u[y].push_back(x); }
struct circ {
int st, nx, len, bs1, bs2, bs3;
circ(int A, int B, int C, int D, int E, int F) {
st = A, nx = B, len = C, bs1 = D, bs2 = E, bs3 = F;
}
friend bool operator<(const circ& x, const circ& y) {
if (x.len != y.len) return x.len < y.len;
if (x.bs1 != y.bs1) return x.bs1 < y.bs1;
if (x.bs2 != y.bs2) return x.bs2 < y.bs2;
return x.bs3 < y.bs3;
}
};
vector<circ> uu, vv;
circ HS() {
int i = 0, j = 1, k = 0;
while (i < p && j < p && k < p) {
if (col[a[(i + k) % p]] == col[a[(j + k) % p]])
k++;
else {
if (col[a[(i + k) % p]] > col[a[(j + k) % p]])
i += k + 1;
else
j += k + 1;
if (i == j) i++;
k = 0;
}
}
int I = p - min(i, j) - 1;
i = 0, j = 1, k = 0;
reverse(a, a + p);
while (i < p && j < p && k < p) {
if (col[a[(i + k) % p]] == col[a[(j + k) % p]])
k++;
else {
if (col[a[(i + k) % p]] > col[a[(j + k) % p]])
i += k + 1;
else
j += k + 1;
if (i == j) i++;
k = 0;
}
}
int J = min(i, j);
for (k = 0; k < p; k++) {
if (col[a[(I + p - k) % p]] == col[a[(J + k) % p]]) continue;
if (col[a[(I + p - k) % p]] < col[a[(J + k) % p]]) {
int r1 = 0, r2 = 0, r3 = 0;
for (k = 0; k < p; k++) {
r1 = (4 * r1 + col[a[(I + p - k) % p]]) % bs1;
r2 = (4 * r2 + col[a[(I + p - k) % p]]) % bs2;
r3 = (4 * r3 + col[a[(I + p - k) % p]]) % bs3;
}
return circ(a[I], a[(I + p - 1) % p], p, r1, r2, r3);
} else {
int r1 = 0, r2 = 0, r3 = 0;
for (k = 0; k < p; k++) {
r1 = (4 * r1 + col[a[(J + k) % p]]) % bs1;
r2 = (4 * r2 + col[a[(J + k) % p]]) % bs2;
r3 = (4 * r3 + col[a[(J + k) % p]]) % bs3;
}
return circ(a[J], a[(J + 1) % p], p, r1, r2, r3);
}
}
int r1 = 0, r2 = 0, r3 = 0;
for (k = 0; k < p; k++) {
r1 = (4 * r1 + col[a[(I + p - k) % p]]) % bs1;
r2 = (4 * r2 + col[a[(I + p - k) % p]]) % bs2;
r3 = (4 * r3 + col[a[(I + p - k) % p]]) % bs3;
}
return circ(a[I], a[(I + p - 1) % p], p, r1, r2, r3);
}
void dfs(vector<int>* w, int x) {
if (vis[x]) return;
vis[x] = true, a[p++] = x;
for (auto y : w[x]) dfs(w, y);
}
int UU[100100], VV[100100];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) col[i] = 0;
for (int i = n + 1; i <= n + m; i++) col[i] = 1;
for (int i = n + m + 1; i <= 2 * n + m; i++) col[i] = 2;
for (int i = 2 * n + m + 1; i <= 2 * n + 2 * m; i++) col[i] = 3;
for (int i = 1, x, y; i <= n + m; i++) {
scanf("%s%s%d%d", s, s + 1, &x, &y);
if (s[0] == 'L') x += 0;
if (s[0] == 'T') x += n;
if (s[0] == 'R') x += n + m;
if (s[0] == 'B') x += 2 * n + m;
if (s[1] == 'L') y += 0;
if (s[1] == 'T') y += n;
if (s[1] == 'R') y += n + m;
if (s[1] == 'B') y += 2 * n + m;
V(x, y);
if (s[0] == 'L' && s[1] == 'R' || s[1] == 'L' && s[0] == 'R') LR++;
if (s[0] == 'B' && s[1] == 'T' || s[1] == 'B' && s[0] == 'T') BT++;
if (s[0] == 'L' && s[1] == 'T' || s[1] == 'L' && s[0] == 'T')
LT++, U(LT, n + LT);
if (s[0] == 'T' && s[1] == 'R' || s[1] == 'T' && s[0] == 'R')
TR++, U(n + m - TR + 1, n + m + TR);
if (s[0] == 'R' && s[1] == 'B' || s[1] == 'R' && s[0] == 'B')
RB++, U(2 * n + m - RB + 1, 2 * n + 2 * m - RB + 1);
if (s[0] == 'B' && s[1] == 'L' || s[1] == 'B' && s[0] == 'L')
BL++, U(2 * n + m + BL, n - BL + 1);
}
if (LR && BT) return puts("No solution"), 0;
for (int i = 1; i <= LR; i++) U(LT + i, n + m + TR + i);
for (int i = 1; i <= BT; i++) U(n + LT + i, 2 * n + m + BL + i);
for (int i = 1; i <= n; i++) V(i, n + m + i), U(i, n + m + i);
for (int i = n + 1; i <= n + m; i++) V(i, n + m + i), U(i, n + m + i);
memset(vis, false, sizeof(vis));
for (int i = 1; i <= 2 * n + 2 * m; i++) {
if (vis[i]) continue;
p = 0, dfs(v, i);
vv.push_back(HS());
}
memset(vis, false, sizeof(vis));
for (int i = 1; i <= 2 * n + 2 * m; i++) {
if (vis[i]) continue;
p = 0, dfs(u, i);
uu.push_back(HS());
}
sort(vv.begin(), vv.end());
sort(uu.begin(), uu.end());
if (vv.size() != uu.size()) return puts("No solution"), 0;
for (int i = 0; i < vv.size(); i++)
if (vv[i] < uu[i] || uu[i] < vv[i]) return puts("No solution"), 0;
for (int i = 0; i < vv.size(); i++) {
int x = vv[i].st, y = uu[i].st;
int X = v[x][0] ^ v[x][1] ^ vv[i].nx;
int Y = u[y][0] ^ u[y][1] ^ uu[i].nx;
for (int j = 0; j < vv[i].len; j++, X = v[x][0] ^ v[x][1] ^ X,
Y = u[y][0] ^ u[y][1] ^ Y, swap(x, X), swap(y, Y)) {
if (col[x] == 0) UU[y] = x;
if (col[x] == 1) VV[y - n] = x - n;
if (col[x] == 2) UU[y - n - m] = x - n - m;
if (col[x] == 3) VV[y - 2 * n - m] = x - 2 * n - m;
}
}
for (int i = 1; i <= n; i++) printf("%d ", UU[i]);
puts("");
for (int i = 1; i <= m; i++) printf("%d ", VV[i]);
puts("");
return 0;
}
| 23
|
/* ॐ Shree ॐ */
/* ॐ ॐ ॐ
ॐ भूर् भुवः स्वः
तत् सवितुर्वरेण्यं
भर्गो देवस्य धीमहि
धियो यो नः प्रचोदयात्
*/
/* It does not matter how slow you go SO LONG AS YOU DON'T STOP */
/*
██▓███ ▄▄▄ ██▀███ ██▓ ██ ▄█▀ ██████ ██░ ██ ██▓▄▄▄█████▓ ██████ ██░ ██ ▄▄▄ ██▀███ ███▄ ▄███▓ ▄▄▄
▓██░ ██▒▒████▄ ▓██ ▒ ██▒▓██▒ ██▄█▒ ▒██ ▒ ▓██░ ██▒▓██▒▓ ██▒ ▓▒ ▒██ ▒ ▓██░ ██▒▒████▄ ▓██ ▒ ██▒▓██▒▀█▀ ██▒▒████▄
▓██░ ██▓▒▒██ ▀█▄ ▓██ ░▄█ ▒▒██▒▓███▄░ ░ ▓██▄ ▒██▀▀██░▒██▒▒ ▓██░ ▒░ ░ ▓██▄ ▒██▀▀██░▒██ ▀█▄ ▓██ ░▄█ ▒▓██ ▓██░▒██ ▀█▄
▒██▄█▓▒ ▒░██▄▄▄▄██ ▒██▀▀█▄ ░██░▓██ █▄ ▒ ██▒░▓█ ░██ ░██░░ ▓██▓ ░ ▒ ██▒░▓█ ░██ ░██▄▄▄▄██ ▒██▀▀█▄ ▒██ ▒██ ░██▄▄▄▄██
▒██▒ ░ ░ ▓█ ▓██▒░██▓ ▒██▒░██░▒██▒ █▄▒██████▒▒░▓█▒░██▓░██░ ▒██▒ ░ ▒██████▒▒░▓█▒░██▓ ▓█ ▓██▒░██▓ ▒██▒▒██▒ ░██▒ ▓█ ▓██▒
▒▓▒░ ░ ░ ▒▒ ▓▒█░░ ▒▓ ░▒▓░░▓ ▒ ▒▒ ▓▒▒ ▒▓▒ ▒ ░ ▒ ░░▒░▒░▓ ▒ ░░ ▒ ▒▓▒ ▒ ░ ▒ ░░▒░▒ ▒▒ ▓▒█░░ ▒▓ ░▒▓░░ ▒░ ░ ░ ▒▒ ▓▒█░
░▒ ░ ▒ ▒▒ ░ ░▒ ░ ▒░ ▒ ░░ ░▒ ▒░░ ░▒ ░ ░ ▒ ░▒░ ░ ▒ ░ ░ ░ ░▒ ░ ░ ▒ ░▒░ ░ ▒ ▒▒ ░ ░▒ ░ ▒░░ ░ ░ ▒ ▒▒ ░
░░ ░ ▒ ░░ ░ ▒ ░░ ░░ ░ ░ ░ ░ ░ ░░ ░ ▒ ░ ░ ░ ░ ░ ░ ░░ ░ ░ ▒ ░░ ░ ░ ░ ░ ▒
░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,a,b) for (ll i = a; i < b; i++)
#define RREP(i,a,b) for (ll i = a; i > b; i--)
#define int long long
#define pb push_back
#define All(n) n.begin(),n.end()
typedef vector<int> vctr;
#define PI 2.0*acos(0.0)
template<typename T>
std::vector<std::vector<std::vector<T>>> make_3d_vector(ll z, ll y, ll x, T value = T{})
{
return std::vector<std::vector<std::vector<T>>>(z, std::vector<std::vector<T>>(y, std::vector<T>(x, value)));
}
template<typename T>
std::vector<std::vector<T>> make_2d_vector(ll z, ll y, T value = T{})
{
return std::vector<std::vector<T>>(z, std::vector<T>(y, value));
}
template<typename T>
std::vector<T> make_1d_vector(ll z, T value = T{})
{
return std::vector<T>(z, value);
}
#define buffer cin.ignore(numeric_limits<streamsize>::max(),'\n');
/////////////////PROGRAM/////////////////////
/////////////////PROGRAM/////////////////////
/////////////////PROGRAM/////////////////////
/////////////////PROGRAM/////////////////////
void solve() {
int zero,one;
cin>>zero>>one;
int x=zero,y=one;
string s;
cin>>s;
int n=s.size();
for(int i=0;i<n;i++){
if((s[i]=='1'||s[i]=='0')&&(s[n-i-1]=='?')){
s[n-i-1]=s[i];
}
}
for(auto i:s){
if(i=='0') zero--;
else if(i=='1') one--;
}
for(int i=0;i<n;i++){
if(s[i]!='?') continue;
if(s[n-i-1]!='?'){
cout<<-1;
return;
}
if(i==n/2&&(n%2==1)){
if(zero%2){
s[i]='0';
zero--;
}
else if(one%2){
s[i]='1';
one--;
}
else{
cout<<-1;
return;
}
}
else if(zero>=2){
s[n-i-1]=s[i]='0';
zero-=2;
}
else if(one>=2){
s[n-i-1]=s[i]='1';
one-=2;
}
else{
cout<<-1;
return;
}
}
for(int i=0;i<n;i++){
if(s[i]=='1') y--;
else if(s[i]=='0') x--;
else {
cout<<-1;
return;
}
if(s[i]!=s[n-i-1]){
cout<<-1;
return;
}
}
if(x||y){
cout<<-1;
return;
}
cout<<s;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#else
// online submission
#endif
long long test=1;
cin>>test;
while (test--) {
solve();
cout<<"\n";
}
cerr<<"time taken : "<<(float)clock()/CLOCKS_PER_SEC<<" secs"<<endl;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
bool mayus(string s) {
for (int i = 0; i < s.size(); i++)
if (toupper(s[i]) != s[i]) return false;
return true;
}
bool mayus2(string s) {
for (int i = 1; i < s.size(); i++)
if (toupper(s[i]) != s[i]) return false;
return true;
}
int main() {
string s;
getline(cin, s);
if (s.size() == 0) {
if (tolower(s[0]) == s[0])
printf("%c\n", toupper(s[0]));
else
printf("%c\n", s[0]);
} else if (mayus(s)) {
for (int i = 0; i < s.size(); i++) printf("%c", tolower(s[i]));
printf("\n");
} else if (mayus2(s)) {
printf("%c", toupper(s[0]));
for (int i = 1; i < s.size(); i++) printf("%c", tolower(s[i]));
printf("\n");
} else
cout << s << endl;
}
| 2
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
const long long mod = 998244353;
long double PI = acosl(-1);
const int nmax = 2e6 + 5;
const int MAXLG = log2(nmax) + 1;
int upor[nmax];
int lim = 1000000;
const int N = 1e6 + 5;
long long inf = 1e18;
long long tr[4 * N], lz[4 * N];
void propagate(int u, int st, int en) {
if (!lz[u]) return;
tr[u] = max(tr[u], lz[u]);
if (st != en) {
lz[2 * u] = max(lz[2 * u], lz[u]);
lz[2 * u + 1] = max(lz[2 * u + 1], lz[u]);
}
lz[u] = 0;
}
void update(int u, int st, int en, int l, int r, long long x) {
propagate(u, st, en);
if (r < st || en < l)
return;
else if (l <= st && en <= r) {
lz[u] = max(lz[u], x);
propagate(u, st, en);
} else {
int mid = (st + en) / 2;
update(2 * u, st, mid, l, r, x);
update(2 * u + 1, mid + 1, en, l, r, x);
tr[u] = max(tr[2 * u], tr[2 * u + 1]);
}
}
long long query(int u, int st, int en, int l, int r) {
propagate(u, st, en);
if (r < st || en < l)
return -inf;
else if (l <= st && en <= r)
return tr[u];
else {
int mid = (st + en) / 2;
return max(query(2 * u, st, mid, l, r),
query(2 * u + 1, mid + 1, en, l, r));
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(upor, -1, sizeof upor);
int n, m;
cin >> n >> m;
vector<pair<int, int> > R(n), L(m);
for (pair<int, int> &z : R) cin >> z.first >> z.second;
for (pair<int, int> &z : L) cin >> z.first >> z.second;
for (pair<int, int> z : L) {
upor[z.first] = z.second;
}
for (int i = lim; i >= 0; i--) {
upor[i] = max(upor[i + 1], upor[i]);
}
vector<int> upchenj = {0};
for (int i = 1; i <= lim + 1; i++)
if (upor[i] != upor[i - 1]) upchenj.push_back(i);
for (pair<int, int> z : R)
for (int i = 0; i < upchenj.size() - 1; i++) {
if (upchenj[i + 1] > z.first) {
int bamm = max(z.first, upchenj[i]);
int dan = upchenj[i + 1] - 1;
if (upor[upchenj[i]] >= z.second) {
int cost = upor[upchenj[i]] + 1 - z.second;
update(1, 0, lim, bamm - z.first, dan - z.first, cost);
}
}
}
long long uttor = inf;
for (int i = 0; i <= lim; i++) {
uttor = min(uttor, i + query(1, 0, lim, i, i));
}
cout << uttor << endl;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
void fastio() {
cin.tie(nullptr);
cin.sync_with_stdio(false);
}
using LL = long long;
using LD = long double;
const LL MOD = 1e9 + 7;
const LL INF = LLONG_MAX;
const LL N = 2e5 + 1;
int main() {
fastio();
LL t;
cin >> t;
while (t--) {
LL n;
cin >> n;
vector<LL> a(n);
for (auto &e : a) {
cin >> e;
}
vector<LL> len(n);
unordered_map<LL, LL> mp;
unordered_map<LL, LL> mp2;
for (LL i = 0; i < n; ++i) {
if (mp[a[i]] == 0) {
mp2[a[i]] = max(mp2[a[i]], i);
} else {
mp2[a[i]] = max(mp2[a[i]], i + 1 - mp[a[i]] - 1);
}
mp[a[i]] = i + 1;
}
for (auto &e : mp2) {
e.second = max(e.second, n + 1 - mp[e.first] - 1);
}
vector<pair<LL, LL>> vp;
for (auto &e : mp2) {
vp.push_back({e.second, e.first});
}
sort(vp.begin(), vp.end());
for (LL i = 0; i < vp[0].first; ++i) {
len[i] = -1;
}
LL mn = vp[0].second;
LL p = 1;
for (LL j = vp[0].first; j < n; ++j) {
while (p < vp.size() && vp[p].first <= j) {
mn = min(mn, vp[p].second);
p++;
}
len[j] = mn;
}
for (auto e : len) {
cout << e << " ";
}
cout << "\n";
}
}
| 7
|
#include <bits/stdc++.h>
#define vi vector<int>
#define vvi vector<vi>
#define vll vector<ll>
#define vpii vector<pair<int, int>>
#define pii pair<int, int>
#define ar array
#define vvll vector<vll>
#define repa(i, b, n) for (int i = b; i < n; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 1e9
#define MP make_pair
#define ll long long int
#define M 1000000007
#define all(a) a.begin(), a.end()
// debugging
#define db(x) cout << x << "\n";
#define db1(x) cout << #x << "=" << x << "\n"
#define db2(x, y) cout << #x << "=" << x << ", " << #y << "=" << y << "\n"
#define db3(x, y, z) cout << #x << "=" << x << ", " << #y << "=" << y << ", " << #z << "=" << z << "\n"
#define dba(x) \
for (auto i : x) \
cout << i << " "
#define dbm(x) \
for (auto i : x) \
{ \
for (auto j : i) \
cout << j << " "; \
cout << "\n"; \
}
#define MOD 1000000007
using namespace std;
const int maxN = 1e5 + 1;
bool foo(int n, int u, int r, int d, int l, int mask)
{
if (mask & 1)
u--, r--;
if (mask & 2)
r--, d--;
if (mask & 4)
d--, l--;
if (mask & 8)
l--, u--;
vi a = {u, r, l, d};
for (int i : a)
{
if (i < 0 || i > n - 2)
return false;
}
return true;
}
bool solve()
{
int n, u, r, d, l;
cin >> n >> u >> r >> d >> l;
rep(i, (1 << 4))
{
if (foo(n, u, r, d, l, i))
return true;
}
return false;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--)
{
if (solve())
{
db("YES");
}
else
{
db("NO");
}
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int N = 432;
int n, m, h, t, r, dp[N][N], dx[N], dy[N], ans = -1, vis[N][N], cnt[N][N];
vector<pair<int, int>> adj[N][N];
queue<pair<int, int>> q;
bool check(int x) { return x < N && x >= 0; }
void make_edge() {
for (int x = 0; x <= r; x++)
for (int y = 0; y + x <= r; y++) {
for (int i = 0; i < min(n, x); i++) {
int new_x = dx[i] + x, new_y = dy[i] + y;
if (check(new_x) && check(new_y)) adj[x][y].push_back({new_x, new_y});
}
for (int i = 0; i < min(m, y); i++) {
int new_x = dx[i + n] + x, new_y = dy[i + n] + y;
if (check(new_x) && check(new_y)) adj[x][y].push_back({new_x, new_y});
}
}
}
void add(int x, int y, int val) {
q.push({x, y});
dp[x][y] = val;
}
void bfs() {
memset(dp, 31, sizeof dp);
add(h, t, 0);
while (q.size()) {
auto [x, y] = q.front();
q.pop();
if (x == 0 && y == 0) {
cout << "Ivan" << endl << dp[0][0] << endl;
exit(0);
}
for (auto [new_x, new_y] : adj[x][y])
if (dp[x][y] + 1 < dp[new_x][new_y]) add(new_x, new_y, dp[x][y] + 1);
}
}
void dfs(int x = h, int y = t) {
vis[x][y] = 2;
for (auto [new_x, new_y] : adj[x][y]) {
if (vis[new_x][new_y] == 2) {
cout << "Draw" << endl;
exit(0);
}
if (vis[new_x][new_y] == 0) dfs(new_x, new_y);
cnt[x][y] = max(cnt[x][y], cnt[new_x][new_y]);
}
vis[x][y] = 1;
cnt[x][y]++;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> h >> t >> r >> n;
for (int i = 0; i < n; i++) {
cin >> dx[i] >> dy[i];
dx[i] -= i + 1;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> dx[i + n] >> dy[i + n];
dy[i + n] -= i + 1;
}
make_edge(), bfs(), dfs();
cout << "Zmey" << endl << cnt[h][t] - 1 << endl;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
int N, A[MAXN];
long long cal(long long x) {
long long ans = 0, cur = 0;
for (int i = 1; i <= N; ++i) {
cur = (cur + A[i]) % x;
ans += min(cur, x - cur);
}
return ans;
}
long long solve(long long x) {
long long ans = LLONG_MAX;
if (x == 1)
return -1;
else {
long long cur = 2;
while (cur * cur <= x) {
if (x % cur == 0) ans = min(ans, cal(cur));
while (x % cur == 0) x /= cur;
++cur;
}
if (x > 1) ans = min(ans, cal(x));
}
return ans;
}
int main() {
scanf("%d", &N);
long long sum = 0;
for (int i = 1, x; i <= N; ++i) {
scanf("%d", &A[i]);
sum += A[i];
}
printf("%lld\n", solve(sum));
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
multiset<int> req;
vector<int> ans;
int n, m, T;
int id = 0;
bool t = false;
cin >> n >> m >> T;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < (int)s.length(); j++) s[j] -= '0';
int time = ((s[0]) * 10 + (s[1])) * 3600 + ((s[3]) * 10 + s[4]) * 60 +
(s[6] * 10 + s[7]);
while (((int)req.size() > 0) && (*req.begin() < time))
req.erase(req.begin());
if ((int)req.size() < m) {
++id;
} else {
set<int>::iterator it;
it = req.find(*req.rbegin());
req.erase(it);
}
ans.push_back(id);
req.insert(time + T - 1);
if ((int)req.size() == m) t = true;
}
if (!t)
cout << "No solution";
else {
cout << id << endl;
for (int i = 0; i < (int)ans.size(); i++) cout << ans[i] << endl;
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int main() {
ios_base::sync_with_stdio(false);
int i, j, n, m, k, t;
cin >> t;
while (t--) {
string s;
cin >> n >> m >> s;
for (i = 0; i < n; i += 2) {
if (s[i] == ')') {
j = i;
k = i;
while (s[j] != '(') j++;
reverse(s.begin() + i, s.begin() + j + 1);
} else if (s[i] == '(') {
j = i;
k = i + 1;
while (s[j] != ')') j++;
reverse(s.begin() + i + 1, s.begin() + j + 1);
}
v.push_back({k + 1, j + 1});
}
m = n / 2 - m;
for (i = 1; i <= m; i++) v.push_back({2 * i, 2 * i + 1});
cout << v.size() << endl;
for (i = 0; i < v.size(); i++)
cout << v[i].first << ' ' << v[i].second << endl;
v.clear();
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<vector<int>> g(n, vector<int>(m));
bool ok = 1;
for (int i = 0; i < n; ++i) {
int c = 0;
for (int j = 0; j < m; ++j) {
cin >> g[i][j], --g[i][j];
c += g[i][j] != j;
}
ok &= c < 3;
}
if (ok) {
cout << "YES";
return 0;
}
for (int f = 0; f < m; ++f) {
for (int s = 0; s < m; ++s) {
bool ok = 1;
for (int i = 0; i < n && ok; ++i) {
vector<int> G = g[i];
for (int j = 0; j < m; ++j) {
if (G[j] == f && j != s) {
swap(G[j], G[s]);
break;
}
if (G[j] == s && j != f) {
swap(G[j], G[f]);
break;
}
if (G[j] != j && G[j] != f && G[j] != s) {
swap(G[j], G[G[j]]);
break;
}
}
ok = 1;
for (int j = 0; j < m; ++j) {
if (G[j] == f) {
ok &= j == s;
} else if (G[j] == s) {
ok &= j == f;
} else {
ok &= j == G[j];
}
}
}
if (ok) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
string s;
int cnt;
bool flag;
int main() {
cin >> s;
if (s.size() >= 7) {
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] == '0')
cnt++;
else if (s[i] == '1' && cnt >= 6)
flag = true;
}
}
if (flag)
cout << "yes";
else
cout << "no";
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
int t_;
cin >> t_;
while (t_--) {
long long n, m;
cin >> n >> m;
vector<vector<long long>> a(n, vector<long long>(m, 0));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> a[i][j];
}
}
if (m > n) {
vector<vector<long long>> b(m, vector<long long>(n, 0));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
b[j][i] = a[i][j];
}
}
a = b;
swap(n, m);
}
vector<vector<bool>> c(n, vector<bool>(m, false));
long long result = 0;
for (long long i = 0; i < n; i++) {
bool success = true;
long long digits[2]{};
for (long long j = 0; j < m && i - j >= 0; j++) {
digits[a[i - j][j]]++;
if (!c[i - j][j])
c[i - j][j] = true;
else
success = false;
}
for (long long j = m - 1; j >= 0 && (n - 1 - i) + (m - 1 - j) < n; j--) {
digits[a[(n - 1 - i) + (m - 1 - j)][j]]++;
if (!c[(n - 1 - i) + (m - 1 - j)][j])
c[(n - 1 - i) + (m - 1 - j)][j] = true;
else
success = false;
}
if (success)
result += min(digits[0], digits[1]);
else
break;
}
cout << result << endl;
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
template <class T>
inline T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
string s;
long long n, res;
long long check(long long a, long long b) {
for (long long l = a, _b = b; l <= _b; l++) {
for (int h = 1; l + h * 2 <= b; h++) {
if (s[l] == s[l + h] && s[l] == s[l + 2 * h]) {
return 1;
}
}
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s;
long long n = s.size();
s = " " + s;
for (long long i = 9, _b = n; i <= _b; i++) res += n - i + 1;
for (long long l = 1, _b = n; l <= _b; l++)
for (long long i = 0, _b = 7; i <= _b; i++) {
if (l + i > n) continue;
res += check(l, l + i);
}
cout << res;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 400;
int n, m;
char hor[MAX_N];
char ver[MAX_N];
int f[MAX_N][MAX_N];
int id(int i, int j) { return i * m + j; }
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
memset(f, 0, sizeof f);
scanf("%s%s", hor, ver);
for (int i = 0; i < n; i++) {
if (hor[i] == '<')
for (int j = 0; j < m; j++)
for (int k = 0; k < j; k++) f[id(i, j)][id(i, k)] |= 1;
else
for (int j = 0; j < m; j++)
for (int k = j + 1; k < m; k++) f[id(i, j)][id(i, k)] |= 1;
}
for (int i = 0; i < m; i++) {
if (ver[i] == '^') {
for (int j = 0; j < n; j++)
for (int k = 0; k < j; k++) f[id(j, i)][id(k, i)] |= 1;
} else {
for (int j = 0; j < n; j++)
for (int k = j + 1; k < n; k++) f[id(j, i)][id(k, i)] |= 1;
}
}
for (int k = 0; k < n * m; k++)
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) f[i][j] |= f[i][k] && f[k][j];
bool good = true;
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) good &= (i == j || f[i][j]);
puts(good ? "YES" : "NO");
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, sum = 0;
char x = getchar();
for (; (x < '0' || x > '9'); x = getchar())
if (x == '-') f = -1;
for (; x >= '0' && x <= '9'; x = getchar()) sum = sum * 10 + x - '0';
return f * sum;
}
int n, t, s;
int a[200005], biao[200005];
multiset<int> q;
vector<int> sta[2];
pair<int, int> cc[200005];
inline int calc_(int opt) {
q.clear();
if (t < s) {
for (int i = 1; i <= t; ++i) sta[opt].push_back(s - i);
if (t) {
sta[opt].pop_back();
sta[opt].push_back(1);
}
for (int i = 2; i <= s - t; ++i) sta[opt].push_back(i);
for (int i = s + 1; i <= n; ++i) sta[opt].push_back(i);
} else {
for (int i = 1; i <= s - 1; ++i) sta[opt].push_back(s - i);
int cnt = 0;
for (int i = s + 1; i <= n - 1; ++i)
cc[++cnt] = make_pair(a[i + 1] - a[i], i);
sort(cc + 1, cc + cnt + 1);
cnt = t - s + 1;
unsigned Min = 0, tot = 0;
for (int i = 1; i <= cnt; ++i) tot += cc[i].first, q.insert(cc[i].first);
Min = tot * 2;
for (int j = n - 1; j >= s + 1; --j) {
auto it = q.lower_bound(a[j + 1] - a[j]);
if (it == q.end()) it--;
q.erase(it);
tot -= *it;
Min = min(Min, a[n] - a[j] + tot * 2);
if (q.empty()) break;
}
tot = 0;
for (int i = 1; i <= cnt; ++i) tot += cc[i].first, q.insert(cc[i].first);
if (tot * 2 == Min) {
for (int i = s + 1; i <= n - 1; ++i) {
auto it = q.lower_bound(a[i + 1] - a[i]);
if (it != q.end()) biao[i] = 1, q.erase(it);
}
} else {
for (int j = n - 1; j >= s + 1; --j) {
biao[j] = 1;
auto it = q.lower_bound(a[j + 1] - a[j]);
if (it == q.end()) it--;
q.erase(it);
tot -= *it;
if (a[n] - a[j] + tot * 2 == Min) {
for (int i = s + 1; i <= j; ++i) {
it = q.lower_bound(a[i + 1] - a[i]);
if (it != q.end()) biao[i] = 1, q.erase(it);
}
break;
}
}
}
for (int las = s, i = s + 1; i <= n; las = i, ++i) {
while (biao[i]) ++i;
sta[opt].push_back(i);
for (int j = i - 1; j >= las + 1; --j) sta[opt].push_back(j);
}
}
int x = sta[opt][0];
unsigned ans = a[max(s, x)] - a[min(s, x)];
for (int i = 1; i <= n - 2; ++i) {
int x = sta[opt][i];
int y = sta[opt][i - 1];
ans += a[max(x, y)] - a[min(x, y)];
}
return ans;
}
int main() {
n = read(), t = read(), s = read();
for (int i = 1; i <= n; ++i) a[i] = read();
if (s != 1 && !t) return puts("-1"), 0;
if (s != n && !(n - t - 1)) return puts("-1"), 0;
unsigned int ans[2] = {0};
ans[0] = calc_(0);
for (int i = 1; i <= n / 2; ++i) swap(a[i], a[n - i + 1]);
memset(biao, 0, sizeof(biao));
for (int i = 1; i <= n; ++i) a[i] = -a[i];
t = n - 1 - t, s = n + 1 - s;
ans[1] = calc_(1);
printf("%d\n", min(ans[0], ans[1]));
if (ans[0] < ans[1])
for (int i = 0, size = sta[0].size(); i < size; ++i)
printf("%d ", sta[0][i]);
else
for (int i = 0, size = sta[1].size(); i < size; ++i)
printf("%d ", n - sta[1][i] + 1);
puts("");
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e7;
const int MAXM = 1 << 20;
const int MAXN = 19;
double a[MAXN][MAXN];
double dp[MAXM];
bool used[MAXM];
int n;
double solve(long long mask) {
if (mask == 1) return 1.0;
if (!(mask & 1)) return 0.0;
if (used[mask]) return dp[mask];
double ret = 0;
for (int i = 0; i < n; i++) {
if (!(mask & (1 << i))) continue;
for (int j = 0; j < n; j++) {
if (!(mask & (1 << j)) or i == j) continue;
double re = 0;
re += (a[i][j] * solve(mask ^ (1 << j)));
re += (a[j][i] * solve(mask ^ (1 << i)));
ret = max(ret, re);
}
}
dp[mask] = ret;
used[mask] = true;
return 1.0 * ret;
}
int main() {
memset(used, false, sizeof(used));
int t, i, j, k;
cin >> n;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cin >> a[i][j];
}
}
printf("%0.6lf\n", solve((1 << n) - 1));
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a[101] = {0};
cin >> n >> k;
for (int i = 0; i < n; ++i) {
int p;
cin >> p;
a[p]++;
}
int max_cutlery = *max_element(a, a + 101);
int min_dishes = (max_cutlery - 1) / k + 1;
int min_cutlery = min_dishes * k;
int lost = 0;
for (int p = 0; p <= 100; ++p) {
if (a[p] > 0 && a[p] < min_cutlery) lost += min_cutlery - a[p];
}
cout << lost << endl;
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
long long int ff(long long int v) {
if (v % 2LL == 0LL)
return (v / 2) * (v + 1);
else
return ((v + 1) / 2) * v;
}
long long int cnt(long long int n, long long int x, long long int y,
long long int t) {
long long int res = t * t + (t + 1) * (t + 1);
long long int v0 = max(1 - x + t, 0LL);
long long int v1 = max(1 - y + t, 0LL);
long long int v2 = max(x + t - n, 0LL);
long long int v3 = max(y + t - n, 0LL);
long long int w0 = max(t - x - y + 1, 0LL);
long long int w1 = max(t + x - y - n, 0LL);
long long int w2 = max(t + x + y - 2 * n - 1, 0LL);
long long int w3 = max(t - x + y - n, 0LL);
res -= v0 * v0;
res += ff(w0);
res -= v1 * v1;
res += ff(w1);
res -= v2 * v2;
res += ff(w2);
res -= v3 * v3;
res += ff(w3);
return res;
}
int main() {
long long int n, x, y, c;
cin >> n >> x >> y >> c;
long long int lb = 0, ub = 2 * n;
while (ub - lb > 10LL) {
long long int md = (lb + ub) / 2;
if (cnt(n, x, y, md) >= c)
ub = md;
else
lb = md;
}
long long int ans = lb;
for (; ans <= ub && cnt(n, x, y, ans) < c; ans++)
;
cout << ans << endl;
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int arr[10005], h[10005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t, n, i;
string st;
cin >> t;
while (t--) {
cin >> st;
int ans = 0, cnt = 0;
n = st.length();
for (i = 0; i < n; i++) {
if (st[i] == 'R')
cnt = 0;
else {
cnt++;
ans = max(ans, cnt);
}
}
cout << ans + 1 << "\n";
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (__typeof((n)) i = (0); i < (n); i += 1) {
int x;
cin >> x;
if (x % 2 == 0) {
x--;
}
cout << x << " ";
}
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[500];
while (scanf(" %s", str) != EOF) {
int pnum = 0, mbottom = 0, mtop = 0;
int len = strlen(str);
for (int i = 0; i < len; i++) {
if (str[i] == '+') {
pnum++;
if (pnum > mtop) mtop = pnum;
if (pnum < mbottom) mbottom = pnum;
} else {
pnum--;
if (pnum > mtop) mtop = pnum;
if (pnum < mbottom) mbottom = pnum;
}
}
cout << mtop - mbottom << endl;
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, max = 0;
cin >> n;
vector<long long> v(n), out(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
max = v[n - 1];
out[n - 1] = 0;
for (int i = n - 2; i >= 0; i--) {
if (v[i] <= max) {
out[i] = (max - v[i] + 1);
} else {
out[i] = 0;
max = v[i];
}
}
for (int i = 0; i < n; i++) {
if (i == 0)
cout << out[i];
else {
cout << " " << out[i];
}
}
cout << endl;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void err(istream_iterator<string> it) { cout << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << " ";
err(++it, args...);
}
long long pow(long long x, long long y) {
if (y == 0) return 1;
long long temp = pow(x, y / 2);
temp = (temp * temp);
if (y % 2 == 1) temp *= x;
return temp;
}
const int MAXN = 1E5 + 100;
int n;
map<int, int> visible, total;
set<int> good;
int main() {
cin >> n;
for (int i = 0, f, b; i < n; i++) {
cin >> f >> b;
visible[f]++;
total[f]++;
if (f != b) total[b]++;
if (total[f] >= (n + 1) / 2) good.insert(f);
if (total[b] >= (n + 1) / 2) good.insert(b);
}
int res = 1E6;
for (int col : good) {
res = min(res, max((n + 1) / 2 - visible[col], 0));
}
if (res == 1E6)
cout << -1;
else
cout << res;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 35;
const int M = 1e6 + 16;
inline int func(int x, int y, int mny, int mxy, int mnz, int mxz) {
int z = -y - x;
return max({abs(y - mny), abs(y - mxy), abs(z - mnz), abs(z - mxz)});
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(32);
int n;
cin >> n;
vector<int> x, y, z;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
int b = 0, n = 0;
for (auto ch : s) {
if (ch == 'B')
b++;
else
n++;
}
x.push_back(b);
y.push_back(-n);
z.push_back(n - b);
}
int mnx = *min_element(x.begin(), x.end());
int mny = *min_element(y.begin(), y.end());
int mnz = *min_element(z.begin(), z.end());
int mxx = *max_element(x.begin(), x.end());
int mxy = *max_element(y.begin(), y.end());
int mxz = *max_element(z.begin(), z.end());
int ans = 1e9, ans_x = 0, ans_y = 0;
for (int xx = 0; xx <= M; xx++) {
int tmp = max(abs(mnx - xx), abs(mxx - xx));
int lo = 0, hi = M;
while (lo < hi) {
int mi = lo + (hi - lo) / 2;
if (func(xx, -mi, mny, mxy, mnz, mxz) <
func(xx, -mi - 1, mny, mxy, mnz, mxz))
hi = mi;
else
lo = mi + 1;
}
int val = max(tmp, func(xx, -lo, mny, mxy, mnz, mxz));
if (ans > val && xx + lo > 0) {
ans = val;
ans_x = xx;
ans_y = lo;
}
}
cout << ans << '\n';
while (ans_x--) {
cout << 'B';
}
while (ans_y--) {
cout << 'N';
}
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
const int N = 22;
int d[N], spos[N], n, m;
vector<pair<int, int> > res;
void solveRev(int id, int a, int b, int c) {
if (id > m) return;
solveRev(id + 1, a, c, b);
for (int i = spos[id]; i < spos[id + 1]; ++i)
res.push_back(pair<int, int>(a, c));
solveRev(id + 1, b, a, c);
}
void solve(int id, int a, int b, int c) {
if (id == m) {
for (int i = spos[id]; i + 1 < spos[id + 1]; ++i)
res.push_back(pair<int, int>(a, b));
res.push_back(pair<int, int>(a, c));
for (int i = spos[id]; i + 1 < spos[id + 1]; ++i)
res.push_back(pair<int, int>(b, c));
return;
}
if (spos[id] + 1 == spos[id + 1]) {
solveRev(id, a, b, c);
return;
}
solveRev(id + 1, a, b, c);
for (int i = spos[id]; i < spos[id + 1]; ++i)
res.push_back(pair<int, int>(a, b));
solveRev(id + 1, c, b, a);
for (int i = spos[id]; i < spos[id + 1]; ++i)
res.push_back(pair<int, int>(b, c));
solve(id + 1, a, b, c);
}
int main() {
scanf("%d", &n);
m = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &d[i]);
if (d[i] != d[i - 1]) spos[++m] = i;
}
spos[m + 1] = n + 1;
solve(1, 1, 2, 3);
printf("%d\n", (int)res.size());
for (pair<int, int> y : res) printf("%d %d\n", y.first, y.second);
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const int INf = 0x7f7f7f7f;
int n, a[N], f[N][2], g[N][2];
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
f[i][0] = f[i][1] = INf;
}
f[1][0] = f[1][1] = -INf;
for (int i = 2; i <= n; i++) {
if (a[i] > a[i - 1] && f[i][0] > f[i - 1][0]) {
f[i][0] = f[i - 1][0];
g[i][0] = 0;
}
if (a[i] > f[i - 1][0] && f[i][0] > a[i - 1]) {
f[i][0] = a[i - 1];
g[i][0] = 0;
}
if (a[i] > -a[i - 1] && f[i][0] > f[i - 1][1]) {
f[i][0] = f[i - 1][1];
g[i][0] = 1;
}
if (a[i] > f[i - 1][1] && f[i][0] > -a[i - 1]) {
f[i][0] = -a[i - 1];
g[i][0] = 1;
}
if (-a[i] > a[i - 1] && f[i][1] > f[i - 1][0]) {
f[i][1] = f[i - 1][0];
g[i][1] = 0;
}
if (-a[i] > f[i - 1][0] && f[i][1] > a[i - 1]) {
f[i][1] = a[i - 1];
g[i][1] = 0;
}
if (-a[i] > -a[i - 1] && f[i][1] > f[i - 1][1]) {
f[i][1] = f[i - 1][1];
g[i][1] = 1;
}
if (-a[i] > f[i - 1][1] && f[i][1] > -a[i - 1]) {
f[i][1] = -a[i - 1];
g[i][1] = 1;
}
}
if (f[n][0] == INf && f[n][1] == INf) {
printf("NO\n");
} else {
printf("YES\n");
int u = f[n][0] == INf ? 1 : 0;
for (int i = n; i >= 1; i--) {
a[i] = u ? -a[i] : a[i];
u = g[i][u];
}
for (int i = 1; i <= n; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
}
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100000];
int sum;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum % n)
cout << n - 1;
else
cout << n;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> &a, pair<int, int> &b) {
if (a.first == b.first) return a.second < b.second;
return a.first < b.first;
}
int main() {
vector<pair<int, int> > v(3);
set<pair<int, int> > ans;
cin >> v[0].first >> v[0].second;
cin >> v[1].first >> v[1].second;
cin >> v[2].first >> v[2].second;
sort(v.begin(), v.end(), cmp);
int i = v[0].first, j = v[0].second;
ans.insert({i, j});
int f1 = 0, f2 = 0;
if (v[1].second > v[0].second) f1 = 1;
if (v[2].second > v[1].second) f2 = 1;
while (i < v[1].first) ++i, ans.insert({i, j});
if (f1 == 1) {
while (j < v[1].second) {
++j, ans.insert({i, j});
}
} else {
while (j > v[1].second) {
--j, ans.insert({i, j});
}
}
if (f2 == 1) {
while (j < v[2].second) {
++j, ans.insert({i, j});
}
} else {
while (j > v[2].second) {
--j, ans.insert({i, j});
}
}
while (i < v[2].first) ++i, ans.insert({i, j});
cout << ans.size() << "\n";
for (auto it = ans.begin(); it != ans.end(); it++)
cout << (*it).first << " " << (*it).second << "\n";
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename C>
ostream& operator<<(ostream& os, const vector<C>& v) {
for (__typeof((v).begin()) __it = (v).begin(); __it != (v).end(); __it++)
os << *(__it) << ' ';
return os;
}
const int inf = 0x3f3f3f3f;
const long long inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-5;
struct widget;
map<string, int> idbyname;
const int maxn = 123;
vector<widget> WS;
int last;
struct widget {
vector<int> inner;
long long border, space;
long long w, h;
int type;
bool calc;
void doCalc() {
if (calc) return;
calc = true;
if (type == 0) {
return;
} else {
if ((int((inner).size()))) {
for (int i = 0; i < (int((inner).size())); i++) {
WS[inner[i]].doCalc();
if (type == 1) {
w += WS[inner[i]].w;
h = max(h, WS[inner[i]].h);
} else {
h += WS[inner[i]].h;
w = max(w, WS[inner[i]].w);
}
if (i) {
if (type == 1)
w += space;
else
h += space;
}
}
w += 2 * border;
h += 2 * border;
}
}
}
};
void clear(string& s) {
for (int j = 0; j < (int((s).size())); j++)
if (s[j] == '(' || s[j] == ',' || s[j] == ')' || s[j] == '.') s[j] = ' ';
}
int main() {
WS.resize(maxn);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s.find('.') == s.npos) {
int type = 0;
if (s == "VBox")
type = 2;
else if (s == "HBox")
type = 1;
cin >> s;
clear(s);
stringstream ss(s);
string name;
ss >> name;
idbyname[name] = last;
if (!type) {
int w, h;
ss >> w >> h;
WS[last].w = w;
WS[last].h = h;
}
WS[last].type = type;
last++;
} else {
clear(s);
stringstream ss(s);
string name, action;
ss >> name >> action;
if (action == "set_border") {
int b;
ss >> b;
WS[idbyname[name]].border = b;
} else if (action == "set_spacing") {
int sp;
ss >> sp;
WS[idbyname[name]].space = sp;
} else {
string inname;
ss >> inname;
WS[idbyname[name]].inner.push_back(idbyname[inname]);
}
}
}
for (pair<string, int> it : idbyname) {
WS[it.second].doCalc();
cout << it.first << ' ' << WS[it.second].w << ' ' << WS[it.second].h
<< endl;
}
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f7f7f7f;
const int MAXN = 305;
const double eps = 1e-10;
int maze[MAXN][MAXN];
int dis[2][MAXN * MAXN];
int n, m, p;
struct node {
int x, y, len, id;
node(int x = 0, int y = 0, int len = 0, int id = 0)
: x(x), y(y), len(len), id(id) {}
};
vector<node> g[MAXN * MAXN];
bool cmp(node X, node Y) { return X.len < Y.len; }
int ABS(int x) { return x < 0 ? -x : x; }
int getdis(int x1, int y1, int x2, int y2) {
return ABS(x1 - x2) + ABS(y1 - y2);
}
int getdis(node tx, node ty) { return ABS(tx.x - ty.x) + ABS(tx.y - ty.y); }
int main() {
int i, j, k, now;
while (scanf("%d%d%d", &n, &m, &p) != EOF) {
for (i = 0; i <= p; i++) g[i].clear();
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
scanf("%d", &maze[i][j]);
g[maze[i][j]].push_back(node(i, j, INF));
}
}
g[0].push_back(node(1, 1));
for (i = 1; i <= p; i++) {
int sz1 = g[i - 1].size();
int sz2 = g[i].size();
node tx, ty;
now = 1 - now;
for (j = 0; j < sz1 && j <= 600; j++) {
tx = g[i - 1][j];
for (k = 0; k < sz2; k++) {
ty = g[i][k];
g[i][k].len = min(ty.len, tx.len + getdis(tx, ty));
}
}
sort(g[i].begin(), g[i].end(), cmp);
}
int ans = INF;
int sz = g[p].size();
for (i = 0; i < sz; i++) {
ans = min(ans, g[p][i].len);
}
printf("%d\n", ans);
}
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T getint() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
template <typename T1, typename T2>
bool umin(T1 &x, const T2 &y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, const T2 &y) {
if (x < y) return x = y, true;
return false;
}
const int maxn = (int)1e6 + 10;
const int inf = (int)1e9 + 5;
const int mod = (int)1e9 + 7;
const long long llinf = (long long)1e18 + 5;
const long double pi = acos(-1.0);
int c[maxn];
int v[maxn];
int x[maxn];
int k;
long long calc(long long v) {
long long t = 0;
for (int i = (0); i < (k + 1); i++) {
long long D = x[i + 1] - x[i];
if (D > v) return llinf;
if (v >= 2 * D) {
t += D;
continue;
}
long long a = v - D;
t += a + 2 * (D - a);
}
return t;
}
int main() {
int n = getint<int>();
k = getint<int>();
int s = getint<int>();
int t = getint<int>();
for (int i = (0); i < (n); i++) {
c[i] = getint<int>();
v[i] = getint<int>();
}
int mx = 0;
for (int i = (1); i < (k + 1); i++) x[i] = getint<int>();
x[k + 1] = s;
sort(x, x + k + 2);
long long l = 0, r = llinf;
while (r - l > 1) {
long long m = (l + r) / 2;
if (calc(m) <= t) {
r = m;
} else
l = m;
}
int res = -1;
for (int i = (0); i < (n); i++) {
if (v[i] < r) continue;
if (res == -1 || res > c[i]) res = c[i];
}
printf("%d\n", res);
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const long long MN = 1e5 + 7;
const long long MK = 1500;
long long n, m, lv[MN], rv[MN], w[MN], lazy[MN << 2], mark[MN];
bitset<MK> a[MN << 2], p;
vector<long long> g[MN], to;
void sh(long long u, long long x) {
bitset<MK> s = a[u];
a[u] = (s >> (m - x)) | (s << x);
}
void push(long long l, long long r, long long u) {
lazy[u] %= m;
if (l == r) {
lazy[u] = 0;
return;
}
sh((u << 1), lazy[u]);
sh(((u << 1) | 1), lazy[u]);
lazy[(u << 1)] = (lazy[(u << 1)] + lazy[u]) % m;
lazy[((u << 1) | 1)] = (lazy[((u << 1) | 1)] + lazy[u]) % m;
lazy[u] = 0;
}
void chup(long long l, long long r, long long u) {
push(l, r, u);
a[u] = a[(u << 1)] | a[((u << 1) | 1)];
}
void upd(long long l, long long r, long long u, long long x, long long y,
long long w) {
if (l == x && r == y) {
sh(u, w);
lazy[u] = (lazy[u] + w) % m;
return;
}
push(l, r, u);
if (x <= ((l + r) >> 1)) {
upd(l, ((l + r) >> 1), (u << 1), x, min(y, ((l + r) >> 1)), w);
}
if (y > ((l + r) >> 1)) {
upd(((l + r) >> 1) + 1, r, ((u << 1) | 1), max(x, ((l + r) >> 1) + 1), y,
w);
}
chup(l, r, u);
}
bitset<MK> ask(long long l, long long r, long long u, long long x,
long long y) {
push(l, r, u);
if (l == x && r == y) {
return a[u];
}
bitset<MK> re = 0;
if (x <= ((l + r) >> 1)) {
re = re | ask(l, ((l + r) >> 1), (u << 1), x, min(y, ((l + r) >> 1)));
}
if (y > ((l + r) >> 1)) {
re = re | ask(((l + r) >> 1) + 1, r, ((u << 1) | 1),
max(x, ((l + r) >> 1) + 1), y);
}
return re;
}
void dfs(long long now) {
lv[now] = to.size();
mark[now] = 1;
for (long long i = 0; i < g[now].size(); i++) {
if (mark[g[now][i]] == 0) {
dfs(g[now][i]);
}
}
rv[now] = to.size();
to.push_back(now);
}
void build(long long l, long long r, long long u) {
if (l == r) {
a[u] = 0;
a[u].set(w[to[l]]);
return;
}
build(l, ((l + r) >> 1), (u << 1));
build(((l + r) >> 1) + 1, r, ((u << 1) | 1));
chup(l, r, u);
}
signed main() {
cin >> n >> m;
for (long long i = 2; i < m; i++) p.set(i);
for (long long i = 2; i < m; i++) {
if (!p[i]) continue;
long long x = i * i;
while (x < m) {
p[x] = 0;
x += i;
}
}
for (long long i = 1; i <= n; i++) {
cin >> w[i];
w[i] %= m;
}
for (long long i = 1; i < n; i++) {
long long x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1);
build(0, n - 1, 1);
long long f;
cin >> f;
while (f--) {
long long t, v;
cin >> t >> v;
if (t == 1) {
long long x;
cin >> x;
x %= m;
upd(0, n - 1, 1, lv[v], rv[v], x);
} else {
cout << (ask(0, n - 1, 1, lv[v], rv[v]) & p).count() << endl;
}
}
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
int hours[100007], konta[100007];
bool vis[100007];
vector<int> v[100007], v2[100007];
vector<int> scc[100007], graph[100007];
vector<int> topsort;
void dfs(int s) {
vis[s] = true;
for (int i = 0; i < v[s].size(); i++) {
int ve = v[s][i];
if (!vis[ve]) {
dfs(ve);
}
}
topsort.push_back(s);
}
void dfs2(int s, int cnt) {
vis[s] = true;
for (int i = 0; i < v2[s].size(); i++) {
int ve = v2[s][i];
if (!vis[ve]) {
dfs2(ve, cnt);
}
}
scc[cnt].push_back(s);
konta[s] = cnt;
}
int main() {
int n, m, h, i, j, k, l, x, y;
cin >> n >> m >> h;
for (i = 1; i <= n; i++) {
cin >> hours[i];
}
for (i = 0; i < m; i++) {
cin >> x >> y;
if (hours[y] == (hours[x] + 1) % h) {
v[x].push_back(y);
v2[y].push_back(x);
}
if (hours[x] == (hours[y] + 1) % h) {
v[y].push_back(x);
v2[x].push_back(y);
}
}
for (i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i);
}
}
reverse(topsort.begin(), topsort.end());
memset(vis, false, sizeof(vis));
int cnt = 0;
for (i = 0; i < n; i++) {
int s = topsort[i];
if (!vis[s]) {
dfs2(s, cnt);
cnt++;
}
}
for (i = 1; i <= n; i++) {
for (j = 0; j < v[i].size(); j++) {
x = i;
y = v[i][j];
if (konta[x] != konta[y]) {
graph[konta[x]].push_back(konta[y]);
}
}
}
int minn = 100007;
int ke;
for (i = 0; i < cnt; i++) {
if ((int)graph[i].size() == 0) {
if ((int)scc[i].size() < minn) {
minn = (int)scc[i].size();
ke = i;
}
}
}
cout << minn << endl;
for (i = 0; i < scc[ke].size(); i++) {
cout << scc[ke][i] << " ";
}
cout << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
clock_t startTime;
double getCurrentTime() {
return (double)(clock() - startTime) / CLOCKS_PER_SEC;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const pair<T, U> &_p) {
_out << _p.first << " " << _p.second;
return _out;
}
template <typename T, typename U>
inline istream &operator>>(istream &_in, pair<T, U> &_p) {
_in >> _p.first >> _p.second;
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const vector<T> &_v) {
if (_v.empty()) return _out;
_out << _v.front();
for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) _out << ' ' << *_it;
return _out;
}
template <typename T>
inline istream &operator>>(istream &_in, vector<T> &_v) {
for (auto &_i : _v) _in >> _i;
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const set<T> &_s) {
if (_s.empty()) return _out;
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const multiset<T> &_s) {
if (_s.empty()) return _out;
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_set<T> &_s) {
if (_s.empty()) return _out;
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_multiset<T> &_s) {
if (_s.empty()) return _out;
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const map<T, U> &_m) {
if (_m.empty()) return _out;
_out << "{\"" << _m.begin()->first << "\", \"" << _m.begin()->second << "\"}";
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it)
_out << ", { \"" << _it->first << "\", \"" << _it->second << "\"}";
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const unordered_map<T, U> &_m) {
if (_m.empty()) return _out;
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it)
_out << ", (" << _it->first << ": " << _it->second << ')';
return _out;
}
template <typename T>
void out(const vector<T> &a, int n) {
for (int i = 1; i <= n; ++i) {
cout << a[i] << ' ';
}
cout << "\n";
}
template <typename T>
void out(const vector<vector<T>> &a, int n, int m) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cout << a[i][j] << ' ';
}
cout << '\n';
}
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> a(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
long long ans = -1e15;
for (long long i = 1; i <= n; ++i) {
for (long long j = i - 1; j >= max(1LL, i - k); --j) {
ans = max(ans, i * j - k * (a[i] | a[j]));
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
startTime = clock();
int T = 1;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m, p;
void doprint(vector<vector<int>> &a, int swapy) {
if (!swapy) {
for (auto e : a) {
for (auto f : e) printf("%c", f ? '*' : '.');
printf("\n");
}
} else {
for (int i = 0; i < a[0].size(); i++) {
for (int j = 0; j < a.size(); j++) {
printf("%c", a[j][i] ? '*' : '.');
}
printf("\n");
}
}
}
int dodo() {
int i, j, k, l;
cin >> n >> m >> p;
vector<vector<int>> a;
a.resize(n);
for (i = 0; i < n; i++) a[i].resize(m);
if (p == 0) {
a[0][0] = 1;
doprint(a, 0);
return 0;
}
if (n <= 4 && m <= 4) {
for (i = 1; i < (1 << n * m); i++) {
for (j = 0; j < n * m; j++) a[j / m][j % m] = !!(i & (1 << j));
int cnt = 0;
for (j = 0; j < n - 1; j++)
for (k = 0; k < m - 1; k++) {
int u = a[j][k] + a[j][k + 1] + a[j + 1][k] + a[j + 1][k + 1];
if (u == 3)
cnt++;
else if (u == 4)
cnt += 4;
}
if (cnt == p) {
for (j = 0; j < n; j++) {
for (k = 0; k < m; k++) printf("%c", a[j][k] ? '*' : '.');
printf("\n");
}
return 0;
}
}
return !printf("-1\n");
}
int swapy = 0;
if (m <= 4) swap(n, m), swapy = 1;
a.resize(n);
for (i = 0; i < n; i++) a[i].resize(m);
if (n == 3 && p == 4 * (n - 1) * (m - 1) - 8) {
for (i = 1; i < m; i++)
for (j = 0; j < 3; j++) a[j][i] = 1;
doprint(a, swapy);
return 0;
}
int now = 0;
for (i = 0; i < m; i++) a[0][i] = 1;
for (i = 1; i < n; i++) {
for (j = 0; j < m; j++) {
if (i == n - 1 && j == m - 4) break;
a[i][j] = 1;
if (j == 0)
now++;
else if (j == m - 1)
now += 3;
else
now += 4;
if (p - now < 4) {
if (i < n - 1) {
if (p - now == 0)
;
else if (p - now == 1) {
if (j >= 1)
a[i + 1][0] = 1;
else
a[i][m - 1] = 1;
} else if (p - now == 2) {
if (j == 0)
a[i][m - 1] = a[i + 1][0] = a[i + 1][1] = 1;
else if (j == 1)
a[i + 1][0] = a[i][m - 1] = 1;
else
a[i + 1][0] = a[i + 1][j] = 1;
} else {
if (j == 0)
a[i + 1][0] = a[i + 1][1] = a[i][m - 2] = 1;
else if (j == 1)
a[i + 1][0] = a[i][m - 2] = 1;
else if (j == 2)
a[i + 1][1] = a[i][m - 1] = 1;
else
a[i + 1][0] = a[i + 1][j - 1] = 1;
}
doprint(a, swapy);
return 0;
} else {
if (p - now == 0)
;
else if (p - now == 1)
a[i][m - 1] = 1;
else if (p - now == 2)
a[i][m - 2] = 1;
else if (p - now == 3)
a[i][m - 3] = a[i][m - 1] = 1;
doprint(a, swapy);
return 0;
}
}
}
}
map<int, string> mq;
mq[0] = "0000";
mq[1] = "0001";
mq[2] = "0010";
mq[3] = "0101";
mq[4] = "1000";
mq[5] = "1001";
mq[6] = "1010";
mq[8] = "1100";
mq[9] = "1101";
mq[12] = "1110";
mq[15] = "1111";
if (mq.count(p - now)) {
for (i = 0; i < 4; i++) a[n - 1][m - 4 + i] = mq[p - now][i] - '0';
doprint(a, swapy);
} else
return !printf("-1\n");
}
int main() {
int i, j, k, l;
int T;
cin >> T;
while (T--) {
dodo();
printf("\n");
}
return 0;
}
| 23
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a = 0;
string x, y;
cin >> x >> y;
for (int i = 0; x[i] != '\0'; i++) {
if (x[i] < y[i]) {
a = 1;
break;
}
}
if (a == 1)
cout << "-1";
else {
for (int i = 0; y[i] != '\0'; i++) {
if (x[i] >= y[i])
cout << y[i];
else
cout << "z";
}
}
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, c;
cin >> n >> k >> c;
int array[c];
for (int i = 0; i < c; ++i) cin >> array[i];
int cnt = 0;
for (int i = 0; i <= n; i += k) {
if (i != 0) cnt++;
for (int j = 0; j < c; ++j) {
if (array[j] < i + k && array[j] >= i + 1) {
i = array[j];
i -= k;
break;
}
}
}
cout << cnt;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 19;
const int N = 2e5 + 25;
struct Trie {
int sz;
vector<int> val, lazy;
Trie(int k) {
sz = 1 << (k + 1);
val.resize(sz, inf);
lazy.resize(sz, 0);
}
void push(int v) {
if (lazy[v]) {
val[v] += lazy[v];
if (val[v] > inf) val[v] = inf;
if ((v << 1) < sz) {
lazy[v << 1] += lazy[v];
lazy[(v << 1) ^ 1] += lazy[v];
}
lazy[v] = 0;
}
}
void insert(string s, int x) {
reverse(s.begin(), s.end());
int rt = 1;
for (auto ch : s) {
push(rt);
rt <<= 1;
if (ch == '1') rt ^= 1;
}
push(rt);
while (rt) {
val[rt] = min(val[rt], x);
rt >>= 1;
}
}
void update(int x) { lazy[1] += x; }
int query(string s) {
reverse(s.begin(), s.end());
int rt = 1;
for (auto ch : s) {
push(rt);
rt <<= 1;
if (ch == '1') rt ^= 1;
}
push(rt);
return val[rt];
}
};
int k;
string s[N];
inline int compute(int x, int y) {
if (x == 0) return k;
for (int len = k; len >= 1; len--) {
if (s[x].substr(k - len) == s[y].substr(0, len)) return k - len;
}
return k;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(32);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
k = s[1].size();
Trie trie(k);
int sum = k;
for (int i = 1; i < n; i++) {
int cur = sum + k;
for (int len = 0; len <= k; len++) {
cur = min(cur, k - len + trie.query(s[i + 1].substr(0, len)));
}
trie.update(compute(i, i + 1));
trie.insert(s[i], cur);
sum += compute(i, i + 1);
}
trie.push(1);
cout << min(sum, trie.val[1]);
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
char p[1011][1011];
long long val[1011][1011];
long long S[26][1011][1011];
struct pic {
int a, b, c, d, e;
};
void update(int e, int a, int b, int c, int d) {
S[e][a][b]++;
S[e][c + 1][b]--;
S[e][a][d + 1]--;
S[e][c + 1][d + 1]++;
}
long long query(long long f[1011][1011], int a, int b, int c, int d) {
return f[c][d] - f[a - 1][d] - f[c][b - 1] + f[a - 1][b - 1];
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> p[i][j];
}
}
vector<pic> Q(k);
for (int i = 0; i < k; i++) {
char temp;
cin >> Q[i].a >> Q[i].b >> Q[i].c >> Q[i].d >> temp;
Q[i].e = temp - 'a';
update(Q[i].e, Q[i].a, Q[i].b, Q[i].c, Q[i].d);
}
for (int e = 0; e < 26; e++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
S[e][i][j] += S[e][i - 1][j] + S[e][i][j - 1] - S[e][i - 1][j - 1];
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int cur = 0;
for (int e = 0; e < 26; e++) cur += S[e][i][j];
S[p[i][j] - 'a'][i][j] += k - cur;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int e = 0; e < 26; e++) {
val[i][j] += S[e][i][j] * abs(e - (int)(p[i][j] - 'a'));
}
val[i][j] += val[i][j - 1] + val[i - 1][j] - val[i - 1][j - 1];
}
}
for (int e = 0; e < 26; e++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
S[e][i][j] += S[e][i - 1][j] + S[e][i][j - 1] - S[e][i - 1][j - 1];
}
}
}
long long ans = 1e18;
for (int i = 0; i < k; i++) {
long long cur = val[n][m];
cur -= query(val, Q[i].a, Q[i].b, Q[i].c, Q[i].d);
for (int e = 0; e < 26; e++) {
cur += abs(e - Q[i].e) * query(S[e], Q[i].a, Q[i].b, Q[i].c, Q[i].d);
}
ans = min(ans, cur);
}
cout << ans;
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int x[10], y[10];
set<int> s;
int main() {
for (int i = 0; i < 6; i++) {
cin >> x[i];
y[x[i]]++;
s.insert(x[i]);
}
for (int i = 1; i <= 9; i++) {
if (y[i] == 4) {
if (s.size() == 3) {
cout << "Bear" << endl;
return 0;
} else if (s.size() == 2) {
cout << "Elephant" << endl;
return 0;
}
} else if (y[i] == 5) {
{
cout << "Bear" << endl;
return 0;
}
} else if (y[i] == 6) {
cout << "Elephant" << endl;
return 0;
}
}
cout << "Alien" << endl;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
template <typename Comp>
struct segment_tree {
int n, neutral;
Comp cmp;
vector<int> nodes;
segment_tree(int n, int neutral)
: n(n), neutral(neutral), cmp(Comp()), nodes(2 * n, neutral) {}
int merge(int x, int y) { return cmp(x, y) ? x : y; }
void update(int p, int v) {
p += n;
nodes[p] = merge(nodes[p], v);
while (p /= 2) nodes[p] = merge(nodes[2 * p], nodes[2 * p + 1]);
}
int query(int l, int r) {
int ans = neutral;
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l & 1) ans = merge(ans, nodes[l++]);
if (r & 1) ans = merge(ans, nodes[--r]);
}
return ans;
}
};
struct int_mapper {
vector<int> values;
int_mapper(vector<int> _values) : values(_values) {
sort(values.begin(), values.end());
values.erase(unique(values.begin(), values.end()), values.end());
}
int operator[](int val) const {
auto it = lower_bound(values.begin(), values.end(), val);
return distance(values.begin(), it);
}
size_t size() const { return values.size(); }
};
int main() {
int n;
scanf("%d", &n);
vector<int> a(n);
for (int &x : a) scanf("%d", &x);
int m;
scanf("%d", &m);
vector<int> l(m), ans(m, oo);
vector<vector<int>> queries(n);
for (int i = 0; i < m; --l[i++]) {
int r;
scanf("%d%d", &l[i], &r);
queries[--r].push_back(i);
}
for (int it : {0, 1}) {
int_mapper mapper(a);
segment_tree<less<int>> tree(a.size(), oo);
segment_tree<greater<int>> positions(mapper.size(), -oo);
for (int i = 0; i < n; ++i) {
int j = positions.query(mapper[a[i]], mapper.size());
while (j >= 0) {
tree.update(j, a[j] - a[i]);
if (a[j] == a[i]) break;
j = positions.query(mapper[a[i]], mapper[(a[i] + a[j] + 1) / 2]);
}
positions.update(mapper[a[i]], i);
for (int q : queries[i]) ans[q] = min(ans[q], tree.query(l[q], i + 1));
}
for (int &x : a) x = 1000000000 - x;
int mn = *min_element(a.begin(), a.end());
for (int &x : a) x -= mn;
}
for (int x : ans) printf("%d\n", x);
return 0;
}
| 23
|
#include <bits/stdc++.h>
using namespace std;
char s[1000010];
char a[1000010], b[1000010];
int v[200] = {0};
int main() {
int n;
cin >> n >> s;
for (int i = 0; i < n; i++) v[s[i]]++;
int l = 1, r = n;
for (int i = 1; i < 128; i++)
if (v[i] & 1) a[l++] = i, v[i]--;
for (int i = 1; i < 128; i++)
if (v[i]) {
while (v[i]--) a[r--] = i;
}
l--;
int ans, len;
for (ans = 1; ans <= n; ans++) {
if (n % ans) continue;
len = n / ans;
if ((n - l) / 2 >= ans * (len / 2)) break;
}
cout << ans << endl;
l = 1, r = n;
for (int i = 1; i <= ans; i++) {
int ll = len / 2, rr = len / 2 + 1;
if (len & 1) b[rr++] = a[l++];
for (int j = 1; j <= len / 2; j++) {
b[ll--] = a[r--];
b[rr++] = a[r--];
}
for (int j = 1; j <= len; j++) cout << b[j];
cout << " ";
}
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
long long ma, mi, ans, s[500001], a[500001];
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
long long ma = -1e9, mi = 1e9;
for (int i = 2; i <= n; i++) {
s[i] = s[i - 1] + abs(a[i] - a[i - 1]) * (i & 1 ? -1 : 1);
ma = max(ma, s[i]);
mi = min(mi, s[i]);
}
ans = ma - min(0LL, mi);
printf("%I64d", ans);
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
int main() {
scanf("%d%d", &n, &m);
printf("%d\n", min((n + m) / 3, min(n, m)));
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long int sum = 0;
int size, a;
cin >> size;
int mid = (size - 1) / 2;
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
cin >> a;
if (i == j || i + j == size - 1 || i == mid || j == mid) {
sum += a;
}
}
}
cout << sum << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int t[6], cnt[111];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int sum = 0, maxV = 0, minV = INT_MAX;
for (int i = 1; i <= 5; ++i) {
cin >> t[i];
sum += t[i];
cnt[t[i]]++;
}
int res = sum;
for (int i = 1; i <= 5; ++i)
if (cnt[t[i]] >= 3)
res = min(res, sum - t[i] * 3);
else if (cnt[t[i]] >= 2)
res = min(res, sum - t[i] * 2);
cout << res << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
bool rv[19];
bool sw[19];
struct node {
int64_t s, e, v, level;
};
node tree[(1 << 19) * 2];
void tree_init(int64_t at, int64_t s, int64_t e, int64_t level) {
if (0)
for (int64_t i = level; i < 19; i++) printf(" ");
if (0) printf("#%ld: [%ld, %ld] (%ld)\n", at, s, e, level);
tree[at].s = s;
tree[at].e = e;
tree[at].v = 0;
tree[at].level = level;
if (s != e) {
int64_t m = (s + e) / 2;
tree_init(at * 2 + 1, s, m, level - 1);
tree_init(at * 2 + 2, m + 1, e, level - 1);
}
}
int64_t re_index(int64_t index) {
for (int64_t i = 19 - 1; i >= 0; i--) {
if (rv[i]) {
int64_t step = (1 << i);
int64_t at = index / step;
int64_t nx = at + 1;
index = at * step + (nx * step - 1 - index);
}
if (sw[i]) {
int64_t step = (1 << i);
int64_t at = index / step;
if (at % 2 == 0) {
index += step;
} else {
index -= step;
}
}
}
return index;
}
void tree_set(int64_t index, int64_t v) {
index = re_index(index);
if (0) printf("set a[%ld] = %ld\n", index, v);
int64_t at = (1 << 19) - 1 + index;
tree[at].v = v;
while (at != 0) {
int64_t parent = (at - 1) / 2;
tree[parent].v = tree[parent * 2 + 1].v + tree[parent * 2 + 2].v;
at = parent;
}
}
int64_t tree_sum(int64_t at, int64_t start, int64_t end, bool reversed) {
int64_t bounds = (1 << tree[at].level) - 1;
if (start > end || end < 0 || start > bounds) return 0;
start = max(start, (int64_t)0L);
end = min(end, bounds);
reversed = reversed ^ rv[tree[at].level];
bool swapped = tree[at].level != 0 && sw[tree[at].level - 1];
if (0) {
for (int64_t i = tree[at].level; i < 19; i++) printf(" ");
printf("at %ld [%ld, %ld], %d %d = %ld\n", at, start, end, reversed,
swapped, tree[at].v);
}
if (start == 0 && end == bounds) return tree[at].v;
if (tree[at].level == 0) return tree[at].v;
int64_t hw = (1 << tree[at].level) / 2;
if (reversed) {
int64_t a = start;
int64_t b = end;
start = bounds - b;
end = bounds - a;
return tree_sum(at, start, end, rv[tree[at].level]);
} else if (swapped) {
return (tree_sum(at * 2 + 1, start - hw, end - hw, reversed) +
tree_sum(at * 2 + 2, start, end, reversed));
} else {
return (tree_sum(at * 2 + 1, start, end, reversed) +
tree_sum(at * 2 + 2, start - hw, end - hw, reversed));
}
}
int64_t n, q, a, t, x, y;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> q;
tree_init(0, 0, (1 << 19) - 1, 19);
for (int64_t i = 0; i < (1 << n); i++) {
cin >> a;
tree_set(i, a);
}
while (q--) {
cin >> t;
if (t == 1) {
cin >> x >> y;
x -= 1;
tree_set(x, y);
}
if (t == 2) {
cin >> x;
rv[x] = !rv[x];
}
if (t == 3) {
cin >> x;
sw[x] = !sw[x];
}
if (t == 4) {
cin >> x >> y;
x -= 1;
y -= 1;
cout << tree_sum(0, x, y, false) << endl;
}
if (0) {
for (int64_t i = 0; i < (1 << n); i++) {
cout << tree[(1 << 19) - 1 + re_index(i)].v << ' ';
}
cout << endl;
}
}
}
| 16
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.