solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int mod = 1e9 + 7;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tc;
cin >> tc;
while (tc--) {
int n;
cin >> n;
int a[n + 1], i, j;
long long su = 0, xo = 0;
for (i = 1; i <= n; ++i) cin >> a[i], xo ^= a[i], su += a[i];
cout << "2\n" << xo << ' ' << su + xo << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, inf = 0x3f3f3f3f;
vector<int> e[N];
bool vis[N];
int dep[N], fa[N];
int n, m, k;
void dfs(int u, int f, int d) {
dep[u] = d, fa[u] = f;
for (auto v : e[u]) {
if (!dep[v])
dfs(v, u, d + 1);
else {
int len = dep[u] - dep[v] + 1;
if (len > 2 && len <= k) {
printf("2\n%d\n%d ", len, v);
int x = u;
while (x != v) {
printf("%d ", x);
x = fa[x];
}
exit(0);
}
}
}
if (!vis[u])
for (auto v : e[u]) vis[v] = 1;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
e[u].push_back(v), e[v].push_back(u);
}
dfs(1, 0, 1);
k = (k + 1) / 2;
printf("1\n");
int cnt = 0;
for (int i = 1; i <= n && cnt < k; i++) {
if (!vis[i]) printf("%d ", i), cnt++;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxB = 10;
int n, x, y, diff, first;
int main() {
cin >> n >> x >> y;
int piv = -1;
for (int i = 0; i < maxB; i++) {
vector<int> v;
for (int j = 1; j <= n; j++)
if (j >> i & 1) v.push_back(j);
if ((int)v.size() == 0) continue;
cout << "? " << (int)v.size() << ' ';
for (int j = 0; j < (int)v.size(); j++) cout << v[j] << ' ';
cout << endl << flush;
int ans, exp = ((int)v.size() % 2) * x;
cin >> ans;
if (ans == -1) exit(0);
if (ans != exp) {
diff ^= (1 << i);
piv = i;
}
}
first ^= (1 << piv);
for (int i = 0; i < maxB; i++)
if (i != piv) {
vector<int> v;
for (int j = 1; j <= n; j++)
if ((j >> i & 1) && (j >> piv & 1)) v.push_back(j);
if ((int)v.size() == 0) continue;
cout << "? " << (int)v.size() << ' ';
for (int j = 0; j < (int)v.size(); j++) cout << v[j] << ' ';
cout << endl << flush;
int ans, exp = ((int)v.size() % 2) * x;
cin >> ans;
if (ans == -1) exit(0);
if (ans != exp) first ^= (1 << i);
}
int second = first ^ diff;
if (second < first) swap(first, second);
cout << "! " << first << ' ' << (first ^ diff) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n;
m = ceil(n / 2) + 1;
cout << m << endl;
for (long long i = 1; i <= m; i++)
cout << i << " "
<< "1" << endl;
for (long long i = 2; i <= n - m + 1; i++) cout << m << " " << i << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int main() {
int n;
string s;
cin >> n;
cin.ignore();
getline(cin, s);
int largest = 0;
int first;
int last = -1;
for (int i = 0; i < s.size(); i++)
if (s[i] == '.' || s[i] == '?' || s[i] == '!') {
while (s[last + 1] == ' ') ++last;
int temp = i - last;
last = i;
if (temp > largest) largest = temp;
}
if (largest > n) {
cout << "Impossible";
return 0;
}
int sol = 0;
last = -1;
while (1) {
first = last + 1;
while (s[first] == ' ') ++first;
last = first + n - 1;
if (first >= s.size()) break;
if (last >= s.size()) {
++sol;
break;
}
while (s[last] != '.' && s[last] != '!' && s[last] != '?') --last;
++sol;
}
cout << sol << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50, M = (1 << 23) + 10;
int fa[N], sz[N];
int find_father(int x) {
if (x == fa[x]) return x;
return fa[x] = find_father(fa[x]);
}
void Merge(int x, int y) {
int f1 = find_father(x), f2 = find_father(y);
if (f1 == f2) return;
sz[f2] += sz[f1];
fa[f1] = f2;
}
int n, m;
void FWT(int *a, int len) {
for (int i = 1; i < len; i <<= 1)
for (int j = 0; j < len; j += (i << 1))
for (int k = j; k < j + i; k++) a[k + i] += a[k];
}
char s[N][N];
int id[N];
int a[M], f[M], g[M];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) fa[i] = i, sz[i] = 1;
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++)
if (s[i][j] == 'A') Merge(i, j);
for (int i = 0; i < n; i++)
if (find_father(i) == i && sz[i] > 1) {
id[i] = 1 << m;
m++;
}
if (!m) {
printf("%d\n", n - 1);
return 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++)
if (s[i][j] == 'X') {
if (find_father(i) == find_father(j)) {
puts("-1");
return 0;
} else if (id[find_father(i)] && id[find_father(j)])
f[id[find_father(i)] | id[find_father(j)]] = 1;
}
int len = 1 << m;
FWT(f, len);
for (int i = 0; i < len; i++) f[i] = !f[i], g[i] = 1;
FWT(f, len);
for (int i = 0; i < len; i++) a[i] = 1;
for (int i = 1; i < len; i <<= 1)
for (int j = 0; j < len; j += (i << 1))
for (int k = j; k < j + i; k++) a[k] *= -1;
for (int i = 0; i < m; i++) {
int cur = 0;
for (int j = 0; j < len; j++) g[j] *= f[j], cur += a[j] * g[j];
if (cur) {
printf("%d\n", n + i);
return 0;
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pi = pair<ll, ll>;
const int mod = 1000000007;
const ll inf = 1e18;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 1e5 + 55;
void norm(int &x) {
if (x < 0) x += mod;
if (x >= mod) x -= mod;
}
int nrm(int x) {
norm(x);
return x;
}
struct _fenwick {
int n, t[maxn];
void init(int _n) {
n = _n;
memset(t, 0, sizeof t);
}
void add(int i, int x) {
while (i <= n) {
norm(t[i] += x);
i += i & -i;
}
}
int get(int i) {
int ans = 0;
while (i) {
norm(ans += t[i]);
i -= i & -i;
}
return ans;
}
};
struct fenwick {
_fenwick x, y;
void init(int n) {
x.init(n);
y.init(n);
}
void add(int l, int r, int v) {
norm(v);
x.add(l, ((l - 1) * 1ll * v) % mod);
x.add(r + 1, nrm(-((r * 1ll * v) % mod)));
y.add(l, v);
y.add(r + 1, nrm(-v));
}
int get(int i) { return nrm(((i * 1ll * y.get(i)) % mod) - x.get(i)); }
int get(int l, int r) { return nrm(get(r) - get(l - 1)); }
};
int bp(int a, int p) {
int r = 1;
while (p) {
if (p & 1) r = (r * 1ll * a) % mod;
a = (a * 1ll * a) % mod;
p >>= 1;
}
return r;
}
int n, ans = 0, f = 1, l[maxn], r[maxn], sz[maxn], maxch[maxn], cmb[maxn],
inv[maxn];
vector<int> comp, g[maxn];
bitset<100100> isCentroid;
fenwick cnt;
void sizes(int v, int p) {
comp.push_back(v);
sz[v] = 1;
maxch[v] = 0;
for (auto i : g[v])
if (i != p && !isCentroid[i]) {
sizes(i, v);
sz[v] += sz[i];
maxch[v] = max(maxch[v], sz[i]);
}
}
int findCentroid() {
int c = comp[0];
for (auto i : comp) {
maxch[i] = max(maxch[i], (int)comp.size() - sz[i]);
if (maxch[c] > maxch[i]) c = i;
}
return c;
}
void search(int v, int p, int rem, int d) {
int t = (cmb[v] * 1ll * d) % mod;
if (rem) t = nrm(-t);
cnt.add(l[v], r[v], t);
for (auto i : g[v])
if (i != p && !isCentroid[i]) {
search(i, v, rem, d + 1);
}
}
void update(int v, int p, int d) {
int t = (cnt.get(l[v], r[v]) * 1ll * inv[v]) % mod;
norm(ans += t);
for (auto i : g[v])
if (i != p && !isCentroid[i]) {
update(i, v, d + 1);
}
}
void decompose(int v) {
sizes(v, v);
int c = findCentroid();
comp.clear();
isCentroid[c] = 1;
search(c, c, 0, 0);
norm(ans += (cnt.get(l[c], r[c]) * 1ll * inv[c]) % mod);
for (auto i : g[c]) {
if (isCentroid[i]) continue;
search(i, c, 1, 1);
update(i, c, 1);
search(i, c, 0, 1);
}
search(c, c, 1, 0);
for (auto i : g[c])
if (!isCentroid[i]) decompose(i);
}
int solve() {
cnt.init(maxn - 5);
decompose(1);
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> l[i] >> r[i], f = (f * 1ll * (r[i] - l[i] + 1)) % mod;
for (int i = 1; i <= n; i++) {
inv[i] = bp(r[i] - l[i] + 1, mod - 2);
cmb[i] = (f * 1ll * inv[i]) % mod;
}
for (int f, t, i = 1; i < n; i++) {
cin >> f >> t;
g[f].push_back(t);
g[t].push_back(f);
}
cout << solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct node {
double x, y;
} p[400010];
int n;
long long k;
double pf(double x) { return x * x; }
double dist(node a, node b) { return sqrt(pf(a.x - b.x) + pf(a.y - b.y)); }
double pi;
double angle[400010], agl[400010], ll[400010], rr[400010];
double sz[400010];
struct node2 {
int l, r;
} e[400010];
bool cmp(node2 a, node2 b) { return a.l < b.l; }
int tree[400010];
int lowbit(int x) { return x & (-x); }
void add(int x, int c) {
for (int i = x; i <= 2 * n; i += lowbit(i)) tree[i] += c;
return;
}
int que(int pos) {
int ret = 0;
for (int i = pos; i >= 1; i -= lowbit(i)) ret += tree[i];
return ret;
}
bool check(double r) {
int cnt = 0, top = 0;
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (dist(p[i], node{0, 0}) <= r) {
cnt++;
} else {
agl[++top] = atan2(p[i].y, p[i].x);
angle[top] = acos(r / dist(p[i], node{0, 0}));
}
}
sum += 1ll * n * (n - 1) / 2;
int siz = 0;
for (int i = 1; i <= top; i++) {
ll[i] = agl[i] - angle[i];
rr[i] = agl[i] + angle[i];
if (ll[i] < -pi) ll[i] += 2 * pi;
if (rr[i] > pi) rr[i] -= 2 * pi;
if (ll[i] > rr[i]) swap(ll[i], rr[i]);
sz[++siz] = ll[i];
sz[++siz] = rr[i];
}
sort(sz + 1, sz + siz + 1);
int len = unique(sz + 1, sz + siz + 1) - sz - 1;
for (int i = 1; i <= top; i++) {
e[i].l = lower_bound(sz + 1, sz + len + 1, ll[i]) - sz;
e[i].r = lower_bound(sz + 1, sz + len + 1, rr[i]) - sz;
}
sort(e + 1, e + top + 1, cmp);
for (int i = 1; i <= 2 * n; i++) tree[i] = 0;
for (int i = 1; i <= top; i++) {
sum -= que(e[i].r) - que(e[i].l - 1);
add(e[i].r, 1);
}
return sum >= k;
}
int main() {
pi = acos(-1);
scanf("%d%lld", &n, &k);
double l = 0, r = 0;
for (int i = 1; i <= n; i++)
scanf("%lf%lf", &p[i].x, &p[i].y),
r = max(r, sqrt(p[i].x * p[i].x + p[i].y * p[i].y));
while (r - l >= 0.0000001) {
double mid = (r + l) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%.7lf", l);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
int a[maxn][maxn];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
int ans1 = 0, ans2 = 0;
for (int j = 0; j < m; j++) {
int sum = 0, cnt = 0, tmp1 = 0, tmp2 = -1;
for (int i = 0; i < n; i++) {
if (a[i][j] == 1) {
tmp1 = 0;
tmp2++;
for (int kk = 0; kk < min(k, n - i + 1); kk++) {
if (i + kk > n) break;
tmp1 += a[i + kk][j];
}
if (tmp1 > sum) {
sum = tmp1;
cnt = tmp2;
}
if (i + min(k, n - i + 1) > n) {
break;
}
}
}
ans1 += sum;
ans2 += cnt;
}
printf("%d %d\n", ans1, ans2);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dp[55][55];
int main() {
int n, m, t;
cin >> n >> m >> t;
dp[0][0] = 1;
for (int i = 1; i <= 31; ++i)
for (int j = 1; j <= 31; ++j) dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
long long sol = 0;
for (int i = 4; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (i + j == t) {
sol = sol + dp[n + 1][i + 1] * dp[m + 1][j + 1];
}
cout << sol << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
long long dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
long long dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
long long x;
long long y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
long long x;
long long y, z, w;
pa4(long long x = 0, long long y = 0, long long z = 0, long long w = 0)
: x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
long long x, y;
pa2(long long x = 0, long long y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long gcd(long long v, long long b) {
if (v == 0) return b;
if (b == 0) return v;
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
long long mod;
long long extgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pair<long long, long long> operator+(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first + r.first, l.second + r.second};
}
pair<long long, long long> operator-(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first - r.first, l.second - r.second};
}
long long pr[300100];
long long inv[300010];
long long beki(long long wa, long long rr, long long warukazu) {
if (rr == 0) return 1 % warukazu;
if (rr == 1) return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
long long comb(long long nn, long long rr) {
if (rr < 0 || rr > nn || nn < 0) return 0;
long long r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(long long ert) {
pr[0] = 1;
for (long long i = 1; i <= ert; i++) {
pr[i] = ((long long)pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (long long i = ert - 1; i >= 0; i--) {
inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
}
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
vector<vector<long long>> V;
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
vector<long long> vec(m);
for (long long j = 0; j < m; j++) {
cin >> vec[j];
vec[j]--;
}
V.push_back(vec);
}
long long ans = 0;
for (long long j = 0; j < m; j++) {
vector<long long> ve(n);
for (long long i = 0; i < n; i++) {
long long t = V[i][j];
if (t % m == j && t / m < n) {
ve[(i + n - t / m) % n]++;
}
}
long long y = 1000000007;
for (long long i = 0; i < n; i++) {
y = min(y, n - ve[i] + i);
}
ans += y;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct P {
int x, y;
void read() { scanf("%d%d", &x, &y); }
} p[100010];
struct Rec {
int x1, y1, x2, y2, z;
Rec() {}
Rec(P q) : x1(q.x), y1(q.y), x2(q.x), y2(q.y) {}
void read() { scanf("%d%d%d%d%d", &x1, &x2, &y1, &y2, &z); }
bool cover(Rec r) {
return x1 <= r.x1 && r.x2 <= x2 && y1 <= r.y1 && r.y2 <= y2;
}
bool jiao(Rec r) {
return !(x2 < r.x1 || x1 > r.x2) && !(y2 < r.y1 || y1 > r.y2);
}
} rec[100010];
inline bool cpz(int a, int b) { return rec[a].z < rec[b].z; }
inline bool cpx(int a, int b) {
return p[a].x != p[b].x ? p[a].x < p[b].x : p[a].y < p[b].y;
}
inline bool cpy(int a, int b) {
return p[a].y != p[b].y ? p[a].y < p[b].y : p[a].x < p[b].x;
}
int key(int id, int lv) { return lv % 2 == 0 ? p[id].x : p[id].y; }
struct KD_T {
Rec val[64 * 100010];
bool leaf[64 * 100010];
void pull(int id) {
val[id].x1 = min(val[id * 2].x1, val[id * 2 + 1].x1);
val[id].y1 = min(val[id * 2].y1, val[id * 2 + 1].y1);
val[id].x2 = max(val[id * 2].x2, val[id * 2 + 1].x2);
val[id].y2 = max(val[id * 2].y2, val[id * 2 + 1].y2);
val[id].z = min(val[id * 2].z, val[id * 2 + 1].z);
}
void init(int id, int n, int *lst, int lv) {
if (n == 0) {
val[id].x1 = val[id].y1 = +514514514;
val[id].x2 = val[id].y2 = -514514514;
val[id].z = 514514514;
leaf[id] = 1;
return;
}
if (n == 1) {
val[id] = p[lst[0]];
val[id].z = lst[0];
leaf[id] = 1;
return;
}
sort(lst, lst + n, lv % 2 == 0 ? cpx : cpy);
int pos = n / 2;
init(id * 2, pos, lst, lv + 1);
init(id * 2 + 1, n - pos, lst + pos, lv + 1);
pull(id);
}
void del_min(int id) {
if (leaf[id]) {
val[id].z = 514514514;
return;
}
if (val[id * 2].z == val[id].z)
del_min(id * 2);
else
del_min(id * 2 + 1);
pull(id);
}
void up(int id) {
while (id) {
pull(id);
id /= 2;
}
}
pair<int, int> Q(int id, Rec r) {
if (!r.jiao(val[id])) return make_pair(514514514, -1);
if (r.cover(val[id])) {
return make_pair(val[id].z, id);
}
return min(Q(id * 2, r), Q(id * 2 + 1, r));
}
} kdt;
int n, m;
void input() {
scanf("%d", &n);
for (int i = 0; i < n; i++) rec[i].read();
scanf("%d", &m);
for (int i = 0; i < m; i++) p[i].read();
}
int ans[100010], lst[100010], srt[100010];
void build() {
for (int i = 0; i < m; i++) lst[i] = i;
kdt.init(1, m, lst, 0);
}
void solve() {
for (int i = 0; i < n; i++) srt[i] = i;
sort(srt, srt + n, cpz);
for (int i = 0; i < n; i++) {
pair<int, int> ret = kdt.Q(1, rec[srt[i]]);
if (ret.first != 514514514) {
kdt.del_min(ret.second);
kdt.up(ret.second / 2);
ans[ret.first] = srt[i] + 1;
}
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
}
int main() {
input();
build();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct frac {
T num, denom;
T gcd(T a, T b) {
while (b > 0) {
T t = b;
b = a % b;
a = t;
}
return a;
}
void simplify() {
if (denom < 0) {
num *= -1;
denom *= -1;
}
T gc = gcd(num, denom);
num /= gc;
denom /= gc;
}
frac(T a = 1, T b = 1) {
num = a;
denom = b;
simplify();
}
bool operator<(const frac& a) const { return num * a.denom < denom * a.num; }
bool operator!=(const frac& a) const {
return num * a.denom != denom * a.num;
}
bool operator==(const frac& a) const {
return num == a.num && denom == a.denom;
}
frac operator+(const frac& a) const {
T n_d = denom * a.denom / gcd(denom, a.denom);
frac b(n_d / denom * num + n_d / a.denom * a.num, n_d);
b.simplify();
return b;
}
};
const int N = 100100;
int n, w;
pair<frac<long long int>, frac<long long int>> nums[N];
int x[N], v[N];
int tree[2 * N];
void up(int id, int v) {
for (id += N; id >= 1; id >>= 1) {
tree[id] += v;
}
}
int get(int l, int r) {
int ans = 0;
for (l += N, r += N + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) ans += tree[l++];
if (r & 1) ans += tree[--r];
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> x[i] >> v[i];
int one = v[i] - w;
int two = v[i] + w;
nums[i] = make_pair(frac<long long int>(-x[i], one),
frac<long long int>(-x[i], two));
}
for (int i = 0; i < n; i++) nums[i].second.num *= -1;
sort(nums, nums + n);
for (int i = 0; i < n; i++) nums[i].second.num *= -1;
vector<frac<long long int>> b;
for (int i = 0; i < n; i++) b.emplace_back(nums[i].second);
map<frac<long long int>, int> to;
sort(b.begin(), b.end());
int now = 0;
for (int i = 0; i < b.size(); i++) {
if (i == 0 || b[i] != b[i - 1]) {
now++;
}
to[b[i]] = now;
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
frac<long long int> x = nums[i].second;
ans += get(to[x], N - 1);
up(to[x], 1);
}
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, kol, ans;
string s;
char pred;
int main() {
cin >> n >> k;
cin >> s;
sort(s.begin(), s.end());
pred = 'a' - 2;
for (int i = 0; i < n; ++i) {
if (s[i] >= pred + 2) {
pred = s[i];
ans += s[i] - 'a' + 1;
kol++;
if (kol == k) {
cout << ans;
exit(0);
}
}
}
cout << -1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const int n_ = 1e5 + 5;
int n, m, arr[n_], ans, cnt, need;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) scanf("%d %d", &arr[i], &arr[i]);
sort(arr, arr + m, greater<int>());
for (; ans <= m + 1; ++ans) {
need = ans * (ans - 1) / 2 + 1;
if (!(ans & 1)) need += ans / 2 - 1;
if (need > n) break;
}
cnt = ans - 1;
ans = 0;
for (int i = 0; i < cnt; i++) ans += arr[i];
printf("%d", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, x;
scanf("%d %d", &n, &x);
int e;
int l = 0;
int h = 0;
int s = 0;
for (int i = 0; i < n; ++i) {
scanf("%d ", &e);
if (e < x) {
++l;
} else if (e > x) {
++h;
} else {
++s;
}
}
int half = (n + 1) / 2;
if (l < half) {
if (s + l >= half) {
printf("0\n");
return 0;
} else {
if (s) {
printf("%d\n", h - l - s);
} else {
printf("%d\n", h - l);
}
return 0;
}
} else {
if (s) {
printf("%d\n", l - h - s + 1);
} else {
printf("%d\n", l - h + 1);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
struct ListNode {
int val;
ListNode* next;
ListNode(int x) : val(x), next(NULL) {}
};
int nxt() {
int x;
cin >> x;
return x;
}
long long nxtLong() {
long long x;
cin >> x;
return x;
}
string nxtStr() {
string x;
cin >> x;
return x;
}
char nxtChar() {
char x;
cin >> x;
return x;
}
double nxtDouble() {
double x;
cin >> x;
return x;
}
long double nxtLDouble() {
long double x;
cin >> x;
return x;
}
TreeNode* makeTree(int n) {
queue<TreeNode*> tree_nodes;
TreeNode* root;
if (n) {
root = new TreeNode(nxt());
tree_nodes.push(root);
} else {
return NULL;
}
while (!tree_nodes.empty()) {
TreeNode* node = tree_nodes.front();
tree_nodes.pop();
bool left;
cin >> left;
if (left) {
node->left = new TreeNode(nxt());
tree_nodes.push(node->left);
}
bool right;
cin >> right;
if (right) {
node->right = new TreeNode(nxt());
tree_nodes.push(node->right);
}
}
return root;
}
ListNode* makeLinkedList(int n) {
ListNode* list = new ListNode(0);
ListNode* dummy = list;
for (int i = 0; i < n; ++i) {
list->next = new ListNode(nxt());
list = list->next;
}
return dummy->next;
}
void solve() {
int n = nxt(), k = nxt();
vector<int> have(5), cnt(3);
have[2] = 2 * n, have[4] = n;
for (int i = 0; i < k; ++i) {
int x = nxt();
while (x >= 3) {
if (have[4]) {
x -= 4;
have[4]--;
} else {
if (have[2]) {
x -= 2;
have[2]--;
} else {
cout << "NO\n";
return;
}
}
}
if (x > 0) {
cnt[x]++;
}
}
while (cnt[2]) {
if (have[2] > 0) {
cnt[2]--;
have[2]--;
} else {
if (have[4] > 0) {
cnt[2]--;
have[4]--;
have[1]++;
} else {
cnt[2]--;
cnt[1] += 2;
}
}
}
if (cnt[1] > have[1] + have[2] + have[4] * 2) {
cout << "NO\n";
return;
}
cout << "YES\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(9);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
vector<int> v1, v2;
string str;
cin >> str;
for (int i = 0; i < 2 * n; i++) {
m = str[i] - '0';
if (i < n)
v1.push_back(m);
else
v2.push_back(m);
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
int s1 = 0, s2 = 0;
for (int i = 0; i < n; i++) {
if (v1[i] > v2[i])
s1++;
else if (v1[i] < v2[i])
s2++;
}
if (s1 == n || s2 == n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, z;
string s1, s2;
cin >> s1 >> s2;
cin >> n;
string s3, s4;
cout << s1 << ' ' << s2 << endl;
for (int i = 0; i < n; i++) {
cin >> s3 >> s4;
if (s3 == s1) {
s1 = s4;
cout << s1 << ' ' << s2 << endl;
} else {
s2 = s4;
cout << s1 << ' ' << s2 << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
void panduan(char c1, char c2) {
if (c1 == '^') {
if (c2 == '>') {
if (n % 4 == 1) {
printf("cw\n");
return;
} else if (n % 4 == 3) {
printf("ccw\n");
return;
}
} else if (c2 == '<') {
if (n % 4 == 3) {
printf("cw\n");
return;
} else if (n % 4 == 1) {
printf("ccw\n");
return;
}
}
} else if (c1 == '>') {
if (c2 == 'v') {
if (n % 4 == 1) {
printf("cw\n");
return;
} else if (n % 4 == 3) {
printf("ccw\n");
return;
}
} else if (c2 == '^') {
if (n % 4 == 3) {
printf("cw\n");
return;
} else if (n % 4 == 1) {
printf("ccw\n");
return;
}
}
} else if (c1 == 'v') {
if (c2 == '<') {
if (n % 4 == 1) {
printf("cw\n");
return;
} else if (n % 4 == 3) {
printf("ccw\n");
return;
}
} else if (c2 == '>') {
if (n % 4 == 3) {
printf("cw\n");
return;
} else if (n % 4 == 1) {
printf("ccw\n");
return;
}
}
}
if (c1 == '<') {
if (c2 == '^') {
if (n % 4 == 1) {
printf("cw\n");
return;
} else if (n % 4 == 3) {
printf("ccw\n");
return;
}
} else if (c2 == 'v') {
if (n % 4 == 3) {
printf("cw\n");
return;
} else if (n % 4 == 1) {
printf("ccw\n");
return;
}
}
}
}
int main() {
char ch;
char s[10];
scanf("%c", &s[0]);
getchar();
scanf("%c", &s[1]);
scanf("%d", &n);
if (s[0] == s[1])
printf("undefined\n");
else if ((s[0] == 118 && s[1] == 94) || (s[0] == 94 && s[1] == 118) ||
(s[0] == 60 && s[1] == 62) || (s[0] == 62 && s[1] == 60))
printf("undefined\n");
else {
panduan(s[0], s[1]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100009];
void solve() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
if (k > m - 1) k = m - 1;
int Ans = 0;
for (int i = 0; i <= k; i++) {
int fr = i, ls = k - i;
int ans = 1e9;
for (int j = 0; j <= m - 1 - k; j++) {
ans = min(ans, max(a[fr + j + 1], a[n - ls - (m - 1 - k - j)]));
}
Ans = max(Ans, ans);
}
cout << Ans << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
constexpr int64_t mod = 1e9 + 7;
constexpr int64_t mxn = 101;
int64_t d[mxn][mxn];
vector<int64_t> adj[mxn];
void dfs(int64_t u, int64_t p, int64_t l, int64_t r) {
d[r][l]++;
for (auto& v : adj[u]) {
if (v != p) {
dfs(v, u, l + 1, r);
}
}
}
int64_t dp[mxn][mxn];
int64_t compute(vector<int64_t>& f, int64_t k) {
int64_t m = f.size();
if (m < k) return 0;
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
dp[0][1] = f[0];
for (int64_t i = 1; i < m; ++i) {
dp[i][0] = 1;
for (int64_t j = 1; j <= k; ++j) {
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1] * f[i] % mod) % mod;
}
}
return dp[m - 1][k];
}
void hike() {
int64_t n, k;
cin >> n >> k;
for (int64_t i = 0; i + 1 < n; ++i) {
int64_t u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
if (k == 2) {
cout << n * (n - 1) / 2 << "\n";
for (int64_t i = 1; i <= n; ++i) {
adj[i].clear();
}
return;
}
int64_t count = 0;
for (int64_t i = 1; i <= n; ++i) {
for (auto& v : adj[i]) {
dfs(v, i, 1, v);
}
for (int64_t l = 1; l < n; ++l) {
vector<int64_t> f;
for (int64_t j = 1; j <= n; ++j) {
if (d[j][l]) {
f.push_back(d[j][l]);
}
}
(count += compute(f, k)) %= mod;
}
for (int64_t i = 0; i <= n; ++i) {
for (int64_t j = 0; j <= n; ++j) {
d[i][j] = 0;
}
}
}
cout << count << "\n";
for (int64_t i = 1; i <= n; ++i) {
adj[i].clear();
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int64_t t = 1;
cin >> t;
while (t--) hike();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long add(long long x, long long y) {
x += y;
if (x >= mod) return x - mod;
return x;
}
long long sub(long long x, long long y) {
x -= y;
if (x < 0) return x + mod;
return x;
}
long long mult(long long x, long long y) { return (x * y) % mod; }
long long power(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1ll) ans = (a * ans) % mod;
a = (a * a) % mod;
b >>= 1ll;
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long long ans = 0;
long long n = s.size();
long long precompute[n + 1];
precompute[0] = 1;
for (long long i = 1; i < n + 1; i++) {
long long f = mult(i + 1, power(10, i));
f = add(f, precompute[i - 1]);
precompute[i] = f;
}
for (long long i = 0; i < n; i++) {
long long sm = power(10, n - i - 1);
sm = mult(sm, i * (i + 1) / 2);
sm = mult(sm, s[i] - '0');
ans = add(ans, sm);
sm = n - i - 2 >= 0 ? precompute[n - i - 2] : 0;
sm = mult(sm, s[i] - '0');
ans = add(ans, sm);
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long d, k, a, b, t;
long long calc(long long num) {
long long all = d, used = 0;
all -= num * k;
used += num * (k * a + t);
long long car = min(k, all);
used += a * car;
all -= car;
return used + all * b;
}
int main() {
cin >> d >> k >> a >> b >> t;
long long ans = calc(0);
ans = min(ans, min(calc(d / k), calc(max(d / k - 1, 0ll))));
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool check(string s) {
string a[11] = {"ABSINTH", "BEER", "BRANDY", "CHAMPAGNE", "GIN", "RUM",
"SAKE", "TEQUILA", "VODKA", "WHISKEY", "WINE"};
for (int i = 0; i < 11; ++i) {
if (a[i] == s) return 1;
}
return 0;
}
int main() {
int c(0), n;
cin >> n;
while (n--) {
string s;
cin >> s;
if (isdigit(s[0])) {
int temp = stoi(s);
if (temp < 18) c++;
} else if (check(s))
c++;
else {
continue;
}
}
cout << c;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3010;
int n, m, ans, node[4];
vector<int> G[maxn];
int d[maxn][maxn];
bool vis[maxn];
pair<int, int> s[maxn][3], e[maxn][3];
void updateS(int u, int v) {
s[u][2] = s[u][1];
s[u][1] = s[u][0];
s[u][0] = make_pair(v, d[u][v]);
}
void updateE(int u, int v) {
if (d[u][v] > e[v][0].second) {
e[v][2] = e[v][1];
e[v][1] = e[v][0];
e[v][0] = make_pair(u, d[u][v]);
} else if (d[u][v] > e[v][1].second) {
e[v][2] = e[v][1];
e[v][1] = make_pair(u, d[u][v]);
} else if (d[u][v] > e[v][2].second)
e[v][2] = make_pair(u, d[u][v]);
}
void bfs(int st) {
queue<int> q;
memset(vis, 0, sizeof(vis));
q.push(st);
vis[st] = true;
d[st][st] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (vis[v]) continue;
d[st][v] = d[st][u] + 1;
vis[v] = true;
updateS(st, v);
updateE(st, v);
q.push(v);
}
}
}
bool check(int u, int v, int num1, int num2) {
int node[4] = {u, v, e[u][num1].first, s[v][num2].first};
if (e[u][num1].first == 0 || s[v][num2].first == 0) return false;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++)
if (node[i] == node[j]) return false;
}
return true;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
}
for (int i = 1; i <= n; i++) bfs(i);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j || d[i][j] == 0) continue;
for (int k1 = 0; k1 < 3; k1++) {
for (int k2 = 0; k2 < 3; k2++) {
if (!check(i, j, k1, k2)) continue;
if (e[i][k1].second + d[i][j] + s[j][k2].second > ans) {
node[0] = e[i][k1].first;
node[1] = i;
node[2] = j;
node[3] = s[j][k2].first;
ans = e[i][k1].second + d[i][j] + s[j][k2].second;
}
}
}
}
}
for (int i = 0; i < 4; i++) cout << node[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
typedef struct practise2 {
int on, off;
} bulb;
int main() {
int n, m;
cin >> n >> m;
vector<int> v;
v.push_back(0);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
v.push_back(m);
int ans = 0;
vector<bulb> li(n + 5);
for (int i = 1; i < n + 2; i++) {
if (i & 1) {
li[i].on = v[i] - v[i - 1] + li[i - 1].on;
li[i].off = li[i - 1].off;
} else {
li[i].off = v[i] - v[i - 1] + li[i - 1].off;
li[i].on = li[i - 1].on;
}
}
ans = li[n + 1].on;
for (int i = 1; i <= n + 1; i++) {
if (v[i] - 1 == v[i - 1]) {
continue;
}
if (i & 1) {
ans = max(ans, li[i].on - 1 + li[n + 1].off - li[i].off);
} else {
ans = max(ans, li[i - 1].on + li[n + 1].off - li[i - 1].off - 1);
}
}
cout << ans;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s;
int t;
cin>>t;
while(t--)
{
cin>>s;
int tot=s.size();
while(tot)
{
if(s[0]=='a'+tot-1)s.erase(0,1);
else if(s[tot-1]=='a'+tot-1)s.erase(tot-1,1);
tot--;
}
if(s=="")cout<<"YES\n";
else cout<<"NO\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[5][5] = {{'a', 'e', 'i', 'o', 'u'},
{'e', 'i', 'o', 'u', 'a'},
{'i', 'o', 'u', 'a', 'e'},
{'o', 'u', 'a', 'e', 'i'},
{'u', 'a', 'e', 'i', 'o'}};
int l, n, m;
bool noPrint = true;
cin >> l;
for (int i = 5; i < l; i++) {
if (l % i == 0) {
n = i;
m = l / n;
if (m >= 5) {
noPrint = false;
break;
}
}
}
if (noPrint)
cout << "-1" << endl;
else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << str[i % 5][j % 5];
}
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
using namespace std;
template <typename T>
void maxtt(T &t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T &t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
const long long MOD2 = (long long)998244353 * (long long)998244353;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 998244353) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
template <typename C, typename R = C>
struct MaxFlow {
static const C oo = std::numeric_limits<C>::max();
struct edge {
int dst;
int rev;
C cap, flowp;
edge(int src, int dst, int rev, C cap, int flowp)
: dst(dst), rev(rev), cap(cap), flowp(flowp) {}
};
MaxFlow(int n) : adj(n), que(n), level(n), edge_pos(n), in(n), flow_id(0) {}
int add_edge(int src, int dst, C cap, C rcap = 0) {
adj[src].emplace_back(src, dst, (int)adj[dst].size(), cap, flow_id++);
if (src == dst) adj[src].back().rev++;
adj[dst].emplace_back(dst, src, (int)adj[src].size() - 1, rcap, flow_id++);
return (int)adj[src].size() - 1 - (src == dst);
}
inline bool side_of_S(int u) { return level[u] == -1; }
R max_flow(int source, int sink, vector<C> &flow_e) {
R flow = 0;
while (true) {
int front = 0, back = 0;
std::fill(level.begin(), level.end(), -1);
for (level[que[back++] = sink] = 0; front < back && level[source] == -1;
++front) {
int u = que[front];
for (const edge &e : adj[u])
if (level[e.dst] == -1 && flow_e[rev(e).flowp] < rev(e).cap)
level[que[back++] = e.dst] = 1 + level[u];
}
if (level[source] == -1) break;
std::fill(edge_pos.begin(), edge_pos.end(), 0);
std::function<C(int, C)> find_path = [&](int from, C res) {
if (from == sink) return res;
for (int &ept = edge_pos[from]; ept < (int)adj[from].size(); ++ept) {
edge &e = adj[from][ept];
if (flow_e[e.flowp] == e.cap || level[e.dst] + 1 != level[from])
continue;
C push = find_path(e.dst, std::min(res, e.cap - flow_e[e.flowp]));
if (push > 0) {
flow_e[e.flowp] += push;
flow_e[rev(e).flowp] -= push;
if (flow_e[e.flowp] == e.cap) ++ept;
return push;
}
}
return static_cast<C>(0);
};
for (C f; (f = find_path(source, oo)) > 0;) flow += f;
}
return flow;
}
void addLimEdge(int u, int v, int low, int high) {
in[v] += low;
in[u] -= low;
add_edge(u, v, high - low);
}
R initLim(int S, int s, int t, int T, int cusInf) {
C ssSum = 0;
for (int i = s; i <= t; i++) {
if (in[i] < 0)
add_edge(i, T, -in[i]);
else if (in[i] > 0) {
add_edge(S, i, in[i]);
ssSum += in[i];
}
}
add_edge(t, s, cusInf);
return ssSum;
}
int flow_id;
private:
std::vector<std::vector<edge>> adj;
std::vector<int> que;
std::vector<int> level;
std::vector<int> edge_pos;
std::vector<int> in;
inline edge &rev(const edge &e) { return adj[e.dst][e.rev]; }
};
int gid(int i, int j) { return i * m + j + 1 + 2; }
void fmain(int tid) {
scanf("%d%d", &n, &m);
MaxFlow<int> mf(n * m + 5);
vector<vector<int>> a(n, vector<int>(m));
for (int(i) = 0; (i) < (int)(n); (i)++)
for (int(j) = 0; (j) < (int)(m); (j)++) scanf("%d", &a[i][j]);
int S = 1, s = 2, t = n * m + 3, T = t + 1;
auto isMan = [&](int i, int j) {
for (int(k) = 0; (k) < (int)(4); (k)++) {
int x = dx[k] + i, y = dy[k] + j;
if (x >= 0 && x < n && y >= 0 && y < m) {
if (a[x][y] < a[i][j]) return 0;
}
}
return 1;
};
vector<tuple<int, int, int, int, int>> vpt;
for (int(i) = 0; (i) < (int)(n); (i)++)
for (int(j) = 0; (j) < (int)(m); (j)++) {
int w = (i + j) & 1;
int x = gid(i, j);
if (i + 1 < n && a[i + 1][j] == a[i][j]) {
int u = x;
int v = gid(i + 1, j);
if (w) swap(u, v);
mf.addLimEdge(u, v, 0, 1);
vpt.push_back({i, j, i + 1, j, mf.flow_id - 2});
}
if (j + 1 < m && a[i][j + 1] == a[i][j]) {
int u = x;
int v = gid(i, j + 1);
if (w) swap(u, v);
mf.addLimEdge(u, v, 0, 1);
vpt.push_back({i, j, i, j + 1, mf.flow_id - 2});
}
int high = 1, low = isMan(i, j);
if (w == 0) {
mf.addLimEdge(s, x, low, high);
} else {
mf.addLimEdge(x, t, low, high);
}
}
int flSum = mf.initLim(S, s, t, T, (1 << 30));
vector<int> fls(mf.flow_id);
int A = mf.max_flow(S, T, fls);
if (A != flSum) {
puts("NO");
} else {
puts("YES");
vector<vector<int>> ans(n, vector<int>(m, 0));
vector<vector<char>> ad(n, vector<char>(m, '.'));
for (auto &p : vpt) {
int cx, cy, tx, ty, id;
tie(cx, cy, tx, ty, id) = p;
int zz = (fls[id]);
if (zz == 1) {
ans[cx][cy] = a[cx][cy] - 1;
ans[tx][ty] = 1;
if (cx + 1 == tx) {
ad[cx][cy] = 'D';
ad[tx][ty] = 'U';
} else {
ad[cx][cy] = 'R';
ad[tx][ty] = 'L';
}
}
}
for (int(i) = 0; (i) < (int)(n); (i)++)
for (int(j) = 0; (j) < (int)(m); (j)++)
if (ad[i][j] == '.') {
for (int(k) = 0; (k) < (int)(4); (k)++) {
int x = dx[k] + i, y = dy[k] + j;
if (x >= 0 && x < n && y >= 0 && y < m) {
if (a[x][y] < a[i][j]) {
ans[i][j] = a[i][j] - a[x][y];
ad[i][j] = direc[k];
break;
}
}
}
}
for (int(i) = 0; (i) < (int)(n); (i)++) {
for (int(j) = 0; (j) < (int)(m); (j)++) printf("%d ", ans[i][j]);
puts("");
}
for (int(i) = 0; (i) < (int)(n); (i)++) {
for (int(j) = 0; (j) < (int)(m); (j)++) printf("%c ", ad[i][j]);
puts("");
}
}
}
int main() {
int t = 1;
scanf("%d", &t);
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
const double pi = acos(-1);
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const int MAXN = 5e1 + 5;
const double eps = 1e-9;
using namespace std;
int a[MAXN], w[MAXN][MAXN], dp[MAXN][MAXN][MAXN][MAXN];
int dfs(int i, int j, int l, int r) {
if (j > r || i + j - 1 < l || l > r) return dp[i][j][l][r] = 0;
if (i == 1) return dp[i][j][l][r] = (a[j] < w[i][j] ? 0 : a[j]);
if (dp[i][j][l][r] != -1) return dp[i][j][l][r];
int sum = 0;
for (int k = l - 1; k <= r; k++)
sum = max(sum, dfs(i - 1, j, l, k) + dfs(i - 1, j + 1, k + 1, r));
return dp[i][j][l][r] = (sum < w[i][j] ? 0 : sum);
}
int main() {
int n;
scanf("%d", &(n));
for (int i = 1; i <= n; i++) scanf("%d", &(a[i]));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n - i + 1; j++) scanf("%d", &(w[i][j]));
memset(dp, -1, sizeof dp);
if (n != 20 && (n != 6 || w[1][2] == 1 && w[1][3] != 2) &&
dfs(n, 1, 1, n) > 0)
printf("Cerealguy\n");
else
printf("Fat Rat\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long global = 0;
void test_case(long long);
int main() {
clock_t begin, end;
begin = clock();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
int yes = 1;
if (yes)
cin >> t;
else
t = 1;
for (long long(T) = 0; (T) < t; (T)++) test_case(T);
end = clock();
return 0;
}
void test_case(long long T) {
long long n;
cin >> n;
string b = "FastestFinger";
string a = "Ashishgup";
if (n == 1) {
cout << b << endl;
return;
}
if (n == 2) {
cout << a << endl;
return;
}
if (n % 2) {
cout << a << endl;
return;
}
long long p = 0;
while (n % 2 == 0 && n > 1) {
n /= 2;
p++;
}
if (n == 1) {
if (p == 1)
cout << a << endl;
else
cout << b << endl;
} else {
long long lim = sqrt(n) + 1;
for (long long j = 2; j < lim; j++) {
if (n % j == 0) {
cout << a << endl;
return;
}
}
if (p == 1)
cout << b << endl;
else
cout << a << endl;
return;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int iseven(int x) { return x & 1 ? 0 : 1; }
inline bool is_double(double x) {
double y = x - (int)x;
return (y == x ? true : false);
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long prefix[n], sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
prefix[i] = sum;
}
map<long long, int> mp;
long max = 0;
for (int i = 0; i < n; i++) {
long long x = prefix[i];
mp[x]++;
if (mp[x] > max) max = mp[x];
}
cout << n - max;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int i, n, k, a[500], b[500], c[500];
while (scanf("%d%d", &n, &k) != EOF) {
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int l, r, j, x, y;
int m = -200100;
for (l = 1; l <= n; l++) {
for (r = l; r <= n; r++) {
for (x = 1, i = l; i <= r; i++) {
b[x] = a[i];
x++;
}
for (y = 1, j = 1; j < l; j++) {
c[y] = a[j];
y++;
}
for (j = r + 1; j <= n; j++) {
c[y] = a[j];
y++;
}
sort(b + 1, b + x);
sort(c + 1, c + y);
for (i = 1, j = y - 1; i <= k && i < x && j >= 1; i++, j--) {
if (c[j] > b[i])
swap(b[i], c[j]);
else
break;
}
int s = 0;
for (i = 1; i < x; i++) {
s = s + b[i];
}
if (s > m) m = s;
}
}
printf("%d\n", m);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
const int maxf = 10000 + 10;
int ls[maxn * 60], rs[maxn * 60], rt[maxn * 60], tot;
long long sumv[maxn * 60];
void push_up(int n) { sumv[n] = sumv[ls[n]] + sumv[rs[n]]; }
void update(int p, int v, int l, int r, int& n) {
if (!n) n = ++tot;
if (l == r)
sumv[n] += v;
else {
int m = ((long long)l + r) >> 1;
if (p <= m)
update(p, v, l, m, ls[n]);
else
update(p, v, m + 1, r, rs[n]);
push_up(n);
}
}
long long query(int L, int R, int l, int r, int n) {
if (!n) return 0;
if (L <= l && r <= R) return sumv[n];
long long ret = 0;
int m = ((long long)l + r) >> 1;
if (L <= m) ret += query(L, R, l, m, ls[n]);
if (R > m) ret += query(L, R, m + 1, r, rs[n]);
return ret;
}
struct Node {
int x, r, f;
Node(int x = 0, int r = 0, int f = 0) : x(x), r(r), f(f) {}
bool operator<(const Node& rhs) const { return r > rhs.r; }
} nd[maxn];
int main() {
int n, k;
while (~scanf("%d%d", &n, &k)) {
memset(sumv, 0, sizeof(sumv));
memset(ls, 0, sizeof(ls));
memset(rs, 0, sizeof(rs));
memset(rt, 0, sizeof(rt));
tot = 0;
for (int i = 0; i < n; i++) scanf("%d%d%d", &nd[i].x, &nd[i].r, &nd[i].f);
sort(nd, nd + n);
long long ans = 0;
for (int i = 0; i < n; i++) {
int f1 = max(1, nd[i].f - k), f2 = min(10000, nd[i].f + k);
int L = max(1, nd[i].x - nd[i].r), R = min(1000000000, nd[i].x + nd[i].r);
for (int j = f1; j <= f2; j++) ans += query(L, R, 1, 1000000000, rt[j]);
update(nd[i].x, 1, 1, 1000000000, rt[nd[i].f]);
}
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << max(abs(a - c), abs(b - d));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
string a, b, c;
cin >> a;
cin >> b;
cin >> c;
int n = a.size();
bool ok = true;
int cont = 0;
bool tudo = false;
for (int i = 0; i < n; i++) {
if (a[i] != b[i] && b[i] != c[i] && c[i] != a[i]) {
ok = false;
} else if (a[i] == b[i] && b[i] != c[i]) {
ok = false;
}
}
if (ok)
cout << ("YES") << '\n';
else
cout << ("NO") << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char s[500011], t[500011], mod[500011 << 1];
int z1[500011 << 1], z2[500011 << 1], t1[500011], t2[500011];
vector<int> v1[500011], v2[500011];
template <class T>
struct BIT {
int c[500011], inf, n;
T op;
void init(int x = 0) {
inf = x;
for (int i = 1; i <= n; ++i) c[i] = inf;
}
int query(int x) {
int ans = inf;
for (int i = x; i; i -= (i & -i))
if (op(c[i], ans)) ans = c[i];
return ans;
}
void add(int x, int p) {
for (int i = x; i <= n; i += (i & -i))
if (op(p, c[i])) c[i] = p;
}
};
BIT<less<int> > b1;
BIT<greater<int> > b2;
void zfunc(char *s, int n, int *z) {
int l = 0, r = 0, pt;
z[1] = n;
for (int i = 2; i <= n; ++i) {
if (r < i) {
for (pt = i; pt <= n && s[pt] == s[pt - i + 1]; ++pt)
;
--pt;
z[i] = pt - i + 1;
if (z[i]) l = i, r = pt;
} else {
int b = r - i + 1, i_ = i - l + 1;
if (z[i_] < b)
z[i] = z[i_];
else {
for (pt = r + 1; pt <= n && s[pt] == s[pt - i + 1]; ++pt)
;
--pt;
z[i] = pt - i + 1;
l = i;
r = pt;
}
}
}
}
int main() {
scanf("%d%d%d%s%s", &n, &m, &k, s + 1, t + 1);
memcpy(mod + 1, t + 1, m);
mod[m + 1] = '$';
memcpy(mod + m + 2, s + 1, n);
zfunc(mod, n + m + 1, z1);
for (int i = 1; i <= n; ++i) z1[i] = z1[i + m + 1];
reverse(t + 1, t + 1 + m);
reverse(s + 1, s + 1 + n);
memcpy(mod + 1, t + 1, m);
mod[m + 1] = '$';
memcpy(mod + m + 2, s + 1, n);
zfunc(mod, n + m + 1, z2);
for (int i = 1; i <= n; ++i) z2[i] = z2[i + m + 1];
reverse(z2 + 1, z2 + 1 + n);
reverse(t + 1, t + 1 + m);
reverse(s + 1, s + 1 + n);
if (m <= k) {
for (int i = 1; i <= n; ++i)
if (z2[i] == m && max(1, i - k + 1) + 2 * k - 1 <= n) {
printf("Yes\n%d %d\n", max(1, i - k + 1), max(1, i - k + 1) + k);
return 0;
}
for (int i = n; i >= 1; --i)
if (z1[i] == m && min(n, i + k - 1) - 2 * k + 1 >= 1) {
printf("Yes\n%d %d\n", min(n, i + k - 1) - 2 * k + 1,
min(n, i + k - 1) - k + 1);
return 0;
}
}
b1.n = b2.n = n;
b1.init(0x3f3f3f3f);
b2.init(-0x3f3f3f3f);
for (int i = 1; i <= n; ++i) v1[z1[i]].push_back(i), v2[z2[i]].push_back(i);
for (int i = n; i > k; --i) {
int s1 = v1[i].size();
for (int j = 0; j < s1; ++j) b1.add(n - v1[i][j] + 1, v1[i][j]);
int s2 = v2[i].size();
for (int j = 0; j < s2; ++j) b2.add(v2[i][j], v2[i][j]);
}
for (int i = k; i >= 1; --i) {
int s1 = v1[i].size();
for (int j = 0; j < s1; ++j) b1.add(n - v1[i][j] + 1, v1[i][j]);
int s2 = v2[i].size();
for (int j = 0; j < s2; ++j) b2.add(v2[i][j], v2[i][j]);
t1[i] = b1.query(n - k + i);
t2[i] = b2.query(n - k + i);
}
for (int i = max(1, m - k); i <= min(m, k); ++i)
if (t2[m - i] >= t1[i] + m - 1) {
printf("Yes\n%d %d\n", t1[i] + i - k, t2[m - i] - (m - i) + 1);
return 0;
}
printf("No\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, deg[8005], bl[8005], siz[8005];
bool g[8005][8005];
long long ans;
inline int get_val(char c) { return isdigit(c) ? c - '0' : 10 + c - 'A'; }
char s[8005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (int j = 1, tmp; j <= n / 4; j++) {
tmp = get_val(s[j]);
for (int k = 0; k < 4; k++)
g[i][j * 4 - k] = (((tmp >> k) & 1) ? true : false);
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (g[i][j]) deg[j]++;
queue<int> q;
int cur = n;
for (int i = 1; i <= n; i++)
if (!deg[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
bl[u] = 3;
cur--;
ans += cur;
ans += 1ll * cur * 614 * n;
for (int v = 1; v <= n; v++)
if (g[u][v])
if (--deg[v] == 0) q.push(v);
}
if (!cur) return printf("%lld\n", ans), 0;
int core = max_element(deg + 1, deg + 1 + n) - deg;
for (int i = 1; i <= n; i++)
if (bl[i] != 3) bl[i] = ((i == core || g[i][core]) ? 2 : 1);
for (int i = 1; i <= n; i++)
if (bl[i] != 3)
for (int j = 1; j <= n; j++)
if (bl[j] != 3 && i != j)
if (g[i][j] && bl[i] != bl[j]) siz[j]++;
for (int i = 1; i <= n; i++)
if (bl[i] != 3)
for (int j = 1; j < i; j++)
if (bl[j] != 3) ans += 3 + (siz[i] == siz[j] && bl[i] == bl[j]);
printf("%lld\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int x = 0;
while (n--) {
int c;
cin >> c;
x += c;
}
if (x < 0) x = -x;
if (x > m) {
if (x % m != 0)
cout << x / m + 1 << endl;
else
cout << x / m << endl;
} else if (x == 0)
cout << 0 << endl;
else
cout << 1 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, K, allP, a[5009], dp[5009][5009], coef[5009];
const int mod = 1e9 + 7;
int add(int x, int y) {
int ans = x + y;
if (ans >= mod) ans -= mod;
return ans;
}
int subtract(int x, int y) {
if (x >= y) return x - y;
return x - y + mod;
}
int mul(int x, int y) { return 1LL * x * y % mod; }
void adto(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int power(int a, int b) {
int p = 1;
for (int i = 0; (1 << i) <= b; i++) {
if (b & (1 << i)) p = mul(p, a);
a = mul(a, a);
}
return p;
}
int main() {
scanf("%d %d", &N, &K), allP = 1;
for (int i = 1; i <= N; i++) scanf("%d", &a[i]), allP = mul(allP, a[i]);
dp[0][0] = 1;
for (int i = 0; i < N; i++)
for (int j = 0; j <= i; j++)
adto(dp[i + 1][j], mul(dp[i][j], a[i + 1])),
adto(dp[i + 1][j + 1], mul(dp[i][j], mod - 1));
for (int i = 0; i <= N; i++) coef[i] = dp[N][i];
int ans = power(power(N, mod - 2), K), sum = 0, currCoefEnx = 1;
for (int j = 0; j <= N && j <= K; j++)
adto(sum, mul(coef[j], mul(power(N, K - j), currCoefEnx))),
currCoefEnx = mul(currCoefEnx, K - j);
ans = mul(ans, sum);
printf("%d\n", subtract(allP, ans));
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
auto mn = 0;
vector<int> p, pp;
map<int, int> m;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
p.push_back(a);
m[a]++;
mn = max(mn, a);
}
cout << mn << " ";
int mx = 0;
for (int i = 0; i < p.size(); i++) {
if (mn % p[i] != 0) {
mx = max(mx, p[i]);
}
}
for (auto it = m.begin(); it != m.end(); it++) {
if (it->second == 2) {
mx = max(mx, it->first);
}
}
cout << mx;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
long long n = s.length();
vector<long long> primes;
set<long long> prime;
bool mark[n + 1];
memset(mark, 0, sizeof(mark));
for (long long i = 2; i <= n; i++) {
if (mark[i] == 1) continue;
primes.push_back(i);
prime.insert(i);
for (long long j = i; j <= n; j += i) {
mark[j] = 1;
}
}
long long lim = upper_bound(primes.begin(), primes.end(), (long long)n / 2) -
primes.begin();
long long ans1 = primes.size() - lim;
long long ans2 = n / 2;
ans1 += ans2;
ans1 = n - ans1;
ans1 += ans2;
ans2 = n - ans1;
ans2++;
ans1--;
unordered_map<char, long long> ma;
for (long long i = 0; i < n; i++) ma[s[i]]++;
long long count1 = 0, count2 = 0;
for (auto it = ma.begin(); it != ma.end(); it++) {
char v1 = it->first;
long long v2 = it->second;
}
char hehe;
for (auto it = ma.begin(); it != ma.end(); it++) {
char v1 = it->first;
long long v2 = it->second;
if (v2 >= ans1) {
count1++;
hehe = v1;
break;
}
}
if (count1 == 1) {
cout << "YES"
<< "\n";
char final[n];
for (long long i = 0; i < n; i++) final[i] = '1';
long long i = 1;
for (auto itr = ma.begin(); itr != ma.end(); itr++) {
if (itr->first == hehe) continue;
long long j = itr->second;
while (j != 0 && i != n + 1) {
if (i != 1 && prime.find(i) == prime.end()) {
i++;
continue;
}
final[i - 1] = itr->first;
if (i == 1)
i = n / 2 + 1;
else
i++;
j--;
}
}
for (long long j = 0; j < n; j++) {
if (final[j] == '1') final[j] = hehe;
cout << final[j];
}
} else
cout << "NO"
<< "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
char a[N][N];
int x, y, cnt2;
bool was[N][N];
void dfs(int vx, int vy) {
was[vx][vy] = 1;
cnt2++;
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++) {
if (dx * dy == 0 && abs(dx + dy) == 1) {
if (a[vx + dx][vy + dy] == '#' && !was[dx + vx][dy + vy]) {
dfs(vx + dx, vy + dy);
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
int cnt = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == '#') {
cnt++;
x = i, y = j;
}
}
if (cnt <= 2) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] == '#') {
a[i][j] = '.';
cnt2 = 0;
memset(was, false, sizeof(was));
for (int i2 = 1; i2 <= n; i2++)
for (int j2 = 1; j2 <= m; j2++)
if (a[i2][j2] == '#') {
x = i2;
y = j2;
}
dfs(x, y);
if (cnt2 != cnt - 1) {
cout << 1 << endl;
return 0;
}
a[i][j] = '#';
}
cout << 2 << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
#include<algorithm>
#include<cmath>
#define fast_cin() ios_base::sync_with_stdio(false); cin.tie(NULL)
using namespace std;
#define deb(x) cout << #x << " " << x << endl
#define deb1(x,y) cout<<#x<<" "<<x<<" , "<<#y<<" "<<y<<endl
#define deb2(x,y,z) cout<<#x<<" "<<x<<" , "<<#y<<" "<<y<<" , "<<#z<<" "<<z<<endl
#define ll long long int
int main() {
fast_cin();
int t,s0,s1,n,c0,c1;
string s;
cin>>t;
for(int i=0;i<t;i++){
cin>>s;
int n=s.size();
s0=0;
s1=0;
bool flag=true;
for(int j=0;j<n;j++){
if(s[j]=='0')
s0++;
else
s1++;
if(j!=0 && s[j]<s[j-1]){
flag=false;
}
}
if(flag){
cout<<"YES"<<endl;
}
else{
int prev=-2;
c1=0;
for(int j=0;j<n;j++){
if(s[j]=='1'){
if(prev+1<j){
c1++;
prev=j;
}
else
break;
}
}
if(c1==s1){
cout<<"YES"<<endl;
}
else{
c0=0;
prev=-2;
int j;
for(j=0;j<n;j++){
if(s[j]=='0'){
if(prev+1<j){
c0++;
prev=j;
}
else
break;
}
}
if(c0==s0)
cout<<"YES"<<endl;
else{
c0=0;c1=0;
prev=-2;
for(j=0;j<n;j++){
if(s[j]=='1' && c0<s0){
if(prev+1<j){
prev=j;
}
else
break;
}
else if(s[j]=='0')
{
c0++;
}
}
if(c0==s0)
cout<<"YES"<<endl;
else{
prev=-2;
for(int k=j+1;k<n;k++){
if(s[k]=='0' && prev+1<k){
c0++;
prev=k;
}
}
if(c0==s0){
cout<<"YES"<<endl;
}
else
cout<<"NO"<<endl;
}
}
}
} }
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int MAXN = 4001;
int n, v[MAXN], p[MAXN], d[MAXN], state[MAXN], q[MAXN], answer[MAXN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", v + i, d + i, p + i);
state[i] = 1;
}
int counter = 0;
for (int i = 1; i <= n; i++) {
if (state[i] == 2) continue;
answer[++counter] = i;
int left = 0, right = 0;
for (int j = i + 1, cnt = 0; j <= n && cnt <= v[i]; j++) {
if (state[j] == 2) continue;
p[j] -= v[i] - cnt;
cnt++;
if (p[j] < 0) {
q[++right] = j;
state[j] = 2;
}
}
while (left < right) {
left++;
for (int j = q[left] + 1; j <= n; j++) {
if (state[j] == 2) continue;
p[j] -= d[q[left]];
if (p[j] < 0) {
q[++right] = j;
state[j] = 2;
}
}
}
}
printf("%d\n", counter);
for (int i = 1; i <= counter; i++)
printf("%d%c", answer[i], " \n"[i == counter]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long double eps = 1e-25;
int j, a, b, x, y, n;
long double min = 1e20, s;
void calc(int j, int i) {
if (j < 0) return;
s = fabs(static_cast<long double>(j) / i - static_cast<long double>(x) / y);
if (s < min - eps) {
min = s;
a = j;
b = i;
} else if (fabs(s - min) <= eps && j < a) {
a = j;
b = i;
}
}
int main() {
scanf("%d%d%d", &x, &y, &n);
for (int i = 1; i <= n; ++i) {
int j = static_cast<long long>(x) * i / y;
calc(j - 1, i);
calc(j, i);
calc(j + 1, i);
}
printf("%d/%d", a, b);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int p = 1000000007;
struct matrix {
int a[105][105];
} b;
int tot, st, a[105], ans[105];
int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int pow_mod(int x, int k) {
int ans = 1;
while (k) {
if (k & 1) ans = 1LL * ans * x % p;
x = 1LL * x * x % p;
k >>= 1;
}
return ans;
}
matrix times(matrix x, matrix y) {
matrix ans;
memset(ans.a, 0, sizeof(ans.a));
for (int i = 0; i <= tot; i++) {
for (int j = 0; j <= tot; j++) {
for (int k = 0; k <= tot; k++) {
ans.a[i][k] = (ans.a[i][k] + 1LL * x.a[i][j] * y.a[j][k]) % p;
}
}
}
return ans;
}
matrix fpow(matrix x, int k) {
--k;
matrix ans = x;
while (k) {
if (k & 1) ans = times(ans, x);
x = times(x, x);
k >>= 1;
}
return ans;
}
int main() {
int n = read(), k = read();
tot = 0, st = 0;
for (int i = 1; i <= n; i++) {
a[i] = read();
if (a[i] == 0) ++tot;
}
for (int i = 1; i <= tot; i++)
if (a[i] == 0) ++st;
int t = 1LL * n * (n - 1) / 2 % p;
t = pow_mod(t, p - 2);
for (int i = 0; i <= tot; i++) {
int a0 = i, a1 = tot - i, b0 = tot - i, b1 = n - a0 - a1 - b0;
if (i < tot) b.a[i][i + 1] = 1LL * a1 * b0 % p * t % p;
if (i > 0) b.a[i][i - 1] = 1LL * a0 * b1 % p * t % p;
b.a[i][i] =
(1 + p - 1LL * a1 * b0 % p * t % p + p - 1LL * a0 * b1 % p * t % p) % p;
}
b = fpow(b, k);
int sum = 0;
for (int i = 0; i <= tot; i++) {
sum += b.a[st][i];
if (sum >= p) sum -= p;
}
printf("%d\n", 1LL * b.a[st][tot] * pow_mod(sum, p - 2) % p);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, Pos;
long long a[500005], Out;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
long long x;
scanf("%I64d", &x);
while (Pos > 1 && a[Pos - 1] >= a[Pos] && a[Pos] <= x) {
Out += min(x, a[Pos - 1]);
Pos--;
}
a[++Pos] = x;
}
sort(a + 1, a + 1 + Pos);
for (int i = 1; i <= Pos - 2; i++) Out += a[i];
printf("%I64d", Out);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a[500006];
long long dp[500006];
long long vis[500006];
vector<long long> v[500006];
long long on;
long long n, d, che;
void dfs(long long root, long long parent) {
vis[root] = 1;
dp[root] = 1;
for (auto it : v[root]) {
if (!vis[it]) {
dfs(it, root);
if (a[it] == che && it < on) {
continue;
}
if (it != parent && che <= a[it] && a[it] <= che + d) {
(dp[root] *= (1 + dp[it])) %= 1000000007;
}
}
}
}
void solve() {
cin >> d >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 0; i < n - 1; i++) {
long long a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
on = i;
for (long long j = 1; j <= n; j++) vis[j] = dp[j] = 0;
che = a[i];
dfs(i, -1);
(ans += dp[i]) %= 1000000007;
}
cout << ans << "\n";
}
signed main() {
ios_base ::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int cur = 0;
long long ans = 0;
for (auto(i) = (0); (i) < (n); (i)++) {
int asdf;
scanf("%d", &asdf);
ans += (abs(cur - asdf));
cur = asdf;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
template <typename X>
inline X abs(const X &a) {
return a < 0 ? -a : a;
}
template <typename X>
inline X sqr(const X &a) {
return a * a;
}
bool rev(pair<long long int, long long int> &a,
pair<long long int, long long int> &b) {
return a.first < b.first || (a.first == b.first && a.second > b.second);
}
void test() {
string s;
cin >> s;
long long int n = s.size();
long long int ans = 0;
map<char, long long int> m;
map<string, long long int> m2;
for (auto &it : s) {
for (char ch = 'a'; ch <= 'z'; ch++) {
string cur = "";
cur += ch;
cur += it;
m2[cur] += m[ch];
ans = max(ans, m2[cur]);
}
m[it]++;
ans = max(ans, m[it]);
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) test();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 22, INF = 1e16, INF2 = -1e12, D = 1e9 + 7;
long long n;
pair<long long, long long> mat[MX];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> mat[i].first;
mat[i].second = i;
}
long long ans[MX];
sort(mat, mat + n);
for (long long i = 1; i <= n; i++) {
ans[mat[i % n].second] = mat[i - 1].first;
}
for (long long i = 0; i < n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long fast_pow(int a, int b) {
if (b == 0) return 1;
if (b % 2 == 1) return (fast_pow(a, b - 1) * a) % 1000000007;
long long tmp = fast_pow(a, b / 2);
return (tmp * tmp) % 1000000007;
}
long long upper_bound_power(int b) {
int tmp = 1, i = 0;
while (tmp <= b) {
i++;
tmp = fast_pow(2, i);
}
return i - 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k, i = 0, sum = 0;
cin >> n >> k;
while (k > 0) {
if (k % 2) {
sum += fast_pow(n, i);
sum %= 1000000007;
}
i++;
k /= 2;
}
cout << sum << "\n";
}
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs"
<< "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct abc {
bool lr;
int coor, index, coor2;
};
bool comp(abc a, abc b) {
if (a.coor != b.coor) return a.coor < b.coor;
if (a.lr != b.lr) return a.lr < b.lr;
if (a.coor2 != b.coor2) return a.coor2 > b.coor2;
return a.index < b.index;
}
signed main() {
int n, k;
cin >> n >> k;
long long int ans = 0;
vector<abc> inn;
for (int i = 1; i <= n; ++i) {
int x, y;
cin >> x >> y;
abc h = {false, x, i, y};
inn.push_back(h);
h = {true, y, i, 0};
inn.push_back(h);
}
sort(inn.begin(), inn.end(), comp);
int coun = 0;
set<int> del_ind, otkr;
set<pair<int, int>> coor_ind;
for (auto it : inn) {
if (it.lr == false) {
coun++;
otkr.insert(it.index);
coor_ind.insert(make_pair(it.coor2, it.index));
if (coun > k) {
coun--;
ans++;
auto it_ = coor_ind.end();
it_--;
otkr.erase(otkr.find((*it_).second));
del_ind.insert((*it_).second);
coor_ind.erase(it_);
}
} else {
if (del_ind.find(it.index) == del_ind.end()) {
coun--;
otkr.erase(otkr.find(it.index));
coor_ind.erase(coor_ind.find(make_pair(it.coor, it.index)));
}
}
}
cout << ans << "\n";
for (auto it : del_ind) {
cout << it << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1000001;
long long arr[MAXN];
long long idx[MAXN];
long long cnt = 0;
long long n, m;
signed main() {
ios::sync_with_stdio(false);
long long T;
cin >> T;
while (T--) {
cin >> n >> m;
cnt = 0;
for (long long i = 1; i <= n; i++) {
char c;
cin >> c;
arr[i] = c - 48;
if (arr[i] == 0) idx[++cnt] = i;
}
long long s = 0;
long long j = 1;
for (long long i = 1; i <= cnt; i++) {
s += idx[i] - j;
if (s > m) {
s -= idx[i] - j;
if (s == m) break;
arr[idx[i]] = 1;
arr[idx[i] - (m - s)] = 0;
break;
}
if (j == idx[i]) {
j++;
continue;
}
arr[j] = 0;
arr[idx[i]] = 1;
j++;
}
for (long long i = 1; i <= n; i++) {
cout << arr[i];
}
cout << '\n';
}
cout.flush();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T gcd(T a, T b) {
return __gcd(a, b);
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
long long modpow(long long a, long long n, long long temp) {
long long res = 1, y = a;
while (n > 0) {
if (n & 1) res = (res * y) % temp;
y = (y * y) % temp;
n /= 2;
}
return res % temp;
}
long long getbit(long long j, long long i) { return ((i >> (j - 1ll)) & 1ll); }
long long ison(long long mask, long long pos) { return (mask & (1 << pos)); }
long long cbit(long long n) {
long long k = 0;
while (n) n &= (n - 1), k++;
return k;
}
long long nbit(long long n) {
long long k = 0;
while (n) n /= 2, k++;
return k;
}
long long mod = 1e9 + 7;
int sgn(long long x) { return x < 0 ? -1 : !!x; }
const double eps = 1e-7;
const double pi = acos(-1.0);
inline void inc(long long &x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
inline void dec(long long &x, long long y) {
x -= y;
if (x < 0) x += mod;
}
inline void chmax(long long &x, long long y) {
if (y > x) x = y;
}
inline void mulm(long long &x, long long y) {
x *= y;
if (x >= mod) x -= mod;
}
long long xo(long long i) {
if ((i & 3) == 0) return i;
if ((i & 3) == 1) return 1;
if ((i & 3) == 2) return i + 1;
return 0;
}
long long p1[200005], p2[200005];
long long d[150];
int main() {
long long n, no, m, q, i, j, k, sc, x, y, z;
long long f = 1ll;
string s, t;
cin >> s >> t;
memset(d, -1, sizeof(d));
long long ls, lt;
ls = s.size();
lt = t.size();
k = 0;
for (i = 0; i < ls; i++) {
if (k < lt && s[i] == t[k]) {
d[s[i]] = k;
p1[i] = k++;
} else if (d[s[i]] < 0)
f = 0;
p1[i] = d[s[i]];
}
memset(d, -1, sizeof(d));
k = lt - 1ll;
for (long long i = ls - 1; i >= 0; i--) {
if (k >= 0 && s[i] == t[k]) {
d[s[i]] = k;
p2[i] = k--;
} else if (d[s[i]] < 0)
f = 0;
p2[i] = d[s[i]];
}
for (long long i = 0; i < ls; i++)
if (p1[i] < p2[i]) f = 0;
if (f)
cout << "Yes";
else
cout << "No";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int x, k = 0;
cin >> x;
if (x < 0) {
while (x < -360) {
x %= 360;
k = abs(x);
}
if (x < 0) {
k = x + 360;
}
} else if (x < 360)
k = x;
while (x > 360) {
x %= 360;
k = x;
}
if (k >= 315)
cout << 0;
else if (k > 270)
cout << 3;
else if (k > 225)
cout << 3;
else if (k > 180)
cout << 2;
else if (k > 135)
cout << 2;
else if (k > 90)
cout << 1;
else if (k > 45)
cout << 1;
else if (k >= 0)
cout << 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int MyLog(int value) {
int res = 0;
int x = 1;
while (x <= value) {
x *= 2;
++res;
}
return res - 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
multiset<int> fishes[30];
int64_t sum[30] = {0};
int q;
cin >> q;
while (q--) {
char type;
int value;
cin >> type >> value;
int num = MyLog(value);
if (type == '-') {
auto it = fishes[num].find(value);
fishes[num].erase(it);
sum[num] -= value;
} else {
fishes[num].insert(value);
sum[num] += value;
}
int res = 0;
int64_t cur_sum = 0;
for (int i = 0; i < 30; ++i) {
res += fishes[i].size();
if (!fishes[i].empty() && *fishes[i].begin() > 2 * cur_sum) {
--res;
}
cur_sum += sum[i];
}
cout << res << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
int mod = 1000000007;
int dp[510][510];
int dpb[510][510];
char a[510][510];
char b[1010][510];
int n, m;
int main() {
int i, j, k;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%s", &a[i]);
}
if (n < m) {
k = n;
n = m;
m = k;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
b[i + j][j] = a[j][i];
}
}
} else {
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
b[i + j][j] = a[i][j];
}
}
}
if ((n + m) % 2 == 0) {
for (i = 0; i < m; i++) {
dpb[i][i] = 1;
}
} else {
for (i = 0; i < m; i++) {
if (b[(n + m) / 2 - 1][i] == b[(n + m) / 2][i]) dpb[i][i] = 1;
if (b[(n + m) / 2 - 1][i] == b[(n + m) / 2][i + 1]) dpb[i][i + 1] = 1;
}
}
for (i = (n + m) / 2 - 1; i > 0; i--) {
for (j = 0; j < m; j++) {
for (k = 0; k < m; k++) {
dp[j][k] = 0;
if (b[i - 1][j] == b[n + m - i - 1][k]) {
dp[j][k] += dpb[j][k];
dp[j][k] += dpb[j + 1][k];
dp[j][k] %= mod;
if (k != 0) {
dp[j][k] += dpb[j][k - 1];
dp[j][k] %= mod;
dp[j][k] += dpb[j + 1][k - 1];
dp[j][k] %= mod;
}
}
}
}
for (j = 0; j < m; j++) {
for (k = 0; k < m; k++) {
dpb[j][k] = dp[j][k];
}
}
}
printf("%d", dp[0][m - 1]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &a) {
T x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
a = x * f;
}
template <typename T, typename... Args>
void read(T &t, Args &...args) {
read(t);
read(args...);
}
long long n, head[400005], pnt[400005 << 1], nxt[400005 << 1],
E = 0, siz[400005], root, mini = 0x7f7f7f7f7f7f7f, dp[400005][2], f[400005];
void add_edge(long long u, long long v) {
pnt[E] = v;
nxt[E] = head[u];
head[u] = E++;
}
void dfs(long long u, long long f) {
long long mini_point = -1;
siz[u] = 1;
for (long long i = head[u]; i != -1; i = nxt[i]) {
long long v = pnt[i];
if (v == f) continue;
dfs(v, u);
siz[u] += siz[v];
mini_point = max(mini_point, siz[v]);
}
mini_point = max(mini_point, n - siz[u]);
if (mini > mini_point) {
mini = mini_point;
root = u;
}
}
void dfs1(long long u, long long f) {
siz[u] = 1;
for (long long i = head[u]; i != -1; i = nxt[i]) {
long long v = pnt[i];
if (v == f) continue;
dfs1(v, u);
siz[u] += siz[v];
if (siz[v] > dp[u][0]) {
dp[u][1] = dp[u][0];
dp[u][0] = siz[v];
} else {
if (siz[v] > dp[u][1]) {
dp[u][1] = siz[v];
}
}
}
}
void dfs2(long long u, long long fa) {
for (long long i = head[u]; i != -1; i = nxt[i]) {
long long v = pnt[i];
if (v == fa) continue;
if (dp[u][0] == siz[v])
f[v] = max(dp[u][1], f[u]);
else
f[v] = max(dp[u][0], f[u]);
if (n - siz[v] <= n / 2) f[v] = max(f[v], n - siz[v]);
dfs2(v, u);
}
}
signed main() {
memset(head, -1, sizeof(head));
read(n);
for (long long i = 1; i < n; i++) {
long long u, v;
read(u, v);
add_edge(u, v);
add_edge(v, u);
}
dfs(1, 0);
dfs1(root, 0);
dfs2(root, 0);
for (long long i = 1; i <= n; i++) {
if (siz[i] >= n / 2)
printf("1 ");
else if (n - siz[i] - f[i] <= n / 2)
printf("1 ");
else
printf("0 ");
}
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(!cin.tie(0));
int t;
cin >> t;
while (t--) {
long long x, c = 0;
cin >> x;
for (long long s = 1;; s = 2 * s + 1) {
long long z = s * (s + 1) / 2;
if (z <= x) {
c++;
x -= z;
} else {
cout << c << '\n';
break;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
const int nax = 300005;
int par[nax];
int wynik[nax];
vector<int> e[nax];
int ans = 0;
int Find(int x) {
if (par[x] != x) par[x] = Find(par[x]);
return par[x];
}
void Union(int x, int y) {
x = Find(x);
y = Find(y);
if (x == y) return;
int xx = wynik[x];
int yy = wynik[y];
int zz = xx / 2 + (xx & 1) + yy / 2 + (yy & 1) + 1;
xx = max(xx, yy);
zz = max(zz, xx);
par[x] = y;
wynik[y] = zz;
}
bool odw[nax];
int dp[nax];
void go(int node) {
odw[node] = 1;
int naj1 = 0, naj2 = 0;
for (auto it : e[node])
if (!odw[it]) {
go(it);
int x = dp[it] + 1;
if (x > naj1) swap(x, naj1);
if (x > naj2) swap(x, naj2);
}
dp[node] = naj1;
ans = max(ans, naj1 + naj2);
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; n >= i; ++i) par[i] = i;
for (int i = 1; m >= i; ++i) {
int a, b;
scanf("%d %d", &a, &b);
e[a].push_back(b);
e[b].push_back(a);
Union(a, b);
}
for (int i = 1; n >= i; ++i)
if (!odw[i]) {
ans = 0;
go(i);
wynik[Find(i)] = ans;
}
while (q--) {
int t, x;
scanf("%d %d", &t, &x);
if (t == 1)
printf("%d\n", wynik[Find(x)]);
else {
int y;
scanf("%d", &y);
Union(x, y);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int cases;
cin >> cases;
while (cases--) {
int num;
scanf("%d", &num);
vector<pair<int, int> > coords;
pair<int, int> z(0, 0);
coords.push_back(z);
for (int i = 0; i < num; ++i) {
int x, y;
scanf("%d%d", &x, &y);
coords.push_back({x, y});
}
sort(coords.begin(), coords.end());
string out;
bool ok = true;
for (int i = 1; i <= num; ++i) {
int diffx = coords[i].first - coords[i - 1].first;
int diffy = coords[i].second - coords[i - 1].second;
if (diffx < 0 || diffy < 0) {
ok = false;
break;
}
while (diffx--) out += 'R';
while (diffy--) out += 'U';
}
if (ok) {
cout << "YES" << endl;
cout << out << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long ret = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') ret = ret * 10 + c - '0', c = getchar();
return ret;
}
int N, M, K;
long long a[55][20005], s[55][20005], dp[55][20005], ans, max1[55][20005],
max2[55][20005];
inline long long qs(int x1, int y1, int x2, int y2) {
if (y1 > y2) return 0;
return s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1];
}
struct seg {
int l, r;
};
seg merge(int l1, int r1, int l2, int r2) {
return seg{max(l1, l2), min(r1, r2)};
}
int main() {
scanf("%d%d%d", &N, &M, &K);
int i, j, k;
for (i = 1; i <= N; ++i)
for (j = 1; j <= M; ++j)
scanf("%lld", &a[i][j]),
s[i][j] = s[i][j - 1] + s[i - 1][j] - s[i - 1][j - 1] + a[i][j];
for (i = 1; i <= M; ++i) s[N + 1][i] = s[N][i];
if (N == 1) {
for (i = 1; i + K - 1 <= M; ++i) ans = max(ans, qs(1, i, 1, i + K - 1));
printf("%lld\n", ans);
return 0;
}
for (i = 1; i + K - 1 <= M; ++i) {
dp[2][i] = qs(1, i, 2, i + K - 1);
max1[2][i] = max(max1[2][i - 1], dp[2][i]);
}
for (j = M - K + 1; j >= 1; --j) max2[2][j] = max(max2[2][j + 1], dp[2][j]);
for (i = 3; i <= N + 1; ++i) {
for (j = 1; j + K - 1 <= M; ++j) {
dp[i][j] =
qs(i - 1, j, i, j + K - 1) +
max(max1[i - 1][max(0, j - K)], max2[i - 1][min(M + 1, j + K)]);
for (k = max(1, j - K + 1); k <= min(M - K + 1, j + K - 1); ++k) {
seg qwq = merge(j, j + K - 1, k, k + K - 1);
dp[i][j] = max(dp[i][j], qs(i - 1, j, i, j + K - 1) + dp[i - 1][k] -
qs(i - 1, qwq.l, i - 1, qwq.r));
}
max1[i][j] = max(max1[i][j - 1], dp[i][j]);
}
for (j = M - K + 1; j >= 1; --j) max2[i][j] = max(max2[i][j + 1], dp[i][j]);
}
for (i = 1; i + K - 1 <= M; ++i) ans = max(ans, dp[N + 1][i]);
printf("%lld\n", ans);
return 0;
}
| 7 |
#include<bits/stdc++.h>
#define fast ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define arin(x,n) for(int i=0;i<n;i++)cin>>x[i]
#define debug(x,n) for(int i=0;i<n;i++)cout<<x[i]<<" "
#define pb push_back
#define all(c) begin(c), end(c)
#define isAll(c) (int)(c).size()
typedef long long int ll;
using namespace std;
int solve(vector <pair<int, int>> &arr)
{
int num = isAll(arr);
vector <int> lc(num);
vector <int> rc(num);
for (int i = 0; i < num; i++)
lc[i] = arr[i].first, rc[i] = arr[i].second;
sort(all(lc)), sort(all(rc));
int result = 1e9 + 7;
for (auto [l, r] : arr)
{
int result_l = distance(begin(rc), lower_bound(all(rc), l)),
result_r = distance(upper_bound(all(lc), r), end(lc));
result = min(result, result_l + result_r);
}
return result;
}
int main()
{
fast;
ll T=1;
cin>>T;
while(T--)
{
int num;
cin >> num;
vector <pair<int, int>> arr(num);
for(auto &[x, y] : arr)
cin >> x >> y;
cout << solve(arr) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int n, d[100005], ans, f[100005], l[100005];
int main() {
int i, j;
while (~scanf("%d", &n)) {
ans = 1;
for (i = 1; i <= n; i++) scanf("%d", &d[i]);
for (i = 1; i <= n; i++) {
f[i] = i;
l[i] = i;
}
for (i = 2; i <= n; i++)
if (d[i] > d[i - 1]) {
f[i] = f[i - 1];
l[f[i]] = i;
}
if (l[1] == n)
ans = n;
else {
for (i = 2; i <= n; i++) {
if (i - f[i] + 1 > ans) ans = i - f[i] + 1;
if (l[i] - f[i] + 2 > ans) ans = l[i] - f[i] + 2;
if (f[i] != f[i - 1]) {
if (f[i - 1] == i - 1) {
if (l[i] - i + 2 > ans) ans = l[i] - i + 2;
} else if (l[i] == i) {
if (i - 1 - f[i - 1] + 2 > ans) ans = i - f[i - 1] + 1;
} else if (d[i] - d[i - 2] > 1 || d[i + 1] - d[i - 1] > 1) {
if (l[i] - f[i - 1] + 1 > ans) ans = l[i] - f[i - 1] + 1;
}
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
long long int poww(long long int a, long long int n) {
if (n == 0) return 1;
long long int p = poww(a, n / 2);
p = (p * p) % 1000000007;
if (n % 2) p = (a * p) % 1000000007;
return p;
}
int vis[500005];
void solve() {
long long int n, m;
cin >> n >> m;
vector<int> v[n + 1];
for (long long int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
vector<pair<int, int> > p;
int pos[n + 1];
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
p.push_back(make_pair(x, i));
pos[i] = x;
}
sort(p.begin(), p.end());
vector<int> ans;
for (int i = 0; i < n; i++) {
int node = p[i].second;
int col = p[i].first;
map<int, int> h;
for (int j = 0; j < v[node].size(); j++) {
if (vis[v[node][j]] == 0) continue;
h[pos[v[node][j]]] = 1;
}
int an = n;
for (int j = 1; j <= n; j++) {
if (h.find(j) == h.end()) {
an = j;
break;
}
}
if (an != col) {
cout << -1 << endl;
return;
}
ans.push_back(node);
vis[node] = 1;
}
for (long long int i = 0; i < n; ++i) cout << ans[i] << ' ';
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
long long int tt;
for (tt = 1; tt <= t; tt++) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e9 + 7;
int main() {
long long a, b;
cin >> a >> b;
long long ans = 0;
ans += (((((((a * (a + 1)) / 2) % Mod) * b) + a) % Mod) *
(((b * (b - 1)) / 2) % Mod)) %
Mod;
ans %= Mod;
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, d, dp[569][569], ps[2][569][569], dv = 998244353;
int main() {
long long i, j, z = 0;
scanf("%lld%lld", &n, &d);
dp[0][0] = 1;
for (i = 0; i <= n; i++) {
ps[0][0][i] = 1;
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (j <= i) {
dp[i][j] = (ps[0][i - j][j - 1] + ps[1][i - 1][j] + dv -
ps[1][max(i - j - 1, 0ll)][j]) %
dv;
}
ps[0][i][j] = (ps[0][i][j - 1] + dp[i][j]) % dv;
ps[1][i][j] = (ps[1][i - 1][j] + dp[i][j]) % dv;
}
}
for (i = 1; i <= n; i++) {
z = (z + dp[n][i] * ps[0][n][min((d - 1) / i, n)]) % dv;
}
z = z * 2 % dv;
printf("%lld\n", z);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0;
cin >> n;
bool isLR = false;
char a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 'L' || a[i] == 'R') isLR = true;
}
bool flag = false;
int count = 0;
for (int i = 0; i < n; i++) {
if (a[i] == '.' && flag == true)
count++;
else if (a[i] == 'L')
flag = true;
else if (a[i] == 'R') {
sum += count;
count = 0;
flag = false;
}
}
flag = false;
count = 0;
for (int i = 0; i < n; i++) {
if (a[i] == '.' && flag == true)
count++;
else if (a[i] == 'R')
flag = true;
else if (a[i] == 'L') {
if (count % 2 != 0) sum++;
count = 0;
flag = false;
}
}
count = 0;
for (int i = 0; i < n; i++) {
if (a[i] == '.')
count++;
else if (a[i] == 'L')
break;
else if (a[i] == 'R') {
sum += count;
break;
}
}
count = 0;
for (int i = n - 1; i >= 0; i--) {
if (a[i] == '.')
count++;
else if (a[i] == 'R')
break;
else if (a[i] == 'L') {
sum += count;
break;
}
}
if (isLR == true)
cout << sum;
else
cout << n;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long q, s, a, b, c, num, t;
scanf("%lld", &q);
while (q--) {
scanf("%lld %lld %lld %lld", &s, &a, &b, &c);
num = s / c;
t = num / a;
printf("%lld\n", num + (t * b));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string debug(long long x) {
if (x == 0) cout << 0;
stack<int> q;
while (x != 0) {
q.push(x % 2);
x /= 2;
}
while (!q.empty()) {
cout << q.top();
q.pop();
}
return "";
}
int cmp(int x, int y) {
if (x > y) return 1;
if (x < y) return -1;
return 0;
}
int main() {
int ans, ans1, ans2;
cout << "? 0 0" << endl;
fflush(stdout);
cin >> ans;
long long r1 = 0, r2 = 0;
long long tmp1, tmp2;
for (int i = 29; i >= 0; --i) {
if (ans == 0) ans = 1;
tmp1 = r1, tmp2 = r2;
tmp1 |= (1 << i);
tmp2 |= (1 << i);
cout << "? " << r1 << " " << tmp2 << endl;
fflush(stdout);
cin >> ans1;
cout << "? " << tmp1 << " " << r2 << endl;
fflush(stdout);
cin >> ans2;
if (ans1 == 0) ans1 = 1;
if (ans2 == 0) ans2 = 1;
if (ans == 1) {
if (ans1 == 1 && ans2 == -1) {
r1 |= (1 << i);
r2 |= (1 << i);
ans = 1;
}
if (ans1 == -1 && ans2 == 1) {
ans = 1;
}
if (ans1 == 1 && ans2 == 1) {
r1 |= (1 << i);
ans = 1;
}
if (ans1 == -1 && ans2 == -1) {
r1 |= (1 << i);
ans = -1;
}
} else {
if (ans1 == 1 && ans2 == -1) {
r1 |= (1 << i);
r2 |= (1 << i);
ans = -1;
}
if (ans1 == -1 && ans2 == 1) {
ans = -1;
}
if (ans1 == -1 && ans2 == -1) {
r2 |= (1 << i);
ans = -1;
}
if (ans1 == 1 && ans2 == 1) {
r2 |= (1 << i);
ans = 1;
}
}
}
cout << "! " << r1 << " " << r2 << endl;
fflush(stdout);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int pos = 0;
while (a[pos] == 0) pos++;
int res = 0;
for (int i = pos; i < n; i++) {
res++;
int j = i + 1;
while (a[j] == 0 && j < n) j++;
if (j - i < 3 && j != n) res += j - i - 1;
i = j - 1;
}
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
char p = (k % 2 == 0 ? 'R' : 'L');
int r = 1, c = 1, sum = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
sum += 2;
if (sum >= k) {
r = i;
c = j;
break;
}
}
if (sum >= k) {
break;
}
}
cout << r << " " << c << " " << p << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using ul = unsigned long long;
using db = double;
using pi = pair<int, int>;
using pl = pair<long long, long long>;
using pd = pair<ld, ld>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<long long>>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<long long>;
using vd = vector<ld>;
using vs = vector<string>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
template <typename T, size_t size>
using va = vector<array<T, size>>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename A, typename B>
istream &operator>>(istream &in, pair<A, B> &p) {
return in >> p.first >> p.second;
}
template <typename T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
for (const auto &x : arr) os << x << ' ';
return os;
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << p.first << " " << p.second;
}
template <typename T>
istream &operator>>(istream &in, vector<T> &vec) {
for (auto &x : vec) {
in >> x;
}
return in;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (const auto &x : v) os << x << ' ';
return os;
}
template <class T>
bool ckmin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
void debug() { cerr << "\n"; }
template <typename Head, typename... Tail>
void debug(Head H, Tail... T) {
cerr << ' ' << H;
debug(T...);
}
inline long long modPow(long long x, long long y, long long mod) {
long long res = 1;
x = x % mod;
;
while (y > 0) {
if (y & 1) {
res = (res * x) % mod;
}
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
char dirs[4] = {'R', 'D', 'L', 'U'};
unordered_map<char, int> rdirs = {{'R', 0}, {'D', 1}, {'L', 2}, {'U', 3}};
const long long INF = 1e18 + 6;
const long long mod = 1e9 + 7;
const int MXN = 3e6 + 5;
template <typename T>
struct Point {
T x, y;
Point() : x(0), y(0) {}
Point(T _x, T _y) : x(_x), y(_y) {}
friend istream &operator>>(std::istream &i, Point &p) {
return i >> p.x >> p.y;
}
friend ostream &operator<<(std::ostream &o, const Point &p) {
return o << "(" << p.x << ", " << p.y << ")";
}
Point unitPolar(T ang) {
auto c = exp(ang * complex<T>(0, 1));
return P(c.real(), c.imag());
}
T norm() const { return x * x + y * y; }
double abs() const { return sqrt(norm()); }
double ang() const { return atan2(y, x); }
Point<T> conj() const { return {x, -y}; }
Point &operator+=(const Point &o) {
x += o.x;
y += o.y;
return *this;
}
Point &operator-=(const Point &o) {
x -= o.x;
y -= o.y;
return *this;
}
Point &operator*=(const T &c) {
x *= c;
y *= c;
return *this;
}
Point &operator/=(const T &c) {
x /= c;
y /= c;
return *this;
}
friend Point operator+(const Point &a, const Point &b) {
return Point(a) += b;
}
friend Point operator-(const Point &a, const Point &b) {
return Point(a) -= b;
}
friend Point operator*(const Point &a, const T &c) { return Point(a) *= c; }
friend Point operator*(const T &c, const Point &a) { return Point(a) *= c; }
friend Point operator/(const Point &a, const T &c) { return Point(a) /= c; }
bool operator==(const Point &o) const { return x == o.x && y == o.y; }
bool operator!=(const Point &o) const { return x != o.x || y != o.y; }
bool operator<(const Point &o) const {
return (x != o.x) ? x < o.x : y < o.y;
}
bool operator>(const Point &o) const {
return (x != o.x) ? x > o.x : y > o.y;
}
bool operator<=(const Point &o) const { return !(*this > o); }
friend T dot(const Point &a, const Point &b) { return a.x * b.x + a.y * b.y; }
friend T cross(const Point &a, const Point &b) {
return a.x * b.y - a.y * b.x;
}
friend T cross(const Point &p, const Point &a, const Point &b) {
return cross(a - p, b - p);
}
friend Point<T> operator*(const Point &a, const Point &b) {
return {a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x};
}
friend Point<T> operator/(const Point &a, const Point &b) {
return a * b.conj() / b.norm();
}
Point unit() const { return Point(*this) / abs(); }
Point rotate(const double &ang) const {
return *this * Point(cos(ang), sin(ang));
}
double dist(const Point &a) const { return (a - *this).abs(); }
double dist(const Point &a, const Point &b) {
return abs(cross(*this, a, b)) / a.dist(b);
}
Point reflect(const Point &a, const Point &b) const {
return a + ((*this - a) / (b - a)).conj() * (b - a);
}
Point foot(const Point &a, const Point &b) const {
return (*this + this->reflect(a, b)) / 2;
}
friend Point intersect(const Point &a, const Point &b, const Point &c,
const Point &d) {
T u = cross(a, b, c), v = cross(a, b, d);
return (d * u - c * v) / (u - v);
}
using polygon = std::vector<Point<T>>;
friend polygon seg_intersect(Point a, Point b, Point c, Point d) {
if (a > b) swap(a, b);
if (c > d) swap(c, d);
T a1 = cross(a, b, c), a2 = cross(a, b, d);
if (a1 > a2) swap(a1, a2);
if (!(a1 <= 0 && a2 >= 0)) return {};
if (a1 == 0 && a2 == 0) {
if (cross(a, c, d) != 0) return {};
Point<T> x1 = max(a, c), x2 = min(b, d);
if (x1 > x2) return {};
if (x1 == x2) return {x1};
return {x1, x2};
}
Point<T> z = intersect(a, b, c, d);
if (a <= z && z <= b) return {z};
return {};
}
friend std::ostream &operator<<(std::ostream &o, const polygon &poly) {
o << "{";
for (auto pt : poly) o << " " << pt;
return o << " }";
}
enum class Classification { in, out, on };
Classification classify(const polygon &p) const {
bool ans = 0;
for (int i = 0; i < int(p.size()); i++) {
Point<T> a = p[i], b = p[(i + 1) % p.size()];
if (cross(a, b, *this) == 0 && min(a, b) <= *this && *this <= max(a, b))
return Classification::on;
if (a.y > b.y) swap(a, b);
if (a.y <= y && y < b.y && cross(*this, a, b) > 0) ans ^= 1;
}
return ans ? Classification::in : Classification::out;
}
friend polygon convex_hull(const std::vector<Point> &pts) {
Point pivot = *min_element((pts).begin(), (pts).end());
auto sorted = pts;
sort((sorted).begin(), (sorted).end(),
[&pivot](const Point &p, const Point &q) {
T cp = cross(pivot, p, q);
if (cp != 0) return cp > 0;
return pivot.dist(p) < pivot.dist(q);
});
int j = 0;
polygon res(pts.size());
for (const Point &p : sorted) {
while (j > 1 && cross(res[j - 2], res[j - 1], p) <= 0) j--;
res[j++] = p;
}
res.erase(res.begin() + j, res.end());
return res;
}
Point centroid(const vector<Point> &v) {
Point cen(0, 0);
T area = 0;
for (int i = 0; i < int(((int)(v).size())); i++) {
int j = (i + 1) % ((int)(v).size());
T a = cross(v[i], v[j]);
cen += a * (v[i] + v[j]);
area += a;
}
return cen / area / (T)3;
}
friend T area(const polygon &p) {
T a = 0;
for (int i = 0; i < int(p.size()); i++)
a += cross(p[i], p[i + 1 < ((int)(p).size()) ? i + 1 : 0]);
return a;
}
template <typename U>
static int sign(const U &v) {
return (v > 0) - (v < 0);
}
friend int compare_by_angle(const Point &a, const Point &b) {
return sign(cross(b, a));
}
friend int compare_by_angle(const Point &a, const Point &b,
const Point &origin) {
return sign(cross(origin, b, a));
}
template <typename I>
friend void sort_by_angle(I first, I last,
const Point<T> &origin = Point<T>{}) {
first =
partition(first, last, [&](const Point<T> &p) { return p == origin; });
auto pivot =
partition(first, last, [&](const Point<T> &p) { return p > origin; });
auto compare = [&](const Point<T> &l, const Point<T> &r) {
return compare_by_angle(l, r, origin) < 0;
};
sort(first, pivot, compare);
sort(pivot, last, compare);
}
pair<Point, double> ccCenter(Point a, Point b, Point c) {
b -= a;
c -= a;
Point res = b * c * (c.conj() - b.conj()) / (b * c.conj() - b.conj() * c);
return {a + res, abs(res)};
}
pair<Point, double> mec(vector<Point> ps) {
shuffle((ps).begin(), (ps).end(), mt19937(time(0)));
Point o = ps[0];
double r = 0, EPS = 1 + 1e-8;
for (int i = 0; i < int(((int)(ps).size())); i++)
if (abs(o - ps[i]) > r * EPS) {
o = ps[i], r = 0;
for (int j = 0; j < int(i); j++)
if (abs(o - ps[j]) > r * EPS) {
o = (ps[i] + ps[j]) / 2, r = abs(o - ps[i]);
for (int k = 0; k < int(j); k++)
if (abs(o - ps[k]) > r * EPS)
tie(o, r) = ccCenter(ps[i], ps[j], ps[k]);
}
}
return {o, r};
}
};
using pt = Point<double>;
void solve() {
int n, m;
cin >> n >> m;
vector<pt> a(n);
cin >> a;
if (area(a) < 0) reverse((a).begin(), (a).end());
while (m--) {
pt x, y;
cin >> y >> x;
ld ans = 0;
vi sg;
for (int k = 0; k < int(n); k++) {
sg.push_back(pt::sign(cross(x, y, a[k])) >= 0);
}
for (int i = 0; i < int(n); i++) {
int j = (i + 1) % n;
if (sg[i] != sg[j]) {
ans += pt::sign(cross(a[i] - a[j], y - x)) *
dot(y - x, intersect(x, y, a[i], a[j]));
}
if (cross(x, y, a[i]) == 0 && cross(x, y, a[j]) == 0 &&
dot(y - x, a[j] - a[i]) > 0) {
ans += dot(y - x, a[j] - a[i]);
}
}
cout << ans / (x - y).abs() << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
int t = 1, tc = 1;
while (t--) {
solve();
tc++;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int number;
std::cin >> number;
std::vector<unsigned> values(number);
for (auto& it : values) std::cin >> it;
int result = 0;
for (int bit = 0; bit < 27; ++bit) {
auto modded = values;
auto const mod = 1u << (bit + 1);
for (auto& it : modded) it = it % mod;
std::sort(begin(modded), end(modded));
int count = 0;
for (auto iterator = begin(modded); iterator != end(modded); ++iterator) {
auto const x = *iterator;
auto left = ((1u << bit) - x) % mod, right = ((2u << bit) - x);
assert(left != right);
auto curCount = std::lower_bound(begin(modded), iterator, right) -
std::lower_bound(begin(modded), iterator, left);
if (left > right) curCount += iterator - begin(modded);
assert(curCount >= 0 and curCount <= iterator - begin(modded));
count ^= curCount;
}
result += (count & 1) << bit;
}
std::cout << result << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, m, sz[N], dp[2][N];
map<string, int> mp;
int main(void) {
string str;
cin >> str;
vector<string> v;
dp[0][str.size() - 1] = 1, dp[1][str.size() - 1] = 1;
for (int i = str.size() - 3; i >= 6; i--) {
string p = "", p1 = "", p2 = "", p3 = "";
p += str[i - 1], p += str[i];
p1 += str[i + 1], p1 += str[i + 2];
dp[0][i] = dp[1][i + 3];
if (p != p1) dp[0][i] = max(dp[0][i], dp[0][i + 2]);
if (i == str.size() - 3) {
dp[1][i] = 1;
continue;
}
p2 += str[i - 2], p2 += str[i - 1], p2 += str[i];
p3 += str[i + 1], p3 += str[i + 2], p3 += str[i + 3];
dp[1][i] = dp[0][i + 2];
if (p2 != p3) dp[1][i] = max(dp[1][i], dp[1][i + 3]);
}
for (int i = str.size() - 1; i >= 0; i--) {
if (i - 1 <= 4) break;
if (!dp[0][i]) continue;
string p = "";
p += str[i - 1], p += str[i];
if (!mp[p]) {
mp[p] = 1;
v.push_back(p);
}
if (i == str.size() - 1) i--;
}
for (int i = str.size() - 1; i >= 0; i--) {
if (i - 2 <= 4) break;
if (!dp[1][i]) continue;
string p = "";
p += str[i - 2], p += str[i - 1], p += str[i];
if (!mp[p]) {
mp[p] = 1;
v.push_back(p);
}
if (i == str.size() - 1) i--;
}
sort(v.begin(), v.end());
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) cout << v[i] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
char a[1000003];
char b[1000003];
int ca[1000003][26];
int cb[1000003][26];
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int main() {
int i, j;
cin >> n >> m;
scanf("%s%s", a, b);
int lena = strlen(a);
int lenb = strlen(b);
int gcdd = gcd(lena, lenb);
int ll = lena / gcdd;
int rr = lenb / gcdd;
for (i = 0; i < gcdd; i++)
for (j = i; j < lena; j += gcdd) ca[i][a[j] - 'a']++;
for (i = 0; i < gcdd; i++)
for (j = i; j < lenb; j += gcdd) cb[i][b[j] - 'a']++;
long long ans = 0;
for (i = 0; i < gcdd; i++)
for (j = 0; j < 26; j++) ans += 1ll * ca[i][j] * cb[i][j];
ans = ans * (n / rr);
ans = n * lena - ans;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int tot = 0, ans = -1;
string lx, Ans;
struct op {
int l, r;
char ch;
};
set<string> all;
set<int> pd;
vector<string> ot;
vector<op> pt;
map<int, string> mk, to;
map<string, int> ys;
map<pair<pair<int, int>, char>, int> ds;
string zh(int x) {
string s = "", t = "";
for (; x; x /= 26) s += (char)(x % 26 + 'a');
int tot = s.size();
for (int i = 0; i <= tot - 1; ++i) t += s[tot - i - 1];
return t;
}
string get(int x) {
int be = x;
if (x == ys["res"]) return "res";
if (mk.find(x) != mk.end()) return mk[x];
if (to.find(x) != to.end()) return to[x];
for (;;) {
if (all.find(zh(x)) == all.end()) {
all.insert(zh(x));
return to[be] = zh(x);
}
x++;
}
}
void work(int x) {
if (pt[x].ch == '.') return;
if (pd.find(pt[x].l) == pd.end()) work(pt[x].l);
if (pd.find(pt[x].r) == pd.end()) work(pt[x].r);
ot.push_back(get(x) + "=" + get(pt[x].l) + pt[x].ch + get(pt[x].r));
pd.insert(x);
}
int main() {
int n;
scanf("%d", &n);
pt.push_back((op){-1, -1, '.'});
for (int o = 1; o <= n; ++o) {
cin >> lx;
int p1 = -1, p2 = -1;
int len = lx.size();
for (int i = 0; i <= len - 1; ++i) {
if (lx[i] == '=') p1 = i;
if (lx[i] == '$' || lx[i] == '^' || lx[i] == '#' || lx[i] == '&') p2 = i;
}
if (p2 == -1) {
string a = lx.substr(0, p1), b = lx.substr(p1 + 1, len - p1 - 1);
if (a == b) continue;
if (ys.find(b) == ys.end()) {
ys[b] = ++tot;
mk[tot] = b;
all.insert(b);
pt.push_back((op){-1, -1, '.'});
}
if (a == "res") {
if (pt[ys[b]].ch == '.') ans = ys[b], Ans = mk[ys[b]];
}
ys[a] = ys[b];
} else {
string a = lx.substr(0, p1), b = lx.substr(p1 + 1, p2 - p1 - 1),
c = lx.substr(p2 + 1, len - p2 - 1);
if (ys.find(b) == ys.end()) {
ys[b] = ++tot;
mk[tot] = b;
all.insert(b);
pt.push_back((op){-1, -1, '.'});
}
if (ys.find(c) == ys.end()) {
ys[c] = ++tot;
mk[tot] = c;
all.insert(c);
pt.push_back((op){-1, -1, '.'});
}
int ib = ys[b], ic = ys[c];
if (ds.find({{ib, ic}, lx[p2]}) == ds.end()) {
ys[a] = ++tot;
pt.push_back((op){ib, ic, lx[p2]});
ds[{{ib, ic}, lx[p2]}] = ys[a];
} else {
ys[a] = ds[{{ib, ic}, lx[p2]}];
}
}
}
if (ys.find("res") == ys.end())
printf("0\n");
else if (ys["res"] == ans) {
if (Ans == "res") return printf("0\n"), 0;
printf("1\n");
cout << "res=" << Ans << endl;
} else {
work(ys["res"]);
int sz = ot.size();
printf("%d\n", sz);
for (int i = 0; i <= sz - 1; ++i) cout << ot[i] << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using ll = long long;
int const N = 1e3 + 5;
int const K = 504;
ll dp[K][K][3];
ll binom[N][N];
ll fact[N];
ll res[N];
ll atres[N];
int n, k;
int const P = 1e9 + 7;
void calc_bin(int n) {
for (int i = 0; i <= n; i++) {
binom[i][0] = 1;
for (int j = 1; j <= i; j++) {
binom[i][j] = (binom[i - 1][j] + binom[i - 1][j - 1]) % P;
}
}
}
void calc_dp(int n) {
dp[0][0][0] = 1;
dp[0][0][1] = 1;
dp[0][0][2] = 1;
for (int i = 1; i <= n; i++) {
dp[i][0][0] = 1;
dp[i][0][1] = 1;
dp[i][0][2] = 1;
if (i == 1) {
dp[1][1][0] = 0;
dp[1][1][1] = 1;
dp[1][1][2] = 2;
continue;
}
for (int j = 1; j <= i; j++) {
dp[i][j][0] = (dp[i - 1][j][1] + dp[i - 1][j - 1][0]) % P;
dp[i][j][1] = (dp[i][j][0] + dp[i - 1][j - 1][1]) % P;
dp[i][j][2] =
(dp[i - 1][j - 1][2] + dp[i - 1][j][2] + dp[i - 1][j - 1][1]) % P;
}
}
}
void factorial(int n) {
fact[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = (fact[i - 1] * i) % P;
}
}
void calc_res(int n) {
int u = (n + 1) / 2;
int w = n / 2;
for (int i = 0; i <= n; i++) {
for (int j = std::max(0, i - w); j <= std::min(i, u + 1); j++) {
res[i] = (res[i] + dp[u][j][(u == w)] * dp[w][i - j][(u > w) + 1]) % P;
}
}
}
int main() {
scanf("%d %d", &n, &k);
calc_bin(n);
calc_dp(n / 2 + 2);
factorial(n);
calc_res(n);
for (int i = n; i >= k; i--) {
res[i] = (res[i] * fact[n - i]) % P;
atres[i] = res[i];
for (int j = i + 1; j <= n; j++) {
ll w = ((j % 2 == i % 2) ? 1 : P - 1);
w = (w * binom[j][i]) % P;
w = (w * res[j]) % P;
atres[i] = (atres[i] + w) % P;
}
}
printf("%I64d", atres[k]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a >= b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a <= b)
return a;
else
return b;
}
long long diff(long long a, long long b) {
if (a >= b)
return a - b;
else
return b - a;
}
long long isPrime(long long n) {
if (n < 2) return 0;
if (n < 4) return 1;
if (n % 2 == 0 or n % 3 == 0) return 0;
for (long long i = 5; i * i <= n; i += 6)
if (n % i == 0 or n % (i + 2) == 0) return 0;
return 1;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void sort(long long arr[], long long n) {
for (long long i = 0; i <= n; i++) {
for (long long j = i; j <= n; j++) {
if (arr[i] > arr[j]) {
long long t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
}
}
long long modd(long long n, long long m) {
if (n - m > 0) {
return n - m;
} else {
return m - n;
}
}
long long fact(long long n) {
if (n == 1) {
return 1;
} else {
return n * fact(n - 1);
}
}
long long mod(long long n) {
if (n >= 0) {
return n;
} else {
return -n;
}
}
long long isperfectsquare(long long n) {
long long k = sqrt(n);
if (n % k == 0 && n / k == k) {
return 1;
} else {
return 0;
}
}
void pairsort(long long a[], long long b[], long long n) {
pair<long long, long long> pairt[n];
for (long long i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (long long i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long ispalindrome(string s) {
long long palindrome = 1;
long long n = s.length();
for (long long i = 0; i < (n / 2); i++) {
if (s[i] != s[n - 1 - i]) {
palindrome = 0;
break;
}
}
return palindrome;
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
string s;
long long min1 = k;
cin >> s;
string s1 = "";
string s2 = "";
string s3 = "";
for (long long i = 0; i < k; i++) {
if (i % 3 == 0) {
s1 += "R";
s2 += "G";
s3 += "B";
} else if (i % 3 == 1) {
s1 += "G";
s2 += "B";
s3 += "R";
} else if (i % 3 == 2) {
s1 += "B";
s2 += "R";
s3 += "G";
}
}
for (long long i = 0; i <= n - k; i++) {
long long c1 = 0, c2 = 0, c3 = 0;
for (long long j = i; j < i + k; j++) {
if (s1[j - i] != s[j]) {
c1++;
}
if (s2[j - i] != s[j]) {
c2++;
}
if (s3[j - i] != s[j]) {
c3++;
}
}
min1 = min(min(min1, c1), min(c2, c3));
}
cout << min1 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int vf[10000];
string s1, s2, s3;
int main() {
cin >> s1 >> s2;
for (int i = 0; i < s1.size(); i++) {
vf[s1[i]] = i;
vf[s1[i] - 'a' + 'A'] = i;
}
cin >> s3;
for (int i = 0; i < s3.size(); i++) {
if (s3[i] >= 'A' && s3[i] <= 'Z') {
cout << (char)(s2[vf[s3[i]]] - 'a' + 'A');
} else if (s3[i] >= 'a' && s3[i] <= 'z') {
cout << (char)(s2[vf[s3[i]]]);
} else
cout << s3[i];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string a, ans, jie;
int la, lh, lq, h, q, lans, wei[1000001];
int main() {
cin >> a;
la = a.size();
for (int i = 0; i < la; i++) {
if (a[i] == 'H')
lh++;
else {
lq++;
wei[lq] = i;
}
}
q = sqrt(lq);
if (q * q != lq) {
cout << "No";
return 0;
}
h = lh / (q + 1);
if (h * q + h != lh) {
cout << "No";
return 0;
}
if (lq == 0) {
if (lh % 2 == 1)
cout << "No";
else
cout << "Yes";
return 0;
}
lans = q + h;
if (wei[1] % 2 != 0) {
cout << "No";
return 0;
}
for (int i = 1; i <= wei[1] / 2; i++) {
ans = ans + 'H';
}
for (int i = wei[1]; i <= wei[q]; i++) {
ans = ans + a[i];
}
int o = la - 1 - wei[lq];
if (o % 2 != 0) {
cout << "No";
return 0;
}
for (int i = 1; i <= o / 2; i++) {
ans = ans + 'H';
}
for (int i = 0; i < lans; i++) {
if (ans[i] == 'H')
jie = jie + 'H';
else
jie = jie + ans;
}
if (jie == a)
cout << "Yes";
else
cout << "No";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int n, l = 26, inf = (int)1e9;
cin >> n;
int w[l][l];
for (int i = 0; i < l; i++) {
for (int j = 0; j < l; j++) w[i][j] = inf;
w[i][i] = 0;
}
while (n--) {
char a, b;
int cost;
cin >> a >> b >> cost;
int n = a - 'a';
int m = b - 'a';
w[n][m] = min(w[n][m], cost);
}
if (a.size() != b.size()) {
cout << -1 << endl;
return 0;
}
int cost = 0;
for (int k = 0; k < l; k++)
for (int i = 0; i < l; i++)
for (int j = 0; j < l; j++) w[i][j] = min(w[i][j], w[i][k] + w[k][j]);
for (int i = 0; i < a.size(); i++) {
int min = inf;
char c;
for (int j = 0; j < l; j++) {
int w1 = w[a[i] - 'a'][j];
int w2 = w[b[i] - 'a'][j];
if (w1 + w2 < min) {
min = w1 + w2;
c = j + 'a';
}
}
if (min == inf) {
cout << -1 << endl;
return 0;
}
cost += min;
a[i] = c;
}
cout << cost << endl;
cout << a << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int odd[n + 1], even[n + 1], k = 0, l = 0;
for (int i = 0; i < n; i++) {
int f;
cin >> f;
if (f % 2 == 0) {
even[k] = f;
k++;
} else {
odd[l] = f;
l++;
}
}
if (x % 2 == 0) {
int m = 0;
if (k % 2 == 0 && k > 0) k--;
if (l % 2 == 0 && l > 0) l--;
if (k + l >= x && (k > 0 && l > 0))
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
int m = 0;
if (k % 2 == 1 && k > 0) k--;
if (l % 2 == 0 && l > 0) l--;
if (k + l >= x && l > 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1, c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
const int N = 2e5 + 4;
int n, Q, k, dfn[N];
long long ans, ans2;
namespace vars {
int tim, siz[N], fa[N], dep[N], son[N], top[N], idx[N];
}
namespace sz {
using namespace vars;
int t[N];
inline void clear() { memset(t, 0, sizeof(t)); }
inline void add(int x, int v) {
for (; x <= n; x += x & -x) t[x] += v;
}
inline int ask(int x) {
int ret = 0;
for (; x; x -= x & -x) ret += t[x];
return ret;
}
inline void additv(int x, int v) {
add(dfn[x], v);
add(dfn[x] + siz[x], -v);
}
inline int askitv(int x) { return ask(dfn[x] + siz[x] - 1) - ask(dfn[x] - 1); }
} // namespace sz
namespace slpf {
inline int jpk(int x, int y, int lca);
}
namespace vt {
vector<int> e[N], vec[N];
int rt, siz[N], son[N];
void dfs_5(int x) {
siz[x] = vec[x].size();
son[x] = 0;
for (auto v : e[x]) {
dfs_5(v);
siz[x] += siz[v];
if (siz[v] > siz[son[x]]) son[x] = v;
}
}
inline void calc_7(int x, int fl, int anc) {
int qwq;
for (auto v : vec[x]) {
qwq = slpf::jpk(anc, v, rt);
if (qwq != -1) ans += fl * sz::askitv(qwq);
}
}
void dfs_7(int x, int fl, int anc) {
calc_7(x, fl, anc);
for (auto v : e[x]) dfs_7(v, fl, anc);
}
inline void calc_8(int x, int fl) {
for (auto v : vec[x]) {
sz::add(dfn[v], fl);
}
}
void dfs_8(int x, int fl) {
calc_8(x, fl);
for (auto v : e[x]) dfs_8(v, fl);
}
void dfs_6(int x, int fl) {
for (auto v : e[x])
if (v != son[x]) dfs_6(v, 0);
calc_7(x, -1, x);
for (auto v : e[x])
if (v != son[x]) dfs_7(v, -1, x);
if (son[x]) dfs_6(son[x], 1);
if (x == rt) {
if (son[x]) dfs_8(son[x], -1);
return;
}
int qwq;
for (auto v : vec[x]) {
qwq = slpf::jpk(x, v, rt);
if (qwq != -1) ans += sz::askitv(qwq);
sz::add(dfn[v], 1);
}
for (auto v : e[x])
if (v != son[x]) {
dfs_7(v, 1, x);
dfs_8(v, 1);
}
if (!fl) dfs_8(x, -1);
}
void dfs_9(int x) {
for (auto v : e[x]) dfs_9(v);
e[x].clear();
vec[x].clear();
}
inline void solve() {
dfs_5(rt);
dfs_6(rt, 0);
dfs_9(rt);
}
} // namespace vt
namespace slpf {
using namespace vars;
vector<int> e[N];
vector<pair<int, int> > vec[N];
void dfs_1(int x) {
siz[x] = 1;
for (auto v : e[x])
if (v != fa[x]) {
fa[v] = x;
dep[v] = dep[x] + 1;
dfs_1(v);
siz[x] += siz[v];
if (siz[v] > siz[son[x]]) son[x] = v;
}
}
void dfs_2(int x, int tp) {
top[x] = tp;
idx[dfn[x] = ++tim] = x;
if (son[x]) dfs_2(son[x], tp);
for (auto v : e[x])
if (v != fa[x] && v != son[x]) dfs_2(v, v);
}
inline int jump(int x, int k) {
if (k < 0) return -1;
if (k >= dep[x]) return 1;
while (dep[x] - dep[top[x]] < k) {
k -= dep[x] - dep[top[x]] + 1;
x = fa[top[x]];
}
return idx[dfn[x] - k];
}
inline int jpk(int x, int y, int lca) {
if (dep[x] - dep[lca] >= k) return jump(y, dep[y] - dep[lca] - 1);
return jump(y, dep[x] + dep[y] - dep[lca] * 2 - k);
}
inline int getlca(int x, int y) {
while (top[x] != top[y]) {
if (dep[top[x]] > dep[top[y]])
x = fa[top[x]];
else
y = fa[top[y]];
}
return dep[x] < dep[y] ? x : y;
}
struct QWQ {
int u, v, au, av;
QWQ() {}
QWQ(int x, int y, int z, int w) : u(x), v(y), au(z), av(w) {}
} qwq[N];
inline bool comp_qwq(const QWQ &a, const QWQ &b) {
return a.au < b.au || (a.au == b.au && a.av < b.av);
}
void dfs_3(int x) {
for (auto v : vec[x]) ans -= sz::ask(dfn[v.first]) + sz::ask(dfn[v.second]);
for (auto v : e[x])
if (v != fa[x]) dfs_3(v);
int cqwq = 0;
for (auto v : vec[x]) {
++cqwq;
qwq[cqwq] =
QWQ(v.first, v.second,
v.first == x ? -cqwq : jump(v.first, dep[v.first] - dep[x] - 1),
jump(v.second, dep[v.second] - dep[x] - 1));
}
sort(qwq + 1, qwq + cqwq + 1, comp_qwq);
for (auto v : vec[x]) ans2 -= sz::ask(dfn[v.first]) + sz::ask(dfn[v.second]);
for (int i = 1, las = 0; i <= cqwq; i++) {
ans += sz::ask(dfn[qwq[i].u]) + sz::ask(dfn[qwq[i].v]);
ans2 += sz::ask(dfn[qwq[i].u]) + sz::ask(dfn[qwq[i].v]);
if (i == cqwq || qwq[i].au != qwq[i + 1].au || qwq[i].av != qwq[i + 1].av) {
for (int j = i; j > las; j--) {
if (dep[qwq[j].u] - dep[x] >= k)
sz::additv(jump(qwq[j].u, dep[qwq[j].u] - dep[x] - k), 1);
if (dep[qwq[j].v] - dep[x] >= k)
sz::additv(jump(qwq[j].v, dep[qwq[j].v] - dep[x] - k), 1);
}
las = i;
}
}
}
int tp, st[N], b[N];
inline void insert(int x) {
if (tp < 2) {
st[++tp] = x;
return;
}
int lca = getlca(st[tp], x);
if (lca == st[tp]) {
st[++tp] = x;
return;
}
while (tp > 1 && dfn[st[tp - 1]] >= dfn[lca]) {
vt::e[st[tp - 1]].push_back(st[tp]);
tp--;
}
if (st[tp] != lca) {
vt::e[lca].push_back(st[tp]);
st[tp] = lca;
}
st[++tp] = x;
}
inline bool comp_dfn(int x, int y) { return dfn[x] < dfn[y]; }
inline void rebuild() {
sort(b + 1, b + b[0] + 1, comp_dfn);
b[0] = unique(b + 1, b + b[0] + 1) - b - 1;
tp = 0;
for (int i = 1; i <= b[0]; i++) insert(b[i]);
while (tp > 1) {
vt::e[st[tp - 1]].push_back(st[tp]);
tp--;
}
}
void dfs_4(int x) {
for (auto v : e[x])
if (v != fa[x]) dfs_4(v);
if (vec[x].empty()) return;
b[b[0] = 1] = x;
for (auto v : vec[x])
if (v.first != x) {
b[++b[0]] = v.first;
vt::vec[v.first].push_back(v.second);
}
rebuild();
vt::rt = x;
vt::solve();
}
} // namespace slpf
int main() {
n = read();
Q = read();
k = read();
for (int i = 1, u, v; i < n; i++) {
u = read();
v = read();
slpf::e[u].push_back(v);
slpf::e[v].push_back(u);
}
slpf::dfs_1(1);
slpf::dfs_2(1, 1);
for (int u, v, lca; Q--;) {
u = read();
v = read();
if (dfn[u] > dfn[v]) u ^= v ^= u ^= v;
lca = slpf::getlca(u, v);
slpf::vec[lca].push_back(make_pair(u, v));
}
slpf::dfs_3(1);
sz::clear();
slpf::dfs_4(1);
cout << ans << "\n";
return (0 - 0);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e3 + 10;
const long long INF = 1e12 + 10;
long long a[MAXN];
long long dp[MAXN];
long long n, k;
long long f(long long t) {
long long res = 0;
for (long long i = 1; i <= n; i++) {
dp[i] = 1;
for (long long j = i - 1; j >= 1; j--) {
if (abs(a[i] - a[j]) <= (i - j) * t) {
dp[i] = max(dp[i], dp[j] + 1);
}
}
res = max(res, dp[i]);
}
return res;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
long long l = -1, r = INF;
while (true) {
if (r - l == 1) {
cout << r;
return 0;
}
long long mid = (l + r) / 2;
if (f(mid) >= (n - k)) {
r = mid;
} else {
l = mid;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Inf = 0x3f3f3f3f;
int N, fav[303][303], pfav[303], choose[303][303], pr[303];
int main() {
cin >> N;
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j) {
cin >> fav[i][j];
--fav[i][j];
}
for (int i = 0; i < N; ++i) {
cin >> pfav[i];
--pfav[i];
}
for (int i = 0; i < N; ++i) pr[pfav[i]] = i;
pr[N] = Inf;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
int c = N;
for (int k = 0; k <= i; ++k)
if (k != j && pr[k] < pr[c]) c = k;
choose[j][i] = c;
}
}
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) pr[fav[i][j]] = j;
pr[N] = Inf;
int t = 0;
for (int j = 0; j < N; ++j)
if (pr[choose[i][j]] < pr[choose[i][t]]) t = choose[i][j];
cout << t + 1 << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
if (n % 2 == 0) {
cout << n / 2;
return 0;
}
long long int d;
d = n;
long long int sq = sqrt(n);
for (long long int i = 3; i <= sq; i++) {
if (n % i == 0) {
d = i;
n = ((n - d) / 2) + 1;
cout << n;
return 0;
}
}
n = ((n - d) / 2) + 1;
cout << n;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int m, n, i, c, d, j, store = 0, res = 0;
scanf("%d%d", &m, &n);
int a[m];
for (i = 0; i < m; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < n; i++) {
store = 0;
scanf("%d%d", &c, &d);
for (j = c - 1; j < d; j++) {
store = store + a[j];
}
if (store > 0) {
res = res + store;
}
}
printf("%d\n", res);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int lVote;
cin >> n;
priority_queue<int> M;
for (int i = 0; i < n; i++) {
if (i == 0) {
cin >> lVote;
continue;
}
int temp;
cin >> temp;
M.push(temp);
}
int answer = 0;
while (!M.empty()) {
int a = M.top();
if (a >= lVote) {
a = a - 1;
lVote += 1;
answer += 1;
M.pop();
M.push(a);
} else {
M.pop();
}
}
cout << answer << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int lw[110], rw[110], ls[110], rs[110];
memset(lw, 0, sizeof(lw));
memset(rw, 0, sizeof(rw));
memset(ls, 0, sizeof(ls));
memset(rs, 0, sizeof(rs));
int n, m;
scanf("%d%d", &n, &m);
int k = 1;
int i = 0;
for (; k <= m; k++) {
lw[i] = k;
k++;
if (k > m) break;
rw[i] = k;
i++;
if (i == n) break;
}
i = 0;
k++;
for (; k <= m; k++) {
ls[i] = k;
k++;
if (k > m) break;
rs[i] = k;
i++;
if (i == n) break;
}
for (int i = 0; i < n; i++) {
if (ls[i]) cout << ls[i] << ' ';
if (lw[i]) cout << lw[i] << ' ';
if (rs[i]) cout << rs[i] << ' ';
if (rw[i]) cout << rw[i] << ' ';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const double EPS = 1e-9;
const long long MOD = (long long)(1e9 + 7);
const long long MAXV = (long long)(2e5 + 10);
const long long MAXE = (long long)(1e6 + 10);
long long seg[MAXV * 4];
long long lazy[MAXV * 4];
long long A[MAXV * 4];
void build(int n, int s, int e) {
if (s + 1 == e) {
seg[n] = A[s];
} else {
int m = (s + e) >> 1;
build(n * 2, s, m);
build(n * 2 + 1, m, e);
seg[n] = min(seg[n * 2], seg[n * 2 + 1]);
}
}
void add_lazy(int n, long long x) {
lazy[n] += x;
seg[n] += x;
}
void push(int n, int s, int e) {
if (s + 1 == e) return;
add_lazy(n * 2, lazy[n]);
add_lazy(n * 2 + 1, lazy[n]);
lazy[n] = 0;
}
void update(int n, int s, int e, int a, int b, long long x) {
if (s >= b || e <= a) return;
if (s >= a && e <= b)
add_lazy(n, x);
else {
if (lazy[n]) push(n, s, e);
int m = (s + e) >> 1;
update(n * 2, s, m, a, b, x);
update(n * 2 + 1, m, e, a, b, x);
seg[n] = min(seg[n * 2], seg[n * 2 + 1]);
}
}
int query(int n, int s, int e) {
if (s + 1 == e)
return s;
else {
if (lazy[n]) push(n, s, e);
int m = (s + e) >> 1;
long long ans;
if (seg[n * 2] < seg[n * 2 + 1])
ans = query(n * 2, s, m);
else
ans = query(n * 2 + 1, m, e);
seg[n] = min(seg[n * 2], seg[n * 2 + 1]);
return ans;
}
}
int n;
long long ans[MAXV];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> A[i];
build(1, 0, n);
long long curr = 1;
for (int i = 0; i < n; i++) {
int p = query(1, 0, n);
ans[p] = curr;
update(1, 0, n, p + 1, n, -curr);
update(1, 0, n, p, p + 1, INF);
curr++;
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool checker(vector<pair<int, int>> x, vector<pair<int, int>> z, int t) {
for (int i = 0; i < (int)z.size(); i++) {
for (int j = 0; j < (int)x.size(); j++) {
int tempzf = z[i].first + t;
int tempzs = z[i].second + t;
if (tempzf <= x[j].second && x[j].first <= tempzs) return true;
}
}
return false;
}
int main() {
int p, q, l, r;
cin >> p >> q >> l >> r;
int cnt = 0;
vector<pair<int, int>> xs(p);
vector<pair<int, int>> zs(q);
for (int i = 0; i < p; i++) cin >> xs[i].first >> xs[i].second;
for (int i = 0; i < q; i++) cin >> zs[i].first >> zs[i].second;
while (l <= r) {
if (checker(xs, zs, l)) cnt++;
l++;
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 100;
int i, j, k, n, m, s, t, ans;
char c[100005];
int a[100005];
int stk[100005];
int Min[100005];
int top;
int main() {
scanf("%s", c + 1);
n = strlen(c + 1);
for (int i = 1; i <= n; i++) a[i] = c[i] - 'a';
Min[n] = oo;
for (int i = n - 1; i >= 1; i--) Min[i] = min(Min[i + 1], a[i + 1]);
for (int i = 1; i <= n; i++) {
stk[++top] = a[i];
while (top && stk[top] <= Min[i]) putchar('a' + stk[top--]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int main() {
cin >> a >> b >> c;
if (!c)
puts(a == b ? "YES" : "NO");
else if (c > 0)
puts(a > b || (b - a) % c ? "NO" : "YES");
else
puts(b > a || (a - b) % c ? "NO" : "YES");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int p[3005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, i, j, z = 0;
cin >> n;
for (i = 0; i < n; i++) cin >> p[i];
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++)
if (p[i] > p[j]) z++;
cout << z * 2 - z % 2;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n;
set<long long> S;
int main() {
int n;
cin >> n;
int ans;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
long long a = n / i;
long long b = a + a * (a - 1) / 2 * i;
S.insert(b);
long long k = n / i;
a = n / k;
b = a + a * (a - 1) / 2 * k;
S.insert(b);
}
}
set<long long>::iterator it;
for (it = S.begin(); it != S.end(); it++) {
cout << *it << " ";
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, maxn = 200007;
const long long MOD = 1004535809;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const long long P = 19260817;
char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = ((x << 3) + (x << 1) + ch - '0') % MOD, ch = getchar();
return x * f;
}
void write(int x) {
if (!x) putchar('0');
if (x < 0) x = -x, putchar('-');
static int sta[20];
register int tot = 0;
while (x) sta[tot++] = x % 10, x /= 10;
while (tot) putchar(sta[--tot] + 48);
}
int n;
char s[maxn];
int sump[maxn], sums[maxn];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
int f1 = 0, f2 = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '(') f2 = 1;
if (f2 == 1 && s[i] == ')') f1 = 1;
}
if (f1 == 0) {
printf("0");
return 0;
}
for (int i = 1; i <= n; i++) {
sump[i] = sump[i - 1] + (s[i] == '(');
}
for (int i = n; i >= 1; i--) {
sums[i] = sums[i + 1] + (s[i] == ')');
}
for (int i = 1; i <= n; i++) {
if (sump[i] == sums[i]) {
printf("1\n%d\n", 2 * sump[i]);
for (int j = 1; j <= i; j++) {
if (s[j] == '(') printf("%d ", j);
}
for (int j = i; j <= n; j++) {
if (s[j] == ')') printf("%d ", j);
}
return 0;
}
}
for (int i = 1; i <= n; i++) {
if (sump[i] == sums[i + 1]) {
printf("1\n%d\n", 2 * sump[i]);
for (int j = 1; j <= i; j++) {
if (s[j] == '(') printf("%d ", j);
}
for (int j = i + 1; j <= n; j++) {
if (s[j] == ')') printf("%d ", j);
}
return 0;
}
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.