solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int a[1000];
long long f[1000001], fi[1000001];
long long pd[1000001];
long long fexp(long long n, long long e) {
if (e == 0) return 1;
if (e == 1) return n;
if (e % 2 == 0) return fexp((1ll * n * n) % 1000000007, e / 2);
return (1ll * n * fexp(n, e - 1)) % 1000000007;
}
long long inv(long long n) { return fexp(n, 1000000007 - 2); }
int main() {
int n, c1 = 0;
cin >> n;
f[0] = 1;
pd[0] = 1;
pd[1] = 1;
for (int i = 1; i < 1000001; i++) f[i] = f[i - 1] * i;
for (int i = 0; i < 1000001; i++) fi[i] = inv(f[i]);
for (int i = 2; i < 1000001; i++) pd[i] = pd[i - 1] + (i - 1) * pd[i - 2];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) c1++;
}
cout << (((pd[c1] * f[n]) % 1000000007) * fi[c1]) % 1000000007 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[4005], s[4005], n, dp[2][2][4005][2 * 100];
int st[4005], dr[4005];
inline int sum(int x, int y) { return s[y] - s[x - 1]; }
int main() {
int i, j, k, p, l1, l2;
cin >> n;
for (i = 1; i <= n; ++i) cin >> a[i];
for (i = 1; i <= n; ++i) s[i] = s[i - 1] + a[i];
int sqr = min(sqrt(2.0 * n), 1.0 * n);
for (i = 1; i <= n; ++i) {
st[i] = n - i + 1 - sqr;
st[i] = max(st[i], 1);
dr[i] = sqr + n - i + 1;
dr[i] = min(dr[i], n);
}
for (i = sqr; i; --i) {
l1 = (i & 1);
l2 = ((i + 1) & 1);
for (p = n; p; --p)
for (k = 0; k <= 2 * sqr; ++k)
for (j = 0; j < 2; ++j) {
int lft = p, rgt = st[p] + k;
if (rgt > dr[p]) {
dp[l1][0][p][k] = 1000000000;
dp[l1][1][p][k] = -1000000000;
continue;
}
int len = rgt - lft + 1;
if (len < i) {
dp[l1][j][p][k] = 0;
continue;
}
if (!j) {
dp[l1][j][p][k] = 1000000000;
if (len >= i && rgt - i - st[lft] >= 0 &&
rgt - i - st[lft] <= 2 * sqr)
dp[l1][j][p][k] =
min(dp[l1][j][p][k], dp[l1][1][lft][rgt - i - st[lft]] -
sum(rgt - i + 1, rgt));
if (len > i && rgt - i - 1 - st[lft] >= 0 &&
rgt - i - 1 - st[lft] <= 2 * sqr)
dp[l1][j][p][k] =
min(dp[l1][j][p][k], dp[l2][1][lft][rgt - i - 1 - st[lft]] -
sum(rgt - i, rgt));
} else {
dp[l1][j][p][k] = -1000000000;
if (len >= i && rgt - st[lft + i] >= 0 &&
rgt - st[lft + i] <= 2 * sqr)
dp[l1][j][p][k] =
max(dp[l1][j][p][k], dp[l1][0][lft + i][rgt - st[lft + i]] +
sum(lft, lft + i - 1));
if (len > i && rgt - st[lft + i + 1] >= 0 &&
rgt - st[lft + i + 1] <= 2 * sqr)
dp[l1][j][p][k] =
max(dp[l1][j][p][k],
dp[l2][0][lft + i + 1][rgt - st[lft + i + 1]] +
sum(lft, lft + i));
}
}
}
cout << dp[l1][1][1][n - st[1]] << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d;
int main() {
cin >> a >> b >> c >> d;
printf("%d\n", ((a ^ b) & (c | d)) ^ ((b & c) | (a ^ d)));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, M = 1e6 + 5, L = 19, INF = 1e9;
struct E {
int a, b, w, i;
};
int q[N], tin[N], tout[N], p[N][L], mx[N][L], ans[M], head[N], anime[N],
anc_e[N], tr[N * 4], sz[N];
vector<E> edges, sorted, t[N];
int timer = 0;
bool mst[M];
int n, m;
void upd(int l, int r, int x, int v = 1, int L = 0, int R = n - 1) {
if (L != R && tr[v] != -1) {
tr[v * 2] = tr[v];
tr[v * 2 + 1] = tr[v];
tr[v] = -1;
}
if (l > r) return;
if (l == L && r == R) {
tr[v] = x;
} else {
int m = (L + R) >> 1;
upd(l, min(m, r), x, v * 2, L, m);
upd(max(m + 1, l), r, x, v * 2 + 1, m + 1, R);
}
}
void calc(int v, int L, int R) {
if (L == R && tr[v] == -1) {
tr[v] = INF;
}
if (tr[v] != -1) {
for (; L <= R; L++) anime[L] = tr[v];
} else {
int m = (L + R) >> 1;
calc(v * 2, L, m);
calc(v * 2 + 1, m + 1, R);
}
}
int findSet(int v) { return q[v] < 0 ? v : q[v] = findSet(q[v]); }
bool connect(int a, int b) {
a = findSet(a);
b = findSet(b);
if (a == b) return false;
if (q[a] > q[b]) swap(a, b);
q[a] += q[b];
q[b] = a;
return true;
}
void walk(int node, int anc) {
sz[node] = 1;
for (E e : t[node]) {
if (e.a != anc) {
walk(e.a, node);
sz[node] += sz[e.a];
}
}
}
void dfs(int node) {
tin[node] = timer++;
for (int i = 1; i < L; i++) {
p[node][i] = p[p[node][i - 1]][i - 1];
mx[node][i] = max(mx[node][i - 1], mx[p[node][i - 1]][i - 1]);
}
if (node) {
int x = 0;
while (t[node][x].a != p[node][0]) x++;
t[node].erase(t[node].begin() + x);
}
for (E &e : t[node]) {
if (sz[t[node][0].a] < sz[e.a]) swap(e, t[node][0]);
}
for (E e : t[node]) {
p[e.a][0] = node;
mx[e.a][0] = e.w;
head[e.a] = t[node][0].i == e.i ? head[node] : e.a;
anc_e[e.a] = e.i;
dfs(e.a);
}
tout[node] = timer;
}
bool upper(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int getLca(int a, int b) {
if (upper(a, b)) return a;
for (int i = L - 1; i >= 0; i--) {
if (!upper(p[a][i], b)) a = p[a][i];
}
return p[a][0];
}
int getMax(int a, int b) {
if (upper(a, b)) return 0;
int ans = 0;
for (int i = L - 1; i >= 0; i--) {
if (!upper(p[a][i], b)) {
ans = max(ans, mx[a][i]);
a = p[a][i];
}
}
ans = max(ans, mx[a][0]);
return ans;
}
void climb(int node, int finish, int val) {
if (head[node] == head[finish]) {
upd(tin[finish] + 1, tin[node], val);
} else {
upd(tin[head[node]], tin[node], val);
climb(p[head[node]][0], finish, val);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, w;
cin >> a >> b >> w;
a--, b--;
edges.push_back({a, b, w, i});
}
sorted = edges;
sort(sorted.begin(), sorted.end(),
[](const E &a, const E &b) { return a.w < b.w; });
fill(q, q + n, -1);
for (E e : sorted) {
if (connect(e.a, e.b)) {
t[e.b].push_back(e);
swap(e.a, e.b);
t[e.b].push_back(e);
mst[e.i] = true;
}
}
walk(0, -1);
dfs(0);
reverse(sorted.begin(), sorted.end());
fill(tr, tr + N * 4, -1);
for (E e : sorted) {
if (!mst[e.i]) {
ans[e.i] = max(getMax(e.b, e.a), getMax(e.a, e.b));
int lca = getLca(e.a, e.b);
climb(e.a, lca, e.w);
climb(e.b, lca, e.w);
}
}
calc(1, 0, n - 1);
for (int i = 1; i < n; i++) {
ans[anc_e[i]] = anime[tin[i]];
}
for (int i = 0; i < m; i++) {
cout << ans[i] << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 47, MAXN = 2e5 + 47;
struct Point {
double x, y;
Point(double a = 0, double b = 0) {
x = a;
y = b;
}
double dist() { return sqrt(x * x + y * y); }
double angle() { return atan2(y, x); }
};
struct Vector {
double x, y;
Vector(double a = 0, double b = 0) {
x = a;
y = b;
}
Vector(const Point& A, const Point& B) {
x = B.x - A.x;
y = B.y - A.y;
}
double dist() { return sqrt(x * x + y * y); }
};
Vector operator+(const Vector& a, const Vector& b) {
return Vector(a.x + b.x, a.y + b.y);
}
Point operator+(const Point& a, const Vector& b) {
return Point(a.x + b.x, a.y + b.y);
}
Vector operator-(const Vector& a, const Vector& b) {
return Vector(a.x - b.x, a.y - b.y);
}
Vector operator*(const Vector& a, double k) { return Vector(a.x * k, a.y * k); }
Vector operator/(const Vector& a, double k) { return Vector(a.x / k, a.y / k); }
istream& operator>>(istream& in, Point& P) {
in >> P.x >> P.y;
return in;
}
ostream& operator<<(ostream& out, const Point& P) {
out << P.x << " " << P.y;
return out;
}
istream& operator>>(istream& in, Vector& P) {
in >> P.x >> P.y;
return in;
}
ostream& operator<<(ostream& out, const Vector& P) {
out << P.x << " " << P.y;
return out;
}
istream& operator>>(istream& in, vector<long long>& a) {
for (auto& i : a) cin >> i;
return in;
}
ostream& operator<<(ostream& out, vector<long long>& a) {
for (auto& i : a) cout << i << " ";
return out;
}
double degrees(double radians) { return radians / M_PI * 180; }
signed main() {
setlocale(LC_ALL, "rus");
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long d1, d2;
cin >> d1 >> d2;
if (d1 == 9 && d2 == 1) {
cout << "9 10";
return 0;
}
if (abs(d1 - d2) > 1) {
cout << -1;
return 0;
} else {
if (d1 == 0 && abs(d1 - d2) == 0) {
cout << -1;
return 0;
}
if (d1 == 0 && d2 == 1) {
cout << "0 1";
return 0;
}
if (abs(d1 - d2) == 0)
cout << d1 << "00 " << d2 << "01";
else if (abs(d1 - d2) == 1) {
if (d2 - d1 < 0)
cout << -1;
else
cout << d1 << "99 " << d2 << "00";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[130000], vec(130000);
bool visited[130000], marked[130000], flag;
int cnt[130000], dp[130000], d;
pair<int, int> p;
void dfs(int v, int l) {
visited[v] = true;
cnt[v] = marked[v];
for (int i = 0; i < graph[v].size(); i++) {
int u = graph[v][i];
if (!visited[u]) {
dfs(u, l + 1);
cnt[v] += cnt[u];
if (!flag) dp[v] += (cnt[u] ? 2 : 0) + dp[u];
}
}
if (marked[v]) {
if (p.first < l) {
p = make_pair(l, v);
} else if (p.first == l) {
p.second = min(p.second, v);
}
}
}
int main() {
int n, m, a;
scanf("%d %d", &n, &m);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
graph[a].push_back(b), graph[b].push_back(a);
}
for (int i = 0; i < m; i++) {
scanf("%d", &a);
marked[a] = true;
}
p.second = 130000;
dfs(a, 0);
memset(visited, false, sizeof(visited));
flag = true;
int d = p.second;
dfs(p.second, 0);
printf("%d\n%d\n", min(d, p.second), dp[a] - p.first);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxk = 25, maxn = 100005;
int n, q;
int a[maxn], st[maxk][maxn], lg[maxn];
map<int, long long> ans;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int query(int l, int r) {
int k = lg[r - l + 1];
return gcd(st[k][l], st[k][r - (1 << k) + 1]);
}
int main() {
scanf("%d", &n), lg[0] = -1;
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), st[0][i] = a[i], lg[i] = lg[i / 2] + 1;
for (int i = 1; i <= 20; i++)
for (int j = 1; j + (1 << (i - 1)) - 1 <= n; j++)
st[i][j] = gcd(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
int v = query(i, j), L = j - 1, R = n + 1;
while (L + 1 < R) {
int mid = (L + R) >> 1;
if (query(i, mid) != v)
R = mid;
else
L = mid;
}
ans[v] += (L - j + 1), j = L;
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int x;
scanf("%d", &x);
if (ans.count(x))
printf("%lld\n", ans[x]);
else
puts("0");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
long long int t = 1;
while (t--) {
long long int n;
cin >> n;
vector<long long int> arr(n);
long long int sum = 0;
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr.rbegin(), arr.rend());
vector<long long int> dp(n);
dp[0] = sum;
for (long long int i = 1; i < n; i++) {
dp[i] = dp[i - 1] - arr[n - i];
}
long long int ans = dp[0];
if (n != 1) {
dp[n - 1] = dp[n - 2];
} else {
cout << dp[0] << "\n";
return 0;
}
for (long long int i = 0; i < n - 1; i++) {
ans += dp[i];
}
cout << ans << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, n;
scanf("%d", &q);
while (q--) {
scanf("%d", &n);
int v[4 * n];
for (int i = 0; i < 4 * n; i++) scanf("%d", &v[i]);
sort(v, v + 4 * n);
bool f = false;
for (int i = 1; i < 4 * n; i += 2)
if (v[i] != v[i - 1]) f = true;
for (int i = 1; i < 2 * n; i++) {
if (v[i] * v[4 * n - i - 1] != v[i - 1] * v[4 * n - i]) f = true;
}
printf(f ? "NO\n" : "YES\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = LLONG_MAX, MOD = 1e9 + 7;
const int N = 4e5;
long long t[N * 2];
long long h;
long long dd[N];
long long n, a, b, c, d, start, len;
vector<pair<long long, pair<long long, long long>>> timetype;
void apply(int p, long long value) {
t[p] += value;
if (p < n) dd[p] += value;
}
void build(int p) {
while (p > 1) p >>= 1, t[p] = min(t[p << 1], t[p << 1 | 1]) + dd[p];
}
void push(int p) {
for (int s = h; s > 0; --s) {
int i = p >> s;
if (dd[i] != 0) {
apply(i << 1, dd[i]);
apply(i << 1 | 1, dd[i]);
dd[i] = 0;
}
}
}
void inc(int l, int r, long long value) {
l += n, r += n;
int l0 = l, r0 = r;
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) apply(l++, value);
if (r & 1) apply(--r, value);
}
build(l0);
build(r0 - 1);
}
long long query(int l, int r) {
l += n, r += n;
push(l);
push(r - 1);
long long res = 0;
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, t[l++]);
if (r & 1) res = min(t[--r], res);
}
return res;
}
void puu(long long tim, pair<long long, long long> change) {
if (tim <= 0) return;
timetype.push_back({tim, change});
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> a >> b >> c >> d >> start >> len;
h = sizeof(int) * 8 - __builtin_clz(n);
int x = 0, y = 0;
long long cum = start;
for (int i = 0; i < n; i++) {
long long typ, tim;
cin >> tim >> typ;
long long delta;
if (tim < len) {
y++;
if (typ == 1) {
delta = c;
} else {
delta = -d;
}
} else {
if (typ == 1) {
delta = a;
} else {
delta = -b;
}
}
cum += delta;
inc(i, i + 1, cum);
puu(tim + 1, {0, (typ == 1 ? a - c : d - b)});
puu(tim - len + 1, {1, (typ == 1 ? c - a : b - d)});
}
sort(timetype.begin(), timetype.end());
if (query(0, y) >= 0) {
return cout << 0 << endl, 0;
}
for (int i = 0; i < (int)timetype.size(); i++) {
auto &pr = timetype[i].second;
if (pr.first) {
inc(y, n, pr.second);
y++;
} else {
inc(x, n, pr.second);
x++;
}
if (i < n - 1 && timetype[i + 1].first == timetype[i].first) continue;
if (query(0, y) >= 0) {
return cout << timetype[i].first << endl, 0;
}
}
cout << -1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = (long long)((1e5) + 100);
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
void pr(long long x) { cout << x; }
void prl(long long x) { cout << x << "\n"; }
long long cbrt(long long x) {
long long lo = 1, hi = min(2000000ll, x);
while (hi - lo > 1) {
long long mid = (lo + hi) / 2;
if (mid * mid * mid < x) {
lo = mid;
} else
hi = mid;
}
if (hi * hi * hi <= x)
return hi;
else
return lo;
}
const long long dx[4] = {-1, 1, 0, 0};
const long long dy[4] = {0, 0, -1, 1};
long long XX[] = {-1, -1, -1, 0, 0, 1, 1, 1};
long long YY[] = {-1, 0, 1, -1, 1, -1, 0, 1};
const long long N = (long long)(6 * 1e5 + 10);
long long fact[N], invfact[N];
long long pow(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
long long modinv(long long k) {
return pow(k, (long long)998244353 - 2, (long long)998244353);
}
void precompute() {
fact[0] = fact[1] = 1;
for (long long i = 2; i < N; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= (long long)998244353;
}
invfact[N - 1] = modinv(fact[N - 1]);
for (long long i = N - 2; i >= 0; i--) {
invfact[i] = invfact[i + 1] * (i + 1);
invfact[i] %= (long long)998244353;
}
}
long long nCr(long long x, long long y) {
if (y > x) return 0;
long long num = fact[x];
num *= invfact[y];
num %= (long long)998244353;
num *= invfact[x - y];
num %= (long long)998244353;
return num;
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long T = 1;
while (T--) {
precompute();
long long n, k;
cin >> n >> k;
if (n < k)
prl(0);
else {
k = k - 1;
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
cnt += nCr((n / i) - 1, k);
cnt = cnt % (long long)998244353;
}
prl(cnt);
}
}
}
| 6 |
#include <bits/stdc++.h>
const int N = 3000010;
int n, m, a[10], aa[10], le = -1;
char s[N], t[N], ze[N], sol[N];
void check(char *z, int l) {
if (!l || l > 1 && z[1] == '0') return;
if (le == -1 || l < le) {
le = l;
for (int i = 1; i <= l; i++) sol[i] = z[i];
return;
}
if (l > le) return;
int i;
for (i = 1; i <= l; i++)
if (sol[i] != z[i]) break;
if (i <= l && z[i] < sol[i]) {
le = l;
for (int i = 1; i <= l; i++) sol[i] = z[i];
}
}
void solve(int leee) {
int z = 0;
for (int i = 0; i < 10; i++) z += a[i];
if (z + m != leee) return;
if (!z) {
check(t, m);
return;
}
for (int i = 0; i <= 10; i++) {
int sz = 0;
for (int j = 0; j < 10; j++) aa[j] = a[j];
for (int j = 0; j < i; j++)
while (aa[j]--) ze[++sz] = j + '0';
for (int j = 1; j <= m; j++) ze[++sz] = t[j];
for (int j = i; j < 10; j++)
while (aa[j]--) ze[++sz] = j + '0';
check(ze, leee);
}
int k = 0, sz = 0;
for (int i = 1; i < 10; i++)
if (a[i]) {
k = i;
break;
}
if (!k) return;
a[k]--;
ze[sz = 1] = k + '0';
for (int i = 0; i <= 10; i++) {
sz = 1;
for (int j = 0; j < 10; j++) aa[j] = a[j];
for (int j = 0; j < i; j++)
while (aa[j]--) ze[++sz] = j + '0';
for (int j = 1; j <= m; j++) ze[++sz] = t[j];
for (int j = i; j < 10; j++)
while (aa[j]--) ze[++sz] = j + '0';
check(ze, leee);
}
a[k]++;
}
int main() {
scanf("%s %s", s + 1, t + 1);
n = strlen(s + 1);
m = strlen(t + 1);
for (int i = 1; i <= n; i++) a[s[i] - '0']++;
for (int i = 1; i <= m; i++) a[t[i] - '0']--;
for (int d = 1; d <= 6; d++) {
int x = n - d, y = x;
if (!x) continue;
while (x) a[x % 10]--, x /= 10;
solve(y);
while (y) a[y % 10]++, y /= 10;
}
for (int i = 1; i <= le; i++) printf("%c", sol[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> a[1000004];
int ans;
int dfs(int pos, int parent) {
int depth = INT_MIN;
for (int i = 0; i < a[pos].size(); i++) {
if (a[pos][i] == parent) continue;
int x = dfs(a[pos][i], pos);
if (depth + x + 2 <= k) {
depth = max(depth, x);
} else {
ans++;
depth = min(depth, x);
}
}
depth++;
depth = max(0, depth);
return depth;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
int root = 1;
for (int i = 1; i <= n; i++) {
if (a[i].size() > 1) {
root = i;
break;
}
}
ans = 0;
int temp = dfs(root, -1);
if (temp != 0) ans++;
cout << ans << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void Print() { cout << endl; }
template <typename T1, typename... T>
void Print(const T1 &t1, const T &...t) {
cout << t1 << " ";
Print(t...);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
long long gcd(long long a, long long b) {
if (b) {
long long r = a % b;
a = b, b = r;
}
return a;
}
tuple<long long, long long, long long> extend_gcd(long long a, long long b) {
if (b == 0)
return make_tuple(a, 1, 0);
else {
long long g, nx, ny;
std::tie(g, nx, ny) = extend_gcd(b, a % b);
return make_tuple(g, ny, nx - (a / b) * ny);
}
}
long long fastpow(long long a, long long e, long long mod) {
if (e == 0) return 1;
if (e == 1) return a % mod;
long long t = fastpow(a, e / 2, mod);
t = t * t % mod;
if (e & 1)
return t * a % mod;
else
return t % mod;
}
const double PI = 3.14159265358979323846;
const int MOD = (int)1e9 + 7;
int n, m;
int dp[5005][5005];
char tmp[5005];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", tmp + 1);
for (int j = m; j >= 1; j--)
if (tmp[j] == '1') dp[i][j] = 1 + dp[i][j + 1];
}
int ans = 0;
for (int j = 1; j <= m; j++) {
vector<int> vals;
for (int i = 1; i <= n; i++) vals.push_back(dp[i][j]);
sort(vals.begin(), vals.end(), greater<int>());
for (int i = 0; i < n; i++) {
if (vals[i] == 0) break;
ans = max(ans, vals[i] * (i + 1));
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int p[N], n, cnt, k;
void unsort(int l, int r) {
if (cnt == k) return;
if (l < r - 1) {
int m = (l + r) / 2;
swap(p[m - 1], p[m]);
cnt += 2;
unsort(l, m);
unsort(m, r);
}
}
int main() {
cin >> n >> k;
if (k % 2 == 0)
cout << -1;
else {
for (int i = 0; i < n; i++) p[i] = i + 1;
cnt = 1;
unsort(0, n);
if (cnt != k)
cout << -1;
else
for (int i = 0; i < n; i++) cout << p[i] << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, k;
cin >> n;
long long maxn = n + n - 1;
int cnt = 0;
long long t = maxn;
while (t) {
cnt++;
t /= 10;
}
if (maxn == (long long)pow(10, cnt) - 1) {
cout << 1 << endl;
return 0;
}
long long ans = 0, nine = pow(10, cnt - 1) - 1;
for (i = 0; i < 9; i++) {
long long p = (long long)pow(10, cnt - 1) * i + nine;
if (p > maxn) break;
ans += min(n - p / 2, p / 2);
}
cout << (n < 5 ? n * (n - 1) / 2 : ans) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
void add(int& a, const int& b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
}
vector<vector<int> > mul(const vector<vector<int> >& a,
const vector<vector<int> >& b) {
vector<vector<int> > m(a.size(), vector<int>(a.size(), 0));
for (int i = 0; i < a.size(); i++)
for (int j = 0; j < a.size(); j++)
for (int k = 0; k < a.size(); k++)
add(m[i][k], (a[i][j] * 1ll * b[j][k]) % mod);
return m;
}
void print(const vector<vector<int> >& a) {
cout << "\n";
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < a[i].size(); j++) cout << a[i][j];
cout << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k;
cin >> n >> k;
vector<int> d;
while (n) {
d.insert(d.begin(), n % k);
n /= k;
}
int m = d.size();
vector<vector<vector<vector<int> > > > a(
m, vector<vector<vector<int> > >(
k, vector<vector<int> >(k + 1, vector<int>(k + 1, 0))));
vector<vector<vector<vector<int> > > > pf(
m, vector<vector<vector<int> > >(
k, vector<vector<int> >(k + 1, vector<int>(k + 1, 0))));
vector<vector<vector<vector<int> > > > sf(
m, vector<vector<vector<int> > >(
k, vector<vector<int> >(k + 1, vector<int>(k + 1, 0))));
for (int i = 0; i < m; i++) {
if (i == 0) {
for (int x = 0; x < k; x++) {
for (int d = 0; d <= k; d++) {
a[i][x][d][d] = 1;
a[i][x][x][d] = 1;
}
}
} else {
a[i][0] = sf[i - 1][0];
for (int x = 1; x < k; x++) a[i][x] = mul(sf[i - 1][x], pf[i - 1][x - 1]);
}
pf[i][0] = a[i][0], sf[i][k - 1] = a[i][k - 1];
for (int d = 1; d < k; d++) pf[i][d] = mul(pf[i][d - 1], a[i][d]);
for (int d = k - 2; d >= 0; d--) sf[i][d] = mul(a[i][d], sf[i][d + 1]);
}
vector<vector<int> > ans(k + 1, vector<int>(k + 1, 0));
for (int i = 0; i <= k; i++) ans[i][i] = 1;
int rem = 0;
for (int i = 0; i < d.size(); i++) {
for (int j = 0; j < d[i]; j++, rem = (rem + 1) % k)
ans = mul(ans, a[d.size() - i - 1][rem]);
}
int res = 0;
for (int i = 0; i <= k; i++) add(res, ans[i][k]);
cout << res << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<long long, long long>;
const long long minf = -1e9;
long long dp[75][75][40][75];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
long long A[75][75];
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) cin >> A[i][j];
}
memset(dp, 0x88, sizeof(dp));
dp[1][0][0][0] = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < m; j++) {
for (long long l = 0; l <= m / 2; l++) {
for (long long o = 0; o < k; o++) {
if (j < m - 1)
dp[i][j + 1][l][o] = max(dp[i][j + 1][l][o], dp[i][j][l][o]);
else
dp[i + 1][0][0][o] = max(dp[i + 1][0][0][o], dp[i][j][l][o]);
if (l < m / 2) {
if (j < m - 1)
dp[i][j + 1][l + 1][(o + A[i][j + 1]) % k] =
max(dp[i][j + 1][l + 1][(o + A[i][j + 1]) % k],
dp[i][j][l][o] + A[i][j + 1]);
else
dp[i + 1][0][0][(o + A[i][j + 1]) % k] =
max(dp[i + 1][0][0][(o + A[i][j + 1]) % k],
dp[i][j][l][o] + A[i][j + 1]);
}
}
}
}
}
cout << max(0LL, dp[n + 1][0][0][0]) << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
template <class T, class U>
inline void add_self(T &a, U b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
}
template <class T, class U>
inline void min_self(T &x, U y) {
if (y < x) x = y;
}
template <class T, class U>
inline void max_self(T &x, U y) {
if (y > x) x = y;
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
cout << t;
;
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
template <class T, class U>
void print_m(const map<T, U> &m, int w = 3) {
if (m.empty()) {
cout << "Empty" << endl;
return;
}
for (auto x : m) cout << "(" << x.first << ": " << x.second << ")," << endl;
cout << endl;
}
template <class T, class U>
void debp(const pair<T, U> &pr, bool end_line = 1) {
cout << "{" << pr.first << " " << pr.second << "}";
cout << (end_line ? "\n" : ", ");
}
template <class T>
void print_vp(const T &vp, int sep_line = 0) {
if (vp.empty()) {
cout << "Empty" << endl;
return;
}
if (!sep_line) cout << "{ ";
for (auto x : vp) debp(x, sep_line);
if (!sep_line) cout << "}\n";
cout << endl;
}
template <typename T>
void print(const T &v, bool show_index = false) {
int w = 2;
if (show_index) {
for (int i = 0; i < int((v).size()); i++) cout << setw(w) << i << " ";
cout << endl;
}
for (auto &el : v) cout << setw(w) << el << " ";
cout << endl;
}
template <typename T>
void print_vv(const T &vv) {
if (int((vv).size()) == 0) {
cout << "Empty" << endl;
return;
}
int w = 3;
cout << setw(w) << " ";
for (int j = 0; j < int((*vv.begin()).size()); j++)
cout << setw(w) << j << " ";
cout << endl;
int i = 0;
for (auto &v : vv) {
cout << i++ << " {";
for (auto &el : v) cout << setw(w) << el << " ";
cout << "},\n";
}
cout << endl;
}
const int nax = 1010;
int n, m, s, t;
vector<int> dis_s, dis_t;
vector<vector<int>> adj;
void bfs(int x, vector<int> &dis) {
queue<int> q;
q.push(x);
dis.assign(nax, -1);
dis[x] = 0;
while (!q.empty()) {
int top = q.front();
q.pop();
for (auto ad : adj[top]) {
if (~dis[ad]) continue;
dis[ad] = dis[top] + 1;
q.push(ad);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
while (cin >> n >> m >> s >> t) {
adj.assign(nax, {});
int u, v;
for (int i = 0; i < int(m); i++) {
cin >> u >> v;
adj[u].push_back(v), adj[v].push_back(u);
}
for (auto &x : adj) sort(x.begin(), x.end());
bfs(s, dis_s);
bfs(t, dis_t);
int D = dis_s[t];
int cnt = 0;
for (int i = int(1); i < int(n + 1); i++) {
for (int j = int(i + 1); j < int(n + 1); j++) {
if (binary_search(adj[i].begin(), adj[i].end(), j)) continue;
if ((i == s && j == t) || (i == t && j == s)) continue;
int d1 = dis_s[i] + dis_t[j] + 1;
int d2 = dis_t[i] + dis_s[j] + 1;
if (min(d1, d2) >= D) ++cnt;
}
}
cout << cnt << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string lexsmallest(string s, int k) {
if (k == s.length()) return s;
string s1;
string s2;
string ans = "";
int n = s.length();
for (int i = 0; i < (n / (2 * k)); i++) {
s1 = "";
s2 = "";
for (int j = 2 * i * k; j < (2 * i + 1) * k; j++) s1 += s[j];
for (int j = (2 * i + 1) * k; j < (2 * i + 2) * k; j++) s2 += s[j];
if (s1 <= s2)
ans += (s1 + s2);
else
ans += (s2 + s1);
}
return lexsmallest(ans, 2 * k);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string a;
string b;
cin >> a >> b;
if (a.length() != b.length()) {
cout << "NO" << endl;
return 0;
}
int n = a.length();
while (n % 2 == 0) n /= 2;
if (lexsmallest(a, n) == lexsmallest(b, n))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool RELAXED = false;
template <int, typename T>
struct MINMAX {
T val;
MINMAX(T val) : val(val) {}
};
template <typename T>
MINMAX<1, T> MAX(T val) {
return MINMAX<1, T>(val);
};
template <typename T>
MINMAX<2, T> MIN(T val) {
return MINMAX<2, T>(val);
};
template <typename T, typename U>
inline T& operator|=(T& lhs, MINMAX<1, U> rhs) {
return lhs = (rhs.val > lhs ? (RELAXED = true, rhs.val)
: (RELAXED = false, lhs));
}
template <typename T, typename U>
inline T& operator|=(T& lhs, MINMAX<2, U> rhs) {
return lhs = (rhs.val < lhs ? (RELAXED = true, rhs.val)
: (RELAXED = false, lhs));
}
template <typename T>
inline vector<T> readVector(int n) {
vector<T> vec(n);
for (int i = 0; i < int(n); i++) cin >> vec[i];
return vec;
}
template <typename T>
void EXIT(T answer) {
cout << answer << endl;
exit(0);
}
signed long long int pow(int d) { return 1LL * d * d; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
vector<vector<int>> p;
for (int i = 0; i < int(n); i++) {
int x, y, z;
cin >> x >> y >> z;
p.push_back({x, y, z});
}
priority_queue<pair<signed long long int, pair<int, int>>> pq;
for (int i = 0; i < int(n); i++)
for (int j = int(i + 1); j <= int(n - 1); j++) {
signed long long int d = pow(p[i][0] - p[j][0]) + pow(p[i][1] - p[j][1]) +
pow(p[i][2] - p[j][2]);
pq.push({-d, {i, j}});
}
set<int> done;
while (pq.size() > 0) {
pair<int, int> ij = pq.top().second;
pq.pop();
if (done.count(ij.first) || done.count(ij.second)) continue;
done.insert(ij.first);
done.insert(ij.second);
cout << ij.first + 1 << " " << ij.second + 1 << "\n";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double x, t;
int main() {
scanf("%lf", &x);
for (int a = 1; a <= 10; ++a)
for (int h = 1; h <= 10; ++h) {
t = sqrt(.25 * a * a + 1. * h * h);
t = .5 * a * h / t - x;
if (t < 0) t = -t;
if (t < 1e-5) {
printf("%d %d\n", a, h);
return 0;
}
}
return 0;
}
| 5 |
#include<iostream>
#include<algorithm>
#include<queue>
#include<stack>
#include<vector>
#include<cstring>
#include<cmath>
#include<set>
#include<iomanip>
#include<map>
#include<stdio.h>
#define INF 0x3f3f3f3f
#define ll long long
#define pll pair<ll,ll>
#define pdl pair<double,ll>
#define pdd pair<double, double>
#define IOS ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std;
const int N = 4e5 + 5;
const int mod = 1e9 + 7;
const double eps = 1e-4;
ll n,m;
vector<ll>g[N];
int color[N];
bool circle[N];
bool mul[N];
int ans[N];
bool vis[N];
void dfs_color(ll cur)
{
color[cur]=1;
for(auto i:g[cur])
{
if(color[i]==1)
{
circle[i]=1;
}
else if(color[i]==2)
{
mul[i]=1;
}
else if(color[i]==0)
{
dfs_color(i);
}
}
color[cur]=2;
}
void dfs_mul(ll cur,int m)
{
vis[cur]=1;
if (mul[cur] == 1)
{
m = 1;
}
if(m==1)
{
ans[cur]=2;
}
//cout<<"cur is "<<cur<<" cir=="<<cir<<" m=="<<m<<" ans=="<<ans[cur]<<" color=="<<color[cur]<<endl;
for(auto i:g[cur])
{
if(!vis[i]){
dfs_mul(i,m);
}
}
}
void dfs_cir(ll cur,ll cir)
{
vis[cur]=1;
if (circle[cur] == 1)
{
cir = 1;
}
if(cir==1)
{
ans[cur]=-1;
}
for(auto i:g[cur])
{
if(!vis[i]){
dfs_cir(i,cir);
}
}
}
void dfs_reachable(ll cur)
{
vis[cur]=1;
ans[cur]=1;
for(auto i:g[cur])
{
if(!vis[i]){
dfs_reachable(i);
}
}
}
void solve()
{
cin>>n>>m;
for(ll i=1;i<=n;i++)
{
g[i].clear();
color[i]=0;
circle[i]=0;
mul[i]=0;
ans[i]=0;
vis[i]=0;
}
for(ll i=0;i<m;i++)
{
ll a,b;
cin>>a>>b;
g[a].push_back(b);
}
dfs_color(1);
memset(vis,0,sizeof vis);
dfs_reachable(1);
memset(vis,0,sizeof vis);
for (ll i = 1; i <= n; i++)
{
if (mul[i] == 1)
{
dfs_mul(i, mul[i]);
}
}
memset(vis,0,sizeof vis);
for (ll i = n; i >=1; i--)
{
if (circle[i] == 1)
{
dfs_cir(i,circle[i]);
}
}
for(ll i=1;i<=n;i++)
{
cout<<ans[i]<<' ';
}
cout<<endl;
}
int main()
{
IOS;
ll _;
cin>>_;
while(_--)
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
static const long long maxLL = (long long)1 << 62;
const long long MOD = 1000000007;
const long long INF = 1e18;
long long N, M;
long long a[100010];
long long maxcnt = 0, sum = 0;
long long now = 0;
long long tmp = 0;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M;
for (long long i = 0; i < N; i++) {
cin >> a[i];
sum += a[i];
maxcnt = max((maxcnt), (a[i]));
}
tmp = maxcnt + N - 1;
sort(a, a + N);
long long ans = 0;
now = 1;
for (long long i = 0; i < N - 1; i++) {
if (now == maxcnt) break;
if (a[i] >= now) {
ans++;
now++;
}
}
tmp -= ans;
cout << sum - tmp << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
int s = n / k;
int c[k], p = 0;
memset(c, 0, sizeof(c));
int i = 0, j = 0, ii;
while (j < k) {
p = 0;
ii = i;
while (p < s) {
c[j] = c[j] + a[ii];
ii += k;
p++;
}
j++, i++;
}
int min = INT_MAX, mini = 0;
for (int i = 0; i < k; i++) {
if (min > c[i]) {
min = c[i];
mini = i;
}
}
cout << (mini + 1) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, r;
cin >> n >> l >> r;
int max_number = pow(2, l - 1);
int sum_a = 0;
int rem = n;
while (max_number > 1) {
sum_a += max_number;
max_number >>= 1;
rem--;
}
sum_a += rem;
int sum_b = 0;
int cur = 1;
for (int i = 0; i < n; i++) {
sum_b += cur;
if (i + 1 < r) {
cur <<= 1;
}
}
cout << sum_a << " " << sum_b << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string s;
int a[10000];
cin >> s;
for (int i = 0; i < s.length(); i++) {
a[i] = int(s[i]) - int('a') + 1;
}
sort(a, a + n);
long long sum = a[0];
int col = 1;
int ind = 0;
if (m == 1) {
cout << sum << endl;
return 0;
}
for (int i = 1; i < n; i++) {
if (a[i] - a[ind] >= 2) {
sum += a[i];
col++;
ind = i;
}
if (col == m) {
cout << sum << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000009;
const int MOD = 1000000007;
int f[30], last[30], best, n, m, K, sum, tmp;
char s[maxn];
int main() {
scanf("%d%d%s", &n, &K, s + 1);
m = strlen(s + 1);
for (int i = 1; i <= m; i++) {
tmp = f[s[i] - 'a'];
f[s[i] - 'a'] = (sum + 1) % MOD;
sum = ((sum + f[s[i] - 'a'] - tmp) % MOD + MOD) % MOD;
last[s[i] - 'a'] = i;
}
for (int i = m + 1; i <= m + n; i++) {
best = -1;
for (int j = 0; j <= K - 1; j++)
if (best == -1 || last[j] < last[best]) best = j;
tmp = f[best];
f[best] = (sum + 1) % MOD;
sum = ((sum + f[best] - tmp) % MOD + MOD) % MOD;
last[best] = i;
}
printf("%d\n", sum + 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
double eps = 1e-9;
using namespace std;
int arr[500002];
int deleted[500002];
int main() {
std::ios::sync_with_stdio(false);
int n, m, p;
cin >> n >> m >> p;
string s, cm;
cin >> s >> cm;
stack<pair<char, int> > sta;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(') {
sta.push(make_pair('(', i));
} else {
pair<char, int> tp = sta.top();
sta.pop();
arr[i + 1] = tp.second + 1;
arr[tp.second + 1] = i + 1;
}
}
for (int i = 0; i < m; i++) {
if (cm[i] == 'R') {
if (deleted[p + 1]) {
p = arr[p + 1] + 1;
} else {
p++;
}
} else if (cm[i] == 'L') {
if (deleted[p - 1]) {
p = arr[p - 1] - 1;
} else {
p--;
}
} else {
int lm, rm;
if (s[p - 1] == '(') {
if (deleted[p - 1]) {
lm = arr[p - 1];
} else {
lm = p;
}
if (deleted[arr[p] + 1]) {
rm = arr[arr[p] + 1];
} else {
rm = arr[p];
}
} else {
if (deleted[p + 1]) {
rm = arr[p + 1];
} else {
rm = p;
}
if (deleted[arr[p] - 1]) {
lm = arr[arr[p] - 1];
} else {
lm = arr[p];
}
}
arr[lm] = rm;
arr[rm] = lm;
deleted[lm] = 1;
deleted[rm] = 1;
if (rm == n) {
p = lm - 1;
} else {
p = rm + 1;
}
}
}
int i = 1;
while (i <= n) {
if (deleted[i]) {
i = arr[i] + 1;
} else {
cout << s[i - 1];
i++;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
long long minX = (1LL << 60), minY = (1LL << 60);
long long maxX = 0, maxY = 0;
long long totalArea = 0;
for (int i = 0; i < n; i++) {
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
totalArea += (x2 - x1) * (y2 - y1);
minX = min(minX, x1), maxX = max(maxX, x2);
minY = min(minY, y1), maxY = max(maxY, y2);
}
if ((maxX - minX) * (maxY - minY) == totalArea && maxX - minX == maxY - minY)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
set<int> R, C;
int n, m;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
if (ifstream("test.inp")) cin.rdbuf((new ifstream("test.inp"))->rdbuf());
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
R.insert(x);
C.insert(y);
cout << static_cast<long long>(n - R.size()) * (n - C.size()) << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, q;
vector<int> a;
vector<pair<int, int> > v;
int main() {
cin >> n >> k >> q;
a.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < q; ++i) {
int t, x;
cin >> t >> x;
--x;
if (t == 1) {
v.push_back(make_pair(a[x], x));
sort(v.rbegin(), v.rend());
if (v.size() > k) v.pop_back();
} else {
bool t = false;
for (int i = 0; i < v.size(); ++i)
if (v[i].second == x) t = true;
if (t)
cout << "YES\n";
else
cout << "NO\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, i, t;
char a[500005];
bool fff;
long long sum;
int main() {
cin >> n;
scanf("%s", a);
for (int i = 0; i < n - 10; i++)
if (a[i] == '8') sum++;
if (sum > (n - 11) / 2)
printf("YES");
else
printf("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1021][1021];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
a[i][j] = 1 + ((i + j - 2) % (n - 1));
}
for (int i = 1; i <= n; ++i) {
a[n][i] = a[i][n] = a[i][i];
a[i][i] = 0;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < n; ++j) cout << a[i][j] << " ";
cout << a[i][n] << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T qmin(const T &a, const T &b) {
return a < b ? a : b;
}
template <typename T>
inline T qmax(const T &a, const T &b) {
return a > b ? a : b;
}
template <typename T>
inline void getmin(T &a, const T &b) {
if (a > b) a = b;
}
template <typename T>
inline void getmax(T &a, const T &b) {
if (a < b) a = b;
}
inline void fileio(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
const int inf = (int)1e9 + 7;
const long long linf = (long long)1e17 + 7;
int a[100], n;
string ans[100];
string tostr(int id) {
string ans = "eax";
ans[1] += id;
return ans;
}
bool dfs(int tot, int pos, int n) {
if (pos == tot) {
if (a[pos] != n) return false;
printf("%d\n", tot);
for (register int i = 0; i < (tot); ++i) printf("%s\n", ans[i].c_str());
return true;
}
for (register int i = (0); i <= (pos); ++i) {
for (int k = 1; k <= 8; k <<= 1) {
a[pos + 1] = a[i] * k;
if (a[pos + 1] > n || pos + 1 == tot && a[pos + 1] != n) continue;
ans[pos] = "lea " + tostr(pos + 1) + ", [" + (char)('0' + k) + "*" +
tostr(i) + "]";
if (dfs(tot, pos + 1, n)) return true;
}
}
for (register int i = (0); i <= (pos); ++i)
for (register int j = (0); j <= (pos); ++j) {
for (int k = 1; k <= 8; k <<= 1) {
a[pos + 1] = a[i] * k + a[j];
if (a[pos + 1] > n || pos + 1 == tot && a[pos + 1] != n) continue;
ans[pos] = "lea " + tostr(pos + 1) + ", [" + tostr(j) + " + " +
(char)('0' + k) + "*" + tostr(i) + "]";
if (dfs(tot, pos + 1, n)) return true;
}
}
return false;
}
int main(void) {
scanf("%d", &n);
a[0] = 1;
for (int i = 0;; ++i)
if (dfs(i, 0, n)) break;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int inf = 1e9;
struct Node {
int sol;
vector<int> v;
} st[4 * N];
struct Q {
int l, r, idx;
bool operator<(const Q &q) const { return r < q.r; }
} qv[3 * N];
int a[N], n, q, sol[3 * N];
int b[N];
void init(int idx, int left, int right) {
if (left == right) {
st[idx].sol = inf;
st[idx].v.push_back(a[left]);
return;
}
init(2 * idx, left, (left + right) / 2);
init(2 * idx + 1, (left + right) / 2 + 1, right);
st[idx].v.resize((int)st[2 * idx].v.size() + (int)st[2 * idx + 1].v.size());
merge(st[2 * idx].v.begin(), st[2 * idx].v.end(), st[2 * idx + 1].v.begin(),
st[2 * idx + 1].v.end(), st[idx].v.begin());
st[idx].sol = inf;
for (int i = 1; i < (int)st[idx].v.size(); i++)
st[idx].sol = min(st[idx].sol, st[idx].v[i] - st[idx].v[i - 1]);
}
int query(int idx, int left, int right, int l, int r) {
if (l <= left && right <= r) return st[idx].sol;
int ret = inf;
if (l <= (left + right) / 2)
ret = min(ret, query(2 * idx, left, (left + right) / 2, l, r));
if (r > (left + right) / 2)
ret = min(ret, query(2 * idx + 1, (left + right) / 2 + 1, right, l, r));
return ret;
}
void update(int idx, int left, int right, int x, int val, int &d) {
if (left == right) {
st[idx].sol = min(st[idx].sol, abs(st[idx].v[0] - val));
d = min(d, st[idx].sol);
return;
}
auto it = lower_bound(st[idx].v.begin(), st[idx].v.end(), val);
if ((it == st[idx].v.end() || *it >= val + d) &&
(it == st[idx].v.begin() || *(it - 1) <= val - d)) {
d = min(d, query(idx, left, right, left, x));
return;
}
if (x <= (left + right) / 2)
update(2 * idx, left, (left + right) / 2, x, val, d);
else {
update(2 * idx + 1, (left + right) / 2 + 1, right, x, val, d);
update(2 * idx, left, (left + right) / 2, (left + right) / 2, val, d);
}
st[idx].sol = min(min(st[2 * idx].sol, st[2 * idx + 1].sol), st[idx].sol);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
init(1, 1, n);
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%d", &qv[i].l, &qv[i].r);
qv[i].idx = i;
}
sort(qv, qv + q);
int R = 1;
for (int i = 0; i < q; i++) {
int l = qv[i].l, r = qv[i].r, idx = qv[i].idx;
while (R < r) {
R++;
int d = inf;
update(1, 1, n, R - 1, a[R], d);
}
sol[idx] = query(1, 1, n, l, r);
}
for (int i = 0; i < q; i++) printf("%d\n", sol[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
void readArray(int *v, int n);
int f(int *v, int l, int r);
int max(int n1, int n2);
int main() {
int left, right, n, a[1005], b[1005], best = 0;
scanf("%d", &n);
readArray(a, n);
readArray(b, n);
for (left = 1; left <= n; left++) {
for (right = left; right <= n; right++)
best = max(best, f(a, left, right) + f(b, left, right));
}
printf("%d\n", best);
return 0;
}
void readArray(int *v, int n) {
int i;
for (i = 1; i <= n; i++) scanf("%d", (v + i));
}
int f(int *v, int l, int r) {
int i, sum = 0;
for (i = l; i <= r; i++) sum |= *(v + i);
return sum;
}
int max(int n1, int n2) { return (n1 > n2) ? n1 : n2; }
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, xlin[102], xcol[102], xorlin, xorcol, ans[102][102];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> xlin[i];
for (int i = 1; i <= m; i++) cin >> xcol[i];
for (int i = 2; i <= n; i++) ans[i][1] = xlin[i], xorcol ^= xlin[i];
for (int i = 2; i <= m; i++) ans[1][i] = xcol[i], xorlin ^= xcol[i];
if ((xorlin ^ xlin[1]) != (xorcol ^ xcol[1])) {
cout << "NO\n";
return 0;
}
ans[1][1] = xorlin ^ xlin[1];
cout << "YES\n";
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << ans[i][j] << " ";
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long solve(long long s, long long x) {
long long S = s;
long long X = x;
int ways = 0;
int hb = -1;
for (int i = 0; i < (int)60; ++i) {
if (x & (1ll << i)) {
++ways;
s -= 1ll << i;
hb = i;
}
}
if (s < 0) {
return 0;
}
if (hb == -1) {
if (s % 2 == 0) return 1;
return 0;
}
for (int i = 0; i < (int)60; ++i) {
if (!(x & (1ll << i))) {
int bit = i + 1;
if (s & (1ll << bit)) {
s -= 1ll << bit;
}
}
}
if (s == 0) {
long long ans = 1ll << ways;
if (X + 0 == S) {
ans -= 2;
}
return ans;
}
return 0;
}
int main() {
long long s, x;
cin >> s >> x;
cout << solve(s, x) << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
const int MAX_N = 200000;
const int inf = (int)1e9;
vector<int> adj[MAX_N + 5];
int ans,n,t,x,y;
int dfs(int x,int p){
if(x!=0 && adj[x].size()==1)
return 1;
vector<int > dis;
for(auto v:adj[x]){
if(v==p)
continue;
int r=dfs(v,x);
dis.push_back(r);
}
sort(dis.begin(),dis.end());
if(dis.size()>1){
if(x==0){
ans=max({ans,dis.back(),dis[dis.size()-2]+1});
}
else{
ans= max(ans,dis.back() + 1);
}
}
ans=max(ans,dis[0]);
return dis[0]+1;
}
int main(){
cin>>t;
while(t--){
cin>>n;ans=0;
for (int i = 0; i <= n; i++)
adj[i].clear();
for(int i=0;i<n-1;i++){
cin>>x>>y;
x--,y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
ans = 0;
dfs(0, -1);
cout << ans << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct poeple {
int h, k;
char s[50];
bool operator<(const poeple b) const { return h < b.h; }
} a[3005];
int n, cnt, p;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%s %d", a[i].s, &a[i].h);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
if (i <= a[i].h) {
puts("-1");
return 0;
}
a[i].k = i - a[i].h;
for (int j = 1; j < i; j++)
if (a[j].k >= a[i].k) a[j].k++;
}
for (int i = 1; i <= n; i++) {
printf("%s %d\n", a[i].s, a[i].k);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
void dfs(long long f, long long& answer, vector<long long>& deg,
vector<vector<long long>>& g) {
for (long long t : g[f]) {
if (deg[t] == 0) {
++deg[f];
answer *= deg[f];
answer %= mod;
deg[t] = 1;
dfs(t, answer, deg, g);
}
}
}
int main() {
long long n;
cin >> n;
vector<vector<long long>> g(n + 10, vector<long long>(0, 0));
vector<long long> deg(n + 10, 0);
for (long long i = 1; i < n; ++i) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
long long answer = n;
dfs(1, answer, deg, g);
cout << answer;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dp[10010][2], n, i, m;
string s, curr;
vector<string> ans, ans1;
int main() {
cin >> s;
n = s.size();
dp[n][0] = dp[n][1] = 1;
for (i = n - 2; i >= 5; i--) {
if (dp[i + 3][0] == 1)
dp[i][1] = 1;
else if (dp[i + 3][1] == 0)
dp[i][1] = 0;
else if ((s[i] != s[i + 3]) || (s[i + 1] != s[i + 4]) ||
(s[i + 2] != s[i + 5]))
dp[i][1] = 1;
else
dp[i][1] = 0;
if (dp[i + 2][1] == 1)
dp[i][0] = 1;
else if (dp[i + 2][0] == 0)
dp[i][0] = 0;
else if ((s[i] != s[i + 2]) || (s[i + 1] != s[i + 3]))
dp[i][0] = 1;
else
dp[i][0] = 0;
}
for (i = 5; i < n - 1; i++) {
curr.clear();
curr += s[i];
curr += s[i + 1];
if (dp[i + 2][0] | dp[i + 2][1]) ans.push_back(curr);
if (i < n - 2) {
curr += s[i + 2];
if (dp[i + 3][0] | dp[i + 3][1]) ans.push_back(curr);
}
}
sort(ans.begin(), ans.end());
m = ans.size();
if (m == 0) {
cout << 0 << endl;
return 0;
}
curr = ans[0];
ans1.push_back(curr);
for (i = 1; i < m; i++) {
if (ans[i] == curr) continue;
curr = ans[i];
ans1.push_back(curr);
}
m = ans1.size();
cout << m << endl;
for (i = 0; i < m; i++) cout << ans1[i] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, x, r, a[100100], fi[100100], lst[100100];
bool ok(int i, int j) {
if (i == j) return lst[i] == 0;
if (lst[i] == 0 || lst[j] == 0) return true;
return lst[j] < fi[i];
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d", &a[i]);
if (fi[a[i]] == 0) fi[a[i]] = i;
lst[a[i]] = i;
}
for (i = 1; i <= n; i++)
for (j = -1; j <= 1; j++) {
x = i + j;
if (x >= 1 && x <= n && ok(i, x)) r++;
}
printf("%d\n", r);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long power_mod(long long a, long long b) {
if (b == 0) {
return 1;
}
long long temp = power_mod(a, b / 2);
temp = (temp * temp) % 1000000007;
if (b % 2) {
temp = (temp * a) % 1000000007;
}
return temp;
}
long long NCR(long long n, long long r) {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
vector<int> ans(n);
ans[0] = v[0];
vector<bool> b(n + 1, false);
b[v[0]] = true;
int index = 1;
bool poss = true;
for (int i = 1; i < n; ++i) {
if (v[i] > v[i - 1]) {
ans[i] = v[i];
} else {
while (index < n && b[index]) {
++index;
}
if (index > v[i] || index == n) {
poss = false;
break;
}
ans[i] = index;
++index;
}
b[ans[i]] = true;
}
if (!poss) {
cout << -1 << "\n";
continue;
}
for (int i : ans) {
cout << i << ' ';
}
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> adj[100005];
vector<int> vis(100005, 1);
vector<int> ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
for (int qq = 1; qq <= T; qq++) {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
priority_queue<int> v;
v.push(-1);
vis[1] = 0;
while (!v.empty()) {
int u = -v.top();
v.pop();
ans.push_back(u);
for (auto i : adj[u])
if (vis[i]) v.push(-i), vis[i] = 0;
}
for (auto i : ans) cout << i << ' ';
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int n, q;
std::vector<int> a, pos, ans, rt, vis, cnt, sum;
std::vector<std::vector<int>> e;
std::vector<std::vector<std::pair<long long, int>>> queries;
void dfs1(int u) {
vis[u] = 1;
for (int v : e[u]) {
if (vis[v] == 0) {
dfs1(v);
} else if (vis[v] == 1) {
pos[v] = 1;
for (int i = u; i != v; i = a[i]) {
rt[i] = v;
++pos[v];
}
rt[v] = v;
for (int i = u, j = pos[v]; i != v; i = a[i]) pos[i] = --j;
}
}
vis[u] = 2;
}
void dfs2(int u, int d) {
if (pos[u] == -1)
for (auto &&[m, i] : queries[u])
if (d + m < int(cnt.size())) ans[i] -= cnt[d + m];
if (d >= int(cnt.size())) cnt.resize(d + 1);
++cnt[d];
for (int v : e[u])
if (pos[v] == -1) dfs2(v, d + 1);
if (pos[u] == -1)
for (auto &&[m, i] : queries[u])
if (d + m < int(cnt.size())) ans[i] += cnt[d + m];
}
void dfs3(int u, int d) {
if (d >= int(cnt.size())) cnt.resize(d + 1);
++cnt[d];
for (int v : e[u])
if (rt[v] != v) dfs3(v, d + 1);
}
void dfs4(int u, int d) {
if (pos[u] != -1)
for (auto &&[m, i] : queries[u])
if (d + m < int(cnt.size())) ans[i] -= cnt[d + m];
if (d >= int(cnt.size())) cnt.resize(d + 1);
++cnt[d];
for (int v : e[u])
if (rt[v] != v) dfs4(v, d + 1);
if (pos[u] != -1)
for (auto &&[m, i] : queries[u])
if (d + m < int(cnt.size())) ans[i] += cnt[d + m];
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cin >> n;
a.resize(n);
pos.assign(n, -1);
e.resize(n);
queries.resize(n);
vis.resize(n);
rt.assign(n, -1);
for (int i = 0; i < n; ++i) {
std::cin >> a[i];
--a[i];
e[a[i]].push_back(i);
}
for (int i = 0; i < n; ++i)
if (vis[i] == 0) dfs1(i);
std::cin >> q;
ans.resize(q);
for (int i = 0; i < q; ++i) {
long long m;
int u;
std::cin >> m >> u;
--u;
queries[u].emplace_back(m, i);
}
for (int i = 0; i < n; ++i) {
if (pos[i] != -1) {
cnt.clear();
dfs2(i, 0);
}
}
for (int i = 0; i < n; ++i) {
if (rt[i] == i) {
cnt.clear();
dfs3(i, 0);
sum = cnt;
for (int j = pos[i]; j < int(sum.size()); ++j) sum[j] += sum[j - pos[i]];
int j = i;
do {
for (auto &&[m, k] : queries[j]) {
long long t = m + (i == j ? 0 : pos[j]);
if (t >= int(cnt.size())) {
t %= pos[i];
t += (cnt.size() - t - 1) / pos[i] * pos[i];
} else {
ans[k] -= cnt[t];
}
ans[k] += sum[t];
}
j = a[j];
} while (j != i);
cnt.clear();
dfs4(i, 0);
}
}
for (int i = 0; i < q; ++i) std::cout << ans[i] << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e18;
const int N = 3e3 + 222;
int c;
bool comp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
if (a.first.first / c != b.first.first / c) {
return a.first.first / c < b.first.first / c;
} else
return a.first.second < b.first.second;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
c = pow(n, 0.66);
int t[n];
for (int i = 0; i < n; ++i) cin >> t[i];
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (t[i] == 2) a[i] = -a[i];
}
long long pref[n];
pref[0] = a[0];
for (int i = 1; i < n; ++i) pref[i] = pref[i - 1] + a[i];
long long p[n], l[n], r[n];
set<long long> st;
st.insert(0);
st.insert(k);
map<long long, int> mp;
for (int i = 0; i < n; ++i) {
l[i] = pref[i] - k;
r[i] = pref[i] + k;
p[i] = pref[i];
st.insert(l[i]);
st.insert(r[i]);
st.insert(p[i]);
}
int z = 1;
for (auto to : st) {
mp[to] = z;
z++;
}
int q;
cin >> q;
pair<pair<int, int>, int> x[q];
for (int i = 0; i < q; ++i) {
cin >> x[i].first.first >> x[i].first.second;
x[i].first.first--;
x[i].first.second--;
x[i].second = i;
}
for (int i = 0; i < n; ++i) {
l[i] = mp[l[i]];
r[i] = mp[r[i]];
p[i] = mp[p[i]];
}
sort(x, x + q, comp);
vector<int> cnt(z, 0);
vector<long long> ot(q);
int cl = -1, cr = -1;
long long ans = 0;
cnt[mp[0]] = 1;
for (int i = 0; i < q; ++i) {
while (cr < x[i].first.second) {
cr++;
ans += cnt[l[cr]];
cnt[p[cr]]++;
}
while (cr > x[i].first.second) {
cnt[p[cr]]--;
ans -= cnt[l[cr]];
cr--;
}
while (cl > x[i].first.first - 1) {
cl--;
if (cl > -1) {
ans += cnt[r[cl]];
cnt[p[cl]]++;
} else {
ans += cnt[mp[k]];
cnt[mp[0]]++;
}
}
while (cl < x[i].first.first - 1) {
if (cl > -1) {
cnt[p[cl]]--;
ans -= cnt[r[cl]];
} else {
cnt[mp[0]]--;
ans -= cnt[mp[k]];
}
cl++;
}
ot[x[i].second] = ans;
}
for (auto to : ot) cout << to << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
double pi = 3.1415926535897;
double dp[1 << maxn];
int n, L, R;
int lp[maxn], rp[maxn];
int ang[maxn];
int main() {
cin >> n >> L >> R;
for (int i = 0; i < n; i++) {
cin >> lp[i] >> rp[i] >> ang[i];
}
double ans = L;
int sN = (1 << n);
for (int i = 0; i < sN; i++) dp[i] = L;
for (int i = 0; i < sN; i++) {
double cur = dp[i];
if (ans < cur) ans = cur;
for (int j = 0; j < n; j++) {
if (!(i & (1 << j))) {
double a = lp[j], b = rp[j], angle = ang[j];
angle *= pi;
angle /= 180.0;
angle += atan((cur - a) / b);
double nxt = a + b * tan(angle);
if (nxt < cur || nxt > R) {
nxt = R;
}
int ij = i + (1 << j);
if (dp[ij] < nxt) dp[ij] = nxt;
}
}
}
ans -= L;
printf("%.9lf\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7f7f7f7f;
int src, snk, nNode, nEdge, n, edge[50 + 5][50 + 5];
int fin[52 + 5], pre[52 + 5], dist[52 + 5];
int cap[2 * 100000 + 5], cost[2 * 100000 + 5], Next[2 * 100000 + 5],
to[2 * 100000 + 5], from[2 * 100000 + 5];
void init(int _src, int _snk, int nodes) {
memset(fin, -1, sizeof(fin));
nNode = nodes, nEdge = 0;
src = _src, snk = _snk;
}
void addEdge(int u, int v, int _cost, int _cap) {
from[nEdge] = u, to[nEdge] = v, cap[nEdge] = _cap, cost[nEdge] = _cost;
Next[nEdge] = fin[u], fin[u] = nEdge++;
from[nEdge] = v, to[nEdge] = u, cap[nEdge] = 0, cost[nEdge] = -(_cost);
Next[nEdge] = fin[v], fin[v] = nEdge++;
assert(nEdge <= 2 * 100000);
}
bool bellman() {
int iter, u, v, i;
bool flag = true;
memset(dist, 0x7f, sizeof(dist));
memset(pre, -1, sizeof(pre));
dist[src] = 0;
for (iter = 1; iter < nNode && flag; iter++) {
flag = false;
for (u = 1; u <= nNode; u++) {
for (i = fin[u]; i >= 0; i = Next[i]) {
v = to[i];
if (cap[i] && dist[v] > dist[u] + cost[i]) {
dist[v] = dist[u] + cost[i];
pre[v] = i;
flag = true;
}
}
}
}
return (dist[snk] < INF);
}
int mcmf(int &fcost) {
int netflow, i, bot, u;
netflow = fcost = 0;
while (bellman()) {
bot = INF;
for (u = pre[snk]; u >= 0; u = pre[from[u]]) bot = min(bot, cap[u]);
for (u = pre[snk]; u >= 0; u = pre[from[u]]) {
cap[u] -= bot;
cap[u ^ 1] += bot;
fcost += bot * cost[u];
}
netflow += bot;
}
return netflow;
}
int setFlow(int flw) {
int i, j, c;
src = n + 1;
snk = n;
init(src, snk, src);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) {
c = edge[i][j];
if (i == j || c == 0) continue;
addEdge(i, j, 0, c);
addEdge(i, j, 1, INF);
}
addEdge(src, 1, 0, flw);
int min_cost, F;
F = mcmf(min_cost);
return (F == flw) ? min_cost : INF;
}
int main() {
int i, j, k;
int c;
scanf("%d %d", &n, &k);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) scanf("%d", &edge[i][j]);
int lo = 0, hi = 100000000, mid;
while (lo != hi) {
mid = lo + (hi - lo + 1) / 2;
if (setFlow(mid) <= k)
lo = mid;
else
hi = mid - 1;
}
printf("%d\n", lo);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, p, q, j, k;
string s;
int main() {
cin >> n >> p >> q >> s;
int cnt1 = 0, cnt2 = 0;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
if (i * p + j * q == n) {
cnt1 = i;
cnt2 = j;
goto go;
}
}
}
go:
if (q + p == n) {
cout << 2 << endl;
for (int i = 0; i < n - q; i++) cout << s[i];
cout << endl;
for (int i = n - q; i < n; i++) cout << s[i];
} else if (n % p == 0) {
cout << n / p << endl;
int m = n / p;
int i = 0;
while (m--) {
for (int i = k; i < n / (n / p) + k; i++) cout << s[i], j = i + 1;
k = j;
cout << endl;
}
} else if (n % q == 0) {
cout << n / q << endl;
int m = n / q;
while (m--) {
for (int i = k; i < n / (n / q) + k; i++) cout << s[i], j = i + 1;
k = j;
cout << endl;
}
} else if (cnt1 || cnt2) {
cout << cnt1 + cnt2 << endl;
int m = cnt1;
while (m--) {
for (int i = k; i < p + k; i++) cout << s[i], j = i + 1;
k = j;
cout << endl;
}
while (cnt2--) {
for (int i = k; i < q + k; i++) cout << s[i], j = i + 1;
k = j;
cout << endl;
}
} else
cout << -1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[10];
for (int i = 0; i < 10; i++) {
a[i] = 0;
}
int n;
cin >> n;
for (int i = n + 1; i <= 9012; i++) {
bool flg = true;
int r = i;
while (r > 0) {
a[r % 10] += 1;
r /= 10;
}
for (int j = 0; j < 10; j++) {
if (a[j] > 1) {
flg = false;
}
a[j] = 0;
}
if (flg) {
cout << i << endl;
return 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int nxt[1005 * 55][10];
int n;
char s[1005];
int ln;
int loc[1005][1005];
int dep[1005 * 55];
char x[55];
int d;
bool alloweq;
int cache[55][1005 * 55][2][2];
int go(int di, int nd, int md, int ce) {
md |= dep[nd] >= d / 2;
if (di == d) return md && (alloweq || ce == 0);
if (cache[di][nd][md][ce] != -1) return cache[di][nd][md][ce];
int uv = 9;
if (ce) uv = x[di] - '0';
long long res = 0;
for (int v = (0); v < (uv + 1); v++)
res += go(di + 1, nxt[nd][v], md, ce && v == uv);
return cache[di][nd][md][ce] = res % 1000000007;
}
int main() {
scanf(" %s", s);
ln = strlen(s);
for (int i = (0); i < (ln); i++) {
int c = 0;
for (int j = (i); j < (ln); j++) {
int v = s[j] - '0';
if (!nxt[c][v]) {
nxt[c][v] = ++n;
}
c = nxt[c][v];
loc[i][j] = c;
dep[c] = j - i + 1;
if (dep[c] > 50) break;
}
}
for (int dij = (0); dij < (ln + 1); dij++)
for (int i = (0); i < (ln); i++) {
int j = i + dij;
if (j < ln) {
for (int v = (0); v < (10); v++) {
if (!nxt[loc[i][j]][v]) {
nxt[loc[i][j]][v] = nxt[loc[i + 1][j]][v];
}
}
}
}
scanf(" %s", x);
d = strlen(x);
memset(cache, -1, sizeof cache);
alloweq = false;
int tmp = go(0, 0, 0, 1);
scanf(" %s", x);
memset(cache, -1, sizeof cache);
alloweq = true;
int tmp2 = go(0, 0, 0, 1);
printf("%d\n", (tmp2 - tmp + 1000000007) % 1000000007);
}
| 12 |
#include <bits/stdc++.h>
long long nof(long long b) {
long long count = 0, i;
for (i = 1; i * i <= b; i++) {
if (b % i == 0) {
if (b / i == i)
count++;
else
count += 2;
}
}
return count;
}
int main() {
long long b, ans;
scanf("%lld", &b);
if (b == 1)
ans = 1;
else
ans = nof(b);
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1 << 30;
int c[6];
int n, s;
void solve() {
int i, j, k, t, ii, jj, kk, tt, s1, s2;
t = oo;
for (i = s / n; i >= 0; i--) {
s1 = i * c[3];
for (j = min((s - s1) / (c[4] + c[5]), (t + s1) / c[4]); j >= i; j--) {
s2 = j * c[4];
if (s1 - s2 >= t) break;
k = (s - s1 - s2) / c[5];
if (k * c[5] - s2 >= t) break;
if (s1 + s2 + k * c[5] == s && k >= j) {
tt = abs(s1 - s2) + abs(s2 - k * c[5]);
if (tt < t) {
t = tt;
ii = i;
jj = j;
kk = k;
}
}
}
}
if (t == oo)
printf("-1\n");
else
printf("%d %d %d\n", ii, jj, kk);
}
int main() {
int i, k;
scanf("%d%d", &n, &s);
memset(c, 0, sizeof(c));
for (i = 0; i < n; i++) {
scanf("%d", &k);
c[k]++;
}
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 7000 + 10;
bool was[N][2];
int cost[N][2];
int out_deg[N][2];
vector<int> s[2];
int n;
int k1;
int k2;
int mod_add(int a, int b) {
a -= b;
a %= n;
a += n;
return a % n;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cin >> n;
cin >> k1;
s[0].resize(k1);
for (int i = 0; i < k1; i++) cin >> s[0][i];
cin >> k2;
s[1].resize(k2);
for (int i = 0; i < k2; i++) cin >> s[1][i];
cost[0][0] = cost[0][1] = -1;
for (int i = 1; i < n; i++) {
out_deg[i][0] = k1;
out_deg[i][1] = k2;
}
queue<pair<int, int> > q;
q.push(pair<int, int>(0, 0));
q.push(pair<int, int>(0, 1));
was[0][0] = was[0][1] = true;
while (q.size()) {
auto tp = q.front();
q.pop();
int x = tp.first;
int who = tp.second;
int ans = -1;
if (x > 0) {
for (int y : s[who]) ans = max(ans, -cost[mod_add(x, -y)][1 - who]);
}
for (int y : s[1 - who]) {
int to = mod_add(x, y);
if (was[to][1 - who]) continue;
out_deg[to][1 - who]--;
if (ans == -1) out_deg[to][1 - who] = 0;
if (out_deg[to][1 - who] == 0) {
was[to][1 - who] = true;
q.push(pair<int, int>(to, 1 - who));
}
}
cost[x][who] = ans;
}
for (int who = 0; who < 2; who++) {
for (int i = 1; i < n; i++)
if (cost[i][who] == 1)
cout << "Win ";
else if (cost[i][who] == 0)
cout << "Loop ";
else
cout << "Lose ";
cout << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long modl = 998244353;
const double pie = 3.1415926535;
unsigned long long power(unsigned long long x, unsigned long long y) {
if (y == 0)
return 1;
else {
if (y % 2 == 0)
return power(x * x, y / 2);
else
return x * power(x * x, (y - 1) / 2);
}
}
long long mod_power(long long x, long long y, long long m) {
long long r = 1;
x = x % m;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) r = (r * x) % m;
y = y / 2;
x = (x * x) % m;
}
return r;
}
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
void transpose(int xl, int xr, int yl, int yr) {}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int TESTS = 1;
while (TESTS--) {
int n, m;
cin >> n >> m;
int a[n][m];
int b[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> a[i][j];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> b[i][j];
}
bool ok = true;
map<int, vector<int> > A;
map<int, vector<int> > B;
for (int i = 0; i < m; i++) {
int x = 0;
for (int j = i; j >= 0; j--) {
A[i].push_back(a[x][j]);
x++;
if (x == n) break;
}
sort(A[i].begin(), A[i].end());
}
int y = m;
for (int i = 1; i < n; i++) {
int x = i;
for (int j = m - 1; j >= 0; j--) {
A[y].push_back(a[x][j]);
x++;
if (x == n) break;
}
sort(A[y].begin(), A[y].end());
y++;
}
for (int i = 0; i < m; i++) {
int x = 0;
for (int j = i; j >= 0; j--) {
B[i].push_back(b[x][j]);
x++;
if (x == n) break;
}
sort(B[i].begin(), B[i].end());
}
y = m;
for (int i = 1; i < n; i++) {
int x = i;
for (int j = m - 1; j >= 0; j--) {
B[y].push_back(b[x][j]);
x++;
if (x == n) break;
}
sort(B[y].begin(), B[y].end());
y++;
}
auto ip = A.begin();
auto it = B.begin();
for (ip; ip != A.end(); ip++) {
if (ip->second != it->second) ok = false;
it++;
if (!ok) break;
}
if (!ok)
cout << "NO" << '\n';
else
cout << "YES" << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
int N, K;
struct node {
int x, y;
node() {}
node(const int &_x, const int &_y) : x(_x), y(_y) {}
bool operator<(const node &o) const { return (x == o.x ? y < o.y : x < o.x); }
} p[maxn], q[maxn];
int Y, yy[maxn];
long long ans;
void init() {
scanf("%d%d", &N, &K);
Y = 0;
for (int x1, x2, y1, y2, i = 1; i <= N; i++) {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
p[i] = node(x1 + x2, y1 + y2);
yy[++Y] = y1 + y2;
}
sort(p + 1, p + N + 1);
sort(yy + 1, yy + N + 1);
ans = (1ULL << 63) - 1;
}
long long work(int l, int r) {
int m = 0;
for (int i = 1; i <= N; i++) {
if (p[i].y >= l && p[i].y <= r) q[++m] = p[i];
}
int k = K - (N - m), res = (1ULL << 31) - 1;
k = m - 1 - k;
for (int i = 1; i + k <= m; i++) {
res = min(res, q[i + k].x - q[i].x);
}
if (r <= l) r = l + 1;
if (res <= 0) res = 1;
return (long long)((res + 1) >> 1) * ((r - l + 1) >> 1);
}
int main(int argc, const char *argv[]) {
init();
for (int i = 1; i <= K + 1; i++) {
for (int j = N; i - 1 + N - j <= K; j--) {
ans = min(ans, work(yy[i], yy[j]));
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using vi = vector<lli>;
using pii = pair<lli, lli>;
using vpii = vector<pair<lli, lli>>;
using si = set<lli>;
void solve() {
lli p, q;
cin >> p >> q;
if (p % q)
cout << p << '\n';
else {
map<lli, lli> mp;
lli dupq = q;
for (int i = 2; i * i <= dupq; i++) {
if (dupq % i == 0) {
int cnt = 0;
while (dupq % i == 0) {
cnt++;
dupq /= i;
}
mp[i] = cnt;
}
}
if (dupq > 1) mp[dupq] = 1;
lli ans = 0;
for (auto primes : mp) {
lli dupp = p;
while (dupp % (primes.first) == 0) {
dupp /= (primes.first);
if (dupp % q != 0) {
ans = max(ans, dupp);
break;
}
}
}
cout << ans << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int _t;
cin >> _t;
while (_t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD1 = 1e9 + 7;
const int MOD2 = 998244353;
const long long INF = 2 * 1e18;
const long double PI = 3.14159265358979323846;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
vector<vector<char> > s(n, vector<char>(m));
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) cin >> s[i][j];
if (n >= 4 && m >= 4)
cout << -1;
else {
if (n == 1 || m == 1) {
cout << 0;
return 0;
}
if (n == 2) {
long long cnt1 = 0, cnt2 = 0;
for (long long i = 0; i < m; i++) {
if (i % 2 == 0) {
if (s[0][i] == s[1][i])
cnt1++;
else
cnt2++;
} else {
if (s[0][i] != s[1][i])
cnt1++;
else
cnt2++;
}
}
cout << min(cnt1, cnt2);
return 0;
}
if (m == 2) {
long long cnt1 = 0, cnt2 = 0;
for (long long i = 0; i < n; i++) {
if (i % 2 == 0) {
if (s[i][0] == s[i][1])
cnt1++;
else
cnt2++;
} else {
if (s[i][0] != s[i][1])
cnt1++;
else
cnt2++;
}
}
cout << min(cnt1, cnt2);
return 0;
}
if (n == 3) {
long long cnt1 = m, cnt2 = m, cnt3 = m, cnt4 = m;
for (long long i = 0; i < m; i++) {
if (i % 2 == 0) {
if (s[0][i] == s[1][i] && s[1][i] == s[2][i])
cnt1--;
else if (s[0][i] == s[1][i] && s[1][i] != s[2][i])
cnt2--;
else if (s[0][i] != s[1][i] && s[1][i] == s[2][i])
cnt3--;
else
cnt4--;
} else {
if (s[0][i] != s[1][i] && s[1][i] != s[2][i])
cnt1--;
else if (s[0][i] != s[1][i] && s[1][i] == s[2][i])
cnt2--;
else if (s[0][i] == s[1][i] && s[1][i] != s[2][i])
cnt3--;
else
cnt4--;
}
}
cout << min(cnt1, min(cnt2, min(cnt3, cnt4)));
return 0;
}
if (m == 3) {
long long cnt1 = n, cnt2 = n, cnt3 = n, cnt4 = n;
for (long long i = 0; i < n; i++) {
if (i % 2 == 0) {
if (s[i][0] == s[i][1] && s[i][1] == s[i][2])
cnt1--;
else if (s[i][0] == s[i][1] && s[i][1] != s[i][2])
cnt2--;
else if (s[i][0] != s[i][1] && s[i][1] == s[i][2])
cnt3--;
else
cnt4--;
} else {
if (s[i][0] != s[i][1] && s[i][1] != s[i][2])
cnt1--;
else if (s[i][0] != s[i][1] && s[i][1] == s[i][2])
cnt2--;
else if (s[i][0] == s[i][1] && s[i][1] != s[i][2])
cnt3--;
else
cnt4--;
}
}
cout << min(cnt1, min(cnt2, min(cnt3, cnt4)));
return 0;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<pair<long long int, long long int> > s;
pair<long long int, long long int> p;
long long int d[300000], x, n, k, l = 0, di = 0;
vector<long long int> v[300000];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> x;
d[i] = x;
v[x].push_back(i);
di = max(x, di);
}
if (v[0].size() > 1 || v[1].size() > k) {
cout << -1;
return 0;
}
for (int i = 0; i <= di; i++)
if (v[i].size() == 0) {
cout << -1;
return 0;
}
for (int i = 0; i < v[1].size(); i++) s.insert({v[0][0], v[1][i]});
for (int i = 2; i <= di; i++) {
if (v[i - 1].size() * (k - 1) < v[i].size()) {
cout << -1;
return 0;
}
x = 1;
l = 0;
for (int j = 0; j < v[i].size(); j++) {
if (x > k - 1) {
l++;
x = 1;
}
s.insert({v[i - 1][l], v[i][j]});
x++;
}
}
cout << s.size() << endl;
while (!s.empty()) {
p = *s.begin();
cout << p.first << ' ' << p.second << '\n';
s.erase(s.begin());
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long long INF = 1e18;
using namespace std;
void solve() {
long long n, k = 3;
cin >> n;
while (k <= n) {
if (n % k == 0) {
cout << n / k << "\n";
break;
}
k += k + 1;
}
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a1, b1, c1, a2, b2, c2;
cin >> a1 >> b1 >> c1 >> a2 >> b2 >> c2;
if (a1 && b1 && a2 && b2) {
if (a1 * b2 == a2 * b1) {
if (a2 * c1 == a1 * c2)
cout << -1;
else
cout << 0;
} else
cout << 1;
} else {
if ((!a1 && !b1) && (!a2 && !b2)) {
if (!c1 && !c2)
cout << -1;
else
cout << 0;
} else if ((!a1 && !b1)) {
if (!c1) {
if (a2 && b2)
cout << -1;
else
cout << -1;
} else
cout << 0;
} else if ((!a2 && !b2)) {
if (!c2) {
if (a1 && b1)
cout << -1;
else
cout << -1;
} else
cout << 0;
} else if ((!a1 && !a2)) {
if (b1 * c2 == b2 * c1)
cout << -1;
else
cout << 0;
} else if ((!b1 && !b2)) {
if (a1 * c2 == a2 * c1)
cout << -1;
else
cout << 0;
} else
cout << 1;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
cout << (s / n) + !(s % n == 0);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Congruence {
int x, mod, index;
};
struct MultiInt {
int x, count;
};
struct SlidingWindow {
std::queue<Congruence> queue;
vector<MultiInt> residues = vector<MultiInt>(41);
void clear() {
queue = std::queue<Congruence>();
residues = vector<MultiInt>(41);
}
bool is_consistent(const Congruence c) const {
for (auto divisor = 1; divisor <= 40; divisor++)
if (c.mod % divisor == 0) {
const auto r = residues[divisor];
if (r.count != 0 && r.x != c.x % divisor) return false;
}
return true;
}
void shrink() {
assert(!queue.empty());
const auto c = queue.front();
queue.pop();
for (auto divisor = 1; divisor <= 40; divisor++)
if (c.mod % divisor == 0) residues[divisor].count--;
}
void expand(const Congruence c) {
for (auto divisor = 1; divisor <= 40; divisor++)
if (c.mod % divisor == 0) {
auto& r = residues[divisor];
r.x = c.x % divisor;
r.count++;
}
queue.push(c);
}
};
int main() {
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
auto by_value = vector<vector<Congruence>>(M);
for (auto i = 0; i < N; i++) {
int k;
cin >> k;
for (auto j = 0; j < k; j++) {
int value;
cin >> value;
value--;
by_value[value].push_back({j, k, i});
}
}
for (const auto& congruences : by_value) {
auto maxrun = 0;
auto window = SlidingWindow();
auto last_index = -1;
for (const auto c : congruences) {
if (c.index != last_index + 1) window.clear();
while (!window.is_consistent(c)) window.shrink();
window.expand(c);
last_index = c.index;
maxrun = max(maxrun, int(window.queue.size()));
}
cout << maxrun << "\n";
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
array<int, 2> a[3];
for (int i = 0; i < 3; ++i) cin >> a[i][0] >> a[i][1];
sort(a, a + 3);
if (a[0][1] <= a[1][1] && a[1][1] <= a[2][1]) {
cout << a[2][0] - a[0][0] + a[2][1] - a[0][1] + 1 << "\n";
int i = a[0][0], j = a[0][1];
while (i < a[1][0]) cout << i++ << " " << j << "\n";
while (j < a[1][1]) cout << i << " " << j++ << "\n";
while (i < a[2][0]) cout << i++ << " " << j << "\n";
while (j < a[2][1]) cout << i << " " << j++ << "\n";
cout << i << " " << j << "\n";
} else if (a[0][1] >= a[1][1] && a[1][1] >= a[2][1]) {
cout << a[2][0] - a[0][0] + a[0][1] - a[2][1] + 1 << "\n";
int i = a[0][0], j = a[0][1];
while (i < a[1][0]) cout << i++ << " " << j << "\n";
while (j > a[1][1]) cout << i << " " << j-- << "\n";
while (i < a[2][0]) cout << i++ << " " << j << "\n";
while (j > a[2][1]) cout << i << " " << j-- << "\n";
cout << i << " " << j << "\n";
} else {
if (abs(a[2][1] - a[1][1]) < abs(a[0][1] - a[1][1])) {
cout << a[2][0] - a[0][0] + abs(a[0][1] - a[2][1]) + 1 +
abs(a[2][1] - a[1][1])
<< "\n";
int i = a[0][0], j = a[0][1];
while (j > a[2][1]) cout << i << " " << j-- << "\n";
while (j < a[2][1]) cout << i << " " << j++ << "\n";
while (i < a[2][0]) cout << i++ << " " << j << "\n";
cout << i << " " << j << "\n";
while (j < a[1][1]) cout << a[1][0] << " " << ++j << "\n";
while (j > a[1][1]) cout << a[1][0] << " " << --j << "\n";
} else {
cout << a[2][0] - a[0][0] + abs(a[0][1] - a[2][1]) + 1 +
abs(a[0][1] - a[1][1])
<< "\n";
int i = a[0][0], j = a[0][1];
while (i < a[2][0]) cout << i++ << " " << j << "\n";
while (j > a[2][1]) cout << i << " " << j-- << "\n";
while (j < a[2][1]) cout << i << " " << j++ << "\n";
cout << i << " " << j << "\n";
j = a[0][1];
while (j < a[1][1]) cout << a[1][0] << " " << ++j << "\n";
while (j > a[1][1]) cout << a[1][0] << " " << --j << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
vector<vector<long long> > adjl(n);
vector<set<long long> > adjs(n);
for (int i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
u--, v--;
adjl[u].push_back(v), adjl[v].push_back(u);
}
vector<long long> t(n);
for (int i = 0; i < n; i++) cin >> t[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < adjl[i].size(); j++)
if (t[adjl[i][j]] <= t[i]) adjs[i].insert(t[adjl[i][j]]);
for (int i = 0; i < n; i++) {
if (adjs[i].count(t[i])) {
cout << "-1";
return 0;
}
if (adjs[i].size() != t[i] - 1) {
cout << "-1";
return 0;
}
}
vector<pair<long long, long long> > par(n);
for (int i = 0; i < n; i++) par[i].first = t[i], par[i].second = i + 1;
sort(par.begin(), par.end());
for (int i = 0; i < n; i++) cout << par[i].second << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
int n, m, p, l[1000010], f[N][N], g[N], s;
long long C[N], P[N];
int get(int i, int j) {
if (j > l[i - 1])
return 0;
else
return g[j];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> p;
for (int i = 1; i <= n; i++) {
cin >> l[i];
}
f[0][0] = P[0] = C[0] = 1;
for (int i = 1; i <= 5000; i++) {
P[i] = P[i - 1] * (m - i + 1) % p;
C[i] = C[i - 1] * i % p;
for (int j = 1; j <= i; j++)
f[i][j] = (f[i - 1][j - 1] + (long long)f[i - 1][j] * (j - 1)) % p;
}
s = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= l[i]; j++)
g[j] = f[l[i]][j] * ((P[j] * s - C[j] * get(i, j)) % p) % p;
s = 0;
for (int j = 0; j <= l[i]; j++) s = (s + g[j]) % p;
}
cout << (s + p) % p;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int a, b;
bool s;
} l[202];
int n, ans;
char s[202];
int main() {
scanf("%d", &n);
scanf("%s", s);
for (int i = 0; i < n; i++) {
scanf("%d%d", &l[i].a, &l[i].b);
if (s[i] == '1')
l[i].s = true;
else
l[i].s = false;
}
for (int t = 0; t < 130; t++) {
int cnt = 0;
for (int i = 0; i < n; i++) {
if ((t - l[i].b) >= 0 && (t - l[i].b) % l[i].a == 0) {
l[i].s = !l[i].s;
}
if (l[i].s) cnt++;
}
ans = max(ans, cnt);
}
printf("%d", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int INFI = (1 << 29);
const long long INFL = (1LL << 62);
using namespace std;
void solve() {
long long n;
string s;
cin >> n >> s;
vector<pair<char, long long> > v(n);
vector<long long> c(n, -1);
for (long long i = 0; i < n; i++) v[i] = {s[i], i};
sort(s.begin(), s.end());
for (long long i = 0; i < n; i++) {
for (long long j = i; j <= (n - 1); j++) {
if (v[j].first == s[i]) {
long long color = -1;
for (long long k = i; k <= (j - 1); k++)
if (c[v[k].second] != -1) color = c[v[k].second];
if (color == -1) {
for (long long k = i; k <= (j - 1); k++) c[v[k].second] = 0;
if (c[v[j].second] == -1) c[v[j].second] = 1;
} else {
for (long long k = i; k <= (j - 1); k++) c[v[k].second] = color;
if (c[v[j].second] == -1) c[v[j].second] = !color;
}
for (long long k = j; k > i; k--)
if (c[v[k - 1].second] != c[v[k].second]) swap(v[k - 1], v[k]);
if (s[i] != v[i].first) {
cout << "NO\n";
return;
}
break;
}
}
}
cout << "YES\n";
for (long long i = 0; i < n; i++) cout << c[i];
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
long long int M, N, aux, ini, fim, i;
long long int cont = 0;
scanf("%lld %lld", &M, &N);
if (N < M) {
aux = M;
M = N;
N = aux;
}
for (i = 1; i <= M; i++) {
ini = 5 - (i % 5);
fim = N - (N % 5) - (i % 5);
if (N - fim >= 5) fim += 5;
if (ini <= N && fim >= 1) {
cont += (fim - ini) / 5 + 1;
}
}
printf("%lld\n", cont);
}
| 1 |
#include <bits/stdc++.h>
int rgt[50002][52];
int rgtid[50002][52];
int nexts[50002][27];
int recent[27];
int n;
int INF = 1000000007;
int best[52];
int bestid[52];
char rds[50002];
int blen = 0;
char sols[52];
int main() {
scanf("%s", rds);
while (rds[n] != '\0') n++;
for (int i = 0; i < 51; i++) best[i] = -INF + 1;
for (int i = 0; i < 27; i++) recent[i] = -INF;
for (int i = 0; i < n; i++) {
recent[(int)(rds[i] - 'a')] = i;
for (int j = 0; j < 27; j++) nexts[i][j] = recent[j];
}
for (int j = 1; j < 51; j++) {
for (int i = 0; i < n; i++) rgt[i][j] = -INF;
int rightmost = -INF;
int opts;
for (int i = 0; i < n; i++) {
if (j == 1) {
if (rgt[i][1] <= nexts[n - 1][(int)(rds[i] - 'a')]) {
rgt[i][1] = nexts[n - 1][(int)(rds[i] - 'a')];
rgtid[i][1] = -INF;
}
} else {
if (rightmost >= 0 && i < rightmost) {
if (i <= nexts[rightmost - 1][(int)(rds[i] - 'a')]) {
rgt[i][j] = nexts[rightmost - 1][(int)(rds[i] - 'a')];
rgtid[i][j] = opts;
}
}
if (rightmost < rgt[i][j - 1]) {
rightmost = rgt[i][j - 1];
opts = i;
}
}
}
}
int opts = 0;
int optsst = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j < 51; j++) {
if (rgt[i][j] >= 0) {
if (i < rgt[i][j]) {
if (opts < j + j) {
opts = j + j;
optsst = i;
}
} else {
if (opts < j + j - 1) {
opts = j + j - 1;
optsst = i;
}
}
}
}
}
int nw = 0;
int k = (opts + 1) / 2;
while (1) {
if (optsst < 0) break;
sols[nw] = rds[optsst];
optsst = rgtid[optsst][k];
k--;
nw++;
}
for (int i = nw - 1; i >= 0; i--) printf("%c", sols[i]);
if (opts % 2 == 0) printf("%c", sols[0]);
for (int i = 1; i < nw; i++) printf("%c", sols[i]);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> A;
string s;
int main() {
A["void"] = 100;
A["errtype"] = 0;
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> s;
if (s[4] == 'd') {
string a, b;
cin >> a >> b;
int l = a.length();
int p = 0, q = 0;
for (int j = 0; j < l; ++j)
if (a[j] == '&')
++p;
else if (a[j] == '*')
++q;
a = a.substr(p, l - p - q);
q -= p;
if (A[a] + q < 100)
A[b] = 0;
else
A[b] = A[a] + q;
} else {
string a;
cin >> a;
int p = 0, q = 0;
int l = a.length();
for (int j = 0; j < l; ++j)
if (a[j] == '&')
++p;
else if (a[j] == '*')
++q;
a = a.substr(p, l - p - q);
q -= p;
if (A[a] + q < 100)
puts("errtype");
else {
printf("void");
int t = A[a] + q;
for (int j = 100; j < t; ++j) printf("*");
puts("");
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long k2, mx, m, n, k, mod = 1e9 + 7, flag, modd = 1e8;
const long long N = 5100;
vector<long long> s1;
vector<long long> s;
long long a[N];
long long solve(long long l, long long r) {
long long idx;
long long ans = 0;
m = 1e9 + 100;
flag = 0;
for (long long i = l; i < r; i++) {
if (a[i] < m) {
m = a[i];
idx = i;
}
if (a[i] != 0) flag = 1;
}
if (flag == 0) return ans;
if (r - l <= m) {
ans += r - l;
return ans;
}
ans += m;
for (long long i = l; i < r; i++) {
a[i] -= m;
}
long long p = 0;
flag = 0;
for (long long i = l; i < r; i++) {
if (a[i] != 0) flag = 1;
}
if (flag == 0) return ans;
long long l2 = l;
for (long long i = l; i <= r; i++) {
p = 0;
if (a[i] == 0) {
p = 1;
ans += solve(l2, i);
}
while (a[i] == 0) {
i++;
}
if (p == 1) {
l2 = i;
i--;
}
}
if (ans > r - l) {
return r - l;
} else {
return ans;
}
}
void Main() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long sefr = 0;
cout << solve(sefr, n);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
Main();
}
| 5 |
#include <bits/stdc++.h>
namespace IO {
template <typename _T>
inline bool read(_T& x) {
x = 0;
_T y = 1;
char c = getchar();
while ((c < '0' || '9' < c) && c != EOF) {
if (c == '-') y = -1;
c = getchar();
}
if (c == EOF) return false;
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getchar();
x *= y;
return true;
}
template <typename _T>
inline _T input() {
_T x = 0, y = 1;
char c = getchar();
while ((c < '0' || '9' < c) && c != EOF) {
if (c == '-') y = -1;
c = getchar();
}
if (c == EOF) return 0;
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getchar();
x *= y;
return x;
}
}; // namespace IO
using namespace IO;
int N, top, topmn, topmx;
int a[400007], b[400007], lst[400007], lstmp[400007];
int stkmn[400007], stkmx[400007];
long long res;
struct segTree {
struct node {
int mn, sum, tag;
} t[400007 << 2];
inline void update(int x) {
t[x].mn = std::min(t[x << 1].mn, t[x << 1 | 1].mn);
t[x].sum = 0;
if (t[x].mn == t[x << 1].mn) t[x].sum += t[x << 1].sum;
if (t[x].mn == t[x << 1 | 1].mn) t[x].sum += t[x << 1 | 1].sum;
}
inline void addTag(int x, int val) { t[x].mn += val, t[x].tag += val; }
inline void pushdown(int x) {
if (t[x].tag) {
addTag(x << 1, t[x].tag);
addTag(x << 1 | 1, t[x].tag);
t[x].tag = 0;
}
}
void build(int x, int l, int r) {
if (l == r) return t[x].mn = 0, t[x].sum = 1, void();
int mid = l + r >> 1;
build(x << 1, l, mid), build(x << 1 | 1, mid + 1, r);
update(x);
}
void modify(int x, int l, int r, int ql, int qr, int val) {
if (ql <= l && r <= qr) return addTag(x, val), void();
pushdown(x);
int mid = l + r >> 1;
if (ql <= mid) modify(x << 1, l, mid, ql, qr, val);
if (mid < qr) modify(x << 1 | 1, mid + 1, r, ql, qr, val);
update(x);
}
void change(int x, int l, int r, int pos, int val) {
if (l == r) return t[x].mn = val, t[x].sum = 1, void();
int mid = l + r >> 1;
pushdown(x);
if (pos <= mid)
change(x << 1, l, mid, pos, val);
else
change(x << 1 | 1, mid + 1, r, pos, val);
update(x);
}
} tr;
inline void solve() {
tr.build(1, 1, N);
for (int i = 1; i <= N; ++i) {
while (topmx && a[i] >= a[stkmx[topmx]]) {
tr.modify(1, 1, N, stkmx[topmx - 1] + 1, stkmx[topmx], -a[stkmx[topmx]]),
topmx--;
}
stkmx[++topmx] = i;
tr.modify(1, 1, N, stkmx[topmx - 1] + 1, i, a[i]);
while (topmn && a[i] <= a[stkmn[topmn]])
tr.modify(1, 1, N, stkmn[topmn - 1] + 1, stkmn[topmn], a[stkmn[topmn]]),
topmn--;
stkmn[++topmn] = i;
tr.modify(1, 1, N, stkmn[topmn - 1] + 1, i, -a[i]);
tr.modify(1, 1, N, lst[i] + 1, i, -1);
tr.change(1, 1, N, i, -1);
res += (long long)(tr.t[1].mn == -1 ? tr.t[1].sum : 0);
}
printf("%lld\n", res);
}
int main() {
read(N);
int x, y;
for (int i = 1; i <= N; ++i) {
read(x), read(y);
a[x] = y;
}
for (int i = 1; i <= N; ++i) {
lst[i] = lstmp[a[i]];
lstmp[a[i]] = i;
}
solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
int n, m;
cin >> n >> m;
pair<int, int>* ma = new pair<int, int>[m];
pair<int, int>* na = new pair<int, int>[n];
int* nrc = new int[n];
int* mrc = new int[m];
for (int i = 0; i < n; i++) {
nrc[i] = 0;
int a, b;
cin >> a >> b;
if (a > b) {
int v = a;
a = b;
b = v;
}
na[i] = make_pair(a, b);
}
for (int i = 0; i < m; i++) {
mrc[i] = 0;
int a, b;
cin >> a >> b;
if (a > b) {
int v = a;
a = b;
b = v;
}
ma[i] = make_pair(a, b);
}
bool ot = 1;
int pm = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int a1 = na[i].first;
int b1 = na[i].second;
int a2 = ma[j].first;
int b2 = ma[j].second;
if (a1 == a2 && b1 == b2) {
continue;
}
if (a1 == a2 || a1 == b2) {
if (pm != 0 && pm != a1) {
ot = 0;
}
pm = a1;
if (nrc[i] != 0 && nrc[i] != a1) {
cout << -1 << endl;
return 0;
}
nrc[i] = a1;
if (mrc[j] != 0 && mrc[j] != a1) {
cout << -1 << endl;
return 0;
}
mrc[j] = a1;
}
if (b1 == a2 || b1 == b2) {
if (pm != 0 && pm != b1) {
ot = 0;
}
pm = b1;
if (nrc[i] != 0 && nrc[i] != b1) {
cout << -1 << endl;
return 0;
}
nrc[i] = b1;
if (mrc[j] != 0 && mrc[j] != b1) {
cout << -1 << endl;
return 0;
}
mrc[j] = b1;
}
}
}
if (!ot) {
cout << 0 << endl;
cin >> n;
return 0;
}
cout << pm << endl, cin >> pm;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const int maxn = 2e5 + 5;
const long long mod = 998244353;
inline long long read() {
long long ans = 0;
char ch = getchar(), last = ' ';
while (!isdigit(ch)) last = ch, ch = getchar();
while (isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
if (last == '-') ans = -ans;
return ans;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void MYFILE() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
int n, du[maxn];
long long ans = 1;
int main() {
n = read();
for (int i = 1; i < n; ++i) {
int x = read(), y = read();
++du[x], ++du[y];
ans = ans * du[x] % mod * du[y] % mod;
}
write(ans * n % mod), puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> adj[100050];
bool side[100050];
int i1, i2, sz1, sz2;
vector<int> vset[2];
int visited[100050] = {0}, visid = 0;
int visited2[100050] = {0}, visid2 = 0;
int dep[100050];
void dfs(int v, bool c) {
visited[v] = visid;
vset[c].push_back(v);
side[v] = c;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (visited[u] == visid) continue;
dfs(u, !c);
}
}
inline void pre() {
++visid;
for (int i = 1; i <= n; i++)
if (visited[i] != visid) dfs(i, 0);
}
inline void output_no() { puts("NO"); }
inline void output_yes() {
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", dep[i]);
puts("");
}
inline void solve() {
pre();
if (vset[0].size() % 3 == 0) {
int c = 0;
for (int i = 0; i < vset[0].size(); i++) dep[vset[0][i]] = (c++) / 3 + 1;
for (int i = 0; i < vset[1].size(); i++) dep[vset[1][i]] = (c++) / 3 + 1;
output_yes();
return;
} else {
if (vset[0].size() % 3 == 1) {
i1 = 0;
i2 = 1;
} else {
i1 = 1;
i2 = 0;
}
sz1 = vset[i1].size();
sz2 = vset[i2].size();
for (int i = 0; i < sz1; i++) {
int v = vset[i1][i];
if ((int)adj[v].size() <= sz2 - 2) {
int j, u, w;
++visid;
for (j = 0; j < adj[v].size(); j++) visited[adj[v][j]] = visid;
for (j = 0; j < sz2; j++)
if (visited[vset[i2][j]] < visid) break;
u = vset[i2][j];
for (j = j + 1; j < sz2; j++)
if (visited[vset[i2][j]] < visid) break;
w = vset[i2][j];
dep[v] = dep[u] = dep[w] = n / 3;
int c = 0;
for (int j = 0; j < vset[i1].size(); j++) {
int x = vset[i1][j];
if (x == v || x == u || x == w) continue;
dep[x] = (c++) / 3 + 1;
}
for (int j = 0; j < vset[i2].size(); j++) {
int x = vset[i2][j];
if (x == v || x == u || x == w) continue;
dep[x] = (c++) / 3 + 1;
}
output_yes();
return;
}
}
int vplus[2], cnt2plus = 0;
for (int i = 0; i < sz2; i++) {
int v = vset[i2][i];
if ((int)adj[v].size() <= sz1 - 2) {
vplus[cnt2plus++] = v;
}
if (cnt2plus >= 2) break;
}
if (cnt2plus >= 2) {
++visid;
int c = 0;
for (int t = 0; t < 2; t++) {
int v = vplus[t];
++visid2;
for (int i = 0; i < adj[v].size(); i++) visited2[adj[v][i]] = visid2;
int j, u, w;
for (j = 0; j < sz1; j++)
if (visited2[vset[i1][j]] < visid2) break;
u = vset[i1][j];
for (j = j + 1; j < sz1; j++)
if (visited2[vset[i1][j]] < visid2) break;
w = vset[i1][j];
dep[v] = dep[u] = dep[w] = c / 3 + 1;
visited[v] = visited[u] = visited[w] = visid;
c += 3;
}
for (int j = 0; j < vset[i1].size(); j++) {
int x = vset[i1][j];
if (visited[x] == visid) continue;
dep[x] = (c++) / 3 + 1;
}
for (int j = 0; j < vset[i2].size(); j++) {
int x = vset[i2][j];
if (visited[x] == visid) continue;
dep[x] = (c++) / 3 + 1;
}
output_yes();
return;
}
output_no();
}
}
int main(void) {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int v, u;
scanf("%d %d", &v, &u);
adj[v].push_back(u);
adj[u].push_back(v);
}
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int b, p, f, h, c;
cin >> b >> p >> f;
cin >> h >> c;
long long int final = 0;
b /= 2;
if (h > c) {
if (b > p) {
b = b - p;
final = final + (p * h);
if (b > f) {
b = b - f;
final = final + (c * f);
} else {
final = final + (b * c);
}
} else {
final = (b * h);
}
cout << final << endl;
} else {
if (b > f) {
b = b - f;
final = final + (f * c);
if (b > p) {
b = b - p;
final = final + (p * h);
} else {
final = final + (b * h);
}
} else {
final = b * c;
}
cout << final << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int aa[23], bb[23];
int a[23], b[23];
map<int, int> val_to_index;
set<int> values;
long long subset_sums[1 << 23];
long long current_subset_sums[1 << 23];
bool bf(int pos) {
if (pos == n) return true;
set<int> now_values = values;
for (int i = 0; i < (1 << pos); i++) {
if (pos == n - 1 && i == ((1 << pos) - 1)) continue;
long long forbid = subset_sums[i + (1 << pos)] - current_subset_sums[i];
if (forbid < 1e9 + 5) now_values.erase(forbid);
}
for (int val : now_values) {
for (int i = 0; i < (1 << pos); i++) {
current_subset_sums[i + (1 << pos)] = current_subset_sums[i] + val;
}
b[pos] = val;
if (bf(pos + 1)) return true;
}
return false;
}
int main() {
srand(1573811);
scanf("%d", &n);
for (int i = 0; i < (n); i++) {
scanf("%d", aa + i);
}
vector<int> perm;
for (int i = 0; i < (n); i++) perm.push_back(i);
set<int> done;
for (int i = 0; i < (n); i++) {
int mini = 1e9 + 5;
int min_index = -1;
for (int j = 0; j < (n); j++) {
if (done.count(j)) continue;
if (aa[j] < mini) {
mini = aa[j];
min_index = j;
}
}
done.insert(min_index);
perm[i] = min_index;
}
for (int i = 0; i < (n); i++) {
a[i] = aa[perm[i]];
}
for (int i = 0; i < (n); i++) {
val_to_index[a[i]] = i;
values.insert(a[i]);
}
for (int i = 0; i < (1 << n); i++) {
if (i == 0) continue;
for (int j = 0; j < (n); j++)
if ((1 << j) & i) {
subset_sums[i] = subset_sums[i - (1 << j)] + a[j];
break;
}
}
if (bf(0)) {
for (int i = 0; i < (n); i++) {
bb[perm[i]] = b[i];
}
for (int i = 0; i < (n); i++) {
if (i) printf(" ");
printf("%d", bb[i]);
}
printf("\n");
} else {
printf("-1\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[1000001], cnt[1000001];
vector<int> crr;
int ans[25][25];
int cnt1[1000001], cnt2[1000001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, a, b;
cin >> n;
for (int i = 0; i < n * n; i++) {
cin >> arr[i];
cnt[arr[i]]++;
cnt1[arr[i]]++;
cnt2[arr[i]]++;
}
int freq4 = 0, freq2 = 0, freq1 = 0;
for (int i = 1; i <= 1000; ++i) {
if (cnt[i] != 0) {
freq4 += (cnt[i] / 4);
cnt[i] = (cnt[i] % 4);
freq2 += (cnt[i] / 2);
cnt[i] = (cnt[i] % 2);
freq1 += (cnt[i] / 1);
cnt[i] = (cnt[i] / 1);
}
}
int nfreq4 = 0, nfreq2 = 0, nfreq1 = 0;
if (n % 2 == 0) {
nfreq4 = (n / 2);
nfreq4 *= (n / 2);
} else {
nfreq4 = (n / 2);
nfreq4 *= (n / 2);
nfreq2 = (n - 1);
nfreq1 = 1;
}
if (n % 2 == 0) {
if (nfreq4 != freq4) {
cout << "NO" << endl;
return 0;
} else {
cout << "YES" << endl;
for (int i = 1; i < 10001; ++i) {
while (cnt1[i] % 4 == 0 && cnt1[i] > 0) {
crr.push_back(i);
cnt1[i] -= 4;
}
}
int u = 0;
for (int i = 1; i <= n / 2; ++i) {
for (int j = 1; j <= n / 2; ++j) {
ans[i][j] = crr[u];
ans[n + 1 - i][j] = crr[u];
ans[n + 1 - i][n + 1 - j] = crr[u];
ans[i][n + 1 - j] = crr[u];
u++;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
cout << ans[j][i] << " ";
}
cout << endl;
}
return 0;
}
} else {
if (nfreq4 > freq4) {
cout << "NO" << endl;
return 0;
}
freq2 += 2 * (freq4 - nfreq4);
if (nfreq2 > freq2) {
cout << "NO" << endl;
return 0;
}
freq1 += 2 * (nfreq2 - freq2);
if (nfreq1 > freq1) {
cout << "NO" << endl;
return 0;
}
vector<int> crr4;
vector<int> crr2;
vector<int> crr1;
cout << "YES" << endl;
for (int i = 1; i < 10001; ++i) {
int bm = cnt2[i] / 4;
int er = 0;
while (bm && nfreq4 > 0) {
er += 4;
crr4.push_back(i);
bm--;
nfreq4--;
}
cnt2[i] -= er;
}
for (int i = 1; i < 10001; ++i) {
int bm = cnt2[i] / 2;
int er = 0;
while (bm && nfreq2 > 0) {
er += 2;
crr2.push_back(i);
bm--;
nfreq2--;
}
cnt2[i] -= er;
}
for (int i = 1; i < 10001; ++i) {
if (cnt2[i] == 1) crr1.push_back(i);
}
int p = 0;
for (int i = 1; i <= n / 2; ++i) {
for (int j = 1; j <= n / 2; ++j) {
ans[i][j] = crr4[p];
ans[n + 1 - i][j] = crr4[p];
ans[n + 1 - i][n + 1 - j] = crr4[p];
ans[i][n + 1 - j] = crr4[p];
p++;
}
}
p = 0;
for (int i = 1; i <= n / 2; ++i) {
ans[(n / 2) + 1][i] = crr2[p];
ans[(n / 2) + 1][n + 1 - i] = crr2[p];
p++;
}
for (int i = 1; i <= n / 2; ++i) {
ans[i][(n / 2) + 1] = crr2[p];
ans[n + 1 - i][(n / 2) + 1] = crr2[p];
p++;
}
ans[(n / 2) + 1][(n / 2) + 1] = crr1[0];
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
cout << ans[j][i] << " ";
}
cout << endl;
}
return 0;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long num[300010];
long long sum[300010];
int n;
bool cmp(int a, int b) { return a > b; }
int main() {
while (~scanf("%d", &n)) {
for (int i = 0; i < n; i++) cin >> num[i];
sort(num, num + n, cmp);
sum[0] = num[0];
for (int i = 1; i < n; i++) {
sum[i] = sum[i - 1] + num[i];
}
long long ans = sum[n - 1];
for (int i = n - 2; i >= 0; i--) ans += sum[i] + num[n - 1 - i];
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void PV(T x) {
for (__typeof__((x).begin()) i = (x).begin(); i != (x).end(); ++i)
cout << *i << " ";
cout << endl;
}
int main(int argc, char *argv[]) {
int N, M;
cin >> N >> M;
vector<int> a(M, 0), b(M, 0);
for (int n_ = (N), i = 0; i < n_; ++i) {
int v;
cin >> v;
a[v]++;
}
for (int n_ = (N), i = 0; i < n_; ++i) {
int v;
cin >> v;
b[v]++;
}
queue<int> q;
stack<int> s;
vector<int> r;
for (int n_ = (M), i = 0; i < n_; ++i) {
while (a[i]--) s.push(i);
while (b[M - i - 1]--) {
if (s.size()) {
r.push_back(s.top() + M - i - 1);
s.pop();
} else {
q.push(M - i - 1);
}
}
}
for (; s.size(); s.pop(), q.pop()) r.push_back(s.top() + q.front() - M);
sort((r).begin(), (r).end());
reverse((r).begin(), (r).end());
PV(r);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, M = 1e6;
int q;
long long ans;
int a[N], b[N];
long long s[N << 2], w[N << 2];
char ins[5];
inline void upd(int now) {
s[now] = s[now << 1] + s[now << 1 | 1];
w[now] = max(w[now << 1] + s[now << 1 | 1], w[now << 1 | 1]);
}
inline void build(int now, int l, int r) {
if (l == r) {
w[now] = l;
return;
}
int mid = (l + r) >> 1;
build(now << 1, l, mid);
build(now << 1 | 1, mid + 1, r);
upd(now);
}
inline void add(int now, int l, int r, int x, int z) {
if (l == r) {
w[now] += z;
s[now] += z;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
add(now << 1, l, mid, x, z);
else
add(now << 1 | 1, mid + 1, r, x, z);
upd(now);
}
inline long long find(int now, int l, int r, int x) {
if (r <= x) {
ans = max(s[now] + ans, w[now]);
return ans;
}
int mid = (l + r) >> 1;
find(now << 1, l, mid, x);
if (x > mid) find(now << 1 | 1, mid + 1, r, x);
return ans;
}
int main() {
scanf("%d", &q);
build(1, 1, M);
for (int i = 1; i <= q; i++) {
scanf("%s%d", ins, &a[i]);
if (ins[0] == '+') {
scanf("%d", &b[i]);
add(1, 1, M, a[i], b[i]);
} else if (ins[0] == '?')
ans = 0, printf("%lld\n", find(1, 1, M, a[i]) - (long long)a[i]);
else
add(1, 1, M, a[a[i]], -b[a[i]]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dp[105][105][30][2];
int n, m;
vector<int> g[105];
int val[105][105];
int dfs(int x, int y, int las, int turn) {
if (dp[x][y][las][turn] != -1) return dp[x][y][las][turn];
int sum = 0;
if (turn == 0) {
for (int i = 0; i < g[x].size(); i++) {
int to = g[x][i];
if (val[x][to] >= las) sum += !dfs(to, y, val[x][to], 1);
}
} else {
for (int i = 0; i < g[y].size(); i++) {
int to = g[y][i];
if (val[y][to] >= las) sum += !dfs(x, to, val[y][to], 0);
}
}
return dp[x][y][las][turn] = sum ? 1 : 0;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
char dd;
scanf("%d %d %c", &a, &b, &dd);
getchar();
g[a].push_back(b);
val[a][b] = dd - 'b' + 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (dfs(i, j, 0, 0) == 1)
printf("A");
else
printf("B");
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void dynamic() {
int n;
cin >> n;
vector<vector<int> > v;
v.resize(n);
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = 1; j * j <= a[i]; j++) {
if (a[i] % j == 0) {
v[i].push_back(j);
if (j != a[i] / j) v[i].push_back(a[i] / j);
}
}
}
long long int ans = 0;
long long int dp[n + 1];
long long int last[n + 1];
memset(dp, 0, sizeof(dp));
memset(last, 0, sizeof(last));
last[0] = 1;
dp[0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < v[i].size(); j++) {
if (v[i][j] <= n) {
ans += dp[v[i][j] - 1] % 1000000007;
ans %= 1000000007;
}
}
for (auto it : v[i]) {
if (it <= n) {
last[it - 1] = dp[it - 1];
last[it] = dp[it];
}
}
for (auto it : v[i]) {
if (it <= n) {
dp[it] += last[it - 1];
dp[it] %= 1000000007;
}
}
}
ans = 0;
for (int i = 1; i <= n; i++) {
ans += dp[i];
ans %= 1000000007;
}
cout << ans % 1000000007 << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
dynamic();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int t, n, i;
cin >> t;
while (t--) {
cin >> n;
int a[n];
map<int, int> m;
for (i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
sort(a, a + n);
int ans = 0;
if (n == 1)
ans = 0;
else {
int min = INT_MIN, k;
for (auto itr = m.begin(); itr != m.end(); itr++) {
if (min < itr->second) {
min = itr->second;
k = itr->first;
}
}
if (min == 1) {
ans = 1;
} else if ((min - 1) == m.size()) {
ans = min - 1;
} else if ((min) == m.size()) {
ans = min - 1;
} else if (min < (m.size())) {
ans = min;
} else if (min > (m.size())) {
ans = m.size();
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, i, j, a[2000011], *s = a;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) a[i] = i;
for (i = 2; i <= n; i++) {
s++;
if (n % i) s[n] = s[n - n % i];
for (j = n - n % i; j > 0; j -= i) s[j] = s[j - i];
}
for (i = 1; i <= n; i++) printf("%d ", s[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, n, c;
long long tri(long long n) { return n * (n + 1) / 2; }
long long make(long long s) {
long long ans = 1;
if (s == 0) return ans;
if (x - s > 0)
ans = ans + s;
else
ans = ans + x - 1;
if (x + s <= n)
ans = ans + s;
else
ans = ans + n - x;
if (y - s > 0)
ans = ans + s;
else
ans = ans + y - 1;
if (y + s <= n)
ans = ans + s;
else
ans = ans + n - y;
if (s == 1) return ans;
long long xx, yy, ss;
xx = x - 1;
yy = y - 1;
ss = s - 1;
if (xx - ss + 1 > 0 && yy - ss + 1 > 0) {
ans = ans + tri(ss);
}
if (xx - ss + 1 <= 0 && yy - ss + 1 > 0) {
ans = ans + tri(ss) - tri(ss - xx);
}
if (xx - ss + 1 > 0 && yy - ss + 1 <= 0) {
ans = ans + tri(ss) - tri(ss - yy);
}
if (xx - ss + 1 < 0 && yy - ss + 1 <= 0) {
if (ss >= xx + yy - 1)
ans = ans + xx * yy;
else
ans = ans + tri(ss) - tri(ss - xx) - tri(ss - yy);
}
xx = x + 1;
yy = y - 1;
if (xx + ss - 1 <= n && yy - ss + 1 > 0) {
ans = ans + tri(ss);
}
if (xx + ss - 1 > n && yy - ss + 1 > 0) {
ans = ans + tri(ss) - tri(xx + ss - 1 - n);
}
if (xx + ss - 1 <= n && yy - ss + 1 <= 0) {
ans = ans + tri(ss) - tri(ss - yy);
}
if (xx + ss - 1 > n && yy - ss + 1 <= 0) {
if (ss >= n - xx + yy)
ans = ans + (n - xx + 1) * yy;
else
ans = ans + tri(ss) - tri(xx + ss - 1 - n) - tri(ss - yy);
}
xx = x - 1;
yy = y + 1;
if (xx - ss + 1 > 0 && yy + ss - 1 <= n) ans = ans + tri(ss);
if (xx - ss + 1 > 0 && yy + ss - 1 > n)
ans = ans + tri(ss) - tri(yy + ss - 1 - n);
if (xx - ss + 1 <= 0 && yy + ss - 1 <= n) ans = ans + tri(ss) - tri(ss - xx);
if (xx - ss + 1 <= 0 && yy + ss - 1 > n) {
if (ss >= n - yy + xx)
ans = ans + xx * (n - yy + 1);
else
ans = ans + tri(ss) - tri(yy + ss - 1 - n) - tri(ss - xx);
}
xx = x + 1;
yy = y + 1;
if (xx + ss - 1 <= n && yy + ss - 1 <= n) ans = ans + tri(ss);
if (xx + ss - 1 > n && yy + ss - 1 <= n)
ans = ans + tri(ss) - tri(xx + ss - 1 - n);
if (xx + ss - 1 <= n && yy + ss - 1 > n)
ans = ans + tri(ss) - tri(yy + ss - 1 - n);
if (xx + ss - 1 > n && yy + ss - 1 > n) {
if (ss >= 2 * n - xx - yy + 1)
ans = ans + (n - xx + 1) * (n - yy + 1);
else
ans = ans + tri(ss) - tri(xx + ss - 1 - n) - tri(yy + ss - 1 - n);
}
return ans;
}
int main() {
scanf("%lld%lld%lld%lld", &n, &x, &y, &c);
long long l, r;
l = 0;
r = n * 3;
while (l < r) {
long long mid = (l + r) / 2;
long long temp = make(mid);
if (temp >= c)
r = mid;
else
l = mid + 1;
}
printf("%lld\n", l);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 150;
char Map[maxn][maxn];
char vis[maxn][maxn];
int dir[8][2] = {{0, 1}, {1, 0}, {1, 1}, {-1, 0},
{0, -1}, {-1, -1}, {-1, 1}, {1, -1}};
int main() {
int n, m, cnt = 0;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", Map[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (Map[i][j] == '*') {
vis[i][j] = '*';
} else
vis[i][j] = '0';
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (vis[i][j] == '*') {
for (int h = 0; h < 8; h++) {
if (i + dir[h][0] < 0 || i + dir[h][0] >= n || j + dir[h][1] < 0 ||
j + dir[h][1] >= m || vis[i + dir[h][0]][j + dir[h][1]] == '*')
continue;
vis[i + dir[h][0]][j + dir[h][1]]++;
}
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (vis[i][j] == '0') {
vis[i][j] = '.';
}
int flag = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (Map[i][j] != vis[i][j]) {
flag = 0;
break;
}
if (flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
const long long maxn = 2e5 + 9, mod = 998244353, inf = 1e9;
long long Read() {
long long x(0), f(1);
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3ll) + (x << 1ll) + c - '0';
c = getchar();
}
return x * f;
}
void Chkmin(long long &x, long long y) {
if (y < x) x = y;
}
void Chkmax(long long &x, long long y) {
if (y > x) x = y;
}
long long add(long long x, long long y) {
return x += y, x >= mod ? x - mod : x;
}
long long dec(long long x, long long y) { return x -= y, x < 0 ? x + mod : x; }
long long mul(long long x, long long y) { return 1ll * x * y % mod; }
long long Pow(long long base, long long b) {
long long ret(1);
while (b) {
if (b & 1) ret = mul(ret, base);
base = mul(base, base);
b >>= 1;
}
return ret;
}
struct Sgtbeats {
struct node {
long long mx, smx, mi, smi, mxnum, minum, sum, tag, num, val;
} a[maxn << 2];
void Build(long long nw, long long l, long long r) {
a[nw] = (node){0, -inf, 0, inf, 0, 0, 0, 0, 0, 0};
if (l == r) return;
long long mid(l + r >> 1);
Build(nw << 1, l, mid);
Build(nw << 1 | 1, mid + 1, r);
}
void Push1(long long nw, long long x) {
a[nw].sum += (x - a[nw].mx) * a[nw].mxnum;
if (a[nw].smi == a[nw].mx) a[nw].smi = x;
if (a[nw].mi == a[nw].mx) a[nw].mi = x;
a[nw].mx = x;
}
void Push2(long long nw, long long x) {
a[nw].sum += (x - a[nw].mi) * a[nw].minum;
if (a[nw].smx == a[nw].mi) a[nw].smx = x;
if (a[nw].mx == a[nw].mi) a[nw].mx = x;
a[nw].mi = x;
}
void Update(long long nw) {
long long lt(nw << 1), rt(nw << 1 | 1), tag(a[nw].tag), num(a[nw].num);
a[nw] = a[rt];
a[nw].tag = tag;
if (a[lt].mx > a[nw].mx)
a[nw].mx = a[lt].mx, a[nw].mxnum = a[lt].mxnum,
a[nw].smx = std::max(a[lt].smx, a[rt].mx);
else if (a[lt].mx == a[nw].mx)
a[nw].mxnum += a[lt].mxnum, Chkmax(a[nw].smx, a[lt].smx);
else
Chkmax(a[nw].smx, a[lt].mx);
if (a[lt].mi < a[nw].mi)
a[nw].mi = a[lt].mi, a[nw].minum = a[lt].minum,
a[nw].smi = std::min(a[lt].smi, a[rt].mi);
else if (a[lt].mi == a[nw].mi)
a[nw].minum += a[lt].minum, Chkmin(a[nw].smi, a[lt].smi);
else
Chkmin(a[nw].smi, a[lt].mi);
a[nw].sum += a[lt].sum;
a[nw].num += a[lt].num;
}
void Pushdown(long long nw) {
long long lt(nw << 1), rt(nw << 1 | 1);
long long x;
if (x = a[nw].tag) {
if (a[lt].num) {
a[lt].tag += x;
a[lt].mx += x;
a[lt].mi += x;
a[lt].sum += x * a[lt].num;
if (a[lt].smx != -inf) a[lt].smx += x;
if (a[lt].smi != inf) a[lt].smi += x;
}
if (a[rt].num) {
a[rt].tag += x;
a[rt].mx += x;
a[rt].mi += x;
a[rt].sum += x * a[rt].num;
if (a[rt].smx != -inf) a[rt].smx += x;
if (a[rt].smi != inf) a[rt].smi += x;
}
a[nw].tag = 0;
}
if (a[lt].num) {
if (a[nw].mx < a[lt].mx) Push1(lt, a[nw].mx);
if (a[nw].mi > a[lt].mi) Push2(lt, a[nw].mi);
}
if (a[rt].num) {
if (a[nw].mx < a[rt].mx) Push1(rt, a[nw].mx);
if (a[nw].mi > a[rt].mi) Push2(rt, a[nw].mi);
}
}
void Modify(long long nw, long long l, long long r, long long x,
long long v) {
if (l == r) {
a[nw].val = 1;
a[nw].num = 1;
a[nw].sum = v;
a[nw].mi = v;
a[nw].mx = v;
a[nw].mxnum = a[nw].minum = 1;
return;
}
Pushdown(nw);
long long mid(l + r >> 1);
if (x <= mid)
Modify(nw << 1, l, mid, x, v);
else
Modify(nw << 1 | 1, mid + 1, r, x, v);
Update(nw);
}
void Modifyadd(long long nw, long long l, long long r, long long lt,
long long rt, long long x) {
if (!a[nw].num) return;
if (lt <= l && rt >= r) {
a[nw].tag += x;
a[nw].mx += x;
a[nw].mi += x;
a[nw].sum += x * a[nw].num;
if (a[nw].smi != inf) a[nw].smi += x;
if (a[nw].smx != -inf) a[nw].smx += x;
return;
}
Pushdown(nw);
long long mid(l + r >> 1);
if (lt <= mid) Modifyadd(nw << 1, l, mid, lt, rt, x);
if (rt > mid) Modifyadd(nw << 1 | 1, mid + 1, r, lt, rt, x);
Update(nw);
}
void Modifymax(long long nw, long long l, long long r, long long lt,
long long rt, long long x) {
if (!a[nw].num) return;
if (lt <= l && rt >= r) {
if (a[nw].mi >= x) return;
if (a[nw].smi > x) {
a[nw].sum += (x - a[nw].mi) * a[nw].minum;
if (a[nw].smx == a[nw].mi) a[nw].smx = x;
if (a[nw].mx == a[nw].mi) a[nw].mx = x;
a[nw].mi = x;
return;
}
}
Pushdown(nw);
long long mid(l + r >> 1);
if (lt <= mid) Modifymax(nw << 1, l, mid, lt, rt, x);
if (rt > mid) Modifymax(nw << 1 | 1, mid + 1, r, lt, rt, x);
Update(nw);
}
void Modifymin(long long nw, long long l, long long r, long long lt,
long long rt, long long x) {
if (!a[nw].num) return;
if (lt <= l && rt >= r) {
if (a[nw].mx <= x) return;
if (a[nw].smx < x) {
a[nw].sum += (x - a[nw].mx) * a[nw].mxnum;
if (a[nw].smi == a[nw].mx) a[nw].smi = x;
if (a[nw].mi == a[nw].mx) a[nw].mi = x;
a[nw].mx = x;
return;
}
}
Pushdown(nw);
long long mid(l + r >> 1);
if (lt <= mid) Modifymin(nw << 1, l, mid, lt, rt, x);
if (rt > mid) Modifymin(nw << 1 | 1, mid + 1, r, lt, rt, x);
Update(nw);
}
} T;
long long n;
long long sum[maxn], a[maxn], ans[maxn], pos[maxn];
namespace Bit {
long long tr[maxn];
long long Lowbit(long long x) { return x & (-x); }
void Init() {
for (long long i = 1; i <= n; ++i) tr[i] = 0;
}
void Modify(long long x) {
for (; x <= n; x += Lowbit(x)) tr[x]++;
}
long long Query(long long x) {
long long ret(0);
for (; x; x -= Lowbit(x)) ret += tr[x];
return ret;
}
} // namespace Bit
int main() {
n = Read();
for (long long i = 1; i <= n; ++i) a[i] = Read(), pos[a[i]] = i;
T.Build(1, 1, n);
Bit::Init();
for (long long i = 1; i <= n; ++i) {
long long x(pos[i]);
T.Modify(1, 1, n, x, 1);
if (x < n) T.Modifyadd(1, 1, n, x + 1, n, 1);
long long q(Bit::Query(x) + 1);
if (x < n) T.Modifymax(1, 1, n, x + 1, n, q + 1);
ans[i] -= T.a[1].sum;
Bit::Modify(x);
}
T.Build(1, 1, n);
Bit::Init();
for (long long i = 1; i <= n; ++i) {
long long x(pos[i]);
T.Modify(1, 1, n, x, i);
long long q(Bit::Query(x) + 1);
if (x != 1) T.Modifymin(1, 1, n, 1, x - 1, q - 1);
if (x < n) T.Modifyadd(1, 1, n, x + 1, n, 1);
ans[i] += T.a[1].sum;
Bit::Modify(x);
}
for (long long i = 1; i <= n; ++i) ans[i] += i;
for (long long i = 1; i <= n; ++i) printf("%lld\n", ans[i]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c h, n;
};
template <class c>
rge<c> range(c h, c n) {
return rge<c>{h, n};
}
template <class c>
auto dud(c *r) -> decltype(cerr << *r);
template <class c>
char dud(...);
struct muu {
template <class c>
muu &operator<<(const c &) {
return *this;
}
};
const int MN = 1e3 + 44;
pair<int, int> coo[MN];
int col[MN];
int n;
int det(int a, int b, int c) {
return (coo[a].first - coo[b].first) * (coo[a].second - coo[c].second) -
(coo[a].second - coo[b].second) * (coo[a].first - coo[c].first);
}
bool inside(int a, int b, int c, int i) {
return abs(det(a, b, i)) + abs(det(b, c, i)) + abs(det(c, a, i)) ==
abs(det(a, b, c));
}
vector<pair<int, int> > ans;
void go(int a, int b, int c) {
vector<int> points;
for (int i = 0; i < n; ++i)
if (i != a && i != b && i != c && inside(a, b, c, i)) points.push_back(i);
muu() << __FUNCTION__ << "#" << 62 << ": "
<< "["
"coo"
"["
"a"
": "
<< (a)
<< "] "
": "
<< coo[a]
<< "] "
"["
"coo"
"["
"b"
": "
<< (b)
<< "] "
": "
<< coo[b]
<< "] "
"["
"coo"
"["
"c"
": "
<< (c)
<< "] "
": "
<< coo[c]
<< "] "
"["
"points"
": "
<< (points) << "] ";
int more = (col[a] + col[b] + col[c]) >= 2;
int oth = col[a] != more ? a : (col[b] != more ? b : c);
assert(col[oth] != more);
for (int x : points) {
if (col[x] != more) {
muu() << __FUNCTION__ << "#" << 70 << ": "
<< "["
"col"
"["
"x"
": "
<< (x)
<< "] "
": "
<< col[x]
<< "] "
"["
"col"
"["
"oth"
": "
<< (oth)
<< "] "
": "
<< col[oth]
<< "] "
"["
"more"
": "
<< (more) << "] ";
ans.emplace_back(x, oth);
go(a, b, x);
go(b, c, x);
go(c, a, x);
return;
}
}
int m = col[a] == more ? a : b;
for (int x : points) {
muu() << __FUNCTION__ << "#" << 81 << ": "
<< "["
"col"
"["
"m"
": "
<< (m)
<< "] "
": "
<< col[m]
<< "] "
"["
"col"
"["
"x"
": "
<< (x)
<< "] "
": "
<< col[x] << "] ";
ans.emplace_back(m, x);
}
}
int main() {
scanf("%d", &n);
if (n == 1) {
printf("0\n");
return 0;
}
for (int i = 0; i < n; ++i)
scanf("%d%d%d", &coo[i].first, &coo[i].second, col + i);
vector<int> order;
for (int i = 0; i < n; ++i) order.push_back(i);
sort(order.begin(), order.end(),
[](int i, int j) { return coo[i] < coo[j]; });
vector<int> up, down;
for (int i : order) {
while (up.size() >= 2u && det(up.back(), up[up.size() - 2], i) >= 0)
up.pop_back();
while (down.size() >= 2u && det(down.back(), down[down.size() - 2], i) <= 0)
down.pop_back();
up.push_back(i);
down.push_back(i);
}
reverse(down.begin(), down.end());
up.pop_back();
down.pop_back();
vector<int> hull = up;
for (int y : down) hull.push_back(y);
muu() << __FUNCTION__ << "#" << 123 << ": "
<< "["
"hull"
": "
<< (hull) << "] ";
vector<int> last_one, last_zero;
int H = hull.size();
for (int i = 0; i < H; ++i) {
int c1 = col[hull[i]];
int c2 = col[hull[(i + 1) % H]];
if (c1 == 0 && c2 == 1)
last_zero.push_back(i);
else if (c1 == 1 && c2 == 0)
last_one.push_back(i);
}
muu() << __FUNCTION__ << "#" << 134 << ": "
<< "["
"last_one"
": "
<< (last_one)
<< "] "
"["
"last_zero"
": "
<< (last_zero) << "] ";
if (last_one.size() >= 2u) {
printf("Impossible\n");
return 0;
}
if (last_one.size() == 1) {
for (int i = 0; i < H; ++i)
if (col[hull[i]] == col[hull[(i + 1) % H]])
go(hull[col[hull[i]] == 0 ? last_one[0] : last_zero[0]], hull[i],
hull[(i + 1) % H]);
for (int i = 0; i < H; ++i)
if (col[hull[i]] == col[hull[(i + 1) % H]]) {
muu() << __FUNCTION__ << "#" << 147 << ": "
<< "["
"hull"
"["
"i"
": "
<< (i)
<< "] "
": "
<< hull[i]
<< "] "
"["
"hull"
"["
"(i + 1) % H"
": "
<< ((i + 1) % H)
<< "] "
": "
<< hull[(i + 1) % H] << "] ";
ans.emplace_back(hull[i], hull[(i + 1) % H]);
}
} else {
int oth = -1;
for (int i = 0; i < n; ++i)
if (col[i] != col[hull[0]]) oth = i;
if (oth == -1)
for (int i = 1; i < n; ++i) ans.emplace_back(0, i);
else {
for (int i = 0; i < H; ++i) {
muu() << __FUNCTION__ << "#" << 159 << ": "
<< "["
"oth"
": "
<< (oth)
<< "] "
"["
"hull"
"["
"i"
": "
<< (i)
<< "] "
": "
<< hull[i]
<< "] "
"["
"hull"
"["
"(i + 1) % H"
": "
<< ((i + 1) % H)
<< "] "
": "
<< hull[(i + 1) % H] << "] ";
go(hull[i], hull[(i + 1) % H], oth);
}
for (int i = 0; i < H - 1; ++i) {
ans.emplace_back(hull[i], hull[i + 1]);
muu() << __FUNCTION__ << "#" << 165 << ": "
<< "["
"ans"
": "
<< (ans) << "] ";
}
}
}
printf("%d\n", (int)ans.size());
for (auto x : ans) {
printf("%d %d\n", x.first, x.second);
assert(col[x.first] == col[x.second]);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x0, y0, x1, y1, x2, y2;
cin >> x0 >> y0 >> x1 >> y1 >> x2 >> y2;
long long v0x = x1 - x0, v0y = y1 - y0;
long long v1x = x2 - x0, v1y = y2 - y0;
long long a = v0x * v1y - v0y * v1x;
if (a == 0)
cout << "TOWARDS" << endl;
else if (a < 0)
cout << "RIGHT" << endl;
else if (a > 0)
cout << "LEFT" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1500000000;
const int MOD = 1000000009;
const int HASH = 137;
const int NUM = 100005;
long long N;
map<long long, map<long long, pair<long long, long long>>> points;
set<pair<long long, pair<long long, long long>>> S;
vector<bool> used;
pair<long long, long long> theone(long long y, long long x) {
long long value[3] = {(points[y - 1].find(x - 1) != points[y - 1].end() &&
!used[points[y - 1][x - 1].first]),
(points[y - 1].find(x) != points[y - 1].end() &&
!used[points[y - 1][x].first]) *
2,
(points[y - 1].find(x + 1) != points[y - 1].end() &&
!used[points[y - 1][x + 1].first]) *
4};
long long index[3] = {-1, 0, 1};
if (__builtin_popcount(value[0] + value[1] + value[2]) == 1)
return make_pair(
y - 1, x + index[__builtin_ffs(value[0] + value[1] + value[2]) - 1]);
return make_pair(-1, -1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (long long i = 0; i < N; i++) {
long long x, y;
cin >> x >> y;
points[y][x] = make_pair(i, 0);
}
used.resize(N, false);
for (auto i : points) {
if (i.first == 0) continue;
for (auto j : i.second) {
pair<long long, long long> index = theone(i.first, j.first);
if (index.first != -1) points[index.first][index.second].second++;
}
}
for (auto i : points)
for (auto j : i.second)
if (j.second.second == 0)
S.insert(make_pair(j.second.first, make_pair(i.first, j.first)));
long long ans[N], next = 0;
bool who = false;
while (!S.empty()) {
pair<long long, pair<long long, long long>> now;
if (who) {
now = *S.begin();
S.erase(S.begin());
} else {
now = *(--S.end());
S.erase(--S.end());
}
used[now.first] = true;
pair<long long, long long> index =
theone(now.second.first, now.second.second);
if (index.first != -1 && --points[index.first][index.second].second == 0)
S.insert(make_pair(points[index.first][index.second].first,
make_pair(index.first, index.second)));
for (long long i = -1; i <= 1; i++) {
if (points[now.second.first + 1].find(now.second.second + i) ==
points[now.second.first + 1].end() ||
used[points[now.second.first + 1][now.second.second + i].first])
continue;
index = theone(now.second.first + 1, now.second.second + i);
if (index.first != -1 && points[index.first][index.second].second++ == 0)
S.erase(make_pair(points[index.first][index.second].first,
make_pair(index.first, index.second)));
}
ans[next++] = now.first;
who = !who;
}
long long final_ans = 0;
for (long long i = 0; i < N; i++) {
final_ans = (final_ans * N) % MOD;
final_ans = (final_ans + ans[i]) % MOD;
}
cout << final_ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100100;
const int maxM = maxN << 1;
const int maxB = 17;
int n, Q, Log[maxN];
int edgecnt = -1, Head[maxN], Next[maxM], V[maxM], W[maxM], Dst[maxN];
class Tree {
public:
int root, Dep[maxN], Fa[maxN], Dst[maxN], Mx[maxN], ST[maxB][maxN],
Mxd[maxB][maxN], dfncnt, dfn[maxN], lst[maxN];
int lcnt, Mark[maxN];
pair<int, int> Leaf[maxN];
void dfs_init(int u, int fa) {
Dep[u] = 0;
ST[0][u] = fa;
for (int i = Head[u]; i != -1; i = Next[i])
if (V[i] != fa) {
dfs_init(V[i], u);
if (Dep[V[i]] + W[i] > Dep[u]) Mx[u] = V[i], Dep[u] = Dep[V[i]] + W[i];
}
return;
}
void dfs_push(int u, int fa, int w) {
Dep[u] = Dep[fa] + 1;
dfn[u] = ++dfncnt;
Mxd[0][dfncnt] = Dst[u];
if (Mx[u] == 0)
Leaf[++lcnt] = make_pair(w, u);
else {
Fa[Mx[u]] = u;
for (int i = Head[u]; i != -1; i = Next[i])
if (V[i] != fa)
Dst[V[i]] = Dst[u] + W[i],
dfs_push(V[i], u, (V[i] == Mx[u]) ? w + W[i] : W[i]);
}
lst[u] = dfncnt;
return;
}
void Init(int r) {
root = r;
dfs_init(root, 0);
Dep[root] = 1;
Dst[root] = 0;
dfs_push(root, 0, 0);
for (int i = 1; i < maxB; i++)
for (int j = 1; j <= n; j++) ST[i][j] = ST[i - 1][ST[i - 1][j]];
sort(&Leaf[1], &Leaf[lcnt + 1]);
reverse(&Leaf[1], &Leaf[lcnt + 1]);
for (int i = 1; i <= lcnt; i++) Leaf[i].first += Leaf[i - 1].first;
for (int i = 1; i <= lcnt; i++) {
int now = Leaf[i].second;
while (now) Mark[now] = i, now = Fa[now];
}
for (int i = 1; i < maxB; i++)
for (int j = 1; j + (1 << (i)) - 1 <= n; j++)
Mxd[i][j] = max(Mxd[i - 1][j], Mxd[i - 1][j + (1 << (i - 1))]);
return;
}
int LCA(int u, int v) {
if (Dep[u] < Dep[v]) swap(u, v);
for (int i = maxB - 1; i >= 0; i--)
if (ST[i][u] && Dep[ST[i][u]] >= Dep[v]) u = ST[i][u];
if (u == v) return u;
for (int i = maxB - 1; i >= 0; i--)
if (ST[i][u] && ST[i][v] && ST[i][u] != ST[i][v])
u = ST[i][u], v = ST[i][v];
return ST[0][u];
}
int GET(int u, int cnt) {
cnt = min(cnt * 2 - 1, lcnt);
if (Mark[u] <= cnt) return Leaf[cnt].first;
int ret = Leaf[cnt - 1].first;
int now = u;
for (int i = maxB - 1; i >= 0; i--)
if (ST[i][now] && Mark[ST[i][now]] > cnt) now = ST[i][now];
now = ST[0][now];
int l = dfn[u], r = lst[u], lg = Log[r - l + 1];
int mxd = max(Mxd[lg][l], Mxd[lg][r - (1 << (lg)) + 1]);
ret = ret + mxd - Dst[now];
return max(ret, Leaf[cnt].first + mxd - Dst[Leaf[Mark[now]].second]);
}
};
Tree T1, T2;
void Add_Edge(int u, int v, int w);
void Bfs(int S);
int main() {
for (int i = 2; i < maxN; i++) Log[i] = Log[i >> 1] + 1;
scanf("%d%d", &n, &Q);
memset(Head, -1, sizeof(Head));
for (int i = 1; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
Add_Edge(u, v, w);
Add_Edge(v, u, w);
}
int S, T;
Bfs(1);
S = 1;
for (int i = 1; i <= n; i++)
if (Dst[S] < Dst[i]) S = i;
Bfs(S);
T = 1;
for (int i = 1; i <= n; i++)
if (Dst[T] < Dst[i]) T = i;
T1.Init(S);
T2.Init(T);
int lstans = 0;
while (Q--) {
int x, y;
scanf("%d%d", &x, &y);
x = (x + lstans - 1) % n + 1;
y = (y + lstans - 1) % n + 1;
printf("%d\n", lstans = max(T1.GET(x, y), T2.GET(x, y)));
}
return 0;
}
void Add_Edge(int u, int v, int w) {
Next[++edgecnt] = Head[u];
Head[u] = edgecnt;
V[edgecnt] = v;
W[edgecnt] = w;
return;
}
void Bfs(int S) {
static int vis[maxN], Qu[maxN];
memset(vis, 0, sizeof(vis));
int l = 1, r = 1;
Qu[1] = S;
Dst[S] = 0;
vis[S] = 1;
while (l <= r)
for (int u = Qu[l++], i = Head[u]; i != -1; i = Next[i])
if (vis[V[i]] == 0) Dst[Qu[++r] = V[i]] = Dst[u] + W[i], vis[V[i]] = 1;
return;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[200005];
bool vis[200005];
int level[200005];
int subtr[200005];
int dfs(int u, int l) {
vis[u] = true;
int res = 0;
for (auto i : adj[u]) {
if (!vis[i]) {
res += dfs(i, l + 1);
}
}
level[u] = l;
subtr[u] = res;
return res + 1;
}
vector<long long int> diff;
int main() {
long long int n, t, m;
cin >> n >> m;
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
--x, --y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(0, 0);
vector<int> v;
for (int i = 0; i < n; i++) {
diff.push_back(level[i] - subtr[i]);
}
sort(diff.rbegin(), diff.rend());
long long int sum = 0;
for (int i = 0; i < m; i++) {
sum += diff[i];
}
cout << sum;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, hed[200010], cnt, fa[200010], sz[200010];
const long long mod = 1e9 + 7;
long long dp[100010][210], s[210][210], jie[210], res[100010], ans, f[210];
struct node {
int to, next;
} a[400010];
inline int read() {
int x = 0;
char s = getchar();
while (s > '9' || s < '0') s = getchar();
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x;
}
inline void add(int from, int to) {
a[++cnt].to = to;
a[cnt].next = hed[from];
hed[from] = cnt;
}
inline void dfs(int x) {
sz[x] = 1;
dp[x][0] = 1;
for (int i = hed[x]; i; i = a[i].next) {
int y = a[i].to;
if (y == fa[x]) continue;
fa[y] = x;
dfs(y);
for (int j = 0; j <= k; ++j) f[j] = dp[x][j];
for (int j = 1; j <= min(k, sz[y]); ++j)
dp[x][j] = (dp[x][j] + dp[y][j] + dp[y][j - 1]);
dp[x][0] = (dp[x][0] + dp[y][0]) % mod;
for (int j = 0; j <= min(k, sz[x]); ++j) {
for (int l = 0; l <= min(k - j, sz[y]); ++l) {
dp[x][j + l] = (dp[x][j + l] + f[j] * dp[y][l] % mod) % mod;
res[j + l] = (res[j + l] + f[j] * dp[y][l] % mod) % mod;
dp[x][j + l + 1] = (dp[x][j + l + 1] + f[j] * dp[y][l] % mod) % mod;
res[j + l + 1] = (res[j + l + 1] + f[j] * dp[y][l] % mod) % mod;
}
}
sz[x] += sz[y];
}
}
int main() {
n = read();
k = read();
for (int i = 1; i <= n - 1; ++i) {
int x = read(), y = read();
add(x, y);
add(y, x);
}
jie[0] = 1;
for (int i = 1; i <= k; ++i) jie[i] = jie[i - 1] * i % mod;
s[1][1] = 1;
for (int i = 2; i <= k; ++i) {
for (int j = 1; j <= k; ++j)
s[i][j] = (s[i - 1][j - 1] + s[i - 1][j] * j) % mod;
}
dfs(1);
for (int i = 1; i <= k; ++i)
ans = (ans + jie[i] * s[k][i] % mod * res[i] % mod) % mod;
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
double solve(double x, double n) {
double a = atan(1) * 4 / n;
double h = sqrt(3 * tan(a) * tan(a) - 1) / tan(a);
double s = n / tan(a);
return pow(x / 2, 3) * h * s / 3;
}
int main() {
double ans = 0;
for (int i = 3; i <= 5; i++) {
double x;
scanf("%lf", &x);
ans += solve(x, i);
}
printf("%.10f\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int a[n], count = 0;
double d = 0, temp;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 1; i < n; i++) {
temp = abs(a[i] - a[i - 1]);
if (d < temp) {
d = temp;
}
}
d = (double)d / 2;
d = fmax(d, a[0]);
d = fmax(d, abs(a[n - 1] - l));
cout.precision(10);
cout << fixed;
cout << d << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class FenwickTree {
public:
FenwickTree(int n) : N(n), data(N, 0) {}
void put(int x, long long v) {
for (; x < N; x |= x + 1) {
data[x] += v;
}
}
long long get(int x) {
long long res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += data[x];
}
return res;
}
private:
int N;
vector<long long> data;
};
class Solution {
public:
int solve(vector<int>& nums) {
int n = nums.size();
FenwickTree ftSum(n);
FenwickTree ftCnt(n);
vector<int> ord(n, 0);
iota(ord.begin(), ord.end(), 0);
auto cmp = [&](int l, int r) { return nums[l] < nums[r]; };
sort(ord.begin(), ord.end(), cmp);
long long res = 0;
long long total = 0;
for (int i = 0; i < n; ++i) {
int j = ord[i];
long long leftSum = ftSum.get(j - 1);
long long leftCnt = ftCnt.get(j - 1);
long long rightSum = total - leftSum;
long long rightCnt = i - leftCnt;
long long cnt = 0;
cnt = mulM(j + 1, n - j);
cnt = addM(cnt, mulM(normalize(leftSum + leftCnt), n - j));
cnt = addM(cnt, mulM(j + 1, addM(mulM(rightCnt, n), -rightSum)));
res = addM(res, mulM(cnt, nums[j]));
ftSum.put(j, j);
ftCnt.put(j, 1);
total += j;
}
return res;
}
private:
const static int M = 1000000007;
long long normalize(long long a) {
if (a >= -M && a < (M << 1)) {
if (a >= M) {
a -= M;
}
if (a < 0) {
a += M;
}
return a;
}
a %= M;
if (a < 0) {
a += M;
}
return a;
}
long long addM(long long a, long long b) { return normalize(a + b); }
long long mulM(long long a, long long b) { return normalize(a * b); }
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
Solution sol;
int n;
cin >> n;
vector<int> nums(n);
for (int i = 0; i < n; ++i) {
cin >> nums[i];
}
cout << sol.solve(nums) << "\n";
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.