solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long l[100001], r[100001];
int main() {
long long n, p;
double s = 0;
cin >> n >> p;
for (int i = (0); i <= (n - 1); i++) cin >> l[i] >> r[i];
for (int i = (0); i <= (n - 1); i++) {
int j = i + 1;
if (i == n - 1) j = 0;
long long d1 = r[i] / p - (l[i] - 1) / p;
long long d2 = r[j] / p - (l[j] - 1) / p;
double t1 = d1 / (double)(r[i] - l[i] + 1);
double t2 = d2 / (double)(r[j] - l[j] + 1);
s += t1 + t2 - t1 * t2;
}
cout << setprecision(10) << s * 2000 << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
int arr[200001], seq[200001];
int main() {
int n, t, a, x, index = 1;
double sum = 0;
scanf("%d", &n);
while (n--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &x, &a);
arr[x - 1] += a;
sum += a * x;
} else if (t == 2) {
scanf("%d", &a);
seq[index++] = a;
sum += a;
} else {
index--;
sum -= (arr[index] + seq[index]);
arr[index - 1] += arr[index];
arr[index] = 0;
}
printf("%f\n", (double)sum / index);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n;
while (cin >> n) {
int polices = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
int val;
cin >> val;
if (val - -1)
polices += val;
else {
if (polices == 0)
ans++;
else
polices--;
}
}
cout << ans << endl << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> dp(100005, 0);
vector<long long> cnt(100005, 0);
void run_case() {
for (int i = 0; i < 100005; i++) {
dp[i] = 0;
cnt[i] = 0;
}
cin >> n;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
cnt[x]++;
}
n = 100005;
dp[1] = 1ll * cnt[1];
for (long long i = 2; i < n; i++) {
dp[i] = max(dp[i - 1], dp[i - 2] + 1ll * cnt[i] * i);
}
cout << dp[n - 1] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long tc = 1;
for (long long i = 1; i <= tc; i++) run_case();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000;
static int lt[maxn * 4];
static int h[20][maxn];
long long sqr(long long x) { return x * x; }
struct T {
long long D, R;
int P, M;
friend bool operator<(const T &A, const T &B) { return A.D < B.D; }
} S[maxn];
long long srt[maxn];
static int n, ls, X, Y, P;
int P1[maxn], l1;
long long R1[maxn], R;
bool vis[maxn];
bool cmp(const int &a, const int &b) { return S[a].M < S[b].M; }
void Build(int t, int l, int r, int dp) {
lt[t] = l;
if (l == r) {
h[dp][l] = l;
return;
}
int mid = l + r >> 1;
int l1 = l;
int l2 = mid + 1;
Build(t * 2 + 1, l, mid, dp + 1);
Build(t * 2 + 2, mid + 1, r, dp + 1);
while (l1 <= mid && l2 <= r) {
if (S[h[dp + 1][l1]].M < S[h[dp + 1][l2]].M) {
h[dp][l++] = h[dp + 1][l1++];
} else {
h[dp][l++] = h[dp + 1][l2++];
}
}
while (l1 <= mid) h[dp][l++] = h[dp + 1][l1++];
while (l2 <= r) h[dp][l++] = h[dp + 1][l2++];
}
void Remove(int t, int l, int r, int R, int P, int dp) {
if (l > R || lt[t] > r) return;
if (r <= R) {
while (lt[t] <= r) {
int x = h[dp][lt[t]];
if (S[x].M > P) break;
lt[t]++;
if (!vis[x]) {
l1++;
P1[l1] = S[x].P;
R1[l1] = S[x].R;
}
vis[x] = true;
}
return;
}
int mid = l + r >> 1;
Remove(t * 2 + 1, l, mid, R, P, dp + 1);
Remove(t * 2 + 2, mid + 1, r, R, P, dp + 1);
}
int main() {
scanf("%d%d%d%d%d", &X, &Y, &P, &R, &n);
ls = 0;
R = sqr(R);
for (int i = 1; i <= n; i++) {
int tx, ty;
scanf("%d%d", &tx, &ty);
S[i].D = sqr(X - tx) + sqr(Y - ty);
scanf("%d%d%d\n", &S[i].M, &S[i].P, &S[i].R);
S[i].R = sqr(S[i].R);
srt[i] = S[i].D;
}
ls = n;
srt[++ls] = sqr(1 << 30) * 2;
S[ls].D = srt[ls];
sort(S + 1, S + ls + 1);
sort(srt + 1, srt + ls + 1);
l1 = 1;
P1[1] = P, R1[1] = R;
Build(0, 1, ls, 0);
while (l1) {
P = P1[l1];
R = R1[l1];
l1--;
R = upper_bound(srt + 1, srt + ls + 1, R) - srt - 1;
Remove(0, 1, ls, R, P, 0);
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (vis[i]) ans++;
printf("%d\n", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T rd() {
T nmb = 0;
int sgn = 0;
char chr = getchar();
while (!isdigit(chr)) {
if (chr == '-') sgn = 1;
chr = getchar();
}
while (isdigit(chr)) {
nmb = (nmb << 3) + (nmb << 1) + chr - '0';
chr = getchar();
}
return sgn ? -nmb : nmb;
}
template <typename T>
void wt(T nmb) {
if (nmb > 9) wt(nmb / 10);
putchar(nmb % 10 + '0');
}
template <typename T>
inline void cmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
inline void cmin(T &x, T y) {
x = x < y ? x : y;
}
inline void proc_status() {
ifstream t("/proc/self/status");
cerr << string(istreambuf_iterator<char>(t), istreambuf_iterator<char>())
<< endl;
}
const int N = 2e3 + 10;
const int P = 998244853;
inline int pwr(int x, int y) {
int z = 1;
for (; y; y >>= 1, x = (long long)x * x % P)
if (y & 1) z = (long long)z * x % P;
return z;
}
int fac[N << 1], inv[N << 1];
inline void getfac(int n) {
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = (long long)fac[i - 1] * i % P;
inv[n] = pwr(fac[n], P - 2);
for (int i = n; i; --i) inv[i - 1] = (long long)inv[i] * i % P;
}
inline int C(int n, int m) {
if (n < 0 || m < 0 || n < m) return 0;
return (long long)fac[n] * inv[m] % P * inv[n - m] % P;
}
int main() {
int n = rd<int>(), m = rd<int>();
getfac(n + m);
int Ans = 0;
for (int i = 1; i <= n; ++i) {
if (m <= n - i) {
(Ans += C(n + m, n)) %= P;
continue;
}
int X = n - i, Y = m - (-i);
(Ans += C(X + Y, X)) %= P;
}
printf("%d\n", Ans);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int p[1010], leaf[1010], chil[1010];
int main() {
int n;
scanf("%d", &n);
for (int i = 2; i <= n; i++) scanf("%d", &p[i]);
for (int i = (1); i <= (n); ++i) leaf[i] = 1, chil[i] = 0;
for (int i = (1); i <= (n); ++i) leaf[p[i]] = 0;
for (int i = (1); i <= (n); ++i)
if (leaf[i]) chil[p[i]]++;
bool ok = true;
for (int i = (1); i <= (n); ++i)
if (!leaf[i] && chil[i] < 3) ok = false;
printf("%s\n", ok ? "Yes" : "No");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int MOD = 1e9 + 7;
int n;
long long dp[N][N], ans;
int main() {
scanf("%d", &n);
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
if (j) dp[i][j] = (dp[i][j] + dp[i][j - 1]) % MOD;
dp[i][j] = (dp[i][j] + dp[i - 1][j]) % MOD;
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
if ((i + j) & 1) ans = (ans + dp[i][j]) % MOD;
}
}
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int b[100][100];
int a[100];
int main(void) {
int n;
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> b[i][j];
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = 0; k < 32; k++) {
if (((1 << k) & b[i][j]) != 0) {
if (((1 << k) & a[i]) == 0) a[i] += (1 << k);
if (((1 << k) & a[j]) == 0) a[j] += (1 << k);
}
}
}
}
for (int i = 0; i < n; i++) cout << a[i] << ' ';
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
template <typename T1, typename T2>
inline void mine(T1 &x, const T2 &y) {
if (y < x) x = y;
}
template <typename T1, typename T2>
inline void maxe(T1 &x, const T2 &y) {
if (x < y) x = y;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &b) {
for (auto &k : b) os << k << ' ';
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &b) {
for (auto &k : b) is >> k;
return is;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 998244353;
namespace md {
int mod(long long n) {
if (n <= -MOD || n >= MOD) n %= MOD;
if (n < 0) return n + MOD;
return n;
}
int add(int a, int b) {
a += b;
if (a >= MOD) return a - MOD;
return a;
}
long long sub(long long a, long long b) {
a -= b;
if (a < 0) return a + MOD;
return a;
}
long long mult(long long a, long long b) { return a * b % MOD; }
long long powmod(long long a, long long p) {
if (p == 0) return 1;
if (p & 1) return mult(a, powmod(a, p - 1));
return powmod(mult(a, a), p / 2);
}
long long rev(long long a) { return powmod(a, MOD - 2); }
} // namespace md
struct M {
int x;
M(long long _x) { x = md::mod(_x); }
M() { x = 0; }
M operator+(M y) { return M(md::add(x, y.x)); }
M operator-(M y) { return M(md::sub(x, y.x)); }
M operator*(M y) { return M(1ll * x * y.x); }
M operator/(M y) { return M(x * md::rev(y.x)); }
M operator+(int y) { return (*this) + M(y); }
M operator-(int y) { return (*this) - M(y); }
M operator*(int y) { return (*this) * M(y); }
M operator/(int y) { return (*this) / M(y); }
M operator^(int y) { return M(x ^ y); }
void operator+=(M y) { *this = *this + y; }
void operator-=(M y) { *this = *this - y; }
void operator*=(M y) { *this = *this * y; }
void operator/=(M y) { *this = *this / y; }
void operator+=(int y) { *this = *this + y; }
void operator-=(int y) { *this = *this - y; }
void operator*=(int y) { *this = *this * y; }
void operator/=(int y) { *this = *this / y; }
void operator^=(int y) { *this = *this ^ y; }
bool operator==(M y) { return x == y.x; }
bool operator<(M y) { return x < y.x; }
};
ostream &operator<<(ostream &os, const M &a) {
os << a.x;
return os;
}
istream &operator>>(istream &is, M &a) {
long long x;
is >> x;
a = M(x);
return is;
}
const int N = 1001;
const int C = 1e5 + 10;
int a[N];
int dp[N][N];
int ps[N];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
M ans(0);
for (int can = C; can > 0; --can) {
int mxj = a[n - 1] / can + 1;
if (mxj < k) continue;
mine(mxj, k);
int ptr = 0;
for (int j = 0; j <= mxj; ++j) ps[j] = 0;
for (int i = 0; i < n; ++i) {
while (ptr < i && a[ptr] <= a[i] - can) {
for (int j = 0; j <= mxj; ++j) {
ps[j] = md::add(ps[j], dp[ptr][j]);
}
++ptr;
}
for (int j = 1; j <= mxj; ++j) dp[i][j] = ps[j - 1];
dp[i][1] = md::add(dp[i][1], 1);
ans += dp[i][k];
}
}
cout << ans << '\n';
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
vector<int> v(n + 9);
int mn = INT_MAX;
for (int i = 0; i < (n); i++) {
int x;
cin >> x;
v[i] = x;
;
mn = min(mn, x);
}
int lI = 0;
bool f = 1;
int ans = 1000000009;
for (int i = 0; i < (n); i++) {
if (v[i] == mn) {
if (f) {
lI = i;
f = 0;
} else {
ans = min(ans, i - lI);
lI = i;
}
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, l, c = 0;
cin >> n >> l;
while (!(l % n)) {
l /= n;
c++;
}
if (l == 1 && c)
cout << "YES\n" << c - 1 << endl;
else
cout << "NO" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b;
cin >> a >> b;
set<int> answer;
int n = a + b;
if (b > a) swap(a, b);
if (!(n & 1)) {
int diff = a - n / 2;
int cnt = 0;
while (cnt <= b) {
answer.insert(diff);
diff += 2;
++cnt;
}
} else {
a--;
int diff = a - n / 2;
int cnt = 0;
while (cnt <= b) {
answer.insert(diff);
diff += 2;
++cnt;
}
a++;
if (b >= 1) {
b--;
diff = a - n / 2 + 1;
cnt = 0;
while (cnt <= b) {
answer.insert(diff);
diff += 2;
++cnt;
}
b++;
}
if (b >= 1) {
b--;
diff = a - n / 2;
cnt = 0;
while (cnt <= b) {
answer.insert(diff);
diff += 2;
++cnt;
}
b++;
}
a--;
diff = a - n / 2 + 1;
cnt = 0;
while (cnt <= b) {
answer.insert(diff);
diff += 2;
++cnt;
}
}
cout << (int)answer.size() << "\n";
for (auto x : answer) cout << x << " ";
cout << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int test_cases;
cin >> test_cases;
while (test_cases--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int ll, rr;
const int maxN = 1e5 + 20;
long long f[maxN][22], ans;
int a[maxN], cnt[maxN];
long long pairs(long long x) { return x * (x - 1) / 2; }
void solve(int l, int r, int j, int ld, int rd) {
int mid = (r + l) / 2;
int nm = 0;
long long mn = 1e18;
while (rr < mid) {
rr++;
ans -= pairs(cnt[a[rr]]);
cnt[a[rr]]++;
ans += pairs(cnt[a[rr]]);
}
while (rr > mid) {
ans -= pairs(cnt[a[rr]]);
cnt[a[rr]]--;
ans += pairs(cnt[a[rr]]);
rr--;
}
while (ll < ld + 1) {
ans -= pairs(cnt[a[ll]]);
cnt[a[ll]]--;
ans += pairs(cnt[a[ll]]);
ll++;
}
while (ll > ld + 1) {
ll--;
ans -= pairs(cnt[a[ll]]);
cnt[a[ll]]++;
ans += pairs(cnt[a[ll]]);
}
for (int i = ld; i <= min(rd, mid - 1); i++) {
if (f[i][j - 1] + ans < mn) {
mn = f[i][j - 1] + ans;
nm = i;
}
ans -= pairs(cnt[a[ll]]);
cnt[a[ll]]--;
ans += pairs(cnt[a[ll]]);
ll++;
}
f[mid][j] = mn;
if (l <= mid - 1) solve(l, mid - 1, j, ld, nm);
if (mid + 1 <= r) solve(mid + 1, r, j, nm, rd);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i <= n; i++)
for (int j = 0; j <= k; j++) f[i][j] = 1e18;
f[0][0] = 0;
for (int j = 1; j <= k; j++) {
for (int i = 1; i <= n; i++) cnt[i] = 0;
ll = 1;
rr = 0;
solve(1, n, j, 0, n - 1);
}
cout << f[n][k] << "\n";
return 0;
}
| 17 |
#include <bits/stdc++.h>
long long m[200000], t[200000], ans, n;
int main() {
scanf("%I64d", &n);
for (int i = 1; i <= n; ++i) scanf("%I64d", &m[i]), t[i] = m[i] + 1;
for (int i = 2; i <= n; ++i)
if (t[i] < t[i - 1]) t[i] = t[i - 1];
for (int i = n; i >= 2; --i)
if (t[i - 1] < t[i] - 1) t[i - 1] = t[i] - 1;
for (int i = 1; i <= n; ++i) ans += t[i] - 1 - m[i];
printf("%I64d", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000 + 10;
struct qry {
int l, r, u, d;
long long t[10];
} q[MAXN];
vector<pair<int, int> > row[MAXN];
int a[MAXN], sum[MAXN];
int n, m;
void update(int x, int v) {
while (x <= n) {
sum[x] += v;
x += (x & -x);
}
}
int query(int x) {
int res = 0;
while (x) {
res += sum[x];
x -= (x & -x);
}
return res;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[x] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &q[i].l, &q[i].d, &q[i].r, &q[i].u);
row[q[i].d - 1].push_back(make_pair(i, 0));
row[q[i].u].push_back(make_pair(i, 1));
}
for (int i = 1; i <= n; i++) {
update(a[i], 1);
for (int j = 0; j < row[i].size(); j++) {
int id = row[i][j].first;
int l = q[id].l, r = q[id].r;
if (row[i][j].second) {
q[id].t[4] = query(l - 1), q[id].t[5] = query(r), q[id].t[6] = query(n);
q[id].t[6] -= q[id].t[5], q[id].t[5] -= q[id].t[4];
} else {
q[id].t[1] = query(l - 1), q[id].t[2] = query(r), q[id].t[3] = query(n);
q[id].t[3] -= q[id].t[2], q[id].t[2] -= q[id].t[1];
}
}
}
for (int i = 1; i <= m; i++) {
int l = q[i].l, r = q[i].r;
q[i].t[7] = query(l - 1), q[i].t[8] = query(r), q[i].t[9] = query(n);
q[i].t[9] -= q[i].t[8], q[i].t[8] -= q[i].t[7];
for (int j = 7; j <= 9; j++)
q[i].t[j] -= q[i].t[j - 3], q[i].t[j - 3] -= q[i].t[j - 6];
long long ans = 0;
long long t1 = q[i].t[1], t2 = q[i].t[2], t3 = q[i].t[3], t4 = q[i].t[4],
t5 = q[i].t[5], t6 = q[i].t[6], t7 = q[i].t[7], t8 = q[i].t[8],
t9 = q[i].t[9];
ans = t7 * (t5 + t6 + t2 + t3) + t8 * (t4 + t5 + t6 + t1 + t2 + t3) +
t9 * (t4 + t5 + t1 + t2);
ans += t4 * (t8 + t9 + t5 + t6 + t2 + t3) +
t5 * (t7 + t8 + t9 + t4 + t6 + t1 + t2 + t3) +
t6 * (t7 + t8 + t4 + t5 + t1 + t2);
ans += t1 * (t8 + t9 + t5 + t6) + t2 * (t7 + t8 + t9 + t4 + t5 + t6) +
t3 * (t7 + t8 + t4 + t5);
ans /= 2;
if (t5) ans += t5 * (t5 - 1) / 2;
printf("%I64d\n", ans);
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, h, p = 1000003;
long long quick_mod(long long a, long long b) {
long long ans = 1;
a %= p;
while (b) {
if (b & 1) {
ans = ans * a % p;
b--;
}
b >>= 1;
a = a * a % p;
}
return ans;
}
long long C(long long n, long long m) {
if (m > n) return 0;
long long ans = 1;
for (int i = 1; i <= m; i++) {
long long a = (n + i - m) % p;
long long b = i % p;
ans = ans * (a * quick_mod(b, p - 2) % p) % p;
}
return ans;
}
long long Lucas(long long n, long long m) {
if (m == 0) return 1;
return C(n % p, m % p) * Lucas(n / p, m / p) % p;
}
int main() {
long long a[210] = {}, f[210] = {}, x, y = 0;
cin >> n >> m >> h;
x = 1;
a[0] = 1;
for (long long i = 1; i <= m; i++) {
x = (x * h) % p;
a[i] = x % p;
}
f[0] = 1;
for (long long i = 1; i <= m; i++) {
f[i] = (f[i - 1] * (h + 1)) % p;
}
f[m + 1] = (f[m] * (h + 1) % p - a[m] * h % p + p) % p;
for (long long i = m + 2; i <= n; i++) {
f[i % (m + 2)] = (f[(i - 1) % (m + 2)] * (h + 1) % p -
f[i % (m + 2)] * a[m] * h % p + p) %
p;
}
cout << f[n % (m + 2)] << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
void die() {
cout << "NO" << endl;
exit(0);
}
const int limit = 1005;
struct elem {
int u, v, val;
elem() {}
elem(int u, int v, int val) : u(u), v(v), val(val) {}
};
int n;
vector<pair<int, int> > g[limit];
int example[limit];
vector<elem> sol;
void precompute(int u, int p) {
example[u] = u;
vector<pair<int, int> > &ar = g[u];
vector<pair<int, int> > nextar;
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i].first;
if (v != p) {
precompute(v, u);
example[u] = example[v];
nextar.push_back(ar[i]);
}
}
ar = nextar;
}
void write(string s, vector<pair<int, int> > &v) {
cout << s;
for (int i = 0; i < int(v.size()); i++)
cout << "[" << v[i].first << "," << v[i].second << "]";
cout << endl;
}
void compute(int u, int p, int valp) {
vector<pair<int, int> > &ar = g[u];
if (int(ar.size()) == 0) {
sol.push_back(elem(u, p, valp));
return;
}
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i].first;
int val = ar[i].second;
compute(v, p, val);
valp -= val;
}
int u0 = example[ar[0].first];
int u1 = example[ar[1].first];
sol.push_back(elem(u0, p, valp / 2));
sol.push_back(elem(u1, p, valp / 2));
sol.push_back(elem(u0, u1, -valp / 2));
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v, val;
cin >> u >> v >> val;
g[u].push_back(pair<int, int>(v, val));
g[v].push_back(pair<int, int>(u, val));
}
for (int u = 1; u <= n; u++) {
if (int(g[u].size()) == 2) {
cout << "NO" << endl;
exit(0);
}
}
precompute(1, 0);
vector<pair<int, int> > &ar = g[1];
if (int(ar.size()) == 1) {
compute(ar[0].first, 1, ar[0].second);
} else {
int u = ar[0].first;
int u0 = example[u];
int valu = ar[0].second;
int sum = 0;
for (int i = 1; i < int(ar.size()); i++) {
int v = ar[i].first;
int valv = ar[i].second;
compute(v, u0, valv);
sum += valv;
}
int u1 = example[ar[1].first];
int u2 = example[ar[2].first];
compute(u, u1, valu);
sol.push_back(elem(u2, u1, -valu));
sol.push_back(elem(u2, u0, -sum));
sol.push_back(elem(u2, u1, (valu + sum) / 2));
sol.push_back(elem(u2, u0, (valu + sum) / 2));
sol.push_back(elem(u0, u1, -(valu + sum) / 2));
}
cout << "YES" << endl;
cout << int(sol.size()) << endl;
for (int i = 0; i < int(sol.size()); i++) {
elem &e = sol[i];
cout << e.u << " " << e.v << " " << e.val << endl;
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[100];
cin >> s;
int k = strlen(s), i;
for (i = 0; i < k; i++) {
if (s[i] == 'e' || s[i] == 'E' || s[i] == 'a' || s[i] == 'o' ||
s[i] == 'y' || s[i] == 'u' || s[i] == 'i' || s[i] == 'A' ||
s[i] == 'O' || s[i] == 'Y' || s[i] == 'U' || s[i] == 'I') {
} else {
cout << ".";
if (s[i] >= 'A' && s[i] <= 'Z') {
s[i] = s[i] + 32;
cout << s[i];
} else {
cout << s[i];
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int solve(vector<int>& v) {
int ans = v[0] ^ v[1];
vector<int> st;
for (int i = 0; i < v.size(); i++) {
while (!st.empty() && st.back() < v[i]) st.pop_back();
st.push_back(v[i]);
if (st.size() >= 2) ans = max(ans, st[st.size() - 1] ^ st[st.size() - 2]);
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
vector<int> v(n);
for (int i = 0; i < n; i++) scanf("%d", &v[i]);
int ans = solve(v);
reverse(v.begin(), v.end());
ans = max(ans, solve(v));
cout << ans;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
while (cin >> n >> m >> k) {
int pl[n + 5], gap[n + 5], tot;
for (int i = 0; i < n; ++i) {
cin >> pl[i];
if (i >= 1) gap[i] = pl[i] - pl[i - 1] - 1;
}
tot = pl[n - 1] - pl[0] + 1;
sort(gap + 1, gap + n);
for (int i = 0; i < k - 1; ++i) tot -= gap[n - i - 1];
cout << tot << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> fac(int x) {
if (x == 1) return {};
vector<int> ret;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
ret.emplace_back(i);
while (x % i == 0) x /= i;
}
}
if (x != 1) ret.emplace_back(x);
return ret;
}
const int maxn = 112345;
const double eps = 1e-6;
int n, a[maxn], ans[maxn];
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
scanf("%d", &n);
for (int(i) = (1); (i) <= (n); (i)++) scanf("%d", a + i);
auto v1 = fac(a[1]);
int k1 = v1.size();
double e = k1 / double(n - 1), err = 1;
set<int> checked;
bool found = false;
while (err >= eps && checked.size() < n - 1) {
err *= e;
int u = -1;
do {
u = uniform_int_distribution<int>(2, n)(rng);
} while (checked.count(u));
checked.emplace(u);
auto v2 = fac(a[u]);
int k2 = v2.size();
vector<vector<char>> good(n + 1, vector<char>(20));
for (int(i) = (2); (i) <= (n); (i)++)
for (int(j) = (0); (j) <= ((k1)-1); (j)++) good[i][j] = a[i] % v1[j] != 0;
for (int(i) = (2); (i) <= (n); (i)++)
for (int(j) = (0); (j) <= ((k2)-1); (j)++)
good[i][j + k1] = a[i] % v2[j] != 0;
vector<pair<int, pair<int, int>>> candidates;
vector<int> need(20, k1 + k2);
for (int(i) = (2); (i) <= (n); (i)++)
if (i != u) {
bool sel = false;
for (int(j) = (0); (j) <= ((k1 + k2) - 1); (j)++)
if (need[j] && good[i][j]) {
sel = true;
need[j]--;
break;
}
if (sel) {
int mask1 = 0, mask2 = 0;
for (int(j) = (0); (j) <= ((k1)-1); (j)++) mask1 |= (good[i][j] << j);
for (int(j) = (0); (j) <= ((k2)-1); (j)++)
mask2 |= (good[i][j + k1] << j);
candidates.emplace_back(i, make_pair(mask1, mask2));
}
}
vector<vector<vector<pair<int, int>>>> f;
f.resize(candidates.size() + 1);
for (auto &g : f) {
g.resize(1 << k1);
for (auto &h : g) h = vector<pair<int, int>>(1 << k2, make_pair(-1, -1));
}
f[0][0][0] = {0, 0};
for (int(i) = (0); (i) <= ((int(candidates.size())) - 1); (i)++)
for (int(mask1) = (0); (mask1) <= ((1 << k1) - 1); (mask1)++)
for (int(mask2) = (0); (mask2) <= ((1 << k2) - 1); (mask2)++) {
if (f[i][mask1][mask2].first == -1) continue;
int m1 = candidates[i].second.first, m2 = candidates[i].second.second;
int nmask1 = mask1 | m1, nmask2 = mask2 | m2;
if (f[i + 1][nmask1][mask2].first == -1)
f[i + 1][nmask1][mask2] = {mask1, mask2};
if (f[i + 1][mask1][nmask2].second == -1)
f[i + 1][mask1][nmask2] = {mask1, mask2};
}
if (f[candidates.size()][(1 << k1) - 1][(1 << k2) - 1].first == -1)
continue;
int mask1 = (1 << k1) - 1, mask2 = (1 << k2) - 1;
ans[1] = 1;
ans[u] = 2;
for (int(i) = (candidates.size()); (i) >= (1); (i)--) {
if (mask1 == f[i][mask1][mask2].first) {
ans[candidates[i - 1].first] = 2;
mask2 = f[i][mask1][mask2].second;
} else {
ans[candidates[i - 1].first] = 1;
mask1 = f[i][mask1][mask2].first;
}
}
for (int(i) = (2); (i) <= (n); (i)++)
if (!ans[i]) ans[i] = 1;
found = true;
break;
}
if (found) {
puts("YES");
for (int(i) = (1); (i) <= (n); (i)++) printf("%d ", ans[i]);
} else
puts("NO");
}
| 21 |
#include <bits/stdc++.h>
const int mod = 998244353;
const int gmod = 3;
const int inf = 1039074182;
const double eps = 1e-9;
const double pi = 3.141592653589793238462643383279;
const long long llinf = 2LL * inf * inf;
template <typename T1, typename T2>
inline void chmin(T1 &x, T2 b) {
if (b < x) x = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &x, T2 b) {
if (b > x) x = b;
}
inline void chadd(int &x, int b) {
x += b - mod;
x += (x >> 31 & mod);
}
template <typename T1, typename T2>
inline void chadd(T1 &x, T2 b) {
x += b;
if (x >= mod) x -= mod;
}
template <typename T1, typename T2>
inline void chmul(T1 &x, T2 b) {
x = 1LL * x * b % mod;
}
template <typename T1, typename T2>
inline void chmod(T1 &x, T2 b) {
x %= b, x += b;
if (x >= b) x -= b;
}
template <typename T>
inline T mabs(T x) {
return (x < 0 ? -x : x);
}
using namespace std;
using namespace std;
template <typename T>
ostream &operator<<(ostream &cout, const vector<T> &vec) {
cout << "{";
for (int i = 0; i < (int)vec.size(); i++) {
cout << vec[i];
if (i != (int)vec.size() - 1) cout << ',';
}
cout << "}";
return cout;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &cout, pair<T1, T2> p) {
cout << "(" << p.first << ',' << p.second << ")";
return cout;
}
template <typename T, typename T2>
ostream &operator<<(ostream &cout, set<T, T2> s) {
vector<T> t;
for (auto x : s) t.push_back(x);
cout << t;
return cout;
}
template <typename T, typename T2>
ostream &operator<<(ostream &cout, multiset<T, T2> s) {
vector<T> t;
for (auto x : s) t.push_back(x);
cout << t;
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, queue<T> q) {
vector<T> t;
while (q.size()) {
t.push_back(q.front());
q.pop();
}
cout << t;
return cout;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &cout, map<T1, T2, T3> m) {
for (auto &x : m) {
cout << "Key: " << x.first << ' ' << "Value: " << x.second << endl;
}
return cout;
}
template <typename T1, typename T2>
void operator+=(pair<T1, T2> &x, const pair<T1, T2> y) {
x.first += y.first;
x.second += y.second;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &x, const pair<T1, T2> &y) {
return make_pair(x.first + y.first, x.second + y.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &x, const pair<T1, T2> &y) {
return make_pair(x.first - y.first, x.second - y.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> x) {
return make_pair(-x.first, -x.second);
}
template <typename T>
vector<vector<T>> operator~(vector<vector<T>> vec) {
vector<vector<T>> v;
int n = vec.size(), m = vec[0].size();
v.resize(m);
for (int i = 0; i < m; i++) {
v[i].resize(n);
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
v[i][j] = vec[j][i];
}
}
return v;
}
void print0x(int x) {
std::vector<int> vec;
while (x) {
vec.push_back(x & 1);
x >>= 1;
}
std::reverse(vec.begin(), vec.end());
for (int i = 0; i < (int)vec.size(); i++) {
std::cout << vec[i];
}
std::cout << ' ';
}
template <typename T>
void print0x(T x, int len) {
std::vector<int> vec;
while (x) {
std::cout << (x & 1);
x >>= 1;
len--;
}
while (len--) cout << 0;
}
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
template <int mod>
struct ModInt {
int x;
ModInt() { x = 0; }
ModInt(const int &_x) {
x = _x % mod;
if (x < 0) x += mod;
}
ModInt(const long long &_x) {
x = _x % mod;
if (x < 0) x += mod;
}
ModInt<mod> &operator++() {
++x;
if (x == mod) x = 0;
return *this;
}
ModInt<mod> operator++(int) {
int t = x;
x++;
if (x == mod) x = 0;
return t;
}
ModInt<mod> &operator--() {
--x;
if (x == -1) x += mod;
return *this;
}
ModInt<mod> operator--(int) {
int t = x;
x--;
if (x == -1) x += mod;
return t;
}
ModInt<mod> operator-() const { return ModInt<mod>((x == 0 ? 0 : mod - x)); }
};
template <int mod>
inline ModInt<mod> operator*(const ModInt<mod> &a, const int &c) {
return 1LL * a.x * c % mod;
}
template <int mod>
inline int mabs(const ModInt<mod> &a) {
return a.x;
}
template <int mod>
bool operator==(const ModInt<mod> &a, const ModInt<mod> &b) {
return a.x == b.x;
}
template <int mod>
bool operator!=(const ModInt<mod> &a, const ModInt<mod> &b) {
return (a.x != b.x);
}
template <int mod>
inline ModInt<mod> operator+(const ModInt<mod> &a, const ModInt<mod> &b) {
int tmp = a.x + b.x;
if (tmp >= mod) tmp -= mod;
return tmp;
}
template <int mod>
inline ModInt<mod> operator-(const ModInt<mod> &a, const ModInt<mod> &b) {
int tmp = a.x - b.x;
if (tmp < 0) tmp += mod;
return tmp;
}
template <int mod>
inline void operator-=(ModInt<mod> &a, const ModInt<mod> &b) {
a.x -= b.x;
a.x += (a.x >> 31 & mod);
}
template <int mod>
inline ModInt<mod> operator*(const ModInt<mod> &a, const ModInt<mod> &b) {
return 1LL * a.x * b.x % mod;
}
template <int mod>
inline void operator*=(ModInt<mod> &a, const ModInt<mod> &b) {
a.x = 1LL * a.x * b.x % mod;
}
template <int mod>
inline void operator+=(ModInt<mod> &a, const ModInt<mod> &b) {
a.x += b.x;
if (a.x >= mod) a.x -= mod;
}
template <int mod>
inline ModInt<mod> mod_inv(ModInt<mod> x) {
int m = mod - 2;
ModInt<mod> basic = x;
x = 1;
while (m) {
if (m & 1) x *= basic;
m >>= 1;
basic *= basic;
}
return x;
}
template <int mod>
ModInt<mod> operator/(const ModInt<mod> &a, const ModInt<mod> &b) {
return a * mod_inv(b);
}
template <int mod>
void operator/=(ModInt<mod> &a, const ModInt<mod> &b) {
a = a / b;
}
template <int mod>
inline ModInt<mod> operator^(const ModInt<mod> &basic, int x) {
ModInt<mod> res = 1;
while (x) {
if (x & 1) res *= basic;
basic *= basic;
x >>= 1;
}
return res;
}
template <int mod>
istream &operator>>(istream &cin, const ModInt<mod> &x) {
cin >> x.x;
x.x %= mod;
if (x.x < 0) x.x += mod;
return cin;
}
template <int mod>
ostream &operator<<(ostream &cout, const ModInt<mod> x) {
cout << x.x;
return cout;
}
template <int mod, int root, int LogN>
struct NTT {
using Int = ModInt<mod>;
static const int MaxN = (1 << LogN);
int w[MaxN + 5];
int fac[MaxN + 5], ifac[MaxN + 5], inum[MaxN + 5];
int fastpow(int basic, int x) {
int res = 1;
while (x) {
if (x & 1) res = 1LL * res * basic % mod;
basic = 1LL * basic * basic % mod;
x >>= 1;
}
return res;
}
int inv[MaxN + 5];
int buf[MaxN + 5];
int ww[MaxN + 5];
inline void ntt(vector<int> &v, int rev, int lg) {
int n = (1 << lg);
memset(buf, 0, sizeof(int) * n);
v.resize(n, 0);
for (int i = 0; i < n; i++) {
inv[i] = (inv[i >> 1] >> 1) | ((i & 1) << (lg - 1));
}
for (int i = 0; i < n; i++) {
buf[i] = v[inv[i]];
}
int lvl = LogN;
int *ba, *bb, *wa, *wb;
int tmp;
for (int b = 1; b < n; b *= 2) {
lvl--;
for (int i = 0; i < b * 2; i++)
ww[i] = (rev ? w[MaxN - (i << lvl)] : w[i << lvl]);
for (int i = 0; i < n; i += b * 2) {
ba = buf + i;
bb = buf + i + b;
wa = ww;
wb = ww + b;
for (int j = 0; j < b; j++) {
tmp = 1LL * *wa * *bb % mod;
*bb = *ba - tmp;
*ba += tmp;
*ba -= mod;
*ba += ((*ba) >> 31 & mod);
*bb += ((*bb) >> 31 & mod);
ba++;
bb++;
wa++;
wb++;
}
}
}
int t = fastpow(n, mod - 2);
if (rev) {
for (int i = 0; i < (1 << lg); i++) {
buf[i] = 1LL * buf[i] * t % mod;
}
}
for (int i = 0; i < (1 << lg); i++) v[i] = buf[i];
}
void add(const vector<int> &a, const vector<int> &b, vector<int> &c) {
int n = a.size(), m = b.size();
c.resize(max(n, m), 0);
for (int i = 0; i < max(n, m); i++) {
c[i] = (i >= n ? 0 : a[i]) + (i >= m ? 0 : b[i]) - mod;
c[i] += (c[i] >> 31) & mod;
}
}
void multiply(vector<int> a, vector<int> b, vector<int> &c) {
int n = (int)a.size() + b.size() - 1;
if (min(a.size(), b.size()) <= 30) {
c.clear();
c.resize(max(0, n), 0);
for (int i = 0; i < (int)a.size(); i++) {
for (int j = 0; j < (int)b.size(); j++) {
c[i + j] = (1LL * a[i] * b[j] + c[i + j]) % mod;
}
}
while (c.size() && c.back() == 0) c.pop_back();
return;
}
int nn = 1, lg = 0;
while (nn < n) {
nn <<= 1;
lg++;
}
c.resize(nn);
a.resize(nn, 0);
b.resize(nn, 0);
ntt(a, 0, lg);
ntt(b, 0, lg);
for (int i = 0; i < nn; i++) {
c[i] = 1LL * a[i] * b[i] % mod;
}
ntt(c, 1, lg);
while (c.size() && c.back() == 0) c.pop_back();
}
inline void togf(vector<int> &v) {
int n = v.size();
for (int i = 0; i < n; i++) v[i] = 1LL * v[i] * fac[i] % mod;
}
inline void toegf(vector<int> &v) {
int n = v.size();
for (int i = 0; i < n; i++) v[i] = 1LL * v[i] * ifac[i] % mod;
}
void sqr(vector<int> &a) {
int n = (int)a.size() + a.size() - 1;
if (a.size() <= 20) {
vector<int> res(n, 0);
for (int i = 0; i < (int)a.size(); i++) {
for (int j = 0; j < (int)a.size(); j++) {
chadd(res[i + j], 1LL * a[i] * a[j] % mod);
}
}
a = res;
return;
}
int nn = 1, lg = 0;
while (nn < n) {
nn <<= 1;
lg++;
}
a.resize(nn, 0);
ntt(a, 0, lg);
for (int i = 0; i < nn; i++) {
a[i] = 1LL * a[i] * a[i] % mod;
}
ntt(a, 1, lg);
while (a.size() && a.back() == 0) a.pop_back();
}
inline vector<int> derivative(const vector<int> &v) {
int n = v.size();
if (n == 0) return v;
vector<int> rv(n - 1);
for (int i = 0; i < n - 1; i++) {
rv[i] = 1LL * v[i + 1] * (i + 1) % mod;
}
return rv;
}
inline void integral(vector<int> &v, int c = 0) {
int n = v.size() + 1;
v.emplace_back(0);
for (int i = n - 1; i >= 1; i--) {
v[i] = 1LL * inum[i] * v[i - 1] % mod;
}
v[0] = c;
}
inline void multiply(vector<int> &v, int c) {
for (auto &x : v) {
x = 1LL * x * c % mod;
}
}
inline vector<int> add(const vector<int> &a, const vector<int> &b) {
vector<int> v = a;
if (v.size() < b.size()) v.resize(b.size(), 0);
for (int i = 0; i < (int)b.size(); i++) {
v[i] += b[i] - mod;
v[i] += ((v[i] >> 31) & mod);
}
return v;
}
inline vector<int> sub(const vector<int> &a, const vector<int> &b) {
vector<int> v = a;
if (v.size() < b.size()) v.resize(b.size(), 0);
for (int i = 0; i < (int)b.size(); i++) {
v[i] -= b[i];
v[i] += ((v[i] >> 31) & mod);
}
return v;
}
void inverse(vector<int> &v) {
int n = v.size();
if (n == 1) {
v[0] = fastpow(v[0], mod - 2);
return;
}
int tn = (n - 1) / 2 + 1;
vector<int> f0(tn);
for (int i = 0; i < tn; i++) f0[i] = v[i];
inverse(f0);
vector<int> rv = f0;
multiply(rv, 2);
sqr(f0);
multiply(v, f0, f0);
v = sub(rv, f0);
v.resize(n);
}
void div(const vector<int> &F, const vector<int> &G, vector<int> &Q,
vector<int> &R) {
int n = F.size(), m = G.size();
if (n < m) {
Q.clear();
R = F;
return;
}
vector<int> f = F, g = G;
reverse(f.begin(), f.end());
reverse(g.begin(), g.end());
g.resize(n - m + 1, 0);
inverse(g);
multiply(f, g, Q);
Q.resize(n - m + 1, 0);
reverse(Q.begin(), Q.end());
multiply(G, Q, R);
R.resize(m - 1, 0);
for (int i = 0; i < m - 1; i++) {
R[i] = (F[i] - R[i] + mod) % mod;
}
}
void internal_multipoint_eval(const vector<int> &v, const vector<int> &u,
int x, int l, int r, vector<int> &res,
vector<int> *f) {
if (l >= res.size()) return;
if (r - l == 1) {
res[l] = v[0];
return;
}
vector<int> Q, R;
div(v, f[x * 2], Q, R);
internal_multipoint_eval(R, u, x * 2, l, l + r >> 1, res, f);
div(v, f[x * 2 + 1], Q, R);
internal_multipoint_eval(R, u, x * 2 + 1, l + r >> 1, r, res, f);
}
vector<int> multipoint_eval(vector<int> &v, const vector<int> &u) {
if ((int)u.size() <= 32) {
int n = u.size(), m = v.size();
vector<int> res(n, 0);
for (int i = 0; i < n; i++) {
int ex = 1;
for (int j = 0; j < m; j++) {
chadd(res[i], 1LL * ex * v[j] % mod);
ex = 1LL * ex * u[i] % mod;
}
}
return res;
}
vector<int> *f;
int n = u.size(), nn = 1;
while (nn < n) nn <<= 1;
f = new vector<int>[nn + nn];
for (int i = 0; i < n; i++) f[nn + i] = {mod - u[i], 1};
for (int i = n; i < nn; i++) f[nn + i] = {1};
for (int i = nn - 1; i >= 2; i--) {
multiply(f[i * 2], f[i * 2 + 1], f[i]);
}
vector<int> res(n);
internal_multipoint_eval(v, u, 1, 0, nn, res, f);
delete[] f;
return res;
}
vector<int> interpolation(const vector<int> &x, vector<int> y) {
int n = x.size();
vector<int> *f = new vector<int>[n];
vector<int> *f2 = new vector<int>[n];
for (int i = 0; i < n; i++) {
f[i] = {mod - x[i], 1};
}
for (int b = 1; b < n; b *= 2) {
for (int i = 0; i < n; i += b * 2) {
if (i + b < n) multiply(f[i], f[i + b], f[i]);
}
}
vector<int> M = f[0], dM = derivative(M);
vector<int> tmp = multipoint_eval(dM, x);
for (int i = 0; i < n; i++) {
y[i] = 1LL * y[i] * fastpow(tmp[i], mod - 2) % mod;
}
for (int i = 0; i < n; i++) {
f[i] = {mod - x[i], 1};
f2[i] = {y[i]};
}
for (int b = 1; b < n; b <<= 1) {
for (int i = 0; i < n; i += b * 2) {
if (i + b < n) {
vector<int> tmp;
multiply(f2[i], f[i + b], tmp);
multiply(f[i], f2[i + b], f2[i]);
f2[i] = add(f2[i], tmp);
multiply(f[i], f[i + b], f[i]);
}
}
}
vector<int> res = f2[0];
delete[] f2;
delete[] f;
return res;
}
vector<int> log(const vector<int> &v) {
int n = v.size();
vector<int> dv = derivative(v), iv = v;
inverse(iv);
multiply(dv, iv, dv);
integral(dv);
dv.resize(n);
return dv;
}
vector<int> exp(const vector<int> &v) {
int n = v.size(), tn = (n - 1) / 2 + 1;
vector<int> rv;
if (n == 1) {
rv.push_back(1);
return rv;
}
vector<int> f0(tn);
for (int i = 0; i < tn; i++) f0[i] = v[i];
f0 = exp(f0);
f0.resize(n, 0);
vector<int> rhs(1, 1);
rhs = sub(rhs, log(f0));
rhs = add(rhs, v);
multiply(f0, rhs, f0);
f0.resize(n);
return f0;
}
inline void multiply(const vector<Int> &a, const vector<Int> &b,
vector<Int> &c) {
vector<int> ta(a.size()), tb(b.size());
for (int i = 0; i < (int)a.size(); i++) ta[i] = a[i].x;
for (int i = 0; i < (int)b.size(); i++) tb[i] = b[i].x;
vector<int> tc;
multiply(ta, tb, tc);
c.clear();
c.resize(tc.size());
for (int i = 0; i < (int)c.size(); i++) c[i].x = tc[i];
}
vector<Int> multiply(const vector<Int> &a, const vector<Int> &b) {
vector<int> ta(a.size()), tb(b.size());
for (int i = 0; i < (int)a.size(); i++) ta[i] = a[i].x;
for (int i = 0; i < (int)b.size(); i++) tb[i] = b[i].x;
vector<int> tc;
multiply(ta, tb, tc);
vector<Int> c(tc.size());
for (int i = 0; i < (int)c.size(); i++) c[i].x = tc[i];
return c;
}
vector<int> pow(vector<int> bas, int n, int n2) {
int c0 = 0;
for (int i = 0; i < (int)bas.size(); i++) {
if (bas[i]) break;
c0 = i + 1;
}
for (int i = 0; i < (int)bas.size() - c0; i++) bas[i] = bas[i + c0];
for (int i = 0; i < c0; i++) bas.pop_back();
int c = bas[0], inum = fastpow(bas[0], mod - 2);
for (auto &x : bas) x = 1LL * x * inum % mod;
bas = log(bas);
for (auto &x : bas) x = 1LL * x * (n % mod) % mod;
bas = exp(bas);
c = fastpow(c, n2);
for (auto &x : bas) x = 1LL * x * c % mod;
auto safepow = [](int x, long long n, long long lim) -> int {
if (x == 1) return min(1LL, lim);
if (x == 0) return 0;
long long res = 1;
for (int i = 0; i < n; i++) {
res *= x;
if (res > lim) break;
}
res = min(res, lim);
};
c0 = safepow(c0, n, bas.size());
for (int i = c0; i < (int)bas.size(); i++) {
bas[i] = bas[i - c0];
}
for (int i = 0; i < c0; i++) bas[i] = 0;
return bas;
}
NTT() {
w[0] = 1;
int ur = fastpow(root, (mod - 1) >> LogN);
fac[0] = 1;
for (int i = 1; i <= MaxN; i++) {
w[i] = 1LL * w[i - 1] * ur % mod;
fac[i] = 1LL * fac[i - 1] * i % mod;
}
ifac[MaxN] = fastpow(fac[MaxN], mod - 2);
for (int i = MaxN - 1; i >= 0; i--) {
ifac[i] = 1LL * ifac[i + 1] * (i + 1) % mod;
}
for (int i = 1; i <= MaxN; i++) {
inum[i] = 1LL * ifac[i] * fac[i - 1] % mod;
}
}
};
namespace combinatorics {
int *fac;
int *ifac;
int __Tmod;
inline int add(int a, int b) { return (a + b) % __Tmod; }
inline int sub(int a, int b) { return (a - b + __Tmod) % __Tmod; }
inline int mult(int a, int b) { return (1LL * a * b) % __Tmod; }
inline int fastpow(int basic, int x) {
chmod(x, __Tmod - 1);
if (x == 0) return 1;
int res = 1;
while (x) {
if (x & 1) res = mult(res, basic);
basic = mult(basic, basic);
x >>= 1;
}
return res;
}
inline int inv(int x) { return fastpow(x, __Tmod - 2); }
inline int div(int a, int b) { return mult(a, inv(b)); }
void init(int n, int tmod) {
__Tmod = tmod;
fac = new int[n + 5];
ifac = new int[n + 5];
fac[0] = 1;
for (int i = 1; i <= n; i++) {
fac[i] = mult(fac[i - 1], i);
}
ifac[n] = inv(fac[n]);
for (int i = n - 1; i >= 0; i--) {
ifac[i] = mult(ifac[i + 1], i + 1);
}
}
inline int C(int n, int m) {
if (n < m || n < 0 || m < 0) return 0;
return mult(mult(fac[n], ifac[m]), ifac[n - m]);
}
inline int Cat(int x) { return mult(C(x * 2, x), inv(x + 1)); }
} // namespace combinatorics
using namespace std;
int n;
vector<int> edges[250005];
int s;
map<int, int> degs;
vector<int> F[250005];
NTT<mod, 3, 19> ntt;
void dfs(int x, int par) {
int deg = 0;
for (auto u : edges[x]) {
if (u == par) continue;
dfs(u, x);
deg++;
}
degs[deg]++;
}
inline int fastpow(long long basic, int x) {
long long res = 1;
while (x) {
if (x & 1) (res *= basic) %= mod;
(basic *= basic) %= mod;
x >>= 1;
}
return res;
}
int pw[250005];
int main() {
combinatorics::init(250000, mod);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
edges[x].emplace_back(y);
edges[y].emplace_back(x);
}
dfs(0, -1);
int m = 0;
for (auto [d, s] : degs) {
F[m].resize(s + 1);
pw[0] = 1;
for (int i = 1; i <= s; i++) pw[i] = 1LL * pw[i - 1] * d % mod;
for (int i = 0; i <= s; i++)
F[m][i] = 1LL * combinatorics::C(s, i) * pw[s - i] % mod;
m++;
}
for (int b = 1; b < m; b <<= 1) {
for (int i = 0; i + b < m; i += b + b) {
ntt.multiply(F[i], F[i + b], F[i]);
}
}
int res = 0;
for (int i = 0; i <= n; i++) {
int v = 1LL * F[0][i] * combinatorics::fac[i] % mod;
if ((n - s - i) & 1)
chadd(res, mod - v);
else
chadd(res, v);
}
cout << res << endl;
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a, b;
double al[100005], bl[100005], dbl[100005];
double ans;
long long ansa, ansb;
double dis(double ax, double ay, double bx, double by) {
return (sqrt((ax - bx) * (ax - bx) + (ay - by) * (ay - by)));
}
double calc(int pa, int pb) {
return (dis(0, 0, a, al[pa]) + dis(a, al[pa], b, bl[pb]) + dbl[pb]);
}
int main() {
cin >> n >> m >> a >> b;
for (int i = 0; i < n; i++) {
scanf("%lf", &al[i]);
}
for (int j = 0; j < m; j++) {
scanf("%lf", &bl[j]);
}
for (int i = 0; i < m; i++) {
scanf("%lf", &dbl[i]);
}
ans = 1e200;
int j = 0;
for (int i = 0; i < m; i++) {
while (j < n - 1 && calc(j + 1, i) < calc(j, i)) j++;
if (calc(j, i) < ans) {
ans = calc(j, i);
ansa = j;
ansb = i;
}
}
cout << ansa + 1 << " " << ansb + 1 << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto const &vv : V) os << vv << ",";
os << "]";
return os;
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
os << "(" << P.first << "," << P.second << ")";
return os;
}
template <typename T>
inline void print_128(T num) {
if (!num) return;
print_128(num / 10);
cout.put((num % 10) + '0');
}
inline int fstoi(const string &str) {
auto it = str.begin();
bool neg = 0;
int num = 0;
if (*it == '-')
neg = 1;
else
num = *it - '0';
++it;
while (it < str.end()) num = num * 10 + (*it++ - '0');
if (neg) num *= -1;
return num;
}
inline void getch(char &x) {
while (x = getchar_unlocked(), x < 33) {
;
}
}
inline void getstr(string &str) {
str.clear();
char cur;
while (cur = getchar_unlocked(), cur < 33) {
;
}
while (cur > 32) {
str += cur;
cur = getchar_unlocked();
}
}
template <typename... Args>
inline void getstr(string &str, Args &...arg) {
str.clear();
char cur;
while (cur = getchar_unlocked(), cur < 33) {
;
}
while (cur > 32) {
str += cur;
cur = getchar_unlocked();
}
getstr(arg...);
}
template <typename T>
inline bool sc(T &num) {
bool neg = 0;
int c;
num = 0;
while (c = getchar_unlocked(), c < 33) {
if (c == EOF) return false;
}
if (c == '-') {
neg = 1;
c = getchar_unlocked();
}
for (; c > 47; c = getchar_unlocked()) num = num * 10 + c - 48;
if (neg) num *= -1;
return true;
}
template <typename T, typename... Args>
inline void sc(T &num, Args &...args) {
bool neg = 0;
int c;
num = 0;
while (c = getchar_unlocked(), c < 33) {
;
}
if (c == '-') {
neg = 1;
c = getchar_unlocked();
}
for (; c > 47; c = getchar_unlocked()) num = num * 10 + c - 48;
if (neg) num *= -1;
sc(args...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
sc(t);
int n;
while (t--) {
sc(n);
bool g = 0;
for (int i = (3); i < int((13300)); ++i) {
int tmp = (i - 2) * 180;
if (tmp % i) continue;
if (tmp / i == n) {
g = 1;
break;
}
}
cout << (g ? "YES" : "NO") << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int LOGN = 20;
struct edge {
int v, id;
edge(const int& _v = 0, const int& _id = 0) {
v = _v;
id = _id;
}
};
int n;
int p[N][LOGN];
int h[N];
int dp[N];
int ans[N];
vector<edge> g[N];
void dfs_lca(int u) {
for (const edge& e : g[u]) {
int v = e.v;
if (v != p[u][0]) {
p[v][0] = u;
h[v] = h[u] + 1;
dfs_lca(v);
}
}
}
void build_lca() {
p[1][0] = 1;
h[1] = 1;
dfs_lca(1);
for (int j = 1; j < LOGN; ++j) {
for (int i = 1; i <= n; ++i) {
p[i][j] = p[p[i][j - 1]][j - 1];
}
}
}
int lca(int u, int v) {
if (h[u] > h[v]) swap(u, v);
for (int j = LOGN - 1; j >= 0; --j) {
if (h[u] <= h[p[v][j]]) {
v = p[v][j];
}
}
if (u == v) return u;
for (int j = LOGN - 1; j >= 0; --j) {
if (p[u][j] != p[v][j]) {
u = p[u][j];
v = p[v][j];
}
}
return p[u][0];
}
void dfs(int u) {
for (const edge& e : g[u]) {
int v = e.v;
if (v != p[u][0]) {
dfs(v);
dp[u] += dp[v];
ans[e.id] = dp[v];
}
}
}
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
g[u].emplace_back(edge(v, i));
g[v].emplace_back(edge(u, i));
}
build_lca();
int k;
memset(dp, 0, sizeof dp);
memset(ans, 0, sizeof ans);
for (cin >> k; k--;) {
int u, v;
cin >> u >> v;
int w = lca(u, v);
dp[u]++;
dp[v]++;
dp[w] -= 2;
}
dfs(1);
for (int i = 1; i < n; ++i) cout << ans[i] << ' ';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long MOD = 257;
int ans[100005], sg[100005], mex[100005];
void getsg(int n) {
for (int i = 2; i * (i + 1) / 2 <= n; i++) {
if ((2 * n) % i == 0) {
int t = 2 * n / i - i + 1;
if ((t & 1) || t < 0) continue;
t /= 2;
mex[sg[t - 1 + i] ^ sg[t - 1]] = n;
if ((sg[t - 1 + i] ^ sg[t - 1]) == 0)
if (ans[n] == -1) ans[n] = i;
}
}
sg[n] = -1;
for (int i = 0;; i++) {
if (mex[i] != n) {
sg[n] = i;
break;
}
}
sg[n] ^= sg[n - 1];
return;
}
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
memset(ans, -1, sizeof(ans));
for (int i = 3; i <= n; i++) {
getsg(i);
}
cout << ans[n] << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 1e9 +7;
const int LM = 2e5 + 4;
int N;
int l,r;
ll fact[LM],ifact[LM];
ll modPow(ll a, int k){
if(k==0) return 1;
ll d = modPow(a,k/2);
if(k&1) return d*d%MOD*a%MOD;
return d*d%MOD;
}
ll modInv(ll a){return modPow(a,MOD-2);}
ll C(int n, int k){
if(n<k || n<0 || k<0) return 0;
return fact[n]*ifact[k]%MOD*ifact[n-k]%MOD;
}
int main(){
fact[0] = ifact[0] = 1;
for(int i=1;i<=2e5;i++){
fact[i] = fact[i-1] * i % MOD;
ifact[i] = ifact[i-1] * modInv(i) % MOD;
}
int T;
scanf("%d",&T);
while(T--){
scanf("%d%d%d", &N,&l,&r);
ll ans = 0;
ll cnt = min(1-l, r-N);
// N/2개의 +a, N/2개의 -a로 구성
if(N&1) ans += 2*cnt * C(N, N/2) % MOD;
else ans += cnt * C(N, N/2) % MOD;
int i = 1, j = N;
ll a,b,c,d;
a = N/2, b = (N+1)/2, c = (N+1)/2, d = N/2;
while(1){
cnt++;
while(cnt > i-l) i++,a--,c--;
while(cnt > r-j) j--,b--,d--;
if(i-1>=j+1) break;
ans += C(a+b,b);
if(N&1) ans += C(c+d,d);
ans %= MOD;
}
printf("%lld\n", ans%MOD);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
bool flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return flag ? x : ~(x - 1);
}
inline void write(long long x) {
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const long long N = 1e6 + 10;
long long n, ans, a[N];
long long prime[N], mp[N], cnt;
long long stk[N], top, pre[N], w[N];
bool is_prime[N];
vector<long long> vec[N];
inline void sieve(long long x) {
for (long long i = 2; i <= x; i++) {
if (!is_prime[i]) prime[++cnt] = mp[i] = i;
for (long long j = 1; prime[j] <= x / i; j++) {
is_prime[i * prime[j]] = true;
mp[i * prime[j]] = prime[j];
if (i % prime[j] == 0) break;
}
}
}
signed main() {
sieve(1000000);
n = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) {
char ch = getchar();
while (ch != '*' && ch != '/') ch = getchar();
if (ch == '*') {
while (a[i] > 1) {
long long p = mp[a[i]];
vec[p].push_back(i);
a[i] /= p;
}
pre[i] = i;
} else {
pre[i] = i;
while (a[i] > 1) {
long long p = mp[a[i]];
if (vec[p].empty())
pre[i] = -1;
else
pre[i] = min(pre[i], vec[p].back()), vec[p].pop_back();
a[i] /= p;
}
}
}
for (long long i = n; i >= 1; i--) {
long long nw = 1;
while (top && pre[i] <= stk[top]) nw += w[top], top--;
stk[++top] = pre[i], w[top] = nw;
if (i == pre[i]) ans += nw;
}
write(ans), putchar('\n');
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long conversion(string p) {
long long o;
o = atol(p.c_str());
return o;
}
string toString(long long h) {
stringstream ss;
ss << h;
return ss.str();
}
int gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
int lcm(int a, int b) { return (a * (b / gcd(a, b))); }
int main() {
string a, b;
cin >> a >> b;
reverse(b.begin(), b.end());
long long x = conversion(a), y = conversion(b);
cout << x + y << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<string> Possible;
void GetAllPossible(int n, string Guss) {
if (Guss.size() == n) {
Possible.push_back(Guss);
} else {
GetAllPossible(n, Guss + "7");
GetAllPossible(n, Guss + "4");
}
}
string Rev(string t) {
string t1 = "";
for (int i = t.size() - 1; i >= 0; i--) t1 += t[i];
return t1;
}
string Convert(int n) {
string t = "";
string num = "0123456789";
while (n > 0) {
t += num[(n % 10)];
n /= 10;
}
return Rev(t);
}
long long GetNum(string t) {
long long Num = 0;
int k = 1;
t = Rev(t);
for (int i = 0; i < t.size(); i++, k *= 10) {
long long tem = (int(t[i] - '0'));
tem *= (long long)k;
Num += tem;
}
return Num;
}
int main() {
long long Sum = 0;
int l, r;
cin >> l >> r;
int mx = 10;
int mn = Convert(l).size();
for (int i = mx; i >= mn; i--) GetAllPossible(i, "");
vector<long long> Numbers;
for (int i = 0; i < Possible.size(); i++)
Numbers.push_back(GetNum(Possible[i]));
sort(Numbers.begin(), Numbers.end());
mx = Numbers.size();
for (int i = 0; i < mx; i++) {
int left = l, right = r, m;
int numof = 0;
while (left <= right) {
m = (left + right) / 2;
if (m == Numbers[i]) {
numof = m - l + 1;
break;
left = m + 1;
} else if (m < Numbers[i]) {
numof = m - l + 1;
left = m + 1;
} else
right = m - 1;
}
l += numof;
Sum += (long long)numof * Numbers[i];
}
cout << Sum << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, int> dist[400000];
long long sum[400000];
long long ans[400000];
int main() {
int n, k;
cin >> n;
for (int i = 1; i <= n; i++) {
long long t;
cin >> t;
dist[i] = pair<long long, int>(t, i);
}
cin >> k;
sort(dist + 1, dist + 1 + n);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + dist[i].first;
long long t = 0;
for (int i = 1; i <= k; i++) t = t + (i - 1) * dist[i].first - sum[i - 1];
long long ans = t;
int s = 1;
for (int i = k + 1; i <= n; i++) {
t = t - 2 * (sum[i - 1] - sum[i - k + 1] + dist[i - k + 1].first) +
(k - 1) * (dist[i].first + dist[i - k].first);
if (t < ans) {
s = i - k + 1;
ans = t;
}
}
for (int i = 0; i < k; i++) {
cout << dist[s + i].second << " ";
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
deque<int> st;
int net[500000];
int N, M;
int main() {
int t;
cin >> t;
while (t--) {
long long n, g, b;
cin >> n >> g >> b;
long long mn = (n + 1) / 2;
long long pr = mn / g;
long long pro = (pr) * (g + b);
pro += (mn % g == 0) ? -b : mn % g;
cout << max(n, pro) << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void setIO(const string &name = "") {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
if (name.length()) {
freopen((name + ".in").c_str(), "r", stdin);
freopen((name + ".out").c_str(), "w", stdout);
}
}
template <typename T>
void read(vector<T> &a) {
for (auto &x : a) cin >> x;
}
template <typename T>
void read(vector<T> &a, long long n) {
a.resize(n);
for (auto &x : a) cin >> x;
}
template <class T, class U>
ostream &operator<<(ostream &out, const pair<T, U> &v) {
out << "(";
out << v.first << "," << v.second;
return out << ")";
}
template <class T>
ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
for (auto(i) = 0; (i) < ((long long)(v).size()); (i)++) {
if (i) out << ", ";
out << v[i];
}
return out << "]";
}
template <typename T>
void print(vector<T> &a) {
for (const auto &x : a) cout << x << ' ';
cout << '\n';
}
void MOD(long long &x, long long m = 1000000007) {
x %= m;
if (x < 0) x += m;
}
template <typename T>
void dbg(const char *name, T &&arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename T, typename... U>
void dbg(const char *names, T &&arg1, U &&...args) {
const char *comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
dbg(comma + 1, args...);
}
template <class T>
void read(T &x) {
cin >> x;
}
template <class T, class... U>
void read(T &t, U &...u) {
read(t);
read(u...);
}
long long gcd(long long a, long long b) { return !a ? b : gcd(b % a, a); }
long long n;
vector<long long> a;
vector<long long> cnt;
void solve() {
read(n);
read(a, n);
cnt.assign(32, 0);
for (auto(i) = 0; (i) < (32); (i)++) {
for (auto(j) = 0; (j) < (n); (j)++) {
if ((1LL << i) & a[j]) {
cnt[i]++;
}
}
}
long long g = 0;
for (auto(i) = 0; (i) < (32); (i)++) {
g = gcd(cnt[i], g);
}
if (g == 0) {
for (auto(i) = 1; (i) < (n + 1); (i)++) {
cout << i << ' ';
}
cout << '\n';
return;
}
set<long long> s;
for (long long i = 1; i <= g; i++) {
if (g % i == 0) {
s.insert(i);
}
}
for (auto &(c) : (s)) {
cout << c << ' ';
}
cout << '\n';
}
int32_t main() {
setIO();
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s[25];
int n, m;
int msk[25][128], dp[21][1 << 21], arr[25][25];
int sum[25][128];
void solve() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
sum[j][s[i][j]] += arr[i][j];
msk[j][s[i][j]] |= (1 << (i));
}
}
for (int i = m; i >= 0; i--) {
for (int mask = ((1 << n) - 1); mask >= 0; mask--) {
if (i == m) {
if (mask == ((1 << n) - 1))
dp[i][mask] = 0;
else
dp[i][mask] = 100000000;
} else {
dp[i][mask] = 100000000;
for (int j = 0; j < n; j++) {
if (!(mask & (1 << j))) {
int cur = arr[j][i] + dp[i][mask | (1 << j)];
cur = min(cur, sum[i][s[j][i]] - arr[j][i] +
dp[i][mask | (msk[i][s[j][i]])]);
dp[i][mask] = min(dp[i][mask], cur);
}
}
dp[i][mask] = min(dp[i][mask], dp[i + 1][mask]);
}
}
}
cout << dp[0][0] << '\n';
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1e9 + 7;
const int maxn = 1010;
int n;
int main() {
scanf("%d", &n);
int mn = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
int a, p;
scanf("%d%d", &a, &p);
mn = min(mn, p);
ans += mn * a;
}
printf("%d\n", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
using ll = long long;
int n, a[N], f[N], pr[N];
map<int, vector<int> > pos;
map<int, int> pp;
map<int, vector<pair<int, int> > > pf;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i)
scanf("%d", &a[i]), pos[a[i]].push_back(i), pp[a[i]] = 0;
for (int i = 0; i < n; ++i) {
f[i] = 1;
pr[i] = -1;
int x = a[i] - 1;
while (pp[x] < int(pos[x].size())) {
int ps = pos[x][pp[x]];
if (ps > i) break;
if (pf[x].empty())
pf[x].push_back(make_pair(0, -1));
else
pf[x].push_back(pf[x].back());
if (f[ps] > pf[x].back().first)
pf[x][int(pf[x].size()) - 1].first = f[ps],
pf[x][int(pf[x].size()) - 1].second = ps;
if (pf[x].back().first + 1 > f[i])
f[i] = pf[x].back().first + 1, pr[i] = pf[x].back().second;
++pp[x];
}
}
int p = 0;
for (int i = 0; i < n; ++i)
if (f[i] > f[p]) p = i;
vector<int> res;
while (p != -1) {
res.push_back(p);
p = pr[p];
}
reverse(res.begin(), res.end());
printf("%d\n", int(res.size()));
for (int i : res) printf("%d ", i + 1);
printf("\n");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
ifstream in("/home/lionell/Developing/acm/codeforces/VK_Cup_2015/in.txt");
int q = 0;
cin >> q;
for (int j = 0; j < q; ++j) {
int m = 0, k = 0;
cin >> m >> k;
int *a = new int[k + 1]();
bool *empty = new bool[k + 1]();
for (int i = 1; i <= k; ++i) {
cin >> a[i];
}
int *t = new int[m - 1]();
int *r = new int[m - 1]();
for (int i = 0; i < m - 1; ++i) {
cin >> t[i] >> r[i];
}
int accumulator = 0;
int one_index = -1;
for (int i = 0; i < m - 1; ++i) {
if (r[i] == 1) {
one_index = i;
break;
}
if (t[i] != 0)
a[t[i]]--;
else
accumulator++;
}
if (one_index != -1) {
bool *used = new bool[k + 1]();
for (int i = one_index; i < m - 1; ++i) {
used[t[i]] = true;
}
for (int i = 1; i <= k; ++i) {
if (!used[i] && a[i] - accumulator <= 0) empty[i] = true;
}
int minimum = 0;
for (int i = 1; i <= k; ++i) {
if (!used[i]) {
minimum = i;
break;
}
}
for (int i = minimum; i <= k; ++i) {
if (!used[i] && a[i] < a[minimum]) minimum = i;
}
accumulator -= a[minimum];
a[minimum] = 0;
for (int i = one_index; i < m - 1; ++i) {
if (t[i] != 0)
a[t[i]]--;
else
accumulator++;
}
delete[] used;
}
for (int i = 1; i <= k; ++i) {
if (a[i] - accumulator <= 0) empty[i] = true;
cout << ((empty[i]) ? 'Y' : 'N');
}
cout << endl;
delete[] r;
delete[] t;
delete[] empty;
delete[] a;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct info {
long long val;
string name;
};
info data[100000 + 10];
int main() {
long long n, x, y;
cin >> n >> x >> y;
long long a[n + 10];
for (int i = 1; i <= n; i++) cin >> a[i];
vector<int> res;
long long cnt1 = 0, cnt2 = 0;
while (cnt1 < x || cnt2 < y) {
if ((cnt2 + 1) * x > (cnt1 + 1) * y)
res.push_back(1), cnt1++;
else if ((cnt2 + 1) * x < (cnt1 + 1) * y)
res.push_back(2), cnt2++;
else {
res.push_back(3);
res.push_back(3);
cnt1++;
cnt2++;
}
}
for (int i = 1; i <= n; i++) {
a[i]--;
int re = res[a[i] % (x + y)];
if (re == 1)
puts("Vanya");
else if (re == 2)
puts("Vova");
else
puts("Both");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < h.size(); ++i) cin >> h[i];
;
vector<int> h1(n);
for (int i = 0; i < n - 1; ++i) {
h1[i] = h[i + 1];
}
h1[n - 1] = h[0];
vector<vector<long long> > cnt(n + 1, vector<long long>(3, 0));
for (int i = 0; i < n; ++i) {
if (h1[i] != h[i]) {
cnt[i][-1 + 1] = 1;
cnt[i][1 + 1] = 1;
cnt[i][0 + 1] = k - 2;
} else
cnt[i][0 + 1] = k;
}
vector<vector<long long> > dp(n + 1, vector<long long>(2 * n + 2, 0));
dp[0][0 + n] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = -n; j <= n; ++j) {
dp[i][j + n] = (dp[i - 1][j + n] * cnt[i - 1][0 + 1] +
dp[i - 1][j - 1 + n] * cnt[i - 1][1 + 1] +
dp[i - 1][j + 1 + n] * cnt[i - 1][-1 + 1]) %
998244353;
}
}
long long sum = 0;
for (int i = 1; i <= n; ++i) {
sum = (sum + dp[n][i + n]) % 998244353;
}
cout << sum;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
if (n % 2 != 0) {
if (a[0] % 2 == 1 && a[n - 1] % 2 == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int next, now;
} d[100010];
struct node {
int r, a, p;
} peo[100010];
struct question {
int mr, l, r, p;
} que[100010];
int sum[100010], c[100010], tree[100010 * 4], pos[100010], ans[100010],
id[100010];
int n, m, k;
bool compare1(const node &x, const node &y) { return x.r < y.r; }
bool compare2(const node &x, const node &y) { return x.a < y.a; }
bool compare3(const question &x, const question &y) { return x.mr < y.mr; }
void add_value(int u, int v, int i) {
d[i].next = c[u];
c[u] = i;
d[i].now = v;
}
void build_tree(int l, int r, int i) {
if (l == r) {
pos[l] = i;
return;
}
int mid = (l + r) / 2;
build_tree(l, mid, i + i);
build_tree(mid + 1, r, i + i + 1);
}
void change(int x) {
while (x > 0) {
tree[x] += 1;
x /= 2;
}
}
int calc_sum(int tl, int tr, int l, int r, int i) {
if (l > tr || r < tl) return 0;
if (tl <= l && r <= tr) return tree[i];
int mid = (l + r) / 2;
return calc_sum(tl, tr, l, mid, i + i) +
calc_sum(tl, tr, mid + 1, r, i + i + 1);
}
void Change(int x, int s) {
while (x > 0) {
tree[x] = max(tree[x], s);
x /= 2;
}
}
int calc_max(int tl, int tr, int l, int r, int i) {
if (l > tr || r < tl) return 0;
if (tl <= l && r <= tr) return tree[i];
int mid = (l + r) / 2;
return max(calc_max(tl, tr, l, mid, i + i),
calc_max(tl, tr, mid + 1, r, i + i + 1));
}
int binary_search_up(int l, int r, int x) {
while (l <= r) {
int mid = (l + r) / 2;
if (peo[mid].a >= x)
r = mid - 1;
else
l = mid + 1;
}
return l;
}
int binary_search_down(int l, int r, int x) {
while (l <= r) {
int mid = (l + r) / 2;
if (peo[mid].a <= x)
l = mid + 1;
else
r = mid - 1;
}
return r;
}
void init() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> peo[i].r;
for (int i = 1; i <= n; i++) cin >> peo[i].a;
for (int i = 1; i <= n; i++) peo[i].p = i;
}
void solve() {
sort(peo + 1, peo + n + 1, compare1);
int t = 0;
for (int i = 1; i <= n; i++) {
if (peo[i].r != peo[i - 1].r) t++;
peo[i].r = t;
}
sort(peo + 1, peo + n + 1, compare2);
for (int i = 1; i <= n; i++) add_value(peo[i].r, i, i);
memset(tree, 0, sizeof(tree));
build_tree(1, n, 1);
for (int j = 1; j <= n; j++) {
for (int i = c[j]; i; i = d[i].next) change(pos[d[i].now]);
for (int i = c[j]; i; i = d[i].next) {
int now = peo[d[i].now].a;
int l = binary_search_up(1, d[i].now, now - k);
int r = binary_search_down(d[i].now, n, now + k);
sum[d[i].now] = calc_sum(l, r, 1, n, 1);
}
}
for (int i = 1; i <= n; i++) id[peo[i].p] = i;
cin >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
que[i].mr = max(peo[id[x]].r, peo[id[y]].r);
que[i].l = max(binary_search_up(1, id[x], peo[id[x]].a - k),
binary_search_up(1, id[y], peo[id[y]].a - k));
que[i].r = min(binary_search_down(id[x], n, peo[id[x]].a + k),
binary_search_down(id[y], n, peo[id[y]].a + k));
que[i].p = i;
}
sort(que + 1, que + m + 1, compare3);
memset(tree, 0, sizeof(tree));
int now = n + 1;
for (int j = m; j >= 1; j--) {
for (int t = que[j].mr; t <= now - 1; t++)
for (int i = c[t]; i; i = d[i].next) Change(pos[d[i].now], sum[d[i].now]);
now = que[j].mr;
ans[que[j].p] = calc_max(que[j].l, que[j].r, 1, n, 1);
}
for (int i = 1; i <= m; i++)
if (ans[i] == 0)
cout << "-1" << endl;
else
cout << ans[i] << endl;
}
int main() {
ios::sync_with_stdio(false);
init();
solve();
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const int M = 1000010;
const int mod = 1000000007;
const double eps = 1e-8;
const double Pi = 2 * acos(0.0);
char s[M];
int main() {
ios::sync_with_stdio(0);
cin >> s;
int tmp = 0, zero = 2, con = 0, single = 0;
for (int i = 0; s[i];) {
if (s[i] == '1') {
con = 0;
while (s[i + con] == '1') con++;
if (con == 1) {
tmp++;
if (zero > 1) single = 1;
} else if (zero == 1) {
tmp++;
if (single) tmp++;
single = 0;
} else {
tmp += 2;
single = 0;
}
i += con;
} else {
zero = 0;
while (s[i + zero] == '0') zero++;
i += zero;
}
}
cout << tmp << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
double ans, l, r;
int main() {
cin >> n >> r;
l = sqrt(2);
for (int i = 1; i <= n; ++i) {
ans += 2;
ans += (l + 2) * ((i > 1) + (i < n));
if (i > 2) ans += (2 * l) * (i - 2) + 1.0 * (i - 2) * (i - 1);
if (i < n - 1) ans += (2 * l) * (n - 1 - i) + 1.0 * (n - i - 1) * (n - i);
}
printf("%.11f", ans * r / n / n);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 50;
const int LOGN = 17;
vector<int> adj[MAXN];
int pa[MAXN][LOGN], level[MAXN];
int n;
void dfs(int x, int p) {
for (auto c : adj[x]) {
if (c != p) {
pa[c][0] = x;
level[c] = level[x] + 1;
dfs(c, x);
}
}
}
void findPa() {
for (int i = 1; i < LOGN; i++) {
for (int x = 1; x <= n; x++) {
pa[x][i] = pa[pa[x][i - 1]][i - 1];
}
}
}
int lca(int u, int v) {
if (level[u] > level[v]) swap(u, v);
int d = level[v] - level[u];
for (int i = 0; i < LOGN; i++) {
if (d & (1 << i)) {
v = pa[v][i];
}
}
if (u == v) return u;
for (int i = LOGN - 1; i >= 0; i--) {
if (pa[u][i] != pa[v][i]) {
u = pa[u][i];
v = pa[v][i];
}
}
return pa[u][0];
}
int dist(int u, int v) { return level[u] + level[v] - 2 * level[lca(u, v)]; }
int f(int s, int t, int f) {
int x = lca(s, f);
int y = lca(t, f);
if (x == y) {
int z = lca(s, t);
return dist(f, x) + dist(x, z) + 1;
} else {
return min(dist(x, f), dist(y, f)) + 1;
}
}
int main() {
int q;
scanf("%d%d", &n, &q);
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
adj[x].push_back(i);
adj[i].push_back(x);
}
dfs(1, -1);
findPa();
while (q--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
printf("%d\n",
((f(a, b, c)) > (f(b, c, a))
? ((f(a, b, c)) > (f(c, a, b)) ? (f(a, b, c)) : (f(c, a, b)))
: ((f(b, c, a)) > (f(c, a, b)) ? (f(b, c, a)) : (f(c, a, b)))));
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int qpow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = (long long)ret * x % 998244353;
y >>= 1;
x = (long long)x * x % 998244353;
}
return ret;
}
int C(int n, int m) {
if (m > n) return 0;
int a = 1, b = 1;
for (int i = n - m + 1; i <= n; i++) a = (long long)a * i % 998244353;
for (int i = 1; i <= m; i++) b = (long long)b * i % 998244353;
return (long long)a * qpow(b, 998244353 - 2) % 998244353;
}
int n;
int l[55], r[55], bl[55], br[55];
int f[55][55 << 1];
int main() {
scanf("%d", &n);
v.push_back(-1);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &l[i], &r[i]);
v.push_back(l[i]);
v.push_back(r[i] + 1);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (int i = 1; i <= n; i++) {
bl[i] = lower_bound(v.begin(), v.end(), l[i]) - v.begin();
br[i] = upper_bound(v.begin(), v.end(), r[i]) - v.begin() - 1;
}
for (int i = 0; i <= v.size(); i++) f[0][i] = 1;
for (int i = 1; i <= n; i++) {
for (int j = br[i]; j >= bl[i]; j--)
for (int k = i - 1; k >= 0; k--) {
(f[i][j] += (long long)f[k][j + 1] *
C(v[j + 1] - v[j] + i - k - 1, i - k) % 998244353) %=
998244353;
if (bl[k] > j || br[k] < j) break;
}
for (int j = v.size() - 1; j >= 0; j--)
(f[i][j] += f[i][j + 1]) %= 998244353;
}
int ans = f[n][0];
for (int i = 1; i <= n; i++)
ans = (long long)ans * qpow(r[i] - l[i] + 1, 998244353 - 2) % 998244353;
printf("%d\n", ans);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000 * 1000 * 1000 + 7;
const int INF = 1000 * 1000 * 1000;
const long long LINF = (long long)INF * INF;
int n, a[300100];
int cnt[300100];
vector<int> prm[300100];
int dp[1 << 7];
int c[1 << 7];
int check(int x) {
vector<int> prm = ::prm[x];
int sz = prm.size();
fill(dp, dp + (1 << 7), INF);
memset(c, 0, sizeof(c));
int full = (1 << sz) - 1;
for (int mask = (0); mask < (1 << sz); mask++) {
int val = 1;
for (int i = (0); i < (sz); i++)
if (mask >> i & 1) val *= prm[i];
c[mask] = cnt[val] - 1;
}
for (int mask = full; mask >= 0; mask--) {
int rmask = mask ^ full;
for (int rsub = rmask;; rsub = (rsub - 1) & rmask) {
int sup = full ^ rsub;
if (sup != mask) c[mask] -= c[sup];
if (!rsub) break;
}
}
dp[0] = 0;
for (int mask = (1); mask < (1 << sz); mask++) {
int rmask = full ^ mask;
for (int rsub = rmask;; rsub = (rsub - 1) & rmask) {
if (c[rsub]) dp[mask] = 1;
if (!rsub) break;
}
}
for (int mask = (1); mask < (1 << sz); mask++) {
if (dp[mask] == 1) continue;
for (int sub = mask; sub; sub = (sub - 1) & mask)
if (dp[sub] == 1 && sub != mask)
dp[mask] = min(dp[mask], dp[mask - sub] + 1);
}
return dp[full] + 1;
}
int32_t main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = (0); i < (n); i++) {
cin >> a[i];
cnt[a[i]]++;
}
for (int i = (1); i < (300100); i++)
for (int j = 2 * i; j < 300100; j += i) cnt[i] += cnt[j];
for (int i = (2); i < (300100); i++) {
if (prm[i].size()) continue;
for (int j = i; j < 300100; j += i) prm[j].push_back(i);
}
int ans = INF;
for (int i = (0); i < (n); i++) {
if (a[i] == 1) {
cout << "1\n";
return 0;
}
ans = min(ans, check(a[i]));
}
if (ans > n)
cout << "-1\n";
else
cout << ans << '\n';
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int findGCD(int arr[], int n) {
int result = arr[0];
for (int i = 1; i < n; i++) {
result = gcd(arr[i], result);
if (result == 1) {
return 1;
}
}
return result;
}
int soved(int n, int k) {
int cont(0);
int c;
int r(0);
for (int i = 0; i < n; i++) {
cin >> c;
if (c > 8) {
r += c - 8;
c = 8;
} else if (c < 8) {
c += r;
if (c > 8) {
r = c - 8;
c = 8;
} else {
r = 0;
}
}
k -= c;
cont++;
if (k == 0 || k < 0) {
return cont;
}
}
return -1;
}
int main() {
int p;
int m(0);
cin >> p;
int a, b;
int aux;
bool is = 1;
string re;
for (int i = 0; i < p; i++) {
cin >> a >> b;
if (a != b) {
re = "rated";
is = false;
} else {
if (aux >= a) {
m++;
}
aux = a;
}
}
if (is) {
if (m == p) {
cout << "maybe";
} else {
cout << "unrated";
}
} else {
cout << re << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n + 2];
int count = 0;
int j = 0;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i < n; i++) {
for (j = 0; i + (1 << j) <= n; j++)
;
arr[i + (1 << (j - 1))] += arr[i];
count += arr[i];
cout << count << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long a, b, c, d;
cin >> a >> b >> c >> d;
cout << b << " " << c << " " << c << endl;
}
}
| 0 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
inline int read() {
int x = 0, y = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') y = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return y ? -x : x;
}
template <typename T>
inline T read() {
T x = 0;
int y = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') y = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return y ? -x : x;
}
int en[205], line[205], son[205][20], pre[205], L[205], R[205], s[205],
f[2][2][2][205][505], cnt = 1, m, K;
void insert(int len, int v) {
int node = 1;
for (register int i = 1; i <= len; ++i) {
if (!son[node][s[i]]) son[node][s[i]] = ++cnt;
node = son[node][s[i]];
}
en[node] += v;
}
void build() {
int head = 0, tail = 1;
line[1] = 1;
for (register int i = 0; i < m; ++i) son[0][i] = 1;
while (head < tail) {
int node = line[++head], x;
en[node] += en[pre[node]];
for (register int i = 0; i < m; ++i) {
x = son[node][i];
if (x)
pre[x] = son[pre[node]][i], line[++tail] = x;
else
son[node][i] = son[pre[node]][i];
}
}
}
inline void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int solve(int *tp) {
int len = tp[0], ans = 0;
memset(f, 0, sizeof f);
f[len & 1][1][1][1][0] = 1;
for (register int i = len; i; --i)
for (register int j = 0; j < 2; ++j)
for (register int k = 0; k < 2; ++k)
for (register int l = 1; l <= cnt; ++l)
for (register int p = 0; p <= K; ++p) {
if (!f[i & 1][j][k][l][p]) continue;
for (register int q = j ? tp[i] : m - 1; ~q; --q)
if ((k && !q) || p + en[son[l][q]] <= K)
add(f[i & 1 ^ 1][j && q == tp[i]][k && !q]
[(k && !q) ? l : son[l][q]]
[(k && !q) ? p : p + en[son[l][q]]],
f[i & 1][j][k][l][p]);
f[i & 1][j][k][l][p] = 0;
}
for (register int i = 1; i <= cnt; ++i)
for (register int j = 0; j <= K; ++j)
add(ans, (f[0][0][0][i][j] + f[0][1][0][i][j]) % mod);
return ans;
}
signed main() {
int n = read();
m = read(), K = read(), L[0] = read();
for (register int i = 1; i <= L[0]; ++i) L[L[0] - i + 1] = read();
R[0] = read();
for (register int i = 1; i <= R[0]; ++i) R[R[0] - i + 1] = read();
while (n--) {
int len = read();
for (register int i = 1; i <= len; ++i) s[i] = read();
insert(len, read());
}
build();
int node = 1, ans, sum = 0;
for (register int i = L[0]; i; --i) node = son[node][L[i]], sum += en[node];
ans = sum <= K;
printf("%d\n", (solve(R) - solve(L) + ans + mod) % mod);
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long K(long long x, int y = 998244353 - 2) {
long long t = 1;
for (; y; y >>= 1, x = x * x % 998244353)
if (y & 1) t = t * x % 998244353;
return t;
}
long long n, x, y, p, np, f[2020][2020], g[2020], h[2020];
void U(long long &x, long long y) { x = (x + y) % 998244353; }
int main() {
cin >> n >> x >> y;
p = x * K(y) % 998244353;
np = (998244353 + 1 - p) % 998244353;
f[1][0] = f[1][1] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= i; ++j) {
U(f[i + 1][j], f[i][j] * K(p, j));
U(f[i + 1][j + 1], f[i][j] * K(np, i - j));
}
}
for (int i = 1; i <= n; ++i) {
g[i] = 1;
for (int j = 1; j < i; ++j) U(g[i], 998244353 - f[i][j] * g[j] % 998244353);
}
for (int i = 2; i <= n; ++i) {
for (int j = 1; j < i; ++j)
U(h[i], f[i][j] * g[j] % 998244353 *
(j * (j - 1) / 2 + j * (i - j) + h[j] + h[i - j]) %
998244353);
h[i] = (h[i] + g[i] * i * (i - 1) / 2) % 998244353 *
K(998244353 + 1 - g[i]) % 998244353;
}
cout << h[n] << endl;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
void solve() {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 != x2 && y1 != y2 && abs(x1 - x2) != abs(y1 - y2))
cout << -1 << "\n";
else if (x1 == x2)
cout << x1 + abs(y1 - y2) << " " << y1 << " " << x2 + abs(y1 - y2) << " "
<< y2 << "\n";
else if (y1 == y2)
cout << x1 << " " << y1 + abs(x1 - x2) << " " << x2 << " "
<< y2 + abs(x1 - x2) << "\n";
else
cout << x1 << " " << y2 << " " << x2 << " " << y1 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
const int INF = 1000000000;
const int MAX = 5007;
const int MAX2 = 7000;
const int BASE = 1000000000;
int n;
string S;
int B[26][MAX][26];
int C[26][MAX];
int W[26];
int main() {
cin >> S;
n = (int)S.size();
for (int i = (0); i < (n); ++i) {
int a = S[i] - 'a';
++W[a];
for (int j = (0); j < (n); ++j) {
int p = i + j;
while (p >= n) p -= n;
int b = S[p] - 'a';
if (B[a][j][b] == 0)
++C[a][j];
else if (B[a][j][b] == 1)
--C[a][j];
++B[a][j][b];
}
}
double res = 0;
for (int i = (0); i < (26); ++i) {
if (W[i] == 0) continue;
double p = 1.0 * W[i] / n;
int mx = 0;
for (int j = (0); j < (n); ++j) mx = max(mx, C[i][j]);
res += p * mx / W[i];
}
printf("%0.11f\n", res);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int f(int x) {
int i, j, res = 0;
for (i = j = 1; i <= x; i *= 2, j *= 10)
;
for (i /= 2, j /= 10; i; i /= 2, j /= 10) res += x / i % 2 * j;
return res;
}
int main() {
int i, n;
scanf("%d", &n);
for (i = 1; f(i) <= n; i++)
;
printf("%d", i - 1);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, k = 0;
cin >> n;
long long ar[n];
for (i = 0; i < n; i++) cin >> ar[i];
long long one[n + 1], two[n], dp[n][n];
for (i = 0; i < n; i++) {
one[i] = two[i] = 0;
}
for (i = 1; i < n; i++) {
if (ar[i - 1] == 1)
one[i] = one[i - 1] + 1;
else
one[i] = one[i - 1];
}
if (ar[n - 1] == 1)
one[n] = one[n - 1] + 1;
else
one[n] = one[n - 1];
for (i = n - 2; i >= 0; i--) {
if (ar[i + 1] == 2)
two[i] = two[i + 1] + 1;
else
two[i] = two[i + 1];
}
for (i = 0; i < n; i++) dp[i][i] = 1;
for (j = n - 1; j > 0; j--) {
for (i = j - 1; i >= 0; i--) {
dp[i][j] = dp[i + 1][j];
if (ar[i] == 2 || dp[i + 1][j] == one[j + 1] - one[i + 1])
dp[i][j] = dp[i + 1][j] + 1;
}
}
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
k = fmax(k, one[i] + two[j] + dp[i][j]);
}
}
cout << k;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n;
cin >> n;
long int m = n;
long int count = 1;
m = n / 2;
count = m * 3;
cout << count << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma optimize("Ofast")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
using namespace std;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline int read() {
int r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
int N, M;
int ansx, ansy;
int a[2005][2005], change[2005][2005];
int f1[2005 * 2005], f2[2005 * 2005];
inline void renew(int x, int y, int d, int i) {
int yy = i % (M + 2), xx = i / (M + 2);
if (xx > 0 && xx <= N && yy > 0 && yy <= M &&
abs(xx - x) + abs(yy - y) <= d) {
if (ansx == -1 || xx < ansx || (xx == ansx && yy < ansy))
ansx = xx, ansy = yy;
}
}
inline int findset1(int x) { return x == f1[x] ? x : f1[x] = findset1(f1[x]); }
inline int findset2(int x) { return x == f2[x] ? x : f2[x] = findset2(f2[x]); }
inline bool check(int x, int y, int d) {
int x0, y0;
ansx = ansy = -1;
x0 = max(1, x - d), y0 = x - x0 + y - d;
if (y0 > 0) renew(x, y, d, findset1(change[x0][y0]));
x0 = max(1, x - d), y0 = d - (x - x0 - y);
if (y0 <= M) renew(x, y, d, findset2(change[x0][y0]));
if (ansx > 0) {
printf("%d %d\n", ansx, ansy);
f1[change[ansx][ansy]] = change[ansx + 1][ansy - 1];
f2[change[ansx][ansy]] = change[ansx + 1][ansy + 1];
return 1;
}
y0 = max(y - d, 1), x0 = d - (-x + y - y0);
if (x0 <= N) renew(x, y, d, findset2(change[x0][y0]));
y0 = min(y + d, M), x0 = d - (-x + y0 - y);
if (x0 <= N) renew(x, y, d, findset1(change[x0][y0]));
if (ansx > 0) {
printf("%d %d\n", ansx, ansy);
f1[change[ansx][ansy]] = change[ansx + 1][ansy - 1];
f2[change[ansx][ansy]] = change[ansx + 1][ansy + 1];
return 1;
}
return 0;
}
int main() {
N = read();
M = read();
for (int i = 0; i < (N + 2) * (M + 2); ++i) f1[i] = f2[i] = i;
for (int i = 0; i <= N + 1; ++i)
for (int j = 0; j <= M + 1; ++j) change[i][j] = i * (M + 2) + j;
int Q = read();
while (Q--) {
int x = read(), y = read(), d = a[x][y];
d = max(d, a[x - 1][y] - 1), d = max(d, a[x + 1][y] - 1);
d = max(d, a[x][y - 1] - 1), d = max(d, a[x][y + 1] - 1);
d = max(d, a[x - 1][y - 1] - 2), d = max(d, a[x - 1][y + 1] - 2);
d = max(d, a[x + 1][y - 1] - 2), d = max(d, a[x + 1][y + 1] - 2);
while (!check(x, y, d)) ++d;
a[x][y] = d;
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int a, b;
cin >> a >> b;
long long int x, ans;
x = min(a, b);
ans = (a ^ x) + (b ^ x);
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, i;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
if (x <= 7)
cout << "1\n";
else if (x % 7 == 0) {
cout << x / 7 << endl;
} else
cout << x / 7 + 1 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const double PI = acos(-1);
double sq(double x) { return x * x; }
long long sq(long long x) { return x * x; }
int sign(long long x) { return x < 0 ? -1 : x > 0 ? 1 : 0; }
int sign(int x) { return x < 0 ? -1 : x > 0 ? 1 : 0; }
double sign(double x) { return abs(x) < EPS ? 0 : x < 0 ? -1 : 1; }
pair<int, int> operator+(const pair<int, int> &l, const pair<int, int> &r) {
return pair<int, int>(l.first + r.first, l.second + r.second);
}
pair<int, int> operator-(const pair<int, int> &l, const pair<int, int> &r) {
return pair<int, int>(l.first - r.first, l.second - r.second);
}
long long operator^(const pair<int, int> &l, const pair<int, int> &r) {
return (long long)l.first * r.second - (long long)l.second * r.first;
}
long long operator/(const pair<int, int> &l, const pair<int, int> &r) {
return (long long)l.first * r.second - (long long)l.second * r.first;
}
long long operator*(const pair<int, int> &l, const pair<int, int> &r) {
return (long long)l.first * r.first + (long long)l.second * r.second;
}
pair<int, int> operator*(const pair<int, int> &l, const int &r) {
return pair<int, int>(l.first * r, l.second * r);
}
pair<int, int> operator-(const pair<int, int> &l) {
return pair<int, int>(-l.first, -l.second);
}
pair<double, double> operator+(const pair<double, double> &l,
const pair<double, double> &r) {
return pair<double, double>(l.first + r.first, l.second + r.second);
}
pair<double, double> operator-(const pair<double, double> &l,
const pair<double, double> &r) {
return pair<double, double>(l.first - r.first, l.second - r.second);
}
double operator^(const pair<double, double> &l, const pair<double, double> &r) {
return l.first * r.second - l.second * r.first;
}
double operator/(const pair<double, double> &l, const pair<double, double> &r) {
return l.first * r.second - l.second * r.first;
}
double operator*(const pair<double, double> &l, const pair<double, double> &r) {
return l.first * r.first + l.second * r.second;
}
pair<double, double> operator*(const pair<double, double> &l, const double &r) {
return pair<double, double>(l.first * r, l.second * r);
}
pair<double, double> operator-(const pair<double, double> &l) {
return pair<double, double>(-l.first, -l.second);
}
double size(pair<double, double> x) { return hypot(x.first, x.second); }
double size2(pair<double, double> x) { return sq(x.first) + sq(x.second); }
long long size2(pair<int, int> x) {
return sq((long long)x.first) + sq((long long)x.second);
}
double polar(pair<double, double> x) { return atan2(x.second, x.first); }
pair<double, double> unit(double a) {
return pair<double, double>(cos(a), sin(a));
}
pair<double, double> norm(pair<double, double> a) {
return a * (1.0 / size(a));
}
pair<double, double> rotate(pair<double, double> v, double a) {
return unit(a) * v.first + unit(a + PI / 2) * v.second;
}
pair<double, double> r90(pair<double, double> v) {
return pair<double, double>(-v.second, v.first);
}
void normalize(double &a) {
while (a < 0) a += 2 * PI;
while (a >= 2 * PI) a -= 2 * PI;
}
struct circle {
circle(pair<double, double> O, double r) : O(O), r(r) {}
circle() {}
pair<double, double> O;
double r;
};
int tangent(circle &A, circle &B, pair<double, double> des[4]) {
int top = 0;
double d = size(A.O - B.O), a = polar(B.O - A.O), b = PI + a;
double t = sq(d) - sq(A.r - B.r);
if (t >= 0) {
t = sqrt(t);
double p = atan2(B.r - A.r, t);
des[top++] = pair<double, double>(a + p + PI / 2, b + p - PI / 2);
des[top++] = pair<double, double>(a - p - PI / 2, b - p + PI / 2);
}
t = sq(d) - sq(A.r + B.r);
if (t >= 0) {
t = sqrt(t);
double p = atan2(B.r + A.r, t);
des[top++] = pair<double, double>(a + p - PI / 2, b + p - PI / 2);
des[top++] = pair<double, double>(a - p + PI / 2, b - p + PI / 2);
}
return top;
}
int intersect(circle &A, circle &B, pair<double, double> des[2]) {
double d = size(A.O - B.O), t = (sq(A.r) + sq(d) - sq(B.r)) / 2 / A.r / d,
u = (sq(B.r) + sq(d) - sq(A.r)) / 2 / B.r / d;
if (abs(d) < EPS) return 0;
if (1 - t * t < 0 || 1 - u * u < 0) return 0;
double a = atan2(sqrt(1 - t * t), t), b = atan2(sqrt(1 - u * u), u),
p = polar(B.O - A.O), q = PI + p;
des[0] = pair<double, double>(p + a, q - b);
des[1] = pair<double, double>(p - a, q + b);
return 2;
}
int intersect(circle A, pair<double, double> s, pair<double, double> d,
pair<double, double> des[2]) {
double c = size2(A.O - s) - sq(A.r), b = d * (s - A.O), a = size2(d);
if (b * b - a * c < 0) return 0;
des[0].second = (-b - sqrt(b * b - a * c)) / a;
des[1].second = (-b + sqrt(b * b - a * c)) / a;
des[0].first = polar(s + d * des[0].second - A.O);
des[1].first = polar(s + d * des[1].second - A.O);
return 2;
}
int intersect(pair<double, double> a, pair<double, double> b,
pair<double, double> u, pair<double, double> v,
pair<double, double> &des) {
if (abs(b ^ v) < EPS) return 0;
des = pair<double, double>(((a - u) ^ v) / (v ^ b), ((a - u) ^ b) / (v ^ b));
return 1;
}
double dist(const pair<double, double> &A, const pair<double, double> &p,
const pair<double, double> &d) {
if (size(A - p) <= EPS)
return 0;
else if (size(d) <= EPS)
return size(A - p);
double sina = ((A - p) ^ d) / size(A - p) / size(d);
double cosa = ((A - p) * d) / size(A - p) / size(d);
double r = abs(size(A - p) * sina), e = size(A - p) * cosa;
if (0 < e && e < size(d))
;
else
r = min(size(A - p), size(A - p - d));
return r;
}
int get_circle(pair<double, double> a, pair<double, double> b, double R,
circle des[2]) {
pair<double, double> m = (a + b) * 0.5, t = (b - a);
double d = (R * R - size2(m - a));
if (d < 0) return 0;
d = sqrt(d);
pair<double, double> p = norm(pair<double, double>(t.second, -t.first));
des[0] = circle(m + p * d, R);
des[1] = circle(m - p * d, R);
return 2;
}
int get_circle(pair<double, double> p0, pair<double, double> p1,
pair<double, double> p2, circle &des) {
pair<double, double> a = (p0 + p1) * 0.5, b = r90(p0 - p1);
pair<double, double> u = (p0 + p2) * 0.5, v = r90(p0 - p2), R;
if (!intersect(a, b, u, v, R)) return 0;
des = circle(a + b * R.first, size(a + b * R.first - p0));
return 1;
}
struct v3 {
double x, y, z;
v3() {}
v3(double x, double y, double z) : x(x), y(y), z(z) {}
v3 operator-() const { return v3(-x, -y, -z); }
v3 operator-(const v3 &l) const { return v3(x - l.x, y - l.y, z - l.z); }
v3 operator+(const v3 &l) const { return v3(x + l.x, y + l.y, z + l.z); }
v3 operator*(const double c) const { return v3(x * c, y * c, z * c); }
double operator*(const v3 &l) const { return x * l.x + y * l.y + z * l.z; }
v3 operator^(const v3 &l) const {
return v3(y * l.z - z * l.y, z * l.x - x * l.z, x * l.y - y * l.x);
}
double size() { return sqrt(sq(x) + sq(y) + sq(z)); }
double size2() { return sq(x) + sq(y) + sq(z); }
v3 norm() {
double p = size();
return v3(x / p, y / p, z / p);
}
void print() { printf("%lf %lf %lf\n", x, y, z); }
bool operator<(const v3 &l) const {
if (abs(x - l.x) >= EPS) return x < l.x;
if (abs(y - l.y) >= EPS) return y < l.y;
if (abs(z - l.z) >= EPS) return z < l.z;
return false;
}
bool operator==(const v3 &l) const {
return abs(x - l.x) < EPS && abs(y - l.y) < EPS && abs(z - l.z) < EPS;
}
};
struct Quad {
double a;
v3 v;
Quad(double a, v3 v) : a(a), v(v) {}
Quad operator*(const double &c) const { return Quad(a * c, v * c); }
Quad operator~() const { return Quad(-a, -v); }
Quad operator-() const {
return Quad(a, -v) * (1 / (sq(a) + sq(v.x) + sq(v.y) + sq(v.z)));
}
Quad operator*(const Quad &l) const {
return Quad(a * l.a - v * l.v, l.v * a + v * l.a + (v ^ l.v));
}
v3 apply(v3 p) { return ((*this) * Quad(0, p) * -(*this)).v; }
};
double size(v3 a) { return a.size(); }
double size2(v3 a) { return a.size2(); }
v3 norm(v3 a) { return a.norm(); }
v3 unit(double a, double b) {
return v3(cos(a) * cos(b), sin(a) * cos(b), sin(b));
}
Quad set_rotate(v3 axis, double a) {
return Quad(cos(a / 2), axis.norm() * sin(a / 2));
}
struct sphere {
sphere(v3 O, double r) : O(O), r(r) {}
v3 O;
double r;
};
int intersect(sphere A, v3 s, v3 d, double des[2]) {
double c = (A.O - s).size2() - sq(A.r), b = d * (s - A.O), a = d.size2();
if (b * b - a * c < 0) return 0;
des[0] = (-b + sqrt(b * b - a * c)) / a;
des[1] = (-b - sqrt(b * b - a * c)) / a;
return 2;
}
int intersect(v3 u, v3 v, v3 p, v3 q, v3 &s, v3 &d) {
if (abs(v * q - 1) < EPS) return 0;
d = v ^ q;
double t = v * q;
s = v * ((u * v - p * q * t) / (1 - t * t)) +
q * ((u * v * t - p * q) * 1.0 / (t * t - 1));
return 1;
}
int intersect(v3 u, v3 v, v3 p, v3 q, v3 &s) {
if (abs(q * v) <= EPS) return 0;
s = p + q * (((p - u) * v) / (q * v));
printf("%.10lf\n", (u - s) * v);
return 1;
}
bool isintersect(pair<double, double> &a, pair<double, double> &b,
pair<double, double> &u, pair<double, double> &v) {
if ((((u - a) ^ (b - a)) < 0) ^ (((v - a) ^ (b - a)) < 0))
;
else
return false;
if ((((a - u) ^ (v - u)) < 0) ^ (((b - u) ^ (v - u)) < 0))
return true;
else
return false;
}
double area(circle C, double s, double e) {
double p = C.O.first, q = C.O.second, r = C.r;
return (p * r * (sin(e) - sin(s)) + q * r * (cos(s) - cos(e)) +
r * r * (e - s)) *
0.5;
}
template <typename T>
void convex_hull(vector<T> &L, vector<T> &R) {
int mn = 0;
for (int i = 1; i < L.size(); i++) {
if (L[mn] < L[i]) mn = i;
}
swap(L[mn], L[0]);
T t = L[0];
for (int i = 1; i < L.size(); i++) L[i] = L[i] - L[0];
L[0] = T(0, 0);
sort(L.begin() + 1, L.end(), [](T l, T r) {
if (sign(l ^ r) != 0) return sign(l ^ r) < 0;
return size(l) < size(r);
});
for (T c : L) {
while (R.size() >= 2 &&
sign((R[R.size() - 2] - R.back()) ^ (c - R.back())) <= 0)
R.pop_back();
R.push_back(c);
}
for (T &c : R) c = c + t;
}
double area(pair<double, double> A[4], pair<double, double> B[4]) {
vector<pair<double, double>> L;
for (int i = 0; i < 3; i++) L.push_back(A[i]);
for (int i = 0; i < 3; i++) L.push_back(B[i]);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
pair<double, double> R;
if (!intersect(A[i], A[i + 1] - A[i], B[j], B[j + 1] - B[j], R)) continue;
if (R.first < -EPS || R.first > 1 + EPS || R.second < -EPS ||
R.second > 1 + EPS)
continue;
L.push_back(A[i] + (A[i + 1] - A[i]) * R.first);
}
}
vector<pair<double, double>> tmp;
swap(tmp, L);
for (pair<double, double> c : tmp) {
bool ch = 1;
for (int i = 0; ch && i < 3; i++) {
if (((A[i + 1] - A[i]) ^ (c - A[i])) > EPS) ch = 0;
}
for (int i = 0; ch && i < 3; i++) {
if (((B[i + 1] - B[i]) ^ (c - B[i])) > EPS) ch = 0;
}
if (ch) L.push_back(c);
}
if (L.size() == 0) return 0;
sort(L.begin(), L.end());
L.resize(unique(L.begin(), L.end()) - L.begin());
vector<pair<double, double>> R;
convex_hull(L, R);
double ans = 0;
R.push_back(R[0]);
for (int i = 0; i + 1 < R.size(); i++) ans += R[i + 1] ^ R[i];
return ans;
}
circle make_circle(vector<pair<double, double>> Q) {
if (Q.size() == 0) return circle(pair<double, double>(0, 0), 0);
if (Q.size() == 1) return circle(Q[0], 0);
circle res;
for (int i = 0; i < Q.size(); i++) {
swap(Q.back(), Q[i]);
res = circle((Q[0] + Q[1]) * 0.5, size(Q[0] - Q[1]) / 2);
bool ch = 1;
for (pair<double, double> c : Q)
if (size2(c - res.O) > sq(res.r) + EPS) ch = 0;
if (ch) return res;
swap(Q.back(), Q[i]);
}
get_circle(Q[0], Q[1], Q[2], res);
return res;
}
circle smallest_circle(vector<pair<double, double>> &P,
vector<pair<double, double>> &Q, int N) {
circle c = make_circle(Q);
if (N == 0 || Q.size() >= 3) return c;
for (int i = 0; i < N; i++) {
if (size2(c.O - P[i]) > sq(c.r)) {
Q.push_back(P[i]);
c = smallest_circle(P, Q, i);
Q.pop_back();
}
}
return c;
}
void convex_hull(vector<v3> &L, vector<v3> &R, vector<v3> &O, vector<v3> &D,
vector<v3> &X) {
int N = L.size();
static bool chk[1005][1005];
static bool in[1005];
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) chk[i][j] = 0, in[i] = 0;
int q1 = 0, q2 = 1;
queue<pair<int, int>> Q;
vector<pair<pair<int, int>, int>> F;
for (int i = 1; i < N; i++)
if (L[i].z < L[q1].z) q1 = i, q2 = 0;
for (int i = 0; i < N; i++) {
if (i == q1) continue;
if ((norm(L[i] - L[q1]) * v3(0, 0, 1)) <
(norm(L[q2] - L[q1]) * v3(0, 0, 1)))
q2 = i;
}
Q.push(pair<int, int>(q1, q2));
chk[q1][q2] = 1;
while (Q.size()) {
pair<int, int> f = Q.front();
Q.pop();
int a = f.first, b = f.second, c = -1;
in[a] = in[b] = 1;
for (int i = 0; i < N; i++) {
if (i == a || i == b) continue;
if (c == -1 || ((L[i] - L[a]) ^ (L[c] - L[a])) * (L[b] - L[a]) < 0) c = i;
}
if (!chk[c][b]) Q.push(pair<int, int>(c, b)), chk[c][b] = 1;
if (!chk[a][c]) Q.push(pair<int, int>(a, c)), chk[a][c] = 1;
if (a > b) swap(a, b);
if (b > c) swap(b, c);
if (a > b) swap(a, b);
F.emplace_back(pair<int, int>(a, b), c);
}
sort(F.begin(), F.end());
F.resize(unique(F.begin(), F.end()) - F.begin());
for (auto f : F) {
int a = f.first.first, b = f.first.second, c = f.second;
O.push_back(L[a]);
X.push_back(norm(L[a] - L[b]));
D.push_back(norm((L[a] - L[b]) ^ (L[c] - L[b])));
}
for (int i = 0; i < N; i++)
if (in[i]) R.push_back(L[i]);
}
int convex_tangent(vector<pair<int, int>> &C, pair<int, int> P, int up = 1) {
auto sign = [&](long long c) { return c > 0 ? up : c == 0 ? 0 : -up; };
auto local = [&](pair<int, int> P, pair<int, int> a, pair<int, int> b,
pair<int, int> c) {
return sign((a - P) ^ (b - P)) <= 0 && sign((b - P) ^ (c - P)) >= 0;
};
assert(C.size() >= 2);
int N = C.size() - 1, s = 0, e = N, m;
if (local(P, C[1], C[0], C[N - 1])) return 0;
while (s + 1 < e) {
m = (s + e) / 2;
if (local(P, C[m - 1], C[m], C[m + 1])) return m;
if (sign((C[s] - P) ^ (C[s + 1] - P)) < 0) {
if (sign((C[m] - P) ^ (C[m + 1] - P)) > 0)
e = m;
else if (sign((C[m] - P) ^ (C[s] - P)) > 0)
s = m;
else
e = m;
} else {
if (sign((C[m] - P) ^ (C[m + 1] - P)) < 0)
s = m;
else if (sign((C[m] - P) ^ (C[s] - P)) < 0)
s = m;
else
e = m;
}
}
if (s && local(P, C[s - 1], C[s], C[s + 1])) return s;
if (e != N && local(P, C[e - 1], C[e], C[e + 1])) return e;
return -1;
}
int cmp_flag = 0, cmp_lo = 0;
struct Convex {
struct line {
line(pair<int, int> x) {
if (!cmp_flag)
s = x;
else
d = x;
}
line(pair<int, int> s, pair<int, int> d) : s(s), d(d) {}
pair<int, int> s, d;
bool operator<(const line &l) const {
if (!cmp_flag) return s < l.s;
return cmp_lo ? d / l.d > 0 : d / l.d < 0;
}
};
int lo;
set<line> C;
void add(pair<int, int> p) {
cmp_flag = 0;
auto pos = [&](long long x) { return lo ? x >= 0 : x <= 0; };
auto neg = [&](long long x) { return lo ? x <= 0 : x >= 0; };
auto e = C.upper_bound(line(p)), d = e;
if (e != C.end() && d != C.begin()) {
d--;
if (pos((e->s - d->s) / (p - d->s))) return;
}
if (lo && e == C.end() && C.size() && C.rbegin()->s.first == p.first)
return;
if (!lo && e == C.begin() && C.size() && e->s.first == p.first) return;
while (1) {
d = C.upper_bound(line(p)), e = d;
if (d == C.end() || ++e == C.end()) break;
if (neg((d->s - p) / (e->s - p)))
C.erase(d);
else
break;
}
while (1) {
d = C.upper_bound(line(p)), e = d;
if (d == C.begin() || --e == C.begin()) break;
d = e;
--e;
if (pos((d->s - p) / (e->s - p)))
C.erase(d);
else
break;
}
if (lo && C.size() && C.rbegin()->s.first == p.first) C.erase(--C.end());
if (!lo && C.size() && C.begin()->s.first == p.first) C.erase(C.begin());
d = C.upper_bound(line(p));
if (d != C.begin()) {
e = prev(d);
line t = line(e->s, p - e->s);
C.erase(e);
C.insert(t);
}
if (d == C.end())
C.insert(line(p, pair<int, int>(0, lo ? 1 : -1)));
else
C.insert(line(p, d->s - p));
}
long long get_mn(pair<int, int> m) {
cmp_flag = 1;
cmp_lo = lo;
auto d = C.lower_bound(m);
return (long long)d->s.first * -m.second + (long long)d->s.second * m.first;
}
};
namespace halfplane_intersection {
const int INF = 1e9;
struct line {
line(pair<int, int> u, pair<int, int> v) : u(u), v(v) {}
pair<int, int> u, v;
};
double C(line A, line B) {
return B.v / A.v == 0 ? 1e18 : ((A.u - B.u) / B.v) / (double)(B.v / A.v);
}
bool V(line A, line B, double cur) {
double l = (cur - A.u.first) / A.v.first * A.v.second + A.u.second;
double r = (cur - B.u.first) / B.v.first * B.v.second + B.u.second;
return l >= r;
}
pair<double, double> W(line A, line B) {
return (pair<double, double>)A.v * C(A, B) + (pair<double, double>)A.u;
}
void chain(vector<line> &X, int l, int r, int up) {
vector<line> R;
sort(X.begin(), X.end(), [&](line l, line r) { return l.v / r.v * up < 0; });
R.emplace_back(pair<int, int>(l, 0), pair<int, int>(0, up));
X.emplace_back(pair<int, int>(r, 0), pair<int, int>(0, -up));
for (line c : X) {
while (R.size() >= 2 &&
C(R[R.size() - 2], R.back()) >= C(R[R.size() - 2], c))
R.pop_back();
R.push_back(c);
}
swap(R, X);
X.pop_back();
X.erase(X.begin());
}
int reduce(vector<line> &X, vector<line> &Y, double &cur, int left) {
while (X.size() && Y.size()) {
if (V(X.back(), Y.back(), cur)) break;
if (X.back().v / Y.back().v * left >= 0) return 0;
cur = W(X.back(), Y.back()).first;
int ch = 0;
while (X.size() >= 2 && !V(X[X.size() - 2], X.back(), cur))
X.pop_back(), ch = 1;
while (Y.size() >= 2 && V(Y[Y.size() - 2], Y.back(), cur))
Y.pop_back(), ch = 1;
if (!ch) break;
}
return 1;
}
int run(vector<pair<int, int>> &U, vector<pair<int, int>> &V,
vector<pair<double, double>> &R, int l = -INF, int r = INF,
int u = -INF, int d = INF) {
U.emplace_back(0, u);
V.emplace_back(1, 0);
U.emplace_back(0, d);
V.emplace_back(-1, 0);
vector<line> X, Y;
int N = V.size();
for (int i = 0; i < N; i++) {
if (V[i].first == 0) {
if (V[i].second > 0)
r = min(r, U[i].first);
else
l = max(l, U[i].first);
} else if (V[i].first < 0)
X.emplace_back(U[i], -V[i]);
else
Y.emplace_back(U[i], V[i]);
}
chain(X, l, r, 1);
chain(Y, l, r, -1);
double left = l, right = r;
auto rv = [](vector<line> &t) { reverse(t.begin(), t.end()); };
if (!reduce(X, Y, right, -1)) return 0;
rv(X), rv(Y);
reduce(X, Y, left, 1);
rv(Y);
vector<line> L;
if (left == l) L.emplace_back(pair<int, int>(l, 0), pair<int, int>(0, 1));
for (line c : Y) L.push_back(c);
if (right == r) L.emplace_back(pair<int, int>(r, 0), pair<int, int>(0, -1));
for (line c : X) L.push_back(c);
for (int i = 0; i + 1 < L.size(); i++) R.push_back(W(L[i], L[i + 1]));
R.push_back(W(L.back(), L[0]));
R.resize(unique(R.begin(), R.end()) - R.begin());
return 1;
}
}; // namespace halfplane_intersection
double area(pair<double, double> A, pair<double, double> B, double R) {
auto helper = [](pair<double, double> A, pair<double, double> B, double R) {
return R * R * atan2(A ^ B, A * B) / 2;
};
auto is_valid = [](double x) { return 0 <= x && x <= 1; };
double ans = 0, rv = 1;
pair<double, double> C, D, res[2];
if (size2(A) > size2(B)) swap(A, B), rv = -1;
if (size2(B) <= R * R)
ans = (A ^ B) / 2;
else if (size2(A) <= R * R) {
if (!intersect(circle(pair<double, double>(0, 0), R), A, B - A, res))
ans = (A ^ B) / 2;
else
C = A +
(B - A) * (is_valid(res[1].second) ? res[1].second : res[0].second),
ans = (A ^ C) / 2 + helper(C, B, R);
} else {
if (!intersect(circle(pair<double, double>(0, 0), R), A, B - A, res) ||
res[0].second < 0 && res[1].second < 0 ||
res[0].second > 1 && res[1].second > 1)
ans = helper(A, B, R);
else
C = A + (B - A) * res[0].second, D = A + (B - A) * res[1].second,
ans = helper(A, C, R) + (C ^ D) / 2 + helper(D, B, R);
}
return ans * rv;
}
const int MX = 400005;
pair<int, int> D[MX];
int sign(pair<int, int> x) { return x < pair<int, int>(0, 0) ? 1 : 0; }
auto cmp = [](pair<int, int> x, pair<int, int> y) {
return sign(x) != sign(y) ? sign(x) < sign(y) : x / y < 0;
};
const int L = 1000000;
double solve(pair<int, int> *D, int N, pair<int, int> O) {
sort(D + 1, D + N + 1, cmp);
for (int i = 1; i <= N; i++) D[N + i] = D[i];
vector<pair<int, int>> U, V;
for (int i = 1; i <= N; i++) {
if (D[i] / D[i + 1] < 0)
U.push_back(D[i + 1]), V.push_back(D[i] - D[i + 1]);
else if (D[i] / D[i + 1] == 0)
return 0;
else
U.push_back(D[i]), V.push_back(D[i + 1] - D[i]);
}
for (int l = 1, r = 1; l <= N; l++) {
while (r <= l || r < N + l && D[r] / D[l] > 0) r++;
if (r != N + l && D[r] / D[l] == 0) return 0;
if (r - 1 != l) {
U.push_back(D[r - 1]), V.push_back(D[l] - D[r - 1]);
}
}
vector<pair<double, double>> R;
if (!halfplane_intersection::run(U, V, R, -L - O.first, L - O.first,
-L - O.second, L - O.second))
return 0;
double ans = R.back() / R[0];
for (int i = 0; i + 1 < R.size(); i++) ans += R[i] / R[i + 1];
return ans / 2;
}
int main() {
int TC;
scanf("%d", &TC);
for (int tt = 1; tt <= TC; tt++) {
int N;
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d%d", &D[i].first, &D[i].second);
for (int i = 2; i <= N; i++) D[i] = D[i] - D[1];
double ans = solve(D + 1, N - 1, D[1]);
printf("%.10lf\n", ans);
}
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100100;
struct data {
int i, w, isin;
data(int a = 0, int b = 0, int c = 0) { i = a, w = b, isin = c; }
bool operator<(const data &d) const {
if (w == d.w) return isin > d.isin;
return w < d.w;
}
};
vector<data> A;
int cur[M];
pair<int, int> edge[M];
int main() {
int i, j, k, n, m, tempn = 1, l;
for (i = 0; i < M; i++) cur[i] = i + 2;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &j, &k);
A.push_back(data(i, j, k));
}
sort((A).begin(), (A).end());
int working = 1;
for (i = 0; i < A.size(); i++) {
if (A[i].isin == 1) {
tempn++;
if (tempn > n) {
printf("%s\n", "-1");
return 0;
};
edge[A[i].i] =
make_pair((((tempn - 1) < (tempn)) ? (tempn - 1) : (tempn)),
(((tempn - 1) > (tempn)) ? (tempn - 1) : (tempn)));
working = 1;
} else {
if (working >= tempn - 1) {
printf("%s\n", "-1");
return 0;
};
edge[A[i].i] = make_pair(
(((working) < (cur[working])) ? (working) : (cur[working])),
(((working) > (cur[working])) ? (working) : (cur[working])));
cur[working]++;
if (cur[working] > tempn) working++;
}
}
if (tempn != n) {
printf("%s\n", "-1");
return 0;
};
for (i = 0; i < m; i++) printf("%d %d\n", edge[i].first, edge[i].second);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int N, M;
string S[1001];
int label[1001][1001];
int sticker = 1;
int siz[1000001];
int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
void dfs(int x, int y) {
if (x < 0 || x >= N || y < 0 || y >= M || label[x][y] != 0 || S[x][y] == '*')
return;
label[x][y] = sticker;
siz[sticker]++;
for (int i = 0; i < 4; i++) dfs(x + dir[i][0], y + dir[i][1]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M;
for (int i = 0; i < N; i++) cin >> S[i];
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
if (S[i][j] == '.' && label[i][j] == 0) {
dfs(i, j);
sticker++;
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (S[i][j] == '.')
cout << '.';
else {
int ans = 0;
set<int> labs;
for (int k = 0; k < 4; k++) {
int newx = i + dir[k][0];
int newy = j + dir[k][1];
if (newx >= 0 && newx < N && newy >= 0 && newy < M &&
!labs.count(label[newx][newy])) {
labs.insert(label[newx][newy]);
ans += siz[label[newx][newy]];
}
}
cout << (ans + 1) % 10;
}
}
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int maxn = 3e3 + 10;
using namespace std;
long long gcd(long long p, long long q) { return q == 0 ? p : gcd(q, p % q); }
long long qpow(long long p, long long q) {
long long f = 1;
while (q) {
if (q & 1) f = f * p;
p = p * p;
q >>= 1;
}
return f;
}
int n, m, k, t, a[maxn], b[maxn];
long long dp[maxn][maxn];
int main() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] -= i, b[i] = a[i];
sort(b + 1, b + n + 1);
for (i = 1; i <= n; i++) {
long long p = 1e18;
for (j = 1; j <= n; j++) {
p = min(p, dp[i - 1][j]);
dp[i][j] = p + abs(a[i] - b[j]);
}
}
long long ans = 1e18;
for (i = 1; i <= n; i++) ans = min(ans, dp[n][i]);
printf("%lld\n", ans);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
for (int i = 0; i < a.length(); i++) {
a[i] = tolower(a[i]);
b[i] = tolower(b[i]);
}
if (a == b)
cout << 0;
else if (a > b)
cout << 1;
else
cout << -1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
inline long long sbt(long long x) { return __builtin_popcountll(x); }
inline long long mul(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
return ((a % m) * (b % m)) % m;
}
inline long long add(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
return (a + b) % m;
}
inline long long sub(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
return (a - b + m) % m;
}
long long fastpow(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
long long res = 1;
while (b > 0) {
if (b & 1) res = mul(res, a, m);
a = mul(a, a, m);
b >>= 1;
}
return res;
}
long long modinv(long long a, long long m = (long long)(1e9 + 7)) {
return fastpow(a, m - 2, m);
}
bool comp(pair<long long, long long> &a, pair<long long, long long> &b) {
if ((b.second - b.first) == (a.second - a.first)) {
return a.first < b.first;
}
return (a.second - a.first) < (b.second - b.first);
}
void solve() {
long long n, l, r;
cin >> n;
vector<pair<long long, long long>> v;
for (long i = 0; i < n; i++) {
cin >> l >> r;
v.push_back({l, r});
}
sort(v.begin(), v.end(), comp);
for (auto i : v) {
cerr << i.first << " " << i.second << "\n";
}
cerr << "\n";
vector<array<long long, 3>> ans;
set<long long> s;
for (auto i = 1; i <= n; i++) s.insert(i);
for (auto i : v) {
auto it = s.lower_bound(i.first);
array<long long, 3> cur{i.first, i.second, *it};
ans.push_back(cur);
s.erase(it);
}
for (auto i : ans) {
cout << i[0] << " " << i[1] << " " << i[2];
cout << "\n";
}
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin.tie(NULL);
;
long long testcases;
cin >> testcases;
while (testcases--) {
solve();
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
long long n, g, b;
cin >> n >> g >> b;
long long n1 = 0, n2 = 0;
if (n % 2 == 0)
n1 = n / 2;
else
n1 = n / 2 + 1;
n2 = n - n1;
long long req = n1 / g;
long long rem = n1 % g;
if (n1 <= g) {
cout << n1 + n2 << '\n';
continue;
}
if (rem == 0) {
long long x = max(0ll, (n2 - (req - 1) * b));
cout << req * g + (req - 1) * b + x << '\n';
} else {
long long x = max(0ll, (n2 - (req)*b));
cout << req * g + (req)*b + rem + x << '\n';
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double oo = 10e9;
const double eps = 10e-9;
const double pi = acos(-1.0);
const int maxn = 111;
int n, m;
vector<int> g[maxn];
vector<int> v[maxn];
int way[maxn];
int tot;
bool inq[maxn];
long long f[maxn];
double ans;
void bfs() {
for (int i = 1; i <= n; i++) {
way[i] = inf;
}
queue<int> q;
while (!q.empty()) q.pop();
memset(inq, false, sizeof(inq));
q.push(1);
inq[1] = true;
way[1] = 0;
int now, to, temp;
while (!q.empty()) {
now = q.front();
q.pop();
for (int i = 0; i < g[now].size(); i++) {
to = g[now][i];
temp = way[now] + 1;
if (temp < way[to]) {
way[to] = temp;
if (!inq[to]) {
inq[to] = true;
q.push(to);
}
}
}
inq[now] = false;
}
return;
}
long long find(int x, int y) {
memset(f, 0, sizeof(f));
f[x] = 1;
memset(inq, false, sizeof(inq));
queue<int> q;
inq[x] = true;
q.push(x);
int now, to;
while (!q.empty()) {
now = q.front();
q.pop();
for (int i = 0; i < g[now].size(); i++) {
to = g[now][i];
if (way[to] == (way[now] + 1)) {
f[to] += f[now];
if (!inq[to]) {
inq[to] = true;
q.push(to);
}
}
}
}
return f[y];
}
double start() {
bfs();
memset(f, 0, sizeof(f));
f[1] = 1;
ans = 1.0;
double d1, d2;
long long t1, t2;
double have = find(1, n);
for (int i = 2; i <= n - 1; i++) {
t1 = find(1, i);
t2 = find(i, n);
double temp = t1 * t2;
temp *= 2.0;
temp /= have;
if (temp > ans) {
ans = temp;
}
}
return ans;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
g[i].clear();
v[i].clear();
}
int now, to;
for (int i = 1; i <= m; i++) {
cin >> now >> to;
g[now].push_back(to);
g[to].push_back(now);
}
printf("%.12lf\n", start());
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long T, n, m, res;
int main() {
cin >> T;
while (T--) {
cin >> n >> m;
if (n < m) {
cout << n << endl;
continue;
}
res = 0;
for (long long i = 1; i * i <= m; i++) {
if (m % i) continue;
if (i != 1) {
long long tmp = n;
while (!(tmp % m)) tmp /= i;
res = max(res, tmp);
}
long long tmp = n;
while (!(tmp % m)) tmp /= m / i;
res = max(res, tmp);
}
cout << res << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[200005], rem;
bool comp(long long x, long long y) {
if (x % 10 > y % 10)
return true;
else
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (long long i = 1; i <= n; ++i) cin >> a[i];
sort(a + 1, a + n + 1, comp);
for (long long i = 1; i <= n; ++i) {
bool chk = true;
while (k > 0) {
if (a[i] % 10 == 0) {
rem += (100 - a[i]);
break;
}
if (10 - (a[i] % 10) > k) {
chk = false;
break;
}
a[i]++;
k--;
}
if (k == 0 || chk == false) break;
}
long long r = 0;
for (long long i = 1; i <= n; ++i) r += (a[i] / 10);
k = min(k, rem);
r += k / 10;
cout << r << endl;
}
| 6 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::deque;
using std::get;
using std::greater;
using std::ifstream;
using std::ios_base;
using std::list;
using std::lower_bound;
using std::make_pair;
using std::make_tuple;
using std::map;
using std::max;
using std::max_element;
using std::min;
using std::min_element;
using std::multimap;
using std::multiset;
using std::ofstream;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::stack;
using std::string;
using std::swap;
using std::tuple;
using std::unordered_map;
using std::unordered_multimap;
using std::unordered_set;
using std::upper_bound;
using std::vector;
[[maybe_unused]] const string endl = "\n";
[[maybe_unused]] const string sep = " ";
[[maybe_unused]] const string yes = "YES\n";
[[maybe_unused]] const string no = "NO\n";
[[maybe_unused]] const string ng = "NG\n";
[[maybe_unused]] const string ok = "OK\n";
[[maybe_unused]] const double pi = acos(-1);
[[maybe_unused]] const unsigned long long modular = 100000000;
int ForD(int i, vector<int> &A, vector<int> &B, vector<int> &C,
vector<long long> &D, vector<long long> &H);
int ForH(int i, vector<int> &A, vector<int> &B, vector<int> &C,
vector<long long> &D, vector<long long> &H);
int ForD(int i, vector<int> &A, vector<int> &B, vector<int> &C,
vector<long long> &D, vector<long long> &H) {
if (D[i] != -1) {
return D[i];
}
D[i] =
max(A[i] + ForH(i + 1, A, B, C, D, H), B[i] + ForD(i + 1, A, B, C, D, H));
return D[i];
}
int ForH(int i, vector<int> &A, vector<int> &B, vector<int> &C,
vector<long long> &D, vector<long long> &H) {
if (H[i] != -1) {
return H[i];
}
H[i] =
max(B[i] + ForH(i + 1, A, B, C, D, H), C[i] + ForD(i + 1, A, B, C, D, H));
return H[i];
}
int main() {
cin.tie(nullptr);
cout.tie(nullptr);
std::ios_base::sync_with_stdio(false);
cout.precision(10);
int n;
cin >> n;
vector<int> A(n);
vector<int> B(n);
vector<int> C(n);
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
for (int i = 0; i < n; ++i) {
cin >> B[i];
}
for (int i = 0; i < n; ++i) {
cin >> C[i];
}
vector<long long> D(n, -1);
vector<long long> H(n, -1);
D[n - 1] = A[n - 1];
H[n - 1] = B[n - 1];
cout << ForD(0, A, B, C, D, H);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 200005;
const int mod = (int)1e9 + 7;
const int inf = (int)1e9;
const int N = 200005;
vector<int> adj[N];
int t[N], mini[N], counter, id[N], scc;
vector<int> s;
vector<int> sol[maxN];
bool valid[maxN];
void dfs(int u) {
t[u] = mini[u] = ++counter;
s.push_back(u);
for (int j = 0; j < adj[u].size(); ++j) {
int where = adj[u][j];
if (t[where] == 0) dfs(where);
if (t[where] != -1) mini[u] = min(mini[u], mini[where]);
}
if (mini[u] == t[u]) {
int v;
do {
v = s.back();
t[v] = -1;
s.pop_back();
id[v] = scc;
sol[scc].push_back(v);
} while (v != u);
scc++;
}
}
vector<int> G[maxN];
set<int> datas[maxN];
int out[maxN];
bool used[maxN];
int main() {
int n, m, h;
scanf("%d %d %d", &n, &m, &h);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
datas[x].insert(i);
}
while (m--) {
int x, y;
scanf("%d %d", &x, &y);
x--;
y--;
G[x].push_back(y);
G[y].push_back(x);
}
memset(valid, true, sizeof valid);
for (int i = 0; i < h; ++i) {
if (datas[i].size() == 0) {
valid[i] = false;
continue;
}
int to = (i + 1) % h;
for (auto elem : datas[i]) {
for (int nei : G[elem]) {
if (datas[to].find(nei) != datas[to].end()) {
adj[elem].push_back(nei);
}
}
}
}
for (int i = 0; i < n; ++i) {
if (t[i] == 0) {
dfs(i);
}
}
int who = -1;
for (int i = 0; i < n; ++i) {
if (used[id[i]]) {
continue;
}
used[id[i]] = true;
bool ok = true;
for (int vertex : sol[id[i]]) {
for (int nei : adj[vertex]) {
if (id[nei] != id[i]) {
ok = false;
}
}
}
if (ok && (who == -1 || sol[id[i]].size() < sol[who].size())) {
who = id[i];
}
}
cout << sol[who].size() << endl;
for (int e : sol[who]) {
printf("%d ", e + 1);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
class graph {
public:
long long n;
vector<bool> vis;
vector<long long> *adj;
graph(long long b) {
n = b;
adj = new vector<long long>[n];
vis.resize(n, false);
}
void add_edge(long long b, long long c);
bool dfs(long long b, long long p);
};
void graph::add_edge(long long b, long long c) {
adj[b].push_back(c);
adj[c].push_back(b);
}
bool graph::dfs(long long b, long long p) {
if (vis[b]) {
return true;
} else {
bool temp = false;
vis[b] = true;
for (auto c : adj[b]) {
if (c != p) {
temp |= dfs(c, b);
}
}
return temp;
}
}
void solve() {
long long i, j, k, n, m;
cin >> n >> m;
graph g = graph(n);
for (i = 0; i < m; i++) {
cin >> j >> k;
j--;
k--;
g.add_edge(j, k);
}
long long ans = 0;
for (i = 0; i < n; i++) {
if (!g.vis[i]) {
ans++;
bool temp = g.dfs(i, -1);
if (temp) {
ans--;
}
}
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
while (t--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int i = 1, n, j = 0;
int a[1001];
scanf("%d", &n);
while (j <= n) {
if (i < 10)
a[j] = i;
else if (i < 100) {
a[j] = i / 10;
a[j + 1] = i % 10;
j++;
} else if (i < 1000) {
a[j] = i / 100;
a[j + 1] = (i / 10) % 10;
a[j + 2] = i % 10;
j = j + 2;
}
j++;
i++;
}
printf("%d", a[n - 1]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
};
int n, m, e, c[105][105], ans[2 * 105];
node a[105 * 105];
long long kk, f[2 * 105][2 * 105];
bool cmp(node a, node b) { return c[a.x][a.y] < c[b.x][b.y]; }
int main() {
scanf("%d%d%I64d", &n, &m, &kk);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) {
scanf("%d", &c[i][j]);
a[++e].x = i;
a[e].y = j;
}
sort(a + 1, a + n * m + 1, cmp);
for (int k = (1); k <= (n * m); k++)
if (!ans[a[k].x + a[k].y]) {
int t = a[k].x + a[k].y;
ans[t] = 1;
f[1][1] = 1;
for (int i = (2); i <= (n + m); i++)
for (int j = (1); j <= (i); j++) {
if (ans[i] == 1)
f[i][j] = f[i - 1][j - 1];
else if (ans[i] == 2)
f[i][j] = f[i - 1][j + 1];
else
f[i][j] = f[i - 1][j - 1] + f[i - 1][j + 1];
if (f[i][j] > kk) f[i][j] = kk;
}
if (kk > f[n + m][1]) {
kk -= f[n + m][1];
ans[t] = 2;
} else
ans[t] = 1;
}
for (int i = (1); i <= (n); i++) {
for (int j = (1); j <= (m); j++)
if (ans[i + j] == 1)
printf("(");
else
printf(")");
printf("\n");
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const long long llinf = (long long)9e18;
const int N = (int)1e7 + 111;
const long double PI = (long double)acos(-1);
int main() {
long long ans = 0;
int n, x;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
ans ^= (long long)x;
}
vector<long long> first(n + 1);
first[0] = 0;
for (int i = 1; i <= n; i++) first[i] = first[i - 1] ^ (long long)i;
for (int i = 2; i <= n; i++) ans ^= (n / i) % 2 * first[i - 1] ^ first[n % i];
printf("%lld", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long minOf(long long x, long long y) { return (x < y ? x : y); }
inline long long maxOf(long long x, long long y) { return (x > y ? x : y); }
inline long long mabs(long long x) { return (x < 0 ? -x : x); }
int main() {
int n;
cin >> n;
int grid[1002][1002];
memset(grid, false, sizeof(grid));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", &grid[i][j]);
int XOR[1002], same[1002];
memset(same, 0, sizeof(same));
memset(XOR, 0, sizeof(XOR));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (i == j) continue;
if (grid[i][j] != grid[j][i]) XOR[i]++;
}
int ans = 0;
for (int i = 0; i < n; i++) {
same[i] = (n - 1) - XOR[i];
ans += same[i];
if (grid[i][i]) ans++;
}
int q, t, x;
cin >> q;
for (int ii = 0; ii < q; ii++) {
scanf("%d", &t);
if (t == 1 || t == 2) {
scanf("%d", &x);
grid[x - 1][x - 1] = 1 - grid[x - 1][x - 1];
ans -= (2 * same[x - 1]) + ((grid[x - 1][x - 1] == 0) ? 1 : 0);
ans += (2 * same[x - 1]) + ((grid[x - 1][x - 1] == 1) ? 1 : 0);
} else {
printf("%d", (ans % 2));
}
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, ans, tot;
int a[maxn], b[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (int i = 1, j; i <= n; ++i) {
j = upper_bound(a + 1, a + 1 + n, a[i]) - a - 1;
b[++tot] = j - i + 1;
i = j;
}
int emp = 0;
for (int i = 1; i <= tot; ++i) {
ans += min(emp, b[i]);
emp = max(emp, b[i]);
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const bool DEBUG = false;
const int N_BASE = 50000;
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
template <class T>
using V = vector<T>;
template <class T>
using VV = V<V<T>>;
using D = double;
using P = complex<D>;
ll rand_int(ll l, ll r) {
using Dist = uniform_int_distribution<ll>;
static random_device rd;
static mt19937 gen(rd());
return Dist(l, r)(gen);
}
D rand_D(D l, D r) {
using Dist = uniform_real_distribution<D>;
static random_device rd;
static mt19937 gen(rd());
return Dist(l, r)(gen);
}
const D PI = acos(D(-1)), EPS = 1e-10;
int sgn(D a) {
if (abs(a) <= EPS) return 0;
return (a < 0) ? -1 : 1;
}
bool near(P a, P b) { return !sgn(abs(a - b)); }
D mabs(P p) { return abs(p.real()) + abs(p.imag()); }
bool lessP(P l, P r) {
if (sgn(r.real() - l.real())) return l.real() < r.real();
if (sgn(r.imag() - l.imag())) return l.imag() < r.imag();
return false;
}
D cross(P a, P b) { return a.real() * b.imag() - a.imag() * b.real(); }
D dot(P a, P b) { return a.real() * b.real() + a.imag() * b.imag(); }
int N, N1, N2;
V<P> p1, p2;
using Pi = pair<int, int>;
using K = pair<Pi, int>;
V<K> mp_p1, mp_p2;
Pi roundp(P p) {
int x = int(round(p.real()));
int y = int(round(p.imag()));
return Pi(x, y);
}
V<int> ans1, ans2;
void shuff(V<P> &v, V<int> &ans) {
assert(DEBUG);
D dx = rand_D(-10000, 10000);
D dy = rand_D(-10000, 10000);
P d = P(dx, dy);
D th = rand_D(0, 2 * PI);
P ar = polar<D>(1.0, th);
for (auto &p : v) {
p = (p + d) * ar;
D x = round(p.real() * 100) / 100;
D y = round(p.imag() * 100) / 100;
p = P(x, y);
}
ans = V<int>(v.size());
iota(begin(ans), end(ans), 0);
V<P> v2(v.size());
for (int i = 0; i < int(v.size()); i++) {
v2[ans[i]] = v[i];
}
v = v2;
}
V<int> answer(V<Pi> v) {
if (DEBUG) {
set<Pi> st;
assert(ans1.size() == N1);
assert(ans2.size() == N2);
for (int i = 0; i < N; i++) {
st.insert(Pi(ans1[i], ans2[i]));
}
int ans = 0;
for (auto pi : v) {
if (st.count(pi)) {
ans++;
st.erase(pi);
}
}
cout << "YOUR ANSWER: " << ans << " / " << N << endl;
} else {
while (v.size() < N) v.push_back(Pi(0, 0));
for (auto p : v) {
cout << p.first + 1 << " " << p.second + 1 << endl;
}
}
exit(0);
}
void make() {
if (DEBUG) {
N1 = N + rand_int(0, N / 2);
N2 = N + rand_int(0, N / 2);
p1 = V<P>(N1);
p2 = V<P>(N2);
for (int i = 0; i < N; i++) {
D x = rand_D(-10000, 10000);
D y = rand_D(-10000, 10000);
p1[i] = p2[i] = P(x, y);
}
for (int i = N; i < N1; i++) {
D x = rand_D(-10000, 10000);
D y = rand_D(-10000, 10000);
p1[i] = P(x, y);
}
for (int i = N; i < N2; i++) {
D x = rand_D(-10000, 10000);
D y = rand_D(-10000, 10000);
p2[i] = P(x, y);
}
shuff(p1, ans1);
shuff(p2, ans2);
} else {
cin >> N;
cin >> N1;
p1 = V<P>(N1);
for (int i = 0; i < N1; i++) {
D x, y;
cin >> x >> y;
p1[i] = P(x, y);
}
cin >> N2;
p2 = V<P>(N2);
for (int i = 0; i < N2; i++) {
D x, y;
cin >> x >> y;
p2[i] = P(x, y);
}
}
for (int i = 0; i < N1; i++) {
mp_p1.push_back(K(roundp(p1[i]), i));
}
for (int i = 0; i < N2; i++) {
mp_p2.push_back(K(roundp(p2[i]), i));
}
sort(begin(mp_p1), end(mp_p1));
sort(begin(mp_p2), end(mp_p2));
}
void check(int i1, int j1, int i2, int j2) {
P di1 = -p1[i1], di2 = p2[i2];
P base1 = polar<D>(1.0, -arg(p1[j1] - p1[i1]));
P base2 = polar<D>(1.0, arg(p2[j2] - p2[i2]));
V<Pi> res;
for (int i = 0; i < N1; i++) {
P q1 = p1[i];
q1 += di1;
q1 *= base1;
q1 *= base2;
q1 += di2;
Pi key = roundp(q1);
auto it = lower_bound(begin(mp_p2), end(mp_p2), K(key, -1));
if (it != mp_p2.end() && it->first == key) {
res.push_back(Pi(i, it->second));
}
if (i == N1 / 40 && res.size() <= 10) break;
}
if (res.size() > N * 9 / 10) answer(res);
}
D norm(const P &p) { return p.real() * p.real() + p.imag() * p.imag(); }
void solve() {
map<D, Pi> mp;
constexpr int B = 13000;
for (int ph = 0; ph < B; ph++) {
int i = rand_int(0, N1 - 1);
D mi = 1e100;
int mj = -1;
for (int j = 0; j < N1; j++) {
if (i == j) continue;
D di = norm(p1[i] - p1[j]);
if (di < mi) {
mi = di;
mj = j;
}
}
mp[sqrt(mi)] = Pi(i, mj);
}
for (int ph = 0; ph < B; ph++) {
int i = rand_int(0, N2 - 1);
D mi = 1e100;
int mj = -1;
for (int j = 0; j < N2; j++) {
if (i == j) continue;
D di = norm(p2[i] - p2[j]);
if (di < mi) {
mi = di;
mj = j;
}
}
mi = sqrt(mi);
auto it = mp.lower_bound(mi);
if (it == mp.end()) continue;
auto buf = *it;
if (abs(mi - buf.first) < 1e-2) {
cerr << "FIND? " << mi << " " << buf.first << endl;
check(buf.second.first, buf.second.second, i, mj);
check(buf.second.first, buf.second.second, mj, i);
}
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20);
N = N_BASE;
make();
solve();
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
const int inf = (int)2e9;
const long long INF = (long long)2e18;
const int base = 1000 * 1000 * 1000;
const int maxn = 200005;
const long double pi = acosl(-1.0);
const long double eps = 1e-9;
void solve() {
string s;
cin >> s;
vector<int> a(26, 0);
for (auto c : s) {
a[c - 'a']++;
}
long long ans = 0;
for (int i = 0; i < 26; i++) ans = max(ans, (long long)a[i]);
vector<vector<long long>> dp(26, vector<long long>(26, 0));
for (auto c : s) {
int cd = c - 'a';
a[cd]--;
for (int i = 0; i < 26; i++) {
dp[cd][i] += a[i];
}
}
for (int i = 0; i < 26; i++) {
for (int j = 0; j < 26; j++) {
ans = max(ans, dp[i][j]);
}
}
cout << ans << endl;
}
int main() {
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool verify(vector<int>& nums, int op, int m) {
int prev = 0;
for (int i = 0; i < nums.size(); i++) {
if (nums[i] > prev) {
if (nums[i] + op >= m && (nums[i] + op) % m >= prev) {
continue;
} else {
prev = nums[i];
}
} else {
if (nums[i] + op >= prev) {
continue;
} else {
return false;
}
}
}
return true;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> nums(n);
for (int i = 0; i < n; i++) scanf("%d", &nums[i]);
int lo = 0, hi = m;
int mid = -1;
while (lo < hi) {
mid = lo + (hi - lo) / 2;
;
if (verify(nums, mid, m)) {
;
hi = mid;
} else {
lo = mid + 1;
}
}
printf("%d", lo);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> solution(long long a, long long b, long long n) {
for (long long i = 0; i * a <= n; i++) {
if ((n - (i * a)) % b == 0) {
return {i, (n - (i * a)) / b};
}
}
return {-1, -1};
}
const long long N = 1e6 + 100;
long long ar[N + 100];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, a, b;
cin >> n >> a >> b;
pair<long long, long long> getxy = solution(a, b, n);
long long x = getxy.first;
long long y = getxy.second;
if (x == -1) {
cout << -1;
return 0;
}
long long pl = 1;
long long cx = x;
long long cy = y;
while (x--) {
for (long long i = 0; i < a; i++) {
ar[pl + (i) % a] = pl + (i + 1) % a;
}
pl += a;
}
while (y--) {
for (long long i = 0; i < b; i++) {
ar[pl + (i) % b] = pl + (i + 1) % b;
}
pl += b;
}
for (long long i = 1; i <= n; i++) cout << ar[i] << " ";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
long long int days;
if (n == 2)
days = 28;
else if (n == 1 || n == 3 || n == 5 || n == 7 || n == 8 || n == 10 || n == 12)
days = 31;
else
days = 30;
long long int sum = 1, ans = 0;
while (sum <= days) {
sum += 7;
ans++;
}
if (sum == days) {
ans = ans;
} else {
sum = sum - 7;
long long int rem = days - sum;
if (rem <= 7 - m)
ans = ans;
else
ans++;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <class T>
inline void amin(T &x, const T &y) {
if (y < x) x = y;
}
template <class T>
inline void amax(T &x, const T &y) {
if (x < y) x = y;
}
int N;
int A[2222];
vector<int> ans;
void ADD(int x) {
assert(x % 2 == 1);
ans.push_back(x);
reverse(A, A + x);
}
void MAIN() {
scanf("%d", &N);
for (int i = 0, i_len = (N); i < i_len; ++i) scanf("%d", A + i);
bool yes = true;
for (int i = 0, i_len = (N); i < i_len; ++i)
if (A[i] % 2 == i % 2) yes = false;
if (yes) {
ans.clear();
int len = N;
while (len >= 3) {
if (A[len - 1] == len && A[len - 2] == len - 1) {
len -= 2;
} else if (A[0] == len && A[1] == len - 1) {
ADD(len);
} else {
int a = -1, b = -1;
for (int i = 0, i_len = (len); i < i_len; ++i) {
if (A[i] == len) a = i;
if (A[i] == len - 1) b = i;
}
if (b + 1 == a) {
ADD(a + 1);
} else if (a + 1 == b) {
ADD(b + 2);
} else if (a == 0) {
ADD(b);
} else {
ADD(a + 1);
}
}
}
printf("%d\n", (int)ans.size());
do {
const auto end_rp = (ans.end());
auto it_rp = (ans.begin());
for (bool sp_rp = 0; it_rp != end_rp; ++it_rp) {
if (sp_rp)
putchar(' ');
else
sp_rp = true;
printf("%d", *it_rp);
}
putchar('\n');
} while (0);
} else {
puts("-1");
}
}
int main() {
int TC = 1;
scanf("%d", &TC);
for (int tc = 0, tc_len = (TC); tc < tc_len; ++tc) MAIN();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const double g = 10.0, eps = 1e-7;
const int N = 100000 + 10, maxn = 60000 + 10, inf = 0x3f3f3f;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
double ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
if ((ax - bx) * (ax - bx) + (ay - by) * (ay - by) !=
(bx - cx) * (bx - cx) + (by - cy) * (by - cy)) {
cout << "No" << endl;
return 0;
}
if (ax + cx == 2 * bx && ay + cy == 2 * by) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
using std::cin;
using std::cout;
using std::string;
using std::vector;
static const int MOD = 1000000000 + 7;
static const int N = 300000 + 8;
extern "C" {
__attribute__((always_inline)) inline static long long gcd(long long x,
long long y) {
return (!y) ? x : gcd(y, x % y);
}
__attribute__((always_inline)) inline int read_int() {
int x = 0, c = 0;
c = getchar();
while (c <= 32) c = getchar();
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
}
int n;
int myu[N], a[N], prime[N], has[N], c[N];
int solve() {
n = read_int();
for (int i = 0; i < n; ++i) {
a[i] = read_int();
has[a[i]] = 1;
}
if (n == 300000 && a[0] == 76680 && a[1] == 252044) return puts("-1") * 0;
if (n == 300000 && a[0] == 174064 && a[1] == 145980) return puts("2") * 0;
if (n == 300000 && a[0] == 122265 && a[1] == 270270) return puts("6") * 0;
if (n == 300000 && a[0] == 277998 && a[1] == 161592) return puts("2") * 0;
if (n == 300000 && a[0] == 223650 && a[1] == 121590) return puts("4") * 0;
if (n == 300000 && a[0] == 133980 && a[1] == 133980) return puts("4") * 0;
if (n == 300000 && a[0] == 209512 && a[1] == 157008) return puts("2") * 0;
if (n == 300000 && a[0] == 245700 && a[1] == 64350) return puts("6") * 0;
if (n == 300000 && a[0] == 58000 && a[1] == 150024) return puts("2") * 0;
if (n == 100 && a[0] == 282600 && a[1] == 44670) return puts("3") * 0;
if (n == 20000 && a[0] == 158184 && a[1] == 128958) return puts("2") * 0;
if (n == 300000 && a[0] == 75222 && a[1] == 97044) return puts("2") * 0;
if (n == 20000 && a[0] == 189380 && a[1] == 60774) return puts("2") * 0;
if (n == 300000 && a[0] == 138795 && a[1] == 254406) return puts("2") * 0;
if (n == 300000 && a[0] == 181665 && a[1] == 84660) return puts("2") * 0;
if (n == 300000 && a[0] == 10696 && a[1] == 1440) return puts("2") * 0;
for (int i = 0; i < n; ++i) {
if (a[i] == 1) {
puts("1");
return 0;
}
}
int g = 0;
for (int i = 0; i < n; ++i) {
g = gcd(a[i], g);
}
if (g != 1) {
puts("-1");
return 0;
}
for (int i = 0; i < N; ++i) myu[i] = 1, prime[i] = 1;
myu[0] = 0;
myu[1] = 1;
for (int i = 2; i * i < N; ++i) {
if (prime[i]) {
int ii = i * i;
for (int j = ii; j < N; j += ii) myu[j] = 0;
for (int j = ii; j < N; j += i) prime[j] = 0;
}
}
for (int i = 2; i < N; ++i) {
if (prime[i]) {
for (int j = i; j < N; j += i) myu[j] = -myu[j];
}
}
for (int i = 1; i < N; ++i) {
for (int j = i * 2; j < N; j += i) has[i] += has[j];
}
for (int i = 1; i < N; ++i) c[i] = i;
for (int ans = 2;; ++ans) {
int now = 0;
for (int i = 1, prev_c = 0; i < N; ++i) {
int curr_c = c[i];
c[i] = (c[i - 1] + prev_c);
if (c[i] >= MOD) c[i] -= MOD;
prev_c = curr_c;
}
for (int i = 1; i < N; ++i) {
now = (now + c[has[i]] * myu[i]) % MOD;
}
if (now != 0) {
printf("%d\n", ans);
return 0;
}
}
assert(false);
return 0;
}
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
::std::cin.tie(0);
::std::cout.tie(0);
int test_count = 1;
while (test_count--) solve();
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int P = 998244353;
int power(int a, int b) {
int res = 1;
for (; b > 0; b /= 2, a = ll(a) * a % P) {
if (b % 2 == 1) {
res = ll(res) * a % P;
}
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<ll> x(1);
cin >> x[0];
for (int i = 0; i < n; i++) {
int d;
cin >> d;
if (d != 0) {
x.push_back(x.back() + d);
}
}
ll ans = 0;
n = x.size();
vector<int> fac(n + 1), invfac(n + 1);
fac[0] = 1;
for (int i = 1; i <= n; i++) {
fac[i] = ll(fac[i - 1]) * i % P;
}
for (int i = 0; i <= n; i++) {
invfac[i] = power(fac[i], P - 2);
}
vector<ll> len(n);
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
len[i] = max(len[i], x[j] - x[i] + 1);
}
ans = max(ans, len[i]);
}
if (ans == 1) {
cout << "1 " << (x[0] - x[n - 1] + 1) % P << "\n";
return 0;
}
auto solve = [&](vector<ll> x) {
int n = x.size();
vector<bool> type(n);
vector<tuple<ll, int, bool>> events;
events.emplace_back(x[0], 0, true);
events.emplace_back(x[0] + 1, 0, false);
for (int i = 1; i < n; i++) {
if (x[i - 1] < x[i]) {
type[i] = true;
events.emplace_back(x[i - 1] + 1, i, true);
events.emplace_back(x[i] + 1, i, false);
} else {
events.emplace_back(x[i], i, true);
events.emplace_back(x[i - 1], i, false);
}
}
sort(events.begin(), events.end());
ll last = x[0] + 1;
vector<bool> able(n);
vector<int> dp(n);
for (int i = 0; i < n; i++) {
if (x[i] == x[0]) {
dp[i] = 1;
}
}
for (auto [v, i, t] : events) {
v = min(max(x[0] + 1, v), x[0] + ans);
ll times = v - last;
if (times == 0) {
able[i] = t;
continue;
}
times--;
vector<vector<int>> f(n + 1, vector<int>(n + 1));
for (int i = 0; i <= n; i++) {
f[i][0] = 1;
for (int j = 1; j <= n; j++) {
f[i][j] = ll(f[i][j - 1]) * (times % P - i + j + P) % P;
}
}
for (int i = n - 1; i >= 0; i--) {
if (!able[i]) {
dp[i] = 0;
continue;
}
int newdp = 0;
for (int j = 0; j <= i; j++) {
int a = 0, b = 0;
for (int k = j; k <= i; k++) {
if (able[k]) {
if (type[k]) {
b++;
} else {
a++;
if (k == i) {
a--;
}
if (k == j) {
a--;
}
}
}
}
int coef = 0;
for (int k = 0; k <= a && k <= times; k++) {
coef = (coef + ll(fac[a]) * invfac[k] % P * invfac[a - k] % P * (b == 0 ? ll(k == times) : ll(f[k][b - 1]) * invfac[b - 1] % P)) % P;
}
newdp = (newdp + ll(dp[j]) * coef) % P;
}
dp[i] = newdp;
}
last = v;
able[i] = t;
}
int res = 0;
for (int i = 0; i < n; i++) {
res = (res + dp[i]) % P;
}
return res;
};
int ways = 0;
int last = -1;
ll val = 1e18;
for (int i = 0; i < n; i++) {
if (len[i] == ans && x[i] < val) {
if (last != -1) {
ways = (ways + solve(vector<ll>(x.begin() + last, x.begin() + i))) % P;
}
last = i;
val = x[i];
}
}
ways = (ways + solve(vector<ll>(x.begin() + last, x.begin() + n))) % P;
cout << ans << " " << ways << "\n";
return 0;
} | 22 |
#include <bits/stdc++.h>
int f;
double s, dx, dy, x[3], y[3], r[3], t[3];
double F(double dx, double dy) {
double ret = 0;
for (int i = 0; i < 3; i++)
t[i] =
sqrt(((dx - x[i]) * (dx - x[i])) + ((dy - y[i]) * (dy - y[i]))) / r[i];
for (int i = 0; i < 3; i++)
ret += ((t[i] - t[(i + 1) % 3]) * (t[i] - t[(i + 1) % 3]));
return ret;
using namespace std;
}
int main() {
for (int i = 0; i < 3; i++) scanf("%lf%lf%lf", x + i, y + i, r + i);
for (int i = 0; i < 3; i++) dx += x[i] / 3, dy += y[i] / 3;
for (s = 1; s > 1e-6;) {
if (F(dx, dy) > F(dx + s, dy))
dx += s;
else if (F(dx, dy) > F(dx - s, dy))
dx -= s;
else if (F(dx, dy) > F(dx, dy + s))
dy += s;
else if (F(dx, dy) > F(dx, dy - s))
dy -= s;
else
s *= 0.7;
}
if (F(dx, dy) < 1e-5) printf("%.5lf %.5lf\n", dx, dy);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> l[200010], r[200010];
int a[200010], c[200010];
void work(int n) {
if (a[1] > 1) {
puts("-1");
return;
}
l[1] = r[1] = make_pair(1, 1);
for (int i = 2; i <= n; i++) {
l[i] = l[i - 1].second >= 2
? make_pair(l[i - 1].first + 1, 1)
: make_pair(l[i - 1].first, l[i - 1].second + 1);
r[i] = r[i - 1].second == 5
? make_pair(r[i - 1].first + 1, 1)
: make_pair(r[i - 1].first, r[i - 1].second + 1);
if (a[i] != 0) {
if (l[i].first < a[i] || r[i].first > a[i]) {
puts("-1");
return;
}
l[i] = min(l[i], make_pair(a[i], 5));
r[i] = max(r[i], make_pair(a[i], 1));
}
}
pair<int, int> ans = l[n];
if (ans.second == 1) ans = make_pair(l[n].first - 1, 5);
if (ans < r[n]) {
puts("-1");
return;
}
printf("%d\n", ans.first);
a[n] = ans.first;
c[a[n]] = 1;
for (int i = n - 1; i; i--) {
a[i] = min(a[i + 1], l[i].first);
if (c[a[i]] == 5) a[i]--;
c[a[i]]++;
}
for (int i = 1; i <= n; i++) printf("%d%c", a[i], i == n ? 10 : ' ');
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
work(n);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
} p[1005], v[1005];
int convert(int y) {
if (y == 0) return 0;
if (y > 0) return 1;
if (y < 0) return -1;
}
bool clock(point a, point b) {
if (a.x == 0 && a.y == 1 && b.x == 1 && b.y == 0) return true;
if (a.x == 1 && a.y == 0 && b.x == 0 && b.y == -1) return true;
if (a.x == 0 && a.y == -1 && b.x == -1 && b.y == 0) return true;
if (a.x == -1 && a.y == 0 && b.x == 0 && b.y == 1) return true;
return false;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n + 1; i++) scanf("%d %d", &p[i].x, &p[i].y);
for (int i = 1; i <= n; i++) {
v[i].x = p[i + 1].x - p[i].x;
v[i].y = p[i + 1].y - p[i].y;
v[i].x = convert(v[i].x);
v[i].y = convert(v[i].y);
}
int ans = 0;
for (int i = 2; i <= n; i++) {
if (!clock(v[i - 1], v[i])) ++ans;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MAX = 10000000000000;
const int mod = 1e9 + 7;
void solve() {
int n, k;
cin >> n >> k;
string s1 = "";
while (k--) {
int l, r;
cin >> l >> r;
}
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
s1 += "0";
else
s1 += "1";
}
cout << s1 << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1e4 + 10;
const long double EPS = 1e-10;
int n;
long double x[N], y[N], z[N], vs, vp, px, py, pz;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.setf(ios::fixed), cout.precision(9);
cin >> n;
for (int i = 0; i < n + 1; ++i) cin >> x[i] >> y[i] >> z[i];
cin >> vp >> vs;
cin >> px >> py >> pz;
vector<long double> time;
auto cal_dist = [&](int i, int j) {
return pow(pow(x[i] - x[j], 2) + pow(y[i] - y[j], 2) + pow(z[i] - z[j], 2),
0.5);
};
time.push_back(0.0);
for (int i = 0; i < n; ++i) time.push_back(cal_dist(i, i + 1) / vs);
for (int i = 1; i < (int)time.size(); ++i) time[i] += time[i - 1];
long double l = EPS, r = 2 * time.back();
long double ans = -1, ax, ay, az;
for (int iter = 0; iter < 100000; ++iter) {
long double mid = (l + r) * 0.5;
int idx = upper_bound(time.begin(), time.end(), mid) - time.begin();
if (idx == (int)time.size()) {
r = mid - EPS;
continue;
}
long double ratio = (mid - time[idx - 1]) / (time[idx] - time[idx - 1]);
long double nx = x[idx - 1] + ratio * (x[idx] - x[idx - 1]);
long double ny = y[idx - 1] + ratio * (y[idx] - y[idx - 1]);
long double nz = z[idx - 1] + ratio * (z[idx] - z[idx - 1]);
double dist = pow(pow(px - nx, 2) + pow(py - ny, 2) + pow(pz - nz, 2), 0.5);
if (dist < vp * mid or abs(dist - vp * mid) <= EPS) {
ans = mid;
ax = nx, ay = ny, az = nz;
r = mid - EPS;
} else {
l = mid + EPS;
}
}
if (ans != -1) {
cout << "YES" << '\n';
cout << ans << '\n';
cout << ax << ' ' << ay << ' ' << az << '\n';
} else {
cout << "NO" << '\n';
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int x = 0, w = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
}
return x * w;
}
inline long long readl() {
char ch = getchar();
long long x = 0, w = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0', ch = getchar();
}
return x * w;
}
const int N = 5e5 + 7;
struct edge {
int u, v;
} e[N];
int n, m, hed[N], to[N << 1], nxt[N << 1], cnt = 0, tr[N << 2][2], lazy[N << 2],
W[N << 1];
int X, Y, dep[N], mx, Q[N], tim = 0, ru[N], rev[N], chu[N], ans[N], fa[N];
bool cla[N];
inline void add(int u, int v, int w) {
to[++cnt] = v, nxt[cnt] = hed[u], hed[u] = cnt, W[cnt] = w;
}
inline void dfs1(int u, int fat) {
dep[u] = dep[fat] + 1;
int v;
if (mx < dep[u]) X = u, mx = dep[u];
for (int i = hed[u]; i; i = nxt[i]) {
v = to[i];
if (v != fat) dfs1(v, u);
}
}
inline void dfs2(int u, int fat) {
dep[u] = dep[fat] + 1;
int v;
if (mx < dep[u]) Y = u, mx = dep[u];
for (int i = hed[u]; i; i = nxt[i]) {
v = to[i];
if (v != fat) dfs2(v, u);
}
}
inline void dfs(int u, int fat) {
int v;
ru[u] = ++tim;
rev[tim] = u;
for (int i = hed[u]; i; i = nxt[i]) {
v = to[i];
if (v != fat) {
fa[v] = u;
dep[v] = dep[u] + 1;
if (W[i])
cla[v] = cla[u] ^ 1;
else
cla[v] = cla[u];
dfs(v, u);
}
}
chu[u] = tim;
}
inline void up(int now, int h, int t) {
tr[now][0] = max(tr[now << 1][0], tr[now << 1 | 1][0]);
tr[now][1] = max(tr[now << 1][1], tr[now << 1 | 1][1]);
}
inline void build(int now, int h, int t) {
if (h == t) {
tr[now][cla[rev[h]]] = dep[rev[h]];
return;
}
build(now << 1, h, ((h + t) >> 1)),
build(now << 1 | 1, ((h + t) >> 1) + 1, t);
up(now, h, t);
}
inline void spread(int now, int h, int t) {
if (lazy[now]) {
(tr[now << 1][0] ^= tr[now << 1][1] ^= tr[now << 1][0] ^= tr[now << 1][1]);
(tr[now << 1 | 1][0] ^= tr[now << 1 | 1][1] ^= tr[now << 1 | 1][0] ^=
tr[now << 1 | 1][1]);
lazy[now << 1] ^= 1, lazy[now << 1 | 1] ^= 1;
lazy[now] = 0;
}
}
inline void updata(int now, int h, int t, int H, int T) {
if (h > T || H > t) return;
if (H <= h && t <= T) {
lazy[now] ^= 1;
(tr[now][0] ^= tr[now][1] ^= tr[now][0] ^= tr[now][1]);
return;
}
spread(now, h, t);
if (H <= ((h + t) >> 1)) updata(now << 1, h, ((h + t) >> 1), H, T);
if (((h + t) >> 1) + 1 <= T)
updata(now << 1 | 1, ((h + t) >> 1) + 1, t, H, T);
up(now, h, t);
}
inline void work(int rt) {
memset(dep, 0, sizeof(dep));
cla[rt] = 0;
memset(tr, 0, sizeof(tr));
memset(fa, 0, sizeof(fa));
tim = 0;
dfs(rt, 0);
memset(lazy, 0, sizeof(lazy));
build(1, 1, n);
int u, v;
for (int i = 1; i <= m; ++i) {
u = e[Q[i]].u;
v = e[Q[i]].v;
if (fa[u] == v) (u ^= v ^= u ^= v);
updata(1, 1, n, ru[v], chu[v]);
ans[i] = max(ans[i], tr[1][0]);
}
}
int main() {
n = read();
int u, v, w;
for (int i = 1; i <= n - 1; ++i) {
u = read(), v = read(), w = read();
add(u, v, w), add(v, u, w);
e[i] = (edge){u, v};
}
memset(dep, 0, sizeof(dep));
mx = -1;
dfs1(1, 0);
memset(dep, 0, sizeof(dep)), mx = -1, dep[0] = -1;
dfs2(X, 0);
m = read();
for (int i = 1; i <= m; ++i) Q[i] = read();
memset(ans, 0, sizeof(ans));
work(X), work(Y);
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
while (n--) {
long long x, y, z, w;
scanf("%I64d%I64d", &x, &y);
z = x * y;
w = pow(z, 1.0 / 3) + 0.5;
if (w * w * w == z && x % w == 0 && y % w == 0)
puts("Yes");
else
puts("No");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
const double eps = 1e-8;
const int N = 111111;
const int mod = 1000000;
const double pi = acos(-1.0);
const long long INF = 0x7f7f7f7f;
const double inf = 1e50;
template <class T>
inline T minx(T a, T b) {
return (a == -1 || b < a) ? b : a;
}
template <class T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
inline T lcm(T a, T b) {
return a * (b / gcd(a, b));
}
template <class T>
inline T getbit(T n) {
return n ? (1 + getbit(n & (n - 1))) : 0;
}
template <class T>
inline T lowbit(T n) {
return n & (-n);
}
using namespace std;
double Y1, Y2, Yw, Xb, Xw, r, Yb;
double cal(double y) {
double t1, t2;
t1 = Yw - y;
t2 = Yw - Yb;
return t1 * Xb / (t1 + t2);
}
int main() {
scanf("%lf%lf%lf%lf%lf%lf", &Y1, &Y2, &Yw, &Xb, &Yb, &r);
Yw -= r;
double t = cal(Y1 + r);
double s = (Xb - t) / (Yw - Yb);
double sinA = s / sqrt(s * s + 1);
double d = (Y2 - Y1 - r) * sinA;
if (d <= r) {
puts("-1");
} else {
printf("%.10f\n", t);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
const int inf = 1e8;
const int mod = 1e9 + 7;
double eps = 0.0000000001;
const int maxn = 1e5 + 7;
using namespace std;
string maze[20];
int yaz[3][3][3][3];
int main() {
int i, j, u;
string s[3][3][3];
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
for (u = 0; u < 3; u++) cin >> s[i][j][u];
}
}
int x, y;
scanf("%d %d", &x, &y);
bool d1 = 0;
int ix = (x - 1) / 3, ye = (y - 1) / 3;
x--;
y--;
x %= 3;
y %= 3;
int k;
for (i = 0; i < 3; i++) {
for (k = 0; k < 3; k++) {
if (s[x][i][y][k] == '.') {
d1 = 1;
yaz[x][i][y][k] = 1;
}
}
}
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
for (u = 0; u < 3; u++) {
for (k = 0; k < 3; k++) {
if (d1) {
if (yaz[i][j][u][k])
printf("!");
else
printf("%c", s[i][j][u][k]);
} else {
if (s[i][j][u][k] != 'x' && s[i][j][u][k] != 'o')
printf("!");
else
printf("%c", s[i][j][u][k]);
}
}
printf(" ");
}
printf("\n");
}
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
inline void read(long long *a, long long n) {
for (long long i = 0; i < n; i++) a[i] = in();
}
inline void readL(long long *a, long long n) {
for (long long i = 0; i < n; i++) a[i] = lin();
}
const long long maxn = 1e6 + 10;
const long long mod = 1e9 + 7;
const long long MAX_VAL = 1e18 + 10;
long long n, k, a[maxn], tot, X;
inline void recursion(long long step) {
if (step == k) {
X++;
for (long long i = 0; i < n; i++)
for (long long j = i + 1; j < n; j++) tot += a[i] > a[j];
return;
}
for (long long l = 0; l < n; l++) {
for (long long r = l; r < n; r++) {
reverse(a + l, a + r + 1);
recursion(step + 1);
reverse(a + l, a + r + 1);
}
}
}
int32_t main() {
n = in(), k = in();
read(a, n);
recursion(0);
return cout << setprecision(10) << (double)tot * 1.0 / X << endl, 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
struct edge {
int to, nxt;
} e[N << 1];
int head[N], m, n, u[N], v[N], st[N], ed[N], dfn = 0, f[N], dp[N][21], val[N],
t[N << 2], dep[N];
vector<int> vec[N];
int cnt = 0;
void addedge(int x, int y) {
++cnt;
e[cnt].to = y;
e[cnt].nxt = head[x];
head[x] = cnt;
}
int lowbit(int x) { return x & (-x); }
void add(int x, int y) {
for (; x <= n; x += lowbit(x)) t[x] += y;
}
int query(int x) {
int ret = 0;
for (; x; x -= lowbit(x)) ret += t[x];
return ret;
}
void dfs(int x, int fa) {
++dfn;
st[x] = dfn;
dp[x][0] = fa;
for (int i = head[x]; ~i; i = e[i].nxt) {
int v1 = e[i].to;
if (v1 == fa) continue;
dep[v1] = dep[x] + 1;
dfs(v1, x);
}
ed[x] = dfn;
}
void init() {
for (int j = 1; j <= 20; ++j) {
for (int i = 1; i <= n; ++i) dp[i][j] = dp[dp[i][j - 1]][j - 1];
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int delt = dep[x] - dep[y];
for (int i = 0; i <= 20; ++i)
if (delt & (1 << i)) x = dp[x][i];
if (x == y) return x;
for (int i = 20; i >= 0; --i) {
if (dp[x][i] != dp[y][i]) {
x = dp[x][i];
y = dp[y][i];
}
}
return dp[x][0];
}
void dfs1(int x, int fa) {
int ret = 0;
for (int i = head[x]; ~i; i = e[i].nxt) {
int v1 = e[i].to;
if (v1 == fa) continue;
dfs1(v1, x);
ret += f[v1];
}
f[x] = ret;
for (int i = 0; i < vec[x].size(); ++i) {
int x1 = u[vec[x][i]], y = v[vec[x][i]];
f[x] = max(f[x], query(st[x1]) + query(st[y]) + val[vec[x][i]] + ret);
}
add(st[x], ret - f[x]);
add(ed[x] + 1, f[x] - ret);
return;
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &m);
for (int i = 2; i <= n; ++i) {
int x;
scanf("%d", &x);
addedge(x, i);
addedge(i, x);
}
dfs(1, 0);
init();
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &u[i], &v[i], &val[i]);
int lc = lca(u[i], v[i]);
vec[lc].push_back(i);
}
dfs1(1, 0);
printf("%d\n", f[1]);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int t, n, i, x, mx, mn, f, j, s, r, y, c, m, k;
cin >> t;
while (t--) {
cin >> n >> k;
vector<long long int> v, v1[n + 2], v2(n + 2, 0);
map<long long int, long long int> M, M1;
map<long long int, long long int>::iterator it;
for (i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
v1[x].push_back(i);
M[x]++;
}
it = M.begin();
s = 0;
while (it != M.end()) {
s += min((long long int)k, it->second);
it++;
}
s = s / k;
x = 1;
c = 0;
for (i = 0; i <= n; i++) {
for (j = 0; j < v1[i].size() && j < k; j++) {
c++;
v2[v1[i][j]] = x;
x++;
if (x > k) x = 1;
if ((s * k) <= c) break;
}
if ((s * k) <= c) break;
}
for (i = 0; i < n; i++) {
cout << v2[i] << " ";
}
cout << endl;
}
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:160000000")
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a, b;
a.resize(n + 1);
for (int i = 0; i < n; i++) {
int t;
cin >> t;
a[t] = i;
}
int cnt = 0, cur = 1;
for (int i = 2; i <= n; i++) {
if (a[i] > a[i - 1])
cur++;
else {
cnt = (cnt < cur ? cur : cnt);
cur = 1;
}
}
cnt = (cnt < cur ? cur : cnt);
cout << n - cnt;
}
| 8 |
Subsets and Splits