solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
struct node {
int x, l, r, t;
node(int x = 0, int l = 0, int r = 0, int t = 0) : x(x), l(l), r(r), t(t) {}
bool operator<(const node& a) const { return x < a.x; }
} a[N];
int tag[N * 60], sm[N * 60], lc[N * 60], rc[N * 60], q1, q2, q3, clk;
void ps(int o, int l, int r) {
if (tag[o])
sm[o] = (l - 1) ^ r;
else
sm[o] = sm[lc[o]] ^ sm[rc[o]];
}
void modify(int& o, int l, int r) {
if (!o) o = ++clk;
if (q1 <= l && r <= q2) {
tag[o] += q3;
return ps(o, l, r);
}
int mid = (l + r) / 2;
if (q1 <= mid) modify(lc[o], l, mid);
if (q2 > mid) modify(rc[o], mid + 1, r);
ps(o, l, r);
}
int rt, ans, K;
void solve(int l, int r) {
int tmp = ((l - 1) ^ r) & sm[rt];
for (int i = 0; i < 30; ++i)
if (tmp >> i & 1) {
ans ^= min(K, 1 << i);
if (i) ans ^= min(K, 1 << (i - 1));
}
}
int n, m, cnt;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> K;
for (; K & (K - 1); K &= K - 1)
;
for (int i = 1; i <= m; ++i) {
int xl, xr, yl, yr;
cin >> xl >> yl >> xr >> yr;
a[++cnt] = node(xl, yl, yr, 1);
a[++cnt] = node(xr + 1, yl, yr, -1);
}
sort(a + 1, a + cnt + 1);
for (int i = 1; i <= cnt; ++i) {
if (a[i].x != a[i - 1].x) solve(a[i - 1].x, a[i].x - 1);
q1 = a[i].l;
q2 = a[i].r;
q3 = a[i].t;
modify(rt, 1, n);
}
cout << (ans ? "Hamed\n" : "Malek\n");
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16000000")
using namespace std;
const int Maxn = 100005;
const int Maxm = 20;
int n, q;
vector<int> neigh[Maxn];
int L[Maxn], P[Maxn][Maxm];
void Traverse(int v) {
for (int i = 0; i < neigh[v].size(); i++) {
int u = neigh[v][i];
L[u] = L[v] + 1;
P[u][0] = v;
Traverse(u);
}
}
int getLCA(int a, int b) {
if (L[a] < L[b]) swap(a, b);
for (int i = Maxm - 1; i >= 0; i--)
if (L[a] - (1 << i) >= L[b]) a = P[a][i];
if (a == b) return a;
for (int i = Maxm - 1; i >= 0; i--)
if (P[a][i] != P[b][i]) a = P[a][i], b = P[b][i];
return P[a][0];
}
int Solve(int a, int b, int c) {
int lca1 = getLCA(a, b), lca2 = getLCA(a, c);
if (L[lca1] < L[lca2]) lca1 = lca2;
int dist = L[a] - L[lca1] + 1;
int lca3 = getLCA(b, c);
if (L[lca3] > L[lca1]) dist += L[lca3] - L[lca1];
return dist;
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
neigh[p].push_back(i);
}
Traverse(1);
for (int j = 1; j < Maxm; j++)
for (int i = 1; i <= n; i++) P[i][j] = P[P[i][j - 1]][j - 1];
while (q--) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
int res = Solve(a, b, c);
res = max(res, Solve(b, a, c));
res = max(res, Solve(c, a, b));
printf("%d\n", res);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 220000;
const int MAXM = 2 * MAXN;
const int MAXS = 26;
struct SAM {
struct Node {
int nxt[MAXS], par;
int len, siz;
} st[MAXM];
int m, root, lst;
inline int newNode(int l) {
int x = ++m;
memset(st[x].nxt, 0, sizeof st[x].nxt);
st[x].par = 0;
st[x].len = l;
st[x].siz = 0;
return x;
}
void extend(char c, bool k) {
int x = c - 'a';
int p = lst, np = newNode(st[p].len + 1);
lst = np;
st[np].siz = k;
while (p && !st[p].nxt[x]) st[p].nxt[x] = np, p = st[p].par;
if (!p) {
st[np].par = root;
return;
}
int q = st[p].nxt[x];
if (st[q].len == st[p].len + 1) {
st[np].par = q;
return;
}
int nq = newNode(st[p].len + 1);
memcpy(st[nq].nxt, st[q].nxt, sizeof st[q].nxt);
st[nq].par = st[q].par;
st[np].par = st[q].par = nq;
while (p && st[p].nxt[x] == q) st[p].nxt[x] = nq, p = st[p].par;
}
void build(int n, char* s, char* t) {
static int c[MAXN], d[MAXM];
m = 0;
lst = root = newNode(0);
for (int i = 0; i < n; i++) extend(s[i], t[i] ^ '1');
memset(c, 0, sizeof c);
for (int i = 1; i <= m; i++) c[st[i].len]++;
for (int i = 1; i <= n; i++) c[i] += c[i - 1];
for (int i = 1; i <= m; i++) d[c[st[i].len]--] = i;
for (int i = m; i >= 2; i--) st[st[d[i]].par].siz += st[d[i]].siz;
}
long long query() {
long long r = 0;
for (int i = 1; i <= m; i++) r = max(r, 1ll * st[i].len * st[i].siz);
return r;
}
} sam;
char s[MAXN], t[MAXN];
int main() {
int n;
scanf("%d", &n);
scanf("%s%s", s, t);
sam.build(n, s, t);
printf("%lld\n", sam.query());
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
int n, m;
string s;
int c[maxn][maxn], f[maxn][maxn], d[maxn][maxn];
int b[maxn], dist[maxn], trace[maxn], cnt[26];
int getsign(int x) {
if (x >= 0)
return 1;
else
return -1;
}
bool findpath() {
for (int i = 1; i <= m; i++) dist[i] = 1e9;
dist[1] = 0;
while (1) {
bool stop = true;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= m; j++)
if (f[i][j] < c[i][j] &&
dist[j] > dist[i] + d[i][j] * getsign(f[i][j])) {
dist[j] = dist[i] + d[i][j] * getsign(f[i][j]);
trace[j] = i;
stop = false;
}
if (stop) break;
}
return dist[2] != (int)1e9;
}
void incflow() {
int delta = 1e9;
int v = 2;
while (v != 1) {
int u = trace[v];
delta = min(delta, c[u][v] - f[u][v]);
v = u;
}
v = 2;
while (v != 1) {
int u = trace[v];
f[u][v] += delta;
f[v][u] -= delta;
v = u;
}
}
int main() {
cin >> n;
cin >> s;
s = ' ' + s;
for (int i = 1; i <= n; i++) cin >> b[i];
m = 2;
for (int i = 1; i <= n; i++) cnt[s[i] - 'a']++;
for (int i = 0; i < 26; i++) {
m++;
c[1][m] = cnt[i];
}
for (int i = 1; i <= n; i++) {
m++;
c[m][2] = 1;
}
for (int i = 1; i <= n / 2; i++) {
m++;
int k = m;
c[m][28 + i] = 1;
c[m][28 + n - i + 1] = 1;
for (int j = 0; j < 26; j++)
if (j != s[i] - 'a' && j != s[n - i + 1] - 'a') {
c[j + 3][m] = 1;
} else {
k++;
c[k][28 + i] = 1;
c[k][28 + n - i + 1] = 1;
if (j == s[i] - 'a') {
d[k][28 + i] = -b[i];
d[28 + i][k] = -b[i];
}
if (j == s[n - i + 1] - 'a') {
d[k][28 + n - i + 1] = -b[n - i + 1];
d[28 + n - i + 1][k] = -b[n - i + 1];
}
c[j + 3][k] = 1;
}
m = k;
}
int ans = 0;
while (findpath()) incflow();
for (int i = 1; i <= m; i++)
for (int j = 1; j <= m; j++)
if (f[i][j] > 0) ans -= f[i][j] * d[i][j];
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 10;
const int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
const int dy[] = {0, 0, 1, -1, 1, -1, -1, 1};
int ma[maxn][maxn], n;
bool v[maxn][maxn];
int in(int x, int y) { return x >= 0 && x < n && y >= 0 && y < n; }
struct point {
double x, y;
point(double x, double y) : x(x), y(y) {}
point() : x(0), y(0) {}
bool operator<(const point &o) const {
if (fabs(x - o.x) < 1E-7) return y < o.y;
return x < o.x;
}
};
vector<point> pts;
void dfs(int x, int y) {
pts.push_back(point(x, y));
v[x][y] = true;
for (int i = 0; i < 8; ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (in(nx, ny) && ma[nx][ny] && !v[nx][ny]) {
dfs(nx, ny);
}
}
}
const double PI = acos(-1.0);
double sqr(double x) { return x * x; }
const double EPS = 1E-7;
const int rotime = 30;
const double magic = PI * .5 / rotime;
const int consize = 100000;
point sh[consize];
inline int dcmp(double x) { return x < -EPS ? -1 : x > EPS; }
double cross(const point &a, const point &b, const point &c) {
return (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);
}
bool check() {
sort(pts.begin(), pts.end());
int tot = 0;
int n = pts.size();
for (int i = 0; i < n; ++i) {
while (tot >= 2 && dcmp(cross(sh[tot - 2], sh[tot - 1], pts[i])) <= 0)
tot--;
sh[tot++] = pts[i];
}
int lev = tot;
for (int i = n - 2; i >= 0; --i) {
while (tot > lev && dcmp(cross(sh[tot - 2], sh[tot - 1], pts[i])) <= 0)
tot--;
sh[tot++] = pts[i];
}
double area = 0;
int sn = tot - 1;
for (int i = 0; i < sn; ++i) {
area += sh[i].x * sh[i + 1].y - sh[i].y * sh[i + 1].x;
}
area = fabs(area) * .5;
double mind = 1E20;
double sinA = sin(magic), cosA = cos(magic);
for (int i = 0; i < rotime; ++i) {
double x1 = 1E20;
double y1 = 1E20;
double x2 = -1E20;
double y2 = -1E20;
for (int j = 0; j < sn; ++j) {
x1 = min(x1, sh[j].x);
y1 = min(y1, sh[j].y);
x2 = max(x2, sh[j].x);
y2 = max(y2, sh[j].y);
}
mind = min(mind, (x2 - x1) * (y2 - y1));
for (int j = 0; j < sn; ++j) {
sh[j] = point(sh[j].x * cosA - sh[j].y * sinA,
sh[j].x * sinA + sh[j].y * cosA);
}
}
double pr = area / mind;
if (pr <= 0.892699081698724) {
return 0;
} else {
return 1;
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
scanf("%d", &ma[i][j]);
}
}
int circleN = 0;
int squareN = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (ma[i][j] && !v[i][j]) {
pts.clear();
dfs(i, j);
if (check()) {
squareN++;
} else {
circleN++;
}
}
}
}
cout << circleN << " " << squareN << endl;
}
| 6 |
#include<bits/stdc++.h>
#define ll long long
#define IO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
double PI=acos(-1);
void test_case()
{
int n;cin>>n;
string ans="";
char a='9';
if(n>45)
{
cout<<-1<<'\n';
return;
}
while(n>0)
{
if(a-'0'<=n)
{
ans+=a;
n-=(a-'0');
}
a--;
}
reverse(ans.begin(),ans.end());
cout<<ans<<'\n';
}
int main(){
IO
int t;cin>>t;
while(t--)
{
test_case();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void _add(long long &a, long long b) { a = (a + b) % 1000000007; }
void _sub(long long &a, long long b) { a = (a + 1000000007 - b) % 1000000007; }
void _mul(long long &a, long long b) { a = (long long)a * b % 1000000007; }
void _max(int &a, int b) { a = max(a, b); }
void _min(int &a, int b) { a = min(a, b); }
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
a /= gcd(a, b);
return a * b;
}
long long pow(long long a, long long b) {
long long res(1);
while (b) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return res;
}
long long powM(long long a, long long b, long long mod) {
long long res(1);
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
const int infi = 2147483647;
const long long infl = 9223372036854775807ll;
const double PI = 3.14159265358979323846;
struct ku {
long long w, h, c;
bool operator<(const ku &x) const {
if (h == x.h) return w < x.w;
return h < x.h;
}
} K[200010];
set<long long> ww, hh;
long long p[200010], q[200010], a[200010], b[200010];
int k, l;
inline long long c(int i, int j) { return K[i * l + j].c; }
int check(long long p0) {
long long q0 = c(0, 0) / p0;
return q[0] % q0 == 0;
if (q0 % b[0]) return 0;
return 1;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0, lim = n - 1; i <= lim; ++i) {
scanf("%I64d", &K[i].w), scanf("%I64d", &K[i].h), scanf("%I64d", &K[i].c);
ww.insert(K[i].w);
hh.insert(K[i].h);
}
sort(K, K + n);
k = hh.size();
l = ww.size();
if ((long long)k * l != n) {
puts("0");
return 0;
}
for (int i = 0, lim = k - 1; i <= lim; ++i) {
p[i] = c(i, 0);
int ok = 1;
for (int j = 1, lim = l - 1; j <= lim; ++j) {
p[i] = gcd(p[i], c(i, j));
if (i)
ok &= fabs(1.0 * c(0, j) * c(i, 0) - 1.0 * c(i, j) * c(0, 0)) <= 1e-9;
}
if (!ok) {
puts("0");
return 0;
}
}
for (int j = 0, lim = l - 1; j <= lim; ++j) {
q[j] = c(0, j);
int ok = 1;
for (int i = 1, lim = k - 1; i <= lim; ++i) {
q[j] = gcd(q[j], c(i, j));
}
if (!ok) {
puts("0");
return 0;
}
}
int ans = 0;
for (long long p0 = 1; p0 <= p[0]; ++p0) {
if (p0 * p0 > p[0]) break;
if (p[0] % p0) continue;
ans += check(p0);
if (p0 != p[0] / p0) ans += check(p[0] / p0);
}
printf("%d", (ans));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
long int n, i, y = 1;
cin >> n;
string s, t;
char p;
queue<char> q1, q2;
for (i = 0; i < n; i++) {
y = 1;
cin >> s >> t;
long int j, c = 0;
for (j = 0; s[j] != 0; j++) {
q1.push(s[j]);
}
for (j = 0; t[j] != 0; j++) {
q2.push(t[j]);
}
while (!q1.empty()) {
c = 0;
p = q1.front();
while (!q1.empty() && p == q1.front()) {
c++;
q1.pop();
}
if (!q2.empty() && q2.front() != p) {
cout << "NO"
<< "\n";
y = 0;
break;
}
while (!q2.empty() && p == q2.front()) {
c--;
q2.pop();
}
if (c > 0) {
cout << "NO"
<< "\n";
y = 0;
break;
}
}
if (y) {
if (!q2.empty())
cout << "NO"
<< "\n";
else
cout << "YES"
<< "\n";
}
while (!q1.empty()) q1.pop();
while (!q2.empty()) q2.pop();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
double c, cnt;
for (int i = 1; i <= n; i++) {
cin >> c;
cin >> c;
cnt += c;
}
cnt /= n;
cout << cnt + 5;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, cnt = 0;
cin >> n >> k;
char c = 'a';
string s, s1;
for (int i = 0; i < k; i++) {
s += c;
c++;
}
s1 = s;
while (1) {
if (n - s.size() == 1) {
s += s[0];
break;
}
if (s.size() >= n) {
break;
}
s += s1;
}
for (int i = 0; i < n; i++) {
cout << s[i];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll mod = 1000000007;
const int INF = 1e9;
const ll LINF = 1e18;
ll mod_sum() { return 0LL; }
template <typename T, typename... Args>
T mod_sum(T a, Args... args) {
return ((a + mod_sum(args...)) % mod + mod) % mod;
}
ll mod_prod() { return 1LL; }
template <typename T, typename... Args>
T mod_prod(T a, Args... args) {
return (a * mod_prod(args...)) % mod;
}
using pii = pair<ll, ll>;
using vi = vector<ll>;
using vb = vector<bool>;
using vvi = vector<vector<ll> >;
using vvb = vector<vector<bool> >;
using vpii = vector<pii>;
using vvpii = vector<vector<pii> >;
struct SegmentTree {
vi t;
SegmentTree(ll n) { t.resize(n << 2); }
void update(ll v, ll tl, ll tr, ll pos, ll val) {
if (tl == tr) {
t[v] = val;
return;
}
ll tm = (tl + tr) >> 1;
if (pos <= tm)
update(v << 1, tl, tm, pos, val);
else
update(v << 1 | 1, tm + 1, tr, pos, val);
t[v] = t[v << 1] + t[v << 1 | 1];
}
ll query(ll v, ll tl, ll tr, ll ql, ll qr) {
if (ql <= tl && tr <= qr) return t[v];
ll tm = (tl + tr) >> 1;
ll ret = 0;
if (ql <= tm) ret += query(v << 1, tl, tm, ql, qr);
if (tm + 1 <= qr) ret += query(v << 1 | 1, tm + 1, tr, ql, qr);
return ret;
}
};
ll solve() {
ll n, m;
cin >> n >> m;
SegmentTree st(n + m + 5);
ll sz = n + m + 5;
vi position(n + 5), mn(n + 5), mx(n + 5);
for (ll i = 1; i <= n; i++) {
position[n - i + 1] = i;
st.update(1, 0, sz - 1, i, 1);
mn[i] = mx[i] = i;
}
ll ptr = n + 1;
for (ll i = 0; i < m; i++) {
ll x;
cin >> x;
ll cnt = st.query(1, 0, sz - 1, position[x], sz - 1);
mx[x] = max(mx[x], cnt);
mn[x] = min(mn[x], cnt);
st.update(1, 0, sz - 1, position[x], 0);
st.update(1, 0, sz - 1, ptr, 1);
position[x] = ptr;
cnt = st.query(1, 0, sz - 1, position[x], sz - 1);
mx[x] = max(mx[x], cnt);
mn[x] = min(mn[x], cnt);
ptr++;
}
for (ll i = 1; i <= n; i++) {
ll cnt = st.query(1, 0, sz - 1, position[i], sz - 1);
mn[i] = min(mn[i], cnt);
mx[i] = max(mx[i], cnt);
}
for (ll i = 1; i <= n; i++) cout << mn[i] << " " << mx[i] << '\n';
return 0;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll t = 1;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long mod = 1;
long long max_value = 100000001;
while (n > 0 && mod < max_value) {
mod <<= 1;
n--;
}
cout << m % mod << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct tt {
int Di;
int Ti;
int Si;
tt() { Di = Ti = Si = 0; }
};
bool cmp(tt a, tt b) { return (a.Si > b.Si); }
tt T[100006];
int main() {
string str;
cin >> str;
for (int i = 0; i < str.size(); i++) cout << str[i];
for (int i = str.size() - 1; i >= 0; i--) cout << str[i];
puts("");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
string s, ss;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
long long tab[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
cin >> n >> m;
n--;
long long dni = tab[n];
dni -= 7 - m + 1;
long long ans = 1;
if (dni % 7 != 0) ans++;
cout << ans + dni / 7;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int nb;
cin >> nb;
for (int i = 0; i < nb; i++) {
string nom;
cin >> nom;
bool verify = true;
int t = nom.length();
if (t % 2 != 0)
verify = false;
else
for (int k = 0; k < (t / 2); k++) {
if (nom[k] != nom[(t / 2) + k]) {
verify = false;
break;
}
}
if (verify) {
cout << "yes" << endl;
} else
cout << "no" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const long long inf = 1e18 + 7;
const int mod = 1e9 + 7;
int q;
long long k, a[10], b[50], c[10], ci[10];
long long wer(long long nub, long long k) {
int ct = 0;
while (ci[ct] < k) ct++;
k = k - ci[ct - 1];
long long ki = (k - 1) / ct + c[ct] / 9;
long long cnt = ct - (k - 1) % ct;
while (--cnt) {
ki = ki / 10;
}
return ki % 10;
}
int main() {
long long h = 9;
ci[0] = 0;
c[0] = 0;
for (int i = 1; i <= 9; i++) {
c[i] = h;
ci[i] = ci[i - 1] + i * c[i];
h *= 10;
}
a[0] = 0;
for (int i = 1; i <= 9; i++) {
a[i] = a[i - 1] + (2 * ci[i - 1] + i * c[i] + i) * c[i] / 2;
}
int th = 1;
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
b[th++] = j;
}
}
cin >> q;
while (q--) {
cin >> k;
int ct = 0;
while (a[ct] < k) ct++;
if (ct == 1) {
cout << b[k] << endl;
continue;
}
k = k - a[ct - 1];
long long l = 1, r = c[ct], mid, kh;
while (l <= r) {
mid = (l + r) / 2;
if ((2 * ci[ct - 1] + ct * mid + ct) * mid / 2 >= k) {
r = mid - 1;
kh = mid;
} else
l = mid + 1;
}
long long ans = c[ct] / 9 - 1 + kh;
k = k - ((2 * ci[ct - 1] + ct * kh) * (kh - 1) / 2);
cout << wer(ans, k) << endl;
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define int long long
#define pb push_back
#define MAX INT_MAX
#define MIN INT_MIN
#define fr(a,b) for(int i = a; i < b; i++)
#define rep(i,a,b) for(int i = a; i < b; i++)
#define mod 1000000007
#define all(x) (x).begin(), (x).end()
#define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL)
using namespace std;
void solve(){
int a,b;
cin >> a >> b;
int ans=abs(a-b);
if(a==b){
cout << "0 0\n";
}
else{
if(a%ans==0 && b%ans==0){
cout << ans << " 0\n";
}
else{
cout << ans << " " << min(a%ans,ans-a%ans) << "\n";
}
}
}
signed main() {
fast_io;
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// #endif
int t = 1;
cin >> t;
while(t--){
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
const int N = 10e5 + 1;
struct edge {
int src, dst, weight;
bool inMST;
edge() = default;
edge(int _src, int _dst, int _weight)
: src{_src}, dst{_dst}, weight{_weight} {}
friend ostream& operator<<(ostream& os, const edge& e) {
os << "Edge : " << e.src << " -> " << e.dst << " (" << e.weight << ")";
return os;
}
friend bool operator<(const edge& e1, const edge& e2) {
return e1.weight < e2.weight;
}
};
int parent_uf[N];
int subtree_size_uf[N];
void init(int n) {
for (int i = 0; i < n; i++) {
parent_uf[i] = i;
subtree_size_uf[i] = 1;
}
}
int root(int x) {
return parent_uf[x] == x ? x : parent_uf[x] = root(parent_uf[x]);
}
void join(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return;
if (subtree_size_uf[x] < subtree_size_uf[y]) {
parent_uf[x] = y;
subtree_size_uf[y] += subtree_size_uf[x];
} else {
parent_uf[y] = x;
subtree_size_uf[x] += subtree_size_uf[y];
}
}
vector<edge> graph[N];
int depth[N];
int parent[N][20];
int parent_max[N][20];
void populate_mst_depths_dfs(int vertex = 1, int prev = -1,
int currentDepth = 0) {
depth[vertex - 1] = currentDepth;
for (size_t i = 0; i < graph[vertex].size(); ++i) {
const edge& e = graph[vertex][i];
if (!e.inMST || e.dst == prev) continue;
parent[e.dst - 1][0] = e.src - 1;
parent_max[e.dst - 1][0] = e.weight;
populate_mst_depths_dfs(e.dst, vertex, currentDepth + 1);
}
}
void preprocess(int n) {
for (int i = 0; i < n; i++) {
for (int j = 1; (1 << j) < n; j++) {
parent[i][j] = -1;
parent_max[i][j] = -1;
}
}
for (int j = 1; (1 << j) < n; j++) {
for (int i = 0; i < n; i++) {
if (parent[i][j - 1] != -1) {
parent[i][j] = parent[parent[i][j - 1]][j - 1];
parent_max[i][j] =
max(parent_max[i][j - 1], parent_max[parent[i][j - 1]][j - 1]);
}
}
}
}
int lca2(int u, int v) {
if (depth[u] < depth[v]) swap(u, v);
for (int i = log2(depth[u]); i >= 0; i--) {
if (depth[u] - (1 << i) >= depth[v]) u = parent[u][i];
}
if (u == v) return u;
for (int i = log2(depth[u]); i >= 0; i--)
if (parent[u][i] != -1 && parent[u][i] != parent[v][i]) {
u = parent[u][i];
v = parent[v][i];
}
return parent[u][0];
}
int max_edge_lca(int u, int v) {
if (depth[u] < depth[v]) swap(u, v);
int result = -1;
for (int i = ceil(log2(depth[u])); i >= 0; i--) {
if (depth[u] - (1 << i) >= depth[v]) {
result = max(result, parent_max[u][i]);
u = parent[u][i];
}
}
if (u == v) return result;
for (int i = ceil(log2(depth[u])); i >= 0; i--)
if (parent[u][i] != -1 && parent[u][i] != parent[v][i]) {
result = max(result, parent_max[u][i]);
result = max(result, parent_max[v][i]);
u = parent[u][i];
v = parent[v][i];
}
result = max(result, parent_max[u][0]);
result = max(result, parent_max[v][0]);
return result;
}
int lca(int u, int v) { return lca2(u - 1, v - 1) + 1; }
int max_edge(int u, int v) { return max_edge_lca(u - 1, v - 1); }
int main() {
int n, m;
cin >> n >> m;
vector<edge> edgeList;
for (int i = 0; i < m; ++i) {
edge e;
cin >> e.src >> e.dst >> e.weight;
edgeList.push_back(e);
}
vector<edge> unsortedEdgeList = edgeList;
sort(edgeList.begin(), edgeList.end());
init(n);
ll weight = 0;
for (edge& e : edgeList) {
if (root(e.src) != root(e.dst)) {
join(e.src, e.dst);
e.inMST = true;
weight += e.weight;
} else {
e.inMST = false;
}
}
for (const edge& e : edgeList) {
graph[e.src].push_back(e);
edge otherEdge;
otherEdge.src = e.dst;
otherEdge.dst = e.src;
otherEdge.inMST = e.inMST;
otherEdge.weight = e.weight;
graph[e.dst].push_back(otherEdge);
}
populate_mst_depths_dfs();
preprocess(n);
for (size_t i = 0; i < unsortedEdgeList.size(); ++i) {
const edge& e = unsortedEdgeList[i];
cout << weight + e.weight - max_edge(e.src, e.dst) << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = numeric_limits<int>::max();
const long long LLINF = numeric_limits<long long>::max();
const unsigned long long ULLINF = numeric_limits<unsigned long long>::max();
const double PI = acos(-1.0);
const int MAXN = 1e6 + 100;
long long t[MAXN * 4], p[4 * MAXN];
int sz = 1;
void build() {
while (sz < MAXN) sz <<= 1;
}
long long query(long long* tree, int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r) return tree[v];
int tm = (tl + tr) / 2;
return query(tree, v + v, tl, tm, l, min(tm, r)) +
query(tree, v + v + 1, tm + 1, tr, max(tm + 1, l), r);
}
void update(long long* tree, int ind, long long val) {
ind += sz;
tree[ind] += val;
while (ind > 1) {
ind /= 2;
tree[ind] = tree[2 * ind] + tree[2 * ind + 1];
}
}
vector<pair<long long, long long>> starts[1000010], endss[1000010];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k, m;
cin >> n >> k >> m;
for (int i = 0; i < m; i++) {
int l, r, c, p;
cin >> l >> r >> c >> p;
starts[l].push_back(make_pair(p, c));
endss[r + 1].push_back(make_pair(p, c));
}
build();
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (auto k : endss[i]) {
update(t, k.first, -k.second);
update(p, k.first, -k.first * k.second);
}
for (auto k : starts[i]) {
update(t, k.first, k.second);
update(p, k.first, k.first * k.second);
}
int l = 0, r = MAXN - 1, res = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (query(t, 1, 0, sz - 1, 0, mid) >= k)
res = mid, r = mid - 1;
else
l = mid + 1;
}
if (res == -1)
ans += p[1];
else {
long long price = query(p, 1, 0, sz - 1, 0, res);
if (query(t, 1, 0, sz - 1, 0, res) > k) {
long long diff = query(t, 1, 0, sz - 1, 0, res) - k;
price -= res * diff;
}
ans += price;
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
string s[100005];
int nxt[maxn][26], par[maxn], len[maxn], tp[maxn], rk[maxn];
long long sum[maxn];
int n, cnt, last;
int add(int l) {
++cnt;
len[cnt] = l;
return cnt;
}
void init() {
cnt = 0;
last = add(0);
}
void insert(char ch) {
int t = ch - 'a', p = last, cur;
if (nxt[p][t]) {
int q = nxt[p][t];
if (len[q] == len[p] + 1) {
last = q;
return;
}
int nq = add(len[p] + 1);
last = nq;
memcpy(nxt[nq], nxt[q], sizeof nxt[q]);
par[nq] = par[q], par[q] = nq;
while (p && nxt[p][t] == q) nxt[p][t] = nq, p = par[p];
return;
}
cur = last = add(len[p] + 1);
while (p && !nxt[p][t]) nxt[p][t] = cur, p = par[p];
if (!p) {
par[cur] = 1;
return;
}
int q = nxt[p][t];
if (len[q] == len[p] + 1) {
par[cur] = q;
return;
}
int nq = add(len[p] + 1);
memcpy(nxt[nq], nxt[q], sizeof nxt[q]);
par[nq] = par[q], par[q] = par[cur] = nq;
while (p && nxt[p][t] == q) nxt[p][t] = nq, p = par[p];
}
void rsort() {
for (int i = 0; i <= cnt; ++i) tp[i] = 0;
for (int i = 1; i <= cnt; ++i) ++tp[len[i]];
for (int i = 1; i <= cnt; ++i) tp[i] += tp[i - 1];
for (int i = cnt; i >= 1; --i) rk[tp[len[i]]--] = i;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
init();
for (int i = 1; i <= n; ++i) {
cin >> s[i];
}
for (int i = 1; i <= n; ++i) {
int c;
cin >> c;
for (int j = 0; j < ((int)s[i].size()); ++j) {
insert(s[i][j]);
sum[last] += c;
}
last = 1;
}
rsort();
long long ret = 0;
for (int i = cnt; i >= 2; --i) {
int u = rk[i];
sum[par[u]] += sum[u];
ret = max(ret, sum[u] * len[u]);
}
cout << ret << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 222;
const int NN = N << 1;
string vow, word;
char buff[NN];
bool igraph[NN][NN], graph[NN][NN];
vector<vector<int> > sccs;
stack<int> st;
bool inst[NN];
int mini[NN], ti, ans[NN], comp[NN], nc[N], nv[N];
bool ok;
int n, m, k;
int tarjan(int u) {
int cur = ++ti;
st.push(u);
inst[u] = true;
mini[u] = cur;
for (int v = (2); v <= (2 * n + 1); v++) {
if (graph[u][v]) {
if (!mini[v]) {
mini[u] = min(mini[u], tarjan(v));
} else if (inst[v]) {
mini[u] = min(mini[u], mini[v]);
}
}
}
if (mini[u] == cur) {
vector<int> scc;
k++;
while (1) {
int x = st.top();
st.pop();
inst[x] = false;
comp[x] = k;
if (comp[x] == comp[x ^ 1]) {
ok = false;
}
scc.push_back(x);
if (x == u) {
break;
}
}
sccs.push_back(scc);
}
return mini[u];
}
bool twoSat() {
k = 0;
sccs.clear();
ok = true;
ti = 0;
fill(mini + 1, mini + 2 * n + 2, 0);
fill(comp + 1, comp + 2 * n + 2, 0);
fill(inst + 1, inst + 2 * n + 2, false);
for (int u = (2); u <= (2 * n + 1); u++) {
if (!mini[u]) {
tarjan(u);
}
}
if (!ok) {
return false;
}
return true;
}
bool rem;
void add(int from, int to) {
if (!graph[from][to]) {
graph[from][to] = true;
rem = true;
}
}
void remove(int from, int to) {
if (rem) {
graph[from][to] = false;
rem = false;
}
}
string anss;
bool solve(int pref) {
anss = "";
for (int i = (2); i <= (2 * n + 1); i++) {
copy(igraph[i] + 2, igraph[i] + 2 * n + 2, graph[i] + 2);
}
for (int i = (1); i <= (pref); i++) {
anss += word[i - 1];
bool isv = vow[word[i - 1] - 'a'] == 'V';
int u = 2 * i + isv;
graph[u ^ 1][u] = true;
}
if (!twoSat()) {
return false;
}
if (pref < (int)(word).size()) {
int x = word[pref] - 'a';
x++;
if (x == (int)(vow).size()) {
return false;
}
bool isv = vow[x] == 'V';
int u = (pref + 1) * 2 + isv;
add(u ^ 1, u);
if (!twoSat()) {
remove(u ^ 1, u);
if (isv)
x = nc[x];
else
x = nv[x];
if (x == -1) return false;
isv = !isv;
int u = (pref + 1) * 2 + isv;
add(u ^ 1, u);
if (!twoSat()) {
return false;
}
}
anss += 'a' + x;
}
for (int i = (pref + 2); i <= ((int)(word).size()); i++) {
int x = 0;
bool isv = vow[x] == 'V';
int u = i * 2 + isv;
add(u ^ 1, u);
if (!twoSat()) {
remove(u ^ 1, u);
if (isv)
x = nc[x];
else
x = nv[x];
if (x == -1) return false;
isv = !isv;
int u = i * 2 + isv;
add(u ^ 1, u);
if (!twoSat()) {
exit(1);
}
}
anss += 'a' + x;
}
return true;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
scanf("%s %d %d", buff, &n, &m);
vow = (string)buff;
for (int i = (1); i <= (m); i++) {
int u, v;
char tu, tv;
scanf("%d %c %d %c", &u, &tu, &v, &tv);
u <<= 1;
v <<= 1;
if (tu == 'V') {
u++;
}
if (tv == 'V') {
v++;
}
igraph[u][v] = true;
igraph[v ^ 1][u ^ 1] = true;
}
if (vow.find('V') == string::npos) {
for (int i = (1); i <= (n); i++) {
igraph[2 * i + 1][2 * i] = true;
}
}
if (vow.find('C') == string::npos) {
for (int i = (1); i <= (n); i++) {
igraph[2 * i][2 * i + 1] = true;
}
}
scanf(" %s", buff);
word = (string)buff;
int c = -1, v = -1;
for (int i = ((int)(vow).size()); i >= (1); i--) {
nc[i - 1] = c;
nv[i - 1] = v;
if (vow[i - 1] == 'V') {
v = i - 1;
} else {
c = i - 1;
}
}
for (int p = (n); p >= (0); p--) {
if (solve(p)) {
printf("%s\n", anss.c_str());
return 0;
}
}
printf("-1\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
const int N = 5e2 + 7;
int n, m;
vector<int> ad[N];
int dis[N][N];
bool mrk[N][N];
pair<int, int> par[N][N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int v, u;
scanf("%d%d", &v, &u);
ad[v].push_back(u);
ad[u].push_back(v);
}
queue<pair<int, int> > q;
q.push({1, n});
mrk[1][n] = 1;
while (q.size()) {
int v = q.front().first;
int u = q.front().second;
q.pop();
for (auto vp : ad[v])
for (auto up : ad[u])
if (up != vp && !mrk[vp][up]) {
mrk[vp][up] = 1;
par[vp][up] = {v, u};
dis[vp][up] = dis[v][u] + 1;
q.push({vp, up});
}
}
if (!mrk[n][1]) {
cout << -1;
return 0;
} else
cout << dis[n][1] << '\n';
int v = n, u = 1;
deque<int> res[3];
res[1].push_front(n);
res[2].push_front(1);
int sv, su;
while (v) {
sv = v, su = u;
v = par[sv][su].first;
u = par[sv][su].second;
if (v) {
res[1].push_front(v);
res[2].push_front(u);
}
}
for (auto x : res[1]) printf("%d ", x);
for (auto x : res[2]) printf("%d ", x);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void Main();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
while (~cin.peek()) Main(), cin.get();
return 0;
}
struct TreeArray {
vector<int> c;
TreeArray(int n) { c.resize(n); }
int lowbit(int x) { return x & -x; }
void add(int p, int x) {
for (int i = p; i < c.size(); i += lowbit(i)) {
c[i] += x;
}
}
int get(int p) {
int ans = 0;
for (int i = p; i > 0; i -= lowbit(i)) {
ans += c[i];
}
return ans;
}
int query(int l, int r) { return get(r) - get(l - 1); }
};
struct StringTree {
vector<vector<int>> tree;
StringTree() { tree.resize(1, vector<int>(26)); }
int insert(string s) {
int cur = 0;
for (auto &ch : s) {
if (!tree[cur][ch - 'a']) {
tree.push_back(vector<int>(26));
tree[cur][ch - 'a'] = tree.size() - 1;
}
cur = tree[cur][ch - 'a'];
}
return cur;
}
int size() { return tree.size(); }
};
struct StringMatch {
StringTree st;
vector<int> lastid;
void get_lastid() {
lastid.resize(st.size());
queue<int> q;
for (int i = 0; i < 26; i++) {
if (st.tree[0][i]) {
q.push(st.tree[0][i]);
}
}
while (!q.empty()) {
int done = q.front();
q.pop();
for (int i = 0; i < 26; i++) {
if (st.tree[done][i]) {
lastid[st.tree[done][i]] = st.tree[lastid[done]][i];
q.push(st.tree[done][i]);
} else {
st.tree[done][i] = st.tree[lastid[done]][i];
}
}
}
}
};
void Main() {
int n;
cin >> n;
vector<vector<pair<int, int>>> graph(n + 1);
for (int i = 1; i <= n; i++) {
int t;
cin >> t;
if (t == 1) {
string s;
cin >> s;
graph[0].push_back({i, s[0] - 'a'});
} else {
int id;
string s;
cin >> id >> s;
graph[id].push_back({i, s[0] - 'a'});
}
}
StringMatch sm;
vector<pair<int, int>> query_seq;
map<int, vector<int>> query;
map<pair<int, int>, int> ans;
int m;
cin >> m;
while (m--) {
int id;
string s;
cin >> id >> s;
int nodeid = sm.st.insert(s);
query[id].push_back(nodeid);
query_seq.push_back({id, nodeid});
}
sm.get_lastid();
vector<vector<int>> graph2(sm.st.size());
for (int i = 1; i < graph2.size(); i++) {
graph2[sm.lastid[i]].push_back(i);
}
int clock = 0;
vector<int> from(graph2.size()), to(graph2.size());
function<void(int)> dfs2 = [&](int rt) {
from[rt] = ++clock;
for (int &id : graph2[rt]) {
dfs2(id);
}
to[rt] = clock;
};
dfs2(0);
TreeArray ta(clock + 1);
stack<int> stk;
stk.push(0);
function<void(int, int)> dfs = [&](int rt, int ch) {
int top = stk.top();
while (top && !sm.st.tree[top][ch]) top = sm.lastid[top];
top = sm.st.tree[top][ch];
ta.add(from[top], 1);
for (int &id : query[rt]) {
ans[{rt, id}] = ta.query(from[id], to[id]);
}
stk.push(top);
for (auto &p : graph[rt]) {
dfs(p.first, p.second);
}
stk.pop();
ta.add(from[top], -1);
};
for (auto &p : graph[0]) {
dfs(p.first, p.second);
}
for (auto &p : query_seq) {
cout << ans[{p.first, p.second}] << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 2e5+5;
int n, S;
struct Statement {
bool isIf;
int y;
ll v;
Statement *ifblock;
Statement *next;
};
Statement* makeSet(int y, ll v, Statement* next) {
Statement* ret = new Statement;
ret->isIf = false;
ret->y = y;
ret->v = v;
ret->ifblock = NULL;
ret->next = next;
return ret;
}
Statement* makeIf(int y, Statement* ifblock, Statement* next) {
Statement* ret = new Statement;
ret->isIf = true;
ret->y = y;
ret->v = 0;
ret->ifblock = ifblock;
ret->next = next;
return ret;
}
string input[maxn];
int idx = 0;
Statement* read() {
//cout << idx << ' ' << input[idx] << endl;
stringstream ss(input[idx]);
string word; ss >> word;
if (word == "set") {
int y; ll v; ss >> y >> v;
idx++;
return makeSet(y,v,read());
}
else if (word == "if") {
int y; ss >> y;
idx++;
Statement* ifblock = read();
idx++;
Statement* next = read();
return makeIf(y,ifblock,next);
}
else if (word == "end") return NULL;
else {
//while (true) {}
}
assert(false); return NULL;
}
void print(Statement* s) {
if (!s) return;
if (!s->isIf) {
cout << "set " << s->y << ' ' << s->v << endl;
}
else {
cout << "if " << s->y << endl;
cout << "{\n";
print(s->ifblock);
cout << "end" << endl;
cout << "}\n";
}
print(s->next);
}
const ll INF = 1e18;
struct Bag {
ll aux = 0;
multiset<ll> s;
map<int,ll> mp;
Bag(int x, ll y) {
aux = 0;
mp[x] = y;
s.insert(y);
}
void insert(int x, ll y) {
if (mp.count(x)) {
auto it = s.find(mp[x]);
assert(it != s.end());
//if (it == s.end()) while (1) {};
s.erase(it);
}
mp[x] = y-aux;
s.insert(y-aux);
}
void insertMin(int x, ll y) {
if (mp.count(x) && mp[x]+aux <= y) return;
else insert(x,y);
}
ll getmin() {
assert(!s.empty());
return *s.begin()+aux;
}
ll lookup(int x) {
if (!mp.count(x)) return INF;
else return mp[x] + aux;
}
void increment(ll x) {
aux += x;
}
vector<pair<int,ll>> getvec() {
vector<pair<int,ll>> v;
for (auto p: mp) {
v.push_back({p.first,p.second+aux});
}
return v;
}
};
void merge(Bag& a, Bag& b, int y) {
bool swp = false;
if (a.mp.size() < b.mp.size()) {
swap(a,b);
swp = true;
}
for (auto p: b.getvec()) {
if (p.first == y) {
if (!swp) a.insert(p.first,p.second);
}
else
a.insertMin(p.first,p.second);
}
}
void solve(Statement* st, Bag* b) {
while (st) {
if (!(st->isIf)) { //set
ll mn = b->getmin();
b->increment(st->v);
if (st->y != S) {
b->insert(st->y,mn);
}
}
else { //if
ll cost = b->lookup(st->y);
if (cost < INF) {
Bag ifBag = Bag(st->y,cost);
solve(st->ifblock,&ifBag);
merge(*b,ifBag,st->y);
}
}
st = st->next;
}
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(NULL);
cin >> n >> S;
string nl; getline(cin,nl);
for (int i = 0; i < n; i++) {
getline(cin,input[i]);
}
input[n] = "end";
Statement *start = read();
Bag b = Bag(0,0);
solve(start,&b);
cout << b.getmin() << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long qpow(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
n >>= 1;
}
return res;
}
int n;
long long s, a[55];
long long C(long long n, long long m) {
m = min(m, n - m);
long long x = 1, y = 1;
for (int i = 1; i <= m; i++) {
x = x * (n - i + 1) % 1000000007;
y = y * i % 1000000007;
}
return x * qpow(y, 1000000007 - 2) % 1000000007;
}
long long lucas(long long n, long long m) {
if (n <= 1000000007 && m <= 1000000007) return C(n, m);
return C(n % 1000000007, m % 1000000007) *
lucas(n / 1000000007, m / 1000000007);
}
int main() {
cin >> n >> s;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
long long ans = 0;
for (int i = 0; i < (1 << n); i++) {
long long t = s, f = 1;
for (int j = 0; j < n; j++) {
if ((1 << j) & i) {
t -= a[j + 1] + 1;
f = -f;
}
}
if (t < 0) continue;
ans = (ans + lucas(t + n - 1, n - 1) * f + 1000000007) % 1000000007;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> ans;
int main() {
long long n, k;
cin >> n >> k;
ans.resize(n + 3);
int pa = 1;
int pb = n;
long long sum = 0;
k -= (n * (n + 1)) / 2;
sum = (n * (n + 1)) / 2;
for (int i = 1; i <= n; i++) ans[i] = i;
while (k > 0) {
if (pa >= pb) break;
while (pb - pa > k) {
pb--;
}
k -= (pb - pa);
sum += (pb - pa);
ans[pb] = pa;
ans[pa] = pb;
pa++;
pb--;
}
if (k < 0)
cout << -1 << endl;
else {
cout << sum << endl;
for (int i = 1; i <= n; i++) {
cout << i << " ";
}
cout << endl;
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int nth_bit(int64_t num, int n) { return (num >> n) & 1; }
void solve() {
int N;
cin >> N;
int ans = 0;
for (int k = 0; k < 9; k++) {
vector<int> v[2];
for (int i = 1; i <= N; i++) v[nth_bit(i, k)].push_back(i);
if (v[1].size() == 0) {
break;
} else {
cout << v[0].size() << " " << v[1].size();
for (int i = 0; i < 2; i++)
for (int a : v[i]) cout << " " << a;
cout << endl;
int res;
cin >> res;
if (res == -1) exit(0);
ans = max(ans, res);
}
}
cout << "-1 " << ans << endl;
}
int main() {
int T;
cin >> T;
while (T--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
template <typename T>
inline bool chkmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
template <typename T>
inline void read(T &x) {
char ch = getchar();
int f = 1;
x = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
read(x), read(args...);
}
int n, a[300050];
long long ans;
int main() {
read(n);
for (register int i = 1; i <= n; ++i) read(a[i]);
long long left = 0;
for (register int i = 1; i <= n; ++i) {
if (a[i] >= left * 2)
ans += left, a[i] -= left * 2, left = 0;
else
ans += a[i] / 2, left -= a[i] / 2, a[i] = a[i] & 1;
ans += a[i] / 3, left += a[i] % 3;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int cnt[30];
string t;
int n;
string s[110];
int a[110];
int S, T;
const int MaxN = 1000010;
int tot;
struct node {
int from, way, cap, cost;
node *next, *rev;
} edge[MaxN], *vec[MaxN];
void addedge(int x, int y, int c, int w) {
++tot;
edge[tot].from = x;
edge[tot].way = y;
edge[tot].cap = c;
edge[tot].cost = w;
edge[tot].next = vec[x];
edge[tot].rev = &edge[tot + 1];
vec[x] = &edge[tot];
++tot;
edge[tot].from = y;
edge[tot].way = x;
edge[tot].cap = 0;
edge[tot].cost = -w;
edge[tot].next = vec[y];
edge[tot].rev = &edge[tot - 1];
vec[y] = &edge[tot];
}
const int INF = 1000000000;
int ans, flow;
int dis[MaxN];
node *pre[MaxN];
priority_queue<pair<int, int> > H;
bool SPFA() {
for (int i = 1; i <= T; ++i) dis[i] = INF;
H.push(make_pair(dis[S] = 0, S));
while (!H.empty()) {
int nowx = H.top().second, nowd = -H.top().first;
H.pop();
if (dis[nowx] != nowd) continue;
for (node *it = vec[nowx]; it; it = it->next)
if (it->cap > 0)
if (dis[it->way] > nowd + it->cost) {
H.push(make_pair(-(dis[it->way] = nowd + it->cost), it->way));
pre[it->way] = it;
}
}
if (dis[T] == INF) return false;
flow += 1;
ans += dis[T];
for (int i = T; i != S; i = pre[i]->from) {
pre[i]->cap -= 1;
pre[i]->rev->cap += 1;
}
return true;
}
int main() {
cin >> t;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> s[i] >> a[i];
a[i] = min(a[i], (int)s[i].length());
}
S = 200;
T = S + 1;
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < t.length(); ++i) cnt[t[i] - 'a' + 1]++;
for (int i = 1; i <= 26; ++i) addedge(S, i, cnt[i], 0);
for (int i = 1; i <= n; ++i) {
addedge(26 + i, T, a[i], i);
memset(cnt, 0, sizeof(cnt));
for (int j = 0; j < s[i].length(); ++j) cnt[s[i][j] - 'a' + 1]++;
for (int j = 1; j <= 26; ++j) addedge(j, 26 + i, cnt[j], 0);
}
while (SPFA())
;
if (flow != t.length()) ans = -1;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int pow1(long long int a, long long int b) {
long long int i, ans = 1;
for (i = 0; i < b; i++) {
ans = ans * a;
}
return ans;
}
void solve() {
long long int d, m, i, k1, j, j1, ans = 0;
cin >> d >> m;
for (j = 30; j >= 0; j--) {
if ((d >> j) & 1 == 1) {
j1 = j;
j = -1;
}
}
vector<vector<int>> dp(31, vector<int>(31, 0));
for (j = 0; j <= 30; j++) {
dp[0][j] = 1;
}
for (i = 1; i <= 30; i++) {
for (j = i - 1; j <= j1; j++) {
k1 = pow1(2, j) % m;
if (j == j1) {
k1 = (d - pow1(2, j) + 1) % m;
}
dp[i][j + 1] = (dp[i][j] + (k1 * (dp[i - 1][j])) % m) % m;
}
}
ans = 0;
for (i = 1; i <= 30; i++) {
ans = (ans + dp[i][j1 + 1]) % m;
}
cout << ans << endl;
return;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
long long x[100010];
while (cin >> n >> d) {
for (int i = (int)0; i < (int)n; i++) cin >> x[i];
long long res = 0;
for (int i = (int)0; i < (int)n - 2; i++) {
int inf = i + 1, sup = n - 1, med, pos = -1;
while (inf <= sup) {
med = (inf + sup) / 2;
if (abs((long long)(x[i]) - (long long)(x[med])) <= d)
pos = med, inf = med + 1;
else
sup = med - 1;
}
if (pos > i && (pos - i) > 1) {
int len = pos - i;
res = (long long)(res) +
(long long)((long long)((long long)(len) * (long long)(len - 1)) /
(long long)(2));
}
}
cout << res << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int f[10001];
int main() {
int a, b = -99999, c = 0;
cin >> a;
for (int i = 1; i <= a; i++) cin >> f[i];
for (int i = 1; i <= a; i++) b = max(b, f[i]);
for (int i = 1; i <= a; i++) c += (b - f[i]);
cout << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k, z;
cin >> n >> k >> z;
int ara[n];
long long int sum[n], mx = 0;
for (int i = 0; i < n; i++) {
cin >> ara[i];
sum[i] = (long long int)ara[i];
}
for (int i = 1; i <= k; i++) {
sum[i] += sum[i - 1];
}
for (int i = 1; i <= k; i++) {
int left = min((k - i + 1) / 2, z), right = min(k - i - left + 1, left);
if (sum[k - left - right] + (right * ara[i]) + (left * ara[i - 1]) > mx) {
mx = (long long int)sum[k - left - right] + right * ara[i] +
left * ara[i - 1];
}
}
cout << mx << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
int highest = 0;
long long smallest = pow(10, 10);
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int input;
cin >> input;
v.push_back(input);
if (input < smallest) smallest = input;
if (input > highest) highest = input;
}
cout << highest - smallest + 1 - n;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
long long f[(1 << 18)] = {1, 1}, I[(1 << 18)] = {1, 1}, J[(1 << 18)] = {1, 1};
void pre() {
for (int k(2); k < (1 << 18); k++)
f[k] = f[k - 1] * k % (1000000007),
J[k] =
-(1000000007) / k * J[(1000000007) % k] % (1000000007) + (1000000007),
I[k] = I[k - 1] * J[k] % (1000000007);
;
}
long long C(int N, int K) {
return N < K ? 0 : (f[N] * I[K] % (1000000007)) * I[N - K] % (1000000007);
}
int N, A[(1 << 18)];
long long go(int I) {
long long S = 0;
if (!I)
for (int i(0); i < N; i++)
S += C((N - 2) / 2, i / 2) * (i & 1 ? -1 : 1) * A[i] % (1000000007);
if (I == 1)
for (int i(0); i < N; i++)
if (!(i & 1)) S += C((N - 1) / 2, i / 2) * A[i] % (1000000007);
if (I == 2)
for (int i(0); i < N; i++) S += C((N - 2) / 2, i / 2) * A[i] % (1000000007);
if (I == 3) {
S = C((N - 3) / 2, 0) * *A % (1000000007);
for (int k(1); k < N; k++)
if (k & 1)
S += 2 * C((N - 3) / 2, k / 2) * A[k] % (1000000007);
else
S += (C((N - 3) / 2, k / 2) - C((N - 3) / 2, k / 2 - 1)) * A[k] %
(1000000007);
}
return (S % (1000000007) + (1000000007)) % (1000000007);
}
int main(void) {
scanf("%d", &N), ga(N, A), pre();
printf("%lld\n", go(N & 3));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a[10000];
int main() {
string s;
long long n, i, k = 0;
cin >> n >> s;
for (i = 0; i < s.size(); i++) {
if (i % 2 == 0) {
a[int(s[i])]++;
} else {
if (a[int(s[i]) + 32] == 0) {
k++;
} else {
a[int(s[i]) + 32]--;
}
}
}
cout << k;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, w;
cin >> l >> w;
int c = 0;
while (l <= w) {
l = l * 3;
w = w * 2;
c++;
if (l > w) {
cout << c;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int l, r;
cin >> l >> r;
cout << r - max(l, r / 2 + 1) << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const double eps = 1e-8;
const int nm = 200005;
int n, k, m, t;
int res;
struct Node {
int x, w;
};
Node N[nm];
int dp[nm];
int endOf[nm];
int Max = 1;
bool cmp(Node u, Node v) { return u.x < v.x; }
int main() {
int i, j, y, z;
int l, r, mid;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &N[i].x, &N[i].w);
}
sort(N + 1, N + n + 1, cmp);
endOf[0] = 0;
endOf[1] = 1;
N[0].x = N[0].x = -MOD;
dp[1] = 1;
for (i = 2; i <= n; i++) {
l = 0;
r = Max;
while (l < r - 1) {
mid = (l + r) >> 1;
k = endOf[mid];
if (N[i].x - N[k].x >= N[i].w + N[k].w) {
l = mid;
} else
r = mid - 1;
}
k = endOf[r];
if (N[i].x - N[k].x >= N[i].w + N[k].w)
dp[i] = r + 1;
else
dp[i] = l + 1;
if (dp[i] > Max || N[i].x + N[i].w < N[endOf[dp[i]]].x + N[endOf[dp[i]]].w)
endOf[dp[i]] = i;
if (dp[i] > Max) Max = dp[i];
}
cout << Max;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int i, j, k, l;
char r[102];
scanf("%s", r);
j = strlen(r);
k = 0;
l = 0;
for (i = 0; i < j; i++) {
if (r[i] == '-') {
k++;
} else if (r[i] == 'o') {
l++;
}
}
if (l != 0) {
if (k % l == 0) {
printf("YES");
} else if (k % l != 0) {
printf("NO");
}
} else {
printf("YES");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, k = 0, knull = 0;
string b, t = "";
cin >> a >> b;
vector<int> c;
while (a > 0) {
if (a % 10 != 0)
c.push_back(a % 10);
else
knull++;
a /= 10;
k++;
}
if (c.size() > 0) {
sort(c.begin(), c.end());
t += (char)c[0] + 48;
}
while (knull > 0) {
t += (char)48;
knull--;
}
if (c.size() > 1) {
for (int i = 1; i < c.size(); i++) t += (char)c[i] + 48;
}
cout << ((atoi(b.c_str()) == atoi(t.c_str()) && k == b.size() ||
(a == 0 && b == "0"))
? "OK"
: "WRONG_ANSWER");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long BigMod(long long base, long long power, long long MOD) {
long long ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
int main() {
int n, i, j, k, m;
cin >> n;
string s;
cin >> s;
int fr[33] = {};
for (i = 0; i <= n - 1; i++) fr[s[i] - 'A']++;
int mx = 0, cnt = 0;
for (i = 0; i <= 25; i++) mx = max(mx, fr[i]);
for (i = 0; i <= 25; i++)
if (fr[i] == mx) cnt++;
cout << BigMod((long long)cnt, (long long)n, 1000000007LL) << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double f[1000][1000], b[1000], pp[1000][2];
int main() {
int N, M, x, y;
scanf("%d %d", &N, &M);
scanf("%d %d", &x, &y);
if (M == 1) {
for (int i = N - 2; i >= 0; --i) f[i][M - 1] = f[i + 1][M - 1] + 2;
} else {
for (int i = N - 2; i >= 0; --i) {
for (int j = 0; j < M; ++j) {
if (j == 0 || j == M - 1)
b[j] = f[i + 1][j] + 3.0;
else
b[j] = f[i + 1][j] + 4.0;
if (j == 0) {
pp[j][0] = 2.0;
pp[j][1] = -1.0;
}
if (j == M - 1) {
pp[j][0] = 2.0;
pp[j][1] = 0.0;
}
if (j > 0 && j < M - 1) {
pp[j][0] = 3.0;
pp[j][1] = -1.0;
}
}
for (int j = 0; j < M - 1; ++j) {
pp[j + 1][0] = pp[j + 1][0] + pp[j][1] / pp[j][0];
b[j + 1] = b[j + 1] + b[j] / pp[j][0];
}
for (int j = M - 1; j >= 1; --j) {
f[i][j] = b[j] / pp[j][0];
b[j - 1] -= f[i][j] * pp[j - 1][1];
}
f[i][0] = b[0] / pp[0][0];
}
}
printf("%.10f\n", f[x - 1][y - 1]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18, DELTA = 1e5;
const long double EPS = 1e-7;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
vector<vector<long long> > set_y(n);
vector<vector<pair<long long, long long> > > col(n);
for (long long i = 0; i < n; ++i) {
col[i].push_back({i + 1, -i - 1});
}
for (long long i = 0; i < m; ++i) {
long long a, b;
cin >> a >> b;
if (a == b) {
continue;
}
if (a > b) {
swap(a, b);
}
set_y[b - 1].push_back(a - 1);
}
long long y = 1;
for (long long i = 0; i < n; ++i) {
for (auto x : set_y[i]) {
col[x].push_back({x + 1, y});
col[i].push_back({-y, y});
col[i].push_back({i + 1, y});
++y;
}
}
for (auto v : col) {
cout << (signed)v.size() << "\n";
for (auto it : v) {
cout << it.first + DELTA << " " << it.second + DELTA << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1005;
int n, m;
char B[Maxn][Maxn];
bool stop;
int a[Maxn], b[Maxn];
void writeCols() {
for (int j = 0; j < m; j++)
for (int i = 0; i < n; i++) B[i][j] = '0' + (i % 2 == 0 ? a[j] : b[j]);
for (int i = 0; i < n; i++) printf("%s\n", B[i]);
}
void writeRows() {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) B[i][j] = '0' + (j % 2 == 0 ? a[i] : b[i]);
for (int i = 0; i < n; i++) printf("%s\n", B[i]);
}
bool checkCol(int c, int a, int b) {
for (int i = 0; i < n; i++)
if (B[i][c] != '0' &&
(i % 2 == 0 && B[i][c] != a + '0' || i % 2 && B[i][c] != b + '0'))
return false;
return true;
}
bool checkRow(int r, int a, int b) {
for (int j = 0; j < m; j++)
if (B[r][j] != '0' &&
(j % 2 == 0 && B[r][j] != a + '0' || j % 2 && B[r][j] != b + '0'))
return false;
return true;
}
void checkCols(int c, int i, int j, int k, int l) {
if (c == m) {
writeCols();
stop = true;
} else if (checkCol(c, i, j)) {
a[c] = i;
b[c] = j;
checkCols(c + 1, k, l, i, j);
} else if (checkCol(c, j, i)) {
a[c] = j;
b[c] = i;
checkCols(c + 1, k, l, i, j);
}
}
void checkRows(int r, int i, int j, int k, int l) {
if (r == n) {
writeRows();
stop = true;
} else if (checkRow(r, i, j)) {
a[r] = i;
b[r] = j;
checkRows(r + 1, k, l, i, j);
} else if (checkRow(r, j, i)) {
a[r] = j;
b[r] = i;
checkRows(r + 1, k, l, i, j);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", B[i]);
for (int i = 1; i <= 4 && !stop; i++)
for (int j = i + 1; j <= 4 && !stop; j++)
for (int k = 1; k <= 4 && !stop; k++)
if (k != i && k != j)
for (int l = k + 1; l <= 4 && !stop; l++)
if (l != i && l != j) {
checkCols(0, i, j, k, l);
if (!stop) checkRows(0, i, j, k, l);
}
if (!stop) printf("0\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long maxv, temp;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> s;
temp = 1;
maxv = s[0] - '0';
for (int i = 1; i < s.length(); i++) {
temp *= 9;
maxv *= s[i] - '0';
}
long long sumv = 1;
for (int i = 0; i < s.length(); i++) {
sumv = 1;
for (int j = 0; j < i; j++) {
sumv *= s[j] - '0';
}
sumv *= s[i] - '1';
if (i == 0 && s[i] == '1') sumv = 1;
if (sumv == 0) break;
maxv = max(maxv, sumv * temp);
temp /= 9;
}
cout << maxv;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double Pi = acos(-1.0);
pair<int, int> toPoint[100011];
map<pair<int, int>, int> toIndex;
int N, lo[100011];
bool check(pair<int, int> a) {
if (!toIndex[a]) return false;
for (int dx = -1; dx <= 1; dx++) {
pair<int, int> n(a.first + dx, a.second + 1);
int id = toIndex[n];
if (id && lo[id] <= 1) return false;
}
return true;
}
int main() {
if (fopen("data.in", "r")) freopen("data.in", "r", stdin);
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d", &toPoint[i].first);
scanf("%d", &toPoint[i].second);
toIndex[toPoint[i]] = i;
}
for (int i = 1; i <= N; i++) {
pair<int, int> c = toPoint[i];
for (int dx = -1; dx <= 1; dx++) {
pair<int, int> n(c.first + dx, c.second - 1);
int ind = toIndex[n];
if (ind) lo[i]++;
}
}
set<int> ok;
for (int i = 1; i <= N; i++)
if (check(toPoint[i])) ok.insert(i);
int ans = 0;
for (int i = 1; i <= N; i++) {
int nxt = *(i % 2 ? --ok.end() : ok.begin());
ok.erase(nxt);
if (!check(toPoint[nxt])) {
i--;
continue;
}
toIndex[toPoint[nxt]] = 0;
pair<int, int> c = toPoint[nxt];
for (int dx = -1; dx <= 1; dx++) {
lo[toIndex[pair<int, int>(c.first + dx, c.second + 1)]]--;
if (check(pair<int, int>(c.first + dx, c.second - 1)))
ok.insert(toIndex[pair<int, int>(c.first + dx, c.second - 1)]);
}
ans = ((long long)ans * N + nxt - 1) % 1000000009;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
vector<pair<int, int> > g[100005];
vector<int> tmp1, tmp2;
vector<int> ans, tmp;
int n, m;
int flag;
int vis[100005];
void dfs(int u, int s, int color) {
if (vis[u] != -1) {
if (vis[u] != s) {
flag = 0;
}
return;
}
if (vis[u] == -1) {
vis[u] = s;
if (s == 0)
tmp1.push_back(u);
else
tmp2.push_back(u);
}
for (int i = 0; i < (int)g[u].size(); ++i) {
if (g[u][i].second == color) {
dfs(g[u][i].first, s, color);
} else {
dfs(g[u][i].first, s ^ 1, color);
}
}
}
int main() {
int u, v, t;
char ch;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &u, &v);
cin >> ch;
t = (ch == 'R' ? 0 : 1);
g[u].push_back(make_pair(v, t));
g[v].push_back(make_pair(u, t));
}
int i, j, ff = inf;
for (i = 0; i <= 1; ++i) {
memset(vis, -1, sizeof(vis));
flag = 1;
tmp.clear();
for (j = 1; j <= n; ++j) {
if (vis[j] == -1) {
tmp1.clear();
tmp2.clear();
dfs(j, 0, i);
} else {
continue;
}
if (!flag) break;
if ((int)tmp1.size() < (int)tmp2.size()) {
for (int k = 0; k < (int)tmp1.size(); ++k) {
tmp.push_back(tmp1[k]);
}
} else {
for (int k = 0; k < (int)tmp2.size(); ++k) {
tmp.push_back(tmp2[k]);
}
}
}
if (!flag) continue;
if ((int)tmp.size() < ff) {
ans = tmp;
ff = (int)ans.size();
}
}
if (ff == inf)
printf("-1\n");
else {
printf("%d\n", ff);
sort(ans.begin(), ans.end());
for (int i = 0; i < (int)ans.size(); ++i) printf("%d ", ans[i]);
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int l1, l2, l3, dp[105][105][105];
char s1[105], s2[105], s3[105];
int dfs(int n1, int n2, int n3) {
int ret = -1000000000;
if (n3 == l3) return dp[n1][n2][n3] = -1000000000;
if (n1 > l1 || n2 > l2) return dp[n1][n2][n3] = 0;
if (~dp[n1][n2][n3]) return dp[n1][n2][n3];
if (s1[n1] == s2[n2]) {
if (s3[n3 + 1] == s1[n1]) {
ret = max(dfs(n1 + 1, n2 + 1, n3 + 1) + 1, ret);
if (s3[1] == s1[n1]) {
int res = dfs(n1 + 1, n2 + 1, 1) + 1;
ret = min(ret, res);
}
} else {
int go = (s1[n1] == s3[1]);
ret = max(dfs(n1 + 1, n2 + 1, go) + 1, ret);
}
}
ret = max(ret, max(dfs(n1 + 1, n2, n3), dfs(n1, n2 + 1, n3)));
return dp[n1][n2][n3] = ret;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%s %s %s", s1 + 1, s2 + 1, s3 + 1);
l1 = strlen(s1 + 1);
l2 = strlen(s2 + 1);
l3 = strlen(s3 + 1);
dfs(1, 1, 0);
int n1 = 1, n2 = 1, n3 = 0;
while (n1 <= l1 && n2 <= l2) {
if (s1[n1] == s2[n2]) {
if (s3[n3 + 1] == s1[n1]) {
if (dp[n1][n2][n3] == dp[n1 + 1][n2 + 1][n3 + 1] + 1) {
printf("%c", s1[n1]);
n1++;
n2++;
n3++;
continue;
}
if (s3[1] == s1[n1]) {
if (dp[n1][n2][n3] == dp[n1 + 1][n2 + 1][1]) {
printf("%c", s1[n1]);
n1++;
n2++;
n3 = 1;
continue;
}
}
} else {
int go = (s1[n1] == s3[1]);
if (dp[n1][n2][n3] == dp[n1 + 1][n2 + 1][go] + 1) {
printf("%c", s1[n1]);
n1++;
n2++;
n3 = go;
continue;
}
}
}
if (dp[n1][n2][n3] == dp[n1 + 1][n2][n3]) {
n1++;
continue;
}
if (dp[n1][n2][n3] == dp[n1][n2 + 1][n3]) {
n2++;
continue;
}
}
if (!dp[1][1][0]) printf("0");
}
| 6 |
#include "bits/stdc++.h"
#define ll long long
#define lld long double
#define MOD 1000000007
#define inf 1000000000000000000LL
#define pii pair<lld,lld>
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define all(v) v.begin(),v.end()
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
ll power(ll x,ll y, ll md=inf){ll res = 1;x%=md;while(y){if(y&1)res = (res*x)%md;x *= x; if(x>=md) x %= md; y >>= 1;}return res;}
using namespace std;
#define endl '\n'
#define int ll
int p[300001];
int sz[300001];
int root(int x) {
if(p[x]!=x) return root(p[x]);
return x;
}
void union1(int a, int b) {
int x = root(a);
int y = root(b);
if(x==y) return;
if(sz[x]>sz[y]) swap(x, y);
p[x] = y;
sz[y] += sz[x];
}
signed main() {
fast;
int t;
cin>>t;
while(t--) {
int n;
cin>>n;
vector<int> v[n];
set<int> st;
int w1 = 0;
for(auto& vv:v) {
int num;
cin>>num;
w1 += num*num;
vv = vector<int>(num);
for(auto& x: vv) {
cin>>x;
st.insert(x);
}
}
int cur = 0;
map<int,int> mp;
for(auto x: st) {
mp[x] = cur++;
}
// cout<<"----\n";
for(auto& vv: v) {
for(auto& x: vv) {
x = mp[x];
// cout<<x<<" ";
}
// cout<<endl;
}
// cout<<"----\n";
for(auto&& vv: v) sort(all(vv));
vector<int> v1[mp.size()];
for(int i=0;i<n;i++) {
for(auto x: v[i]) {
v1[x].pb(i);
}
}
int w2 = 0;
for(auto&& vv: v1) {
w2 += (int)vv.size() * (int)vv.size();
}
bool f = false;
if(w1<=w2) {
map<pii,int> mp1;
for(int i=0;i<n;i++) {
for(int j=0;j<v[i].size();j++) {
for(int k=j+1;k<v[i].size();k++) {
if(mp1.count({v[i][j],v[i][k]})) {
cout<<mp1[{v[i][j],v[i][k]}]+1<<" "<<i+1<<endl;
f = true;
break;
}
mp1[{v[i][j],v[i][k]}] = i;
}
if(f) break;
}
if(f) break;
}
if(!f) cout<<-1<<endl;
}
else {
map<pii,int> mp1;
for(int i=0;i<mp.size();i++) {
for(int j=0;j<v1[i].size();j++) {
for(int k=j+1;k<v1[i].size();k++) {
if(mp1.count({v1[i][j],v1[i][k]})) {
int a = mp1[{v1[i][j],v1[i][k]}];
int b = i;
vector<int> res;
for(int ii=0;ii<n;ii++) {
int both = 0;
for(auto x: v[ii]) {
both += (x==a);
both += (x==b);
}
if(both==2) res.pb(ii);
}
assert(res.size()>=2);
for(int ii=0;ii<2;ii++) cout<<res[ii]+1<<" ";
cout<<endl;
f = true;
break;
}
mp1[{v1[i][j],v1[i][k]}] = i;
}
if(f) break;
}
if(f) break;
}
if(!f) cout<<-1<<endl;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int inf = 1e9 + 7;
int n, m, k, dist[N][N];
char s[N][N];
int dx[] = {+1, 0, 0, -1};
int dy[] = {0, -1, +1, 0};
string dir = "DLRU";
bool valid(int nx, int ny) {
if (nx < 0 || nx >= n || ny < 0 || ny >= m || s[nx][ny] == '*') {
return false;
}
return true;
}
void bfs(int x, int y) {
queue<pair<int, int>> q;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
dist[i][j] = inf;
}
}
dist[x][y] = 0;
q.push({x, y});
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i];
int ny = y + dy[i];
if (!valid(nx, ny)) {
continue;
}
if (dist[nx][ny] > dist[x][y] + 1) {
dist[nx][ny] = dist[x][y] + 1;
q.push({nx, ny});
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
if (k & 1) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
int x, y;
for (int i = 0; i < n; ++i) {
cin >> s[i];
for (int j = 0; j < m; ++j) {
if (s[i][j] == 'X') {
x = i;
y = j;
}
}
}
bfs(x, y);
string result = "";
for (int i = 0; i < k; ++i) {
int pos = 0;
while (pos < 4) {
int nx = x + dx[pos];
int ny = y + dy[pos];
if (valid(nx, ny) && dist[nx][ny] <= k - i - 1) {
break;
}
++pos;
}
if (pos == 4) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
x += dx[pos];
y += dy[pos];
result += dir[pos];
}
cout << result << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int siz = 102;
long long inf = 1e15;
struct matrix {
int row, col;
long long data[siz][siz];
matrix() {
row = siz;
col = siz;
memset(data, 0, sizeof data);
}
void print() {
printf("\n");
for (int i = 0; i < row; ++i) {
for (int j = 0; j < col; ++j) {
printf("%lld ", data[i][j]);
}
printf("\n");
}
printf("\n");
}
matrix operator*(const matrix other) const {
matrix result = matrix();
for (int i = 0; i < row; i++) {
for (int j = 0; j < other.col; j++) {
result.data[i][j] = -inf;
for (int k = 0; k < col; k++) {
result.data[i][j] =
max(result.data[i][j], data[i][k] + other.data[k][j]);
}
}
}
result.row = row;
result.col = col;
return result;
}
void init() {
memset(data, 0, sizeof(data));
for (int i = 0; i < siz; ++i) data[i][i] = 0ll;
}
matrix pow_(long long n) {
matrix ret;
ret.init();
if (n == 0) return ret;
if (n == 1) return *this;
matrix P = *this;
while (n) {
if (n & 1) {
ret = ret * P;
}
n = n / 2ll;
P = P * P;
}
return ret;
}
};
long long mem[102][102], n, t, a[102];
int main() {
scanf("%lld", &n);
scanf("%lld", &t);
for (int i = 0; i < n + 0; i++) {
scanf("%lld", &a[i]);
};
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[j] < a[i]) {
mem[i][j] = -inf;
continue;
}
mem[i][j] = 1;
for (int k = 0; k < j; k++)
if (a[k] <= a[j]) {
mem[i][j] = max(mem[i][j], mem[i][k] + 1ll);
}
}
}
matrix tr;
tr.col = n;
tr.row = n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
tr.data[i][j] = mem[i][j];
}
}
tr = tr.pow_(t);
long long ans = -inf;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
ans = max(ans, tr.data[i][j]);
}
}
printf("%lld\n", ans);
}
| 5 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main ()
{
int t;
cin>>t;
while(t--){
ll n;
cin>>n;
vector <ll>v,v1;
for(int i=0;i<3;i++)
{
ll x;
cin>>x;
v.push_back(x);
}
sort(v.begin(),v.end());
//ll m=1000000000000000000ll;
for(int i=0;i<3;i++)
{
ll q = n/v[i];
if(n%v[i]!=0)q++;
ll m=(q*v[i])-n;
// cout<<"q "<<q<<" m "<<m<<endl;
v1.push_back(m);
}
ll m=*min_element(v1.begin(),v1.end());
cout<<m<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, x, y, p, q, low, mid, high;
cin >> t;
while (t--) {
cin >> x >> y >> p >> q;
if ((p == 0 && x > 0) || (p == q && x < y)) {
cout << "-1" << '\n';
continue;
}
if (p * y == x * q) {
cout << 0 << '\n';
continue;
}
low = 1, high = 1e9;
while (low <= high) {
mid = (low + high) / 2;
if ((mid * q < y) || (mid * p < x))
low = mid + 1;
else if (mid * p - x <= mid * q - y)
high = mid - 1;
else
low = mid + 1;
}
cout << low * q - y << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
char grid[53][53];
memset(grid, 0, sizeof grid);
int n, m;
cin >> n >> m;
int sx, sy, ex, ey;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> grid[i][j];
if (grid[i][j] == 'S') {
sx = i;
sy = j;
}
if (grid[i][j] == 'E') {
ex = i;
ey = j;
}
}
}
string s;
cin >> s;
string dir = "0123";
int cnt = 0, dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
do {
int cx = sx, cy = sy;
bool ok = false;
for (int i = 0; i < s.length(); i++) {
int cm = s[i] - '0', mv = dir[cm] - '0';
cx += dx[mv];
cy += dy[mv];
if (cx < 0 || cy < 0 || cx >= n || cy >= m || grid[cx][cy] == '#') break;
if (cx == ex && cy == ey) {
ok = true;
break;
}
}
if (ok) cnt++;
} while (next_permutation(dir.begin(), dir.end()));
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(int a) {
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(int a) {
if (a < 0) {
a = -a;
putchar('-');
}
write(a);
puts("");
}
const int N = 1000005, mod = 1000000007;
inline int ksm(int a, int b) {
int t = 1, y = a;
while (b) {
if (b & 1) t = (long long)t * y % mod;
y = (long long)y * y % mod;
b >>= 1;
}
return t;
}
int n, fac[N], a[N], mx, ans, fff[N], ycl[N];
inline int p(int n, int m) { return (long long)fac[n] * fff[n - m] % mod; }
int main() {
n = read();
fff[0] = fac[0] = 1;
for (int i = 1; i <= n + 1; i++) {
if (i <= n) mx = max(mx, a[i] = read());
fac[i] = (long long)fac[i - 1] * i % mod;
fff[i] = ksm(fac[i], mod - 2);
ycl[i] = ((long long)ycl[i - 1] * i + 1) % mod;
}
sort(&a[1], &a[n + 1]);
for (int i = 1; i <= n; i++)
if (a[i] != mx) {
int t = lower_bound(&a[1], &a[n + 1], a[i]) - a - 1;
ans = (ans + (long long)a[i] * fac[n] % mod *
ksm((long long)(n - t) * fac[t] % mod, mod - 2) % mod *
fac[t]) %
mod;
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, m, k, l;
cin >> n >> m >> k >> l;
printf("%0.9f", (m - n) / (k + l));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
struct sett {
long long x, y;
sett operator-(const sett &a) { return (sett){x - a.x, y - a.y}; }
long long operator^(const sett &a) { return x * a.y - a.x * y; }
} lib[2000005];
long long n;
long long sta[2000005], size = 0;
bool cmp(sett a, sett b) { return (a.x ^ b.x) ? a.x < b.x : a.y > b.y; }
bool aux(sett a, sett b, sett c) { return ((c - a) ^ (c - b)) >= 0; }
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
long long x, y;
scanf("%lld%lld", &x, &y);
lib[i] = (sett){x, y - x * x};
}
sort(lib + 1, lib + n + 1, cmp);
for (long long i = 1; i <= n; i++) {
if (i > 1 && lib[i].x == lib[i - 1].x) continue;
while (size >= 2 && aux(lib[sta[size - 1]], lib[sta[size]], lib[i])) size--;
sta[++size] = i;
}
cout << size - 1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int f[2][1 << 7][2];
long long int g[2][1 << 7][2];
string itos(int v) {
if (v == 0) return "0";
string ans = "";
for (; v != 0; v /= 7) ans = string(1, '0' + (v % 7)) + ans;
return ans;
}
int solve(string s, long long int dp[2][1 << 7][2]) {
int n = s.size();
int rw = 0;
dp[rw][0][0] = 1;
dp[rw][0][1] = 1;
for (int i = n - 1; i >= 0; i--) {
rw ^= 1;
for (int b = 0; b < (1 << 7); b++) {
for (int e = 0; e < 2; e++) {
dp[rw][b][e] = 0;
for (int j = 0; j < 7; j++)
if (b & (1 << j)) {
if (e == 1 && j + '0' > s[i]) continue;
int ne = e;
if (j + '0' != s[i]) ne = 0;
dp[rw][b][e] += dp[rw ^ 1][b ^ (1 << j)][ne];
}
}
}
}
return rw;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
string sn = itos(n - 1);
int rf = solve(sn, f);
string sm = itos(m - 1);
int rg = solve(sm, g);
long long int ans = 0;
for (int a = 0; a < (1 << 7); a++)
if (__builtin_popcount(a) == sn.size()) {
for (int b = 0; b < (1 << 7); b++)
if (__builtin_popcount(b) == sm.size()) {
bool ok = true;
for (int i = 0; i < 7 && ok; i++) {
if (a & (1 << i))
if (b & (1 << i)) ok = false;
}
if (!ok) continue;
ans += f[rf][a][1] * g[rg][b][1];
}
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int INF = 2000000007;
int main() {
int n, x;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
a[i] = x;
}
sort(a.begin(), a.end());
int pars = 0, min = INF;
for (int i = 1; i < n; i++) {
if (a[i] - a[i - 1] < min) {
min = a[i] - a[i - 1];
pars = 1;
} else if ((a[i] - a[i - 1] == min)) {
pars++;
}
}
cout << min << " " << pars;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int N = 1e3 + 5;
using namespace std;
string s;
void init() {
freopen(
"550C"
".inp",
"r", stdin);
freopen(
"550C"
".out",
"w", stdout);
}
void nhap() { getline(cin, s); }
void xuli() {
for (int i = 0; i < s.length(); i++) {
if (s[i] == '0' || s[i] == '8') {
cout << "YES" << endl;
cout << s[i];
return;
}
for (int j = i + 1; j < s.length(); j++) {
int x = s[i] - '0';
int y = s[j] - '0';
int tam = x * 10 + y;
if (tam % 8 == 0) {
cout << "YES" << endl;
cout << x << y;
return;
}
for (int k = j + 1; k < s.length(); k++) {
int x = s[i] - '0';
int y = s[j] - '0';
int z = s[k] - '0';
int tam = x * 100 + y * 10 + z;
if (tam % 8 == 0) {
cout << "YES" << endl;
cout << x << y << z;
return;
}
}
}
}
cout << "NO";
}
int main() {
nhap();
xuli();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
scanf("%d%d", &n, &q);
int odd = 0, even = 0;
for (long i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 2) {
odd += -2 * (odd % 2) + 1;
even += -2 * ((even + 1) % 2) + 1;
} else {
int d;
scanf("%d", &d);
odd += d;
even += d;
}
odd = (n + odd - 1) % n + 1;
even = (n + even - 1) % n + 1;
}
for (long i = 1; i <= n; i++) {
if (i % 2 != odd % 2)
printf("%d", (i + n - odd - 1) % n + 1);
else
printf("%d", (i + n - even - 1) % n + 1);
printf(" ");
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return a.first > b.first;
}
template <typename T>
inline T Bigmod(T base, T power, T MOD) {
T ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
int n;
while (cin >> n) {
int cnt = 0;
while (n--) {
int p, q;
cin >> p >> q;
if ((q - p) >= 2) cnt++;
}
cout << cnt << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200020;
const int mod = 1000000007;
long long int n;
long long int k;
vector<long long int> g[N];
long long int dp[200][60];
long long int tmp[60];
void dfs(long long int x, long long int pa) {
dp[x][0] = 1;
dp[x][k + 1] = 1;
for (auto y : g[x]) {
if (y == pa) continue;
dfs(y, x);
for (long long int i = 0; i < 60; i++) tmp[i] = 0;
for (long long int i = 0; i <= 2 * k; i++) {
for (long long int j = 0; j <= 2 * k; j++) {
if (i + j <= 2 * k) {
tmp[min(i, j + 1)] += dp[x][i] * dp[y][j];
tmp[min(i, j + 1)] %= mod;
} else {
tmp[max(i, j + 1)] += dp[x][i] * dp[y][j];
tmp[max(i, j + 1)] %= mod;
}
}
}
for (long long int i = 0; i <= 2 * k; i++) dp[x][i] = tmp[i];
}
}
int main() {
cin >> n >> k;
for (long long int i = 1; i < n; i++) {
long long int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
long long int ans = 0;
for (long long int i = 0; i <= k; i++) {
ans += dp[1][i];
ans %= mod;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long getD(long long totLen, long long pos) {
if (totLen == 1) return 0;
long long tmp = totLen, cnt = 1;
while (tmp > 4) {
tmp /= 4;
cnt *= 4;
}
long long term = totLen / 4;
if (pos <= term) return getD(term, pos);
if (pos > term && pos <= 2 * term) return getD(term, pos - term);
if (pos > 2 * term && pos <= 3 * term)
return cnt + getD(term, pos - 2 * term);
return cnt * 5 + getD(term, pos - 3 * term);
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%lld", &n);
long long id = (n - 1) / 3 + 1;
long long start = 1, totLen = 1, sum = totLen, pos;
while (sum < id) {
start *= 4;
totLen *= 4;
sum += totLen;
}
pos = id - (sum - totLen);
long long val = (start + (pos - 1)) * 2 - getD(totLen, pos);
if (n % 3 == 1) {
printf("%lld\n", start + pos - 1);
} else if (n % 3 == 2) {
printf("%lld\n", val);
} else {
printf("%lld\n", (start + pos - 1) ^ val);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[5000002];
int main() {
int i, j, k, l, m, n;
scanf("%d", &n);
for (i = 1; i <= n; i++) a[i] = i;
for (i = 2; i <= n; i++) {
if (n % i) a[n + i - 1] = a[n - n % i + i - 1];
for (j = n - n % i - 1; j >= i - 1; j -= i) a[j + i] = a[j];
}
for (i = n; i <= 2 * n - 1; i++) printf("%d ", a[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
double value[MAXN];
int n;
double fun(double x) {
double mn = 0, mx = 0, sum = 0;
for (int i = 0; i < n; i++) {
sum += (value[i] - x);
mn = min(sum, mn);
mx = max(sum, mx);
}
return (mx - mn);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> value[i];
}
double l = -10000.0, r = 10000.0;
for (int i = 0; i < 100; i++) {
double m1 = l + (r - l) / 3.0;
double m2 = r - (r - l) / 3.0;
if (fun(m1) < fun(m2))
r = m2;
else
l = m1;
}
cout << fixed << setprecision(6) << fun(l) << endl;
return 0;
}
| 6 |
#include<bits/stdc++.h>
#define f(i,n) for (int i = 0; i < n; i++)
#define fr(i,n) for (int i = n-1; i >= 0; i--)
#define feq(i,k,n) for (int i = k; i <= n; i++)
#define frq(i,k,n) for (int i = k; i >= n; i--)
#define print(a) for (auto i:a) cout<<i<<" "; cout<<endl;
#define re return
#define en "\n"
#define pb push_back
#define fir first
#define sec second
#define MOD 1000000007
using namespace std;
typedef long long int ll;
typedef pair<ll,ll> pl;
typedef long double ld;
typedef vector<ll> vec;
void solve(){
int n; cin>>n;
if(n%2==0){
for(int i=1; i<n; i+=2){
cout<<i+1<<" "<<i<<" ";
}
cout<<en;
}
else{
cout<<3<<" "<<1<<" "<<2<<" ";
for(int i=4; i<n; i+=2){
cout<<i+1<<" "<<i<<" ";
}
cout<<en;
}
}
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int tc;
cin>>tc;
// tc=1;
while(tc--){
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 10;
const int INF = (1u << 31) - 1;
bool like[MN][MN];
map<string, int> mp;
int st[MN];
int b1 = INF, b2 = -1;
int g[3];
int n;
string a, b, temp;
void back_track(int a) {
if (a == 7) {
int mx = -1, mn = INF;
int cnt[10];
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < 7; i++) cnt[st[i]]++;
for (int i = 0; i < 3; i++)
if (cnt[i] == 0) return;
for (int i = 0; i < 7; i++) {
int temp = g[st[i]] / cnt[st[i]];
mx = max(mx, temp);
mn = min(mn, temp);
}
if (mx - mn > b1) return;
int fr = 0;
for (int i = 0; i < 7; i++)
for (int j = 0; j < 7; j++)
if (st[i] == st[j] && like[i][j]) fr++;
if ((mx - mn) < b1 || ((mx - mn) == b1 && fr > b2)) {
b1 = mx - mn;
b2 = fr;
}
return;
}
for (int i = 0; i < 3; i++) st[a] = i, back_track(a + 1);
}
int main() {
mp["Anka"] = 0;
mp["Chapay"] = 1;
mp["Cleo"] = 2;
mp["Troll"] = 3;
mp["Dracul"] = 4;
mp["Snowy"] = 5;
mp["Hexadecimal"] = 6;
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> temp >> b;
like[mp[a]][mp[b]] = 1;
}
cin >> g[0] >> g[1] >> g[2];
back_track(0);
cout << b1 << " " << b2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
int n;
cin >> n;
vector<int> q(n);
for (int i = 0; i < n; ++i) cin >> q[i];
vector<int> cost(n, -1);
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
if (cost[b - 1] == -1 || cost[b - 1] > c) {
cost[b - 1] = c;
}
}
int ans = 0, head = 0;
for (int i = 0; i < n; ++i) {
if (cost[i] != -1)
ans += cost[i];
else
head++;
}
if (head > 1)
cout << -1 << endl;
else {
if (!head) {
int maxx = cost[0];
for (int i = 1; i < n; ++i) maxx = max(maxx, cost[i]);
ans -= maxx;
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)5e5;
int v[MAXN + 1];
int aib[MAXN + 1];
bool dp[MAXN + 1];
inline void update(int pos, int n, int val) {
for (int i = pos; i <= n; i += (i & (-i))) {
aib[i] += val;
}
}
inline int query(int pos) {
int ans = 0;
for (int i = pos; i > 0; i -= (i & (-i))) {
ans += aib[i];
}
return ans;
}
int main() {
int i, n, k, d;
ios::sync_with_stdio(false);
cin >> n >> k >> d;
for (i = 1; i <= n; i++) {
cin >> v[i];
}
sort(v + 1, v + n + 1);
int pos = 1;
for (i = 1; i <= n; i++) {
while (pos <= n && v[i] - v[pos] > d) {
pos++;
}
if (pos == 1) {
dp[i] = (i >= k);
} else {
dp[i] = ((query(i - k) - query(pos - 2)) > 0);
}
update(i, n, dp[i]);
}
if (dp[n] == 1) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, t;
cin >> n >> t;
long int arr[n + 1];
bool visited[n + 1];
for (long int i = 1; i < n; i++) {
cin >> arr[i];
visited[i] = false;
}
long int i = 1;
while (visited[i] == false && i != t && i != n) {
visited[i] = true;
i = i + arr[i];
}
if (i == t) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 200200;
const int N = 5;
const int T = 133;
int fact[] = {1, 1, 2, 6, 24, 120};
int n, m;
int F;
array<int, N> operator*(const array<int, N> &a, const array<int, N> &b) {
array<int, N> c;
fill((c).begin(), (c).end(), 0);
for (int i = 0; i < m; ++i) c[i] = a[b[i]];
return c;
}
array<int, N> I;
vector<array<int, N>> perms;
int x[T][T];
int a[M];
int nx[M][T];
set<set<int>> groups;
map<pair<array<bool, T>, int>, array<bool, T>> mem;
int id(const array<int, N> &p) {
int ans = lower_bound((perms).begin(), (perms).end(), p) - perms.begin();
assert(ans < (int)perms.size());
return ans;
}
void read() {
cin >> n >> m;
for (int i = 0; i < m; ++i) I[i] = i;
array<int, N> cur = I;
F = fact[m];
for (int i = 0; i < F; ++i) {
perms.push_back(cur);
next_permutation(cur.begin(), cur.begin() + m);
}
sort((perms).begin(), (perms).end());
for (int i = 0; i < F; ++i)
for (int j = 0; j < F; ++j) {
x[i][j] = id(perms[i] * perms[j]);
}
for (int i = 0; i < n; ++i) {
array<int, N> cur;
fill((cur).begin(), (cur).end(), 0);
for (int j = 0; j < m; ++j) {
cin >> cur[j];
--cur[j];
}
a[i] = id(cur);
}
}
int sz(array<bool, T> s) {
int ans = 0;
for (int i = 0; i < F; ++i)
if (s[i]) ++ans;
return ans;
}
array<bool, T> add(array<bool, T> g, int i) {
pair<array<bool, T>, int> tut = make_pair(g, i);
if (mem.count(tut)) return mem[tut];
g[i] = true;
static int q[T];
int qs = 0, qf = 0;
for (int i = 0; i < F; ++i)
if (g[i]) q[qf++] = i;
while (qs < qf) {
int i = q[qs++];
for (int j = 0; j < F; ++j)
if (g[j]) {
if (!g[x[i][j]]) {
g[x[i][j]] = true;
q[qf++] = x[i][j];
}
if (!g[x[j][i]]) {
g[x[j][i]] = true;
q[qf++] = x[j][i];
}
}
}
return mem[tut] = g;
}
void kill() {
for (int i = 0; i < F; ++i) nx[n][i] = n;
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < F; ++j) nx[i][j] = nx[i + 1][j];
assert(0 <= a[i] && a[i] < F);
nx[i][a[i]] = i;
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
array<bool, T> cur;
fill((cur).begin(), (cur).end(), false);
cur[id(I)] = true;
cur = add(cur, a[i]);
int r = i;
while (r < n) {
int to = n;
for (int t = 0; t < F; ++t)
if (!cur[t]) to = min(to, nx[i][t]);
ans += (to - r) * sz(cur);
if (to < n) {
cur = add(cur, a[to]);
}
r = to;
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
read();
kill();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int d[2001];
int e[2001];
int f[2001][2001];
int dp(int p, int q) {
if (f[p][q] > 0) return f[p][q];
if (q == 0) {
f[p][q] = (long long)p * dp(p - 1, 0) % 1000000007;
} else if (q == 1) {
f[p][q] = (long long)p * dp(p, 0) % 1000000007;
} else {
f[p][q] = ((long long)p * dp(p, q - 1) % 1000000007 +
(long long)(q - 1) * dp(p + 1, q - 2) % 1000000007) %
1000000007;
}
return f[p][q];
}
int main() {
int n, p = 0, q = 0;
int i;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> d[i];
e[d[i]] = 1;
}
for (i = 1; i <= n; ++i) {
if (e[i] == 0) {
if (d[i] == -1)
++q;
else
++p;
}
}
f[0][0] = 1;
cout << dp(p, q) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int a;
unsigned long long b;
bool operator<(const point A) const {
if (a != A.a) return a < A.a;
return b < A.b;
}
};
int l;
unsigned long long d[30], r[30], two[30], n, m;
int wh[(1 << 18) + 10];
queue<point> Q;
unsigned long long dp[110][(1 << 18) + 10];
int lowbit(int t) { return t & (-t); };
int main() {
int i, j, k, last;
bool f, fq;
point A, B;
while (~scanf("%I64u%I64u", &n, &m)) {
unsigned long long t = n;
l = 0;
while (t > 0) {
d[++l] = t % 10;
t /= 10;
}
sort(d + 1, d + l + 1);
r[0] = 0;
r[l] = 1;
for (i = l - 1; i > 0; i--) r[i] = (r[i + 1] * 10) % m;
two[0] = 1;
for (i = 1; i <= l; i++) two[i] = (two[i - 1] << 1);
wh[0] = 0;
for (i = 1; i < (1 << l); i++) wh[i] = wh[i - lowbit(i)] + 1;
for (i = 0; i < m; i++)
for (j = 0; j < (1 << l); j++) dp[i][j] = 0;
while (!Q.empty()) Q.pop();
A.a = 0;
A.b = (1uLL << l) - 1;
dp[A.a][A.b] = 1;
Q.push(A);
last = wh[A.b];
i = -1;
last = -1;
while (!Q.empty()) {
A = Q.front();
Q.pop();
if (wh[A.b] != last) i++;
last = wh[A.b];
f = false;
for (k = 1; k <= l; k++) {
if (f && d[k] == d[k - 1]) continue;
if (k == 1 || d[k] != d[k - 1]) f = 0;
if (i == 0 && d[k] == 0) continue;
if (two[k - 1] & A.b) {
f = 1;
B.a = (d[k] * r[i + 1] + A.a) % m;
B.b = A.b ^ two[k - 1];
if (dp[B.a][B.b] == 0) {
dp[B.a][B.b] = dp[A.a][A.b];
Q.push(B);
} else
dp[B.a][B.b] += dp[A.a][A.b];
}
}
}
printf("%I64u\n", dp[0][0]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
void __never(int a) { printf("\nOPS %d", a); }
long long A;
string B, C;
string to_roman(int x) {
string I[] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
string X[] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
string C[] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
string M[] = {"", "M", "MM", "MMM"};
string re;
re = I[x % 10] + re;
x /= 10;
re = X[x % 10] + re;
x /= 10;
re = C[x % 10] + re;
x /= 10;
re = M[x % 10] + re;
return re;
}
long long to_dec(string s, long long base) {
long long re = 0;
for (int a = (0); a <= ((int)((s).size()) - 1); a++)
if ('0' <= s[a] && s[a] <= '9')
re = re * base + (long long)(s[a] - '0');
else if ('A' <= s[a] && s[a] <= 'Z')
re = re * base + (long long)(s[a] - 'A' + 10);
return re;
}
string to_to(long long num, long long base) {
string re;
while (num > 0) {
long long rem = num % base;
if (rem <= 9)
re = string(1, '0' + rem) + re;
else
re = string(1, 'A' + rem - 10) + re;
num /= base;
}
if (re == "") re = "0";
return re;
}
int main() {
cin >> A >> B >> C;
long long z = to_dec(C, A);
if (B == "R")
cout << to_roman(z);
else {
int ba;
sscanf(B.c_str(), "%d", &ba);
cout << to_to(z, ba);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long pow(int a, int b, long long MOD) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > MOD) x %= MOD;
}
y = (y * y);
if (y > MOD) y %= MOD;
b /= 2;
}
return x;
}
long long InverseEuler(int n, long long MOD) { return pow(n, MOD - 2, MOD); }
int hcf(int n1, int n2) {
if (n2 != 0)
return hcf(n2, n1 % n2);
else
return n1;
}
int p[100090] = {};
void prime() {
for (int i = 2; i * i <= 100009; i++)
if (p[i] == 0)
for (int j = i + i; j <= 100009; j += i) p[j] = 1;
p[0] = 1;
p[1] = 1;
}
void bfs(int n) {
queue<string> q;
q.push("0");
q.push("1");
int c = 0;
while (!q.empty()) {
string d = q.front();
q.pop();
string d1 = q.front();
q.pop();
if (d.length() == n || d1.length() == n) {
cout << d << " ";
cout << d1 << " ";
}
if (d.length() < n && d1.length() < n) {
string f = "", e = "", f1 = "", e1 = "";
f = "0" + d, e = "0" + d1;
f1 = "1" + d1;
e1 = "1" + d;
q.push(f);
q.push(e);
q.push(f1);
q.push(e1);
}
}
}
int main() {
map<int, int> m;
m[2] = 1;
m[4] = 4;
m[5] = 5;
m[3] = 7;
m[7] = 8;
m[6] = 9;
int n;
cin >> n;
int mx = 0;
if (n % 2 == 1) {
cout << 7;
n -= 3;
}
while (n > 0 && n % 2 == 0) {
cout << 1;
n -= 2;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char g[2020][2020];
int du[2020][2020];
queue<pair<int, int> > q;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
int check(int x, int y) {
if (x < 1 || x > n || y < 1 || y > m) return 0;
if (g[x][y] == '.') return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", g[i] + 1);
if (n == 1 && m == 1 && g[1][1] == '*') {
puts("*");
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (g[i][j] == '.') {
for (int d = 0; d < 4; d++) du[i][j] += check(i + dx[d], j + dy[d]);
if (du[i][j] == 1) q.push(make_pair(i, j));
}
}
}
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
if (g[x][y] != '.') continue;
int tmp = -1;
for (int d = 0; d < 4; d++) {
if (g[x + dx[d]][y + dy[d]] == '.') {
tmp = d;
break;
}
}
switch (tmp) {
case 0:
g[x][y] = '<';
g[x][y + 1] = '>';
break;
case 1:
g[x][y] = '^';
g[x + 1][y] = 'v';
break;
case 2:
g[x][y] = '>';
g[x][y - 1] = '<';
break;
case 3:
g[x][y] = 'v';
g[x - 1][y] = '^';
break;
}
x = x + dx[tmp], y = y + dy[tmp];
for (int d = 0; d < 4; d++)
if (g[x + dx[d]][y + dy[d]] == '.')
if ((--du[x + dx[d]][y + dy[d]]) == 1) {
q.push(make_pair(x + dx[d], y + dy[d]));
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (g[i][j] == '.') {
puts("Not unique");
return 0;
}
for (int i = 1; i <= n; i++) printf("%s\n", g[i] + 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, mn = INT_MAX;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int x = 0; x < n; x++) {
int count = 0;
for (int i = 0; i < n; i++) {
count += 2 * (a[i] * (abs(i - x) + x + i));
}
mn = min(count, mn);
}
cout << mn << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
int mem[3][3][N];
int n, a[N], f[N], m;
int dp(int complete, int not_complete, int i) {
if (i == m + 1) return 0;
int &ret = mem[complete][not_complete][i];
if (ret != -1) return ret;
if (complete + not_complete > f[i]) {
ret = 0;
return ret;
}
ret = dp(not_complete, 0, i + 1) + (f[i] - complete - not_complete) / 3 +
complete;
if (f[i] - complete - not_complete - 1 >= 0)
ret = max(ret, dp(not_complete, 1, i + 1) + complete +
(f[i] - complete - not_complete - 1) / 3);
if (f[i] - complete - not_complete - 2 >= 0)
ret = max(ret, dp(not_complete, 2, i + 1) + complete +
(f[i] - complete - not_complete - 2) / 3);
return ret;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
f[a[i]]++;
}
memset(mem, -1, sizeof mem);
cout << dp(0, 0, 1);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, p, q, r, a[100000], s = -3000000000000000000, dpmi[100000],
dpma[100000], dppmi[100000],
dppma[100000], i;
cin >> n >> p >> q >> r;
for (i = 0; i < n; i++) cin >> a[i];
dpmi[0] = a[0];
dpma[0] = a[0];
dppmi[n - 1] = a[n - 1];
dppma[n - 1] = a[n - 1];
for (i = 1; i < n; i++) {
dpma[i] = max(dpma[i - 1], a[i]);
dpmi[i] = min(dpmi[i - 1], a[i]);
}
for (i = n - 2; i >= 0; i--) {
dppma[i] = max(dppma[i + 1], a[i]);
dppmi[i] = min(dppmi[i + 1], a[i]);
}
for (i = 0; i < n; i++) {
if (p > 0) {
if (r > 0) {
s = max(s, p * dpma[i] + q * a[i] + r * dppma[i]);
} else {
s = max(s, p * dpma[i] + q * a[i] + r * dppmi[i]);
}
} else {
if (r > 0) {
s = max(s, p * dpmi[i] + q * a[i] + r * dppma[i]);
} else {
s = max(s, p * dpmi[i] + q * a[i] + r * dppmi[i]);
}
}
}
cout << s;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, d;
long long ans;
pair<int, int> a[100001];
long long prefix[100001];
int main() {
cin >> n >> d;
for (int i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
prefix[i] = prefix[i - 1] + a[i].second;
}
for (int i = 1; i <= n; i++) {
int mini = i, maxi = n, mid = (mini + maxi + 1) / 2;
while (mini != maxi) {
if (a[i].first + d > a[mid].first) {
mini = mid;
} else {
maxi = --mid;
}
mid = (mini + maxi + 1) / 2;
}
ans = max(ans, prefix[mid] - prefix[i - 1]);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
using namespace std;
const long long infl = 2e18;
const long long infi = 2e9;
const long long mod = 1e9 + 7;
mt19937 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
auto clk = clock();
long long rng(long long lim) {
uniform_int_distribution<long long> uid(0, lim);
return uid(rang);
}
long long a[200005];
vector<long long> ld, ld2, res;
vector<pair<long long, long long> > segs, segs2;
vector<long long> reduce(vector<long long> ld) {
ld.clear();
return ld2;
}
bool check(long long i) {
long long te = (1 << 30) - 1 - i;
for (long long ii : ld) {
if (te < (ii ^ te)) {
te ^= ii;
}
}
if (te + 1 == (1 << 30)) return 0;
return 1;
}
void solve() {
long long n;
cin >> n;
long long xorian = 0;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
xorian ^= a[i];
}
if (xorian == 0) {
cout << -1 << '\n';
return;
}
segs.push_back({1, n});
ld.push_back(xorian);
bool notdone = 1;
while (notdone) {
notdone = 0;
for (long long ii = 0; ii < segs.size(); ii++) {
auto &temp = segs[ii];
long long xo = 0;
for (long long i = temp.first; i < temp.second && (!notdone); i++) {
xo ^= a[i];
if (check(xo)) {
ld.push_back(xo);
for (long long j = 29; j >= 0; j--) {
for (long long i : ld) {
if (i & (1 << j)) {
ld2.push_back(i);
for (long long &k : ld) {
if (k & (1 << j)) k ^= i;
}
break;
}
}
}
ld2.swap(ld);
ld2.clear();
for (long long j = 0; j < ii; j++) segs2.push_back(segs[j]);
segs2.push_back({temp.first, i});
segs2.push_back({i + 1, temp.second});
for (long long j = ii + 1; j < segs.size(); j++)
segs2.push_back(segs[j]);
segs.swap(segs2);
segs2.clear();
notdone = 1;
}
}
if (notdone) break;
}
}
cout << ld.size() << '\n';
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
long long t = 1;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, T, r, a[10000], cnt[301] = {0};
set<int> lis;
int conv(int v, int bi, int pi) { return v * (100 * 100) + bi * 100 + pi; }
void calc_lis() {
lis.insert(a[0]);
for (int i = (1); i < (n * r); i++) {
auto it = lis.upper_bound(a[i]);
if (it != lis.end()) lis.erase(it);
lis.insert(a[i]);
}
}
int main() {
cin >> n >> T;
r = min(n, T);
for (int i = (0); i < (n); i++) {
cin >> a[i];
cnt[a[i]]++;
}
for (int i = (1); i < (r); i++)
for (int j = (0); j < (n); j++) a[n * i + j] = a[j];
for (int i = (0); i < (r); i++)
for (int j = (0); j < (n); j++) a[n * i + j] = conv(a[n * i + j], i, j);
calc_lis();
int mx = -1;
for (int i = (0); i < (301); i++) mx = max(mx, cnt[i]);
cout << lis.size() + max(0, T - n) * mx;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int vet[100001], tmp[100001], n, m, resa[100001], resb[100001], ma, mb, p;
map<int, int> a, b, pos;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &vet[i]), tmp[i] = vet[i];
sort(vet, vet + n);
for (int i = 0; i < n; ++i) pos[vet[i]] = i;
m = (n + 2) / 3;
ma = m, mb = m;
p = 0;
for (; p < n && ma; ++p) {
if (a.count(0)) --ma;
a[0]++;
b[vet[p]]++;
resa[p] = 0;
resb[p] = vet[p];
}
for (; p < n && mb; ++p) {
if (b.count(0)) --mb;
b[0]++;
a[vet[p]]++;
resa[p] = vet[p];
resb[p] = 0;
}
for (int i = p; i < n; ++i) {
int la = n - i;
resa[i] = la;
resb[i] = vet[i] - la;
}
printf("YES\n");
for (int i = 0; i < n; ++i) printf("%d ", resa[pos[tmp[i]]]);
printf("\n");
for (int i = 0; i < n; ++i) printf("%d ", resb[pos[tmp[i]]]);
printf("\n");
}
| 8 |
/*
／＞ フ
| _ _|
／`ミ _x 彡 * MEOW *
/ |
/ ヽ ﾉ
／￣| | | |
| (￣ヽ＿_ヽ_)_)
＼二つ
*/
#include <bits/stdc++.h>
#define ll long long
#define db(x) cout << (#x) << " = " << x << "\n" ;
#define pb push_back
#define mt make_tuple
#define F first
#define S second
using namespace std;
bool comp(pair <ll , ll> &a , pair <ll , ll> &b){
ll s1 = a.F + a.S , s2 = b.F + b.S;
if(s1==s2){
return a.F < b.F;
} else return s1 < s2;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
/* uWu */
ll t;
cin >> t;
while(t--){
ll n , k;
cin >> n >> k;
vector < pair < ll , ll > > arr;
for(ll i = 0;i<n;i++){
ll a , b;
cin >> a >> b;
arr.pb({a,b});
}
ll extreme_d = 0 , found = 0;
for(ll i=0;i<n;i++){
ll a = arr[i].F , b = arr[i].S;
found = 1;
for(ll j=0;j<n;j++){
ll c = arr[j].F , d = arr[j].S;
if(abs(a-c) + abs(b-d)>k) found = 0;
}
if(found) break;
}
if(found){
cout << 1 << "\n";
} else {
cout << -1 << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int x[3555], y[3555], cnt[3555], pre[3555], nxt[3555];
vector<int> v, v2[3555];
bool cmp(int a, int b) { return y[a] < y[b]; }
bool dfs(int x, int lef) {
if ((!x) || (!lef)) return 0;
if (dfs(pre[x], lef - 1)) cnt[pre[x]] = 0;
cnt[pre[x]] += cnt[x];
return 1;
}
int main() {
int r, c, n, k;
long long ans = 0;
scanf("%d%d%d%d", &r, &c, &n, &k);
for (int i = 1; i <= n; i++)
scanf("%d%d", &x[i], &y[i]), v2[x[i]].push_back(i);
y[3001] = c + 1;
for (int i = 1; i <= r; i++) {
memset(cnt, 0, sizeof(cnt));
memset(pre, 0, sizeof(pre));
memset(nxt, 0, sizeof(nxt));
v.clear();
for (int j = 1; j <= n; j++)
if (x[j] >= i) v.push_back(j);
if (!v.size()) continue;
sort(v.begin(), v.end(), cmp);
long long sum = 0;
int now = 0;
for (int j = 1; j < v.size(); j++) pre[v[j]] = v[j - 1];
pre[v[0]] = 0;
for (int j = 0; j < ((int)v.size()) - 1; j++) nxt[v[j]] = v[j + 1];
nxt[v[v.size() - 1]] = 3001;
for (int j = 1; j <= c; j++) {
while (now < v.size() && y[v[now]] == j) now++;
int tmp = now ? v[now - 1] : 0;
for (int d = k - 2; d >= 0; d--) tmp = pre[tmp];
cnt[tmp]++;
}
for (int j = 0; j < v.size(); j++) sum += y[v[j]] * cnt[v[j]];
now = 0;
for (int j = r; j >= i; j--) {
ans += sum;
for (int d = 0; d < v2[j].size(); d++) {
int t = v2[j][d];
for (int cc = 1; t > 0 && cc <= k; cc++)
sum -= cnt[t] * (y[t] - y[pre[t]]), t = pre[t];
dfs(v2[j][d], k);
t = v2[j][d];
pre[nxt[t]] = pre[t];
nxt[pre[t]] = nxt[t];
}
}
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long a[210005];
long long dp[250][250];
int main() {
long long i, j, k, l, n, x, tt;
scanf("%lld%lld%lld", &n, &k, &x);
for (i = 1; i <= n; i++) scanf("%lld", &a[i]);
memset(dp, -1000000007, sizeof(dp));
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
tt = 0;
tt = max(i - k, tt);
for (j = tt; j <= i - 1; j++) {
for (l = 0; l < x; l++) dp[i][l + 1] = max(dp[i][l + 1], dp[j][l] + a[i]);
}
}
long long maxn;
maxn = -1;
for (i = n; i > n - k; i--) maxn = max(maxn, dp[i][x]);
printf("%lld\n", maxn);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, t, u[1000005], v[1000005], w[1000005], first[1000005],
nxt[1000005];
long long f[500005][2], d[500005], tot;
inline bool cmp(long long a, long long b) { return a > b; }
inline void dfs(long long now, long long fa) {
long long num = 0;
for (long long i = first[now]; i; i = nxt[i]) {
if (v[i] == fa) continue;
dfs(v[i], now);
num += f[v[i]][0];
}
tot = 0;
for (long long i = first[now]; i; i = nxt[i]) {
if (v[i] == fa) continue;
d[++tot] = f[v[i]][1] + w[i] - f[v[i]][0];
}
sort(d + 1, d + 1 + tot, cmp);
long long sum = 0;
f[now][0] = f[now][1] = num;
for (long long i = 1; i <= tot; i++) {
sum += d[i];
if (i <= k) f[now][0] = max(f[now][0], num + sum);
if (i < k) f[now][1] = max(f[now][1], num + sum);
}
return;
}
signed main() {
cin >> t;
while (t--) {
cin >> n >> k;
for (long long i = 1; i < n; i++) {
scanf("%lld%lld%lld", &u[i], &v[i], &w[i]);
nxt[i] = first[u[i]], first[u[i]] = i;
u[i + n] = v[i], v[i + n] = u[i], w[i + n] = w[i];
nxt[i + n] = first[u[i + n]], first[u[i + n]] = i + n;
}
dfs(1, 0);
cout << f[1][0] << endl;
for (long long i = 1; i <= n; i++) f[i][0] = f[i][1] = 0;
for (long long i = 1; i <= n * 2; i++) first[i] = nxt[i] = 0;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int total_sum = accumulate(v.begin(), v.end(), 0);
int sum = 0, a, b;
cin >> a >> b;
int start = (a < b) ? a : b;
int end = a + b - start;
for (int i = start - 1; i < end - 1; i++) {
sum += v[i];
}
if (sum <= total_sum - sum)
cout << sum << "\n";
else
cout << total_sum - sum << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, p, sum, B;
int n;
int a[1000005];
int getMax(long long m, long long X, long long Y) {
long long mat[2][2] = {{1, 1}, {1, 0}};
swap(Y, X);
while (m > 0) {
if (m % 2 == 1) {
long long v = mat[0][0] * X + mat[0][1] * Y,
w = mat[1][0] * X + mat[1][1] * Y;
v %= p;
w %= p;
X = v;
Y = w;
}
long long nat[2][2] = {};
for (int i = 0; i < 2; i++)
for (int k = 0; k < 2; k++)
for (int j = 0; j < 2; j++)
nat[i][j] = (nat[i][j] + mat[i][k] * mat[k][j]) % p;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) mat[i][j] = nat[i][j];
m /= 2;
}
return (int)(X % p);
}
long long bigmod(long long A, long long m) {
if (m == 0) return 1;
if (m == 1) return A;
long long r = bigmod(A * A % p, m / 2);
if (m % 2) r = r * A % p;
return r;
}
long long calSum(long long m) {
if (m == 0) return 0;
if (m == 1) return 1;
long long r = calSum(m / 2);
r = (1 + bigmod(3, m / 2)) * r % p;
if (m % 2) r = (r * 3 + 1) % p;
return r;
}
int getSum(long long m, long long X, long long Y) {
if (m == 0) return X % p;
if (m == 1) return ((3 * X - Y) % p + p) % p;
return (bigmod(3, m) * X % p - calSum(m) * Y % p + p) % p;
}
void solve() {
if (n == 1) {
printf("%d\n", (int)(a[1] % p));
return;
}
sum = getSum(x, sum, B);
B = (a[1] + getMax(x, a[n - 1], a[n])) % p;
sum = getSum(y, sum, B);
sum = (sum % p + p) % p;
printf("%d\n", (int)sum);
}
int main(void) {
scanf("%d%I64d%I64d%I64d", &n, &x, &y, &p);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) sum += a[i];
B = a[1] + a[n];
sum %= p;
B %= p;
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1.0);
const long long mod7 = 1000000007;
const long long mod9 = 1000000009;
const int linf = 2000000000;
const long long llinf = 1000000000000000000ll;
vector<long long> p, t;
long long gcd(long long a, long long b) {
while (b) {
a %= b;
a ^= b ^= a ^= b;
}
return a;
}
int main() {
long long n, m, temp;
cin >> n >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> temp;
p.push_back(temp);
}
for (int i = 0; i < m; ++i) {
cin >> temp;
t.push_back(temp);
}
long long best = 100000;
for (int i = 0; i < n; ++i) {
long long total = 0;
for (int j = 0; j < m; ++j) {
if (t[j] % p[i] == 0) ++total;
}
best = min(total, best);
}
vector<int> ans;
for (int i = 0; i < n; ++i) {
long long total = 0;
for (int j = 0; j < m; ++j) {
if (t[j] % p[i] == 0) {
++total;
}
}
if (total == best) {
ans.push_back(i + 1);
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i] << ' ';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long mod = 1e9 + 7, n, q;
vector<long> v1[500005], vis;
long times = 1, childs[500005], entry[500005], indexs[500005];
long dfs(long u) {
vis[u] = 1;
entry[u] = times++;
indexs[entry[u]] = u;
for (auto it : v1[u]) {
if (!vis[it]) {
dfs(it);
childs[u] += childs[it];
}
}
return childs[u] += 1;
}
int main() {
cin >> n >> q;
vis.assign(n + 1, false);
for (long i = 1; i < n; i++) {
long x;
cin >> x;
v1[x].push_back(i + 1);
v1[i + 1].push_back(x);
}
for (long i = 1; i < n + 1; i++) sort(v1[i].begin(), v1[i].end());
dfs(1);
while (q--) {
long x, k;
cin >> x >> k;
if (k > childs[x])
cout << "-1\n";
else {
long diff = k - 1 + entry[x];
cout << indexs[diff] << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline void mood(long long &x) {
if (x < 0) x += 1000000007;
if (x >= 1000000007) x -= 1000000007;
}
inline long long modMul(long long a, long long b) {
normal(a);
normal(b);
a *= b;
normal(a);
return a;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
inline long long power(long long bs, long long k) {
long long x = 1LL, y = bs;
if (k == 0) return 1LL;
while (k > 0) {
if (k % 2) x *= y;
y *= y;
k /= 2;
}
return x;
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const pair<first, second> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
string to_str(T t) {
stringstream ss;
ss << t;
return ss.str();
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const map<first, second> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
clock_t tStart = clock();
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
int cap[200][200], cost[200][200], fnet[200][200], adj[200][200], deg[200],
par[200], d[200], pi[200];
bool dijkstra(int n, int s, int t) {
for (int i = 0; i < n; i++) d[i] = (INT_MAX / 2), par[i] = -1;
d[s] = 0;
par[s] = -n - 1;
while (1) {
int u = -1, bestD = (INT_MAX / 2);
for (int i = 0; i < n; i++) {
if (par[i] < 0 && d[i] < bestD) bestD = d[u = i];
}
if (bestD == (INT_MAX / 2)) break;
par[u] = -par[u] - 1;
for (int i = 0; i < deg[u]; i++) {
int v = adj[u][i];
if (par[v] >= 0) continue;
if (fnet[v][u] && d[v] > (d[u] + pi[u] - pi[v]) - cost[v][u])
d[v] = (d[u] + pi[u] - pi[v]) - cost[v][u], par[v] = -u - 1;
if (fnet[u][v] < cap[u][v] && d[v] > (d[u] + pi[u] - pi[v]) + cost[u][v])
d[v] = (d[u] + pi[u] - pi[v]) + cost[u][v], par[v] = -u - 1;
}
}
for (int i = 0; i < n; i++)
if (pi[i] < (INT_MAX / 2)) pi[i] += d[i];
return par[t] >= 0;
}
int mcmf3(int n, int s, int t, int &fcost) {
memset(deg, 0, sizeof(deg));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (cap[i][j] || cap[j][i]) adj[i][deg[i]++] = j;
memset(fnet, 0, sizeof(fnet));
memset(pi, 0, sizeof(pi));
int flow = fcost = 0;
while (dijkstra(n, s, t)) {
int bot = INT_MAX;
for (int v = t, u = par[v]; v != s; u = par[v = u]) {
bot = min(bot, fnet[v][u] ? fnet[v][u] : cap[u][v] - fnet[u][v]);
}
for (int v = t, u = par[v]; v != s; u = par[v = u]) {
if (fnet[v][u]) {
fnet[v][u] -= bot;
fcost -= bot * cost[v][u];
} else {
fnet[u][v] += bot;
fcost += bot * cost[u][v];
}
}
flow += bot;
}
return flow;
}
int main() {
string t, s;
cin >> t;
int sz = (int)t.size(), cnt[200], i, j;
memset(cnt, 0, sizeof(cnt));
memset(cost, 0, sizeof(cost));
memset(cap, 0, sizeof(cap));
for (i = 0; i < sz; ++i) {
++cnt[(t[i] - 'a') + 1];
}
for (i = 1; i <= 26; ++i) cap[i][150] = cnt[i];
int x, y;
cin >> x;
for (i = 0; i < x; ++i) {
cin >> s >> y;
memset(cnt, 0, sizeof(cnt));
sz = (int)s.size();
cap[0][i + 27] = y;
for (j = 0; j < sz; ++j) ++cnt[(s[j] - 'a') + 1];
for (j = 1; j <= 26; ++j) {
cap[i + 27][j] = cnt[j];
cost[i + 27][j] = i + 1;
}
}
int fcost = 0;
int ss = 0, tt = 150;
int flow = mcmf3(200 - 1, ss, tt, fcost);
if (flow != (int)t.size())
cout << -1;
else
cout << fcost;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool ask(int x, int y) {
printf("? %d %d\n", x, y);
fflush(stdout);
char buf[4];
scanf("%s", buf);
assert(buf[0] != 'e');
return buf[0] == 'x';
}
int work() {
if (ask(0, 1)) return 1;
int l = 1, r;
while (ask(l * 2, l)) l *= 2;
r = l * 2 + 1;
l++;
r = min(r, 1000000000);
while (r > l) {
int mid = (l + r) / 2;
if (ask(mid, (mid + 1) / 2))
l = mid + 1;
else
r = mid;
}
return l;
}
int main() {
char cmd[32];
while (true) {
scanf("%s", cmd);
if (strcmp(cmd, "start") == 0) {
printf("! %d\n", work());
fflush(stdout);
} else
break;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 1e14;
const int maxn = 1e6 + 5;
bool yes[maxn];
int l[maxn];
int a, n, m, k;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
memset(yes, 1, sizeof yes);
for (int i = 1; i <= m; i++) {
int x;
cin >> x;
yes[x] = 0;
}
for (int i = 0; i <= n; i++) {
if (yes[i])
l[i] = i;
else
l[i] = l[i - 1];
}
ll ans = inf;
for (int i = 1; i <= k; i++) {
cin >> a;
if (yes[0]) {
ll cnt = 1;
bool f = 1;
int st = 0;
while (st < n) {
if (st + i >= n) {
break;
}
if (yes[st + i]) {
st = st + i;
cnt++;
} else if (l[st + i] > st) {
st = l[st + i];
cnt++;
} else {
f = 0;
break;
}
}
if (f) ans = min(ans, cnt * a);
}
}
if (ans == inf) ans = -1;
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-12;
const int maxn = 600;
int n, m, N, S, T;
double A[maxn];
int E[maxn][maxn], D[maxn];
inline int dblc(double x) { return (x > eps) - (x < -eps); }
struct Tgauss {
int n, m;
double A[maxn][maxn];
void solve() {
int i, j, k;
for (i = 0; i < n; ++i) {
for (j = i; j < n; ++j)
if (dblc(A[i][j])) break;
swap(A[i], A[j]);
for (k = m; k >= i; --k) A[i][k] /= A[i][i];
for (j = 0; j < n; ++j)
if (i != j)
for (k = m; k >= i; --k) A[j][k] -= A[i][k] * A[j][i];
}
}
void print() {
int i, j;
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) fprintf(stderr, "%.3lf ", A[i][j]);
cerr << endl;
}
}
} Ax;
namespace Ninit {
void init() {
int i, ai, bi;
scanf("%d%d%d%d", &n, &m, &S, &T), --S, --T;
for (i = 0; i < m; ++i) {
scanf("%d%d", &ai, &bi), --ai, --bi;
E[ai][bi] = E[bi][ai] = true;
++D[ai], ++D[bi];
}
for (i = 0; i < n; ++i) E[i][i] = true;
N = n * n;
for (i = 0; i < n; ++i) scanf("%lf", A + i);
}
} // namespace Ninit
namespace Nsolve {
inline double Fp(int a, int b) { return a == b ? A[a] : (1 - A[a]) / D[a]; }
void solve() {
int i, j, p, q, x;
Ax.n = N, Ax.m = N + n;
for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j) {
x = i * n + j;
Ax.A[x][x] = 1;
if (i == j) {
Ax.A[x][N + i] = 1;
continue;
}
for (p = 0; p < n; ++p)
if (E[i][p])
for (q = 0; q < n; ++q)
if (E[j][q]) {
Ax.A[x][p * n + q] -= Fp(i, p) * Fp(j, q);
}
}
Ax.solve();
for (i = 0; i < n; ++i) printf("%.8lf ", Ax.A[S * n + T][N + i]);
printf("\n");
}
} // namespace Nsolve
int main() {
Ninit::init();
Nsolve::solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4;
int cnt[N];
int ans;
int n;
int dfs(int v) {
if (v >= n) return 0;
int a = dfs(v * 2 + 1);
int b = dfs(v * 2 + 2);
ans += max(a, b) - min(a, b);
return max(a, b) + cnt[v];
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(20);
cin >> n;
n = (1 << n + 1) - 1;
for (int i = (0); i < (int)(n - 1); ++i) {
int x;
cin >> x;
cnt[i + 1] = x;
}
dfs(0);
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s;
int a[11][105][3];
int f[10000];
struct point {
int v, b;
} g[10000];
int main() {
int n, m, kkk;
cin >> n >> m >> kkk;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++)
scanf("%d%d%d", &a[i][j][0], &a[i][j][1], &a[i][j][2]);
}
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
memset(f, 0, sizeof(f));
int l = 0;
for (int k = 0; k < m; k++) {
int t = a[i][k][2];
int tt = 1;
while (t - tt >= 0) {
g[l].v = tt * (a[j][k][1] - a[i][k][0]);
g[l].b = tt;
l++;
t -= tt;
tt *= 2;
}
if (t) g[l].v = t * (a[j][k][1] - a[i][k][0]), g[l].b = t, l++;
}
for (int ii = 0; ii < l; ii++)
for (int jj = kkk; jj >= g[ii].b; jj--)
if (f[jj] < f[jj - g[ii].b] + g[ii].v)
f[jj] = f[jj - g[ii].b] + g[ii].v;
if (f[kkk] > ans) ans = f[kkk];
}
cout << ans;
ans++;
ans--;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
constexpr string_view gtype() {
string_view s = __PRETTY_FUNCTION__;
return string_view(s.data() + 45, s.find(';', 45) - 45);
}
const int MAXN = 1e5;
const double eps = 1e-7;
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long n, x1, x2, y1, y2;
cin >> n >> x1 >> y1 >> x2 >> y2;
vector<pair<long long, long long>> points(n);
long long mxr2 = 0;
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
long long r1 = (x - x1) * (x - x1) + (y - y1) * (y - y1);
long long r2 = (x - x2) * (x - x2) + (y - y2) * (y - y2);
points[i] = {r1, r2};
mxr2 = max(r2, mxr2);
}
sort(((points).begin()), ((points).end()));
long long ans = 1e18;
for (int i = 0; i < n; i++) {
long long r1 = points[i].first;
long long r2 = 0;
for (int j = i + 1; j < n; j++) {
r2 = max(r2, points[j].second);
}
ans = min(ans, r1 + r2);
}
cout << min(ans, mxr2) << endl;
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.