solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
const int mod = 1e9 + 7;
int digit[maxn];
int dp[10][2][1 << 10];
int n, k;
int g[1 << 10];
int dfs(int len, bool lim, int s) {
if (len == 0) return g[s] <= k;
int &x = dp[len][lim][s];
if (~x) return x;
int low = lim ? digit[len] : 0;
int ans = false;
for (int i = low; i <= 9; i++) {
ans |= dfs(len - 1, lim && i == low, s | (1 << i));
if (ans) break;
}
return x = ans;
}
long long ksm(long long a, long long b) {
long long ans = 1, base = a;
while (b) {
if (b & 1) ans = ans * base % mod;
b >>= 1;
base = base * base % mod;
}
return ans;
}
long long getans(int len, int lim, int s) {
if (len == 0) return 0;
int low = lim ? digit[len] : 0;
for (int i = low; i <= 9; i++) {
bool ok = dfs(len - 1, lim && i == low, s | (1 << i));
if (ok) {
return i * ksm(10, len - 1) +
getans(len - 1, lim && i == low, s | (1 << i));
}
}
return -1;
}
long long solve() {
int k = 0;
while (n) {
digit[++k] = n % 10;
n /= 10;
}
memset(dp, -1, sizeof dp);
dfs(k, true, 0);
return getans(k, true, 0);
}
int main() {
ios::sync_with_stdio(false);
g[0] = 0;
for (int i = 1; i < 1 << 10; i++) {
g[i] = g[i >> 1] + (i & 1);
}
int t;
cin >> t;
while (t--) {
cin >> n >> k;
cout << solve() << endl;
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int c[2][110][110], dp[110], s[500010], n, k, p;
void update(int f, int t, int x, int w) {
for (int i = x + 1; i <= p + 1; i += i & -i) c[f][t][i] = min(c[f][t][i], w);
}
int query(int f, int t, int x) {
int res = 0x3f3f3f3f;
for (int i = x + 1; i; i -= i & -i) res = min(c[f][t][i], res);
return res;
}
int main() {
while (~scanf("%d%d%d", &n, &k, &p)) {
memset(dp, 0x3f3f3f3f, sizeof(dp));
for (int i = 1; i <= n; i++) {
scanf("%d", &s[i]);
s[i] = (s[i - 1] + s[i]) % p;
}
for (int i = 0; i <= k; i++)
for (int j = 0; j <= p + 1; j++) c[0][i][j] = c[1][i][j] = 0x3f3f3f3f;
update(0, 0, p + 1, 0);
update(1, 0, 0, 0);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= min(i, k); j++)
dp[j] = min(query(0, j - 1, s[i]), query(1, j - 1, p - s[i])) + s[i];
for (int j = 1; j <= min(i, k); j++) {
if (dp[j] == 0x3f3f3f3f) continue;
int now = p - s[i];
update(0, j, s[i], dp[j] - s[i]);
update(1, j, now, now + dp[j]);
}
}
printf("%d\n", dp[k]);
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10010;
const int M = 15;
const double eps = 1e-7;
const int INF = 1 << 30;
int n;
struct node {
double x, y, z;
node() { x = y = z = 0; }
node(double xx, double yy, double zz) {
x = xx;
y = yy;
z = zz;
}
} poy[N], ori;
double vp, vs, prelen;
int ln;
double ABS(double x) {
while (x < 0) x = -x;
return x;
}
double dist(node a, node b) {
double tmp = 0;
tmp += (a.x - b.x) * (a.x - b.x);
tmp += (a.y - b.y) * (a.y - b.y);
tmp += (a.z - b.z) * (a.z - b.z);
return sqrt(tmp);
}
void init() {
double x, y, z;
for (int i = 1; i <= n + 1; i++) {
cin >> x >> y >> z;
poy[i] = node(x, y, z);
}
cin >> vp >> vs;
cin >> x >> y >> z;
ori = node(x, y, z);
}
bool solve() {
double t = 0;
for (int i = 2; i <= n + 1; i++) {
double len = dist(ori, poy[i]) / vp;
double edge = dist(poy[i - 1], poy[i]) / vs;
t += edge;
if ((t - len) >= -eps) {
ln = i;
prelen = t - edge;
return 1;
}
}
return 0;
}
node getmid(node a, node b) {
double xx, yy, zz;
xx = (a.x + b.x) * 0.5;
yy = (a.y + b.y) * 0.5;
zz = (a.z + b.z) * 0.5;
return node(xx, yy, zz);
}
void cal() {
node pre = poy[ln - 1];
node l = poy[ln - 1], r = poy[ln];
double t;
while (ABS(dist(l, r)) > eps) {
node mid = getmid(l, r);
double len1 = dist(ori, mid);
double len2 = dist(mid, pre);
double t1 = len1 / vp;
double t2 = len2 / vs + prelen;
t = t1;
if ((t1 - t2) < 1e-12)
r = mid;
else
l = mid;
}
printf("%.10lf\n%.10lf %.10lf %.10lf\n", t, l.x, l.y, l.z);
}
int main() {
while (cin >> n) {
init();
if (solve())
cout << "YES" << endl;
else {
cout << "NO" << endl;
continue;
}
cal();
}
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e18;
const long long mod = (long long)1e9 + 7;
const double pi = acos(-1.0);
const double eps = (double)1e-9;
const int dx[] = {0, 0, 1, 0, -1};
const int dy[] = {0, 1, 0, -1, 0};
const int N = 200500;
const int block = 450;
long long cur, ans[N];
bool pol[N], u[N];
vector<int> g[N];
int timer, tin[N], tout[N], eu[N];
int n, q, f[N], ar[N], up[N][17], cnt1[N], cnt2[N];
void dfs(int v, int pr = -1) {
tin[v] = ++timer;
eu[timer] = v;
for (auto to : g[v]) {
if (to == pr) continue;
up[to][0] = v;
dfs(to, v);
}
tout[v] = ++timer;
eu[timer] = v;
}
inline bool upper(int x, int y) {
return (tin[x] <= tin[y] && tout[y] <= tout[x]);
}
inline int lca(int x, int y) {
if (upper(x, y)) return x;
if (upper(y, x)) return y;
for (int i = 16; i >= 0; i--)
if (up[x][i] && !upper(up[x][i], y)) x = up[x][i];
return up[x][0];
}
struct query {
int l, r, bl, lca, id;
query(){};
query(int a, int b, int c, int d, int e) {
l = a;
r = b;
bl = c;
lca = d;
id = e;
}
} qr[N];
inline bool cmp(query q1, query q2) {
if (q1.bl == q2.bl) return q1.r < q2.r;
return q1.bl < q2.bl;
}
inline void add(int v) {
if (pol[v]) {
cur += cnt2[f[v]];
cnt1[f[v]]++;
} else {
cur += cnt1[f[v]];
cnt2[f[v]]++;
}
}
inline void del(int v) {
if (pol[v]) {
cur -= cnt2[f[v]];
cnt1[f[v]]--;
} else {
cur -= cnt1[f[v]];
cnt2[f[v]]--;
}
}
inline void upd(int i) {
int v = eu[i];
if (!u[v])
add(v);
else
del(v);
u[v] ^= 1;
}
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> pol[i];
for (int i = 1; i <= n; i++) {
cin >> f[i];
ar[i] = f[i];
}
sort(ar + 1, ar + 1 + n);
int sz = unique(ar + 1, ar + 1 + n) - ar - 1;
for (int i = 1; i <= n; i++)
f[i] = lower_bound(ar + 1, ar + 1 + sz, f[i]) - ar;
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1);
for (int j = 1; j <= 16; j++)
for (int i = 1; i <= n; i++) up[i][j] = up[up[i][j - 1]][j - 1];
cin >> q;
for (int i = 1; i <= q; i++) {
int x, y;
cin >> x >> y;
if (tin[x] > tin[y]) swap(x, y);
if (upper(x, y))
qr[i] = query(tin[x], tin[y], tin[x] / block, lca(x, y), i);
else
qr[i] = query(tout[x], tin[y], tout[x] / block, lca(x, y), i);
}
sort(qr + 1, qr + 1 + q, &cmp);
int l = qr[1].l, r = qr[1].l - 1;
for (int i = 1; i <= q; i++) {
int L = qr[i].l;
int R = qr[i].r;
while (L < l) upd(--l);
while (l < L) upd(l++);
while (r < R) upd(++r);
while (R < r) upd(r--);
if (eu[qr[i].l] != qr[i].lca) upd(tin[qr[i].lca]);
ans[qr[i].id] = cur;
if (eu[qr[i].l] != qr[i].lca) upd(tin[qr[i].lca]);
}
for (int i = 1; i <= q; i++) cout << ans[i] << endl;
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int r1, r2, c1, c2, d1, d2;
int a[2][2];
bool solve() {
if (a[0][0] + a[0][1] != r1) return false;
if (a[1][0] + a[1][1] != r2) return false;
if (a[0][0] + a[1][0] != c1) return false;
if (a[0][1] + a[1][1] != c2) return false;
if (a[0][0] + a[1][1] != d1) return false;
if (a[0][1] + a[1][0] != d2) return false;
return true;
}
int main() {
bool flag = false;
cin >> r1 >> r2 >> c1 >> c2 >> d1 >> d2;
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= 9; j++) {
if (i == j) continue;
for (int k = 1; k <= 9; k++) {
if (k == i || k == j) continue;
for (int l = 1; l <= 9; l++) {
if (l == i || l == j || l == k) continue;
a[0][0] = i;
a[0][1] = j;
a[1][0] = k;
a[1][1] = l;
if (solve()) {
flag = true;
break;
}
}
if (flag) break;
}
if (flag) break;
}
if (flag) break;
}
if (flag) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
cout << a[i][j] << " ";
}
cout << endl;
}
} else {
cout << -1 << endl;
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
struct Point {
long long x, y;
Point() : x(0), y(0) {}
Point(long long x, long long y) : x(x), y(y) {}
long long operator*(long long pos) const { return x * pos + y; }
};
struct DynLichao {
struct Node {
Point p;
int l, r;
Node() : p(Point(0, INF)), l(0), r(0) {}
};
vector<Node> t;
void inline init() {
t.clear();
t.push_back(Node());
t.push_back(Node());
}
int inline newnode() {
t.push_back(Node());
return ((int)(t).size()) - 1;
}
void add(Point p, int now = 1, int l = 0, int r = Inf) {
int m = (l + r) >> 1;
bool Lcmp = p * l < t[now].p * l;
bool Mcmp = p * m < t[now].p * m;
if (Mcmp) swap(p, t[now].p);
if (l == r) return;
if (Lcmp != Mcmp) {
if (!t[now].l) {
int id = newnode();
t[now].l = id;
}
add(p, t[now].l, l, m);
} else {
if (!t[now].r) {
int id = newnode();
t[now].r = id;
}
add(p, t[now].r, m + 1, r);
}
}
long long get(long long x, int now = 1, int l = 0, int r = Inf) {
if (!now) return INF;
if (l == r) return t[now].p * x;
int m = (l + r) >> 1;
return min(t[now].p * x,
(m >= x ? get(x, t[now].l, l, m) : get(x, t[now].r, m + 1, r)));
}
} seg;
int n;
long long a[1 << 17], b[1 << 17];
long long dp[1 << 17];
int main() {
scanf("%d", &n);
for (int i = 1; i <= (n); ++i) scanf("%lld", a + i);
for (int i = 1; i <= (n); ++i) scanf("%lld", b + i);
seg.init();
dp[1] = 0;
seg.add(Point(b[1], dp[1]));
for (int i = (2); i <= (n); ++i) {
dp[i] = seg.get(a[i]);
seg.add(Point(b[i], dp[i]));
}
printf("%lld\n", dp[n]);
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int x = 1LL << (n + 1);
cout << x - 2;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long powerm(long long x, long long y, long long M) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % M;
y = y >> 1;
x = (x * x) % M;
}
return res % M;
}
long long power(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T;
T = 1;
while (T--) {
long long n;
cin >> n;
vector<long long> a(n);
vector<long long> b(n);
vector<long long> orz(n + 1);
for (long long i = 0; i < n; i++) {
cin >> a[i];
orz[a[i]] = i;
}
for (long long i = 0; i < n; i++) cin >> b[i];
map<long long, long long> rot;
for (long long i = 0; i < n; i++) {
long long shift = orz[b[i]] - i;
if (shift < 0) shift += n;
rot[shift]++;
}
long long ans = 0;
for (auto x : rot) {
ans = max(ans, x.second);
}
cout << ans;
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
string n;
int len;
int solve_00() {
int pos[20], cnt = 0;
for (int i = 0; i < len; i++)
if (n[i] == '0') pos[++cnt] = i;
if (cnt < 2) return inf;
return len - 1 - pos[cnt] + len - 2 - pos[cnt - 1];
}
int solve_other(int l1, int l2) {
int pos1 = -1, pos2 = -1, ret = 0;
string tn = n;
for (int i = 0; i < len; i++) {
if (tn[i] - '0' == l1) pos1 = i;
if (tn[i] - '0' == l2) pos2 = i;
}
if (pos1 == -1 || pos2 == -1) return inf;
int lpos = min(pos1, pos2), rpos = max(pos1, pos2);
for (int i = rpos; i < len - 1; i++, ret++) swap(tn[i], tn[i + 1]);
if (lpos == 0)
for (int i = 1; tn[i] == '0' && i < len - 1; i++, ret++)
if (i == len - 2) return inf;
ret += len - 2 - lpos + (lpos == pos2);
return ret;
}
int main() {
cin >> n;
len = n.size();
int ans = solve_00();
ans = min(ans, solve_other(2, 5));
ans = min(ans, solve_other(5, 0));
ans = min(ans, solve_other(7, 5));
if (ans == inf) ans = -1;
cout << ans;
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int u, v, mod;
inline int add(int a, int b) {
if ((a += b) >= mod) a -= mod;
return a;
}
inline int mult(int a, int b) {
long long t = 1ll * a * b;
if (t >= mod) t %= mod;
return t;
}
inline int power(int a, int b) {
int out = 1;
while (b) {
if (b & 1) out = mult(out, a);
a = mult(a, a);
b >>= 1;
}
return out;
}
unordered_map<int, pair<int, int> > mp;
mt19937 rnd(2309482);
vector<int> V[96000];
int main() {
scanf("%d%d%d", &u, &v, &mod);
if (u == v) {
puts("0");
return 0;
}
for (int i = 1; 1ll * i * i <= 3ll * mod; i++) {
mp[u] = make_pair(i, -1);
int np = u;
for (int j = 0; j < 100; j++) {
int cstp;
if (j == 0)
cstp = rnd() % 3 + 1;
else {
int v1, v2;
if (V[i].back() == 1)
v1 = 1, v2 = 3;
else if (V[i].back() == 2)
v1 = 2, v2 = 3;
else
v1 = 1, v2 = 2;
if (rnd() & 1)
cstp = v1;
else
cstp = v2;
}
if (cstp == 1)
np = add(np, 1);
else if (cstp == 2)
np = add(np, mod - 1);
else
np = power(np, mod - 2);
mp[np] = make_pair(i, j);
V[i].push_back(cstp);
}
}
if (mp.find(v) != mp.end()) {
pair<int, int> tmp = mp[v];
printf("%d\n", tmp.second + 1);
for (int i = 0; i <= tmp.second; i++) printf("%d ", V[tmp.first][i]);
return 0;
}
for (int i = 1; 1ll * i * i <= 3ll * mod; i++) {
vector<int> cur;
int np = v;
for (int j = 0; j < 100; j++) {
int cstp;
if (j == 0)
cstp = rnd() % 3 + 1;
else {
int v1, v2;
if (V[i].back() == 1)
v1 = 1, v2 = 3;
else if (V[i].back() == 2)
v1 = 2, v2 = 3;
else
v1 = 1, v2 = 2;
if (rnd() & 1)
cstp = v1;
else
cstp = v2;
}
cur.push_back(cstp);
if (cstp == 1)
np = add(np, mod - 1);
else if (cstp == 2)
np = add(np, 1);
else
np = power(np, mod - 2);
if (mp.find(np) != mp.end()) {
pair<int, int> tmp = mp[np];
printf("%d\n", tmp.second + j + 2);
for (int k = 0; k <= tmp.second; k++) printf("%d ", V[tmp.first][k]);
for (int k = j; k >= 0; k--) printf("%d ", cur[k]);
return 0;
}
}
}
puts("qaq");
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
struct query {
int l, r, id;
query() : l(0), r(0), id(0){};
query(int l, int r, int id) : l(l), r(r), id(id){};
};
int n, t, a[202020], num[1000001], bb[202020], ll, rr;
vector<query> qq[400];
long long ans[202020], cur = 0;
bool cmp(query q1, query q2) {
if (q1.r < q2.r) return true;
return false;
}
long long fun(int x) {
long long a = num[x];
long long b = x;
return a * a * b;
}
void inc_r() {
++rr;
cur -= fun(a[rr]);
num[a[rr]]++;
cur += fun(a[rr]);
}
void dec_l() {
--ll;
cur -= fun(a[ll]);
num[a[ll]]++;
cur += fun(a[ll]);
}
void inc_l() {
cur -= fun(a[ll]);
num[a[ll]]--;
cur += fun(a[ll]);
++ll;
}
int main() {
for (int it = 0; it < 400; it++) {
int ll = it * 500 + 1;
int rr = (it + 1) * 500;
for (int i = ll; i <= rr; i++) bb[i] = it;
}
scanf("%d%d", &n, &t);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= t; i++) {
int l, r;
scanf("%d%d", &l, &r);
qq[bb[l]].push_back(query(l, r, i));
}
for (int it = 0; it < 400; it++) {
if (qq[it].size() == 0) continue;
sort(qq[it].begin(), qq[it].end(), cmp);
ll = it * 400 + 1;
rr = it * 400;
inc_r();
for (int i = 0; i < qq[it].size(); i++) {
while (rr < qq[it][i].r) inc_r();
while (ll < qq[it][i].l) inc_l();
while (ll > qq[it][i].l) dec_l();
ans[qq[it][i].id] = cur;
}
cur = 0;
for (int i = ll; i <= rr; i++) num[a[i]] = 0;
}
for (int i = 1; i <= t; i++) printf("%I64d\n", ans[i]);
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
int n, a[MAXN], b[MAXN];
int main() {
int T;
cin >> T;
while (T--) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], b[i] = a[i];
sort(b + 1, b + n + 1);
int l = 1, r = n;
for (int i = 1; i <= n; i++) {
if (a[i] == b[i])
l++;
else
break;
}
for (int i = n; i >= 1; i--) {
if (a[i] == b[i] && r > l)
r--;
else
break;
}
if (l >= r) {
cout << 0 << endl;
} else {
bool flag = 0;
for (int i = l; i <= r; i++) {
if (a[i] == b[i]) {
flag = 1;
break;
}
}
if (flag) {
cout << 2 << endl;
} else {
cout << 1 << endl;
}
}
}
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
struct aha {
long long ind, val;
aha() { ind = val = 0; }
} A[100005], B[100005];
long long C[200005], len = 0;
map<long long, long long> Ans;
int main() {
long long n, m;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> A[i].ind >> A[i].val;
C[++len] = A[i].ind;
Ans[A[i].ind] = A[i].val;
}
cin >> m;
for (long long i = 1; i <= m; i++) {
cin >> B[i].ind >> B[i].val;
C[++len] = B[i].ind;
long long a = Ans[B[i].ind];
Ans[B[i].ind] = max(B[i].val, a);
}
sort(C + 1, C + len + 1);
long long ans = 0;
for (long long i = 1; i <= len; i++) {
if (C[i] == C[i + 1]) continue;
ans += Ans[C[i]];
}
cout << ans;
return 0;
}
| 2
|
#include <bits/stdc++.h>
#pragma GCC optmize(2)
using namespace std;
constexpr int maxn = 2e5 + 100, inf = 0x7fffffff;
struct IO {
private:
static constexpr int ibufsiz = 1 << 20;
char ibuf[ibufsiz + 1], *inow = ibuf, *ied = ibuf;
static constexpr int obufsiz = 1 << 20;
char obuf[obufsiz + 1], *onow = obuf;
const char *oed = obuf + obufsiz;
public:
inline char getchar() {
if (inow == ied) {
ied = ibuf + sizeof(char) * fread(ibuf, sizeof(char), ibufsiz, stdin);
*ied = '\0';
inow = ibuf;
}
return *inow++;
}
template <typename T>
inline void read(T &x) {
static bool flg;
flg = 0;
x = 0;
char c = getchar();
while (!isdigit(c)) flg = c == '-' ? 1 : flg, c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
if (flg) x = -x;
}
template <typename T, typename... Y>
inline void read(T &x, Y &...X) {
read(x);
read(X...);
}
inline int readi() {
static int res;
read(res);
return res;
}
inline long long readll() {
static long long res;
read(res);
return res;
}
inline void flush() {
fwrite(obuf, sizeof(char), onow - obuf, stdout);
fflush(stdout);
onow = obuf;
}
inline void putchar(char c) {
*onow++ = c;
if (onow == oed) {
fwrite(obuf, sizeof(char), obufsiz, stdout);
onow = obuf;
}
}
template <typename T>
inline void write(T x, char split = '\0') {
static unsigned char buf[64];
if (x < 0) putchar('-'), x = -x;
int p = 0;
do {
buf[++p] = x % 10;
x /= 10;
} while (x);
for (int i = p; i >= 1; i--) putchar(buf[i] + '0');
if (split != '\0') putchar(split);
}
inline void lf() { putchar('\n'); }
~IO() { fwrite(obuf, sizeof(char), onow - obuf, stdout); }
} io;
template <typename A, typename B>
inline void chkmin(A &x, const B &y) {
if (y < x) x = y;
}
template <typename A, typename B>
inline void chkmax(A &x, const B &y) {
if (y > x) x = y;
}
int n, val[maxn], f[maxn], tmp[maxn];
inline void discretize() {
for (int i = 1; i <= n; i++) tmp[i] = val[i];
sort(tmp + 1, tmp + 1 + n);
int tot = unique(tmp + 1, tmp + 1 + n) - tmp - 1;
for (int i = 1; i <= n; i++)
val[i] = lower_bound(tmp + 1, tmp + 1 + tot, val[i]) - tmp;
}
inline void solve() {
for (int i = 0; i <= n; i++) f[i] = 0;
io.read(n);
for (int i = 1; i <= n; i++) io.read(val[i]);
discretize();
int ans = 0;
for (int i = 1; i <= n; i++) {
f[i] = 1;
for (int j = 1; j < i; j++)
if (val[j] + 1 == val[i]) chkmax(f[i], f[j] + 1);
}
for (int i = 1; i <= n; i++) chkmax(ans, f[i]);
printf("%d\n", n - ans);
}
int t;
int main() {
io.read(t);
while (t--) solve();
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int n, m, nr, k, i, j, l, c, a[11][11], s[11][11], cnt, v, w, sol;
int main() {
cin >> n >> m >> nr >> k;
for (i = 1; i <= nr; i++) {
cin >> l >> c;
a[l][c] = 1;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
s[i][j] = a[i][j] + s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
for (v = i; v <= n; v++)
for (w = j; w <= m; w++)
if (s[v][w] - s[i - 1][w] - s[v][j - 1] + s[i - 1][j - 1] >= k) sol++;
cout << sol;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
long long a1, b1, a2, b2;
cin >> a1 >> b1 >> a2 >> b2;
int cnt = 0;
long long area1 = a1 * b1;
long long area2 = a2 * b2;
long long com = gcd(area1, area2);
area1 /= com;
area2 /= com;
long long tmp = area1;
while (tmp % 3 == 0) tmp /= 3;
while (tmp % 2 == 0) tmp /= 2;
if (tmp != 1) {
puts("-1");
return 0;
}
tmp = area2;
while (tmp % 3 == 0) tmp /= 3;
while (tmp % 2 == 0) tmp /= 2;
if (tmp != 1) {
puts("-1");
return 0;
}
while (area1 % 3 == 0) {
area1 = area1 * 2 / 3;
if (a1 % 3 == 0)
a1 = a1 * 2 / 3;
else
b1 = b1 * 2 / 3;
cnt++;
}
while (area2 % 3 == 0) {
area2 = area2 * 2 / 3;
if (a2 % 3 == 0)
a2 = a2 * 2 / 3;
else
b2 = b2 * 2 / 3;
cnt++;
}
while (area1 % 2 == 0 && area2 % 2 == 0) {
area1 /= 2;
area2 /= 2;
}
while (area1 % 2 == 0) {
area1 = area1 / 2;
if (a1 % 2 == 0)
a1 = a1 / 2;
else
b1 = b1 / 2;
cnt++;
}
while (area2 % 2 == 0) {
area2 = area2 / 2;
if (a2 % 2 == 0)
a2 = a2 / 2;
else
b2 = b2 / 2;
cnt++;
}
cout << cnt << endl;
cout << a1 << " " << b1 << endl;
cout << a2 << " " << b2 << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long cs = 200005;
const long long mod = 1000000007;
const double PI = 2 * acos(0.0);
void solve() {
long long int t, n, m, a, b, c, d, e, i, j, k, x, y, z, cnt = 0, cnt1 = 0;
bool flag = false;
cin >> n >> m >> x >> y;
cnt = x;
for (i = 1; i <= y; i++) {
a = n / (m * i - m + 1);
if (!a) break;
if (a > x) a = x;
if (cnt < a * i) cnt = a * i;
}
cout << cnt << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 12
|
#include <bits/stdc++.h>
const int N = 510;
int DP[N][N], t[N][N], n, m, k;
int dx[] = {-2, -1, -1, -1, 0}, dy[] = {-1, -2, -1, 0, -1};
char map[N][N];
bool ok(int a, int b) {
for (int i = 0; i < 5; i++)
if (map[a + dx[i]][b + dy[i]] == '0') return 0;
return 1;
}
bool ok(int mid, int i, int j, int l) {
if (DP[j][l] - DP[i - 1][l] - DP[j][mid + 1] + DP[i - 1][mid + 1] >= k)
return 1;
return 0;
}
int bs(int l, int u, int i, int j) {
int low = l, up = u, mid;
while (low <= up) {
mid = (low + up) / 2;
if (ok(mid, i, j, l)) {
if (mid == l || !ok(mid - 1, i, j, l)) return mid;
up = mid - 1;
} else
low = mid + 1;
}
return m;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%s", map[i]);
for (int i = 2; i < n; i++)
for (int j = 2; j < m; j++)
if (ok(i, j)) t[i][j] = 1;
for (int i = 2; i < n; i++)
for (int j = m - 1; j >= 2; j--)
DP[i][j] = DP[i - 1][j] + DP[i][j + 1] - DP[i - 1][j + 1] + t[i][j];
long long ans = 0;
for (int i = 2; i < n; i++)
for (int j = i; j < n; j++)
for (int s = 2; s < m; s++) ans += m - bs(s, m - 1, i, j);
printf("%I64d\n", ans);
scanf(" ");
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
long ans;
string a;
bool comp(long a, long b) { return (a < b); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> a;
if (a.length() > 3)
for (int i = 0; i < a.length() - 3; i++) {
long l = 1, r = a.length() - i - 3;
if ((a[i] == 'b') && a[i + 1] == 'e' && a[i + 2] == 'a' &&
a[i + 3] == 'r') {
for (int j = i - 1; j >= 0; j--) {
if (a[j] == 'b' && a[j + 1] == 'e' && a[j + 2] == 'a' &&
a[j + 3] == 'r') {
break;
} else
l++;
}
ans += l * r;
}
}
cout << ans;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int solve(int i, vector<int>* graph, int current_time, int level,
pair<int, int>* exp_time, vector<vector<pair<int, int>>>& levels,
int* vals, int* arr) {
if (levels.size() <= level) levels.push_back(vector<pair<int, int>>());
levels.at(level).push_back(
make_pair(current_time, arr[level] = vals[i] ^ arr[level]));
int max_time = current_time;
for (int& j : graph[i]) {
max_time = max(current_time, solve(j, graph, max_time + 1, level + 1,
exp_time, levels, vals, arr));
}
exp_time[i] = make_pair(current_time, max_time);
return max_time;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int>* graph = new vector<int>[n];
int* vals = new int[n];
vector<vector<pair<int, int>>>* levels = new vector<vector<pair<int, int>>>();
pair<int, int>* exp_time = new pair<int, int>[n];
for (int i = 1; i < n; i++) {
int a;
scanf("%d", &a);
graph[a - 1].push_back(i);
}
getchar();
for (int i = 0; i < n; i++) {
char a;
scanf("%c", &a);
vals[i] = 1 << (int)(a - 'a');
}
solve(0, graph, 0, 0, exp_time, *levels, vals, new int[n]());
for (int i = 0; i < m; i++) {
int v, h;
scanf("%d%d", &v, &h);
v = v - 1;
h = h - 1;
if (levels->size() <= h) {
printf("Yes\n");
continue;
}
int lb = exp_time[v].first;
int ub = exp_time[v].second + 1;
const vector<pair<int, int>>& level = levels->at(h);
int lo = 0, hi = level.size() - 1;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (level[mid].first < lb)
lo = mid + 1;
else
hi = mid;
}
int left = lo;
lo = left;
hi = level.size() - 1;
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
if (level[mid].first < ub)
lo = mid;
else
hi = mid - 1;
}
int right = lo;
int letter =
level.at(right).second ^ (left > 0 ? level.at(left - 1).second : 0);
if (level[left].first >= lb && letter & -letter ^ letter)
printf("No\n");
else
printf("Yes\n");
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int par[1005];
int find(int x) {
if (par[x] == x)
return x;
else
return par[x] = find(par[x]);
}
void unity(int a, int b) {
int x = find(a);
int y = find(b);
par[x] = par[y];
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
par[i] = i;
}
int ans = 0;
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
if (find(a) == find(b)) {
ans = 1;
} else
unity(a, b);
}
int num = 0;
for (int i = 1; i <= n; i++) {
if (find(i) == i) num++;
}
if (num != 1) ans = 1;
printf("%s\n", ans == 1 ? "no" : "yes");
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 10;
const long long INF = 1e18;
const int maxn = 1e4 + 5;
const int mod = 1e9 + 7;
long long n, k, l, m;
struct matrix {
int dat[2][2];
matrix() {}
matrix(int a, int b, int c, int d) {
dat[0][0] = a, dat[0][1] = b;
dat[1][0] = c, dat[1][1] = d;
}
};
matrix operator*(const matrix &a, const matrix &b) {
matrix ret;
ret.dat[0][0] =
1LL * a.dat[0][0] * b.dat[0][0] % m + 1LL * a.dat[0][1] * b.dat[1][0] % m;
ret.dat[0][1] =
1LL * a.dat[0][0] * b.dat[0][1] % m + 1LL * a.dat[0][1] * b.dat[1][1] % m;
ret.dat[1][0] =
1LL * a.dat[1][0] * b.dat[0][0] % m + 1LL * a.dat[1][1] * b.dat[1][0] % m;
ret.dat[1][1] =
1LL * a.dat[1][0] * b.dat[0][1] % m + 1LL * a.dat[1][1] * b.dat[1][1] % m;
ret.dat[0][0] %= m, ret.dat[0][1] %= m;
ret.dat[1][0] %= m, ret.dat[1][1] %= m;
return ret;
}
matrix fast_matrix(matrix x, long long p) {
matrix ret(1, 0, 0, 1);
while (p) {
if (p & 1) ret = ret * x;
x = x * x;
p >>= 1;
}
return ret;
}
int pw(int x, long long p) {
int ret = 1;
while (p) {
if (p & 1) ret = 1LL * ret * x % m;
x = 1LL * x * x % m;
p >>= 1;
}
return ret;
}
int fib(int a, int b, long long n) {
if (n == 1)
return a;
else if (n == 2)
return b;
matrix ret = fast_matrix(matrix(0, 1, 1, 1), n - 2);
return (1LL * a * ret.dat[0][1] + 1LL * b * ret.dat[1][1]) % m;
}
int MAIN() {
scanf("%I64d%I64d%I64d%I64d", &n, &k, &l, &m);
if (l == 63) {
if (k >= (1ULL << l)) {
puts("0");
return 0;
}
} else if (l != 64) {
if (k >= (1LL << l)) {
puts("0");
return 0;
}
}
int N = l;
int discrete = fib(2, 3, n), continous = (pw(2, n) - discrete + m) % m;
int tot = 1 % m;
for (int bit = 0; bit < N; ++bit) {
long long mask = (1LL << bit);
if (k & mask) {
tot = 1LL * continous * tot % m;
} else {
tot = 1LL * discrete * tot % m;
}
}
printf("%d\n", tot);
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
cout << fixed << setprecision(16);
int ret = MAIN();
return ret;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int count = 0;
string str;
cin >> str;
for (int i = 0; i < str.size(); i++) {
if (str[i] == 'H' || str[i] == 'Q' || str[i] == '9') {
count = count + 1;
break;
}
}
if (count > 0) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
list<long long int> l[100010];
long long int a[100010];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m;
cin >> n >> m;
long long int i, x, y, ans;
bool flag;
for (i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
l[x].push_back(y);
l[y].push_back(x);
}
if (m == 0) {
ans = n - 1;
} else {
long long int mymin = INT_MAX;
for (i = 0; i < n; i++) {
if (mymin == i) {
break;
}
list<long long int>::iterator it;
for (it = l[i].begin(); it != l[i].end(); it++) {
mymin = min(*it, mymin);
}
}
flag = 1;
mymin--;
for (i = mymin + 1; i < n; i++) {
list<long long int>::iterator it;
for (it = l[i].begin(); it != l[i].end(); it++) {
if (*it > i) {
flag = 0;
break;
}
}
}
if (!flag)
ans = 0;
else {
ans = 1;
for (i = mymin;; i--) {
if (l[i].size() == 0)
ans++;
else
break;
}
}
}
cout << ans << endl;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
string a, b;
cin >> a >> b;
int has[26] = {0};
std::vector<int> v;
long long int cnt = 0;
for (long long int i = 0; i < n; i++) {
has[a[i] - 'a']++;
has[b[i] - 'a']++;
if (a[i] != b[i]) {
cnt++;
v.push_back(i);
}
}
bool flag = false;
for (long long int i = 0; i < 26; i++) {
if (has[i] % 2 == 1) {
flag = true;
break;
}
}
if (flag)
cout << "No\n";
else {
if (cnt == 0) {
cout << "Yes\n";
} else if (cnt == 2) {
if (a[v[0]] == a[v[1]] && b[v[0] == b[v[1]]])
cout << "Yes\n";
else
cout << "No\n";
} else
cout << "No\n";
}
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000006;
int n, q;
vector<vector<long long>> c;
vector<vector<int>> banned;
set<vector<int>> blocked;
long long sum[N];
long long ans = 0;
vector<int> ansv;
string getStr(vector<int>& a) {
string tmp = "";
for (int i = 0; i < (int)(n); ++i) {
tmp = tmp + to_string(a[i]) + "#";
}
return tmp;
}
void solve() {
cin >> n;
c.resize(n);
vector<int> mx;
for (int i = 0; i < (int)(n); ++i) {
int k;
cin >> k;
c[i].resize(k);
mx.push_back(k - 1);
for (int j = 0; j < (int)(k); ++j) cin >> c[i][j];
}
cin >> q;
banned.resize(q);
for (int i = 0; i < (int)(q); ++i) {
banned[i].resize(n);
for (int j = 0; j < (int)(n); ++j) {
cin >> banned[i][j];
banned[i][j]--;
sum[i] += c[j][banned[i][j]];
}
blocked.insert(banned[i]);
}
if (blocked.count(mx) == 0) {
ansv = mx;
for (int i = 0; i < (int)(n); ++i) ans += c[i].back();
}
for (int i = 0; i < (int)(q); ++i) {
for (int j = 0; j < (int)(n); ++j) {
if (banned[i][j] > 0) {
banned[i][j]--;
if (blocked.count(banned[i]) == 0 &&
ans < (sum[i] - c[j][banned[i][j] + 1] + c[j][banned[i][j]])) {
ans = (sum[i] - c[j][banned[i][j] + 1] + c[j][banned[i][j]]);
ansv = banned[i];
}
banned[i][j]++;
}
}
}
for (int x : ansv) cout << x + 1 << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(9);
solve();
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
string ans[] = {
"Washington", "Adams", "Jefferson", "Madison", "Monroe",
"Adams", "Jackson", "Van Buren", "Harrison", "Tyler",
"Polk", "Taylor", "Fillmore", "Pierce", "Buchanan",
"Lincoln", "Johnson", "Grant", "Hayes", "Garfield",
"Arthur", "Cleveland", "Harrison", "Cleveland", "McKinley",
"Roosevelt", "Taft", "Wilson", "Harding", "Coolidge",
"Hoover", "Roosevelt", "Truman", "Eisenhower", "Kennedy",
"Johnson", "Nixon", "Ford", "Carter", "Reagan"};
int a;
cin >> a;
cout << ans[a - 1];
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 2;
const int LOG = 17;
const int inf = 1e9;
int jump[LOG][maxn];
int depth[maxn];
bool red[maxn];
int tin[maxn];
int tout[maxn];
int tmr = 0;
int dist[maxn];
int nearest[maxn];
queue<int> q;
vector<int> e[maxn];
vector<int> New;
int n;
void dfs(int v, int id, int p, int h) {
if (id == 0)
jump[id][v] = p;
else
jump[id][v] = jump[id - 1][jump[id - 1][v]];
depth[v] = h;
for (int i = 0; i < (int)e[v].size(); i++)
if (e[v][i] != p) dfs(e[v][i], id, v, h + 1);
}
void dfsT(int v, int p) {
tin[v] = tmr++;
for (int i = 0; i < (int)e[v].size(); i++)
if (e[v][i] != p) dfsT(e[v][i], v);
tout[v] = tmr++;
}
inline bool pred(int v, int u) {
return tin[v] <= tin[u] && tout[u] <= tout[v];
}
inline int lca(int v, int u) {
if (pred(v, u)) return v;
if (pred(u, v)) return u;
for (int i = LOG - 1; i >= 0; i--)
if (!pred(jump[i][v], u)) v = jump[i][v];
return jump[0][v];
}
inline int len(int v, int u) {
int z = lca(v, u);
return (depth[v] - depth[z]) + (depth[u] - depth[z]);
}
void re_build() {
int v;
for (int i = 0; i < (int)New.size(); i++) red[New[i]] = 1;
New.clear();
memset(dist, 63, sizeof(dist));
for (int i = 0; i < n; i++)
if (red[i]) {
dist[i] = 0;
q.push(i);
}
while (!q.empty()) {
v = q.front();
q.pop();
for (int i = 0; i < (int)e[v].size(); i++)
if (dist[e[v][i]] > dist[v] + 1) {
dist[e[v][i]] = dist[v] + 1;
q.push(e[v][i]);
}
}
}
int main() {
int m, m_sqrt, v, u, ans, t;
scanf("%d%d", &n, &m);
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &v, &u);
v--;
u--;
e[v].push_back(u);
e[u].push_back(v);
}
for (int i = 0; i < LOG; i++) dfs(0, i, 0, 0);
dfsT(0, -1);
m_sqrt = sqrt(m * log(n));
if (m_sqrt == 0) m_sqrt++;
red[0] = 1;
re_build();
for (int i = 0; i < m; i++) {
scanf("%d%d", &t, &v);
v--;
if (t == 1) {
New.push_back(v);
if ((int)New.size() == m_sqrt) re_build();
}
if (t == 2) {
ans = dist[v];
for (int j = 0; j < (int)New.size(); j++) ans = min(ans, len(v, New[j]));
printf("%d\n", ans);
}
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int t, n, k, i, ansk;
string s, pr, sf, anss;
int main() {
ios_base::sync_with_stdio(0);
cin >> t;
while (t--) {
cin >> n >> s;
anss = s, ansk = 1;
for (k = 1; k <= n; k++) {
pr = s.substr(0, k - 1), sf = s.substr(k - 1);
if ((n - (k - 1)) & 1) reverse(pr.begin(), pr.end());
if (sf + pr < anss) {
anss = sf + pr;
ansk = k;
}
}
cout << anss << "\n" << ansk << "\n";
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i;
cin >> n;
long long int a[n], b[n];
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) cin >> b[i];
long long int dp[n + 1][2];
dp[0][0] = 0;
dp[0][1] = 0;
for (i = 1; i <= n; i++) {
dp[i][0] = max(a[i - 1] + dp[i - 1][1], dp[i - 1][0]);
dp[i][1] = max(b[i - 1] + dp[i - 1][0], dp[i - 1][1]);
}
cout << max(dp[n][0], dp[n][1]);
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
void preprocess() {}
int main() {
int n, m, a, b;
scanf("%d", &n);
;
scanf("%d", &m);
;
scanf("%d", &a);
;
scanf("%d", &b);
;
int ans = 0;
while (n >= m) {
if (b < a * m)
ans += b;
else
ans += a * m;
n -= m;
}
if (n > 0) {
if (b < a * n)
ans += b;
else
ans += a * n;
}
printf("%d\n", ans);
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int n;
int tree[300010 + 1];
int a[300010 + 1];
int get(int pos) {
int ret = 0, i;
for (i = pos; i; i -= (i & -i)) ret += tree[i];
return ret;
}
void update(int pos, int val) {
int i;
for (i = pos; i <= 300010; i += (i & -i)) tree[i] += val;
}
int vis[300010];
void rem(int val) {
int l, r;
if (get(val) - get(val - 1)) {
update(val, -1);
}
if (val != n && (get(val + 1) - get(val)) == 0) {
update(val + 1, 1);
}
}
void add(int val) {
if (val != n) {
if (vis[val + 1] > vis[val])
if (get(val + 1) - get(val)) {
update(val + 1, -1);
}
}
update(val, 1);
}
void chek(int val) {
if (val != 1) {
if (vis[val - 1] < vis[val]) {
if (get(val) - get(val - 1)) update(val, -1);
}
}
}
int main() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d\n", &a[i]);
vis[a[i]] = i;
}
vis[0] = 0;
vis[n + 1] = 0;
int now;
for (i = 1; i <= n;) {
now = i;
update(i, 1);
while (vis[now + 1] > vis[now]) now++;
i = now + 1;
}
int q, x, y;
scanf("%d", &q);
while (q--) {
scanf("%d", &i);
if (i == 1) {
scanf("%d %d", &x, &y);
int ret = get(y) - get(x - 1);
printf("%d\n", get(y) - get(x) + 1);
} else {
scanf("%d %d", &x, &y);
swap(a[x], a[y]);
x = a[x];
y = a[y];
if (x > y) swap(x, y);
rem(x);
rem(y);
swap(vis[x], vis[y]);
add(y);
add(x);
chek(y);
chek(x);
}
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
set<int> x, y;
vector<int> ans;
for (int i = 0; i < n * n; i++) {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
if (x.find(a) == x.end() && y.find(b) == y.end()) {
x.insert(a);
y.insert(b);
ans.push_back(i + 1);
}
}
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1, b1, c1, a2, b2, c2;
scanf("%d%d%d%d%d%d", &a1, &b1, &c1, &a2, &b2, &c2);
if (a1 == 0 && b1 == 0 && c1 != 0) {
puts("0");
return 0;
}
if (a2 == 0 && b2 == 0 && c2 != 0) {
puts("0");
return 0;
}
if (a1 == 0 && b1 == 0 || a2 == 0 && b2 == 0) {
puts("-1");
return 0;
}
if (a1 * b2 == a2 * b1) {
if (a1 != 0 && a1 * c2 == a2 * c1 || b1 != 0 && b1 * c2 == b2 * c1) {
puts("-1");
} else
puts("0");
} else
puts("1");
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 10;
const long long INF = 1e18;
const double eps = 0.0000001;
const long long mod = 1e9 + 7;
long long n, m;
pair<int, int> a[N];
map<int, int> maps;
void add(int x, int y) {
maps[x] += y;
if (maps[x] == 0) maps.erase(x);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long x, y, z, k, sum = 0, ans, need, cnt, exc = 0;
cin >> n >> m >> k;
ans = (n % k + m % k) >= k ? min(k - n % k, k - m % k) : 0;
cout << (n + m) / k << " " << ans << endl;
}
| 2
|
#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];
}
vector<pair<int, int>> P(n);
for (int i = 0; i < n; i++) {
P[i] = make_pair(a[i], i);
}
sort(P.rbegin(), P.rend());
vector<int> b(n);
for (int i = 0; i < n; i++) {
b[i] = P[i].first;
}
vector<vector<int>> ans(n + 1, vector<int>(n, 0));
for (int i = 0; i < n; i++) {
ans[n - 1 - i][i] = 1;
b[i]--;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= n; j++) {
if (j != n - 1 - i && j != n - i) {
if (b[i] > 0) {
ans[j][i] = 1;
b[i]--;
}
}
}
}
vector<int> p(n);
for (int i = 0; i < n; i++) {
p[P[i].second] = i;
}
cout << n + 1 << endl;
for (int i = 0; i <= n; i++) {
for (int j = 0; j < n; j++) {
cout << ans[i][p[j]];
}
cout << endl;
}
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cerr << *i << ' ';
cout << endl;
}
long long rev(long long x) {
long long res = 0;
for (; x; x /= 10) res = res * 10 + (x % 10);
return res;
}
long long gcd(long long a, long long b) { return b != 0 ? gcd(b, a % b) : a; }
pair<long long, long long> gen(long long x, int s) {
long long r = rev(x);
long long g = gcd(x, r);
x /= g;
r /= g;
if (s == 0)
return make_pair(x, r);
else
return make_pair(r, x);
}
int main() {
long long maxX, maxY, W;
while (cin >> maxX >> maxY >> W) {
map<pair<long long, long long>, int> countX, countY;
for (int x = 1; x <= maxX; x++) {
++countX[gen(x, 0)];
}
long long best = maxX * maxY + 10;
vector<int> res(2, -1);
int curW = 0;
long long y = 0;
for (int x = maxX; x >= 1 && y <= maxY;) {
if (curW >= W) {
if (best > x * y) {
best = x * y;
res[0] = x;
res[1] = y;
}
}
if (curW < W) {
y++;
++countY[gen(y, 1)];
curW += countX[gen(y, 1)];
} else {
--countX[gen(x, 0)];
curW -= countY[gen(x, 0)];
x--;
}
}
if (res[0] == -1)
cout << res[0] << endl;
else
cout << res[0] << ' ' << res[1] << endl;
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, j, dp[55][15], sum;
string st;
bool bo = 1;
int main() {
cin >> st;
for (i = 0; i <= 9; i++) dp[0][i] = 1;
for (i = 0; i < st.length() - 1; i++) {
for (j = 0; j <= 9; j++) {
dp[i + 1][(j + st[i + 1] - '0') / 2] += dp[i][j];
if ((j + st[i + 1] - '0') & 1)
dp[i + 1][(j + st[i + 1] - '0') / 2 + 1] += dp[i][j];
}
}
for (i = 0; i <= 9; i++) sum += dp[st.length() - 1][i];
for (i = 1; i < st.length(); i++) {
if (abs(st[i - 1] - st[i]) > 1) bo = 0;
}
cout << sum - bo;
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 123;
const int mod = 1e9 + 7;
const int INF = 1e9 + 1;
const long long INFL = 3e18 + 1;
const double pi = acos(-1.0);
inline void DoBetter() {
unsigned int FOR;
asm("rdtsc" : "=a"(FOR));
srand(FOR);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int n, k;
int main() {
DoBetter();
cin >> n >> k;
if (k == 0 || k == n)
cout << "0 0";
else if (k <= n / 3)
cout << "1 " << k + k;
else
cout << "1 " << n - k;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
bool compare(const pair<int, int> a, const pair<int, int> b) {
if (a.first == b.first)
return (a.second < b.second);
else
return (a.first > b.first);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
if (n % 2 == 0)
cout << -1 << '\n';
else {
vector<int> a, b, c;
set<int> st1;
set<int> st2;
for (int i = 0; i < n; ++i) {
a.push_back(i);
int j = i + 1, y;
if (j == n) j = 0;
while (1) {
if (st1.find(j) == st1.end()) {
if (j + i >= n)
y = (j + i) % n;
else
y = j + i;
if (st2.find(y) == st2.end()) {
b.push_back(j);
c.push_back(y);
st1.insert(j);
st2.insert(y);
break;
}
}
j++;
if (j == n) j = 0;
}
}
for (int i = 0; i < n; ++i) cout << a[i] << " ";
cout << '\n';
for (int i = 0; i < n; ++i) cout << b[i] << " ";
cout << '\n';
for (int i = 0; i < n; ++i) cout << c[i] << " ";
cout << '\n';
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 210000;
long long n, k;
long long f[N], g[N];
long long qpow(long long a, long long b) {
long long res = 1;
for (; b > 0; b /= 2, a = a * a % mod)
if (b % 2) res = res * a % mod;
return res;
}
void init(int m) {
f[0] = 1;
for (int i = 1; i <= n; i++) f[i] = f[i - 1] * i % mod;
for (int i = 0; i <= n; i++) g[i] = qpow(f[i], mod - 2);
return;
}
long long C(int n, int m) {
if (n < m) return 0;
return f[n] * g[m] % mod * g[n - m] % mod;
}
long long S(int n, int m) {
long long sum = 0;
for (int i = 0; i <= m - 1; i++) {
sum += qpow(mod - 1, i) * C(m, i) % mod * qpow(m - i, n) % mod;
sum %= mod;
}
return sum;
}
int main() {
scanf("%lld%lld", &n, &k);
if (k == 0) {
long long sum = 1;
for (int i = n; i >= 1; i--) sum = sum * i % mod;
printf("%lld\n", sum);
return 0;
}
if (k >= n) return printf("0\n"), 0;
int m = n - k;
init(m);
long long ans = S(n, m) * C(n, m) % mod * 2 % mod;
printf("%lld\n", ans);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int M = 5000000;
int n, m, a[N];
long long k;
vector<int> v;
struct persistent_tree {
int lson[M], rson[M], c[M], T[M];
int tot, m;
void Init(int t, int _m) {
tot = 0;
m = _m;
T[t] = bulid(1, m);
}
int bulid(int l, int r) {
int root = tot++;
c[root] = 0;
if (l != r) {
int m = (l + r) >> 1;
lson[root] = bulid(l, m);
rson[root] = bulid(m + 1, r);
}
return root;
}
int update(int root, int pos, int val) {
int newroot = tot++, tmp = newroot;
c[newroot] = c[root] + val;
int l = 1, r = m;
while (l < r) {
int mid = (l + r) >> 1;
if (pos <= mid) {
rson[newroot] = rson[root];
lson[newroot] = tot++;
newroot = lson[newroot];
root = lson[root];
r = mid;
} else {
lson[newroot] = lson[root];
rson[newroot] = tot++;
newroot = rson[newroot];
root = rson[root];
l = mid + 1;
}
c[newroot] = c[root] + val;
}
return tmp;
}
int query(int root, int l, int r, int L, int R) {
if (R < L) return 0;
if (l == L && r == R) return c[root];
int m = (l + r) >> 1;
if (R <= m)
return query(lson[root], l, m, L, R);
else if (L > m)
return query(rson[root], m + 1, r, L, R);
else
return query(lson[root], l, m, L, m) +
query(rson[root], m + 1, r, m + 1, R);
}
void insert(int now, int old, int pos, int val) {
T[now] = update(T[old], pos, val);
}
} pre, suf;
int main() {
cin >> n >> k;
v.push_back(-1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
v.push_back(a[i]);
}
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
for (int i = 1; i <= n; i++)
a[i] = lower_bound(v.begin(), v.end(), a[i]) - v.begin();
m = v.size() - 1;
pre.Init(0, m);
suf.Init(m + 1, m);
for (int i = 1; i <= n; i++) pre.insert(i, i - 1, a[i], 1);
for (int i = n; i >= 1; i--) suf.insert(i, i + 1, a[i], 1);
long long cur = 0, ans = 0;
for (int i = 1; i <= n; i++)
cur += (long long)pre.query(pre.T[i], 1, m, a[i] + 1, m);
for (int i = 1, j = 2; i <= n; i++) {
while (j <= n && cur > k) {
cur -= (long long)pre.query(pre.T[i], 1, m, a[j] + 1, m);
cur -= (long long)suf.query(suf.T[j], 1, m, 1, a[j] - 1);
j++;
}
ans += n - j + 1;
if (j == i + 1) {
cur -= (long long)pre.query(pre.T[i], 1, m, a[j] + 1, m);
cur -= (long long)suf.query(suf.T[j], 1, m, 1, a[j] - 1);
j++;
}
cur += (long long)pre.query(pre.T[i], 1, m, a[i + 1] + 1, m);
cur += (long long)suf.query(suf.T[j], 1, m, 1, a[i + 1] - 1);
}
cout << ans << endl;
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxm = 2e5 + 10;
const int maxn = 1e5 + 10;
const int N = 2e5 + 1;
int a[maxn], b[maxn], head[maxn];
int root[maxn];
struct node {
int ls, rs, flag;
long long b, k;
} tree[maxm * 15];
struct Edge {
int v, nxt;
} ed[maxm];
int ecnt, cnt;
long long anss;
long long ans[maxm];
double cross(long long k1, long long b1, long long k2, long long b2) {
double res = (1.0 * (b2 - b1)) / (1.0 * (k1 - k2));
return res;
}
void update(int L, int R, long long B, long long K, int &rt) {
int l = L - 1e5 - 1;
int r = R - 1e5 - 1;
if (!rt) {
rt = ++cnt;
tree[rt].b = B;
tree[rt].k = K;
} else {
int mid = l + r >> 1;
int MID = L + R >> 1;
long long y1 = K * l + B, y2 = K * r + B, y3 = tree[rt].k * l + tree[rt].b,
y4 = tree[rt].k * r + tree[rt].b;
if (y1 >= y3 && y2 >= y4) return;
if (y1 <= y3 && y2 <= y4) {
tree[rt].b = B;
tree[rt].k = K;
return;
}
double xx = cross(K, B, tree[rt].k, tree[rt].b);
if (y1 >= y3) {
if (xx > mid)
update(MID + 1, R, B, K, tree[rt].rs);
else {
update(L, MID, tree[rt].b, tree[rt].k, tree[rt].ls);
tree[rt].b = B;
tree[rt].k = K;
}
} else {
if (xx <= mid)
update(L, MID, B, K, tree[rt].ls);
else {
update(MID + 1, R, tree[rt].b, tree[rt].k, tree[rt].rs);
tree[rt].b = B;
tree[rt].k = K;
}
}
}
}
void merge(int &a, int b, int L, int R) {
int l = L - 1e5 - 1;
int r = R - 1e5 - 1;
int mid = l + r >> 1;
int MID = L + R >> 1;
if (!b) return;
if (!a) {
a = b;
return;
} else {
long long y1 = tree[a].k * mid + tree[a].b,
y2 = tree[b].k * mid + tree[b].b;
long long y3 = tree[a].k * l + tree[a].b, y4 = tree[b].k * l + tree[b].b;
long long y5 = tree[a].k * r + tree[a].b, y6 = tree[b].k * r + tree[b].b;
if (y3 <= y4 && y5 <= y6)
;
else if (y3 >= y4 && y5 >= y6) {
tree[a].k = tree[b].k;
tree[a].b = tree[b].b;
} else if (y1 >= y2) {
if (y3 >= y4) {
update(MID + 1, R, tree[a].b, tree[a].k, tree[a].rs);
} else
update(L, MID, tree[a].b, tree[a].k, tree[a].ls);
tree[a].k = tree[b].k;
tree[a].b = tree[b].b;
} else {
if (y3 >= y4)
update(L, MID, tree[b].b, tree[b].k, tree[a].ls);
else
update(MID + 1, R, tree[b].b, tree[b].k, tree[a].rs);
}
}
merge(tree[a].ls, tree[b].ls, L, MID);
merge(tree[a].rs, tree[b].rs, MID + 1, R);
}
void query(int rt, int L, int R, int pos) {
int l = L - 1e5 - 1;
int r = R - 1e5 - 1;
if (rt) {
anss = min(anss, tree[rt].k * pos + tree[rt].b);
}
if (l == r) return;
int mid = l + r >> 1;
int MID = L + R >> 1;
if (pos <= mid)
query(tree[rt].ls, L, MID, pos);
else
query(tree[rt].rs, MID + 1, R, pos);
}
void addedge(int u, int v) {
ed[ecnt].v = v;
ed[ecnt].nxt = head[u];
head[u] = ecnt++;
}
void dfs(int u, int fa) {
for (int i = head[u]; i != -1; i = ed[i].nxt) {
int v = ed[i].v;
if (v == fa) continue;
dfs(v, u);
merge(root[u], root[v], 1, N);
}
anss = 1e18;
query(root[u], 1, N, a[u]);
if (anss >= 1e17) anss = 0;
ans[u] = anss;
update(1, N, anss, b[u], root[u]);
}
int main() {
int n;
scanf("%d", &n);
memset(head, -1, sizeof(head));
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
dfs(1, 0);
printf("%I64d", ans[1]);
for (int i = 2; i <= n; i++) printf(" %I64d", ans[i]);
printf("\n");
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000009;
const long long INFL = 1759849216489136867ll;
const double eps = 1e-9;
void solve();
int main() {
clock_t t_start, t_end;
solve();
return 0;
}
void solve() {
int n, m;
cin >> n >> m;
vector<vector<int> > matrix(n, vector<int>(m));
vector<vector<pair<int, int> > > coordinates(n, vector<pair<int, int> >(m));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) coordinates[i][j] = make_pair(i, j);
int q;
cin >> q;
vector<pair<int, int> > buf(n);
for (int i = 0; i < q; ++i) {
int t;
scanf("%d", &t);
if (t == 1) {
int r;
scanf("%d", &r);
r--;
rotate(coordinates[r].begin(), coordinates[r].begin() + 1,
coordinates[r].end());
}
if (t == 2) {
int c;
scanf("%d", &c);
c--;
for (int j = 0; j < n; ++j) {
buf[(j - 1 + n) % n] = coordinates[j][c];
}
for (int j = 0; j < n; ++j) {
coordinates[j][c] = buf[j];
}
}
if (t == 3) {
int r, c, x;
scanf("%d%d%d", &r, &c, &x);
r--;
c--;
matrix[coordinates[r][c].first][coordinates[r][c].second] = x;
}
}
for (auto &line : matrix) {
for (auto d : line) cout << d << ' ';
cout << '\n';
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e5 + 10;
int n, x, y;
int A[Max];
int B[Max];
set<pair<int, int>, greater<pair<int, int>>> _01, _02, _10, _12, _20, _21;
set<int> ansA, ansB;
int res;
void upd(int i, int cur, int nxt) {
int a = A[i], b = B[i];
if (cur == 0) {
_01.erase(make_pair(a, i));
_02.erase(make_pair(b, i));
} else if (cur == 1) {
res -= a;
ansA.erase(i);
_10.erase(make_pair(-a, i));
_12.erase(make_pair(b - a, i));
} else {
res -= b;
ansB.erase(i);
_20.erase(make_pair(-b, i));
_21.erase(make_pair(a - b, i));
}
if (nxt == 0) {
_01.insert(make_pair(a, i));
_02.insert(make_pair(b, i));
} else if (nxt == 1) {
res += a;
ansA.insert(i);
_10.insert(make_pair(-a, i));
_12.insert(make_pair(b - a, i));
} else {
res += b;
ansB.insert(i);
_20.insert(make_pair(-b, i));
_21.insert(make_pair(a - b, i));
}
}
int main() {
cin >> n >> x >> y;
for (int i = 0; i < n; i++) cin >> A[i];
for (int i = 0; i < n; i++) cin >> B[i];
for (int i = 0; i < x; i++) {
res += A[i];
ansA.insert(i);
_10.insert(make_pair(-A[i], i));
_12.insert(make_pair(B[i] - A[i], i));
}
for (int i = x; i < x + y; i++) {
res += B[i];
ansB.insert(i);
_20.insert(make_pair(-B[i], i));
_21.insert(make_pair(A[i] - B[i], i));
}
for (int i = x + y; i < n; i++) {
_01.insert(make_pair(A[i], i));
_02.insert(make_pair(B[i], i));
}
while (true) {
bool change = false;
if (x >= 1 && y >= 1 && x + y < n) {
pair<int, int> a = *_12.begin();
pair<int, int> b = *_20.begin();
pair<int, int> c = *_01.begin();
if (a.first + b.first + c.first >= 1) {
change = true;
upd(a.second, 1, 2);
upd(b.second, 2, 0);
upd(c.second, 0, 1);
}
}
if (x >= 1 && y >= 1 && x + y < n) {
pair<int, int> a = *_21.begin();
pair<int, int> b = *_10.begin();
pair<int, int> c = *_02.begin();
if (a.first + b.first + c.first >= 1) {
change = true;
upd(a.second, 2, 1);
upd(b.second, 1, 0);
upd(c.second, 0, 2);
}
}
if (x >= 1 && x + y < n) {
pair<int, int> a = *_01.begin();
pair<int, int> b = *_10.begin();
if (a.first + b.first > 0) {
change = true;
upd(a.second, 0, 1);
upd(b.second, 1, 0);
}
}
if (y >= 1 && x + y < n) {
pair<int, int> a = *_02.begin();
pair<int, int> b = *_20.begin();
if (a.first + b.first > 0) {
change = true;
upd(a.second, 0, 2);
upd(b.second, 2, 0);
}
}
if (x >= 1 && y >= 1) {
pair<int, int> a = *_12.begin();
pair<int, int> b = *_21.begin();
if (a.first + b.first > 0) {
change = true;
upd(a.second, 1, 2);
upd(b.second, 2, 1);
}
}
if (!change) break;
}
cout << res << '\n';
for (int i : ansA) cout << i + 1 << " ";
cout << '\n';
for (int i : ansB) cout << i + 1 << " ";
cout << '\n';
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
int ans = 0;
for (int i = 1; i < 6; i++) {
for (int j = 1; j < 6; j++) {
cin >> c;
if (c == '1') ans = abs(3 - i) + abs(3 - j);
}
}
cout << ans;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int oneMatch(int a, int b, int c, int d) {
if (a == c && b != d) return a;
if (b == d && a != c) return b;
if (a == d && b != c) return a;
if (b == c && a != d) return b;
return -1;
}
int n, m, ans = 0, a1[20], a2[20], b1[20], b2[20];
int main() {
scanf("%d%d", &n, &m);
bool deduced = true;
int cnt = 0;
for (int i = 0; i < n; i++) scanf("%d%d", &a1[i], &a2[i]);
for (int i = 0; i < m; i++) scanf("%d%d", &b1[i], &b2[i]);
for (int i = 0; i < n; i++) {
int unique = 0;
for (int j = 0; j < m; j++) {
int match = oneMatch(a1[i], a2[i], b1[j], b2[j]);
if (match != -1) {
if (ans == 0)
ans = match;
else if (ans != match)
ans = -1;
if (unique == 0)
unique = match;
else if (match != unique)
deduced = false;
}
}
}
for (int i = 0; i < m; i++) {
int unique = 0;
for (int j = 0; j < n; j++) {
int match = oneMatch(b1[i], b2[i], a1[j], a2[j]);
if (match != -1) {
if (unique == 0)
unique = match;
else if (match != unique)
deduced = false;
}
}
}
if (ans != 0 && ans != -1)
printf("%d\n", ans);
else if (deduced)
printf("0\n");
else
printf("-1\n");
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAXN = (int)200 + 7;
int n, m;
int second[MAXN][MAXN];
char a[MAXN][MAXN];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
int ans = 0;
for (int i = n; i > 0; --i) {
for (int j = m; j > 0; --j) {
int cur = second[i][j];
int need = 0;
if (a[i][j] == 'W')
need = 1;
else
need = -1;
int coef = need - cur;
if (coef) {
ans++;
for (int x = 1; x <= i; x++)
for (int y = 1; y <= j; y++) second[x][y] += coef;
}
}
}
cout << ans;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
void answer() {
long long n, m, ans = 0, x1, x2, y1, y2, ans1;
cin >> n >> x1 >> x2 >> y1 >> y2;
std::vector<pair<long long, long long>> v;
for (int i = 0; i <= n; i++) v.push_back({i, 0});
for (int i = 1; i <= n; i++) v.push_back({n, i});
for (int i = 1; i <= n; i++) v.push_back({n - i, n});
for (int i = 1; i <= n - 1; i++) v.push_back({0, n - i});
for (int i = 0; i < v.size(); i++) {
if (v[i].first == x1 && v[i].second == x2) ans = i;
if (v[i].first == y1 && v[i].second == y2) ans1 = i;
}
cout << min(abs(ans1 - ans), 4 * n - abs(ans1 - ans));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int q;
answer();
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int k = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) k = k * 10 + c - '0';
return k * f;
}
int n, m;
pair<int, int> a[15], b[15];
int vis1[15][15], vis2[15][15];
int ans1[15], ans2[15];
int cmp(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first && a.second == b.second) return -1;
if (a.first != b.first && a.first != b.second && a.second != b.first &&
a.second != b.second)
return 0;
if (a.first == b.first || a.first == b.second) return 1;
return 2;
}
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) {
a[i].first = read(), a[i].second = read();
if (a[i].first > a[i].second) swap(a[i].first, a[i].second);
}
for (int i = 1; i <= m; i++) {
b[i].first = read();
b[i].second = read();
if (b[i].first > b[i].second) swap(b[i].first, b[i].second);
}
int sum = 0, sum2 = 0, sum3 = 0, sum4 = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int k = cmp(a[i], b[j]);
int w = cmp(b[j], a[i]);
if (k > 0) vis1[i][k]++;
if (w > 0) vis2[j][w]++;
}
if (vis1[i][1] == 0 && vis1[i][2] != 0) ans1[a[i].second]++;
if (vis1[i][1] != 0 && vis1[i][2] == 0) ans1[a[i].first]++;
if (vis1[i][1] > 0 && vis1[i][2] > 0) sum2++;
}
for (int i = 1; i <= m; i++) {
if (vis2[i][1] == 0 && vis2[i][2] != 0) ans2[b[i].second]++;
if (vis2[i][1] != 0 && vis2[i][2] == 0) ans2[b[i].first]++;
if (vis2[i][1] > 0 && vis2[i][2] > 0) sum4++;
}
for (int i = 1; i <= 9; i++)
if (ans1[i]) sum++;
for (int i = 1; i <= 9; i++)
if (ans2[i]) sum3++;
if (sum2 + sum4) {
puts("-1");
return 0;
}
if (sum == 1 && sum3 == 1) {
for (int i = 1; i <= n; i++) {
if (vis1[i][1]) {
printf("%d\n", a[i].first);
return 0;
}
if (vis1[i][2]) {
printf("%d\n", a[i].second);
return 0;
}
}
}
if (sum >= 1 && sum3 >= 1) puts("0");
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
const int inf = 1e8;
int dp[N], n, k, a[N];
bool isok(int x) {
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = i - 1;
for (int j = i - 1; j >= 1; j--) {
if (abs(a[j] - a[i]) <= 1ll * x * (i - j)) {
dp[i] = min(dp[i], dp[j] + i - j - 1);
}
}
}
for (int i = 1; i <= n; i++) {
if (dp[i] + n - i <= k) return 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int l = 0, r = 2e9 + 5;
while (l < r) {
int mid = ((long long)l + (long long)r) / 2;
if (isok(mid))
r = mid;
else
l = mid + 1;
}
printf("%d\n", l);
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int m, n;
cin >> m;
vector<long long> A(m);
for (int i = 0; i < m; ++i) {
cin >> A[i];
}
cin >> n;
vector<long long> B(n);
for (int j = 0; j < n; ++j) {
cin >> B[j];
}
int i = 0, j = 0;
int len = m;
bool f = true;
while (i < m && j < n) {
long long x = A[i];
long long y = B[j];
while (x != y) {
if (x < y) {
if (i + 1 < m) {
x += A[++i];
--len;
} else {
break;
}
} else {
if (j + 1 < n) {
y += B[++j];
} else {
break;
}
}
}
if (x != y) {
f = false;
break;
}
++i;
++j;
}
if (f && (i == m && j == n)) {
cout << len << "\n";
} else {
cout << -1 << "\n";
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
const long long p = 1000000007;
long long qp(long long x, long long y) {
if (y == 0) return 1;
if (y == 1) return x;
long long res = qp(x * x % p, y >> 1);
if (y & 1) res *= x, res %= p;
return res;
}
int main() {
int n = read(), m = read();
printf("%lld\n", (n + 1 - m) * qp(n + 1, m - 1) % p * qp(2, m) % p);
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 5e3 + 5, mod = 998244353;
long long int n, x, f[maxn], dp[maxn][maxn], inv[maxn];
long long int binpow(long long int base, long long int exp) {
base %= mod;
long long int answer = 1;
while (exp) {
if (exp & 1) {
answer *= base;
answer %= mod;
}
base *= base;
base %= mod;
exp /= 2;
}
return answer;
}
long long int add(long long int a, long long int b) { return (a + b) % mod; }
long long int mul(long long int a, long long int b) { return (a * b) % mod; }
long long int solve(long long int idx, long long int rem) {
if (idx == n + 1) return 0;
long long int &ans = dp[idx][rem];
if (~ans) return ans;
ans = solve(idx + 1, rem);
ans = add(ans, mul(solve(idx + 1, rem - 1), mul(f[idx], inv[rem])));
ans = add(ans, mul(mul(f[idx], inv[rem]), mul(f[idx] - 1, inv[rem - 1])));
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (long long int i = 0; i < n; i++) cin >> x, f[x]++;
for (long long int i = 0; i < maxn; i++) inv[i] = binpow(i, mod - 2);
memset(dp, -1, sizeof(dp));
cout << solve(1, n);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n != 1)
cout << 6 * n << " " << 5 * n;
else
cout << "25"
<< " "
<< "24";
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b;
cin >> a >> b;
printf("%.13f\n", ((b * b) - (a * a)) / (2 * a));
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> all;
vector<int> ori;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
all.push_back(t);
ori.push_back(t);
}
sort(all.begin(), all.end());
vector<stack<int>> res(n);
bool ok = true;
int curr = 1;
for (int i = 0; i < n; i++) {
int currval = all[i];
int hastobesame = n - currval - 1;
res[currval].push(curr);
for (int j = i + 1; j < i + hastobesame + 1; j++) {
if (all[j] != currval) {
ok = false;
} else {
res[currval].push(curr);
}
}
curr++;
i += hastobesame;
}
if (ok) {
cout << "Possible\n";
for (int i = 0; i < n; i++) {
cout << res[ori[i]].top() << " ";
res[ori[i]].pop();
}
} else {
cout << "Impossible\n";
}
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
long long ans = 0;
n--;
for (int i = 0; i < k && n > 0; i++) {
ans += 2 * n - 1;
n -= 2;
}
printf("%lld\n", ans);
return 0;
}
| 4
|
#include <bits/stdc++.h>
const long long SZ = 401010;
const long long INF = 1e18;
const long long MOD = 1000000007;
const long long mod = 998244353;
long long opnmbr = 1;
using namespace std;
void solve() {}
long long answr = 0;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
void krdiyasuru() {
long long n;
cin >> n;
long long ans = 2 * 2 * 2 * 3 * 3 * 5 * 7;
cout << n / ans << '\n';
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
{ krdiyasuru(); }
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50;
const int INF = 1234567;
int c[MAXN][MAXN], f[MAXN][MAXN], k2[MAXN][MAXN], d[MAXN], len[MAXN];
int n, k;
bool used[MAXN];
int SPFA(int s, int t, int &ret) {
queue<int> que;
fill(d, d + n, INF);
fill(len, len + n, INF);
fill(used, used + n, 0);
que.push(s);
d[s] = 0;
len[s] = 0;
used[s] = 1;
while (!que.empty()) {
int u = que.front();
que.pop();
used[u] = 0;
for (int v = 0; v < n; v++) {
if (!f[u][v] && !k2[v][u]) continue;
int cost = !(c[u][v]);
if (k2[v][u]) cost = -1;
if (d[v] > d[u] + cost || (d[v] == d[u] + cost && len[u] + 1 < len[v])) {
d[v] = d[u] + cost;
len[v] = len[u] + 1;
if (!used[v]) {
que.push(v);
used[v] = 1;
}
}
}
}
(void)0;
if (d[t] == INF) {
ret = 0;
return 0;
}
vector<int> p;
int c1 = 0;
int add = INF;
for (int v = t; v != s;) {
p.push_back(v);
(void)0;
for (int u = 0; u < n; u++) {
if (!f[u][v] && !k2[v][u]) continue;
int cost = !(c[u][v]);
if (k2[v][u]) cost = -1;
if (d[u] + cost == d[v] && len[u] + 1 == len[v]) {
if (cost == 0) add = min(add, c[u][v]);
if (cost == -1) add = min(add, k2[v][u]);
c1 += cost;
v = u;
break;
}
}
}
assert(c1 >= 0);
if (c1 > 0) add = min(add, ret / c1);
(void)0;
if (add == 0) return 0;
ret -= add * c1;
for (int u = s; u != t;) {
int v = p.back();
p.pop_back();
int cost = !(c[u][v]);
if (k2[v][u]) cost = -1;
if (cost == 0) c[u][v] -= add;
if (cost == 1) k2[u][v] += add;
if (cost == -1) k2[v][u] -= add;
u = v;
}
return add;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", f[i] + j);
c[i][j] = f[i][j];
}
}
int ans = 0;
int tmp = 0;
while ((tmp = SPFA(0, n - 1, k))) {
ans += tmp;
(void)0;
}
printf("%d\n", ans);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
const long long MOD = 4294967296;
const int MX = 100000000;
bitset<MX + 1> mrk;
int n, A, B, C, D;
long long ev(long long first) {
long long tr = (first * first) % MOD;
return (A * (tr * first) % MOD + B * tr + C * first + D) % MOD;
}
long long ct(long long base, long long cur) {
return (n / cur) - (n / (cur * base));
}
int num(int idx) { return (idx / 6) * 2 + (idx % 6 == 1 ? 0 : 1); }
int main() {
cin >> n >> A >> B >> C >> D;
for (long long i = 4; i * i <= n; ++i) {
if (mrk[num(i)] || !(i % 6 == 1 || i % 6 == 5)) continue;
for (int j = i + i; j <= n; j += i) {
if (!(j % 6 == 1 || j % 6 == 5)) continue;
mrk[num(j)] = 1;
}
}
long long all = 0;
for (int i = 2; i <= n; ++i) {
if (i != 2 && i != 3 && (!(i % 6 == 1 || i % 6 == 5))) continue;
if (i != 2 && i != 3 && mrk[num(i)]) continue;
long long e = i;
int cnt = 0;
while (e <= n) {
cnt++;
e *= i;
}
while (cnt) {
e /= i;
long long am = ct(i, e);
all = (all + ev(i) * cnt * am) % MOD;
cnt--;
}
}
cout << all << endl;
return 0;
}
| 17
|
#include <bits/stdc++.h>
int main() {
long int n, m, add, s, f, t, s1, s2, choice;
scanf("%ld %ld", &n, &m);
add = (m - 1) << 1;
while (n--) {
scanf("%ld%ld%ld", &s, &f, &t);
if (f == s) {
printf("%d\n", t);
continue;
}
s1 = s - 1;
s2 = 2 * m - 1 - s;
while (1) {
if (s1 >= t) {
choice = 1;
break;
}
s1 += add;
if (s2 >= t) {
choice = 2;
break;
}
s2 += add;
}
if (s1 == s2) choice = 2;
if (choice == 1)
t = s1;
else
t = s2;
if (choice == 1 && f > s || choice == 2 && f < s)
printf("%ld\n", t + (f - s < 0 ? s - f : f - s));
else if (choice == 2)
printf("%ld\n", t + f + s - 2);
else
printf("%ld\n", t + 2 * m - s - f);
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int abc;
mt19937 rnd(time(0));
int rd(int l, int r) {
uniform_int_distribution<> ee(l, r);
return ee(rnd);
}
const int mxn = 2e5 + 3, sq = 500;
int n, a[mxn], b[mxn], m, ee[sq][sq], ti[mxn], s[mxn];
void add(int x, int l, int t) {
if (x > m) return;
x = max(x, l);
s[x] += t;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) abc = scanf("%d%d", a + i, b + i);
for (int t = 1; t <= m; ++t) {
int o, x;
abc = scanf("%d%d", &o, &x);
if (o == 1) {
ti[x] = t;
int h = a[x] + b[x];
if (h >= sq) {
for (int e = t + a[x]; e <= m; e += h)
add(e, t, 1), add(e + b[x], t, -1);
} else {
for (int i = t + a[x]; i < t + h; ++i) ++ee[h][i % h];
}
} else {
int tt = ti[x], h = a[x] + b[x];
if (h >= sq) {
for (int e = tt + a[x]; e <= m; e += h)
add(e, t, -1), add(e + b[x], t, 1);
} else {
for (int i = tt + a[x]; i < tt + h; ++i) --ee[h][i % h];
}
}
s[t] += s[t - 1];
int re = s[t];
for (int i = 1; i < sq; ++i) re += ee[i][t % i];
printf("%d\n", re);
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const long long MM = 1e9 + 7;
const int N = 160;
int n, m;
long long F[4][N][N], S[4][N][N];
long long mod(long long x) { return (x + MM) % MM; }
void add(long long &a, long long b) { a = mod(a + b); }
void prepare_pref(long long f[N][N], long long s[N][N]) {
for (int i = 1; i <= m; i++)
for (int j = 1; j <= m; j++)
s[i][j] = mod(s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + f[i][j]);
}
long long sum(long long s[N][N], int x1, int x2, int y1, int y2) {
if (x1 > x2 || y1 > y2) return 0;
return mod(s[x2][y2] - s[x2][y1 - 1] - s[x1 - 1][y2] + s[x1 - 1][y1 - 1]);
}
void prepare_row(void) {
for (int k = 0; k < 4; k++) prepare_pref(F[k], S[k]);
}
void DP(void) {
for (int i = 1; i <= m; i++)
for (int j = i; j <= m; j++) {
F[0][i][j] = 1;
add(F[0][i][j], sum(S[0], i, j, i, j));
F[1][i][j] = 0;
add(F[1][i][j], sum(S[0], 1, i - 1, i, j));
add(F[1][i][j], sum(S[1], 1, i, i, j));
F[2][i][j] = 0;
add(F[2][i][j], sum(S[0], i, j, j + 1, m));
add(F[2][i][j], sum(S[2], i, j, j, m));
F[3][i][j] = 0;
add(F[3][i][j], sum(S[0], 1, i - 1, j + 1, m));
add(F[3][i][j], sum(S[1], 1, i, j + 1, m));
add(F[3][i][j], sum(S[2], 1, i - 1, j, m));
add(F[3][i][j], sum(S[3], 1, i, j, m));
}
}
int main() {
scanf("%d%d", &n, &m);
long long ans = 0;
for (int i = 1; i <= n; i++) {
DP();
prepare_row();
for (int k = 0; k < 4; k++) add(ans, S[k][m][m]);
}
printf("%d\n", (int)ans);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, i;
cin >> n;
int a[n], b[n], c[n];
vector<pair<int, int> > v;
for (i = 0; i < n; i++) {
cin >> a[i];
b[i] = (~a[i]);
c[i] = b[i];
}
for (i = 1; i < n; i++) {
b[i] = b[i] & b[i - 1];
}
for (i = n - 2; i >= 0; i--) {
c[i] = c[i] & c[i + 1];
}
int maxs = 0, ans, tmp;
for (i = 0; i < n; i++) {
if (i > 0) {
if (i < n - 1) {
tmp = a[i] & c[i + 1] & b[i - 1];
} else {
tmp = a[i] & b[i - 1];
}
} else {
tmp = a[i] & c[i + 1];
}
if (tmp >= maxs) {
maxs = tmp;
ans = i;
}
}
cout << a[ans] << " ";
for (i = 0; i < n; i++) {
if (i != ans) {
cout << a[i] << " ";
}
}
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 23;
const int MOD = 1e9 + 7;
string s;
string t;
char ch;
int x, ans, res = INF, n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.size();
char ch;
for (int i = 0; i < 26; i++) {
ch = 'a' + i;
t = ch + s + ch;
ans = 0;
x = 0;
for (int j = 0; j <= n + 1; j++) {
if (t[j] == ch) {
ans = max(ans, x);
x = 0;
}
x++;
}
res = min(ans, res);
}
cout << res;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
string s[12] = {"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "B", "H"};
map<string, int> m;
void init() {
for (int i = 0; i < 12; ++i) {
m[s[i]] = i;
}
}
bool cal(string a, string b, string c) {
int x = (m[b] - m[a] + 12) % 12;
int y = (m[c] - m[b] + 12) % 12;
int z = (m[c] - m[a] + 12) % 12;
if (x == 4 && y == 3 && z == 7) return 1;
return 0;
}
bool cal2(string a, string b, string c) {
int x = (m[b] - m[a] + 12) % 12;
int y = (m[c] - m[b] + 12) % 12;
int z = (m[c] - m[a] + 12) % 12;
if (x == 3 && y == 4) return 1;
return 0;
}
int main() {
init();
string a, b, c;
cin >> a >> b >> c;
if (cal(a, b, c) || cal(a, c, b) || cal(b, a, c) || cal(b, c, a) ||
cal(c, a, b) || cal(c, b, a))
puts("major");
else if (cal2(a, b, c) || cal2(a, c, b) || cal2(b, a, c) || cal2(b, c, a) ||
cal2(c, a, b) || cal2(c, b, a))
puts("minor");
else
puts("strange");
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T load() {
T r;
cin >> r;
return r;
}
template <typename T>
vector<T> loadMany(int n) {
vector<T> rs(n);
generate(rs.begin(), rs.end(), &load<T>);
return rs;
}
struct StrInt {
StrInt(const string& ref) : ref(ref) {}
int operator[](int i) const { return ref[i] - 'a'; }
int size() const { return (int)ref.size(); }
const string& ref;
};
struct Trans {
explicit Trans(int k) : k(k), tab(k, -1), rev(k, -1) {}
Trans() : tab() {}
void add(int from, int to) {
tab[from] = to;
rev[to] = from;
}
int get(int i) { return tab[i]; }
bool loose(int i) { return tab[i] == -1; }
bool free(int j) { return rev[j] == -1; }
bool anyRangeFree(int j1, int j2) {
for (auto j = j1; j <= j2; ++j)
if (free(j)) return true;
return false;
}
int findRangeFree(int j1, int j2) {
for (auto j = j1; j <= j2; ++j)
if (free(j)) return j;
return -1;
}
bool defined() { return not tab.empty(); }
void fillWithAny() {
auto j = 0;
for (auto i = 0; i < k; ++i)
if (loose(i)) {
while (not free(j)) ++j;
add(i, j);
}
}
void print() {
for (auto i = 0; i < k; ++i) cout << (char)('a' + tab[i]);
}
int k;
vector<int> tab;
vector<int> rev;
};
Trans solveA(int i, int k, StrInt s, StrInt a, Trans&& trans) {
auto n = (int)s.size();
if (trans.loose(s[i]) and trans.free(a[i]))
trans.add(s[i], a[i]);
else if (trans.loose(s[i]))
return {};
++i;
for (; i < n; ++i)
if (trans.loose(s[i]) and trans.anyRangeFree(a[i] + 1, k - 1))
return trans.add(s[i], trans.findRangeFree(a[i] + 1, k - 1)), move(trans);
else if (trans.loose(s[i]) and trans.free(a[i]))
trans.add(s[i], a[i]);
else if (trans.loose(s[i]))
return {};
else if (trans.get(s[i]) > a[i])
return move(trans);
else if (trans.get(s[i]) < a[i])
return {};
return move(trans);
}
Trans solveB(int i, int, StrInt s, StrInt b, Trans&& trans) {
auto n = (int)s.size();
if (trans.loose(s[i]) and trans.free(b[i]))
trans.add(s[i], b[i]);
else if (trans.loose(s[i]))
return {};
++i;
for (; i < n; ++i)
if (trans.loose(s[i]) and trans.anyRangeFree(0, b[i] - 1))
return trans.add(s[i], trans.findRangeFree(0, b[i] - 1)), move(trans);
else if (trans.loose(s[i]) and trans.free(b[i]))
trans.add(s[i], b[i]);
else if (trans.loose(s[i]))
return {};
else if (trans.get(s[i]) < b[i])
return move(trans);
else if (trans.get(s[i]) > b[i])
return {};
return move(trans);
}
Trans solve(int k, StrInt s, StrInt a, StrInt b) {
auto n = s.size();
auto trans = Trans(k);
auto i = 0;
for (; i < n; ++i)
if (a[i] != b[i] and trans.loose(s[i]))
break;
else if (a[i] != b[i] and
(a[i] < trans.get(s[i]) and trans.get(s[i]) < b[i]))
return trans;
else if (a[i] != b[i] and a[i] == trans.get(s[i]))
return solveA(i, k, s, a, move(trans));
else if (a[i] != b[i] and b[i] == trans.get(s[i]))
return solveB(i, k, s, b, move(trans));
else if (trans.loose(s[i]) and trans.free(a[i]))
trans.add(s[i], a[i]);
else if (trans.loose(s[i]))
return {};
else if (not(a[i] <= trans.get(s[i]) and trans.get(s[i]) <= b[i]))
return {};
if (i == n) return trans;
if (trans.anyRangeFree(a[i] + 1, b[i] - 1))
return trans.add(s[i], trans.findRangeFree(a[i] + 1, b[i] - 1)),
move(trans);
auto ans1 = solveA(i, k, s, a, Trans(trans));
if (ans1.defined()) return ans1;
auto ans2 = solveB(i, k, s, b, move(trans));
return ans2;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
auto t = load<int>();
while (t-- > 0) {
auto k = load<int>();
auto s = load<string>();
auto a = load<string>();
auto b = load<string>();
auto ans = solve(k, s, a, b);
if (ans.defined()) {
ans.fillWithAny();
cout << "YES\n";
ans.print();
cout << '\n';
} else
cout << "NO\n";
}
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int a[1000000];
bool vis[1000000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
set<int> s;
for (int i = 0; i < n; i++) cin >> a[i], s.insert(a[i]);
sort(a, a + n);
int ret = n;
for (int i = 0; i < n; i++) {
auto p = s.upper_bound(a[i]);
if (p == s.end()) continue;
if (*p - a[i] <= k) ret--;
}
cout << ret << endl;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a = n / 10;
long long r = n % 10;
if (r <= 5)
cout << a * 10 << endl;
else
cout << (a + 1) * 10 << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
const int maxn = 200010;
int n, m, k, L, R, t, countn = 0;
char s[200050];
char op[15], cc;
int rson[maxn << 2], rt[maxn << 2], lson[maxn << 2];
int tot[maxn << 2];
char b[256];
void pushup(int root) {
int ls = root << 1;
int rs = root << 1 | 1;
rson[root] = rson[rs];
lson[root] = lson[ls];
}
void build(int l, int r, int root) {
tot[root] = r - l + 1;
if (l == r) {
rson[root] = lson[root] = rt[root] = s[l];
return;
}
int mid = l + (r - l) / 2;
build(l, mid, root << 1);
build(mid + 1, r, root << 1 | 1);
pushup(root);
}
void pushdown(int root) {
if (rt[root] > 0) {
int ls = root << 1;
int rs = root << 1 | 1;
rson[rs] = lson[rs] = rt[rs] = rt[root];
rson[ls] = lson[ls] = rt[ls] = rt[root];
rt[root] = 0;
}
}
void setv(int l, int r, int root) {
if (L <= l && r <= R) {
rson[root] = lson[root] = rt[root] = cc;
return;
}
pushdown(root);
int mid = l + (r - l) / 2;
if (mid >= L) setv(l, mid, root << 1);
if (mid < R) setv(mid + 1, r, root << 1 | 1);
pushup(root);
}
int query(int l, int r, int root) {
if (rt[root] > 0 || l == r) {
return tot[root];
}
int mid = l + (r - l) / 2;
int lret = query(l, mid, root << 1);
int rret = query(mid + 1, r, root << 1 | 1);
int ret = lret + rret;
int ls = root << 1;
int rs = root << 1 | 1;
if (b[rson[ls]] < b[lson[rs]]) --ret;
return ret;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
scanf("%s", s);
int len = strlen(s);
build(0, len - 1, 1);
while (m--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &L, &R);
L--;
R--;
while ((cc = getchar()) < 'a' || cc > 'z')
;
setv(0, len - 1, 1);
} else {
scanf("%s", op);
int len1 = strlen(op);
for (int i = 0; i < len1; i++) {
b[op[i]] = i;
}
printf("%d\n", query(0, len - 1, 1));
}
}
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long infLL = 0x3f3f3f3f3f3f3f3fLL;
const int maxn = 100000 + 5;
int psz;
struct Edge {
int v, w;
Edge *next;
} pool[maxn * 2], *e[maxn];
void add_edge(int u, int v, int w) {
Edge *i = pool + psz++;
i->v = v, i->w = w, i->next = e[u];
e[u] = i;
}
int n, k;
int dis[maxn];
void dfs(int u, int f) {
for (Edge *i = e[u]; i; i = i->next) {
int v = i->v, w = i->w;
if (v == f) continue;
dfs(v, u);
dis[u] = max(dis[u], dis[v] + w);
}
}
int check(int u, int f, int up, int bound) {
multiset<int> tree;
for (Edge *i = e[u]; i; i = i->next) {
int v = i->v, w = i->w;
if (v == f) continue;
tree.insert(dis[v] + w);
}
multiset<int> brc;
for (Edge *i = e[u]; i; i = i->next) {
int v = i->v, w = i->w;
if (v == f) continue;
tree.erase(tree.find(dis[v] + w));
int down = up + w;
if (!tree.empty()) down = max(down, *tree.rbegin() + w);
int S = check(v, u, down, bound);
if (S == -1 || S == maxn) return S;
if (down <= bound) return maxn;
if (!S) {
if (dis[v] + w > bound) brc.insert(1);
} else {
brc.insert(S);
}
tree.insert(dis[v] + w);
}
if (brc.empty()) {
return 0;
} else if (brc.size() == 1) {
if (*brc.begin() + 1 > k) return -1;
return *brc.begin() + 1;
} else if (brc.size() == 2) {
if (*brc.begin() + *brc.rbegin() + 1 > k) return -1;
return up <= bound ? maxn : -1;
} else {
return -1;
}
}
int main(int argc, char *argv[]) {
scanf("%d%d", &n, &k);
int l = 0, r = 0;
for (int i = 0; i < (n - 1); ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
--u, --v, r += w;
add_edge(u, v, w);
add_edge(v, u, w);
}
dfs(0, -1);
while (l < r) {
int mid = l + (r - l) / 2;
if (~check(0, -1, 0, mid))
r = mid;
else
l = mid + 1;
}
printf("%d\n", r);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void setIO(string s = "") {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin.exceptions(cin.failbit);
if (s.size()) {
setIn(s + ".inp");
setOut(s + ".out");
} else {
}
}
} // namespace IO
using namespace IO;
namespace Function {
template <typename T1, typename T2>
void amax(T1 &a, T2 b) {
if (typeid(a).name() == typeid(int).name() &&
typeid(b).name() == typeid(long long).name()) {
cout << "Error on amax";
exit(0);
}
if (a < b) a = b;
}
template <typename T1, typename T2>
void amin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T>
void compress(vector<T> &a) {
sort(a.begin(), a.end());
a.resize(unique(a.begin(), a.end()) - a.begin());
}
template <typename T>
long long sqr(T x) {
return 1LL * x * x;
}
template <typename T1, typename T2>
long long gcd(T1 a, T2 b) {
return (b == 0 ? a : gcd(b, a % b));
}
template <typename T1, typename T2>
long long lcm(T1 a, T2 b) {
return 1LL * a / gcd(a, b) * b;
}
} // namespace Function
using namespace Function;
namespace Output {
void print(int x) { cout << x << "\n"; }
void print(unsigned int x) { cout << x << "\n"; }
void print(long unsigned int x) { cout << x << "\n"; }
void print(long long x) { cout << x << "\n"; }
void print(unsigned long long x) { cout << x << "\n"; }
void print(float x) { cout << x << "\n"; }
void print(double x) { cout << x << "\n"; }
void print(long double x) { cout << x << "\n"; }
void print(char x) { cout << x << "\n"; }
void print(const char *x) { cout << x << "\n"; }
void print(string x) { cout << x << "\n"; }
void print(bool x) { cout << x << "\n"; }
template <class T, class... Ts>
void print(T t, Ts... ts) {
cout << t << " ";
print(ts...);
}
template <typename T1, typename T2>
void print(pair<T1, T2> a) {
print(a.first, a.second);
}
template <typename T>
void print(T a) {
for (auto it : a) {
print(it);
}
}
template <class T, class... Ts>
void prine(T t, Ts... ts) {
print(t, ts...);
exit(0);
}
} // namespace Output
using namespace Output;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
const int INF = 1e9;
const long long INFL = 1e18;
const int MOD = 998244353;
const int N = 1e5 + 10;
long long dp[20][(1 << 10) + 10][3][2];
int k;
long long calc(long long n) {
if (n == 0) {
return 0;
}
string s = to_string(n);
memset(dp, 0, sizeof(dp));
dp[0][0][1][1] = 1;
for (int i = 0; i < s.size(); i++) {
for (int mask = 0; mask < (1 << 10); mask++) {
for (int sta = 0; sta < 3; sta++) {
if (dp[i][mask][sta][1] > 0) {
for (int k = (i == 0 ? 1 : 0); k < 10; k++) {
int newsta;
if (sta != 1) {
newsta = sta;
} else {
if (k < s[i] - '0') {
newsta = 0;
} else if (k > s[i] - '0') {
newsta = 2;
} else {
newsta = 1;
}
}
int new_mask = mask | (1 << k);
dp[i + 1][new_mask][newsta][0] +=
dp[i][mask][sta][0] * 10 + dp[i][mask][sta][1] * k;
dp[i + 1][new_mask][newsta][0] %= MOD;
dp[i + 1][new_mask][newsta][1] += dp[i][mask][sta][1];
dp[i + 1][new_mask][newsta][1] %= MOD;
}
}
}
}
}
long long res = 0;
for (int i = 1; i <= s.size(); i++) {
for (int mask = 1; mask < (1 << 10); mask++) {
if (__builtin_popcount(mask) > k) {
continue;
}
for (int sta = 0; sta < (i < s.size() ? 3 : 2); sta++) {
res += dp[i][mask][sta][0];
res %= MOD;
}
}
}
return res;
}
int main() {
setIO();
long long l, r;
cin >> l >> r >> k;
print((calc(r) - calc(l - 1) + MOD) % MOD);
return 0;
}
| 15
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int T;cin>>T;
while(T--){
int d,k;cin>>d>>k;
int a=d/sqrt(2);
a=a/k*k;
if(1ll*a*a+1ll*(a+k)*(a+k)<=1ll*d*d) cout<<"Ashish\n";
else cout<<"Utkarsh\n";
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
vector<int> p[maxn];
int ans, f;
void dfs(int start, int finish, int s) {
if (s > ans) {
ans = s;
f = start;
}
int i;
for (i = 0; i < (int)p[start].size(); i++) {
int to = p[start][i];
if (to != finish) {
dfs(to, start, s + 1);
}
}
}
int main() {
int n, m, i;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) p[i].clear();
for (i = 1; i <= m; i++) {
int start, finish;
scanf("%d%d", &start, &finish);
p[start].push_back(finish);
p[finish].push_back(start);
}
ans = 0;
dfs(1, 0, 0);
ans = 0;
dfs(f, 0, 0);
printf("%d\n", ans);
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T>
inline bool Min(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
inline bool Max(T &a, T b) {
return a < b ? (a = b, true) : false;
}
inline int ni() {
int a;
scanf("%d", &a);
return a;
}
inline ll nl() {
ll a;
scanf("%lld", &a);
return a;
}
inline double nd() {
double a;
scanf("%lf", &a);
return a;
}
inline void pi(int a) { printf("%d ", a); }
inline void pl(ll a) { printf("%lld ", a); }
inline void pd(double a) { printf("%.12lf ", a); }
const int N = 5005;
int n;
int a[N];
int l[N][N], r[N][N];
int cnt[N];
void solve() {
n = ni();
for (int i = 0; i < (int)(n); ++i) a[i] = ni();
for (int i = 0; i < n; i++) {
for (int j = n; j >= 0; j--) l[i][j] = l[i][j + 1] + cnt[j + 1];
cnt[a[i]]++;
}
fill(cnt, cnt + n, 0);
for (int i = n - 1; i >= 0; i--) {
for (int j = 1; j <= n; j++) r[i][j] = r[i][j - 1] + cnt[j - 1];
cnt[a[i]]++;
}
int ans = 0;
for (int i = 0; i < n; i++) ans += r[i][a[i]];
int ansCnt = 1;
int total = ans;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (a[i] < a[j]) continue;
int cur = total;
cur -= r[j][a[j]] + r[i][a[i]] + l[i][a[i]] + l[j][a[j]] - 1;
cur += r[i][a[j]] + l[i][a[j]] + r[j][a[i]] + l[j][a[i]];
if (Min(ans, cur))
ansCnt = 1;
else if (ans == cur)
ansCnt++;
}
}
cout << ans << " " << ansCnt << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
template <typename T, typename E>
struct SegmentTree {
using F = function<T(T, T)>;
using G = function<T(T, E, long long)>;
using H = function<E(E, E)>;
long long n;
vector<T> dat;
vector<E> laz;
F f;
G g;
H h;
T ti;
E ei;
SegmentTree(F f, G g, H h, T ti, E ei) : f(f), g(g), h(h), ti(ti), ei(ei) {}
void init(long long n_) {
n = 1;
while (n < n_) n <<= 1;
dat.assign((n << 1) - 1, ti);
laz.assign((n << 1) - 1, ei);
}
void build(const vector<T> &v) {
long long n_ = v.size();
init(n_);
for (long long i = (0); i < ((n_)); i++) dat[i + n - 1] = v[i];
for (long long i = n - 2; i >= 0; --i) {
dat[i] = f(dat[(i << 1) + 1], dat[(i << 1) + 2]);
}
}
void eval(long long k, long long l, long long r) {
if (laz[k] == ei) return;
dat[k] = g(dat[k], laz[k], r - l);
if (r - l > 1) {
laz[(k << 1) + 1] = h(laz[(k << 1) + 1], laz[k]);
laz[(k << 1) + 2] = h(laz[(k << 1) + 2], laz[k]);
}
laz[k] = ei;
}
void update(long long a, long long b, E x, long long k = 0, long long l = 0,
long long r = -1) {
if (r < 0) r = n;
eval(k, l, r);
if (r <= a || b <= l) return;
if (a <= l && r <= b) {
laz[k] = h(laz[k], x);
eval(k, l, r);
} else {
update(a, b, x, (k << 1) + 1, l, (l + r) / 2);
update(a, b, x, (k << 1) + 2, (l + r) / 2, r);
dat[k] = f(dat[(k << 1) + 1], dat[(k << 1) + 2]);
}
}
T query(long long a, long long b, long long k = 0, long long l = 0,
long long r = -1) {
if (r < 0) r = n;
eval(k, l, r);
if (r <= a || b <= l) return ti;
if (a <= l && r <= b) return dat[k];
T xl = query(a, b, (k << 1) + 1, l, (l + r) / 2);
T xr = query(a, b, (k << 1) + 2, (l + r) / 2, r);
return f(xl, xr);
}
long long find(long long k = 0, long long l = 0, long long r = -1) {
if (r < 0) r = n;
eval(k, l, r);
if (dat[k] >= 0) return -1;
if (r - l == 1) return l;
T xr = query((l + r) / 2, r, (k << 1) + 2, (l + r) / 2, r);
if (xr < 0) return find((k << 1) + 2, (l + r) / 2, r);
return find((k << 1) + 1, l, (l + r) / 2);
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m;
cin >> n >> m;
auto f = [](long long a, long long b) { return min(a, b); };
auto g = [](long long a, long long b, long long len) { return a + b; };
auto h = [](long long a, long long b) { return a + b; };
vector<long long> tmp(1e6 + 10, 0);
SegmentTree<long long, long long> seg(f, g, h, (1LL << 60), 0);
seg.build(tmp);
vector<long long> a(n);
for (long long i = (0); i < ((n)); i++)
cin >> a[i], seg.update(0, a[i] + 1, -1);
vector<long long> b(m);
for (long long i = (0); i < ((m)); i++)
cin >> b[i], seg.update(0, b[i] + 1, 1);
long long q;
cin >> q;
for (long long _ = (0); _ < ((q)); _++) {
long long x, y, z;
cin >> x >> y >> z, y--;
if (x == 1) {
seg.update(0, a[y] + 1, 1);
seg.update(0, z + 1, -1);
a[y] = z;
} else {
seg.update(0, b[y] + 1, -1);
seg.update(0, z + 1, 1);
b[y] = z;
}
cout << seg.find() << '\n';
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
int list[35];
int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
int main() {
int t, n, i, k;
list[0] = 1;
for (i = 1; i <= 30; i++) list[i] = list[i - 1] * 2 + 1;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (i = 1; i <= 30; i++)
if (list[i] >= n) break;
printf("%d\n", i);
int ans = i, d = 1;
for (i = 0; i < ans; i++) {
n -= d;
k = min(n / (ans - i), d * 2);
printf("%d ", k - d);
d = k;
}
printf("\n");
}
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
class DSU {
private:
long long n;
long long *id;
long long *w;
long long *mm;
long long *arr;
public:
DSU(long long n, long long arr[]) {
this->n = n;
id = new long long[n + 1];
w = new long long[n + 1];
mm = new long long[n + 1];
this->arr = arr;
for (long long i = 0; i <= n; i++) {
id[i] = i;
w[i] = 1;
mm[i] = arr[i];
}
}
long long root(long long n) {
while (n != id[n]) {
id[n] = id[id[n]];
n = id[n];
}
return n;
}
void unite(long long a, long long b) {
long long aroot = root(a);
long long broot = root(b);
if (aroot == broot) return;
if (w[aroot] < w[broot]) {
id[aroot] = broot;
w[broot] += w[aroot];
mm[broot] = min(mm[broot], mm[aroot]);
} else {
id[broot] = aroot;
w[aroot] += w[broot];
mm[aroot] = min(mm[broot], mm[aroot]);
}
}
long long ans(long long deepshri[], long long m) {
long long answer = 0;
for (long long i = 0; i < m; i++) {
answer += mm[root(deepshri[i])];
}
return answer;
}
};
int main() {
long long t, k, m;
cin >> t >> k >> m;
map<string, long long> mp;
long long arr[t];
for (long long i = 0; i < t; i++) {
string s;
cin >> s;
mp[s] = i;
}
for (long long i = 0; i < t; i++) cin >> arr[i];
DSU dsu(t, arr);
for (long long i = 0; i < k; i++) {
long long nums;
cin >> nums;
long long ar[nums];
cin >> ar[0];
dsu.unite(ar[0] - 1, ar[0] - 1);
for (long long i = 1; i < nums; i++) {
cin >> ar[i];
dsu.unite(ar[i] - 1, ar[i - 1] - 1);
}
}
long long deepshri[m];
for (long long i = 0; i < m; i++) {
string s;
cin >> s;
deepshri[i] = mp[s];
}
cout << dsu.ans(deepshri, m);
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int a, b;
int l, h;
int cost;
bool operator<(Edge o) const {
if (a != o.a) {
return a < o.a;
}
if (b != o.b) {
return b < o.b;
}
return 0;
}
};
Edge edge[20];
int numEdge;
int n;
int minFlow;
int maxCost;
int flowVertex[7];
int flowEdge[20];
int getCost() {
int ret = 0;
for (int i = 0; i < numEdge; i++) {
if (flowEdge[i] != 0) {
ret += edge[i].cost;
ret += flowEdge[i] * flowEdge[i];
}
}
return ret;
}
void debug() {
cerr << "vertex flow : ";
for (int i = 1; i <= n; i++) {
cerr << flowVertex[i] << " ";
}
cerr << endl;
cerr << "edge flow : " << endl;
for (int i = 0; i < numEdge; i++) {
cerr << edge[i].a << "->" << edge[i].b << " (" << edge[i].cost << ") "
<< flowEdge[i] << endl;
}
cerr << getCost() << endl;
}
void DFS(int depth) {
if (depth == numEdge) {
if (flowVertex[n - 1] != 0 || flowVertex[n] == 0) {
return;
}
if (minFlow > flowVertex[n]) {
minFlow = flowVertex[n];
maxCost = getCost();
} else if (minFlow == flowVertex[n]) {
maxCost = max(maxCost, getCost());
}
} else {
int curVertex = edge[depth].a;
int nxtVertex = edge[depth].b;
if (curVertex == 1) {
for (int f = edge[depth].l; f <= edge[depth].h; f++) {
flowEdge[depth] = f;
flowVertex[nxtVertex] += f;
DFS(depth + 1);
flowVertex[nxtVertex] -= f;
}
} else {
if (flowVertex[curVertex - 1] != 0) {
return;
}
for (int f = edge[depth].l;
f <= edge[depth].h && f <= flowVertex[curVertex]; f++) {
flowEdge[depth] = f;
flowVertex[nxtVertex] += f;
flowVertex[curVertex] -= f;
DFS(depth + 1);
flowVertex[nxtVertex] -= f;
flowVertex[curVertex] += f;
}
}
}
}
bool specialCase() {
int ans = 0;
for (int i = 0; i < numEdge; i++) {
if (edge[i].l != 0) {
return false;
}
}
puts("0 0");
return true;
}
int main() {
while (scanf("%d", &n) != EOF) {
numEdge = n * (n - 1) / 2;
for (int i = 0; i < numEdge; i++) {
scanf("%d%d%d%d%d", &edge[i].a, &edge[i].b, &edge[i].l, &edge[i].h,
&edge[i].cost);
}
if (specialCase()) {
continue;
}
sort(edge, edge + numEdge);
maxCost = 0;
minFlow = 99999999;
memset(flowEdge, 0, sizeof(flowEdge));
memset(flowVertex, 0, sizeof(flowVertex));
DFS(0);
if (maxCost == 0) {
puts("-1 -1");
} else {
printf("%d %d\n", minFlow, maxCost);
}
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
inline int Getint() {
int Ret = 0;
char Ch = ' ';
bool Flag = 0;
while (!(Ch >= '0' && Ch <= '9')) {
if (Ch == '-') Flag ^= 1;
Ch = getchar();
}
while (Ch >= '0' && Ch <= '9') {
Ret = Ret * 10 + Ch - '0';
Ch = getchar();
}
return Flag ? -Ret : Ret;
}
int n, m;
inline void Input() { cin >> n >> m; }
inline void Solve() {
if (m == 3 && n > 4)
cout << -1 << endl;
else {
for (int i = 1; i <= m; i++) cout << i << ' ' << i * i + 100000 << endl;
for (int i = 1; i <= n - m; i++) cout << i << ' ' << -i * i << endl;
}
}
int main() {
Input();
Solve();
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
void fastio() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
int main() {
fastio();
long long int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long int x, f;
cin >> x >> f;
long long int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= (x + f)) {
ans += f * (a[i] / (x + f));
}
if (a[i] % (x + f) > x) ans += f;
}
cout << ans << "\n";
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios::sync_with_stdio(0);
solve();
return 0;
}
int R;
vector<pair<int, int> > head, tail;
int H[300][300];
int Dp(pair<int, int> u) {
if (u.first + u.second > R) return 0;
if (H[u.first][u.second] != -1) return H[u.first][u.second];
int& r = H[u.first][u.second] = 0;
int lim = min(u.first, (int)((head).size()));
for (int i = 0; i < lim; i++) {
pair<int, int> v(u.first - i - 1 + head[i].first,
u.second + head[i].second);
r = max(r, Dp(v) + 1);
}
lim = min(u.second, (int)((tail).size()));
for (int i = 0; i < lim; i++) {
pair<int, int> v(u.first + tail[i].first,
u.second - i - 1 + tail[i].second);
r = max(r, Dp(v) + 1);
}
return r;
}
void dfs(pair<int, int> u) {
H[u.first][u.second] = 1;
int lim = min(u.first, (int)((head).size()));
for (int i = 0; i < lim; i++) {
pair<int, int> v(u.first - i - 1 + head[i].first,
u.second + head[i].second);
if (v.first + v.second > R) continue;
if (H[v.first][v.second] == 1) {
cout << "Draw\n";
exit(0);
}
if (H[v.first][v.second] == 0) dfs(v);
}
lim = min(u.second, (int)((tail).size()));
for (int i = 0; i < lim; i++) {
pair<int, int> v(u.first + tail[i].first,
u.second - i - 1 + tail[i].second);
if (v.first + v.second > R) continue;
if (H[v.first][v.second] == 1) {
cout << "Draw\n";
exit(0);
}
if (H[v.first][v.second] == 0) dfs(v);
}
H[u.first][u.second] = 2;
}
void solve() {
int h, t;
cin >> h >> t >> R;
int N;
cin >> N;
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
head.push_back(pair<int, int>(a, b));
}
int M;
cin >> M;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
tail.push_back(pair<int, int>(a, b));
}
memset(H, -1, sizeof(H));
H[h][t] = 0;
deque<pair<int, int> > Q;
Q.push_back(pair<int, int>(h, t));
while (!Q.empty()) {
pair<int, int> u = Q.front();
Q.pop_front();
int h = H[u.first][u.second] + 1;
int lim = min(u.first, (int)((head).size()));
for (int i = 0; i < lim; i++) {
pair<int, int> v(u.first - i - 1 + head[i].first,
u.second + head[i].second);
if (v.first + v.second > R) continue;
if (H[v.first][v.second] == -1) {
H[v.first][v.second] = h;
Q.push_back(v);
}
}
lim = min(u.second, (int)((tail).size()));
for (int i = 0; i < lim; i++) {
pair<int, int> v(u.first + tail[i].first,
u.second - i - 1 + tail[i].second);
if (v.first + v.second > R) continue;
if (H[v.first][v.second] == -1) {
H[v.first][v.second] = h;
Q.push_back(v);
}
}
}
if (H[0][0] != -1) {
cout << "Ivan\n";
cout << H[0][0] << '\n';
return;
}
memset(H, 0, sizeof(H));
dfs(make_pair(h, t));
memset(H, -1, sizeof(H));
cout << "Zmey\n";
cout << Dp(make_pair(h, t)) << '\n';
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int used[1010];
int ans[1010][1010];
int h[1010];
int n;
int cur;
void solve() {
int ma = 0;
for (int i = (int)(0); i < (int)(n); ++i) {
if (!used[i]) ma = max(h[i], ma);
}
if (ma == 0) return;
vector<int> ms;
for (int i = (int)(0); i < (int)(n); ++i) {
if (!used[i] && h[i] == ma) ms.push_back(i);
}
for (int j = (int)(0); j < (int)(ms.size()); ++j) {
for (int i = (int)(0); i < (int)(ma); ++i) {
ans[(cur - i - j + 2 * cur + 1) % (cur + 1)][ms[j]] = 1;
}
}
for (int i = (int)(0); i < (int)(ms.size()); ++i) used[ms[i]] = 1;
cur = cur - ms.size();
for (int i = (int)(0); i < (int)(n); ++i) {
if (!used[i] && h[i] > cur) {
for (int j = (int)(0); j < (int)(h[i] - cur); ++j)
ans[j + cur + 1][i] = 1;
h[i] = cur;
}
}
solve();
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
for (int i = (int)(0); i < (int)(n); ++i) cin >> h[i];
cur = n;
solve();
cout << n + 1 << endl;
for (int i = (int)(0); i < (int)(n + 1); ++i) {
for (int j = (int)(0); j < (int)(n); ++j) cout << ans[i][j];
cout << '\n';
}
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
struct point {
double x, y;
} C, A, ans;
int dcmp(double u) {
if (fabs(u) <= eps)
return 0;
else
return u > eps ? 1 : -1;
}
double R;
double dis(point a, point b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
int main() {
scanf("%lf%lf%lf%lf%lf", &R, &C.x, &C.y, &A.x, &A.y);
if (dcmp(C.x - A.x) == 0 && dcmp(C.y - A.y) == 0) {
double xb = (2 * C.x + R) / 2, yb = C.y;
printf("%.7lf %.7lf %.7lf", xb, yb, R / 2);
} else if (dcmp(R - dis(A, C)) <= 0) {
printf("%.7lf %.7lf %.7lf", C.x, C.y, R);
} else {
double ans = (R + dis(A, C)) / 2, tmp = dis(A, C), d = ans / tmp;
double xb = d * (C.x - A.x) + A.x, yb = d * (C.y - A.y) + A.y;
printf("%.7lf %.7lf %.7lf", xb, yb, ans);
}
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long p = 1000000007;
const unsigned int D = 29;
unsigned long long sum[50010][30];
unsigned int a[50010], l[50010], r[50010], key[50010];
unsigned int l0[50010], r0[50010], key0[50010], x[50010];
unsigned int n, m, tot, tot0;
int find(int l, int r, int x) {
int mid;
if (l > r) return 0;
mid = (l + r) / 2;
if (key[mid] == x) return mid;
if (key[mid] > x) return find(l, mid - 1, x);
if (key[mid] < x) return find(mid + 1, r, x);
}
int main() {
unsigned long long ans, S, S1, S2;
unsigned int h, t, mid, num, X;
int i, j, k;
scanf("%u%u", &n, &m);
for (i = 1; i <= n; i++) scanf("%u", &a[i]);
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++)
for (j = 0; j <= D; j++)
sum[i][j] = sum[i - 1][j] + ((a[i] & (1 << j)) >> j);
tot = 1;
ans = 0;
l[1] = 1;
r[1] = n;
key[1] = 0;
X = 0;
for (i = D; i >= 0; i--) {
tot0 = 0;
for (j = 1; j <= tot; j++) {
if (a[l[j]] & (1 << i)) {
tot0++;
l0[tot0] = l[j];
r0[tot0] = r[j];
key0[tot0] = key[j] + (1 << i);
} else if ((a[r[j]] & (1 << i)) == 0) {
tot0++;
l0[tot0] = l[j];
r0[tot0] = r[j];
key0[tot0] = key[j];
} else {
h = l[j];
t = r[j];
while (h < t) {
mid = (h + t) / 2;
if (a[mid] & (1 << i))
t = mid;
else
h = mid + 1;
}
tot0++;
l0[tot0] = l[j];
r0[tot0] = h - 1;
key0[tot0] = key[j];
tot0++;
l0[tot0] = h;
r0[tot0] = r[j];
key0[tot0] = key[j] + (1 << i);
}
}
tot = tot0;
memcpy(l, l0, sizeof(l0));
memcpy(r, r0, sizeof(r0));
memcpy(key, key0, sizeof(key0));
S = 0;
num = 0;
for (j = 1; j <= tot; j++) {
x[j] = find(1, tot, key[j] ^ (X + (1 << i)));
if (x[j]) num += (r[x[j]] - l[x[j]] + 1) * (r[j] - l[j] + 1);
}
if (num / 2 < m) {
for (j = 1; j <= tot; j++)
if (x[j])
for (k = i - 1; k >= 0; k--) {
S1 = (sum[r[x[j]]][k] - sum[l[x[j]] - 1][k]) *
(r[j] - l[j] + 1 - sum[r[j]][k] + sum[l[j] - 1][k]);
S2 =
(sum[r[j]][k] - sum[l[j] - 1][k]) *
(r[x[j]] - l[x[j]] + 1 - sum[r[x[j]]][k] + sum[l[x[j]] - 1][k]);
S = (S + (S1 + S2) * (1 << k)) % p;
}
S = (S + (long long)(X + (1 << i)) * num) % p;
ans = (ans + S) % p;
m -= num / 2;
} else
X += 1 << i;
}
ans = (ans + (long long)X * m * 2) % p;
printf("%I64u\n", (ans * 500000004) % p);
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e5 + 100;
vector<int> v1[MN];
vector<int> v2[MN];
vector<int> group;
bool used1[MN];
bool used2[MN];
bool used3[MN];
void findGroup(int x) {
used1[x] = 1;
group.push_back(x);
for (auto y : v1[x]) {
if (!used1[y]) {
findGroup(y);
}
}
}
int findCycle(int x) {
used2[x] = 1;
used3[x] = 1;
for (auto y : v2[x]) {
if (used3[y]) return 1;
if (!used2[y]) {
if (findCycle(y)) return 1;
}
}
used3[x] = 0;
return 0;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int q, w;
cin >> q >> w;
--q, --w;
v1[q].push_back(w);
v1[w].push_back(q);
v2[q].push_back(w);
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (!used1[i]) {
group.clear();
findGroup(i);
if (group.size() == 1) continue;
for (int j = 0; j < group.size(); ++j) {
if (!used2[group[j]]) {
if (findCycle(group[j])) goto lol;
}
}
ans += group.size() - 1;
continue;
lol:;
ans += group.size();
}
}
cout << ans << '\n';
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long double eps = 1e-6;
int32_t main() {
cout << fixed << setprecision(15);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long double l = -inf, r = inf;
long double fueled = 0;
long double last_station = 0;
for (long long i = 0; i < n; ++i) {
fueled += 1;
long double station;
cin >> station;
station *= 10;
last_station = station;
l = max(l, station / fueled);
r = min(r, (station + (long double)(10)) / fueled);
}
r -= eps;
l = (fueled + 1) * l - last_station;
r = (fueled + 1) * r - last_station;
last_station /= 10;
l /= 10;
r /= 10;
l = floor(l);
r = floor(r);
if (r - l >= 1) {
cout << "not unique\n";
} else {
cout << "unique\n";
cout << (long long)(last_station + l) << "\n";
}
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300000 + 5;
const int INF = 0x3f3f3f3f;
int n, c[N];
int colormax[N], colormin[N], colormax1[N], colormax2[N];
int main() {
scanf("%d", &n);
memset(colormin, 0x3f, sizeof(colormin));
for (register int i = 1; i <= n; i++)
scanf("%d", &c[i]), colormax[c[i]] = max(colormax[c[i]], i),
colormin[c[i]] = min(colormin[c[i]], i);
if (c[1] != c[n]) {
cout << n - 1;
return 0;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (i == c[1]) continue;
ans = max(ans, colormax[i] - 1);
}
for (int i = 1; i <= n; i++) {
if (i == c[n]) continue;
ans = max(ans, n - colormin[i]);
}
cout << ans;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
long long g(int n) {
bool first = 1;
long long res = 0;
long long mul = 1;
while (n) {
int v = min(first ? 8 : 9, n);
res += mul * v;
n -= v;
first = 0;
mul *= 10;
}
return res;
}
const int M = 18;
const long long inf = 1e18;
long long solve(int a, int b, int n) {
int top = 0;
long long mul = 1;
long long res = 1e18;
for (int i = 0; i < M; ++i) {
int dem = a + b;
int num = n - b - a * top;
if (num >= 0 && num % dem == 0) {
long long tans = g(num / dem);
tans *= mul;
tans += mul - 1;
res = min(res, tans);
}
top += 9;
mul *= 10;
}
return res;
}
long long ans(int n, int k) {
long long res = inf;
for (int i = 0; i < 10; ++i) {
int a = 0, b = 0;
int tsum = 0;
for (int j = 0; j < k + 1; ++j) {
if (i + j >= 10)
++b;
else
++a;
tsum += (i + j) % 10;
}
long long tans = solve(a, b, n - tsum);
if (tans != inf) tans = 10 * tans + i;
res = min(res, tans);
}
if (res == inf) res = -1;
return res;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
cout << ans(n, k) << '\n';
}
}
| 14
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
void solve() {
int n;
cin >> n;
if (n & 1) {
cout << "Second" << endl;
vector<vector<int>> pairs(n);
vector<vector<int>> loc(n);
for (int i = 0; i < 2 * n; i++) {
int x;
cin >> x;
x--;
pairs[x].push_back(i + 1);
loc[(i + 1) % n].push_back(x);
}
set<int> unused_pairs, unused_nums;
for (int i = 0; i < n; i++) unused_pairs.insert(i);
for (int i = 0; i < n; i++) unused_nums.insert(i);
set<int> ans;
ans.insert(pairs[0][0]);
unused_pairs.erase(0);
unused_nums.erase(pairs[0][0] % n);
int next = pairs[0][1] % n;
for (int i = 0; i < n - 1; i++) {
if (unused_nums.find(next) == unused_nums.end()) {
int a = *unused_pairs.begin();
ans.insert(pairs[a][0]);
unused_pairs.erase(a);
unused_nums.erase(pairs[a][0] % n);
next = pairs[a][1] % n;
} else {
vector<int> a = loc[next];
int b = a[0];
if (unused_pairs.find(a[0]) == unused_pairs.end()) {
b = a[1];
}
int c = pairs[b][0] % n == next ? 0 : 1;
ans.insert(pairs[b][c]);
unused_pairs.erase(b);
unused_nums.erase(pairs[b][c] % n);
next = pairs[b][1 - c] % n;
}
}
int sum = 0;
for (int i : ans) {
sum = (sum + i) % (2 * n);
}
if (sum == 0) {
for (int i : ans) cout << i << " ";
} else {
for (int i = 1; i <= 2 * n; i++) {
if (ans.find(i) == ans.end()) cout << i << " ";
}
}
cout << endl;
} else {
cout << "First" << endl;
for (int i = 0; i < 2; i++) {
for (int j = 1; j <= n; j++) {
cout << j << " ";
}
}
cout << endl;
}
int x;
cin >> x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
long long const MOD = 1e9 + 7;
int n;
map<pair<string, int>, vector<pair<string, int>>> g;
set<pair<string, int>> answer;
map<string, int> used;
queue<pair<string, int>> q;
pair<string, int> start;
void go() {
vector<pair<string, int>> tmp;
while (!q.empty()) {
tmp.push_back(q.front());
q.pop();
}
map<string, int> localUsed;
for (int i = 0; i < tmp.size(); i++) {
vector<pair<string, int>> temporary = g[tmp[i]];
for (int j = 0; j < temporary.size(); j++) {
if (!used[temporary[j].first]) {
int v1, v2;
v1 = localUsed[temporary[j].first];
v2 = temporary[j].second;
localUsed[temporary[j].first] = max(v1, v2);
}
}
}
map<string, int>::iterator it = localUsed.begin();
for (; it != localUsed.end(); it++) {
pair<string, int> elem = {it->first, it->second};
used[it->first] = 1;
q.push(elem);
answer.insert(elem);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
string t;
int aa;
for (int i = 0; i < n; i++) {
int tmp;
cin >> t >> aa >> tmp;
if (!i) start = {t, aa};
for (int j = 0; j < tmp; j++) {
string t1;
int b;
cin >> t1 >> b;
g[{t, aa}].push_back({t1, b});
}
}
q.push(start);
used[start.first] = 1;
while (!q.empty()) go();
set<pair<string, int>>::iterator it = answer.begin();
cout << answer.size() << endl;
for (; it != answer.end(); it++)
cout << it->first << " " << it->second << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
void solution() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a.begin(), a.end());
for (int i = 1; i < n; ++i) {
if (a[i] == a[i - 1]) {
cout << "YES\n";
return;
}
}
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
solution();
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q, m;
string s;
char c;
cin >> n >> s;
int k[26][1501] = {}, dp[26][1501] = {};
for (int i = 0; i < 26; i++)
for (int j = 0; j < n; j++)
k[i][j] = (s[j] - 'a' == i ? 0 : 1) + (j == 0 ? 0 : k[i][j - 1]);
for (int i = 0; i < 26; i++)
for (int j1 = 0; j1 < n; j1++)
for (int j2 = j1; j2 < n; j2++) {
int t = k[i][j2] - (j1 == 0 ? 0 : k[i][j1 - 1]);
dp[i][t] = max(dp[i][t], j2 - j1 + 1);
}
for (int i = 0; i < 26; i++)
for (int j = 0; j <= n; j++)
dp[i][j] = max(dp[i][j], (j == 0 ? 0 : dp[i][j - 1]));
cin >> q;
while (q--) {
cin >> m >> c;
printf("%d\n", dp[c - 'a'][m]);
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e6 + 10;
long long mn[Max * 4], mx[Max * 4], sum[Max * 4], sz[Max * 4], lazy[Max * 4];
vector<pair<long long, pair<long long, long long> > > A;
long long Y[Max], Z[Max];
void build(long long tl = 1, long long tr = Max, long long idx = 1) {
lazy[idx] = -1;
sz[idx] = tr - tl;
if (tr - tl == 1) return;
long long mid = (tl + tr) / 2;
build(tl, mid, idx * 2);
build(mid, tr, idx * 2 + 1);
}
void put(long long idx, long long x) {
mx[idx] = mn[idx] = x;
sum[idx] = x * sz[idx];
lazy[idx] = x;
}
void shift(long long idx) {
if (lazy[idx] == -1) return;
put(idx * 2, lazy[idx]);
put(idx * 2 + 1, lazy[idx]);
lazy[idx] = -1;
}
void upd(long long r, long long x, long long tl = 1, long long tr = Max,
long long idx = 1) {
if (mn[idx] >= x) return;
if (tl >= r) return;
if (tr <= r && mx[idx] <= x) {
put(idx, x);
return;
}
long long mid = (tl + tr) / 2;
shift(idx);
upd(r, x, tl, mid, idx * 2);
upd(r, x, mid, tr, idx * 2 + 1);
sum[idx] = sum[idx * 2] + sum[idx * 2 + 1];
mn[idx] = min(mn[idx * 2], mn[idx * 2 + 1]);
mx[idx] = max(mx[idx * 2], mx[idx * 2 + 1]);
}
long long get(long long l, long long r, long long x, long long tl = 1,
long long tr = Max, long long idx = 1) {
if (mx[idx] <= x) return 0;
if (tr <= l || r <= tl) return 0;
if (l <= tl && tr <= r && mn[idx] >= x) return sum[idx] - x * sz[idx];
long long mid = (tl + tr) / 2;
shift(idx);
return get(l, r, x, tl, mid, idx * 2) + get(l, r, x, mid, tr, idx * 2 + 1);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
build();
long long n, x, y, z;
cin >> n >> x >> y >> z;
for (long long i = 1; i <= n; i++) {
long long X, Y, Z;
cin >> X >> Y >> Z;
A.push_back(make_pair(X, make_pair(Y, Z)));
}
sort(A.begin(), A.end());
long long ANS = 0;
Y[x + 1] = Z[x + 1] = 0;
for (long long chk = x, j = n - 1; chk >= 1; chk--) {
Y[chk] = Y[chk + 1], Z[chk] = Z[chk + 1];
while (j >= 0 && A[j].first >= chk)
Y[chk] = max(Y[chk], A[j].second.first),
Z[chk] = max(Z[chk], A[j].second.second), j--;
}
for (long long chk = 1, j = 0; chk <= x; chk++) {
while (j < n && A[j].first < chk) {
upd(A[j].second.first + 1, A[j].second.second);
j++;
}
if (Y[chk] < y && Z[chk] < z) {
ANS += (z - Z[chk]) * (y - Y[chk]) - get(Y[chk] + 1, Max, Z[chk]);
}
}
cout << ANS << '\n';
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 42;
long long need[N];
int a[N], ans[N];
long long n, m;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i <= n; i++) {
long long l = 0, r = 1e15;
if (i) r = need[i - 1];
while (l < r) {
long long mid = (l + r) / 2;
int am = 0;
long long csum = 0;
multiset<int> cur;
for (int j = 0; j < n; j++) {
csum += a[j];
cur.insert(a[j]);
while (csum + mid < 0) {
csum -= *cur.begin();
cur.erase(cur.begin());
am++;
}
}
if (am <= i)
r = mid;
else
l = mid + 1;
}
need[i] = l;
}
vector<pair<long long, long long> > q(m);
for (int i = 0; i < m; i++) {
cin >> q[i].first;
q[i].second = i;
}
sort((q).rbegin(), (q).rend());
int cpos = 0;
for (int i = 0; i < m; i++) {
while (q[i].first < need[cpos]) cpos++;
ans[q[i].second] = cpos;
}
for (int i = 0; i < m; i++) printf("%lld\n", ans[i]);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int t = power(a, b / 2, m);
t = (t * t) % m;
if (b & 1) t = (t * a) % m;
return t;
}
long long int modInverse(long long int a, long long int m) {
return power(a, m - 2, m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, i, j, k, l, w;
cin >> n >> w;
long long int ar[n], sm[n + 1];
sm[0] = 0;
for (i = 0; i < n; i++) {
cin >> ar[i];
}
for (i = 0; i < n; i++) {
sm[i + 1] = sm[i] + ar[i];
}
long long int mx = 0, mn = 0;
for (i = 1; i <= n; i++) {
if (sm[i] < mn) mn = sm[i];
if (sm[i] > mx) mx = sm[i];
}
long long int a, b;
a = (w - mx);
b = abs(mn);
if ((a - b + 1) > 0) {
cout << (a - b + 1) << endl;
} else
cout << "0";
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[5][5];
int i, j;
for (i = 0; i < 4; i++) {
scanf("%s", s[i]);
}
int f = 0;
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
int sum = 0;
if (s[i][j] == '#') sum++;
if (s[i + 1][j] == '#') sum++;
if (s[i][j + 1] == '#') sum++;
if (s[i + 1][j + 1] == '#') {
sum++;
}
if (sum != 2) {
f = 1;
break;
}
}
if (f == 1) break;
}
if (f)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e3 + 5, mod = 1e9 + 7;
long long int dp[2 * N][2 * N];
long long int n;
long long int solve(long long int i, long long int c) {
if (c < 0) return 0;
if (i == 2 * n) {
if (c == 0)
return 1;
else
return 0;
}
if (dp[i][c] == -1) {
dp[i][c] = 0;
dp[i][c] += solve(i + 1, c + 1);
dp[i][c] += solve(i + 1, c - 1);
dp[i][c] %= mod;
}
return dp[i][c];
}
int main() {
cin >> n;
memset(dp, -1, sizeof(dp));
long long int t = solve(0, 0);
long long int ans = 0;
long long int p = 1;
for (long long int i = 2 * n - 1; i >= 0; i--) {
long long int c = 0;
for (long long int j = 0; j < N - 1; ++j) {
if (dp[i][j] == -1) dp[i][j] = 0;
c += dp[i][j];
c %= mod;
}
if (i % 2 == 0) {
ans += p;
ans %= mod;
}
p = c;
}
cout << ans % mod << "\n";
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
string s;
cin >> s;
int contA = 0, contI = 0, contF = 0;
for (int i = 0; i < N; i++) {
if (s[i] == 'A') contA++;
if (s[i] == 'I') contI++;
if (s[i] == 'F') contF++;
}
if (contI <= 1) {
if (contI == 1)
cout << 1 << endl;
else
cout << contA << endl;
} else {
cout << 0 << endl;
}
return 0;
}
| 2
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.