solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int N, M;
int par[(int)1e5 + 3][21], depth[(int)1e5 + 3], dp[(int)1e5 + 3],
ans[(int)1e5 + 3];
vector<int> v[(int)1e5 + 3];
map<pair<int, int>, int> mp;
void dfs(int n, int p) {
depth[n] = depth[p] + 1;
par[n][0] = p;
for (int i = 0; i < v[n].size(); i++) {
if (v[n][i] != p) dfs(v[n][i], n);
}
}
void precompute() {
for (int i = 1; i <= 20; i++) {
for (int node = 1; node <= N; node++) {
if (par[node][i - 1] != -1) par[node][i] = par[par[node][i - 1]][i - 1];
}
}
}
int lca(int u, int v) {
if (depth[v] < depth[u]) swap(u, v);
int diff = depth[v] - depth[u];
for (int i = 0; i <= 20; i++)
if ((diff >> i) & 1) v = par[v][i];
if (u == v) return u;
for (int i = 20; i >= 0; i--)
if (par[u][i] != par[v][i]) {
u = par[u][i];
v = par[v][i];
}
return par[u][0];
}
void Count(int n, int p) {
for (int i = 0; i < v[n].size(); i++) {
int to = v[n][i];
if (to == p) continue;
Count(to, n);
dp[n] += dp[to];
int idx = mp[make_pair(to, n)];
ans[idx] = dp[to];
}
}
int main() {
ios::sync_with_stdio(false);
cin >> N;
for (int i = 0; i < N - 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
mp[make_pair(x, y)] = mp[make_pair(y, x)] = i;
}
cin >> M;
dfs(1, -1);
precompute();
while (M--) {
int x, y;
cin >> x >> y;
int z = lca(x, y);
dp[z] -= 2;
dp[x]++;
dp[y]++;
}
Count(1, -1);
for (int i = 0; i < N - 1; i++) cout << ans[i] << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const double pi = 3.1415926535897932, eps = 1e-6;
int n, tm, t[5005];
double p[5005], dp[5005][5005], ans;
double qpow(double x, int y) {
double cur = 1;
while (y) {
if (y & 1) cur *= x;
x *= x;
y >>= 1;
}
return cur;
}
int main() {
scanf("%d%d", &n, &tm);
for (int(i) = (1); (i) <= (n); (i)++)
scanf("%lf%d", p + i, t + i), p[i] /= 100.0;
dp[1][0] = 1;
for (int(i) = (1); (i) <= (n); (i)++) {
double now = 0, r1 = qpow(1 - p[i], t[i] - 1) * p[i],
r2 = qpow(1 - p[i], t[i] - 1);
for (int(j) = (0); (j) <= (tm - 1); (j)++) {
now *= 1 - p[i];
now += dp[i][j] * p[i];
if (j + 1 >= t[i]) {
now -= dp[i][j + 1 - t[i]] * r1;
dp[i + 1][j + 1] = now + dp[i][j + 1 - t[i]] * r2;
} else
dp[i + 1][j + 1] = now;
}
for (int(j) = (0); (j) <= (tm); (j)++) ans += dp[i + 1][j];
}
printf("%.10lf", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bitset<1000> state[1000];
struct query {
int v, tp, x, y;
};
vector<query> g[100001];
int ans[100001];
int N, M, Q;
void dfs(int u) {
int here = ans[u];
for (const auto& q : g[u]) {
int there = here;
if (q.tp == 1) {
bool b = state[q.x][q.y];
if (!b) state[q.x][q.y] = true, there++;
ans[q.v] = there;
dfs(q.v);
if (!b) state[q.x][q.y] = false;
} else if (q.tp == 2) {
bool b = state[q.x][q.y];
if (b) state[q.x][q.y] = false, there--;
ans[q.v] = there;
dfs(q.v);
if (b) state[q.x][q.y] = true;
} else if (q.tp == 3) {
int c = 0;
for (int i = 0; i < M; i++)
if (state[q.x][i]) c++;
int there = here - c + M - c;
state[q.x].flip();
ans[q.v] = there;
dfs(q.v);
state[q.x].flip();
} else {
ans[q.v] = here;
dfs(q.v);
}
}
}
int main() {
scanf("%d%d%d", &N, &M, &Q);
for (int i = 1; i <= Q; i++) {
int tp;
scanf("%d", &tp);
if (tp == 1 || tp == 2) {
int x, y;
scanf("%d%d", &x, &y);
g[i - 1].push_back({i, tp, x - 1, y - 1});
} else if (tp == 3) {
int x;
scanf("%d", &x);
g[i - 1].push_back({i, tp, x - 1, -1});
} else {
int x;
scanf("%d", &x);
g[x].push_back({i, tp, -1, -1});
}
}
dfs(0);
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
unsigned long long int n;
cin >> n;
cout << "25";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[100100];
vector<int> cha[100100];
int tot;
queue<int> q[2];
int cnt[2];
vector<int> typ[2];
deque<int> ta;
int ca;
int ans[100100];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
int p, id;
for (int i = 1; i <= n; ++i) {
p = (s[i] == 'R');
if (q[p ^ 1].empty()) {
tot++;
cha[tot].push_back(i);
q[p].push(tot);
} else {
id = q[p ^ 1].front();
q[p ^ 1].pop();
cha[id].push_back(i);
q[p].push(id);
}
}
int lr = tot + 1, rl = tot + 2;
int ma;
for (int i = 1; i <= tot; ++i) {
if (s[cha[i][0]] == 'L') {
if (s[cha[i][cha[i].size() - 1]] == 'L')
typ[0].push_back(i);
else {
ma = cha[i].size() - 1;
for (int j = 0; j <= ma; ++j) cha[lr].push_back(cha[i][j]);
}
} else {
if (s[cha[i][cha[i].size() - 1]] == 'R')
typ[1].push_back(i);
else {
ma = cha[i].size() - 1;
for (int j = 0; j <= ma; ++j) cha[rl].push_back(cha[i][j]);
}
}
}
int slr = cha[lr].size(), srl = cha[rl].size();
int fl = 0;
if (slr && srl) {
fl = 1;
typ[0].push_back(lr);
typ[1].push_back(rl);
if (cha[lr][slr - 1] > cha[rl][srl - 1])
cha[rl].push_back(cha[lr][slr - 1]), cha[lr].resize(slr - 1);
else
cha[lr].push_back(cha[rl][srl - 1]), cha[rl].resize(srl - 1);
}
cnt[0] = typ[0].size(), cnt[1] = typ[1].size();
int pos[2] = {0, 0};
int cur = cnt[1] > cnt[0] ? 1 : 0;
if (cnt[1] == cnt[0] && fl == 0 && srl) cur = 1;
for (; pos[0] < cnt[0] || pos[1] < cnt[1]; cur ^= 1) {
id = typ[cur][pos[cur]];
pos[cur]++;
ma = cha[id].size();
for (int i = 0; i < ma; ++i) ta.push_back(cha[id][i]);
}
if (!fl) {
if (slr) {
int flag = 0;
if (ta.size())
if (s[ta.back()] == 'R') {
flag = 1;
for (int i = 0; i < slr; ++i) ta.push_back(cha[lr][i]);
}
if (!flag)
for (int i = slr - 1; i >= 0; --i) ta.push_front(cha[lr][i]);
} else if (srl) {
int flag = 0;
if (ta.size())
if (s[ta.back()] == 'L') {
flag = 1;
for (int i = 0; i < srl; ++i) ta.push_back(cha[rl][i]);
}
if (!flag) {
for (int i = srl - 1; i >= 0; --i) ta.push_front(cha[rl][i]);
}
}
}
ans[1] = ta.front();
ta.pop_front();
p = 1;
while (ta.size()) {
ans[++p] = ta.front(), ta.pop_front();
if (ans[p] < ans[p - 1]) ca++;
}
printf("%d\n", ca);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
clock_t startTime = clock();
using namespace std;
void io() {
ios::sync_with_stdio(false);
cin.tie(0);
}
double PI = 4 * atan(1);
long long mod = 1e9 + 7, mxn = 3e5 + 5;
void deb(vector<long long> v) {
for (auto t : v) cerr << t << " ";
cerr << "\n";
}
long long mul(long long a, long long b, long long mod) {
a %= mod;
b %= mod;
a *= b;
a += mod;
return a % mod;
}
bool sortbysecdesc(const pair<int, int> &a, const pair<int, int> &b) {
return a.second > b.second;
}
bool check_sorted(vector<long long> a) {
long long n = a.size();
for (long long i = 1; i < n; i++) {
if (a[i] >= a[i - 1]) continue;
return false;
}
return true;
}
vector<long long> fact(2e5 + 5, 1);
long long binPow(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a;
long long ret = binPow(a, b / 2);
if (b % 2 == 0) return (ret * ret) % mod;
return ((ret * ret) % mod * a) % mod;
}
long long inv(long long a) { return (binPow(a, mod - 2) % mod + mod) % mod; }
long long binom(long long a, long long b) {
if (b < 0 or a < 0) return 0;
return (((fact[a] * inv(fact[b])) % mod * inv(fact[a - b])) % mod + mod) %
mod;
}
vector<int> sieveOfEratosthenes(int N) {
bool primes[N + 1];
memset(primes, true, sizeof(primes));
vector<int> arr;
for (int i = 2; i * i <= N; i++)
if (primes[i] == true) {
for (int j = i * i; j <= N; j += i) primes[j] = false;
}
for (int i = 2; i <= N; i++)
if (primes[i]) arr.emplace_back(i);
return arr;
}
void prime_fact(long long n, vector<long long> &res) {
while (n % 2 == 0) {
res.push_back(2);
n = n / 2;
}
for (long long i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
res.push_back(i);
n = n / i;
}
}
if (n > 2) {
res.push_back(n);
}
}
bool valid_coordinate(long long x, long long y, long long n, long long m) {
if (x < 0 || y < 0)
return false;
else if (x >= n || y >= m)
return false;
else
return true;
}
int sod(int n) {
int sum = 0;
while (n) {
sum += (n % 10);
n /= 10;
}
return sum;
}
bool isPowerOfTwo(long long n) { return n && (!(n & (n - 1))); }
bool check(vector<long long> &a, long long h, long long mid) {
long long cnt = 0;
for (long long i = 0; i < a.size(); i++) {
long long newVal = a[i] + mid;
if (i + 1 < a.size() && a[i + 1] < newVal) {
cnt += a[i + 1] - a[i];
} else {
cnt += mid;
}
if (cnt >= h) return true;
}
return false;
}
void solve() {
long long n, h;
cin >> n >> h;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long lo = 0, hi = 1e18;
while (lo < hi) {
long long mid = lo + (hi - lo) / 2;
if (check(a, h, mid)) {
hi = mid;
} else {
lo = mid + 1;
}
}
cout << lo << endl;
return;
}
int main() {
io();
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
string s;
cin >> s;
int w1 = 0, w2 = 0;
int wynik = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '(')
w1++;
else {
w2++;
if (w2 > w1) {
w2--;
wynik++;
}
}
}
cout << wynik << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
template <typename T>
T gcd(T a, T b) {
return (b ? __gcd(a, b) : a);
}
template <typename T>
T lcm(T a, T b) {
return (a * (b / gcd(a, b)));
}
void run() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long check(long n) {
long long ans = n - 1;
long long low = 2, high = n - 1;
while (low <= high) {
long long mid = (low + high) / 2;
long long x = n / (mid);
x = x + mid - 2;
if (n % mid) x++;
if (x <= ans) {
ans = x;
high = mid - 1;
} else
low = mid + 1;
}
return ans;
}
int main() {
run();
int test;
cin >> test;
while (test--) {
long n;
cin >> n;
long long ans = check(n);
long f = ans;
for (long i = f - 1; i >= 1; i--) {
long long x = n / (i);
x = x + i - 2;
if (n % i) x++;
ans = min(ans, x);
}
cout << ans << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int le, ri;
int mx, tag;
} sgt[20005 << 2];
int n, m, k;
int a[55][20005], sum[55][20005], dp[55][20005];
void build(int cur, int l, int r, int x) {
sgt[cur].le = l, sgt[cur].ri = r;
sgt[cur].tag = 0;
if (l == r - 1) {
sgt[cur].mx = dp[x - 1][l] + sum[x][l + k - 1] - sum[x][max(k - 1, l - 1)];
} else {
int le = cur << 1, ri = le + 1;
build(le, l, (l + r) >> 1, x);
build(ri, (l + r) >> 1, r, x);
sgt[cur].mx = max(sgt[le].mx, sgt[ri].mx);
}
}
void update(int cur) {
int le = cur << 1, ri = le + 1;
sgt[le].mx += sgt[cur].tag;
sgt[ri].mx += sgt[cur].tag;
sgt[le].tag += sgt[cur].tag;
sgt[ri].tag += sgt[cur].tag;
sgt[cur].tag = 0;
}
void modify(int cur, int l, int r, int del) {
if (l <= sgt[cur].le && sgt[cur].ri <= r) {
sgt[cur].mx += del;
sgt[cur].tag += del;
} else {
if (sgt[cur].tag) update(cur);
int le = cur << 1, ri = le + 1;
int mid = (sgt[cur].le + sgt[cur].ri) >> 1;
if (l < mid) modify(le, l, r, del);
if (r > mid) modify(ri, l, r, del);
sgt[cur].mx = max(sgt[le].mx, sgt[ri].mx);
}
}
void solve() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
sum[i][0] = 0;
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
sum[i][j] = sum[i][j - 1] + a[i][j];
}
}
for (int j = 1; j <= m - k + 1; j++)
dp[1][j] = sum[1][j + k - 1] - sum[1][j - 1];
for (int i = 2; i <= n; i++) {
build(1, 1, m - k + 2, i);
for (int j = 1; j <= m - k + 1; j++) {
modify(1, j, j + k, -a[i][j + k - 1]);
dp[i][j] = sgt[1].mx + sum[i][j + k - 1] - sum[i][j - 1];
modify(1, max(j - k + 1, 1), j + 1, a[i][j]);
}
}
int ans = dp[n][1];
for (int j = 2; j <= m; j++) ans = max(ans, dp[n][j]);
printf("%d\n", ans);
}
int main() {
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a{}, b{}, c{}, d{};
cin >> a >> b >> c >> d;
int cnt1{}, cnt2{};
cnt1 = max(3 * a / 10, a - a / 250 * c);
cnt2 = max(3 * b / 10, b - b / 250 * d);
if (cnt1 == cnt2) cout << "Tie\n";
if (cnt1 > cnt2) cout << "Misha\n";
if (cnt1 < cnt2) cout << "Vasya\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[3005];
int main() {
scanf("%s", s);
set<char> forb;
forb.insert('a');
forb.insert('e');
forb.insert('i');
forb.insert('o');
forb.insert('u');
int m = strlen(s);
int q = 0;
set<char> diff;
string ans = "";
for (int i = 0; i < m; i++) {
if (!forb.count(s[i])) {
diff.insert(s[i]);
q++;
if (diff.size() > 1 && q > 2) {
i--;
printf("%s ", ans.c_str());
ans = "";
q = 0;
diff.clear();
continue;
}
ans += s[i];
} else {
ans += s[i];
diff.clear();
q = 0;
}
}
printf("%s\n", ans.c_str());
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long P = 1050, N = P * P, W = 1e9;
long long n, m, Q, num = 0, top, S, T;
map<long long, bool> mp;
void ins(long long u, long long v) {
if (u == v) return;
if (u > v) swap(u, v);
mp[u * W + v] = 1;
}
bool chk(long long u, long long v) {
if (u > v) swap(u, v);
return mp[u * W + v];
}
char s[P];
long long t[P][P], col[P][P], p[20];
long long cx[8] = {1, -1, 0, 0, 1, 1, -1, -1},
cy[8] = {0, 0, 1, -1, -1, 1, -1, 1};
void dfs(long long x, long long y) {
long long i, nx, ny;
col[x][y] = num;
for (i = 0; i < 8; i++) {
nx = x + cx[i];
ny = y + cy[i];
if (t[nx][ny] && (!col[nx][ny])) dfs(nx, ny);
}
}
void init() {
long long i, j, k, k1, k2, nx, ny;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (t[i][j] && (!col[i][j])) {
num++;
dfs(i, j);
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if ((i == 2 && j == 2) || (i == n - 1 && j == m - 1)) continue;
if (t[i][j] == 0) {
top = 0;
for (k = 0; k < 8; k++) {
nx = i + cx[k];
ny = j + cy[k];
if (col[nx][ny]) p[++top] = col[nx][ny];
}
sort(p + 1, p + top + 1);
top = unique(p + 1, p + top + 1) - p - 1;
for (k1 = 1; k1 < top; k1++)
for (k2 = k1 + 1; k2 <= top; k2++) {
ins(p[k1], p[k2]);
}
}
}
}
}
long long K, tim = 0;
vector<long long> e[N];
long long px[20], py[20];
void eadd(long long u, long long v) {
e[u].push_back(v);
e[v].push_back(u);
}
long long vis[N];
vector<long long> vec[2];
void srh(long long x, long long c) {
vis[x] = tim;
vec[c].push_back(x);
for (long long v : e[x]) {
if (vis[v] == tim) continue;
srh(v, c);
}
}
bool mchk(long long i1, long long i2) {
if (i1 < i2) swap(i1, i2);
if (i1 > num && i2 > num) {
i1 -= num;
i2 -= num;
return max(abs(px[i1] - px[i2]), abs(py[i1] - py[i2])) <= 2;
}
if (i1 > num) {
long long x, y, nx, ny;
x = px[i1 - num];
y = py[i1 - num];
for (nx = x - 2; nx <= x + 2; nx++) {
for (ny = y - 2; ny <= y + 2; ny++) {
if (nx >= 1 && nx <= n && ny >= 1 && ny <= m) {
if (col[nx][ny] == i2) return 1;
}
}
}
return 0;
} else {
return chk(i1, i2);
}
}
bool solve() {
long long i, j, x, y, nx, ny;
scanf("%lld", &K);
for (i = 1; i <= K; i++) {
scanf("%lld%lld", &x, &y);
x++;
y++;
px[i] = x;
py[i] = y;
col[x][y] = num + i;
}
for (i = 1; i <= K; i++) {
x = px[i];
y = py[i];
for (j = 0; j < 8; j++) {
nx = x + cx[j];
ny = y + cy[j];
if (col[nx][ny]) eadd(num + i, col[nx][ny]);
}
}
S = col[3][1];
T = col[1][3];
vec[0].clear();
vec[1].clear();
tim++;
srh(S, 0);
srh(T, 1);
for (i = 1; i <= K; i++) {
x = px[i];
y = py[i];
col[x][y] = 0;
e[num + i].clear();
for (j = 0; j < 8; j++) {
nx = x + cx[j];
ny = y + cy[j];
if (col[nx][ny]) e[col[nx][ny]].clear();
}
}
for (long long x : vec[0])
if (x == T) return 1;
for (long long x : vec[0]) {
for (long long y : vec[1]) {
if (mchk(x, y)) return 1;
}
}
return 0;
}
int main() {
long long i, j;
scanf("%lld%lld%lld", &n, &m, &Q);
n += 2;
m += 2;
for (i = 2; i < n; i++) {
scanf("%s", s + 1);
for (j = 2; j <= m; j++)
if (s[j - 1] == '#') t[i][j] = 1;
}
for (i = 3; i <= m; i++) t[1][i] = 1;
for (i = 2; i <= n - 2; i++) t[i][m] = 1;
for (i = 3; i <= n; i++) t[i][1] = 1;
for (i = 2; i <= m - 2; i++) t[n][i] = 1;
init();
while (Q--) {
if (solve())
puts("NO");
else
puts("YES");
fflush(stdout);
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long bit = 997;
const long long bitt = 2333;
const long long mod = 23333333333LL;
const long long modd = 1000000009LL;
const long long MOD = 1000000007LL;
const long long inf = 1LL << 50;
char s[1000005];
char ss[1000005];
long long num[1000005];
long long a[1000005];
long long w[1000005];
long long v[1000005];
long long q[1000005];
long long r[1000005];
int main() {
w[0] = 1;
v[0] = 1;
for (int i = 1; i <= 1000000; ++i)
w[i] = w[i - 1] * bit % mod, v[i] = v[i - 1] * bitt % modd;
int n, m;
while (~scanf("%d%d", &n, &m)) {
long long ans = 0, anss = 0;
scanf("%s", s);
int len = strlen(s);
for (int i = 0; i <= n; ++i) num[i] = inf;
for (int i = 0; i < m; ++i) {
scanf("%I64d", a + i);
num[a[i]] = 1;
}
for (int i = 1; i <= n; ++i) num[i] = min(num[i], num[i - 1] + 1);
for (int i = 0; i <= n; ++i)
if (num[i] <= len) ss[i] = s[num[i] - 1];
for (int i = 1; i <= n; ++i)
if (num[i] > len) ans++;
anss = 1;
for (int i = 0; i < ans; ++i) anss = anss * 26 % MOD;
long long p = 0, p2 = 0;
for (int i = 0; i < len; ++i) {
p = (p + s[i] * w[len - i - 1]) % mod;
p2 = (p2 + s[i] * v[len - 1 - i]) % modd;
}
for (int i = 1; i <= len; ++i) {
q[i] = (q[i - 1] + ss[i] * w[len - i]) % mod;
r[i] = (r[i - 1] + ss[i] * v[len - i]) % modd;
}
for (int i = len + 1; i <= n; ++i) {
q[i] = (((q[i - 1] - ss[i - len] * w[len - 1]) % mod + mod) % mod * bit +
ss[i]) %
mod;
r[i] =
(((r[i - 1] - ss[i - len] * v[len - 1]) % modd + modd) % modd * bitt +
ss[i]) %
modd;
}
bool ok = 0;
for (int i = 0; i < m; ++i)
if (q[a[i] + len - 1] != p || r[a[i] + len - 1] != p2) {
puts("0");
ok = 1;
break;
}
if (ok) continue;
printf("%I64d\n", anss % MOD);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace ::std;
int fx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int fy[] = {1, -1, 0, 0, 1, 1, -1, -1};
template <class T>
T Square(T a) {
return T(a * a);
}
template <class T, class S>
S Distance(T a, T b) {
return S(sqrt(S(Square(S(a)) + Square(S(b)))));
}
template <class T>
T Tbits(T a) {
T c(0);
while (++c, a /= 2, a)
;
return c;
}
template <class T>
T Obits(T a) {
T c(0);
while (c += (a & 1), a /= 2, a)
;
return c;
}
template <class T>
T Gcd(T a, T b) {
T c(0);
if (b)
while (b, c = a % b, a = b, b = c, b)
;
return a;
}
template <class T>
void Failure(T F[], string text, T sz) {
memset(F, 0, sizeof F);
T i, j;
for (i = 2; i <= sz; ++i) {
for (j = F[i - 1]; j and text[i - 1] != text[j]; j = F[j])
;
if (text[i - 1] == text[j]) F[i] = ++j;
}
}
int N, C, R, M, K;
int DeadPool[107][107];
const long long mod = 1e9 + 7;
vector<int> dig;
int Hash(vector<int> x) {
long long prime = 1, res = 0;
for (int i = 0; i < x.size(); ++i)
res = (res + prime * x[i]) % mod, prime = (prime * 153LL) % mod;
int d = res;
return d;
}
int rec() {}
int main() {
int test, t(1), a, b = 0;
int offer, Product, items, value, tog;
cin >> offer;
cout << offer << endl;
for (int i = 0; i < offer; ++i) cout << 1 << ' ';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = (int)1e5 + 20, MAX_H = 20, INF = (int)1e9;
vector<int> adj[MAX_N];
int mark[MAX_N], upMax[MAX_N], cut_ed[MAX_N], d[MAX_N];
int Par[MAX_N][MAX_H];
int n, m, k;
void readInput() {
cin >> n >> m;
for (int i(0); i < int(m); i++) {
int v, u;
cin >> v >> u;
--v, u--;
adj[v].push_back(u);
adj[u].push_back(v);
}
for (int i(0); i < int(n); i++) upMax[i] = INF;
}
void dfs(int v) {
mark[v] = 1;
for (int i(0); i < int(adj[v].size()); i++) {
int u = adj[v][i];
if (!mark[u]) {
d[u] = d[v] + 1;
Par[u][0] = v;
dfs(u);
upMax[v] = min(upMax[v], upMax[u]);
} else if (mark[u] && u != Par[v][0])
upMax[v] = min(upMax[v], d[u]);
}
if (upMax[v] >= d[v]) ++cut_ed[v];
}
void sfd(int v) {
mark[v] = 1;
for (int i(0); i < int(adj[v].size()); i++) {
int u = adj[v][i];
if (!mark[u]) {
cut_ed[u] += cut_ed[v];
sfd(u);
}
}
}
int get_P(int v, int dist) {
for (int i(0); i < int(MAX_H); i++)
if ((dist & (1 << i))) v = Par[v][i];
return v;
}
int LCA(int v, int u) {
if (d[v] < d[u]) swap(v, u);
v = get_P(v, d[v] - d[u]);
if (v == u) return v;
for (int i(MAX_H - 1); i >= int(0); i--)
if (Par[v][i] != Par[u][i]) v = Par[v][i], u = Par[u][i];
return Par[v][0];
}
void query() {
cin >> k;
while (k--) {
int v, u;
cin >> v >> u;
--v, u--;
cout << cut_ed[v] + cut_ed[u] - cut_ed[LCA(v, u)] * 2 << endl;
}
}
int main() {
ios::sync_with_stdio(false);
readInput();
dfs(0);
for (int i(1); i < int(MAX_H); i++)
for (int v(0); v < int(n); v++) Par[v][i] = Par[Par[v][i - 1]][i - 1];
fill(mark, mark + n, 0);
sfd(0);
query();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, d, lg[200100] = {-1};
long long ans;
int maxa[200100][30], minb[200100][30];
int getmax(int x, int y) {
int k = lg[y - x + 1];
return max(maxa[x][k], maxa[y + 1 - (1 << k)][k]);
}
int getmin(int x, int y) {
int k = lg[y - x + 1];
return min(minb[x][k], minb[y + 1 - (1 << k)][k]);
}
int lower(int x, int l, int r) {
int mid;
while (r > l) {
mid = (l + r) / 2;
if (getmax(x, mid) >= getmin(x, mid))
r = mid;
else
l = mid + 1;
}
if (getmax(x, l) == getmin(x, l))
return l;
else
return 0;
}
int upper(int x, int l, int r) {
int mid;
while (r > l) {
mid = (l + r + 1) / 2;
if (getmax(x, mid) <= getmin(x, mid))
l = mid;
else
r = mid - 1;
}
return l;
}
int main() {
int i, j, l, r, t;
cin >> n;
for (i = 1; i < 200100; i++) lg[i] = lg[i / 2] + 1;
for (i = 1; i <= n; i++) cin >> maxa[i][0];
for (i = 1; i <= n; i++) cin >> minb[i][0];
for (j = 1; j <= lg[n]; j++) {
t = n - (1 << j) + 1;
for (i = 1; i <= t; i++) {
maxa[i][j] = max(maxa[i][j - 1], maxa[i + (1 << (j - 1))][j - 1]);
minb[i][j] = min(minb[i][j - 1], minb[i + (1 << (j - 1))][j - 1]);
}
}
for (i = 1; i <= n; i++)
if (minb[i][0] >= maxa[i][0]) {
l = lower(i, i, n);
if (l > 0) {
r = upper(i, i, n);
ans += r - l + 1;
}
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string name[16];
int nel[1000][2];
int n, m;
int num(int i) {
int kol = 0;
while (i > 0) {
if (i % 2 == 1) ++kol;
i /= 2;
}
return kol;
}
bool check(int ch) {
bool arr[16];
for (int i = 0; i < 16; ++i) arr[i] = 0;
int i = 0;
while (ch > 0) {
arr[i++] = ch % 2;
ch /= 2;
}
for (int i = 0; i < m; ++i)
if (arr[nel[i][0]] && arr[nel[i][1]]) return false;
return true;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> name[i];
for (int i = 0; i < m; ++i) {
string s;
int t1, t2;
cin >> s;
for (int j = 0; j < n; ++j)
if (name[j] == s) t1 = j;
cin >> s;
for (int j = 0; j < n; ++j)
if (name[j] == s) t2 = j;
nel[i][0] = t1;
nel[i][1] = t2;
}
int numm = 0, max = -1;
for (int i = 0; i < 1 << n; ++i) {
if (check(i) && num(i) > max) max = num(i), numm = i;
}
cout << max << endl;
int i = 0;
vector<string> otv;
while (numm > 0) {
if (numm % 2 == 1) otv.push_back(name[i]);
numm /= 2;
++i;
}
sort(otv.begin(), otv.end());
for (int i = 0; i < otv.size(); ++i) cout << otv[i] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0) return b;
if (b == 0) return a;
if (a == b) return a;
if (a > b) return gcd(a - b, b);
return gcd(a, b - a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
int a, h, sum = 0;
cin >> a;
for (int i = 2; i < a; i++) {
int n = a;
while (n >= i) {
sum += n % i;
n = n / i;
}
sum += n;
}
h = gcd(sum, a - 2);
cout << sum / h << "/" << (a - 2) / h << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, k, i;
double t, z, a, b, d = 0;
scanf("%d %d", &n, &k);
int x[n], y[n];
for (i = 0; i < n; i++) {
scanf("%d %d", &x[i], &y[i]);
}
for (i = 1; i < n; i++) {
a = x[i - 1] - x[i];
b = y[i - 1] - y[i];
a = pow(a, 2);
b = pow(b, 2);
z = a + b;
z = sqrt(z);
d = d + z;
}
t = (d / 50) * k;
printf("%.9lf", t);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int T, n, par[MAXN];
long long cnt[MAXN], ans;
vector<pair<int, int>> edge;
bool check(int x) {
while (x > 0) {
if (x % 10 != 4 && x % 10 != 7) return false;
x /= 10;
}
return true;
}
int get_par(int v) { return (par[v] < 0 ? v : par[v] = get_par(par[v])); }
void merge(int u, int v, long long c) {
if ((u = get_par(u)) == (v = get_par(v))) return;
if (par[u] > par[v]) swap(u, v);
par[u] += par[v];
par[v] = u;
cnt[u] = c;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
T = 1;
while (T--) {
memset(par, -1, sizeof par);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v, w;
cin >> u >> v >> w;
if (check(w)) {
edge.push_back({u, v});
} else {
merge(u, v, 0);
}
}
for (auto e : edge) {
int u = get_par(e.first);
int v = get_par(e.second);
ans += 1LL * (-par[u]) * (-par[u] - 1) * (-par[v]) +
1LL * (-par[v]) * (-par[v] - 1) * (-par[u]);
ans += 4LL * (-par[u]) * cnt[v] + 4LL * (-par[v]) * cnt[u];
merge(u, v, 1LL * par[v] * par[u] + cnt[v] + cnt[u]);
}
cout << ans;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e6 + 15;
const int Q = 1e9 + 7;
long long a[M];
long long l[M], r[M];
set<pair<long long, int> > se;
int ans[M];
vector<pair<pair<long long, long long>, int> > g;
int main() {
srand(time(NULL));
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
scanf(
"%lld"
"%lld",
&l[i], &r[i]);
for (int i = 0; i < m; i++) {
scanf("%lld", &a[i]);
g.push_back(make_pair(make_pair(a[i], -i), -1));
}
for (int i = 0; i < n - 1; i++) {
g.push_back(make_pair(make_pair(r[i + 1] - l[i], l[i + 1] - r[i]), i));
}
sort(g.begin(), g.end());
for (int i = 0; i < (int)g.size(); i++) {
if (g[i].second == -1) {
se.insert(make_pair(g[i].first.first, -g[i].first.second));
} else {
set<pair<long long, int> >::iterator it =
se.lower_bound(make_pair(g[i].first.second, -1));
if (it == se.end() || (*it).first > g[i].first.first) {
cout << "No";
return 0;
}
ans[g[i].second] = (*it).second + 1;
se.erase(it);
}
}
cout << "Yes\n";
for (int i = 0; i < n - 1; i++) printf("%d ", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int cubic_array[24];
for (int i = 0; i < 24; i++) {
cin >> cubic_array[i];
}
int temp_array[24];
for (int i = 0; i < 24; i++) {
temp_array[i] = cubic_array[i];
}
for (int i = 0; i < 6; i++) {
if (i == 0) {
temp_array[0] = cubic_array[4];
temp_array[2] = cubic_array[6];
temp_array[4] = cubic_array[8];
temp_array[6] = cubic_array[10];
temp_array[8] = cubic_array[23];
temp_array[10] = cubic_array[21];
temp_array[23] = cubic_array[0];
temp_array[21] = cubic_array[2];
}
if (i == 1) {
temp_array[0] = cubic_array[23];
temp_array[2] = cubic_array[21];
temp_array[4] = cubic_array[0];
temp_array[6] = cubic_array[2];
temp_array[8] = cubic_array[4];
temp_array[10] = cubic_array[6];
temp_array[23] = cubic_array[8];
temp_array[21] = cubic_array[10];
}
if (i == 2) {
temp_array[12] = cubic_array[4];
temp_array[13] = cubic_array[5];
temp_array[4] = cubic_array[16];
temp_array[5] = cubic_array[17];
temp_array[16] = cubic_array[20];
temp_array[17] = cubic_array[21];
temp_array[20] = cubic_array[12];
temp_array[21] = cubic_array[13];
}
if (i == 3) {
temp_array[12] = cubic_array[20];
temp_array[13] = cubic_array[21];
temp_array[4] = cubic_array[12];
temp_array[5] = cubic_array[13];
temp_array[16] = cubic_array[4];
temp_array[17] = cubic_array[5];
temp_array[20] = cubic_array[16];
temp_array[21] = cubic_array[17];
}
if (i == 4) {
temp_array[2] = cubic_array[16];
temp_array[3] = cubic_array[18];
temp_array[16] = cubic_array[9];
temp_array[18] = cubic_array[8];
temp_array[9] = cubic_array[15];
temp_array[8] = cubic_array[13];
temp_array[15] = cubic_array[2];
temp_array[13] = cubic_array[3];
}
if (i == 5) {
temp_array[2] = cubic_array[15];
temp_array[3] = cubic_array[13];
temp_array[16] = cubic_array[2];
temp_array[18] = cubic_array[3];
temp_array[9] = cubic_array[16];
temp_array[8] = cubic_array[18];
temp_array[15] = cubic_array[9];
temp_array[13] = cubic_array[8];
}
if (temp_array[0] == temp_array[1] && temp_array[0] == temp_array[2] &&
temp_array[0] == temp_array[3] && temp_array[4] == temp_array[5] &&
temp_array[4] == temp_array[6] && temp_array[4] == temp_array[7] &&
temp_array[8] == temp_array[9] && temp_array[8] == temp_array[10] &&
temp_array[8] == temp_array[11] && temp_array[12] == temp_array[13] &&
temp_array[12] == temp_array[14] && temp_array[12] == temp_array[15] &&
temp_array[16] == temp_array[17] && temp_array[16] == temp_array[18] &&
temp_array[16] == temp_array[19] && temp_array[20] == temp_array[21] &&
temp_array[20] == temp_array[22] && temp_array[20] == temp_array[23]) {
cout << "yes";
return 0;
}
for (int j = 0; j < 24; j++) {
temp_array[j] = cubic_array[j];
}
}
cout << "no";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int p = 1e6;
const long double cnt = 1e-8;
struct Point {
long double x, y;
Point() {}
Point(long double a, long double b) {
x = a;
y = b;
}
bool operator<(const Point &r) const { return x == r.x ? y < r.y : x < r.x; }
Point operator-(const Point &r) const { return Point(x - r.x, y - r.y); }
long double operator*(const Point &r) const { return x * r.y - y * r.x; }
};
bool above(Point a, Point b, Point c) { return (b - a) * (c - a) <= cnt; }
set<Point> points;
int main() {
int q, i, lasti = 0, t, x, y;
long long m;
scanf("%i %lld", &q, &m);
points.insert(Point(0, 0));
for (i = 1; i <= q; i++) {
scanf("%i %i %i", &t, &x, &y);
x = (x + lasti) % p + 1;
y = (y + lasti) % p + 1;
if (t == 1) {
set<Point>::iterator it, last, next, pre;
it = points.lower_bound(Point(x, 0));
if (it != points.end() && it->y <= y) continue;
last = it;
last--;
if (it != points.end() && above(*last, Point(x, y), *it)) continue;
it = points.insert(Point(x, y)).first;
next = last = it;
pre = --last;
pre--;
next++;
while (next != points.end() && next->x == x) points.erase(next++);
while (last != points.begin() && above(*pre, *last, *it))
points.erase(last--), pre--;
} else {
set<Point>::iterator it, it2;
it = points.lower_bound(Point(1.0 * y / x, 0));
bool good = false;
if (it != points.end()) {
if (it->y * x <= m) {
good = true;
} else {
it2 = it;
it2--;
if (above(Point(it2->x * x, it2->y * x), Point(y, m),
Point(it->x * x, it->y * x))) {
good = true;
}
}
}
if (good)
printf("YES\n"), lasti = i;
else
printf("NO\n");
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void FastIO() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(15);
}
long long modpow(long long a, long long p, long long mod) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
p /= 2;
}
return ret % mod;
}
long long power(long long a, long long p) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * a);
a = (a * a);
p /= 2;
}
return ret;
}
vector<pair<pair<int, int>, int> > vec[1015];
int main() {
int n, x, y;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
int block = x / 1000;
if (block % 2)
vec[block].push_back(make_pair(make_pair(-y, x), i));
else
vec[block].push_back(make_pair(make_pair(y, x), i));
}
for (int i = 0; i < 1005; i++) {
sort(vec[i].begin(), vec[i].end());
for (int j = 0; j < (int)(vec[i].size()); j++)
printf("%d ", vec[i][j].second + 1);
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct point {
T x, y;
point() {}
point(const T &x, const T &y) : x(x), y(y) {}
point operator+(const point &b) const { return point(x + b.x, y + b.y); }
point operator-(const point &b) const { return point(x - b.x, y - b.y); }
T cross(const point &b) const { return x * b.y - y * b.x; }
};
template <typename T>
struct dynemic_lower_convex_hull {
map<T, T> hull;
typename map<T, T>::iterator l, r, l2, r2;
bool isIn(const point<T> &p) {
if (hull.empty()) return 0;
if (hull.count(p.x)) return p.y >= hull[p.x];
if (p.x < hull.begin()->first || (--hull.end())->first < p.x) return 0;
l = r = hull.lower_bound(p.x);
--l;
point<T> L(l->first, l->second), R(r->first, r->second);
return (R - L).cross(p - L) >= 0;
}
void insert(const point<T> &p) {
if (isIn(p)) return;
l = r = hull.upper_bound(p.x);
if (l != hull.begin())
if (--l != hull.begin()) {
l2 = l;
--l2;
while (l != hull.begin()) {
point<T> L(l->first, l->second), L2(l2->first, l2->second);
if ((L2 - p).cross(L - p) <= 0) {
hull.erase(l);
l = l2;
--l2;
} else
break;
}
}
if (r != hull.end()) {
r2 = r;
++r2;
while (r2 != hull.end()) {
point<T> R(r->first, r->second), R2(r2->first, r2->second);
if ((R - p).cross(R2 - p) <= 0) {
hull.erase(r);
r = r2;
++r2;
} else
break;
}
}
hull[p.x] = p.y;
}
};
int main() {
int n;
scanf("%d", &n);
dynemic_lower_convex_hull<long long> c1, c2;
for (int i = 1; i <= n; ++i) {
int x, y, type;
scanf("%d%d%d", &type, &x, &y);
if (type == 1) {
c1.insert(point<long long>(x, y));
c2.insert(point<long long>(x, -y));
} else {
bool ans1 = c1.isIn(point<long long>(x, y));
bool ans2 = c2.isIn(point<long long>(x, -y));
if (ans1 && ans2) {
puts("YES");
} else {
puts("NO");
}
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long mul(long long a, long long b, long long p = 1000000007) {
return ((a % p) * (b % p)) % p;
}
long long add(long long a, long long b, long long p = 1000000007) {
return (a % p + b % p) % p;
}
void input(long long a[], long long sz) {
for (long long i = 0; i < sz; i++) cin >> a[i];
}
void print(long long a[], long long sz) {
for (long long i = 0; i < sz; i++) {
if (i == sz - 1)
cout << a[i] << "\n";
else
cout << a[i] << " ";
}
}
long long maxr(long long a[], long long sz) {
long long ma;
for (long long i = 0; i < sz; i++) {
if (i == 0)
ma = a[i];
else if (a[i] > ma)
ma = a[i];
}
return ma;
}
long long minr(long long a[], long long sz) {
long long mi;
for (long long i = 0; i < sz; i++) {
if (i == 0)
mi = a[i];
else if (a[i] < mi)
mi = a[i];
}
return mi;
}
long long isprm(long long n) {
if (n <= 1) return 0;
if (n <= 3) return 1;
if (n % 2 == 0 || n % 3 == 0) return 0;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return 0;
return 1;
}
long long power(long long x, long long y, long long p = 1000000007) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long modInverse(long long n, long long p = 1000000007) {
return power(n, p - 2, p);
}
long long ncrMod(long long n, long long r, long long p = 1000000007) {
if (r == 0) return 1;
long long fac[n + 1];
fac[0] = 1;
for (long long i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
struct comp {
bool operator()(const pair<long long, long long> &a,
const pair<long long, long long> &b) const {
if (a.first == b.first) {
return (a.second > b.second);
}
return (a.first < b.first);
}
};
long long solve(vector<bitset<30>> b, long long i) {
if (i < 0) return 0;
vector<bitset<30>> x, y;
long long n = b.size(), ans = 0;
for (long long j = 0; j < n; j++) {
if (b[j][i] == 0)
x.push_back(b[j]);
else
y.push_back(b[j]);
}
if (x.size() == 0)
ans += solve(y, i - 1);
else if (y.size() == 0)
ans += solve(x, i - 1);
else
ans += (pow(2, i) + min(solve(y, i - 1), solve(x, i - 1)));
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n;
cin >> n;
long long a[n + 5];
input(a, n);
vector<bitset<30>> b(n);
for (long long i = 0; i < n; i++) b[i] = a[i];
long long ans = solve(b, 30);
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
while (cin >> n) {
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int senar = -1;
bool b = true;
for (int i = 0; i < n; i++) {
if (v[i] % 2 != 0) {
if (senar == -1)
senar = i;
else
b = false;
}
}
if (!b) {
cout << 0 << endl;
for (int i = 0; i < n; i++)
for (int j = 0; j < v[i]; j++) cout << char('a' + i);
cout << endl;
} else {
int res = v[0];
for (int i = 0; i < n; i++) res = gcd(res, v[i]);
cout << res << endl;
if (res <= 2) {
for (int i = 0; i < n; i++) {
if (v[i] % 2 == 0)
for (int j = 0; j < v[i] / 2; j++) cout << char('a' + i);
}
if (senar != -1)
for (int j = 0; j < v[senar]; j++) cout << char('a' + senar);
for (int i = n - 1; i >= 0; --i) {
if (v[i] % 2 == 0)
for (int j = 0; j < v[i] / 2; j++) cout << char('a' + i);
}
cout << endl;
} else if (res % 2 != 0) {
for (int c = 0; c < res; c++) {
int tonto = -1;
for (int i = 0; i < n; i++) {
if (v[i] % (2 * res) == 0)
for (int j = 0; j < v[i] / (2 * res); j++) cout << char('a' + i);
else
tonto = i;
}
if (tonto != -1)
for (int j = 0; j < v[tonto] / res; j++) cout << char('a' + tonto);
for (int i = n - 1; i >= 0; --i) {
if (v[i] % (2 * res) == 0)
for (int j = 0; j < v[i] / (2 * res); j++) cout << char('a' + i);
else
tonto = i;
}
}
} else {
res /= 2;
for (int c = 0; c < res; c++) {
int tonto = -1;
for (int i = 0; i < n; i++) {
if (v[i] % (2 * res) == 0)
for (int j = 0; j < v[i] / (2 * res); j++) cout << char('a' + i);
else
tonto = i;
}
if (tonto != -1)
for (int j = 0; j < v[tonto] / res; j++) cout << char('a' + tonto);
for (int i = n - 1; i >= 0; --i) {
if (v[i] % (2 * res) == 0)
for (int j = 0; j < v[i] / (2 * res); j++) cout << char('a' + i);
else
tonto = i;
}
}
cout << endl;
}
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double PI = 3.14159265359;
const long long MOD = 998244353;
void i_o() {}
long long n, m;
vector<long long> p, h;
vector<vector<long long>> adj;
bool ans = true;
pair<long long, long long> dfs(long long v, long long par = -1) {
long long here = 0, g_n = 0;
for (auto j : adj[v]) {
if (j == par) continue;
auto chld = dfs(j, v);
here += chld.first;
g_n += chld.second;
}
here += p[v];
if ((h[v] + 1000000000) % 2 != here % 2) ans = false;
if ((h[v] + here) > 2 * here) ans = false;
if ((h[v] + here) < 2 * g_n) ans = false;
return make_pair(here, (here + h[v]) / 2);
}
bool help() {
ans = true;
auto pi = dfs(0);
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
i_o();
int ntc;
cin >> ntc;
while (ntc--) {
cin >> n >> m;
p = vector<long long>(n);
for (int i = 0; i < n; i++) cin >> p[i];
h = vector<long long>(n);
for (int i = 0; i < n; i++) cin >> h[i];
adj = vector<vector<long long>>(n);
for (int i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
adj[x - 1].push_back(y - 1);
adj[y - 1].push_back(x - 1);
}
if (help())
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string p, s;
cin >> p >> s;
int i = 0, j = 0;
map<int, int> pat, str;
int minc = INT_MAX, c = 0;
vector<int> ans, temp;
for (int j = 0; j < m - n + 1; j++) {
int c = 0;
temp.clear();
for (int i = 0; i < n; i++) {
if (s[j + i] != p[i]) {
c++;
temp.push_back(i + 1);
}
}
if (c < minc) {
ans = temp;
minc = c;
}
}
cout << minc << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int maxn = 1e5 + 10;
int n, p, a[maxn], b[maxn];
int getp(double t) {
bool flag = false;
double v = 0;
for (int i = 0; i < n; i++) {
double k = a[i] * t - b[i];
if (k <= 0) continue;
v += k / t;
flag = true;
}
if (p >= v) return 1;
return 0;
}
int main() {
while (~scanf("%d%d", &n, &p)) {
long long sum = 0;
for (int i = 0; i < n; i++) scanf("%d%d", &a[i], &b[i]), sum += a[i];
double right = 1e15, left = 0.0, mid;
bool flag = false;
if (sum <= p)
flag = true;
else {
while (right - left >= eps) {
mid = (right + left) / 2;
int k = getp(mid);
if (k == 1)
left = mid;
else if (!k)
right = mid;
}
}
if (flag)
puts("-1");
else
cout << mid << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long fact[200001], invf[200001];
vector<long long> v[2];
const long long mod = 1e9 + 7LL;
long long bino(int x, int y) {
return fact[x] * (invf[x - y] * invf[y] % mod) % mod;
}
long long spow(int x, int p) {
if (p == 0) return 1LL;
long long ret = spow(x, p >> 1);
ret = ret * ret % mod;
if (p & 1)
return ret * x % mod;
else
return ret;
}
int main() {
long long n;
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
long long x;
scanf("%lld", &x);
v[0].push_back(x);
}
fact[0] = invf[0] = 1LL;
for (long long i = 1LL; i <= n; i++) {
fact[i] = fact[i - 1] * i % mod;
invf[i] = spow(fact[i], mod - 2);
}
int t = 0;
for (int plus = 1; n % 4 != 1; t ^= 1, n--) {
for (int i = 0; i < n - 1; i++) {
if (plus)
v[t ^ 1].push_back(v[t][i] + v[t][i + 1]);
else
v[t ^ 1].push_back(v[t][i] - v[t][i + 1] + mod);
v[t ^ 1][i] %= mod;
plus ^= 1;
}
v[t].clear();
}
long long ans = 0LL;
int N = n >> 1;
for (int i = 0; i < n; i += 2) {
ans += bino(N, i >> 1) * v[t][i];
ans %= mod;
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<ll, ll>;
ll const N = 1e5 + 20, LG = 20, mod = 1e9 + 7;
ll n, q;
ll sz[N];
ll in1[N], out1[N];
ll in2[N], out2[N];
vector<ll> g[N];
struct edge {
ll u, v, w;
} e[N];
ll par[LG][N], h[N], d[N];
void pre_dfs(ll v) {
for (ll i = 1; i < LG; i++)
if (~par[i - 1][v]) par[i][v] = par[i - 1][par[i - 1][v]];
for (ll ed : g[v]) {
ll u = e[ed].u ^ e[ed].v ^ v, w = e[ed].w;
if (u != par[0][v]) {
h[u] = h[v] + 1;
d[u] = (d[v] + w) % mod;
par[0][u] = v;
pre_dfs(u);
}
}
}
void dfs_down(ll v, ll par = -1) {
sz[v] = 1;
for (ll ed : g[v]) {
ll u = e[ed].u ^ e[ed].v ^ v, w = e[ed].w;
if (u == par) continue;
dfs_down(u, v);
sz[v] += sz[u];
in1[v] = (in1[v] + (in1[u] + 1ll * sz[u] * w % mod)) % mod;
in2[v] = (in2[v] + (in2[u] + 1ll * w * w % mod * sz[u] % mod +
2ll * w * in1[u] % mod)) %
mod;
}
}
void dfs_up(ll v, ll par = -1) {
for (ll ed : g[v]) {
ll u = e[ed].u ^ e[ed].v ^ v, w = e[ed].w;
if (u == par) continue;
out1[u] = ((in1[v] + out1[v] - (in1[u] + 1ll * sz[u] * w % mod)) +
1ll * (n - sz[u]) * w % mod) %
mod;
out2[u] =
(out2[v] + in2[v] -
(in2[u] + 1ll * w * w % mod * sz[u] % mod + 2ll * w * in1[u] % mod)) %
mod;
out2[u] =
(out2[u] + 1ll * w * w % mod * (n - sz[u]) % mod +
2ll * w * (in1[v] + out1[v] - (in1[u] + 1ll * sz[u] * w % mod))) %
mod;
dfs_up(u, v);
}
}
inline ll lca(ll u, ll v) {
if (h[u] > h[v]) swap(u, v);
for (ll i = 0; i < LG; i++)
if ((h[v] - h[u]) >> i & 1) v = par[i][v];
if (u == v) return u;
for (ll i = LG - 1; ~i; i--)
if (par[i][u] != par[i][v]) {
u = par[i][u];
v = par[i][v];
}
return par[0][u];
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (ll i = 0; i < n - 1; i++) {
ll &u = e[i].u, &v = e[i].v;
cin >> u >> v >> e[i].w;
u--, v--;
g[u].push_back(i);
g[v].push_back(i);
}
memset(par, -1, sizeof par);
pre_dfs(0);
dfs_down(0);
dfs_up(0);
cin >> q;
while (q--) {
ll u, v, ans = 0;
cin >> u >> v;
u--, v--;
ll l = lca(u, v);
ll len = (d[u] + d[v] - 2 * d[l]) % mod;
if (l == v) {
ans = (in2[u] + out2[u] -
(out2[v] + 1ll * len * len % mod * (n - sz[v]) % mod +
2ll * len * out1[v]) %
mod) %
mod;
ans = (+ans - (out2[v] + 1ll * len * len % mod * (n - sz[v]) % mod +
2ll * len * out1[v] % mod)) %
mod;
} else {
ans = (in2[u] + out2[u] -
(in2[v] + 1ll * len * len % mod * sz[v] % mod +
2ll * len * in1[v] % mod)) %
mod;
ans = (-ans + (in2[v] + 1ll * len * len % mod * sz[v] % mod +
2ll * len * in1[v] % mod)) %
mod;
}
cout << (ans + mod) % mod << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e6;
const int Inf = 1 << 30;
int dp[MaxN + 5], res[15];
int main() {
int n, x, cnt, nxt, tmp;
scanf("%d", &n);
for (int i = 1; i <= n; i++) dp[i] = Inf;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
x = i;
cnt = 0;
while (x) {
nxt = x / 10;
tmp = x - nxt * 10;
if (tmp != 0) res[++cnt] = tmp;
x = nxt;
}
for (int j = 1; j <= cnt; j++) dp[i] = min(dp[i], dp[i - res[j]] + 1);
}
printf("%d\n", dp[n]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
string ss;
while (cin >> ss) {
int flag = 'a';
for (int i = 0; i < ss.length(); ++i) {
if (ss[i] <= flag) {
ss[i] = (char)flag;
flag++;
if (flag > 'z') break;
}
}
if (flag <= 'z')
printf("-1\n");
else
cout << ss;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main()
{long long i,j,k,l,m,n,x,t;
cin>>t;string s;
while(t>0)
{t=t-1;cin>>n>>k>>s;
for(i=0;i<k;i++)
{if(s[i]!=s[n-i-1])break;}
if(i==k&&n>2*k)cout<<"YES"<<"\n";
else cout<<"NO"<<"\n";}
return 0;} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
int main() {
int n, m;
cin >> n >> m;
set<int> exist;
int x;
for (int i = 1; i <= n; ++i) {
cin >> x;
exist.insert(x);
}
int sum = 0;
vector<int> res;
for (int i = 1; sum + i <= m; ++i) {
if (exist.find(i) != exist.end()) continue;
sum += i;
res.push_back(i);
}
cout << int(res.size()) << '\n';
for (int to : res) cout << to << ' ';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename Templ1isPerfectSquare>
bool isPerfectSquare(Templ1isPerfectSquare n) {
Templ1isPerfectSquare sq = sqrt(n);
return ((sq * sq) == n);
}
long long powerll_modulo(long long a, long long n, long long mod) {
long long res = 1;
a = a % mod;
while (n) {
if (n % 2 == 1) {
n--;
res *= a;
res = res % mod;
}
if (n > 0) {
n /= 2;
a = a * a;
a %= mod;
}
}
return res;
}
long long powerll(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2 == 1) {
n--;
res *= a;
}
if (n > 0) {
n /= 2;
a = a * a;
}
}
return res;
}
string stringMultiplication(string a, string b) {
vector<long long> v(a.size() + b.size() + 100, 0);
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
for (long long i = 0; i < a.size(); i++) {
for (long long j = 0; j < b.size(); j++) {
v[i + j] += ((a[i] - '0') * (b[j] - '0'));
}
}
for (long long i = 0; i < v.size() - 1; i++) {
v[i + 1] += v[i] / 10;
v[i] = v[i] % 10;
}
int j = v.size() - 1;
while (j >= 0 && v[j] == 0) {
j--;
}
string res = "";
for (; j >= 0; j--) {
res += (char)(v[j] + '0');
}
return res;
}
long long Ncr(long long n, long long m) {
map<long long, long long> mp1;
unordered_map<long long, long long> mp2;
vector<long long> v1;
vector<long long> v2;
for (long long i = 1; i < n + 1; i++) {
long long k = i;
for (long long j = 2; j < sqrt(k) + 1; j++) {
if (k % j == 0) {
long long ct = 0;
while (k % j == 0) {
ct++;
k /= j;
}
if (!mp1[j]) {
v1.push_back(j);
}
mp1[j] += ct;
}
}
if (k > 1) {
if (mp1[k] == 0) {
v1.push_back(k);
}
mp1[k]++;
}
}
for (long long i = 1; i < m + 1; i++) {
long long k = i;
for (long long j = 2; j < sqrt(k) + 1; j++) {
if (k % j == 0) {
long long ct = 0;
while (k % j == 0) {
ct++;
k /= j;
}
if (!mp2[j]) {
v2.push_back(j);
}
mp2[j] += ct;
}
}
if (k > 1) {
if (mp2[k] == 0) {
v2.push_back(k);
}
mp2[k]++;
}
}
for (long long i = 1; i < n - m + 1; i++) {
long long k = i;
for (long long j = 2; j < sqrt(k) + 1; j++) {
if (k % j == 0) {
long long ct = 0;
while (k % j == 0) {
ct++;
k /= j;
}
if (!mp2[j]) {
v2.push_back(j);
}
mp2[j] += ct;
}
}
if (mp2[k] == 0) {
v2.push_back(k);
}
mp2[k]++;
}
long long num = 1, den = 1;
for (long long i = 0; i < v1.size(); i++) {
if (mp2[v1[i]] > mp1[v1[i]]) {
mp2[v1[i]] -= mp1[v1[i]];
mp1[v1[i]] = 0;
} else {
mp1[v1[i]] -= mp2[v1[i]];
mp2[v1[i]] = 0;
}
num *= powerll(v1[i], mp1[v1[i]]);
}
for (long long i = 0; i < v2.size(); i++) {
if (mp2[v2[i]] > mp1[v2[i]]) {
mp2[v2[i]] -= mp1[v2[i]];
mp1[v2[i]] = 0;
} else {
mp1[v2[i]] -= mp2[v2[i]];
mp2[v2[i]] = 0;
}
den *= powerll(v2[i], mp2[v2[i]]);
}
return num / den;
}
void solve() {
int n, k;
cin >> n >> k;
vector<vector<long long> > v(n, vector<long long>(2));
long long sum = 0;
priority_queue<long long> pq;
for (long long i = 0; i < n; i++) {
cin >> v[i][0] >> v[i][1];
sum += min(v[i][1], v[i][0]);
pq.push(min(v[i][1], 2 * v[i][0]) - min(v[i][1], v[i][0]));
}
while (k--) {
sum += pq.top();
pq.pop();
}
cout << sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long test;
test = 1;
while (test--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (y > x) x = y;
}
const long long inf = (long long)1e18 + 17;
const long long iinf = 1500000000;
const long long dx[] = {1, 0, -1, 0};
const long long dy[] = {0, 1, 0, -1};
const long long mod = 1e9 + 7;
bool test_case = 1;
void solve() {
string a, b;
cin >> a >> b;
long long next[a.size() + 10][26], n1 = a.size();
for (long long i = 0; i < 26; i++) next[n1][i] = inf;
for (long long i = n1 - 1; i >= 0; i--) {
for (long long j = 0; j < 26; j++) next[i][j] = next[i + 1][j];
next[i][a[i] - 'a'] = i;
}
long long n = b.size();
long long dp[n + 10][n + 10];
dp[0][0] = 0;
for (long long ii = 0; ii < b.size(); ii++) {
long long l1 = ii + 1, l2 = b.size() - l1;
for (long long i = 0; i <= l1; i++) {
for (long long j = 0; j <= l2; j++) {
if (i == 0 && j == 0) continue;
dp[i][j] = inf;
if (j != 0) {
long long op1 = dp[i][j - 1];
if (op1 != inf && ii + j < b.size()) {
long long nex = b[ii + j] - 'a';
long long pos = next[op1][nex];
amin(dp[i][j], pos + 1);
}
}
if (i != 0) {
long long op1 = dp[i - 1][j];
if (op1 != inf) {
long long nex = b[i - 1] - 'a';
long long pos = next[op1][nex];
amin(dp[i][j], pos + 1);
}
}
}
}
if (dp[l1][l2] != inf) {
cout << "YES\n";
return;
}
}
cout << "NO\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
if (test_case == true) cin >> t;
for (long long i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 13, p = 1000003;
int n;
long long a[Maxn][Maxn], x[Maxn];
long long fast_pow(long long x, long long y) {
long long ans = 1, now = x;
while (y) {
if (y & 1) ans = (ans * now) % p;
now = (now * now) % p;
y >>= 1;
}
return ans;
}
void gauss(void) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (i != j) {
long long tmp = a[i][i] * fast_pow(a[j][i], p - 2) % p;
for (int k = 1; k <= n + 1; k++)
a[j][k] = a[i][k] - a[j][k] * tmp % p,
a[j][k] = ((a[j][k] % p) + p) % p;
}
}
for (int i = 1; i <= n; i++)
a[i][n + 1] *= fast_pow(a[i][i], p - 2), a[i][n + 1] %= p;
}
int main() {
n = 11;
for (int i = 1; i <= 11; i++) {
printf("? %d ", i);
fflush(stdout);
scanf("%lld", &a[i][12]);
a[i][1] = 1;
for (int j = 2; j <= 11; j++) a[i][j] = a[i][j - 1] * i % p;
}
gauss();
for (int i = 0; i <= 1000002; i++) {
long long ans = 0, now = 1;
for (int j = 1; j <= 11; j++)
ans += now * a[j][12] % p, ans %= p, now = (now * i) % p;
if (!ans) {
printf("! %d ", i);
fflush(stdout);
return 0;
}
}
printf("! -1 ");
fflush(stdout);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int iinf = 1234567890;
struct line {
pair<int, int> a, b;
line(int x1, int y1, int x2, int y2) {
a.first = x1;
a.second = y1;
b.first = x2;
b.second = y2;
}
line() {}
};
int main() {
line ver[5];
line gor[5];
int v = 0, g = 0;
bool f = 0;
for (int i = 0; i < 4; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
if (y1 > y2) swap(y1, y2);
gor[v] = line(x1, y1, x2, y2);
v++;
if (y1 == y2) f = 1;
} else if (y1 == y2) {
if (x1 > x2) swap(x1, x2);
ver[g] = line(x1, y1, x2, y2);
g++;
if (x1 == x2) f = 1;
} else {
cout << "NO";
return 0;
}
}
if (v != 2 || g != 2 || f) {
cout << "NO";
return 0;
}
if (ver[0].a.second > ver[1].a.second) swap(ver[0], ver[1]);
if (gor[0].a.first > gor[1].a.first) swap(gor[0], gor[1]);
if (gor[0].a == ver[0].a && gor[0].b == ver[1].a && ver[0].b == gor[1].a &&
gor[1].b == ver[1].b) {
cout << "YES";
} else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
template <typename T>
using v = vector<T>;
template <typename... T>
using tup = tuple<T...>;
const ld PI = 3.1415926535;
v<ll> p;
v<bool> was;
v<ll> cnt;
ll dfs(ll x) {
if (was[x]) {
return 0;
} else {
was[x] = true;
return 1 + dfs(p[x]);
}
}
void setThings(ll x, ll a) {
if (cnt[x] == -1) {
cnt[x] = a;
setThings(p[x], a);
}
}
void solve() {
ll n;
cin >> n;
p = v<ll>(n);
for (ll i = 0; i < n; ++i) {
cin >> p[i];
--(p[i]);
}
was = v<bool>(n, false);
cnt = v<ll>(n, -1);
v<ll> x(n, 0);
for (ll i = 0; i < n; ++i) {
ll x = dfs(i);
setThings(i, x);
}
for (ll i = 0; i < n; ++i) {
cout << cnt[i] << ' ';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
ll t = 1;
cin >> t;
for (ll i = 0; i < t; ++i) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
short n;
cin >> n;
short y[n];
for (short i = 0; i < n; ++i) {
cin >> y[i];
}
sort(y, y + n);
cout << y[n / 2];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, S;
int sub = -1, must;
int Coins[70010];
bool root[70010];
int Less[70010];
bitset<70005> dp1[7010], dp2[10 + 5];
bool Ispossible(int items, int remaining) {
if (sub != items / 10 * 10) {
sub = items / 10 * 10;
dp2[0] = dp1[sub / 10];
for (int i = 0; i < 10 - 1; i++) {
int offset = sub + i;
if (offset == must)
dp2[i + 1] = (dp2[i] << Coins[offset]);
else
dp2[i + 1] = (dp2[i] | (dp2[i] << Coins[offset]));
}
}
return dp2[items - sub][remaining];
}
int main() {
ios_base::sync_with_stdio(false);
cin >> N >> S;
for (int i = 0; i < N; i++) cin >> Coins[i];
for (int i = 0; i < N; i++) {
if (Coins[i] > Coins[must]) must = i;
}
bitset<70005> bits;
bits[0] = true;
for (int i = 0; i <= N; i++) {
if (i % 10 == 0) dp1[i / 10] = bits;
if (i == N) break;
if (i == must)
bits = bits << Coins[i];
else
bits |= (bits << Coins[i]);
}
if (!Ispossible(N, S)) {
cout << -1 << endl;
return 0;
}
root[must] = true;
for (int i = N - 1; i >= 0; i--) {
if (S >= Coins[i]) {
if (Ispossible(i, S - Coins[i])) {
S -= Coins[i];
root[i] = true;
}
}
}
std::vector<pair<int, int> > Children;
memset(Less, -1, sizeof(Less));
for (int i = 0; i < N; i++) {
if (root[i]) continue;
Children.push_back(make_pair(Coins[i], i));
}
sort(Children.begin(), Children.end());
for (int i = 1; i < Children.size(); i++) {
Less[Children[i].second] = Children[i - 1].second;
}
if (Children.size() >= 1) Less[must] = Children[Children.size() - 1].second;
for (int i = 0; i < N; i++) {
if (Less[i] == -1) {
cout << Coins[i] << " " << 0 << endl;
} else
cout << Coins[i] - Coins[Less[i]] << " " << 1 << " " << Less[i] + 1
<< endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int c = 0;
for (int i = 1; i < n; i++) c += ((k - arr[i]) / arr[0]);
cout << c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int b[10000], a[11], ans;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
memset(b, 0, sizeof(b));
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[a[i]]++;
}
ans = 0;
for (int i = 0; i < n; i++) {
if (b[a[i]] > 1) {
bool flag = 0;
for (int j = 0; j <= 9; j++) {
int temp =
(a[i] / (int)pow(10, 1)) * pow(10, 1) + a[i] % (int)pow(10, 0);
temp += j * pow(10, 0);
if (b[temp] == 0) {
b[temp] = 1;
b[a[i]]--;
a[i] = temp;
flag = 1;
ans++;
break;
}
}
if (flag) continue;
}
}
printf("%d\n", ans);
for (int i = 0; i < n; i++) {
if (a[i] < 1000) printf("0");
if (a[i] < 100) printf("0");
if (a[i] < 10) printf("0");
printf("%d\n", a[i]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
long long w[100005], dis[100005], f[100005];
vector<pair<long long, long long>> G[100005];
vector<long long> Q[100005];
bool vis[100005];
long long n, m, t;
void init() {
priority_queue<pair<long long, long long>> pq;
memset(dis, 0x3f, sizeof(dis));
pq.emplace(0, 1);
dis[1] = 0;
while (pq.size()) {
auto x = pq.top();
pq.pop();
x.first = -x.first;
if (dis[x.second] != x.first) continue;
for (auto e : G[x.second]) {
if (dis[e.first] > dis[x.second] + w[e.second]) {
dis[e.first] = dis[x.second] + w[e.second];
pq.emplace(-dis[e.first], e.first);
}
}
}
}
void cal() {
memset(f, 0x3f, sizeof(f));
memset(vis, 0, sizeof(vis));
f[1] = 0;
Q[0].push_back(1);
for (long long d = 0; d <= n; Q[d++].clear()) {
for (long long x = 0; x < Q[d].size(); x++) {
long long u = Q[d][x];
if (vis[u]) continue;
vis[u] = true;
for (auto e : G[u]) {
long long ds = dis[u] + w[e.second] - dis[e.first];
if (d + ds < f[e.first]) {
f[e.first] = d + ds;
if (f[e.first] <= n) Q[f[e.first]].push_back(e.first);
}
}
}
}
for (long long i = 1; i <= n; i++) {
if (dis[i] >= INF) continue;
dis[i] += f[i];
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> t;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v >> w[i];
G[u].emplace_back(v, i);
}
init();
long long op, x;
while (t--) {
cin >> op >> x;
if (op == 1) {
if (dis[x] < INF)
cout << dis[x] << '\n';
else
cout << "-1\n";
} else {
for (long long i = 0, id; i < x; i++) {
cin >> id;
w[--id]++;
}
cal();
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int S, a, b, c;
int main() {
while (scanf("%d", &S) != EOF) {
scanf("%d%d%d", &a, &b, &c);
int sum = a + b + c;
if (sum == 0)
printf("%d 0.0 0.0\n", S);
else
printf("%.10f %.10f %.10f\n", (S * a * 1.0) / sum, (S * b * 1.0) / sum,
(S * c * 1.0) / sum);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main(void) {
int n;
scanf("%d", &n);
n--;
long m = n * (n + 1) / 2;
m *= 12;
m++;
printf("%I32d", m);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long N = 10005;
long n, m, dd[N], match[N], ti, kq, l, r, mid;
vector<long> ke[N], cp[N], c;
bool dfs(long u) {
for (long i = 0; i < ke[u].size(); i++)
if (cp[u][i] <= mid) {
long v = ke[u][i];
if (dd[v] == ti) continue;
dd[v] = ti;
if (match[v] == 0) {
match[v] = u;
return 1;
}
if (dfs(match[v])) {
match[v] = u;
return 1;
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long i = 1; i <= m; i++) {
long u, v, w;
cin >> u >> v >> w;
ke[u].push_back(v);
cp[u].push_back(w);
}
l = 1;
r = 1000000001;
while (l < r) {
mid = (l + r) >> 1;
c.clear();
for (long i = 1; i <= n; i++) {
dd[i] = match[i] = 0;
c.push_back(i);
}
ti = 0;
kq = 0;
while (1) {
ti++;
long cu = c.size();
for (long i = c.size() - 1; i >= 0; i--)
if (dfs(c[i])) {
kq++;
c[i] = c.back();
c.pop_back();
}
if (cu == c.size()) break;
}
if (kq == n)
r = mid;
else
l = mid + 1;
}
if (l == 1000000001)
cout << -1;
else
cout << l;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, s1, s2, s3, s4;
cin >> a >> b >> c;
s1 = a + c + b;
s2 = a + a + b + b;
s3 = a + c + c + a;
s4 = b + c + c + b;
cout << min(s1, (min(s2, min(s3, s4))));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int i = 0, k = 0, a[100009];
while (n != 0) {
int r = n % 10;
if (r == 0) {
i++;
} else {
a[k] = r * pow(10, i);
i++;
k++;
}
n = n / 10;
}
cout << k << endl;
for (int i = 0; i < k; i++) {
cout << a[i] << " ";
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100010];
int res[100010], flag[100010], fa[100010];
int a[100010], n, m;
int gcd(int x, int y) {
if (x < y) swap(x, y);
return y == 0 ? x : gcd(y, x % y);
}
void dfs1(int v, int p) {
fa[v] = p;
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
if (u == p) continue;
dfs1(u, v);
}
}
void dfs2(int v, int p) {
flag[v] = 0;
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
if (u == p) continue;
dfs2(u, v);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs1(1, -1);
while (m--) {
int op, v, w;
scanf("%d%d", &op, &v);
if (op == 1) {
if (flag[v]) {
printf("%d\n", res[v]);
continue;
}
int ans = -1;
int u = fa[v];
while (u != -1) {
if (gcd(a[u], a[v]) > 1) {
ans = u;
break;
}
u = fa[u];
}
printf("%d\n", ans);
res[v] = ans;
flag[v] = 1;
} else {
scanf("%d", &w);
a[v] = w;
dfs2(v, fa[v]);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000;
int N, K;
int a[MAXN];
int psa[MAXN + 1];
int main() {
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> a[i];
}
psa[0] = 0;
for (int i = 1; i <= N; i++) {
psa[i] = psa[i - 1] + a[i - 1];
}
double ans = 0;
for (int i = 1; i + K - 1 <= N; i++) {
for (int j = i + K - 1; j <= N; j++) {
ans = max(ans, (double)(psa[j] - psa[i - 1]) / (j - i + 1));
}
}
cout.precision(10);
cout << fixed;
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool is_palindrome(string temp) {
int n = temp.length(), i = 0, j = n - 1;
while (i < j) {
if (temp[i] != temp[j]) return false;
i++;
j--;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int n = s.length(), i, flag = 0;
if (s.length() == 1 || s.length() == 3)
cout << "Impossible" << '\n';
else {
for (i = 1; i < n / 2; i++) {
if (s[i] != s[i - 1]) {
flag = 1;
break;
}
}
if (flag == 0)
cout << "Impossible" << '\n';
else {
flag = 0;
string temp, tt = "";
for (i = 0; i < n - 1; i++) {
temp = s.substr(i + 1, n - i - 1);
tt = tt + s[i];
if (is_palindrome(temp + tt) && (temp + tt) != s) {
cout << 1 << '\n';
flag = 1;
break;
}
}
if (flag == 0) cout << 2 << '\n';
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
cout << s;
reverse(s.begin(), s.end());
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long z = 1000000007;
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res = (res * a) % z;
b--;
} else {
a = (a * a) % z;
b = b >> 1;
}
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) {
long long n, p = 0;
cin >> n;
long long ar[n];
for (long long i = 0; i < n; i++) cin >> ar[i];
set<long long> s;
map<long long, long long> m;
s.insert(ar[0]);
m[ar[0]] = 0;
for (long long i = 1; i < n; i++) {
set<long long>::iterator it = s.lower_bound(ar[i]);
if (it == s.begin()) {
s.insert(ar[i]);
p++;
m[ar[i]] = p;
} else if (it == s.end()) {
s.erase(*s.rbegin());
s.insert(ar[i]);
m[ar[i]] = 0;
} else {
it--;
m[ar[i]] = m[*it];
s.erase(*it);
s.insert(ar[i]);
}
}
vector<long long> v[200001];
for (long long i = 0; i < n; i++) {
v[m[ar[i]]].push_back(ar[i]);
}
for (long long i = 0; i < 200000; i++) {
if (v[i].size()) {
for (long long j = 0; j < v[i].size(); j++) cout << v[i][j] << " ";
cout << "\n";
} else
break;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const double eps = 1e-6;
const int inf = 0x3f3f3f3f;
const long long INF = 100000000000000000ll;
const int MAXN = 4004;
const int MAXM = 300030;
int dp[MAXN][MAXN];
int main() {
int n;
cin >> n;
dp[0][0] = 1;
for (int i = 1; i <= n + 1; i++) {
dp[i][0] = dp[i - 1][i - 1];
for (int j = 1; j <= i; j++) {
dp[i][j] = (dp[i][j - 1] + dp[i - 1][j - 1]) % mod;
}
}
printf("%d\n", (dp[n + 1][0] - dp[n][0] + mod) % mod);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
int k, n, Min = 0x7f7f7f7f;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
Min = min(Min, a[i]);
}
long long ans = 0;
for (int i = 0; i < n; i++) {
if ((a[i] - Min) % k != 0) {
printf("-1\n");
return 0;
}
ans += (a[i] - Min) / k;
}
printf("%lld\n", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long abs1(long long h) {
if (h < 0)
return -h;
else
return h;
}
int main() {
long long i, j, n, m, e, k, ot, x, y, i1, i2, i3, i4;
vector<int> a, q, g;
vector<vector<int> > w;
vector<int> d;
cin >> n;
for (i = 0; i <= n + 4; i++) {
q.push_back(0);
w.push_back(d);
}
q[1] = 1;
q[n + 1] = 1;
for (i = 0; i < 2 * n; i++) {
cin >> x >> y;
w[x].push_back(y);
w[y].push_back(x);
}
for (i = 1; i <= n; i++) {
if (w[i].size() != 4) {
cout << -1;
return 0;
}
}
for (i1 = 1; i1 <= 4; i1++) {
for (i2 = 1; i2 <= 4; i2++) {
for (i3 = 1; i3 <= 4; i3++) {
for (i4 = 1; i4 <= 4; i4++) {
if (i1 != i2 && i1 != i3 && i1 != i4 && i2 != i3 && i2 != i4 &&
i3 != i4) {
g.clear();
for (i = 0; i < n + 2; i++) g.push_back(0);
q[2] = w[1][i1 - 1];
q[3] = w[1][i2 - 1];
q[n] = w[1][i3 - 1];
q[n - 1] = w[1][i4 - 1];
q[0] = q[n];
q[n + 2] = q[2];
int z = 0;
for (i = 2; i <= n - 2; i++) {
e = 0;
k = 0;
for (j = 0; j < 4; j++) {
if (w[q[i]][j] != q[i + 1] && w[q[i]][j] != q[i - 1] &&
w[q[i]][j] != q[i - 2]) {
e++;
k = w[q[i]][j];
}
}
if (e != 1) {
z = 1;
break;
} else
q[i + 2] = k;
}
q[0] = q[n];
q[n + 2] = q[2];
if (z == 0) {
z = 0;
for (i = 2; i <= n; i++) {
e = 0;
for (j = 0; j < 4; j++) {
if (w[q[i]][j] != q[i + 1] && w[q[i]][j] != q[i - 1] &&
w[q[i]][j] != q[i - 2] && w[q[i]][j] != q[i + 2])
e++;
}
if (e != 0) {
z = 1;
break;
}
}
for (i = 1; i <= n; i++) {
g[q[i]]++;
if (g[q[i]] == 2) {
z = 1;
break;
}
}
if (z == 0) {
for (i = 1; i <= n; i++) cout << q[i] << " ";
return 0;
}
}
}
}
}
}
}
cout << -1;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int m;
const long long mod = 1e9 + 7;
struct Mat {
long long mat[111][111];
} st, ed;
long long stt[111][111];
void init() {
memset(stt, 0, sizeof(stt));
stt[0][0] = stt[0][m - 1] = 1;
for (int i = 1; i < m; ++i) stt[i][i - 1] = 1;
for (int i = 0; i < m; ++i)
for (int j = 0; j < m; ++j) st.mat[i][j] = stt[i][j];
}
Mat mul(Mat a, Mat b) {
Mat ret;
for (int i = 0; i < m; ++i)
for (int j = 0; j < m; ++j) {
ret.mat[i][j] = 0;
for (int k = 0; k < m; ++k)
(ret.mat[i][j] += a.mat[i][k] * b.mat[k][j] % mod) %= mod;
}
return ret;
}
Mat pow(Mat a, long long b) {
Mat ret;
memset(ret.mat, 0, sizeof(ret.mat));
for (int i = 0; i < m; ++i) ret.mat[i][i] = 1;
while (b) {
if (b & 1) ret = mul(ret, a);
a = mul(a, a);
b >>= 1;
}
return ret;
}
int main() {
cin >> n >> m;
if (n < m) return 0 * puts("1");
init();
ed = pow(st, n - m + 1);
long long ans = 0;
for (int i = 0; i < m; ++i) (ans += ed.mat[0][i]) %= mod;
cout << ans << ('\n');
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 654321987654321LL;
const int max_n = 100000;
const int max_m = 100000;
struct person {
int t, s, f, i;
long long int out_time;
person() {}
person(int t, int s, int f, int i) : t(t), s(s), f(f), i(i) {}
bool operator<(const person &p) const { return t < p.t; }
};
bool comp_by_i(const person &a, const person &b) { return a.i < b.i; }
int n, m;
person p[max_n];
void get_input() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
int t, s, f;
scanf("%d %d %d", &t, &s, &f);
p[i] = person(t, s, f, i);
}
sort(p, p + n);
}
int curr_person;
int curr_floor;
long long int curr_time;
int upper, lower;
int dir;
multiset<int> demand;
vector<int> departure[max_m + 1], arrival[max_m + 1];
void process() {
curr_person = 0;
curr_floor = 1;
curr_time = 0LL;
upper = lower = 0;
dir = 0;
demand.clear();
for (int i = 1; i <= m; i++) departure[i].clear(), arrival[i].clear();
while (true) {
for (; curr_person < n && p[curr_person].t == curr_time; curr_person++) {
person pp = p[curr_person];
if (pp.s > curr_floor)
upper++;
else if (pp.s < curr_floor)
lower++;
demand.insert(pp.s);
departure[pp.s].push_back(curr_person);
}
for (int j = 0; j < departure[curr_floor].size(); j++) {
int p_idx = departure[curr_floor][j];
if (p[p_idx].f > curr_floor)
upper++;
else if (p[p_idx].f < curr_floor)
lower++;
demand.erase(demand.find(p[p_idx].s));
demand.insert(p[p_idx].f);
arrival[p[p_idx].f].push_back(p_idx);
}
departure[curr_floor].clear();
for (int j = 0; j < arrival[curr_floor].size(); j++) {
int p_idx = arrival[curr_floor][j];
demand.erase(demand.find(p[p_idx].f));
p[p_idx].out_time = curr_time;
}
arrival[curr_floor].clear();
long long int income_time = (curr_person < n) ? p[curr_person].t : inf;
long long int move_time = inf;
dir = 0;
if (upper >= lower && upper > 0)
move_time = (*demand.upper_bound(curr_floor)) - curr_floor + curr_time,
dir = 1;
else if (upper < lower)
move_time =
curr_floor - (*(--demand.lower_bound(curr_floor))) + curr_time,
dir = -1;
long long int next_time = min(income_time, move_time);
int next_floor = curr_floor + dir * (next_time - curr_time);
if (next_time == inf) break;
curr_time = next_time;
curr_floor = next_floor;
if (dir == -1)
lower -= demand.count(curr_floor);
else if (dir == 1)
upper -= demand.count(curr_floor);
}
}
void print_output() {
sort(p, p + n, comp_by_i);
for (int i = 0; i < n; i++) printf("%I64d\n", p[i].out_time);
}
int main() {
get_input();
process();
print_output();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxi = 1079;
vector<vector<int> > f(maxi, vector<int>(maxi, 0));
void connect(int x1, int y1, int x2, int y2, vector<pair<int, int> > &myans) {
if (!f[x1][y1]) {
f[x1][y1] = 1;
myans.push_back({x1, y1});
}
for (; x1 < x2;) {
x1++;
if (!f[x1][y1]) {
f[x1][y1] = 1;
myans.push_back({x1, y1});
}
}
for (; x1 > x2;) {
x1--;
if (!f[x1][y1]) {
f[x1][y1] = 1;
myans.push_back({x1, y1});
}
}
for (; y1 < y2;) {
y1++;
if (!f[x1][y1]) {
f[x1][y1] = 1;
myans.push_back({x1, y1});
}
}
for (; y1 > y2;) {
y1--;
if (!f[x1][y1]) {
f[x1][y1] = 1;
myans.push_back({x1, y1});
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int x[3], y[3];
for (int i = 0; i < 3; i++) cin >> x[i] >> y[i];
vector<pair<int, int> > bestans(1, {-1, -1});
vector<int> p;
for (int i = 0; i < 3; i++) p.push_back(i);
do {
vector<pair<int, int> > myans;
connect(x[p[0]], y[p[0]], x[p[1]], y[p[1]], myans);
pair<int, int> cl = myans[0];
for (pair<int, int> i : myans)
if (abs(i.first - x[p[2]]) + abs(i.second - y[p[2]]) <
abs(cl.first - x[p[2]]) + abs(cl.second - y[p[2]]))
cl = i;
connect(cl.first, cl.second, x[p[2]], y[p[2]], myans);
if (bestans.back().first == -1 || bestans.size() > myans.size())
bestans = myans;
for (pair<int, int> i : myans) f[i.first][i.second] = 0;
} while (next_permutation(p.begin(), p.end()));
cout << bestans.size() << "\n";
for (int i = 0; i < bestans.size(); i++)
cout << bestans[i].first << " " << bestans[i].second << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, vet[100001], big, res;
vector<int> primes;
bool comp[100001];
void sieve() {
int lim = sqrt(100001) + 1;
for (int i = 2; i <= lim; ++i) {
if (comp[i]) continue;
for (long long j = i * i; j < 100001; j += i) comp[j] = 1;
}
for (int i = 2; i < 100001; ++i)
if (!comp[i]) primes.push_back(i);
}
int pow(int num, int pot) {
long long res = 1, aux = num;
while (pot) {
if (pot & 1) res = (res * aux) % 1000000007;
pot /= 2;
aux = (aux * aux) % 1000000007;
}
return res;
}
void findit(int num, vector<int>& res) {
for (int i = 1, l = sqrt(num) + 1; i <= l && i < num; ++i) {
if (num % i == 0) res.push_back(i), res.push_back(num / i);
}
res.push_back(num);
sort(res.begin(), res.end());
vector<int> aux(res.size());
vector<int>::iterator it = unique(res.begin(), res.end());
int p = it - res.begin();
res.resize(p);
reverse(res.begin(), res.end());
}
int calc(int num) {
vector<int> divs;
findit(num, divs);
int p = 0, f = 1, m = divs.size(), l = n;
long long z = 1;
while (p < m) {
int now = divs[p];
int go = lower_bound(vet, vet + n, now) - vet;
if (f && go == n) break;
if (f) {
long long aux = (pow(m - p, l - go) - pow(m - p - 1, l - go));
aux = (aux + 1000000007) % 1000000007;
z = (z * aux) % 1000000007;
} else
z = (z * pow(m - p, l - go)) % 1000000007;
f = 0;
l = go;
++p;
}
return z;
}
int main() {
sieve();
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &vet[i]), big = max(big, vet[i]);
sort(vet, vet + n);
for (int i = 1; i <= big; ++i) res = (res + calc(i)) % 1000000007;
printf("%d\n", res);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void dbs(string str, T t) {
cerr << str << " : " << t << "\n";
}
template <class T, class... S>
void dbs(string str, T t, S... s) {
long long idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ", ";
dbs(str.substr(idx + 1), s...);
}
template <class T>
void prc(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
template <class T>
void prall(T a) {
prc(a.begin(), a.end());
}
const int inf = 1000 * 1000 * 1000 + 9;
const long long infl = 1ll * inf * inf;
int MOD = 1000 * 1000 * 1000 + 7;
mt19937_64 mt(chrono::steady_clock::now().time_since_epoch().count());
long long randrange(long long l, long long r) { return l + mt() % (r - l + 1); }
void solve() {
int n;
cin >> n;
vector<int> a(n);
vector<int> b(n);
for (int i = 0; i < n; i++) cin >> a[i], a.push_back(a[i]);
for (int i = 0; i < n; i++) cin >> b[i], b.push_back(b[i]);
vector<int> done(n + n);
for (int i = 0; i < n; i++) {
if (done[i]) continue;
done[i] = 1;
int buf = 0;
bool ok = 1;
for (int j = 1; j < n; j++) {
if (a[i + j] > buf + b[i + j]) {
ok = 0;
break;
} else {
done[i + j] = 1;
if (a[i + j] <= buf)
buf = b[i + j];
else
buf = b[i + j] + buf - a[i + j];
}
}
if (ok && buf + b[i] >= a[i]) {
cout << "YES" << '\n';
return;
}
}
cout << "NO" << '\n';
}
int main() {
clock_t beg = clock();
ios_base::sync_with_stdio(0);
cin.tie(0);
int testcases = 1;
cin >> testcases;
cout << fixed << setprecision(13);
int cs = 1;
while (testcases--) {
cs++;
solve();
}
clock_t end = clock();
fprintf(stderr, "%lf sec\n", (double)(end - beg) / (CLOCKS_PER_SEC));
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, a, b, ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y >> a >> b;
ans += (a - x + 1) * (b - y + 1);
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
int main(void) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
if ((b - 1 <= c && (c + 1) / 2 - 1 <= b) ||
(a - 1 <= d && (d + 1) / 2 - 1 <= a))
puts("YES");
else
puts("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, fa[1000006], f[1000006], m[1000006][2];
int main() {
scanf("%d", &n);
++n;
for (int i = 2; i <= n; ++i) {
scanf("%d", &fa[i]);
f[i] = 1;
int x = i;
while (x != 1) {
if (f[x] >= m[fa[x]][0])
m[fa[x]][1] = m[fa[x]][0], m[fa[x]][0] = f[x];
else
m[fa[x]][1] = max(m[fa[x]][1], f[x]);
if (max(m[fa[x]][1] + 1, m[fa[x]][0]) == f[fa[x]]) break;
f[fa[x]] = max(m[fa[x]][1] + 1, m[fa[x]][0]);
x = fa[x];
}
printf("%d ", m[1][0]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long po(long long a, long long x, long long m) {
if (x == 0) {
return 1;
}
long long ans = 1;
long long k = 1;
while (k <= x) {
if (x & k) {
ans = ((ans * a) % m);
}
k <<= 1;
a *= a;
a %= m;
}
return ans;
}
struct node {
long long x;
long long lev, cur, deg = 1;
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, d, k;
cin >> n >> d >> k;
if (d == 1) {
if (n == 2) {
cout << "YES\n";
if (n == 2) {
cout << 1 << " " << 2 << "\n";
}
cout << "\n";
} else {
cout << "NO\n";
}
return 0;
}
swap(k, d);
long long mor, les;
mor = (k & 1) ? k / 2 + 1 : k / 2;
les = k / 2;
stack<node> q;
node a;
a.x = 1;
a.lev = les;
a.cur = 0;
q.push(a);
long long cnt = 2;
vector<pair<long long, long long>> v;
bool f = false, s = false;
for (long long i = 1; i <= mor && cnt <= n; i++) {
if (i == mor) {
f = true;
}
if (d == 1) break;
node app = q.top();
q.pop();
if (app.x != 1) app.deg = 2;
q.push(app);
node temp;
temp.x = cnt;
temp.lev = mor;
temp.cur = i;
v.push_back(make_pair(cnt - 1, cnt));
cnt++;
q.push(temp);
}
stack<node> to;
while (!q.empty()) {
to.push(q.top());
q.pop();
}
q.swap(to);
for (long long i = 1; i <= les && cnt <= n; i++) {
if (d == 1) break;
if (i == les) s = true;
node app = q.top();
q.pop();
app.deg = 2;
q.push(app);
node temp;
temp.x = cnt;
temp.lev = les;
temp.cur = i;
v.push_back(make_pair(app.x, cnt));
cnt++;
q.push(temp);
}
long long j = 0;
while (cnt <= n && !q.empty()) {
node temp = q.top();
while (temp.cur >= temp.lev || temp.deg >= d) {
q.pop();
if (q.empty()) break;
temp = q.top();
}
if (q.empty()) break;
q.pop();
node etc;
etc.x = cnt++;
etc.lev = temp.lev;
etc.cur = temp.cur + 1;
etc.deg = 1;
temp.deg = temp.deg + 1;
v.push_back(make_pair(temp.x, etc.x));
q.push(temp);
q.push(etc);
}
if (cnt <= n || !f || !s) {
cout << "NO\n";
} else {
cout << "YES\n";
for (auto x : v) {
cout << x.first << " " << x.second << "\n";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long x, y, x1 = 0, y1 = 0, ans = 1;
while (n--) {
cin >> x >> y;
long long a = min(x, y), b = max(x1, y1);
if (a >= b) ans += a - b + 1;
if (x1 == y1) ans--;
x1 = x;
y1 = y;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, x, y;
cin >> a >> b >> x >> y;
int aA = a - 1;
int bB = b - 1;
bool col = false;
int maxr = max(x, aA - x);
int maxc = max(bB - y, y);
cout << max((maxr * b), (maxc * a)) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 3e3 + 555;
struct node {
long long x, y, v;
bool operator<(const node& n) const {
if (x != n.x)
return x < n.x;
else
return y < n.y;
}
};
long long pre[maxn][maxn];
node ori[maxn];
inline long long cal(long long hang1, long long lie1, long long hang2,
long long lie2) {
hang1 = min(hang1, 1000ll);
lie1 = min(lie1, 1000ll);
hang2 = max(hang2, 1ll);
lie2 = max(lie2, 1ll);
return pre[hang1][lie1] - pre[hang1][lie2 - 1] - pre[hang2 - 1][lie1] +
pre[hang2 - 1][lie2 - 1];
}
long long buxuan[maxn];
long long f[maxn];
void init() {
f[0] = 1;
for (long long i = 1; i < maxn; i++) f[i] = f[i - 1] * i % mod;
}
inline long long qpow(long long a, long long n) {
long long base = a;
long long res = 1;
while (n) {
if (n & 1) res = res * base % mod;
base = base * base % mod;
n >>= 1;
}
return res;
}
long long C(long long n, long long m) {
if (n < m) return 0;
return f[n] * qpow(f[m], mod - 2) % mod * qpow(f[n - m], mod - 2) % mod;
}
void solve() {
long long n, m, r;
scanf("%lld %lld %lld", &n, &m, &r);
for (long long i = 1; i <= n; i++) {
scanf("%lld %lld %lld", &ori[i].x, &ori[i].y, &ori[i].v);
pre[ori[i].x][ori[i].y] = 1;
}
sort(ori + 1, ori + n + 1);
long long ans = 0;
for (long long i = 1; i <= 1000; i++)
for (long long j = 1; j <= 1000; j++) pre[i][j] += pre[i][j - 1];
for (long long j = 1; j <= 1000; j++)
for (long long i = 1; i <= 1000; i++) pre[i][j] += pre[i - 1][j];
long long base = C(n, m);
for (long long i = 1; i <= n; i++) {
long long wai =
n - cal(ori[i].x + r, ori[i].y + r, ori[i].x - r, ori[i].y - r);
long long cnt = C(wai, m);
buxuan[i] = cnt;
ans += ori[i].v * ori[i].v % mod * (base - cnt) % mod;
ans %= mod;
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j < i; j++) {
long long wai =
n - cal(ori[i].x + r, ori[i].y + r, ori[i].x - r, ori[i].y - r);
wai -= cal(ori[j].x + r, ori[j].y + r, ori[j].x - r, ori[j].y - r);
if (ori[i].x - ori[j].x <= r * 2) {
if (abs(ori[j].y - ori[i].y) <= r * 2) {
if (ori[j].y < ori[i].y)
wai = wai +
cal(ori[j].x + r, ori[j].y + r, ori[i].x - r, ori[i].y - r) %
mod;
else
wai = wai +
cal(ori[j].x + r, ori[i].y + r, ori[i].x - r, ori[j].y - r) %
mod;
}
}
long long cnt = (base - buxuan[i] - buxuan[j] + C(wai, m)) % mod;
cnt += mod;
cnt %= mod;
ans += ori[i].v * ori[j].v % mod * 2 % mod * cnt % mod;
ans %= mod;
}
}
printf("%lld\n", ans);
}
signed main() {
init();
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[8][11];
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 10; j++) {
cin >> str[i][j];
}
str[i][10] = '\0';
}
char nums[10][11];
for (int i = 0; i < 10; i++) {
cin >> nums[i];
nums[i][10] = '\0';
}
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 10; j++) {
if (!strcmp(str[i], nums[j])) {
cout << j;
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, m;
cin >> n >> m;
long long ans = 0;
long long _5 = 5;
while (true) {
if (n + m < _5) break;
long long d = _5 - max(n, m);
ans += min(_5 - 1, min(n, m)) - (d > 0 ? d : 1) + 1;
_5 += 5;
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 10e5 + 10;
pair<int, int> st[SIZE];
pair<int, int> S[SIZE];
long long int A[2 * 100000 + 10];
long long int B[2 * 100000 + 10];
long long int energie(const int x, const int y) {
if (x == 0 && y == 0) return 0;
return (x != y) ? 2 * (B[x] + B[y]) + A[y] - A[x] : 2 * B[x];
}
long long int max(const long long int a, const long long int b,
const long long int c, long long int d) {
return max(max(a, b), max(c, d));
}
pair<int, int> combine(const pair<int, int>& a, const pair<int, int>& b) {
long long int d1 = energie(a.first, a.second);
long long int d2 = energie(b.first, b.second);
long long int d3 = energie(a.first, b.first);
long long int d4 = energie(a.first, b.second);
long long int maxi1 = max(d1, d2, d3, d4);
long long int d5 = energie(a.second, b.first);
long long int d6 = energie(a.second, b.second);
long long int maxi2 = max(d5, d6);
long long int maxi = max(maxi1, maxi2);
if (d1 == maxi) return a;
if (d2 == maxi) return b;
if (d3 == maxi) return make_pair(a.first, b.first);
if (d4 == maxi) return make_pair(a.first, b.second);
if (d5 == maxi) return make_pair(a.second, b.first);
if (d6 == maxi) return make_pair(a.second, b.second);
}
void build(int p, int l, int r) {
if (l == r)
st[p] = make_pair(l, l);
else {
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build((p << 1) + 1, mid + 1, r);
st[p] = combine(st[p << 1], st[(p << 1) + 1]);
}
}
void Build(int p, int l, int r) {
if (l == r)
S[p] = make_pair(l, l);
else {
int mid = (l + r) >> 1;
Build(p << 1, l, mid);
Build((p << 1) + 1, mid + 1, r);
S[p] = combine(S[p << 1], S[(p << 1) + 1]);
}
}
pair<int, int> query(int p, int l, int r, int i, int j) {
if (j < l || r < i) return make_pair(-1, -1);
if (i <= l && r <= j) return st[p];
int mid = (l + r) >> 1;
pair<int, int> p1 = query(p << 1, l, mid, i, j);
pair<int, int> p2 = query((p << 1) + 1, mid + 1, r, i, j);
if (p1.first == -1 && p1.second == -1) return p2;
if (p2.first == -1 && p2.second == -1) return p1;
return combine(p1, p2);
}
pair<int, int> Query(int p, long long int l, long long int r, int i, int j) {
if (j < l || r < i) return make_pair(-1, -1);
if (i <= l && r <= j) return S[p];
int mid = (l + r) >> 1;
pair<int, int> p1 = Query(p << 1, l, mid, i, j);
pair<int, int> p2 = Query((p << 1) + 1, mid + 1, r, i, j);
if (p1.first == -1 && p1.second == -1) return p2;
if (p2.first == -1 && p2.second == -1) return p1;
return combine(p1, p2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n = 0;
int m = 0;
int l = 0;
int r = 0;
cin >> n >> m;
A[0] = 0, A[1] = 0;
B[0] = 0;
for (int i = 2; i < n + 2; ++i) {
cin >> A[i];
}
for (int j = n + 2; j < 2 * n + 1; ++j) {
A[j] = A[j - n];
}
for (int i = 1; i < n + 1; ++i) {
cin >> B[i];
}
for (int j = n + 1; j < 2 * n; ++j) {
B[j] = B[j - n];
}
for (int i = 2; i < 2 * n; ++i) {
A[i] += A[i - 1];
}
pair<int, int> b;
pair<int, int> A1;
pair<int, int> B1;
build(1, 1, 2 * n);
Build(1, 1, n);
long long int ans = 0;
for (int i = 1; i < m + 1; ++i) {
cin >> l >> r;
if (l == 1 && r == n) return 0;
if (l <= r) {
b = query(1, 1, 2 * n, r + 1, n + l - 1);
A1 = (l != 1) ? Query(1, 1, n, 1, l - 1) : make_pair(0, 0);
B1 = ((r + 1) != n) ? Query(1, 1, n, r + 1, n) : make_pair(0, 0);
ans = max(1, energie(b.first, b.second), energie(A1.first, A1.second),
energie(B1.first, B1.second));
cout << ans << "\n";
} else {
A1 = Query(1, 1, n, r + 1, l - 1);
cout << energie(A1.first, A1.second) << "\n";
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[1111], prime[1111], isprime[1111];
int num = 0;
void init() {
for (int i = 2; i < 1111; i++) isprime[i] = 1;
for (int i = 2; i < 1111; i++) {
if (isprime[i]) {
prime[num++] = i;
for (int j = i * 2; j < 1001; j += i) isprime[j] = 0;
}
}
}
int main() {
init();
int n;
cin >> n;
int ans = 0;
for (int i = 0; i < num; i++) {
int res = prime[i];
while (res <= n) {
a[ans++] = res;
res *= prime[i];
}
}
cout << ans << endl;
if (ans == 0) return 0;
for (int i = 0; i < ans - 1; i++) cout << a[i] << " ";
cout << a[ans - 1] << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long arr[100000];
for (int i = 0; i < n; i++) cin >> arr[i];
long long l = 0, r = n - 1, a = 0, b = 0, prev_l = -1, prev_r = -1;
long long sum1 = 0, sum2 = 0;
if (n == 1) {
cout << 1 << " " << 0 << " ";
return 0;
}
while (l <= r) {
if (l != prev_l) {
sum1 += arr[l];
prev_l = l;
}
if (r != prev_r) {
sum2 += arr[r];
prev_r = r;
}
if (sum1 > sum2) {
b++;
r--;
} else if (sum1 < sum2) {
a++;
l++;
} else {
if (r - l == 2)
a++;
else {
a++;
b++;
}
l++;
r--;
}
}
cout << a << " " << b << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
ifstream Cin("input.txt");
ofstream Cout("output.txt");
int main() {
long long n, k, i, c[100001] = {}, r[100001], ll, rr, cc = 0;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> r[i];
c[r[i]]++;
if (c[r[i]] == 1) cc++;
}
if (cc < k) {
cout << "-1 -1";
return 0;
}
rr = n;
while (cc >= k) {
c[r[rr]]--;
if (c[r[rr]] == 0) cc--;
rr--;
}
cc++;
rr++;
c[r[rr]]++;
ll = 1;
while (cc >= k) {
c[r[ll]]--;
if (c[r[ll]] == 0) cc--;
ll++;
}
cc++;
ll--;
c[r[ll]]++;
cout << ll << " " << rr << endl;
}
| 3 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::sort;
using std::string;
using std::swap;
struct xy {
int fr, go, num;
long long val;
void in() {
cin >> fr >> go >> val;
--fr;
--go;
}
} arr[400010];
bool operator<(xy a, xy b) { return a.val < b.val; }
std::vector<int> ans;
long long bfs(std::vector<std::pair<int, int> > *v, int n) {
std::queue<int> q;
long long ver[n];
for (int i = 0; i < n; ++i) ver[i] = LLONG_MAX;
int u;
cin >> u;
--u;
q.push(u);
ver[u] = 0;
while (q.size()) {
int now = q.front();
q.pop();
for (std::pair<int, int> &i : v[now])
if (ver[now] + arr[i.second].val < ver[i.first]) {
ver[i.first] = ver[now] + arr[i.second].val;
q.push(i.first);
}
}
ans = std::vector<int>();
long long sum = 0;
for (int j = 0; j < n; ++j) {
if (j == u) continue;
long long min = LLONG_MAX;
int now = -1;
for (std::pair<int, int> &i : v[j])
if (ver[j] - arr[i.second].val == ver[i.first] &&
arr[i.second].val < min) {
min = arr[now = i.second].val;
}
sum += min;
ans.push_back(now);
};
return sum;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
{
int n, m;
while (cin >> n >> m) {
std::vector<std::pair<int, int> > v[n];
for (int i = 0; i < m; ++i) {
arr[i].in();
arr[i].num = i;
v[arr[i].fr].push_back(std::make_pair(arr[i].go, i));
v[arr[i].go].push_back(std::make_pair(arr[i].fr, i));
}
cout << bfs(v, n) << endl;
for (int &i : ans) cout << i + 1 << " ";
cout << endl;
;
};
}
return 0;
};
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
bool found[n];
set<long long> s;
for (int i = 0; i < n; i++) cin >> v[i], found[i] = false;
for (int i = 0; i < n; i++) {
long long a = (i + v[i] + (n * (long long)1e10)) % n;
s.insert(a);
}
for (int i = 0; i < n; i++) {
if (s.find(i) == s.end()) {
cout << "NO"
<< "\n";
return;
}
}
cout << "YES"
<< "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int chill = 1;
cin >> chill;
while (chill--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string word1[m], word2[m];
string lecture[n];
for (int i = 0; i < m; i++) cin >> word1[i] >> word2[i];
for (int i = 0; i < n; i++) cin >> lecture[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (lecture[i] == word1[j]) {
if (word1[j].size() > word2[j].size())
cout << word2[j] << " ";
else
cout << lecture[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 31;
int N;
int a[MAXN];
bool bio[MAXN][2 * MAXN][MAXN * MAXN];
vector<int> path, opt;
vector<pair<int, int> > v;
int sol[2 * MAXN][2 * MAXN];
int limit;
void load() {
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", a + i);
}
void dfs(int pos, int sum) {
int num = path.size();
if (pos == N) {
if (sum == num * (num - 1) / 2 && (opt.empty() || path.size() < opt.size()))
opt = path;
return;
}
if (num > limit || sum > limit * (limit - 1) / 2) return;
if (bio[pos][num][sum]) return;
bio[pos][num][sum] = true;
sum += a[pos];
if (sum < num * (num + 1) / 2) return;
path.push_back(a[pos]);
dfs(pos, sum);
dfs(pos + 1, sum);
path.pop_back();
}
void solve() {
sort(a, a + N);
limit = 2 * a[N - 1] + 1;
dfs(0, 0);
if (opt.empty()) {
puts("=(");
return;
}
int nodes = opt.size();
for (int i = 0; i < nodes; i++) v.push_back({opt[i], i});
for (int i = 0; i < nodes; i++) {
for (int j = 0; j < nodes - i - 1; j++)
if (j < v[i].first)
sol[v[i].second][v[i + j + 1].second] = 1;
else {
sol[v[i + j + 1].second][v[i].second] = 1;
v[i + j + 1].first--;
}
sort(v.begin() + i + 1, v.end());
}
printf("%d\n", nodes);
for (int i = 0; i < nodes; i++, puts(""))
for (int j = 0; j < nodes; j++) printf("%d", sol[i][j]);
}
int main() {
load();
solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr1[n], arr2[n];
for (int i = 0; i < n; i++) {
cin >> arr1[i] >> arr2[i];
}
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (arr1[i] == arr2[j]) cnt++;
}
cout << cnt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a1, a2, a3, a4, p, mn;
const int N = 1e5 + 10, mod = 1e9 + 7;
string s, s4, s7, ans;
bool ff = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int r = 0;
cin >> a1 >> a2 >> a3 >> a4;
if (abs(a3 - a4) > 1) return cout << -1, 0;
mn = min(a3, a4);
while (mn--) {
s += "47";
a1--;
a2--;
}
mn = min(a3, a4);
a3 -= mn;
a4 -= mn;
if (a1) {
s += '4';
a1--;
} else if (a2) {
reverse(s.begin(), s.end());
s += '7';
a2--;
} else
ff = 1;
if (a4) {
if (s[s.size() - 1] == '7')
s += '4', a1--;
else
s = "7" + s, a2--;
a4--;
} else if (a3) {
if (s[s.size() - 1] == '4')
s += '7', a2--;
else
ff = 1;
a3--;
}
for (int i = 1; i <= a1; i++) s4 += '4';
int j = s.size() - 1, i = 0, k = 0, p = 0;
for (int i = 1; i <= a2; i++) s7 += '7';
if (!(a1 >= 0 && a2 >= 0) || ff) return cout << -1, 0;
for (; j >= 0; j--)
if (s[j] == '7') {
p = j;
break;
}
for (; i < s.size(); i++)
if (s[i] == '4') {
k = i;
break;
}
for (int r = 0; r < s.size(); r++) {
if (r == p) cout << s7;
if (r == k) cout << s4;
cout << s[r];
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:200000000")
const double EPS = 1E-9;
const int INF = 1000000000;
const long long INF64 = (long long)1E18;
const double PI = 3.1415926535897932384626433832795;
const int NMAX = 310000;
double delta[NMAX * 4][3][3], md[NMAX * 4][3][3], add[3][3], result[3],
mult_result[3][3], mult1_result[3], a0[3], a1[3];
bool upd[NMAX * 4];
void mult(double a[3][3], double b[3][3]) {
for (int i = 0; i < (int)(3); i++)
for (int j = 0; j < (int)(3); j++) {
mult_result[i][j] = 0;
for (int k = 0; k < (int)(3); k++) mult_result[i][j] += a[i][k] * b[k][j];
}
}
void mult1(double a[3], double b[3][3]) {
for (int i = 0; i < (int)(3); i++) {
mult1_result[i] = 0;
for (int k = 0; k < (int)(3); k++) mult1_result[i] += a[k] * b[k][i];
}
}
void relax(int idx, int l, int r) {
if (!upd[idx]) return;
mult(md[idx], delta[idx]);
memcpy(md[idx], mult_result, sizeof(md[idx]));
upd[idx] = false;
if (l != r) {
mult(delta[idx << 1], delta[idx]);
memcpy(delta[idx << 1], mult_result, sizeof(md[idx]));
mult(delta[idx << 1 | 1], delta[idx]);
memcpy(delta[idx << 1 | 1], mult_result, sizeof(md[idx]));
upd[idx << 1] = upd[idx << 1 | 1] = true;
}
for (int i = 0; i < (int)(3); i++)
for (int j = 0; j < (int)(3); j++) delta[idx][i][j] = i == j ? 1.0 : 0.0;
}
void update(int idx, int l, int r, int p) {
relax(idx, l, r);
if (l == p) {
memcpy(delta[idx], add, sizeof(add));
upd[idx] = true;
relax(idx, l, r);
return;
}
int mid = (l + r) >> 1;
if (p <= mid) update(idx << 1, l, mid, p);
update(idx << 1 | 1, mid + 1, r, max(p, mid + 1));
}
void get(int idx, int l, int r, int p) {
relax(idx, l, r);
if (l == r) {
result[0] = l;
result[1] = 0;
result[2] = 1.0;
mult1(result, md[idx]);
memcpy(result, mult1_result, sizeof(mult1_result));
} else {
int mid = (l + r) >> 1;
if (p <= mid)
get(idx << 1, l, mid, p);
else
get(idx << 1 | 1, mid + 1, r, p);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)(NMAX * 4); i++)
for (int j = 0; j < (int)(3); j++) md[i][j][j] = delta[i][j][j] = 1;
for (int ii = 0; ii < (int)(m); ii++) {
int tp, num, z;
scanf("%d%d%d", &tp, &num, &z);
num--;
get(1, 0, n, num);
memcpy(a0, result, sizeof(a0));
if (tp == 1) {
get(1, 0, n, num + 1);
memcpy(a1, result, sizeof(a1));
pair<double, double> v(a1[0] - a0[0], a1[1] - a0[1]);
double len = sqrt(v.first * v.first + v.second * v.second);
v.first /= len;
v.second /= len;
memset(add, 0, sizeof(add));
add[0][0] = 1;
add[2][0] = v.first * z;
add[1][1] = 1;
add[2][1] = v.second * z;
add[2][2] = 1;
update(1, 0, n, num + 1);
} else {
double ang = -z / 360.0 * 2 * PI;
memset(add, 0, sizeof(add));
add[0][0] = cos(ang);
add[1][0] = -sin(ang);
add[2][0] = -a0[0] * cos(ang) + a0[1] * sin(ang) + a0[0];
add[0][1] = sin(ang);
add[1][1] = cos(ang);
add[2][1] = -a0[0] * sin(ang) - a0[1] * cos(ang) + a0[1];
add[2][2] = 1;
update(1, 0, n, num + 1);
}
get(1, 0, n, n);
printf("%.10lf %.10lf\n", result[0], result[1]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
int an[MAX];
int cc[MAX];
int num[MAX];
int ans[MAX];
int main() {
int n;
scanf("%d", &n);
int mm = INT_MIN;
for (int i = 1; i <= n; ++i) {
scanf("%d", &an[i]);
cc[an[i]]++;
mm = std::max(mm, an[i]);
}
bool ok = 1;
int ss;
int cur;
for (int i = 1; i <= mm; i++) {
if (cc[i] < cc[i + 1]) {
ok = 0;
break;
} else {
if (i == 1) {
ss = cc[i], cur = ss;
num[i] = ss - cur + 1;
} else {
cur = cur - (cc[i - 1] - cc[i]);
num[i] = ss - cur + 1;
}
}
}
if (ok) {
printf("%d\n", ss);
for (int i = 1; i <= n; ++i) {
ans[i] = num[an[i]]++;
printf("%d ", ans[i]);
}
printf("\n");
} else
printf("%d\n", -1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i, a[10], r[10], cnt = 0, temp = 0, len = 0, rem;
string dig;
for (i = 0; i < 10; i++) {
a[i] = 0;
r[i] = 0;
}
cin >> t;
cin >> dig;
len = dig.length();
for (i = 0; i < len; i++) a[dig[i] - 48]++;
len = 0;
temp = t;
while (temp > 0) {
r[temp % 10]++;
temp /= 10;
len++;
}
while (1) {
temp = 0;
for (i = 0; i < 10; i++) {
if (r[i]) {
if (a[i] >= r[i]) {
a[i] -= r[i];
temp += r[i];
} else if (a[i] > 0 && (i == 2 || i == 5 || i == 6 || i == 9)) {
rem = r[i] - a[i];
temp += a[i];
a[i] = 0;
if (i == 2 && a[5] >= rem) {
temp += rem;
a[5] -= rem;
} else if (i == 5 && a[2] >= rem) {
temp += rem;
a[2] -= rem;
} else if (i == 6 && a[9] >= rem) {
temp += rem;
a[9] -= rem;
} else if (i == 9 && a[6] >= rem) {
temp += rem;
a[6] -= rem;
}
} else if (i == 2 || i == 5 || i == 6 || i == 9) {
if (i == 2 && a[5] >= r[i]) {
temp += r[i];
a[5] -= r[i];
} else if (i == 5 && a[2] >= r[i]) {
temp += r[i];
a[2] -= r[i];
} else if (i == 6 && a[9] >= r[i]) {
temp += r[i];
a[9] -= r[i];
} else if (i == 9 && a[6] >= r[i]) {
temp += r[i];
a[6] -= r[i];
}
}
}
}
if (temp == len)
cnt++;
else
break;
}
cout << cnt;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (a[0] > a[n - 1]) {
cout << "No"
<< "\n";
} else {
cout << "Yes"
<< "\n";
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
#define ff first
#define ss second
#define pi pair<lli,lli>
#define pb push_back
#define vi vector<lli>
#define vc vector<char>
#define vp vector<pair<lli,lli>>
#define si set<lli>
#define M 1000000007
#define decimal cout<<fixed<<setprecision(10)
#define bi bitset<32>
void solve(){
lli n,m,k;
cin>>n>>m>>k;
lli ans = 0;
ans += (m-1);
ans += ((n-1)*m);
if(ans == k){
cout<<"YES"<<"\n";
}
else{
cout<<"NO"<<"\n";
}
}
int main(){
lli t;
//t=1;
cin>>t;
while(t--){
solve();
}
return 0;
}
/* Works as bitset<32> bit[n] n-->(input size)
for(int i=0;i<n;++i){
cin>>a;
bit[i] = a; // will store the binary representation of a;
}
//accessing bit by bit:
for(int i=0;i<n;++i){
for(int j=0;j<32;++j){
cout<<bit[i][j];
}
}
remember:
1.) the is_sorted() and reverse() in c++
2.) sqrt() returns double.
*/ | 0 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-8;
long double D[105];
long double dp[105][105];
long double eps;
int n, k;
long double dist(int x0, int y0, int x1, int y1) {
return (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0);
}
long double prob(long double d, long double R) {
if (d <= R * R + EPS)
return 1;
else
return exp(1 - d / (R * R));
}
bool check(long double R) {
for (int i = int(0); i < int(n + 1); i++)
for (int j = int(0); j < int(n + 1); j++) dp[i][j] = 0;
dp[0][0] = 1;
for (int i = int(1); i < int(n + 1); i++) {
long double p = prob(D[i], R);
for (int j = int(0); j < int(i + 1); j++) {
dp[i][j] = (k > 0 ? dp[i - 1][j - 1] * p : 0) + dp[i - 1][j] * (1 - p);
}
}
long double cur = 0.0;
for (int i = int(k); i < int(n + 1); i++) cur += dp[n][i];
return cur >= 1 - eps;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
cin >> eps;
eps /= 1000;
int x0, y0, x1, y1;
cin >> x0 >> y0;
for (int i = int(1); i < int(n + 1); i++) {
cin >> x1 >> y1;
D[i] = dist(x1, y1, x0, y0);
}
long double l = 0, r = 2000000;
while (r - l > EPS) {
long double mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
cout << setprecision(12) << (l + r) / 2 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int M = 2e6 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
int n, m, tot, s, fa[N], depth[N], nx[N][20], mx[N][20];
struct node {
int u, v, w, c, id;
bool operator<(const node &rhs) const { return w < rhs.w; }
} e[N << 1];
bool cmp(node a, node b) { return a.id < b.id; }
vector<pair<int, int> > edge[N];
map<int, int> result;
int Find(int x) { return x == fa[x] ? x : fa[x] = Find(fa[x]); }
long long kruscal() {
long long ans = 0;
for (int i = 1; i <= n; i++) fa[i] = i;
sort(e, e + m);
for (int i = 0; i < m; i++) {
int u = e[i].u, v = e[i].v, w = e[i].w;
int nx_u = Find(u);
int nx_v = Find(v);
if (nx_u != nx_v) {
edge[u].push_back(make_pair(v, e[i].id));
edge[v].push_back(make_pair(u, e[i].id));
fa[nx_u] = nx_v;
ans += w;
result[e[i].id] = w;
}
}
sort(e, e + m, cmp);
return ans;
}
int getMxId(int a, int b) {
if (a == -1) return b;
if (b == -1) return a;
return e[a].w > e[b].w ? a : b;
}
void dfs(int u, int pre) {
nx[u][0] = pre;
for (int i = 1; i < 20; i++) {
if (nx[u][i - 1] != -1) {
nx[u][i] = nx[nx[u][i - 1]][i - 1];
mx[u][i] = getMxId(mx[u][i - 1], mx[nx[u][i - 1]][i - 1]);
} else
nx[u][i] = mx[u][i] = -1;
}
for (auto t : edge[u]) {
int v = t.first;
if (v == pre) continue;
depth[v] = depth[u] + 1;
mx[v][0] = t.second;
dfs(v, u);
}
}
int getLca(int a, int b) {
if (depth[a] < depth[b]) swap(a, b);
for (int i = 0; i < 20; i++)
if (depth[a] - depth[b] >> i & 1) a = nx[a][i];
if (a == b) return a;
for (int i = 19; i >= 0; i--)
if (nx[a][i] != nx[b][i]) a = nx[a][i], b = nx[b][i];
return nx[a][0];
}
int getMxIdPath(int a, int b) {
int lca = getLca(a, b);
int ret = -1;
for (int i = 19; i >= 0; i--) {
if (nx[a][i] != -1 && depth[nx[a][i]] >= depth[lca]) {
ret = getMxId(ret, mx[a][i]);
a = nx[a][i];
}
if (nx[b][i] != -1 && depth[nx[b][i]] >= depth[lca]) {
ret = getMxId(ret, mx[b][i]);
b = nx[b][i];
}
}
return ret;
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", &e[i].w);
for (int i = 0; i < m; i++) scanf("%d", &e[i].c);
for (int i = 0; i < m; i++) {
scanf("%d", &e[i].u);
scanf("%d", &e[i].v);
e[i].id = i;
}
scanf("%d", &s);
long long cost = kruscal();
dfs(1, -1);
long long ans = cost, p = 0;
for (int id = 0; id < m; id++) {
int big = getMxIdPath(e[id].u, e[id].v);
long long tmp = cost - e[big].w + e[id].w - s / e[id].c;
if (tmp < ans) ans = tmp, p = id;
}
printf("%lld\n", ans);
result.erase(getMxIdPath(e[p].u, e[p].v));
result[p] = e[p].w - s / e[p].c;
for (auto t : result) printf("%d %d\n", t.first + 1, t.second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[100005], b[100005], count, t, n, i, diff;
cin >> t;
while (t--) {
count = 0;
diff = 0;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) cin >> b[i];
for (i = 0; i < n; i++) {
if (a[i] - b[i] != diff) {
diff = a[i] - b[i];
if (diff != 0) count++;
}
if (diff > 0) count += 5;
}
if (count > 1)
cout << "NO";
else
cout << "YES";
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ans = 0, n;
void rec(int a) {
ans++;
if (a * 10 <= n) rec(a * 10);
if (a * 10 + 1 <= n) rec(a * 10 + 1);
return;
}
void solve() {
cin >> n;
rec(1);
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int t, n, cs = 0, i, j, k, x;
cin >> n;
n = n / 2;
n++;
cout << n << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double eps = 1e-6;
int n, k;
double l, v1, v2;
bool judge(double time_limit) {
int remain_num = n;
double remain_time = time_limit;
double remain_dis = l;
while (remain_num > k and remain_time > eps) {
remain_num -= k;
double x = (remain_time * v1 * v2 - v1 * remain_dis) / (v2 - v1);
double go_time = (remain_dis - x) / v2;
double return_time = (remain_dis - x - v1 * go_time) / (v1 + v2);
double t = go_time + return_time;
remain_dis -= v1 * t;
remain_time -= t;
}
remain_time -= remain_dis / v2;
return remain_time > eps;
}
int main() {
while (cin >> n >> l >> v1 >> v2 >> k) {
double left = 0, right = l / v1 + eps;
int count = 0;
while (left + eps < right) {
double mid = (left + right) / 2;
if (judge(mid))
right = mid;
else
left = mid;
count += 1;
}
printf("%.10f\n", left);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int N = 1005;
int n, ans;
int a[N];
signed main() {
register int i, j;
scanf("%d", &n);
for (i = 1; i <= n * 2; i++) scanf("%d", &a[i]);
for (i = 1; i <= n * 2; i += 2) {
for (j = i + 1; j <= n * 2; j++)
if (a[j] == a[i]) {
memcpy(a + i + 2, a + i + 1, sizeof(int) * (j - i - 1));
ans += j - i - 1;
a[i + 1] = a[i];
break;
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000");
using namespace std;
long long solve1(long long x, long long k) {
if (k >= x - 1) return x;
return k + 1;
}
long long solve2(long long x, long long y, long long k) {
if (x > y) swap(x, y);
if (2 * (x - 1) >= k) {
long long a = k / 2, b = k - a;
return (a + 1) * (b + 1);
}
return x * solve1(y, k - x + 1);
}
int main() {
long long x, y, z, k;
cin >> x >> y >> z >> k;
if (3 * (min(x, min(y, z)) - 1) >= k) {
long long a = k / 3;
long long b = (k - a) / 2;
long long c = k - a - b;
cout << (a + 1) * (b + 1) * (c + 1) << endl;
return 0;
}
if (y > z) swap(y, z);
if (x > y) swap(x, y);
cout << x * solve2(y, z, k - x + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=a;i<int(b);i++)
#define FIL(a,b) memset((a),(b),sizeof(a))
#define SZ(a) ((int)(a).size())
#define ALL(a) begin(a),end(a)
#define PB push_back
#define FI first
#define SE second
typedef long long LL;
typedef pair<int,int> PT;
typedef complex<double> PX;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<PT> VPT;
template<typename T> ostream& operator<<(ostream& s, vector<T> const& v)
{ s << '{'; FOR(i,0,v.size()) s << (i ? "," : "") << v[i]; return s << '}'; }
template<typename S, typename T> ostream& operator<<(ostream &s, pair<S,T> const& p)
{ return s << '(' << p.first << ',' << p.second << ')'; }
const int LS = 300000;
struct node {
LL sum, lsum;
void apply(LL x, LL c) {
sum += x*c;
lsum += c;
}
void split(node& ls, node& rs, int l, int m, int r) {
if (lsum) {
ls.apply(m-l+1, lsum);
rs.apply(r-m, lsum);
lsum = 0;
}
}
void merge(node& ls, node& rs) {
sum = ls.sum + rs.sum;
}
} seg[4*LS];
LL segQuery(int n, int l, int r, int i) {
if (l == r) return seg[n].sum;
int m = (l+r)/2;
seg[n].split(seg[2*n+1],seg[2*n+2],l,m,r);
if (m >= i) return segQuery(2*n+1, l, m, i);
else return segQuery(2*n+2, m+1, r, i);
}
void segUpdate(int n, int l, int r, int i, int j, LL c) {
if (i > r || j < l) return;
if (i <= l && r <= j) {
seg[n].apply(r-l+1, c);
return;
}
int m = (l+r)/2;
seg[n].split(seg[2*n+1],seg[2*n+2],l,m,r);
segUpdate(2*n+1, l, m, i, j, c);
segUpdate(2*n+2, m+1, r, i, j, c);
seg[n].merge(seg[2*n+1], seg[2*n+2]);
}
int segBinarySearch(int n, int l, int r, LL x) {
if (l==r) return l;
int m = (l+r)/2;
seg[n].split(seg[2*n+1],seg[2*n+2],l,m,r);
if (seg[2*n+1].sum >= x) return segBinarySearch(2*n+1, l, m, x);
else return segBinarySearch(2*n+2, m+1, r, x-seg[2*n+1].sum);
}
int main() {
int N, K;
scanf("%d%d", &N, &K);
VI L(N);
FOR(n,0,N) {
scanf("%d", &L[n]);
}
sort(ALL(L), greater<int>());
segUpdate(0, 0, LS-1, 0, 0, 1);
LL tot = 1;
int lvl = 0, ans = INT_MAX;
for (int l : L) {
while (lvl < LS && !segQuery(0, 0, LS-1, lvl)) ++lvl;
if (lvl == LS) {puts("-1"); return 0;}
segUpdate(0, 0, LS-1, lvl, lvl, -1);
int p1 = l/2;
int p2 = l%2 ? p1 : p1-1;
segUpdate(0, 0, LS-1, lvl+2, lvl+1+p1, 1);
segUpdate(0, 0, LS-1, lvl+2, lvl+1+p2, 1);
tot += l-2;
if (tot >= K) {
ans = min(ans, segBinarySearch(0, 0, LS-1, K));
}
}
printf("%d\n", ans==INT_MAX ? -1 : ans);
}
| 9 |
#include <bits/stdc++.h>
void read();
const int N = 1e5 + 100;
const int M = 2e5 + 100;
const long long oo = 1e18;
using namespace std;
vector<vector<int>> v;
int vis[M];
int first = 0;
int lasN = -1;
void dfs(int cur, int las) {
vis[cur] = true;
if (first) first = -1;
for (int i = 0; i < v[cur].size(); i++) {
if (!vis[v[cur][i]])
dfs(v[cur][i], cur);
else if (v[cur][i] != las && !first)
first = 1, lasN = cur;
else if (v[cur][i] != las && first == 1 && v[cur][i] != lasN)
first = -1;
}
if (!first) first = -1;
}
int main() {
int n, m;
cin >> n >> m;
v.resize(n);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
r--, l--;
v[l].push_back(r);
v[r].push_back(l);
}
int sum = 0;
for (int i = 0; i < n; i++) {
first = 0;
lasN = -1;
if (!vis[i]) {
dfs(i, i);
}
if (first == 1) sum += 1;
}
cout << sum << endl;
return 0;
}
void read() {
freopen("in.txt", "r", stdin);
freopen("ou.txt", "w", stdout);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string com;
map<string, bool> mp;
int ans = 0;
while (getline(cin, com)) {
if (com[0] == '+') {
com.erase(com.begin(), com.begin() + 1);
mp[com] = 1;
} else if (com[0] == '-') {
com.erase(com.begin(), com.begin() + 1);
mp[com] = 0;
} else {
int len = com.size() - com.find(':') - 1, cnt = 0;
for (map<string, bool>::iterator it = mp.begin(); it != mp.end(); it++) {
if (it->second) cnt++;
}
ans += cnt * len;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 200005;
const int N = 900005;
struct node {
int son[27];
int fa;
} a[N];
int sz;
char s[N];
int mat[M];
vector<int> over[N];
inline int new_id() {
++sz;
over[sz].clear();
for (int i = (1); i <= (26); i++) a[sz].son[i] = -1;
return sz;
}
int np, ans;
void ins(int pos, int x, int y) {
over[pos].push_back(np);
if (x == y) return;
int cur = s[x] - 'a' + 1;
if (a[pos].son[cur] == -1) {
a[pos].son[cur] = new_id();
a[a[pos].son[cur]].fa = pos;
}
ins(a[pos].son[cur], ++x, y);
return;
}
int u[M], n;
void dfs(int x, int dep) {
for (int i = (1); i <= (26); i++)
if (a[x].son[i] != -1) dfs(a[x].son[i], dep + 1);
vector<int> g1, g2;
g1.clear();
g2.clear();
for (int i = 0; i < over[x].size(); i++) {
int j = over[x][i];
if (u[j]) continue;
if (j <= n)
g1.push_back(j);
else
g2.push_back(j);
}
for (int i = 0; i < min(g1.size(), g2.size()); i++) {
ans += dep;
u[g1[i]] = u[g2[i]] = 1;
mat[g1[i]] = g2[i] - n;
}
}
int main() {
scanf("%d", &n);
sz = -1;
new_id();
for (int i = (1); i <= (n * 2); i++) {
np = i;
scanf("%s", &s);
int len = strlen(s);
ins(0, 0, len);
}
dfs(0, 0);
printf("%d\n", ans);
for (int i = (1); i <= (n); i++) printf("%d %d\n", i, mat[i]);
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.