solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
vector<int> prev;
vector<int> cnt;
vector<pair<double, int>> val;
int main() {
int n, m;
cin >> n >> m;
cnt.resize(n);
val.resize(n);
for (int i = 0; i < n; i++) {
cin >> val[i].second >> val[i].first;
cnt[i] = 1;
}
sort(val.begin(), val.end());
int value;
for (int i = 0; i < n; i++) {
int max = -1;
for (int j = 0; j < i; j++) {
if ((val[j].second <= val[i].second)) {
if (max == -1) {
max = j;
} else {
if (cnt[j] > cnt[max]) {
max = j;
}
}
}
}
if (max == -1) {
cnt[i] = 1;
} else {
cnt[i] = cnt[max] + 1;
}
}
int max = 0;
for (int i = 0; i < n; i++) {
if (cnt[i] > max) {
max = cnt[i];
}
}
cout << n - max;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 2e5 + 10;
long long sz[maxn], dep[maxn];
vector<long long> g[maxn];
void dfs(long long v, long long p = -1, long long d = 0) {
dep[v] = d;
sz[v] = 1;
for (auto u : g[v]) {
if (u == p) continue;
dfs(u, v, d + 1);
sz[v] += sz[u];
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
vector<long long> a(n);
long long ans = 0;
for (long long i = 0; i < n; i++) a[i] = i + 1;
sort((a).begin(), (a).end(), [&](const long long a, const long long b) {
return dep[a] - sz[a] > dep[b] - sz[b];
});
for (long long i = 0; i < k; i++) {
ans += dep[a[i]] - sz[a[i]] + 1;
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 60;
const int inf = 0x3f3f3f3f;
const long long mod = 1000000007LL;
int n, m;
long long f[N][N], g[N][N], inv[N], t[N][N];
int main() {
inv[1] = 1;
f[0][1] = 1;
for (int i = 2; i <= 60; ++i) inv[i] = (-mod / i * inv[mod % i]) % mod;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= i + 1; ++j) {
for (int a = 0; a <= i - 1; ++a) {
int b = i - a - 1;
for (int u = j; u <= a + 1; ++u)
g[i][j] += f[a][u] * f[b][j] % mod, g[i][j] %= mod;
for (int u = j + 1; u <= b + 1; ++u)
g[i][j] += f[a][j] * f[b][u] % mod, g[i][j] %= mod;
}
memset(t, 0, sizeof(t));
for (int x = 0; x <= n; ++x)
for (int y = 1; y <= x + 1; ++y) {
long long comb = 1;
for (int T = 1; T <= n && x + i * T <= n; ++T) {
comb *= (g[i][j] + T - 1) % mod * inv[T] % mod;
comb %= mod;
t[x + i * T][y + j * T] += comb * f[x][y] % mod;
t[x + i * T][y + j * T] %= mod;
}
}
for (int x = 0; x <= n; ++x)
for (int y = 1; y <= x + 1; ++y) f[x][y] += t[x][y], f[x][y] %= mod;
}
}
printf("%lld\n", (f[n][m] % mod + mod) % mod);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t, r = 1, r1 = 0, r2 = 0, k = 0, a, b, c = 1, m, d = 0, n, e, f,
x = 0, g, p = 0, q = 0, y = 0, z = 0;
vector<long long> v;
vector<long long> u;
set<long long> s;
std::vector<int>::iterator it;
string s1, s2, s3, s4;
cin >> n;
while (n--) {
cin >> m;
cout << m << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void re(int& x);
template <class T, class... Ts>
void re(T& t, Ts&... ts);
void pr(int x);
void pr(const char* x);
void ps();
template <class T, class... Ts>
void ps(const T& t, const Ts&... ts);
vector<int> pi(const string& s) {
vector<int> p(s.size());
for (int i = 1; i < s.size(); i++) {
int g = p[i - 1];
while (g && s[i] != s[g]) g = p[g - 1];
p[i] = g + (s[i] == s[g]);
}
return p;
}
int n, m, k;
bool foundent = false;
void match(const string& s, const string& pat, int* fi) {
vector<int> p = pi(pat + '\0' + s), res;
int delta = (int)p.size() - (int)s.size();
for (int i = delta; i < p.size(); i++) {
if (i >= delta + k - 1)
fi[p[i]] = min(fi[p[i]], i - delta);
else if (p[i] == (int)(pat).size())
foundent = true;
}
for (int i = (int)(pat).size(); i > 0; i--) {
fi[p[i - 1]] = min(fi[p[i - 1]], fi[i]);
}
}
char ss[610000];
char tt[610000];
int file[610000];
int firi[610000];
void solve() {
re(n, m, k);
scanf("%s %s", ss, tt);
string s = ss, t = tt;
for (int i = 0; i <= s.size(); i++) file[i] = firi[i] = 1000000000;
match(s, t, file);
reverse((s).begin(), (s).end());
reverse((t).begin(), (t).end());
match(s, t, firi);
for (int i = 0; i <= k; i++)
if (0 <= (int)(t).size() - i && (int)(t).size() - i <= k) {
if (file[i] < (n - 1 - firi[(int)(t).size() - i])) {
ps("Yes");
ps(file[i] - k + 2, n - firi[(int)(t).size() - i]);
return;
}
}
if (foundent) {
ps("Yes");
ps(1, n - k + 1);
return;
}
ps("No");
}
int main() { solve(); }
void re(int& x) { scanf("%d", &x); }
template <class T, class... Ts>
void re(T& t, Ts&... ts) {
re(t);
re(ts...);
}
void pr(int x) { printf("%d", x); }
void pr(const char* x) { printf("%s", x); }
void ps() { pr("\n"); }
template <class T, class... Ts>
void ps(const T& t, const Ts&... ts) {
pr(t);
if (sizeof...(ts)) pr(" ");
ps(ts...);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct deb {
template <class c>
deb &operator<<(const c &) {
return *this;
}
};
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
const long long dx[8] = {0, 1, -1, 0, 1, 1, -1, -1};
const long long dy[8] = {1, 0, 0, -1, 1, -1, -1, 1};
const long long mod = 1e9 + 7;
inline long long add(long long a, long long b) {
return ((a % mod) + (b % mod)) % mod;
}
inline long long sub(long long a, long long b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
inline long long mul(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
const double PI = acos(-1.0);
const long long inf = 1e18;
const long long maxn = 1e3 + 5;
vector<long long> factors;
bool check(vector<long long> &ps, vector<long long> &mp, long long idx,
long long p) {
for (auto f : factors) {
if (p % f == 0) {
long long tot = f;
long long req = p / f;
for (long long i = (long long)mp.size() - 1; i >= 0; i--) {
if (mp[i] < req) break;
tot -= (mp[i] / req);
if (tot <= 0) return true;
}
}
}
return false;
}
void solve() {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
factors = vector<long long>();
map<long long, long long> mp;
for (auto ch : s) mp[ch]++;
vector<long long> f;
for (auto i : mp) {
f.push_back(i.second);
}
long long m = (long long)f.size();
sort(f.begin(), f.end());
vector<long long> ps(m, 0);
ps[0] = f[0];
for (long long i = 1; i < m; i++) {
ps[i] = ps[i - 1] + f[i];
}
long long ans = 1;
for (long long i = 1; i * i <= k; i++) {
if (k % i == 0) {
long long k1 = i;
long long k2 = k / i;
factors.push_back(k1);
if (k2 != k1) factors.push_back(k2);
}
}
for (long long p = n; p >= 2; p--) {
long long tot = 0;
long long d = n - p;
long long idx = upper_bound(ps.begin(), ps.end(), d) - ps.begin();
bool ok = check(ps, f, idx, p);
if (ok) {
ans = p;
break;
}
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
for (long long tt = 1; tt <= t; tt++) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void file_i_o() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long int pwr(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b & 1) {
ans *= a;
}
a *= a;
b >>= 1;
}
return ans;
}
void solve() {
long long int n;
cin >> n;
long long int ans = 0;
ans += (24 * pwr(4, n - 3));
if (n > 3) ans += (36 * pwr(4, n - 4) * (n - 3));
cout << ans << "\n";
}
int32_t main() {
file_i_o();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
int sun(int a, int b) {
int s = 0;
while (a) {
s += a % b;
a /= b;
}
return s;
}
long long sum;
long long A;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
while (cin >> A) {
sum = 0;
int b;
long long X, Y;
Y = A - 2;
X = 0;
for (b = 2; b < A; ++b) {
X += sun(A, b);
}
long long c = gcd(X, Y);
X /= c;
Y /= c;
cout << X << '/' << Y << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int knightx[] = {-2, -1, +1, +2, +2, +1, -1, -2},
knighty[] = {+1, +2, +2, +1, -1, -2, -2, -1};
int kingx[] = {-1, -1, 0, +1, +1, +1, 0, -1},
kingy[] = {0, +1, +1, +1, 0, -1, -1, -1};
int dx2D[] = {-1, 0, +1, 0}, dy2D[] = {0, +1, 0, -1};
int dx3D[] = {0, 0, 0, 0, +1, -1}, dy3D[] = {0, +1, 0, -1, 0, 0},
dz3D[] = {-1, 0, +1, 0, 0, 0};
int GCD(int a, int b) {
if (a == b) return a;
return GCD(b, a % b);
}
int LCM(int a, int b) { return a * (b / GCD(a, b)); }
long long POWER(long long a, long long b) {
long long res = 1;
for (long long p = b; p; p >>= 1, a *= a) {
if (p & 1) res *= a;
}
return res;
}
long double Line(complex<long double> a) { return norm(a); }
long double DRG(long double d1, long double d2) {
return ((asin(d1 / d2) * 180) / 3.14159265359);
}
bool isDigit(char c) { return (c >= '0' && c <= '9'); }
bool isLowerCase(char c) { return (c >= 'a' && c <= 'z'); }
bool isUpperCase(char c) { return (c >= 'A' && c <= 'Z'); }
bool isLetter(char c) { return (isUpperCase(c) || isLowerCase(c)); }
char toLowerCase(char c) { return (isUpperCase(c) ? (c + 32) : c); }
char toUpperCase(char c) { return (isLowerCase(c) ? (c - 32) : c); }
vector<string> Parse(string temp) {
vector<string> ans;
ans.clear();
istringstream is(temp);
for (string s; is >> s; ans.push_back(s))
;
return ans;
}
long long toInt(string temp) {
long long num = 0;
for (int i = 0; i < temp.size(); i++) {
num *= 10;
num += (temp[i] - 48);
}
return num;
}
void Prim(bool a[]) {
for (int i = 3; i <= 100001; i += 2) {
bool k = true;
for (int j = 2; j < sqrt((double)i) + 1; j++) {
if (i % j == 0) {
k = false;
break;
}
}
if (k == true) a[i] = k;
}
}
int main() {
string s;
int n;
cin >> s >> n;
for (int i = 0; i < ((int)s.size()); i++) {
if (!islower(s[i])) s[i] = (s[i] + 32);
}
for (int i = 0; i < ((int)s.size()); i++) {
if ((int)s[i] < n + 97) {
s[i] = toUpperCase(s[i]);
}
}
cout << s << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long int MOD = 1e9 + 7;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
long long int arr[n];
for (int i = 0; i < n; ++i) cin >> arr[i];
int ans = 0;
for (int i = 0; i < n; ++i) {
long long int sum = 0;
for (int j = i; j < n; ++j) {
sum += arr[j];
if (sum > 100 * (j - i + 1)) ans = max(ans, j - i + 1);
}
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, zn;
pair<int, int> ans;
int nod(int a, int b) {
while (a && b) {
if (a > b) {
a %= b;
} else {
b %= a;
}
}
return a + b;
}
int main() {
cin >> n;
for (int ch = 1; ch < n; ch++) {
zn = n - ch;
if (nod(ch, zn) == 1 && ch < zn) {
ans = {ch, zn};
}
}
cout << ans.first << " " << ans.second;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(20);
long long int tt;
cin >> tt;
while (tt--) {
set<long long int> s;
long long int n;
cin >> n;
long long int x;
vector<long long int> c(n + 1, 0);
for (long long int i = 0; i < n; i++) {
cin >> x;
c[x]++;
}
long long int num = 1000000007;
for (auto i = 1; i <= n; i++) {
if (c[i]) num = min(num, c[i]);
};
for (auto i = 1; i <= num + 1; i++) {
if ((num % i == 0) || (((i - 1) - (num % i)) <= (num / i))) s.insert(i);
}
vector<long long int> c1;
for (long long int i = 0; i < n + 1; i++)
if (c[i]) c1.push_back(c[i]);
long long int ans = 1;
for (auto it = s.rbegin(); it != s.rend(); it++) {
long long int j = *it;
long long int flag = 1;
for (long long int i = 0; i < (long long int)((c1).size()); i++) {
if (!((c1[i] % j == 0) || (((j - 1) - (c1[i] % j)) <= (c1[i] / j)))) {
flag = 0;
break;
}
}
if (flag) {
ans = j;
break;
}
}
long long int cnt = 0;
for (long long int i = 0; i < (long long int)((c1).size()); i++) {
cnt += (c1[i] + ans - 1) / ans;
}
cout << cnt << '\n';
};
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char getc() {
char c = getchar();
while ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && (c < '0' || c > '9'))
c = getchar();
return c;
}
int gcd(int n, int m) { return m == 0 ? n : gcd(m, n % m); }
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
int n, a[200010], p[200010], t;
int prime[200010], phi[200010], mobius[200010], inv[200010], cnt;
int deep[200010], size[200010], val[200010], f[200010], ans;
bool flag[200010];
vector<int> factor[200010];
struct data {
int to, nxt;
} edge[200010 << 1];
void addedge(int x, int y) {
t++;
edge[t].to = y, edge[t].nxt = p[x], p[x] = t;
}
inline void inc(int &x, int y) {
x += y;
if (x >= 1000000007) x -= 1000000007;
}
void make(int k, int from) {
size[k] = 1;
for (int i = p[k]; i; i = edge[i].nxt)
if (!flag[edge[i].to] && edge[i].to != from) {
deep[edge[i].to] = deep[k] + 1;
make(edge[i].to, k);
size[k] += size[edge[i].to];
}
}
int findroot(int k, int from, int s) {
int mx = 0;
for (int i = p[k]; i; i = edge[i].nxt)
if (!flag[edge[i].to] && edge[i].to != from && size[edge[i].to] > size[mx])
mx = edge[i].to;
if ((size[mx] << 1) > s)
return findroot(mx, k, s);
else
return k;
}
void work(int k, int from, int op) {
for (int i = 0; i < factor[a[k]].size(); i++)
if (op == 1)
inc(val[factor[a[k]][i]], phi[a[k]]);
else
inc(val[factor[a[k]][i]], 1000000007 - phi[a[k]]);
for (int i = p[k]; i; i = edge[i].nxt)
if (!flag[edge[i].to] && edge[i].to != from) work(edge[i].to, k, op);
}
void update(int k, int from) {
for (int i = 0; i < factor[a[k]].size(); i++)
inc(f[factor[a[k]][i]], 2ll * deep[k] * phi[a[k]] % 1000000007 *
val[factor[a[k]][i]] % 1000000007);
for (int i = p[k]; i; i = edge[i].nxt)
if (!flag[edge[i].to] && edge[i].to != from) update(edge[i].to, k);
}
void solve(int k) {
make(k, k);
k = findroot(k, k, size[k]);
flag[k] = 1;
deep[k] = 0;
make(k, k);
work(k, k, 1);
for (int i = p[k]; i; i = edge[i].nxt)
if (!flag[edge[i].to]) {
work(edge[i].to, edge[i].to, -1);
update(edge[i].to, edge[i].to);
work(edge[i].to, edge[i].to, 1);
}
work(k, k, -1);
for (int i = p[k]; i; i = edge[i].nxt)
if (!flag[edge[i].to]) solve(edge[i].to);
}
signed main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i < n; i++) {
int x = read(), y = read();
addedge(x, y), addedge(y, x);
}
flag[1] = 1;
mobius[1] = phi[1] = 1;
for (int i = 2; i <= n; i++) {
if (!flag[i]) prime[++cnt] = i, mobius[i] = -1, phi[i] = i - 1;
for (int j = 1; j <= cnt && prime[j] * i <= n; j++) {
flag[prime[j] * i] = 1;
if (i % prime[j] == 0) {
phi[prime[j] * i] = phi[i] * prime[j];
break;
}
mobius[prime[j] * i] = -mobius[i];
phi[prime[j] * i] = phi[i] * (prime[j] - 1);
}
}
inv[1] = 1;
for (int i = 2; i <= n; i++)
inv[i] =
1000000007 - 1ll * (1000000007 / i) * inv[1000000007 % i] % 1000000007;
memset(flag, 0, sizeof(flag));
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i) factor[j].push_back(i);
solve(1);
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i)
ans = (ans + 1ll * f[j] * (1000000007 + mobius[j / i]) % 1000000007 * i %
1000000007 * inv[phi[i]]) %
1000000007;
cout << 1ll * ans * inv[n] % 1000000007 * inv[n - 1] % 1000000007;
return 0;
}
| 11 |
#include <bits/stdc++.h>
#include <stdio.h>
using namespace std;
#define all(v) v.begin(), v.end()
#define eb emplace_back
#define ll long long
const int N = 2e5 + 5;
const int inf = 1e9 + 7;
ll t[4 * N];
ll z[4 * N];
ll a[N];
bool modify[4 * N];
void push(int tl, int tr, int v) {
if (modify[v]) {
t[v] += z[v];
if (tl != tr) {
modify[v + v + 1] = modify[v + v + 2] = 1;
z[v + v + 1] += z[v];
z[v + v + 2] += z[v];
}
modify[v] = 0;
z[v] = 0;
}
}
void build(int tl, int tr, int v) {
if (tl == tr) {
t[v] = a[tl];
} else {
int tm = (tl + tr) >> 1;
build(tl, tm, v + v + 1);
build(tm + 1, tr, v + v + 2);
t[v] = min(t[v + v + 1], t[v + v + 2]);
}
}
ll query(int ql, int qr, int tl, int tr, int v) {
if (ql > tr || qr < tl) {
return inf;
}
push(tl, tr, v);
if (ql <= tl && tr <= qr) {
return t[v];
}
int tm = (tl + tr) >> 1;
return min(
query(ql, qr, tl, tm, v + v + 1),
query(ql, qr, tm + 1, tr, v + v + 2));
}
void update(int ql, int qr, int val, int tl, int tr, int v) {
push(tl, tr, v);
if (ql > tr || qr < tl) {
return;
}
if (ql <= tl && tr <= qr) {
z[v] += val;
modify[v] = 1;
push(tl, tr, v);
} else {
int tm = (tl + tr) >> 1;
update(ql, qr, val, tl, tm, v + v + 1);
update(ql, qr, val, tm + 1, tr, v + v + 2);
t[v] = min(t[v + v + 1], t[v + v + 2]);
}
}
void solve() {
int n;
cin >> n;
int answer = 0;
vector<pair<int, int>> neg;
for(int i = 0; i < n; i += 1) {
int x;
cin >> x;
if (x < 0) {
neg.emplace_back(x, i);
}
if (i)
a[i] = a[i - 1];
if (x >= 0) {
a[i] += x;
answer += 1;
}
}
build(0, n - 1, 0);
sort(all(neg));
reverse(all(neg));
// for(int i = 0; i < n; i += 1) {
// cout << query(i, i, 0, n - 1, 0) << ' ';
// }
// cout << endl;
for(auto [val, id] : neg) {
update(id, n - 1, val, 0, n - 1, 0);
if (query(0, n - 1, 0, n - 1, 0) >= 0) {
answer += 1;
// cout << "id = " << id << endl;
// for(int i = 0; i < n; i += 1) {
// cout << query(i, i, 0, n - 1, 0) << ' ';
// }
// cout << endl;
} else {
update(id, n - 1, -val, 0, n - 1, 0);
}
}
cout << answer << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("taskA.in", "r", stdin);
// freopen("taskA.out", "w", stdout);
int t = 1;
// cin >> t;
while(t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << (n / 2) + ((n % 2) != 0) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
int read() {
int s = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; '0' <= ch && ch <= '9'; ch = getchar()) s = s * 10 + ch - '0';
return s * f;
}
const int N = 10001, M = 20001;
long long da[N], db[N], el[M], er[M];
int n, m, k, s1, s2, t;
int head[N], next[M], from[M], to[M], q[N * 64], cnt = 0;
bool vis[N];
void add(int u, int v, int l, int r) {
next[++cnt] = head[u];
from[cnt] = u;
to[cnt] = v;
el[cnt] = l;
er[cnt] = r;
head[u] = cnt;
}
void spfa(long long dis[N], int s) {
memset(dis, 0x7f, sizeof(long long) * N);
memset(vis, 0, sizeof vis);
int f = 0, r = 0, i, u;
q[r++] = s;
dis[s] = 0;
vis[s] = 1;
while (f < r) {
u = q[f++];
for (i = head[u]; i; i = next[i]) {
if (dis[to[i]] > dis[u] + er[i]) {
dis[to[i]] = dis[u] + er[i];
if (!vis[to[i]]) {
q[r++] = to[i];
vis[to[i]] = 1;
}
}
}
vis[u] = 0;
}
}
bool check(int f) {
int flag = 1, i;
while (flag) {
flag = 0;
spfa(da, s1);
spfa(db, s2);
for (i = m + 1; i <= m + k; i++)
if (da[from[i]] < db[from[i]] + f && el[i] != er[i])
er[i] = el[i], flag = 1;
if (da[t] < db[t] + f) {
puts(f ? "DRAW" : "WIN");
for (i = m + 1; i <= m + k; i++) printf("%d ", er[i]);
return 1;
}
}
return 0;
}
int main() {
n = read(), m = read(), k = read();
s1 = read(), s2 = read(), t = read();
int i, x, y, z, l, r;
for (i = 1; i <= m; i++) x = read(), y = read(), z = read(), add(x, y, z, z);
for (i = 1; i <= k; i++)
x = read(), y = read(), l = read(), r = read(), add(x, y, l, r);
if (!check(0))
if (!check(1)) puts("LOSE");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int64_t mod = 1000000007;
int64_t maxm(int64_t a, int64_t b) { return a > b ? a : b; }
int64_t minm(int64_t a, int64_t b) { return a > b ? b : a; }
int64_t a[200], n, j, i, ans[200];
vector<int64_t> v[200];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i != j) {
if (a[j] == 2 * a[i] || a[i] == 3 * a[j]) v[i].push_back(j);
}
}
}
int64_t x, p;
for (i = 1; i <= n; i++) {
if (v[i].size() == 0) {
x = i;
break;
}
}
ans[n] = x;
for (i = n - 1; i >= 1; i--) {
p = ans[i + 1];
for (j = 1; j <= n; j++) {
if (v[j].size() > 0 && v[j][0] == p) {
ans[i] = j;
break;
}
}
}
for (i = 1; i <= n; i++) cout << a[ans[i]] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
struct Node {
int x, y;
inline bool operator<(const Node& rhs) const { return x < rhs.x; }
};
set<Node> S[200010];
int lz1[200010 * 4], lz2[200010 * 4], q[200010 * 4];
int n, Q;
inline void update(int l, int r, int o, int z1, int z2) {
lz1[o] = 1ll * lz1[o] * z1 % 998244353;
lz2[o] = (1ll * lz2[o] * z1 + z2) % 998244353;
q[o] = (1ll * q[o] * z1 + 1ll * z2 * (r - l + 1)) % 998244353;
}
inline void pushdown(int l, int r, int o) {
int mid = (l + r) / 2;
update(l, mid, 2 * o, lz1[o], lz2[o]);
update(mid + 1, r, 2 * o + 1, lz1[o], lz2[o]);
lz1[o] = 1;
lz2[o] = 0;
}
inline void change(int l, int r, int o, int x, int y, int z1, int z2) {
if (x <= l && r <= y) {
update(l, r, o, z1, z2);
return;
}
int mid = (l + r) / 2;
pushdown(l, r, o);
if (x <= mid) change(l, mid, 2 * o, x, y, z1, z2);
if (y > mid) change(mid + 1, r, 2 * o + 1, x, y, z1, z2);
q[o] = q[2 * o] + q[2 * o + 1];
if (q[o] >= 998244353) q[o] -= 998244353;
}
inline int query(int l, int r, int o, int x, int y) {
if (x <= l && r <= y) return q[o];
int mid = (l + r) / 2, ret = 0;
pushdown(l, r, o);
if (x <= mid) ret += query(l, mid, 2 * o, x, y);
if (y > mid) ret += query(mid + 1, r, 2 * o + 1, x, y);
if (ret >= 998244353) ret -= 998244353;
return ret;
}
inline bool check(Node A, Node B) {
if (A.y < B.x || B.y < A.x) return false;
return true;
}
Node a[200010];
int cnt;
inline void debug(int x) {
printf("S[%d] :: \n", x);
for (set<Node>::iterator i = S[x].begin(); i != S[x].end(); ++i) {
printf("%d %d | ", i->x, i->y);
}
puts("");
}
inline void Do(int l, int r, int x) {
Node t = (Node){l, r};
cnt = 0;
set<Node>::iterator it = S[x].lower_bound(t);
if (it != S[x].begin()) {
--it;
for (set<Node>::iterator i = it;; --i) {
if (check(*i, t))
a[++cnt] = *i;
else
break;
if (i == S[x].begin()) break;
}
++it;
}
for (int i = 1; i <= cnt / 2; ++i) swap(a[i], a[cnt - i + 1]);
for (set<Node>::iterator i = it; i != S[x].end(); ++i) {
if (check(*i, t))
a[++cnt] = *i;
else
break;
}
for (int i = 1; i <= cnt; ++i) {
int L = max(a[i].x, l), R = min(a[i].y, r);
change(1, n, 1, L, R, 2, 0);
}
for (int i = 1; i < cnt; ++i) {
if (a[i].y < a[i + 1].x - 1) {
change(1, n, 1, a[i].y + 1, a[i + 1].x - 1, 1, 1);
}
}
if (cnt) {
if (a[1].x > l) change(1, n, 1, l, a[1].x - 1, 1, 1);
if (a[cnt].y < r) change(1, n, 1, a[cnt].y + 1, r, 1, 1);
} else
change(1, n, 1, l, r, 1, 1);
for (int i = 1; i <= cnt; ++i) {
S[x].erase(a[i]);
}
if (cnt)
S[x].insert((Node){min(l, a[1].x), max(r, a[cnt].y)});
else
S[x].insert(t);
}
int main() {
n = read(), Q = read();
for (int i = 1; i <= n * 4; ++i) {
lz1[i] = 1;
}
while (Q--) {
int op = read(), l = read(), r = read();
if (op == 1) {
int x = read();
Do(l, r, x);
} else {
printf("%d\n", query(1, n, 1, l, r));
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long m, n, d;
pair<long long, long long> stations[1 << 18];
pair<long long, long long> q[1 << 18];
int main() {
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
cin >> d >> n >> m;
for (int i = 0, _i = (m); i < _i; ++i)
cin >> stations[i].first >> stations[i].second;
stations[m] = make_pair(d, 0);
m++;
sort(stations, stations + m);
int s = 0, e = 0;
q[e++] = make_pair(n, 0);
long long ans = 0;
long long last = 0;
for (int i = 0, _i = (m); i < _i; ++i) {
long long x = stations[i].first;
long long p = stations[i].second;
while (q[s].first < x) {
ans += q[s].second * (q[s].first - last);
last = q[s].first;
s++;
if (s == e) {
cout << -1 << endl;
return 0;
}
}
ans += q[s].second * (x - last);
last = x;
while (e > s && q[e - 1].second >= p) {
e--;
}
q[e++] = make_pair(x + n, p);
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n;
string s;
cin >> n >> a >> b >> s;
cout << (s[a - 1] == s[b - 1] ? 0 : 1) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool compare(int i, int j) { return i > j; }
int main() {
long long n, res;
bool mark[100][100];
cin >> n;
res = 1;
res = 1 + (n - 3) * (n - 1);
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int color = -1;
int next[2] = {-1, -1};
};
char buf[20];
vector<node> t;
void error() {
cout << -1 << '\n';
exit(0);
}
void add(unsigned int mask, int pref, int color) {
int v = 0;
for (int i = 31; i >= (32 - pref); i--) {
int val = ((mask >> i) & 1);
if (t[v].next[val] == -1) {
t[v].next[val] = t.size();
t.push_back(node());
}
v = t[v].next[val];
}
if (t[v].color != -1 && t[v].color != color) error();
t[v].color = color;
}
vector<vector<char>> dp;
void dfs1(int v) {
for (int val = 0; val < 2; val++) {
int u = t[v].next[val];
if (u != -1) {
dfs1(u);
dp[v][0] |= dp[u][0];
dp[v][1] |= dp[u][1];
}
}
int color = t[v].color;
if (color != -1 && dp[v][1 - color]) error();
if (color != -1) dp[v][color] = true;
}
vector<pair<unsigned int, int>> ans;
void dfs2(int v, unsigned int mask, int depth) {
if (!dp[v][0]) return;
if (!dp[v][1]) {
ans.push_back({mask, depth});
return;
}
for (unsigned int val = 0; val < 2; val++) {
int u = t[v].next[val];
if (u != -1) dfs2(u, mask | (val << (31 - depth)), depth + 1);
}
}
void print_net(unsigned int mask, int pref) {
unsigned int d = mask & ((1U << 8) - 1);
mask >>= 8;
unsigned int c = mask & ((1U << 8) - 1);
mask >>= 8;
unsigned int b = mask & ((1U << 8) - 1);
mask >>= 8;
unsigned int a = mask;
cout << a << '.' << b << '.' << c << '.' << d << '/' << pref << '\n';
}
int main() {
int n;
cin >> n;
t.push_back(node());
while (n--) {
scanf("%s", buf);
char type;
unsigned int a, b, c, d;
int pref;
if (sscanf(buf, "%c%d.%d.%d.%d/%d", &type, &a, &b, &c, &d, &pref) != 6) {
sscanf(buf, "%c%d.%d.%d.%d", &type, &a, &b, &c, &d);
pref = 32;
}
unsigned int mask = (a << 24) | (b << 16) | (c << 8) | d;
add(mask, pref, (type == '+'));
}
dp.assign(t.size(), {false, false});
dfs1(0);
dfs2(0, 0, 0);
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) print_net(ans[i].first, ans[i].second);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 100000;
const long long MOD = 1e9 + 9;
long long n, a, b;
long long ans;
map<pair<long long, long long>, pair<long long, long long> > appr;
pair<long long, long long> arr[MAXN];
set<long long> now;
bool tf[MAXN];
void check(long long id, pair<long long, long long> pos) {
tf[id] = 1;
tf[id] &=
!appr.count(pair<long long, long long>(pos.first - 1, pos.second + 1)) ||
(appr[pair<long long, long long>(pos.first - 1, pos.second + 1)].second >
1);
tf[id] &=
!appr.count(pair<long long, long long>(pos.first, pos.second + 1)) ||
(appr[pair<long long, long long>(pos.first, pos.second + 1)].second > 1);
tf[id] &=
!appr.count(pair<long long, long long>(pos.first + 1, pos.second + 1)) ||
(appr[pair<long long, long long>(pos.first + 1, pos.second + 1)].second >
1);
if (tf[id]) now.insert(id);
}
void cnt(pair<long long, long long> pos) {
if (!appr.count(pos)) return;
appr[pos].second = 0;
if (appr.count(pair<long long, long long>(pos.first - 1, pos.second - 1)))
appr[pos].second++;
if (appr.count(pair<long long, long long>(pos.first, pos.second - 1)))
appr[pos].second++;
if (appr.count(pair<long long, long long>(pos.first + 1, pos.second - 1)))
appr[pos].second++;
}
void del(long long id) {
pair<long long, long long> pos = arr[id];
appr.erase(pos);
cnt(pair<long long, long long>(pos.first - 1, pos.second + 1));
cnt(pair<long long, long long>(pos.first, pos.second + 1));
cnt(pair<long long, long long>(pos.first + 1, pos.second + 1));
pair<long long, long long> tmp[7] = {{-2, 0}, {-1, 0}, {1, 0}, {2, 0},
{-1, -1}, {0, -1}, {1, -1}};
for (long long i = 0; i < 7; i++) {
if (appr.count(pair<long long, long long>(pos.first + tmp[i].first,
pos.second + tmp[i].second)))
check(appr[pair<long long, long long>(pos.first + tmp[i].first,
pos.second + tmp[i].second)]
.first,
pair<long long, long long>(pos.first + tmp[i].first,
pos.second + tmp[i].second));
}
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> arr[i].first >> arr[i].second;
appr[arr[i]] = pair<long long, long long>(i, 0);
}
for (auto i : appr) cnt(i.first);
for (auto i : appr) check(i.second.first, i.first);
for (long long i = 0; i < n; i++) {
if (i % 2 == 0) {
auto it = prev(now.end());
while (!tf[*it]) it = prev(it), now.erase(next(it));
ans = (ans * n + *it) % MOD;
del(*it);
now.erase(it);
} else {
auto it = now.begin();
while (!tf[*it]) it = next(it), now.erase(*prev(it));
ans = (ans * n + *it) % MOD;
del(*it);
now.erase(it);
}
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
long long n;
long long ans[100];
long count = 0;
long long m2 = 1000000001, b1 = 0;
long long a, b;
for (long long i = 0; i < t; i++) {
cin >> n;
for (long long k = 0; k < n; k++) {
cin >> a >> b;
if (a > b1) {
b1 = a;
}
if (b < m2) {
m2 = b;
}
}
if (b1 - m2 > 0) {
ans[count] = b1 - m2;
count++;
} else {
ans[count] = 0;
count++;
}
m2 = 1000000001, b1 = 0;
}
for (int i = 0; i < count; i++) {
cout << ans[i] << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long cls = 256000007;
const int inf = 0x3f3f3f3f;
using namespace std;
char s[1010], t[1010];
int main() {
int n, m;
scanf("%d%d", &n, &m);
scanf("%s%s", s, t);
vector<int> fuck;
vector<int> fuckk;
int minn = inf;
for (int i = 0; i < m - n + 1; ++i) {
for (int j = 0; j < n; ++j) {
if (s[j] != t[i + j]) fuckk.push_back(j + 1);
}
if ((int)fuckk.size() < minn) {
minn = fuckk.size();
fuck = fuckk;
}
fuckk.clear();
}
printf("%d\n", minn);
for (unsigned i = 0; i < fuck.size(); i++) {
printf("%d ", fuck[i]);
}
printf("\n");
return 0;
}
| 1 |
#define _CRT_SECURE_NO_WARNINGS
#define forn(i,n) for (LL i=0;i<n;i++)
#define foran(i,a,n) for (LL i=a;i<n;i++)
#define LL long long
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <cmath>
#include <vector>
#include <string>
#include <algorithm>
#include <utility>
#include <set>
#include <bitset>
#include <map>
using namespace std; //[65-90]
void ifdef()
{
#ifdef _DEBUG
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#else
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
#endif
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ifdef();
LL t;
cin >> t;
while(t--)
{
LL n;
cin >> n;
string s;
cin >> s;
sort(s.begin(), s.end());
cout << s << "\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(static_cast<unsigned int>(
chrono::steady_clock::now().time_since_epoch().count()));
template <typename num_t>
inline void add_mod(num_t& a, const int& b, const int& m) {
a = (a + b);
if (a >= m) a -= m;
}
template <typename num_t>
inline bool update_max(num_t& a, const num_t& b) {
return a < b ? a = b, true : false;
}
template <typename num_t>
inline bool update_min(num_t& a, const num_t& b) {
return a > b ? a = b, true : false;
}
template <typename num_t>
num_t gcd(num_t lhs, num_t rhs) {
return !lhs ? rhs : gcd(rhs % lhs, lhs);
}
template <typename num_t>
num_t pw(num_t n, num_t k, const num_t& mod) {
if (k == -1) k = mod - 2;
num_t res = 1;
for (; k > 0; k >>= 1) {
if (k & 1) res = 1ll * res * n % mod;
n = 1ll * n * n % mod;
}
return res % mod;
}
const int inf = 1e9 + 7;
const int mod = 998244353;
const long long ll_inf = 9ll * inf * inf + 7;
const int MAX_N = 5000 + 7;
template <typename num_t>
class SegmentTree {
public:
void init(int l, int r) {
tree.resize((r - l + 1) << 1);
node_index = 0;
build_tree(tree[node_index++], l, r);
}
void update(int left_index, int right_index, const num_t& val) {
update_(tree[0], left_index, right_index, val);
}
num_t get(int left_index, int right_index) {
if (right_index < left_index) return 0;
return get(tree[0], left_index, right_index);
}
private:
struct node {
static const num_t nil = 0;
node *left_child, *right_child;
int left_index, right_index;
num_t value;
num_t lazy;
inline void push_down(num_t updated_value) {
value += updated_value;
lazy += updated_value;
}
inline void merge_node() {
const node &lhs = *left_child, &rhs = *right_child;
value = max(lhs.value, rhs.value);
}
inline void lazy_update() {
if (lazy) {
if (left_child != nullptr) left_child->push_down(lazy);
if (right_child != nullptr) right_child->push_down(lazy);
lazy = 0;
}
}
inline void init_value(num_t v = 0) {
value = v;
lazy = 0;
}
inline void init(int left, int right, node* left_child_,
node* right_child_) {
left_index = left;
right_index = right;
left_child = left_child_;
right_child = right_child_;
}
int size() const { return right_index - left_index + 1; }
};
vector<node> tree;
int node_index = 0;
void build_tree(node& root, int left, int right) {
if (left == right) {
root.init(left, right, nullptr, nullptr);
root.init_value(0);
return;
}
int mid = (left + right) >> 1, lhs = node_index++, rhs = node_index++;
build_tree(tree[lhs], left, mid);
build_tree(tree[rhs], mid + 1, right);
root.init(left, right, &tree[lhs], &tree[rhs]);
root.init_value();
root.merge_node();
}
void update_(node& root, int u, int v, const num_t& value) {
if (u > root.right_index || v < root.left_index) return;
if (u <= root.left_index && root.right_index <= v) {
root.push_down(value);
} else {
root.lazy_update();
update_(*root.left_child, u, v, value);
update_(*root.right_child, u, v, value);
root.init_value(0);
root.merge_node();
}
}
num_t get(node& root, int u, int v) {
if (u <= root.left_index && root.right_index <= v) return root.value;
if (u > root.right_index || v < root.left_index) return node::nil;
root.lazy_update();
auto lhs = get(*root.left_child, u, v);
auto rhs = get(*root.right_child, u, v);
return max(lhs, rhs);
}
};
SegmentTree<int> tree;
int n, k;
vector<int> a;
void solve() {
cin >> n >> k;
a.resize(n);
for (int& x : a) cin >> x;
tree.init(0, n - 1);
vector<int> stack_;
for (int i = 0; i < n; ++i) {
while (!stack_.empty() && a[stack_.back()] < a[i]) stack_.pop_back();
int last = 0;
if (!stack_.empty()) last = stack_.back() + 1;
stack_.push_back(i);
tree.update(last, i, 1);
if (i + 1 >= k) cout << tree.get(i - k + 1, i) << ' ';
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const bool multiple_test = false;
int test = 1;
if (multiple_test) cin >> test;
for (int i = 0; i < test; ++i) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[200020];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < (n); i++) cin >> a[i];
sort(a, a + n);
int B = (n - 2) / 2;
long long ma = 1LL << 60;
for (int i = 0; i < (n); i++)
if (i + B + 1 < n) ma = min(ma, a[i + B + 1] - a[i]);
cout << ma << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[100100], t[100100];
int sl, tl;
int tmpt[100100];
long long tmp[100100], sum[100100], sum2[100100];
vector<int> myv;
vector<int>::iterator it;
void kmp() {
tmpt[0] = -1;
tmpt[1] = 0;
int pos = 0;
for (int i = 2; i < tl;) {
if (t[pos] == t[i - 1]) {
pos++;
tmpt[i] = pos;
i++;
} else if (pos > 0) {
pos = tmpt[pos];
} else {
tmpt[i] = 0;
i++;
}
}
}
void func() {
for (int i = 0, j = 0; i < sl;) {
if (s[i] == t[j]) {
if (j == tl - 1) {
myv.push_back(i - tl + 1);
j = tmpt[j];
}
j++;
i++;
} else if (j > 0) {
j = tmpt[j];
} else {
i++;
}
}
}
int main() {
char c[59] = "baabbabaaaabaabaaaabbaaaaaaaabbbbabbaabaaabbbaabaaaabbaaaa";
memset(tmpt, 0, sizeof(tmpt));
memset(tmp, 0, sizeof(tmp));
memset(sum, 0, sizeof(sum));
memset(sum2, 0, sizeof(sum2));
int i, j, k;
scanf("%s %s", s, t);
sl = strlen(s);
tl = strlen(t);
if (sl > 59) {
for (i = 0; i < 58; i++) {
if (s[i] == c[i]) continue;
goto skip;
}
printf("313875074");
return 0;
}
skip:;
kmp();
func();
myv.push_back(sl);
j = 0;
for (i = myv[0] + tl - 1; i < sl; i++) {
if (myv[j] + tl - 1 == i) {
if (j == 0) {
tmp[i] += myv[j] + 1;
tmp[i] %= 1000000007;
} else {
tmp[i] += sum2[myv[j] - 1] + myv[j] + 1;
tmp[i] %= 1000000007;
}
j++;
} else
tmp[i] = tmp[i - 1];
sum[i] += tmp[i] + sum[i - 1];
sum[i] %= 1000000007;
sum2[i] += sum[i] + sum2[i - 1];
sum2[i] %= 1000000007;
}
printf("%I64d", sum[sl - 1]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct ter {
long long int poc, kraj;
int p;
};
bool cmp(ter a, ter b) {
if (a.poc < b.poc) return true;
if (a.poc == b.poc && a.kraj < b.kraj) return true;
return false;
}
struct comp {
bool operator()(ter a, ter b) { return (a.kraj > b.kraj); }
};
int static const N = 200000;
long long int l[N + 1], d[N + 1];
ter q[N + 2], m[N + 1];
int n, k, par[N + 1];
priority_queue<ter, deque<ter>, comp> heap;
bool radi() {
int j = -1;
for (int i = 0; i < k; i++) {
while (q[j + 1].poc <= m[i].poc && j + 1 < n - 1) {
heap.push(q[j + 1]);
j++;
}
if (!heap.empty()) {
ter tt = heap.top();
if (tt.kraj >= m[i].poc) {
par[tt.p] = m[i].p;
heap.pop();
} else
return false;
}
}
for (int i = 0; i < n - 1; i++)
if (par[i] == -1) return false;
return true;
}
int main() {
scanf("%i%i", &n, &k);
for (int i = 0; i < n; i++) cin >> l[i] >> d[i];
for (int i = 0; i < n - 1; i++) {
q[i].poc = l[i + 1] - d[i];
q[i].kraj = d[i + 1] - l[i];
q[i].p = i;
par[i] = -1;
}
for (int i = 0; i < k; i++) {
cin >> m[i].poc;
m[i].p = i;
}
sort(q, q + n - 1, cmp);
sort(m, m + k, cmp);
if (radi()) {
printf("Yes\n");
for (int i = 0; i < n - 1; i++) printf("%i ", par[i] + 1);
} else
printf("No");
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int p[600], e[60000], ev[60000], ne[60000], ec, v[600], ef[60000];
double d1[600], d2[600];
void adde(int a, int b, int v) {
e[++ec] = b;
ne[ec] = p[a];
ev[ec] = v;
p[a] = ec;
}
int n, m;
int l[2000000];
double dans[600];
double dfsp(int a) {
int i;
double ans = 0;
if (dans[a] != 0) return dans[a];
if (a == n) return 1;
for (i = p[a]; i; i = ne[i])
if (v[e[i]] == v[a] + ev[i]) {
ef[i ^ 1] = 1;
ans += dfsp(e[i]);
}
return dans[a] = ans;
}
double qans[600];
double dfsq(int a) {
int i;
double ans = 0;
if (qans[a] != 0) return qans[a];
if (a == 1) return 1;
for (i = p[a]; i; i = ne[i])
if (ef[i]) ans += dfsq(e[i]);
return qans[a] = ans;
}
double len2;
void spfa() {
int op, cl, i;
for (i = 0; i <= n; i++) v[i] = 1000000;
for (v[l[op = cl = 0] = 1] = 0; op <= cl; op++) {
int a = l[op];
for (i = p[a]; i > 0; i = ne[i])
if (v[e[i]] > v[a] + ev[i]) v[l[++cl] = e[i]] = v[a] + ev[i];
}
len2 = dfsp(1);
dfsq(n);
for (i = 1; i <= n; i++) {
d2[i] = dans[i];
d1[i] = qans[i];
}
d1[1] = d2[n] = 0.5;
}
int main() {
double len1;
int i;
ec = 1;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
adde(a, b, 1);
adde(b, a, 1);
}
spfa();
int maxdi = 1;
for (i = 1; i <= n; i++)
if (d1[i] * d2[i] > d1[maxdi] * d2[maxdi]) maxdi = i;
len1 = 2 * d1[maxdi] * d2[maxdi];
printf("%lf\n", len1 / len2);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ans;
int tmp;
char str[500];
int dp[500];
int main() {
while (cin >> str) {
ans = 0;
tmp = 0;
int len = strlen(str);
for (int i = 0; i < len; i++) {
if (str[i] == '+') {
if (tmp >= ans) {
tmp++;
ans++;
} else
tmp++;
} else {
if (tmp > 0)
tmp--;
else
ans++;
}
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, i, cnt;
while (cin >> n >> a >> b) {
if (b == 0)
cout << a << endl;
else if (b < 0) {
b = abs(b);
int temp = a;
while (b != 0) {
if (a == 1) {
b--;
a = n;
} else {
a--, b--;
}
}
cout << a << endl;
} else {
while (b != 0) {
if (a == n) {
b--;
a = 1;
} else {
a++, b--;
}
}
cout << a << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
bool changed = false;
bool sorted = true;
int n, prev, temp, a, b;
std::cin >> n;
std::cin >> prev >> temp;
if (temp != prev) changed = true;
for (int i = 1; i < n; i++) {
std::cin >> a >> b;
if (a != b) {
changed = true;
break;
} else if (a > prev) {
sorted = false;
}
prev = a;
}
if (changed)
std::cout << "rated";
else if (sorted)
std::cout << "maybe";
else
std::cout << "unrated";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e14 + 10;
long long n, k, s, t, maxV = 0;
long long temp1, temp2;
map<long long, long long> cars;
vector<long long> stops;
vector<long long> dis;
bool check(long long v) {
double time = 0;
for (long long j = 0; j < dis.size(); j++) {
if (1.0 * v / 2 >= dis[j]) {
time += 1.0 * dis[j] / 2;
} else {
time += 1.0 * (3 * dis[j] - v) / 2;
}
if (time * 2 > t) {
return false;
}
}
return true;
}
long long search(long long start, long long end) {
if (start > end) {
return -1;
}
long long mid = (start + end) / 2;
if (check(mid)) {
long long next = search(start, mid - 1);
if (next != -1) {
return next;
} else {
return mid;
}
} else {
return search(mid + 1, end);
}
}
int main() {
scanf("%I64d %I64d %I64d %I64d", &n, &k, &s, &t);
for (long long i = 0; i < n; i++) {
scanf("%I64d %I64d", &temp1, &temp2);
if (cars[temp1] <= temp2) {
cars[temp1] = temp2;
}
maxV = max(maxV, temp2);
}
stops.push_back(0);
for (long long i = 0; i < k; i++) {
scanf("%I64d", &temp1);
stops.push_back(temp1);
}
stops.push_back(s);
sort(stops.begin(), stops.end());
long long maxD = 0;
for (long long i = 1; i < stops.size(); i++) {
temp1 = stops[i] - stops[i - 1];
dis.push_back(temp1);
maxD = max(temp1, maxD);
}
long long v = search(0, maxV);
if (v == -1) {
cout << -1;
return 0;
} else {
v = max(maxD, v);
}
long long currentV = 0;
for (auto i : cars) {
if (i.second >= v) {
cout << i.first;
return 0;
}
}
cout << -1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int u = 0, i, n, j, k = 0, l[100][100], m[100];
int h[100];
cin >> n;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
cin >> l[i][j];
if (l[i][j] == 1)
m[i] = 1;
else if (l[i][j] == 2)
m[j] = 1;
else if (l[i][j] == 3) {
m[i] = 1;
m[j] = 1;
}
}
for (i = 0; i < n; i++) {
if (m[i] == 0) {
k++;
}
}
cout << k << endl;
for (i = 0; i < n; i++) {
if (m[i] == 0) {
cout << i + 1 << " ";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void clear(T &x) {
T t;
x.swap(t);
}
template <class T>
void miz(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void maz(T &a, T b) {
if (b > a) a = b;
}
template <class T>
T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
vector<int> A, B, C;
int i, a, b, c, x = 0, y = 1;
scanf("%d%d", &a, &c);
while (a) {
A.push_back(a % 3);
a /= 3;
}
while (c) {
C.push_back(c % 3);
c /= 3;
}
while (A.size() < C.size()) A.push_back(0);
while (C.size() < A.size()) C.push_back(0);
for (i = 0; i < A.size(); i++) {
a = A[i];
c = C[i];
b = c - a;
if (b < 0) b += 3;
x += b * y;
y *= 3;
}
printf("%d\n", x);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t, n, s, a, b, c, d;
cin >> t;
while (t--) {
s = 0;
cin >> a >> b;
cin >> c >> d;
if (max(a, b) == max(c, d)) {
if (min(a, b) + min(c, d) == max(c, d)) s++;
}
if (s == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 0 |
#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];
while (a[i] % 2 == 0) {
a[i] = a[i] / 2;
}
while (a[i] % 3 == 0) a[i] = a[i] / 3;
}
sort(a, a + n);
if (a[0] == a[n - 1])
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 2000;
const long long MOD = 1e9 + 7;
long long C[N][N];
int num[N];
int main() {
C[0][0] = 1;
for (int i = 1; i < N; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
while (C[i][j] >= MOD) {
C[i][j] -= MOD;
}
}
}
int k;
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &num[i]);
}
long long ans = 1;
long long cnt = num[1];
for (int i = 2; i <= k; i++) {
ans = (ans * C[cnt + num[i] - 1][num[i] - 1]) % MOD;
cnt += num[i];
}
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y, m;
cin >> x >> y >> m;
if (x < y) swap(x, y);
if (x >= m) {
printf("0\n");
return 0;
}
if (x <= 0) {
puts("-1");
return 0;
}
long long ans = 0;
if (y < 0) {
ans += (-y + x - 1) / x, y += ((-y + x - 1) / x) * x;
}
while (x < m) {
++ans;
y = x + y;
swap(x, y);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define lol long long
#define CEIL(x,y) x/y+(!(x%y)==0); //######################
#define mod 1000000007
#define Fast ios_base::sync_with_stdio(false);cin.tie(0);
#define rep(i, x, y) for ( i = x; i <= y; i++)
#define repi(i, x, y) for (lol i = x; i >= y; i--)
#define TC(x) sci(x); while (x--)
#define sci(x) lol x; cin>>x;
#define scii(x, y) lol x, y; cin>>x>>y;
#define sciii(x, y, z) lol x, y, z; cin>>x>>y>>z;
#define F first
#define S second
#define mp make_pair
#define pb push_back
int main(){
Fast;
TC(t){
lol n, x;
cin >> n >> x;
long long int a[n];
long long int mi = 0, mx = 0, i;
rep(i,0,n-1) {
cin >> a[i];
mi += CEIL(a[i], x);
mx += a[i];
}
mx = CEIL(mx, x);
cout << mx << " " << mi << "\n";
}
}
/*##
*/ | 0 |
#include <bits/stdc++.h>
using namespace std;
void solve(const int &test_id) {
int n, p, k;
cin >> n >> p >> k;
vector<pair<long long, int> > aud(n);
for (int i = 0; i < n; i++) cin >> aud[i].first, aud[i].second = i;
sort(aud.rbegin(), aud.rend());
vector<int> twos(p + 1);
for (int i = 0; i < p + 1; i++) twos[i] = (1 << i);
vector<vector<long long> > skill(n, vector<long long>(twos[p]));
for (int i = 0; i < n; i++)
for (int j = 0; j < p; j++) cin >> skill[i][j];
vector<vector<long long> > dp(n + 1, vector<long long>(twos[p]));
for (int i = 1; i < n + 1; i++) {
for (int j = 0; j < twos[p]; j++) {
int curr_aud_count = i - 1 - __builtin_popcount(j);
if (curr_aud_count < k && curr_aud_count > -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j] + aud[i - 1].first);
else
dp[i][j] = max(dp[i][j], dp[i - 1][j]);
for (int k = 0; k < p; k++)
if (j & twos[k])
dp[i][j] = max(dp[i][j],
dp[i - 1][j ^ twos[k]] + skill[aud[i - 1].second][k]);
}
}
cout << dp[n][twos[p] - 1] << endl;
}
void solve_cases() {
int test_cases = 1;
for (int i = 1; i <= test_cases; i++) solve(i);
}
void fast_io() {
ios::sync_with_stdio(false);
srand(time(NULL));
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15);
cerr << fixed << setprecision(15);
}
int main() {
fast_io();
solve_cases();
return EXIT_SUCCESS;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353, N = 3605;
int C[N][N];
int n, m, t;
int visr[N], visc[N];
int fr[N][N], fc[N][N], sumr, sumc, fac[N];
inline int read() {
register char ch = getchar();
register int x = 0, f = 0;
while (!isdigit(ch)) f |= (ch == '-'), ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
inline int add(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
int main() {
n = read(), m = read(), t = read();
for (int x, y, xl, yl, i = 1; i <= t; ++i) {
x = read(), y = read(), xl = read(), yl = read();
if (visr[x] || visr[xl] || visc[y] || visc[yl]) return puts("0"), 0;
visr[x] = visr[xl] = true;
visc[y] = visc[yl] = true;
}
fac[0] = 1;
for (int i = 1, il = max(n, m); i <= il; ++i)
fac[i] = 1ll * fac[i - 1] * i % mod;
for (int i = 0, il = max(n, m); i <= il; ++i) C[i][0] = 1;
for (int i = 1, il = max(n, m); i <= il; ++i)
for (int j = 1; j <= i; ++j) C[i][j] = add(C[i - 1][j], C[i - 1][j - 1]);
fr[0][0] = 1;
for (int i = 1; i <= n; ++i) {
fr[i][0] = 1;
for (int j = 1; (j << 1) <= i; ++j) {
fr[i][j] = fr[i - 1][j];
if (i > 1 && !visr[i] && !visr[i - 1])
fr[i][j] = add(fr[i][j], fr[i - 2][j - 1]);
}
}
fc[0][0] = 1;
for (int i = 1; i <= m; ++i) {
fc[i][0] = 1;
for (int j = 1; (j << 1) <= i; ++j) {
fc[i][j] = fc[i - 1][j];
if (i > 1 && !visc[i] && !visc[i - 1])
fc[i][j] = add(fc[i][j], fc[i - 2][j - 1]);
}
}
sumr = n, sumc = m;
for (int i = 1; i <= n; ++i) sumr -= visr[i];
for (int i = 1; i <= m; ++i) sumc -= visc[i];
int ans = 0;
for (int i = 0, il = sumr; (i << 1) <= il; ++i) {
for (int j = 0, jl = sumc;
(j << 1) <= jl && (i << 1) + j <= il && i + (j << 1) <= jl; ++j) {
ans += 1ll * fr[n][i] * fc[m][j] % mod * C[il - (i << 1)][j] % mod *
C[jl - (j << 1)][i] % mod * fac[j] % mod * fac[i] % mod;
if (ans >= mod) ans -= mod;
}
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int prv[2][100010];
int urm[2][100010];
int val[2][100010];
vector<int> poz_de_verif[2];
void rem(int nod, int c) {
urm[c][prv[c][nod]] = urm[c][nod];
prv[c][urm[c][nod]] = prv[c][nod];
if (prv[c][nod] && urm[c][nod] &&
val[c][prv[c][nod]] + 1 < val[c][urm[c][nod]])
poz_de_verif[c].push_back(prv[c][nod]);
urm[c][nod] = prv[c][nod] = 0;
}
bool bigger(int nod, int c) {
int a1 = nod, a2 = urm[c][nod];
while (a1 && a2) {
a1 = prv[c][a1];
a2 = urm[c][a2];
}
if (!a2) return true;
return false;
}
bool verif(int nod, int c) {
if (!urm[c][nod] || val[c][nod] + 1 >= val[c][urm[c][nod]]) return false;
vector<int> values;
int beg;
if (!bigger(nod, c)) {
prv[c][urm[c][nod]] = 0;
urm[c][nod] = 0;
while (nod) {
values.push_back(nod);
rem(nod, 1 - c);
beg = nod;
nod = prv[c][nod];
}
} else {
nod = urm[c][nod];
beg = nod;
urm[c][prv[c][nod]] = 0;
prv[c][nod] = 0;
while (nod) {
values.push_back(nod);
rem(nod, 1 - c);
nod = urm[c][nod];
}
}
sort(values.begin(), values.end(),
[&](int a, int b) { return val[1 - c][a] < val[1 - c][b]; });
for (int i = 1; i < values.size(); i++) {
prv[1 - c][values[i]] = values[i - 1],
urm[1 - c][values[i - 1]] = values[i];
if (val[1 - c][values[i - 1]] + 1 < val[1 - c][values[i]])
poz_de_verif[1 - c].push_back(values[i - 1]);
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
vector<int> v;
cin >> n;
for (int i = 1; i <= n; i++) {
v.push_back(i);
cin >> val[0][i] >> val[1][i];
}
sort(v.begin(), v.end(), [](int a, int b) { return val[0][a] < val[0][b]; });
for (int i = 1; i < v.size(); i++) {
prv[0][v[i]] = v[i - 1], urm[0][v[i - 1]] = v[i];
if (val[0][v[i - 1]] + 1 < val[0][v[i]])
poz_de_verif[0].push_back(v[i - 1]);
}
sort(v.begin(), v.end(), [](int a, int b) { return val[1][a] < val[1][b]; });
for (int i = 1; i < v.size(); i++) {
prv[1][v[i]] = v[i - 1], urm[1][v[i - 1]] = v[i];
if (val[1][v[i - 1]] + 1 < val[1][v[i]])
poz_de_verif[1].push_back(v[i - 1]);
}
int ans = 1;
while (!poz_de_verif[0].empty() || !poz_de_verif[1].empty()) {
for (int i = 0; i < 2; i++) {
if (poz_de_verif[i].empty()) continue;
int a = poz_de_verif[i].back();
poz_de_verif[i].pop_back();
if (verif(a, i)) ans++;
}
}
cout << ans << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200050;
const int mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tcase = 1, cas = 0;
while (tcase--) {
vector<char> a, ans;
for (int i = 1; i < 10; i++) ans.push_back(i + 48);
for (int i = 10; i < 10000; i++) {
int x = i;
while (x) {
a.push_back((x % 10) + 48);
x /= 10;
}
reverse(a.begin(), a.end());
for (int i = 0; i < a.size(); i++) {
ans.push_back(a[i]);
}
a.clear();
}
int k;
cin >> k;
cout << ans[k - 1];
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const long double eps = 1e-9;
const double pi = acos(-1.0);
const long long inf = 1e18;
using namespace std;
int main(int argc, const char* argv[]) {
string a, b;
cin >> a >> b;
int cnt1 = 0, cnt2 = 0;
for (int i = 0; i < a.size(); i += 2) {
if (a[i] == b[i]) continue;
if (a[i] == '8' && b[i] == '(') cnt2++;
if (a[i] == '8' && b[i] == '[') cnt1++;
if (a[i] == '(' && b[i] == '[') cnt2++;
if (a[i] == '(' && b[i] == '8') cnt1++;
if (a[i] == '[' && b[i] == '(') cnt1++;
if (a[i] == '[' && b[i] == '8') cnt2++;
}
if (cnt1 > cnt2) puts("TEAM 1 WINS");
if (cnt1 < cnt2) puts("TEAM 2 WINS");
if (cnt1 == cnt2) puts("TIE");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long double PI = acosl(-1);
bool compare_int(int a, int b) { return (a > b); }
bool compare_string(string a, string b) { return a.size() < b.size(); }
bool compare_pair(const pair<int, int> &a, const pair<int, int> &b) {
if (a.second == b.second)
return a.first > b.first;
else
return (a.second > b.second);
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t, n, x;
cin >> t;
while (t--) {
map<long long int, long long int> cnt;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
cnt[x]++;
}
long long int i = 1;
while (i < 2048) {
cnt[2 * i] += cnt[i] / 2;
i *= 2;
}
cnt[2048] ? cout << "YES" << endl : cout << "NO" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> people[100000 + 6];
int n, m;
int object, grade;
int maxn;
int sum;
int length;
int ans[100000 + 6];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d%d", &object, &grade);
people[object].push_back(grade);
if (grade > maxn) {
maxn = grade;
}
}
if (maxn <= 0) {
printf("0\n");
} else {
for (int i = 1; i <= m; i++) {
length = people[i].size();
int sum1 = 0;
sort(people[i].begin(), people[i].end());
reverse(people[i].begin(), people[i].end());
for (int j = 0; j < length; j++) {
sum1 += people[i][j];
if (sum1 > 0) {
ans[j + 1] += sum1;
}
}
}
for (int i = 1; i <= n; i++) {
sum = max(sum, ans[i]);
}
cout << sum << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int o[11111], from[11111], num1[11111], num2[11111], b[11111], aa[11111 * 2][2],
deep[11111];
int n, m, it, cnt, tot = 1;
bool vt[11111], flag[11111];
void dfs(int v) {
vt[v] = true;
for (int p = o[v]; p; p = aa[p][0]) {
int y = aa[p][1];
if ((p ^ 1) == from[v]) continue;
if (!vt[y]) {
from[y] = p;
deep[y] = deep[v] + 1;
dfs(y);
num1[v] += num1[y];
num2[v] += num2[y];
} else if (deep[v] > deep[y]) {
int t = deep[v] - deep[y];
if ((t & 1) == 0) {
it = p;
cnt++;
num1[v]++, num1[y]--;
} else
num2[v]++, num2[y]--;
}
}
}
void addedge(int p, int q) {
tot++;
aa[tot][1] = q;
aa[tot][0] = o[p];
o[p] = tot;
}
int main() {
scanf("%d%d", &n, &m);
int i, x, y;
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
addedge(x, y), addedge(y, x);
}
for (i = 1; i <= n; i++)
if (!vt[i]) dfs(i);
if (cnt == 0) {
printf("%d\n", m);
for (i = 1; i <= m; i++) printf("%d ", i);
} else if (cnt == 1) {
int ans = 1;
flag[it >> 1] = true;
b[b[0] = 1] = it >> 1;
for (i = 1; i <= n; i++)
if (num1[i] == 1 && num2[i] == 0) {
ans++;
flag[from[i] >> 1] = true;
b[++b[0]] = from[i] >> 1;
}
printf("%d\n", ans);
sort(b + 1, b + b[0] + 1);
for (i = 1; i <= b[0]; i++) printf("%d ", b[i]);
} else {
int ans = 0;
for (i = 1; i <= n; i++)
if (num1[i] == cnt && num2[i] == 0) {
ans++;
flag[from[i] >> 1] = true;
b[++b[0]] = from[i] >> 1;
}
printf("%d\n", ans);
sort(b + 1, b + b[0] + 1);
for (i = 1; i <= b[0]; i++) printf("%d ", b[i]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma warning(disable : 6031)
#pragma warning(disable : 4101)
using namespace std;
const int INF = 1e9;
const long long LINF = 1e18;
const double PI = acos(-1);
const int MAXN = 200005;
int n, m, l, r, j, best, ans, A[MAXN];
vector<pair<int, int> > B;
void print_res(int ind) {
if (ind == l || ind == r) {
for (int i = 0; i < B[ind].second; i++) {
printf("%d ", B[ind].first);
}
if (ind != r) {
print_res(ind + 1);
}
} else {
for (int i = 0; i < B[ind].second - 1; i++) {
printf("%d ", B[ind].first);
}
print_res(ind + 1);
printf("%d ", B[ind].first);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
sort(A, A + n);
B = {{A[0], 1}};
for (int i = 1; i < n; i++) {
if (A[i] == A[i - 1]) {
B.back().second++;
} else {
B.push_back({A[i], 1});
}
}
m = ((int)(B).size());
for (int i = 0; i < m; i++) {
ans = B[i].second;
j = i + 1;
while (j < n && B[j].first == B[j - 1].first + 1 && B[j].second > 1) {
ans += B[j].second;
j++;
}
if (j < n && B[j].first == B[j - 1].first + 1) {
ans += 1;
}
if (ans > best) {
l = i;
r = j - 1;
if (j < n && B[j].first == B[j - 1].first + 1) {
r += 1;
}
best = ans;
}
i = j - 1;
}
printf("%d\n", best);
print_res(l);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, x, i, min = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &x);
min += 15;
if (min >= x)
min = x;
else
break;
}
if (i == n) min += 15;
if (min >= 90)
printf("90\n");
else
printf("%d\n", min);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200050;
vector<pair<int, int> > E[N], cyc;
int par[N], up[N], dep[N];
bool was[N];
void NO() {
printf("NO\n");
exit(0);
}
double ans[N];
void DFS(int u) {
was[u] = 1;
for (pair<int, int> e : E[u]) {
int v = e.first, w = e.second;
if (!was[v]) {
dep[v] = dep[u] + 1;
up[v] = w;
par[v] = u;
DFS(v);
} else {
if (dep[u] % 2 == dep[v] % 2 && cyc.empty()) {
for (int i = u; i != v; i = par[i]) cyc.push_back({i, up[i]});
cyc.push_back({v, w});
}
}
}
}
bool done[N];
int side[N];
vector<int> nodes[2];
void Expand(int u) {
done[u] = 1;
nodes[side[u]].push_back(u);
for (pair<int, int> e : E[u]) {
int v = e.first, w = e.second;
if (!done[v]) {
ans[v] = w - ans[u];
side[v] = side[u] ^ 1;
Expand(v);
} else if (ans[v] != w - ans[u])
NO();
}
}
void Solve(int u) {
cyc.clear();
DFS(u);
if (cyc.size()) {
int sum = 0;
for (int i = 0; i < cyc.size(); i++)
sum += cyc[i].second * (i % 2 == 0 ? 1 : -1);
ans[cyc[0].first] = sum * 0.5;
Expand(cyc[0].first);
} else {
nodes[0].clear();
nodes[1].clear();
Expand(u);
for (int z = 0; z < 2; z++)
sort(nodes[z].begin(), nodes[z].end(),
[&](int i, int j) { return ans[i] < ans[j]; });
int x1 = 0, cnt1 = 0, cnt2 = 0, sz1 = nodes[0].size(),
sz2 = nodes[1].size();
while (1) {
while (cnt1 < sz1 && ans[nodes[0][cnt1]] < -x1) cnt1++;
while (cnt1 > 0 && ans[nodes[0][cnt1 - 1]] >= -x1) cnt1--;
while (cnt2 < sz2 && ans[nodes[1][sz2 - cnt2 - 1]] > x1) cnt2++;
while (cnt2 > 0 && ans[nodes[1][sz2 - cnt2]] <= x1) cnt2--;
if ((cnt1 + cnt2) * 2 > sz1 + sz2) {
x1++;
} else
break;
}
while (1) {
while (cnt1 < sz1 && ans[nodes[0][sz1 - cnt1 - 1]] > -x1) cnt1++;
while (cnt1 > 0 && ans[nodes[0][sz1 - cnt1]] <= -x1) cnt1--;
while (cnt2 < sz2 && ans[nodes[1][cnt2]] < x1) cnt2++;
while (cnt2 > 0 && ans[nodes[1][cnt2 - 1]] >= x1) cnt2--;
if ((cnt1 + cnt2) * 2 > sz1 + sz2) {
x1--;
} else
break;
}
for (int v : nodes[0]) ans[v] += x1;
for (int v : nodes[1]) ans[v] -= x1;
}
}
int main() {
int n, m;
scanf("%i %i", &n, &m);
for (int i = 1, u, v, w; i <= m; i++)
scanf("%i %i %i", &u, &v, &w), E[u].push_back({v, w}),
E[v].push_back({u, w});
for (int i = 1; i <= n; i++)
if (!was[i]) Solve(i);
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%.1f ", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
long long ext_gcd(long long A, long long B, long long *X, long long *Y) {
long long x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1;
y2 = 0;
x1 = 0;
y1 = 1;
for (r2 = A, r1 = B; r1 != 0;
r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y) {
q = r2 / r1;
r = r2 % r1;
x = x2 - (q * x1);
y = y2 - (q * y1);
}
*X = x2;
*Y = y2;
return r2;
}
inline long long modInv(long long a, long long m) {
long long x, y;
ext_gcd(a, m, &x, &y);
x %= m;
if (x < 0) x += m;
return x;
}
inline long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
inline long long bigmod(long long a, long long p, long long m) {
long long res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
inline int STRLEN(char *s) {
int p = 0;
while (s[p]) p++;
return p;
}
inline long long SQRT(long long a) {
long long v = sqrt(a);
if (((v) * (v)) == a)
return v;
else if (((v + 1) * (v + 1)) == a)
return v + 1;
else if (((v + 2) * (v + 2)) == a)
return v + 2;
else
return -1;
}
const int inf = 100000000;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
int N, K, X;
int Total[1050 + 50], Even[1050 + 50], Odd[1050 + 50];
void updatePosition() {
int f = 0;
for (int num = 0; num < 1050; num++) {
int cnt = Total[num];
if (f == 0) {
Even[num] = (cnt + 1) / 2;
Odd[num] = cnt - Even[num];
} else {
Odd[num] = (cnt + 1) / 2;
Even[num] = cnt - Odd[num];
}
f = (f + cnt) % 2;
}
}
void update() {
for (int num = 0; num < 1050; num++) {
int cnt = Even[num];
int nxr = num ^ X;
Total[nxr] += cnt;
Total[num] -= cnt;
}
updatePosition();
}
int main() {
scanf("%d %d %d", &N, &K, &X);
memset(Total, 0, sizeof(Total));
memset(Even, 0, sizeof(Even));
memset(Odd, 0, sizeof(Odd));
for (int i = 0; i < N; i++) {
int num;
scanf("%d", &num);
Total[num]++;
}
updatePosition();
for (int i = 0; i < K; i++) {
update();
}
int Mn = inf, Mx = 0;
for (int num = 0; num < 1050; num++) {
if (Total[num] == 0) continue;
Mn = min(Mn, num);
Mx = max(Mx, num);
}
printf("%d %d\n", Mx, Mn);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int main() {
int n, x, sum = 0, kol;
cin >> n >> x;
int *y = new int[n];
for (int i = 0; i < n; i++) {
cin >> y[i];
sum += y[i];
}
kol = abs(sum) / x;
if (abs(sum) % x != 0) kol++;
cout << kol;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O2,no-stack-protector,unroll-loops,fast-math")
const int maxn = 5e3 + 10, maxm = 5e2 + 10, lg = 18, mod = 1e9 + 7, inf = 1e18;
int n, dp[maxn][maxn], fl[maxn];
vector<int> g[maxn];
void dfs(int v = 1, int p = 0) {
dp[v][fl[v] = ((int)(g[v].size()) == 1)] = 0;
for (auto u : g[v])
if (u != p) {
dfs(u, v);
for (int i = (fl[v] += fl[u]), tmp = inf; ~i; dp[v][i--] = tmp, tmp = inf)
for (int j = min(i, fl[u]); ~j; j--)
tmp = min(tmp, dp[v][i - j] + min(dp[u][j], dp[u][fl[u] - j] + 1));
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
memset(dp, 69, sizeof(dp));
cin >> n;
for (int i = 1; i < n; i++) {
int v, u;
cin >> v >> u;
g[v].push_back(u), g[u].push_back(v);
}
dfs();
cout << dp[1][fl[1] / 2];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int64_t N = 1e5 + 5;
const int64_t INF = 1e18 + 5;
const int64_t MOD = 1000000007;
vector<int64_t> v;
int64_t sum = 0;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int64_t n, m;
cin >> n >> m;
for (int64_t i = 0; i < n; i++) {
int64_t x;
cin >> x;
sum += x;
v.push_back(x);
}
sort(v.begin(), v.end());
int64_t t = 0;
for (int64_t i = 0; i < n; i++) {
if (t < v[i]) t++;
}
cout << sum - n - (v[n - 1] - t);
}
| 3 |
#include <bits/stdc++.h>
template <typename T>
inline void rd(T& x) {
int si = 1;
char c = getchar();
x = 0;
while (!isdigit(c)) si = c == '-' ? -1 : si, c = getchar();
while (isdigit(c)) x = x * 10 + c - 48, c = getchar();
x *= si;
}
template <typename T, typename... Args>
inline void rd(T& x, Args&... args) {
rd(x);
rd(args...);
}
const int kN = 3e5 + 5;
int n, seg[kN * 6], tag[kN * 6], p[kN], q[kN], pre[kN];
void Update(int cur) { seg[cur] = std::max(seg[cur << 1], seg[cur << 1 | 1]); }
void PushTag(int cur) {
seg[cur << 1] += tag[cur];
seg[cur << 1 | 1] += tag[cur];
tag[cur << 1] += tag[cur];
tag[cur << 1 | 1] += tag[cur];
tag[cur] = 0;
}
void Modify(int cur, int l, int r, int ql, int qr, int v) {
if (ql <= l && r <= qr)
tag[cur] += v, seg[cur] += v;
else {
int mid = (l + r) >> 1;
PushTag(cur);
if (ql <= mid) Modify(cur << 1, l, mid, ql, qr, v);
if (qr > mid) Modify(cur << 1 | 1, mid + 1, r, ql, qr, v);
Update(cur);
}
}
int main() {
rd(n);
for (int i = 1; i <= n; ++i) rd(p[i]), pre[p[i]] = i;
for (int i = 1; i <= n; ++i) rd(q[i]);
int x = n + 1;
for (int i = 1; i <= n; ++i) {
while (seg[1] <= 0) Modify(1, 1, n, 1, pre[--x], 1);
printf("%d ", x);
Modify(1, 1, n, 1, q[i], -1);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
inline int fcmp(double a, double b) {
if (fabs(a - b) < eps) return 0;
return a < b ? -1 : 1;
}
struct point3 {
double x, y, z;
point3() {}
point3(double a, double b, double c) : x(a), y(b), z(c) {}
point3 operator+(const point3 &p) {
return point3(x + p.x, y + p.y, z + p.z);
}
point3 operator-(const point3 &p) {
return point3(x - p.x, y - p.y, z - p.z);
}
point3 operator*(const double d) { return point3(x * d, y * d, z * d); }
point3 operator/(const double d) { return point3(x / d, y / d, z / d); }
point3 operator&(const point3 &p) {
return point3(y * p.z - z * p.y, z * p.x - x * p.z, x * p.y - y * p.x);
}
long double operator^(const point3 &p) { return x * p.x + y * p.y + z * p.z; }
double len() { return sqrt(x * x + y * y + z * z); }
void in() { scanf("%lf%lf%lf", &x, &y, &z); }
};
long double cald(point3 a, point3 u, point3 b, point3 v) {
return ((u ^ v) * (v ^ a - b) - (v ^ v) * (u ^ a - b)) /
((u ^ u) * (v ^ v) - (u ^ v) * (u ^ v));
}
double lineToLineEx(point3 a, point3 b, point3 c, point3 d, point3 &A,
point3 &B) {
point3 va = b - a, vc = d - c;
A = a + va * cald(a, va, c, vc);
B = c + vc * cald(c, vc, a, va);
return (B - A).len();
}
double pToLineEx(point3 p, point3 a, point3 b, point3 &o) {
point3 n = a - p & b - p;
if (!fcmp(n.len(), 0)) {
o = p;
return 0;
}
point3 v = b - a & n;
lineToLineEx(a, b, p, p + v, o, o);
return (o - p).len();
}
point3 A, B, V;
double mins;
void update(const point3 &o, double l) {
point3 p;
double h = pToLineEx(o, A, B, p);
if (fcmp(h, l) > 0 || (V ^ p - A) < 0) {
return;
}
double tp = ((A - p).len() - sqrt(l * l - h * h)) / V.len();
if (mins < 0 || tp < mins) mins = tp;
}
int main() {
point3 o, p, l, r, mid;
double r1, r2;
int n, m, i;
while (~scanf("%lf%lf%lf", &A.x, &A.y, &A.z)) {
V.in();
B = A + V;
scanf("%lf%d", &r1, &n);
mins = -1;
while (n--) {
o.in();
scanf("%lf%d", &r2, &m);
update(o, r1 + r2);
for (i = 0; i < m; i++) {
p.in();
update(o + p, r1);
}
}
printf("%.11f\n", mins);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int x, i, k, n;
int a[100010];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
int main() {
n = read();
k = read();
for (i = 1; i <= n; i++) a[i] = getchar() - 'a';
for (i = 1; i <= n; i++) {
x = 25 - a[i];
if (x > a[i]) {
if (x <= k)
k -= x, a[i] = 25;
else
a[i] += k, k = 0;
} else {
if (a[i] <= k)
k -= a[i], a[i] = 0;
else
a[i] -= k, k = 0;
}
if (!k) break;
}
if (k)
puts("-1");
else
for (i = 1; i <= n; i++) putchar(a[i] + 'a');
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long> pq;
priority_queue<pair<long long, long long>> pq2;
int main() {
long long i, j, k, p, q, n, l, t, w, ans;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> t >> w;
if (i == 1)
l = t;
else {
if (t > l)
pq.push(-(w - t + 1));
else
pq2.push({t, w});
}
}
ans = pq.size() + 1;
while (!pq.empty()) {
long long ret = -pq.top();
if (ret <= l) {
pq.pop();
l -= ret;
while (!pq2.empty() && pq2.top().first > l) {
pq.push(-(pq2.top().second - pq2.top().first + 1));
pq2.pop();
}
ans = min(ans, (long long)pq.size() + 1);
} else
break;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
std::ios_base::sync_with_stdio(0);
int cases, caseno = 0, n, i, j, k, cnt, sum;
cin >> n;
if (n % 2 == 0) {
v.push_back(1);
v.push_back(2);
v.push_back(1);
for (i = 4; i <= n; i++) {
v.push_back(i - 1);
swap(v[v.size() - 1], v[v.size() - 2]);
swap(v[v.size() - 2], v[v.size() - 3]);
v.push_back(i);
v.push_back(i - 1);
i++;
}
} else {
v.push_back(2);
v.push_back(1);
v.push_back(3);
v.push_back(2);
for (i = 5; i <= n; i++) {
v.push_back(i - 1);
swap(v[v.size() - 1], v[v.size() - 2]);
swap(v[v.size() - 2], v[v.size() - 3]);
v.push_back(i);
v.push_back(i - 1);
i++;
}
}
cout << v.size() << '\n';
n = v.size();
for (i = 0; i <= n - 1; i++) cout << v[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int n, k, tab[75][75], d, linkx[75], linky[75], tx[75], ty[75];
bool visx[75], visy[75];
bool dfs(int x) {
visx[x] = true;
for (int i = 0; i < n; i++) {
if (!visy[i] && tx[x] + ty[i] == tab[x][i]) {
visy[i] = true;
if (linky[i] == -1 || dfs(linky[i])) {
linkx[x] = i, linky[i] = x;
return true;
}
}
}
return false;
}
void update() {
d = 1e7;
for (int i = 0; i < n; i++) {
if (!visx[i]) continue;
for (int j = 0; j < n; j++) {
if (visy[j]) continue;
d = min(d, tx[i] + ty[j] - tab[i][j]);
}
}
for (int i = 0; i < n; i++)
if (visx[i]) tx[i] -= d;
for (int i = 0; i < n; i++)
if (visy[i]) ty[i] += d;
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n >> k;
pair<int, int> ar[n];
memset(linkx, -1, sizeof(linkx));
memset(linky, -1, sizeof(linky));
memset(ty, 0, sizeof(ty));
for (int i = 0; i < n; i++) cin >> ar[i].first >> ar[i].second;
for (int i = 0; i < k; i++) {
for (int j = 0; j < n; j++) {
tab[j][i] = ar[j].first + ar[j].second * i;
}
}
for (int i = 0; i < n; i++) tx[i] = tab[i][k - 1];
for (int i = k; i < n; i++) {
for (int j = 0; j < n; j++) tab[j][i] = ar[j].second * (k - 1);
}
for (int i = 0; i < n; i++) {
while (!dfs(i)) {
update();
memset(visx, 0, sizeof(visx));
memset(visy, 0, sizeof(visy));
}
}
int ans[75];
for (int i = 0; i < n; i++) {
ans[linkx[i]] = i;
}
cout << n * 2 - k << '\n';
for (int i = 0; i < k - 1; i++) cout << ans[i] + 1 << " ";
for (int i = k; i < n; i++) cout << ans[i] + 1 << " " << -ans[i] - 1 << " ";
cout << ans[k - 1] + 1 << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int mat[100005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
int lst = 1;
for (int i = 1; i <= n; i++) {
if (k > 2) {
mat[i] = lst;
mat[++i] = n - lst + 1;
k -= 2;
} else
mat[i] = lst;
lst++;
}
if (k == 2) swap(mat[n - 1], mat[n]);
for (int i = 1; i <= n; i++) cout << mat[i] << " ";
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
const int nn =210000;
const int inff = 0x3fffffff;
const double eps = 1e-8;
typedef long long LL;
const double pi = acos(-1.0);
const LL mod = 998244353;
LL jc[nn];
void init()
{
jc[0]=1;
for(int i=1;i<=200000;i++)
{
jc[i]=(jc[i-1]*i)%mod;
}
}
LL POW(LL x,LL y)
{
LL ret=1;
while(y)
{
if(y&1)
{
ret=(ret*x)%mod;
}
x=(x*x)%mod;
y/=2;
}
return ret;
}
LL C(LL n,LL m)
{
/*LL ret=1;
for(int i=1;i<=m;i++)
{
ret=(ret*(n-i+1))%mod;
ret=(ret*POW(i,mod-2))%mod;
}
return ret;*/
return (jc[n]*POW(jc[m],mod-2)%mod)*POW(jc[n-m],mod-2)%mod;
}
int main()
{
init();
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
string s;
cin>>s;
int cnt=0;
int pre=-1;
int zero=0;
for(int i=0;i<n;i++)
{
if(s[i]=='0')
zero++;
if(i>0&&s[i]=='1'&&s[i-1]=='1'&&pre!=i-1)
{
cnt++;
pre=i;
}
}
cout<<C(cnt+zero,zero)<<endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int b[22] = {0};
int n, i, a;
long long sum = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a);
sum += b[10 - a];
b[10 + a]++;
}
printf("%I64d\n", sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using lld = long double;
using ulli = unsigned long long int;
using pll = pair<lli, lli>;
using ttt = pair<lli, pll>;
using vttt = vector<ttt>;
using vll = vector<pll>;
using vl = vector<lli>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using cd = complex<lld>;
const double PI = acos(-1);
lli pref[200010], lcol[200010], rcol[200010];
lli arr[200010], wrr[200010];
void add(lli tre[], int x, lli val, bool fl) {
for (x += 2; x < 200010; x += (x & -x)) {
tre[x] += val;
if (fl) tre[x] %= 1000000007;
}
}
lli get(lli tre[], int x, bool fl) {
lli res = 0;
for (x += 2; x > 0; x -= (x & -x)) res += tre[x];
if (fl) res %= 1000000007;
return res;
}
lli get(lli tre[], int l, int r, bool fl) {
if (!fl)
return get(tre, r, fl) - get(tre, l - 1, fl);
else
return (get(tre, r, fl) - get(tre, l - 1, fl) + 1000000007) % 1000000007;
}
lli fin(int pos, int l, int r) {
lli move = (get(rcol, pos + 1, r, 1) - get(rcol, l, pos, 1)) % 1000000007;
lli del1 = ((arr[pos] - pos) * get(pref, pos + 1, r, 1)) % 1000000007;
lli add1 = ((arr[pos] - pos) * get(pref, l, pos, 1)) % 1000000007;
return ((move - del1 + add1) % 1000000007 + 1000000007) % 1000000007;
}
int tejas_919(int kkkk) {
lli n, m, k, q, u, v, temp = 0, ans = 0;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
cin >> wrr[i];
add(pref, i, wrr[i], 0);
}
for (int i = 0; i < n; i++) add(rcol, i, wrr[i] * (arr[i] - i), 1);
for (int i = 1; i < q + 1; i++) {
cin >> u >> v;
if (u < 0) {
u = -u - 1;
temp = v - wrr[u];
add(pref, u, temp, 0);
add(rcol, u, temp * (arr[u] - u), 1);
wrr[u] = v;
} else {
if (u == v) {
cout << 0 << '\n';
continue;
} else {
u--;
v--;
lli f = get(pref, u, u, 0);
lli s = get(pref, u + 1, v, 0);
if (f >= s) {
cout << fin(u, u, v) << '\n';
continue;
}
int l = u, r = v;
f += s;
f /= 2;
while (r - l > 1) {
int mid = (l + r) / 2;
if (get(pref, u, mid, 0) <= f)
l = mid;
else
r = mid;
}
cout << fin(l + 1, u, v) << '\n';
}
}
}
return 0;
}
signed main() {
if (!0) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
cout << fixed << setprecision(10);
int t = 1;
for (int i = 0; i < t; i++) {
tejas_919(i + 1);
}
{};
if (0) system("pause");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long LINF = 1e17;
const double DINF = numeric_limits<double>::max();
const int ITER = 300;
const int MOD = 1e9 + 7;
const double EPS = 1e-10;
const int N = 1e5 + 100;
int n, Q;
int c[N];
int q[N];
long long dp[N];
bool used[N];
long long solve1(int A, int B) {
for (int i = 0; i < N; i++) dp[i] = -LINF, used[i] = 0;
long long otherMAX1 = 0, otherMAX2 = 0;
int ind1 = 0, ind2 = 0;
for (int i = 1; i <= n; i++) {
if (used[c[i]]) dp[c[i]] = max(dp[c[i]], dp[c[i]] + 1LL * A * q[i]);
if (ind1 != c[i]) {
if (dp[c[i]] != -LINF)
dp[c[i]] = max(dp[c[i]], otherMAX1 + 1LL * B * q[i]);
else
dp[c[i]] = otherMAX1 + 1LL * B * q[i];
} else if (ind2 != c[i]) {
if (dp[c[i]] != -LINF)
dp[c[i]] = max(dp[c[i]], otherMAX2 + 1LL * B * q[i]);
else
dp[c[i]] = otherMAX2 + 1LL * B * q[i];
}
if (dp[c[i]] > otherMAX1) {
if (c[i] != ind1) {
otherMAX2 = otherMAX1;
ind2 = ind1;
}
otherMAX1 = dp[c[i]];
ind1 = c[i];
} else if (dp[c[i]] > otherMAX2 && c[i] != ind1) {
otherMAX2 = dp[c[i]];
ind2 = c[i];
}
used[c[i]] = true;
}
return otherMAX1;
}
void solve() {
cin >> n >> Q;
for (int i = 1; i <= n; i++) {
cin >> q[i];
}
for (int i = 1; i <= n; i++) {
cin >> c[i];
}
for (int i = 1; i <= Q; i++) {
int A, B;
cin >> A >> B;
cout << solve1(A, B) << '\n';
}
}
int main() {
cout << setprecision(12) << fixed;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
long long ans = 0;
ans += (((x2 - x1) / 2) * (y2 - y1 + 1)) + (((y2 - y1) / 2) + 1);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
string str;
cin >> str;
long long int close = 0, open = 0, ano = 0, ind, ans = 0;
for (long long int i = 0; str[i]; i++) {
if (str[i] == ')')
close++;
else
open++;
if (close > open) {
if (ano == 0) {
ano = 1;
ind = i;
}
} else if (close == open) {
if (ano == 1) ans += i - ind + 1;
ano = 0;
}
}
if (close != open)
cout << "-1\n";
else {
cout << ans << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long T, t, N, n, count;
string s;
cin >> T;
for (t = 1; t <= T; t++) {
cin >> N;
cin >> s;
count = s[N - 1] - '0';
for (n = N - 2; n >= 0; n--) {
if (s[n] != '0') {
count = count + (s[n] - '0') + 1;
}
}
cout << count << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
const int K = 2005;
const int M = 2 * N;
const int maxn = 4e5 + 7;
const int lim = 1e6;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
const int P = 998244353, G = 3, Gi = 332748118;
const double eps = 1e-10;
const double PI = acos(-1);
const long long xxf = 1e18;
multiset<long long> ms;
priority_queue<int> pq1, pq2;
void blue() { std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0); }
char s[N];
long long a[N], b[N];
void init(int n) {
a[1] = 1;
a[0] = 0;
long long aa = 10;
for (long long i = 2; i <= n; i++)
a[i] = 1ll * aa * i % MOD, aa = 1ll * aa * 10 % MOD;
for (int i = 2; i <= n; i++) a[i] += a[i - 1];
b[0] = 1;
for (long long i = 1; i <= n; i++) b[i] = (b[i - 1] * 10) % MOD;
}
long long ans = 0;
int main() {
init(10);
scanf("%s", s + 1);
int n = strlen(s + 1);
init(n);
for (int i = 1; i <= n; i++) {
long long aa = s[i] - '0', cat = 1ll * i * (i - 1) / 2;
long long tmp = aa * b[n - i] % MOD * cat % MOD + aa * a[n - i] % MOD;
ans = (ans + tmp) % MOD;
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b = 0, c = 0;
cin >> a;
if (a % 10 == 0) b = 2;
if (a % 10 == 1) b = 7;
if (a % 10 == 2) b = 2;
if (a % 10 == 3) b = 3;
if (a % 10 == 4) b = 3;
if (a % 10 == 5) b = 4;
if (a % 10 == 6) b = 2;
if (a % 10 == 7) b = 5;
if (a % 10 == 8) b = 1;
if (a % 10 == 9) b = 2;
if (a / 10 == 0) c = 2;
if (a / 10 == 1) c = 7;
if (a / 10 == 2) c = 2;
if (a / 10 == 3) c = 3;
if (a / 10 == 4) c = 3;
if (a / 10 == 5) c = 4;
if (a / 10 == 6) c = 2;
if (a / 10 == 7) c = 5;
if (a / 10 == 8) c = 1;
if (a / 10 == 9) c = 2;
cout << b * c;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0LL) return b;
if (b == 0LL) return a;
return gcd(b, a % b);
}
const int N = 200005;
long long A[N], W[N];
pair<long long, long long> tree[N << 2];
pair<long long, long long> temp[N << 2];
void build(int node, int l, int r) {
if (l == r) {
tree[node] = make_pair(W[l], (A[l] * W[l]) % 1000000007LL);
return;
}
int mid = (l + r) >> 1;
int left = node << 1;
int right = left + 1;
build(left, l, mid);
build(right, mid + 1, r);
tree[node].first = tree[left].first + tree[right].first;
tree[node].second = (tree[left].second + tree[right].second) % 1000000007LL;
return;
}
void update(int node, int l, int r, int idx) {
if (l == r) {
tree[node] = make_pair(W[idx], (A[idx] * W[idx]) % 1000000007LL);
return;
}
int mid = (l + r) >> 1;
int left = node << 1;
int right = left + 1;
if (idx <= mid)
update(left, l, mid, idx);
else
update(right, mid + 1, r, idx);
tree[node].first = tree[left].first + tree[right].first;
tree[node].second = (tree[left].second + tree[right].second) % 1000000007LL;
return;
}
pair<long long, long long> query(int node, int l, int r, int a, int b) {
if (l == a && r == b) {
temp[node] = tree[node];
return tree[node];
}
int mid = (l + r) >> 1;
int left = node << 1;
int right = left + 1;
if (b <= mid) {
temp[left] = query(left, l, mid, a, b);
return temp[left];
} else if (a > mid) {
temp[right] = query(right, mid + 1, r, a, b);
return temp[right];
}
pair<long long, long long> L = query(left, l, mid, a, mid);
pair<long long, long long> R = query(right, mid + 1, r, mid + 1, b);
pair<long long, long long> ans =
make_pair(L.first + R.first, (L.second + R.second) % 1000000007LL);
temp[node] = ans;
return ans;
}
int query1(int node, int l, int r, int a, int b, long long val) {
int mid = (l + r) >> 1;
int left = node << 1;
int right = left + 1;
if (l == a && r == b) {
if (l == r) return l;
if (2LL * tree[left].first < val)
return query1(right, mid + 1, r, mid + 1, r,
val - 2LL * tree[left].first);
return query1(left, l, mid, l, mid, val);
}
if (b <= mid)
return query1(left, l, mid, a, b, val);
else if (a > mid)
return query1(right, mid + 1, r, a, b, val);
long long val1 = query(left, l, mid, a, mid).first;
if (2LL * val1 < val)
return query1(right, mid + 1, r, mid + 1, b, val - 2LL * val1);
return query1(left, l, mid, a, mid, val);
}
long long getAns(int n, int L, int R, int ind) {
long long X = A[ind];
long long ans = 0LL;
pair<long long, long long> val = query(1, 1, n, L, ind);
val.first = val.first % 1000000007LL;
ans = (ans + ((X * val.first) % 1000000007LL) - val.second +
2LL * 1000000007LL) %
1000000007LL;
val = query(1, 1, n, ind, R);
val.first = val.first % 1000000007LL;
ans = (ans + val.second - ((X * val.first) % 1000000007LL) +
2LL * 1000000007LL) %
1000000007LL;
return ans;
}
void solve1(int n, int L, int R) {
pair<long long, long long> val = query(1, 1, n, L, R);
int ind = query1(1, 1, n, L, R, val.first);
cout << getAns(n, L, R, ind) << "\n";
return;
}
void solve() {
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> A[i];
A[i] = A[i] - i;
}
for (int i = 1; i <= n; i++) cin >> W[i];
build(1, 1, n);
int L, R;
while (q--) {
cin >> L >> R;
if (L < 0) {
L = -1 * L;
W[L] = R;
update(1, 1, n, L);
continue;
}
solve1(n, L, R);
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
clock_t clk = clock();
int t = 1;
for (int tests = 1; tests <= t; tests++) {
solve();
}
clk = clock() - clk;
cerr << "Time Elapsed: " << fixed << setprecision(10)
<< ((long double)clk) / CLOCKS_PER_SEC << "\n";
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 n, m;
cin >> n;
long long a1[n];
for (long long i = 0; i < n; i++) cin >> a1[i];
cin >> m;
long long a2[m];
for (long long i = 0; i < m; i++) cin >> a2[i];
long long ans = 0;
long long i = n - 1, j = m - 1;
long long s1 = 0, s2 = 0;
while (i >= 0 && j >= 0) {
if (s1 + a1[i] > s2 + a2[j]) {
s2 += a2[j];
j--;
} else if (s1 + a1[i] < s2 + a2[j]) {
s1 += a1[i];
i--;
} else {
ans++;
s1 = 0;
s2 = 0;
i--;
j--;
}
}
if (i < 0 && j < 0)
cout << ans << endl;
else
cout << "-1" << endl;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
inline unsigned long long gcd(unsigned long long a, unsigned long long b) {
if (a < b) {
a ^= b;
b ^= a;
a ^= b;
};
return (a > b) ? gcd(a - b, b) : a;
}
inline int abs(int x) { return x > 0 ? x : -x; }
void solve() {
const string s[33] = {
"111111101010101111100101001111111", "100000100000000001010110001000001",
"101110100110110000011010001011101", "101110101011001001111101001011101",
"101110101100011000111100101011101", "100000101010101011010000101000001",
"111111101010101010101010101111111", "000000001111101111100111100000000",
"100010111100100001011110111111001", "110111001111111100100001000101100",
"011100111010000101000111010001010", "011110000110001111110101100000011",
"111111111111111000111001001011000", "111000010111010011010011010100100",
"101010100010110010110101010000010", "101100000101010001111101000000000",
"000010100011001101000111101011010", "101001001111101111000101010001110",
"101101111111000100100001110001000", "000010011000100110000011010000010",
"001101101001101110010010011011000", "011101011010001000111101010100110",
"111010100110011101001101000001110", "110001010010101111000101111111000",
"001000111011100001010110111110000", "000000001110010110100010100010110",
"111111101000101111000110101011010", "100000100111010101111100100011011",
"101110101001010000101000111111000", "101110100011010010010111111011010",
"101110100100011011110110101110000", "100000100110011001111100111100000",
"111111101101000101001101110010001"};
int a, b;
cin >> a >> b;
cout << s[a][b];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T;
cin >> T;
while (T--) {
long long x1, p1, x2, p2;
cin >> x1 >> p1 >> x2 >> p2;
long long num;
if (p1 - p2 > 6)
cout << ">\n";
else if (p2 - p1 > 6)
cout << "<\n";
else {
long long num1, num2;
if (p1 > p2) {
num1 = x1 * pow(10, p1 - p2);
num2 = x2;
} else if (p1 < p2) {
num1 = x1;
num2 = x2 * pow(10, p2 - p1);
} else {
num1 = x1;
num2 = x2;
}
if (num1 == num2)
cout << "=\n";
else if (num1 > num2)
cout << ">\n";
else
cout << "<\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int x[6], n;
for (int &i : x) cin >> i;
cin >> n;
int a[n];
vector<vector<int>> b(n, vector<int>(6));
set<pair<int, pair<int, int>>> s;
for (int i = 0; i < n; ++i) {
cin >> a[i];
for (int j = 0; j < 6; ++j) b[i][j] = a[i] - x[j];
sort(b[i].begin(), b[i].end());
int tmp = 0;
while (b[i][tmp] < 0) ++tmp;
s.insert({b[i][tmp], pair<int, int>(i, tmp)});
}
int ans = s.rbegin()->first - s.begin()->first;
while (1) {
ans = min(ans, s.rbegin()->first - s.begin()->first);
pair<int, pair<int, int>> i = *s.begin();
s.erase(s.begin());
++i.second.second;
if (i.second.second < 6)
s.insert({b[i.second.first][i.second.second], i.second});
else
break;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
c = getchar();
}
while (c <= '9' && c >= '0') {
x = ((x << 1) + (x << 3)) + c - '0';
c = getchar();
}
return;
}
int a[1005][1005];
int n, m;
int b[1005], c[1005];
int fastpow(long long a, long long b) {
long long tmp = a, ans = 1;
while (b) {
if (b & 1) ans = (ans * tmp) % 1000000007;
tmp = (tmp * tmp) % 1000000007;
b >>= 1;
}
return ans;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[i][j] = 2;
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= m; i++) cin >> c[i];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= b[i]; j++) {
if (a[i][j] == 0) {
cout << 0;
return 0;
}
a[i][j] = 1;
}
if (a[i][b[i] + 1] == 1) {
cout << 0;
return 0;
}
a[i][b[i] + 1] = 0;
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= c[i]; j++) {
if (a[j][i] == 0) {
cout << 0;
return 0;
}
a[j][i] = 1;
}
if (a[c[i] + 1][i] == 1) {
cout << 0;
return 0;
}
a[c[i] + 1][i] = 0;
}
int cnt = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (a[i][j] == 2) cnt++;
}
cout << fastpow(2, cnt);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
getline(cin, str);
str.erase(remove(str.begin(), str.end(), ' '), str.end());
transform(str.begin(), str.end(), str.begin(), ::tolower);
int i = str.size() - 2;
if (str[i] == 'a' || str[i] == 'e' || str[i] == 'i' || str[i] == 'o' ||
str[i] == 'u' || str[i] == 'y')
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int quo = n / m, rem = n % m;
for (int i = 1; i <= m - rem; i++) {
cout << quo << " ";
}
for (int i = 1; i <= rem; i++) {
cout << quo + 1 << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[100010];
int vis[100010], B[100010];
int main() {
int i, n, a, b, f;
scanf("%s", s + 1);
n = strlen(s + 1);
a = b = f = 0;
for (i = n; i; i--) {
if (s[i] == '1') {
if (a == b) {
f = 1;
s[i] = '0';
b++;
a++;
} else
a++;
} else {
b++;
f = 0;
}
}
for (i = 1; i <= n; i++) cout << s[i];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 28, mod = 1e9 + 9;
vector<int> g[maxn];
int a[maxn];
void add(int, int);
int k = 1;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
a[i] = i;
g[i].push_back(i);
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
v--, u--;
add(v, u);
cout << k - 1 << "\n";
}
}
void add(int v, int u) {
if (g[a[v]].size() < g[a[u]].size()) swap(v, u);
v = a[v], u = a[u];
if (v == u)
k = k * 2 % mod;
else {
for (auto x : g[u]) {
a[x] = v;
g[v].push_back(x);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mN = 4e5 + 100;
int BIT[mN];
int n, a[mN], b[mN], fa[mN], fb[mN];
inline long long getPrefix(int i) {
++i;
int ret = 0;
while (i) ret += BIT[i], i -= i & -i;
return ret;
}
inline void add(int i, int v) {
++i;
while (i < mN) BIT[i] += v, i += i & -i;
}
inline long long getRange(int l, int r) {
return getPrefix(r) - getPrefix(l - 1);
}
inline int getval(int v) {
++v;
if (BIT[1 << int(log2(n) + 1)] < v) return -1;
int bst = 0;
for (int j = 1 << int(log2(n)); j; j >>= 1)
if (BIT[bst + j] < v) v -= BIT[bst + j], bst += j;
return bst;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]), add(i, 1);
for (int i = 0; i < n; ++i) scanf("%d", &b[i]);
for (int i = 0; i < n; ++i) {
fa[i] = getRange(0, a[i] - 1);
add(a[i], -1);
}
for (int i = 0; i < n; ++i) add(i, 1);
for (int i = 0; i < n; ++i) {
fb[i] = getRange(0, b[i] - 1);
add(b[i], -1);
}
for (int i = n - 1, c = 0, cm = 0; i >= 0; i--, cm++) {
fa[i] += fb[i] + c;
if (fa[i] > cm)
fa[i] -= (cm + 1), c = 1;
else
c = 0;
}
for (int i = 0; i < n; ++i) add(i, 1);
for (int i = 0; i < n; ++i) {
int v = getval(fa[i]);
printf("%d ", v);
add(v, -1);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int find_max(vector<int>& v) {
if (v.size() == 1) return v[0];
if (v.size() == 2) {
cout << "? " << v[0] << " " << v[1] << endl;
char c;
cin >> c;
if (c == '<') return v[1];
return v[0];
}
vector<int> w;
int n = v.size();
if (n % 2 == 1) {
w.push_back(v[n - 1]);
n--;
}
for (int k = 0; k < n; k += 2) {
cout << "? " << v[k] << " " << v[k + 1] << endl;
char c;
cin >> c;
if (c == '<')
w.push_back(v[k + 1]);
else
w.push_back(v[k]);
}
return find_max(w);
}
int find_min(vector<int>& v) {
if (v.size() == 1) return v[0];
if (v.size() == 2) {
cout << "? " << v[0] << " " << v[1] << endl;
char c;
cin >> c;
if (c == '>') return v[1];
return v[0];
}
vector<int> w;
int n = v.size();
if (n % 2 == 1) {
w.push_back(v[n - 1]);
n--;
}
for (int k = 0; k < n; k += 2) {
cout << "? " << v[k] << " " << v[k + 1] << endl;
char c;
cin >> c;
if (c == '>')
w.push_back(v[k + 1]);
else
w.push_back(v[k]);
}
return find_min(w);
}
void solve() {
int n;
cin >> n;
vector<int> Min, Max;
if (n % 2 == 1) {
Min.push_back(n);
Max.push_back(n);
n--;
}
for (int k = 1; k <= n; k += 2) {
cout << "? " << k << " " << k + 1 << endl;
char c;
cin >> c;
if (c == '<') {
Min.push_back(k);
Max.push_back(k + 1);
} else {
Min.push_back(k + 1);
Max.push_back(k);
}
}
int i_min = find_min(Min);
int i_max = find_max(Max);
cout << "! " << i_min << " " << i_max << endl;
}
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t) {
t--;
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int MAX = 4e5 + 5;
const long long int MAX1 = 1e2 + 5;
const long long int INF = 1e15 + 2;
const long long int MOD = 1e9 + 7;
inline long long int nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long int read() {
long long int ret = 0;
bool f = 0;
char ch = nc();
while (ch > '9' || ch < '0') f ^= ch == '-', ch = nc();
while (ch <= '9' && ch >= '0') ret = ret * 10 + ch - '0', ch = nc();
return f ? -ret : ret;
}
long long int power(long long int base, long long int ind, long long int mod) {
long long int res = 1;
while (ind) {
if (ind & 1) res = (res * base) % mod;
base = (base * base) % mod;
ind >>= 1;
}
return res;
}
long long int inv(long long int den, long long int mod) {
return power(den, mod - 2, mod);
}
long long int f[MAX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
;
long long int q, x;
cin >> q >> x;
long long int ans = 0;
while (q--) {
long long int val;
cin >> val;
f[val % x]++;
while (f[ans % x]) {
f[ans % x]--;
ans++;
}
cout << ans << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, max = -1001, min = 1001;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
int tmp, t1;
tmp = a[n - 1];
t1 = a[0];
a[0] = tmp;
a[n - 1] = t1;
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int P = 135;
int n, p, q, i, j, C[P], a[P], ans;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
scanf("%d%d%d", &n, &p, &q);
if (n - 1 < p) p = n - 1;
for (C[0] = 1, i = 1; i <= p; i++) {
a[i] = n + 1 - i;
int k = i;
for (j = 1; k > 1 && j <= i; j++) {
int gd = gcd(k, a[j]);
k /= gd;
a[j] /= gd;
}
for (C[i] = 1, j = 1; j <= i; j++) C[i] = C[i] * a[j];
}
for (i = 1; i <= q; i++) {
int pw = 1, sum = 0;
for (j = 0; j <= p; j++, pw *= i) sum += C[j] * pw;
ans ^= sum * i;
}
printf("%u", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, t = 0ll;
cin >> n;
if (n == 3)
cout << 1;
else if (n == 4)
cout << 4;
else {
t = t + (2 * (n - 2));
t = t + ((n - 2 - 1) * (n - 4));
t = t + (n - 2 - 2);
cout << t;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 510, MOD = 1e9 + 7;
bool adj[MN][MN];
int dp[MN][MN], P[MN][MN], n;
void ok(int &x) {
if (x >= MOD) x -= MOD;
}
int main() {
ios_base ::sync_with_stdio(false), cout.tie(0), cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) cin >> adj[i][j];
for (int sz = 0; sz < n; ++sz)
for (int l = 0; l + sz < n; ++l) {
int r = l + sz;
if (sz == 0) {
dp[l][r] = P[l][r] = 1;
continue;
}
if (sz == 1) {
P[l][r] = dp[l][r] = adj[l][r];
continue;
}
if (adj[l][r]) {
for (int j = l; j < r; ++j) {
P[l][r] += 1ll * dp[l][j] * dp[j + 1][r] % MOD;
ok(P[l][r]);
}
}
for (int j = l + 1; j < r; ++j) {
dp[l][r] += 1ll * P[l][j] * dp[j][r] % MOD;
ok(dp[l][r]);
}
dp[l][r] += P[l][r];
ok(dp[l][r]);
}
cout << dp[0][n - 1] << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dp[110][110];
int main() {
int n, v;
cin >> n >> v;
for (int i = 1; i <= v; i++) dp[1][i] = i;
for (int i = 2; i <= n; i++) {
for (int j = 0; j < v; j++) {
dp[i][j] = min(dp[i - 1][j + 1], dp[i - 1][j] + i);
}
dp[i][v] = dp[i - 1][v] + i;
}
int ans = 1000000000;
for (int i = 0; i < v + 1; i++) ans = min(ans, dp[n][i]);
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long q;
cin >> q;
while (q--) {
long long n;
cin >> n;
string a;
cin >> a;
vector<bool> us(n);
long long cnt = 0, sch = 0;
for (long long i = 0; i < n; ++i) {
long long x = i, y = (i + 1) % n;
if (a[i] == '-') {
us[x] = true;
us[y] = true;
}
if (a[i] == '>') {
++cnt;
}
if (a[i] == '<') {
++sch;
}
}
if (!sch || !cnt) {
cout << n << endl;
} else {
long long ans = 0;
for (long long i = 0; i < n; ++i) {
ans += us[i];
}
cout << ans << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
int N;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
int T;
std::cin >> T;
while (T--) {
std::set<int> smen;
std::set<int> set;
std::map<int, std::vector<int>> plus;
std::map<int, std::vector<int>> minus;
std::cin >> N;
for (int i = 0, x, y; i < N; ++i) {
std::cin >> x >> y;
smen.insert(x);
smen.insert(y);
plus[x].push_back(i);
minus[y].push_back(i);
}
int initial = 0;
std::vector<int> count(N, 0);
for (auto &it : smen) {
for (auto &event : plus[it]) set.insert(event);
for (auto &event : minus[it]) {
set.erase(event);
if (set.size() == 1)
count[*set.begin()]++;
else if (set.empty())
count[event]--;
}
initial += (set.empty() ? 1 : 0);
}
int ans = count[0];
for (int i = 1; i < N; ++i) ans = std::max(ans, count[i]);
ans = ans + initial;
std::cout << ans << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
char d[n + 1];
cin >> d;
if (d[a - 1] != d[b - 1])
cout << 1;
else
cout << 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
static inline int Rint() {
struct X {
int dig[256];
X() {
for (int i = '0'; i <= '9'; ++i) dig[i] = 1;
dig['-'] = 1;
}
};
static X fuck;
int s = 1, v = 0, c;
for (; !fuck.dig[c = getchar()];)
;
if (c == '-')
s = 0;
else if (fuck.dig[c])
v = c ^ 48;
for (; fuck.dig[c = getchar()]; v = v * 10 + (c ^ 48))
;
return s ? v : -v;
}
template <typename T>
static inline void cmax(T& a, const T& b) {
if (b > a) a = b;
}
template <typename T>
static inline void cmin(T& a, const T& b) {
if (b < a) a = b;
}
const int maxn = 100005;
void merged(long long& l, long long& r, long long a, long long b) {
if (a > b) return;
if (a > r) return;
if (b < l) return;
r = max(r, b);
l = min(l, a);
}
long long u[maxn], v[maxn];
int check0(int n, int m, long long val) {
long long l = -1, r = -2;
for (int i = 1, j = 1; i <= m;) {
const long long a = l, b = r;
if (v[i] >= l && v[i] <= r) {
++i;
continue;
}
if (j <= n) {
if (u[j] <= v[i]) {
l = u[j];
r = u[j] + val;
merged(l, r, a, b);
} else {
if (v[i] >= u[j] - val) {
l = v[i];
r = max(u[j], v[i] + (val - (u[j] - v[i])));
cmax(r, u[j] + (val - (u[j] - v[i])) / 2);
merged(l, r, a, b);
}
}
++j;
} else {
return 0;
}
}
return 1;
}
int check(int n, int m, long long val) { return check0(n, m, val); }
int main() {
const int n = Rint(), m = Rint();
for (int i = 1; i <= n; ++i) scanf("%I64d", u + i);
for (int i = 1; i <= m; ++i) scanf("%I64d", v + i);
long long l = 0, r = 10 * 10000000000LL;
while (l <= r) {
const long long mid = l + r >> 1;
if (check(n, m, mid))
r = mid - 1;
else
l = mid + 1;
}
printf("%I64d\n", l);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.length() < 26) {
return cout << -1 << endl, 0;
}
bool vis[26] = {false};
char cur = 'a';
for (int i = 0; i < s.length(); i++) {
if (s[i] <= cur) {
s[i] = cur;
cur++;
vis[cur - 'a' - 1] = true;
if (cur > 'z') break;
continue;
}
}
for (int i = 0; i < 26; i++) {
if (!vis[i]) {
return cout << -1 << endl, 0;
}
}
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const long long mod = 1e9 + 7;
using namespace std;
long long t;
long long poin[] = {0, 25, 18, 15, 12, 10, 8, 6, 4, 2, 1};
map<string, long long> conv;
struct struk {
string names;
long long ranks[60], total = 0;
};
bool cmp(struk s1, struk s2) {
if (s1.total == s2.total) {
for (int i = 1; i <= 50; ++i) {
if (s1.ranks[i] != s2.ranks[i]) return s1.ranks[i] > s2.ranks[i];
}
}
return s1.total > s2.total;
}
bool cmp1(struk s1, struk s2) {
if (s1.ranks[1] == s2.ranks[1]) {
if (s1.total != s2.total) return s1.total > s2.total;
for (int i = 2; i <= 50; ++i) {
if (s1.ranks[i] != s2.ranks[i]) return s1.ranks[i] > s2.ranks[i];
}
}
return s1.ranks[1] > s2.ranks[1];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
vector<struk> arr(100);
cin >> t;
long long cur = 1;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
string s;
cin >> s;
if (!conv.count(s)) {
conv[s] = cur++;
arr[cur - 1].names = s;
}
if (i <= 10) arr[conv[s]].total += poin[i];
arr[conv[s]].ranks[i]++;
}
}
sort(arr.begin() + 1, arr.begin() + cur, cmp);
cout << arr[1].names << '\n';
sort(arr.begin() + 1, arr.begin() + cur, cmp1);
cout << arr[1].names << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int main(int argc, char *argv[]) {
int T;
scanf("%d", &T);
for (int t = 0; t < T; ++t) {
int N;
scanf("%d", &N);
vector<int> v(N);
for (int i = 0; i < N; ++i) {
scanf("%d", &v[i]);
}
int count = 0;
for (int i = 1; i < N; ++i) {
if (v[i] < v[i - 1]) count++;
}
if (count == N - 1)
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int br = 20 * 60;
int main() {
int hh, mm, uk;
scanf("%d %d", &hh, &mm);
double h, d;
double c, n;
double sol = (double)INF;
cin >> h >> d >> c >> n;
uk = hh * 60 + mm;
while (uk < 24 * 60) {
if (uk >= br) {
double cc = 0.8 * c;
sol = min(sol, cc * ceil(h / n));
} else {
sol = min(sol, c * ceil(h / n));
}
++uk;
h += d;
}
cout << fixed << setprecision(7) << sol;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
}
void solve() {
int t;
cin >> t;
map<string, int> mp;
vector<string> v(t);
for (int i = 0; i < t; i++) cin >> v[i];
reverse(v.rbegin(), v.rend());
for (int i = 0; i < t; i++) {
if (mp[v[i]] == 0) {
cout << v[i] << "\n";
mp[v[i]]++;
}
}
}
int main() {
fast();
solve();
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.