solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,K,x,s=0;
cin>>N>>K;
for(int i = 0;i<N;i++){
cin>>x;
s+=min(x,K-x)*2;
}
cout<<s<<endl;
} | 0 |
#include<iostream>
using namespace std;
int main(){
int n,a[101],tmp,cnt=0;
cin>>n;
for(int i=0;i<n;i++) cin>>a[i];
for(int i=0;i<n-1;i++)
for(int j=n-1;j>0;j--){
if(a[j]<a[j-1]){
tmp=a[j];
a[j]=a[j-1];
a[j-1]=tmp;
cnt++;
}
}
for(int i=0;i<n-1;i++)cout<<a[i]<<" ";
cout<<a[n-1]<<endl<<cnt<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int t, n;
long long s;
pair<int, int> x[N];
bool valid(int mid) {
int cnt = (n + 1) / 2;
long long sum = s;
for (int i = n - 1; ~i; --i) {
if (cnt && mid <= x[i].second)
--cnt, sum -= max(x[i].first, mid);
else
sum -= x[i].first;
}
return sum >= 0 && !cnt;
}
int solve() {
int l = 0, r = 1e9 + 5;
while (l < r) {
int mid = l + (r - l + 1) / 2;
if (valid(mid))
l = mid;
else
r = mid - 1;
}
return l;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> s;
for (int i = 0; i < n; ++i) cin >> x[i].first >> x[i].second;
sort(x, x + n, [](pair<int, int>& a, pair<int, int>& b) {
return a.first < b.first;
});
cout << solve() << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int dx[] = {0, 1, 0, -1, 1, -1, 1, -1, -2, 2, 0, 0},
dy[] = {1, 0, -1, 0, -1, 1, 1, -1, 0, 0, -2, 2};
using namespace std;
int n, k, a;
int avail;
int getAvail(pair<long long, long long> r) {
int len = r.second - r.first + 1;
return (len + 1) / (a + 1);
}
set<pair<long long, long long> > ss;
int main() {
ios_base::sync_with_stdio(false);
scanf("%d %d %d", &n, &k, &a);
ss.insert(make_pair(1, n));
avail = getAvail(make_pair(1, n));
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
auto it = ss.upper_bound(make_pair(x, INT_MAX));
it--;
pair<long long, long long> cur = *it;
if (x < cur.first || x > cur.second) continue;
avail -= getAvail(cur);
ss.erase(it);
pair<long long, long long> first = make_pair(cur.first, x - 1);
pair<long long, long long> second = make_pair(x + 1, cur.second);
int fg = getAvail(first);
int sg = getAvail(second);
avail += fg;
avail += sg;
ss.insert(first);
ss.insert(second);
if (avail < k) {
cout << i + 1;
exit(0);
}
}
cout << -1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e17;
const int maxn = 5010;
struct E {
int v, next;
long long w;
} e[maxn << 1];
int head[maxn], tot;
void add(int s, int t, long long w) {
e[tot].v = t;
e[tot].w = w;
e[tot].next = head[s];
head[s] = tot++;
e[tot].v = s;
e[tot].w = w;
e[tot].next = head[t];
head[t] = tot++;
}
void init() {
tot = 0;
memset(head, -1, sizeof(head));
}
int n;
long long sum;
long long ans, dp[maxn], mi;
int son[maxn];
void dfs(int u, int fa) {
son[u] = 1;
dp[u] = 0;
int i;
for (i = head[u]; ~i; i = e[i].next) {
int v = e[i].v;
if (v == fa) continue;
dfs(v, u);
son[u] += son[v];
dp[u] += dp[v] + e[i].w * son[v];
}
}
void dfs2(int u, int fa, int rt) {
mi = min(mi, dp[u]);
int i;
for (i = head[u]; ~i; i = e[i].next) {
int v = e[i].v;
if (v == fa) continue;
sum += e[i].w * (son[rt] - son[v]) * son[v];
dp[v] = dp[u] - e[i].w * son[v] + e[i].w * (son[rt] - son[v]);
dfs2(v, u, rt);
}
}
int u[maxn], v[maxn];
long long w[maxn];
int main() {
ios ::sync_with_stdio(0);
int i, j;
cin >> n;
init();
int x, y;
long long z;
for (i = 0; i < n - 1; i++) {
cin >> u[i] >> v[i] >> w[i];
add(u[i], v[i], w[i]);
}
ans = INF;
for (i = 0; i < n - 1; i++) {
x = u[i];
y = v[i];
z = w[i];
sum = 0;
mi = INF;
dfs(x, y);
dfs2(x, y, x);
sum += mi * (n - son[x]);
mi = INF;
dfs(y, x);
dfs2(y, x, y);
sum += mi * (n - son[y]);
sum += z * son[x] * son[y];
ans = min(ans, sum);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, n;
cin >> a >> b >> n;
int count = 0;
while (max(a, b) <= n) {
if (a > b)
b += a;
else
a += b;
count++;
}
cout << count << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
int arr[200100];
int main() {
int i;
scanf("%d%d",&n,&x);
if (x>1&&x<2*n-1) {
printf("Yes\n");
arr[n-1] = x;
int p = 1;
for (i=n;i<2*n-1;i++) {
if (p==x) p++;
arr[i] = p++;
}
p = 2*n-1;
for (i=n-2;i>=0;i--) {
if (p==x) p--;
arr[i] = p--;
}
for (i=0;i<2*n-1;i++) printf("%d\n",arr[i]);
}
else printf("No\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct dinic {
struct edge {
int src, dst;
T low, cap, flow;
int rev;
};
int n;
vector<vector<edge>> adj;
dinic(int n) : n(n), adj(n + 2) {}
void add_edge(int src, int dst, T low, T cap) {
adj[src].push_back({src, dst, low, cap, 0, (int)adj[dst].size()});
if (src == dst) adj[src].back().rev++;
adj[dst].push_back({dst, src, 0, 0, 0, (int)adj[src].size() - 1});
}
vector<int> level, iter;
T augment(int u, int t, T cur) {
if (u == t) return cur;
for (int &i = iter[u]; i < (int)adj[u].size(); ++i) {
edge &e = adj[u][i];
if (e.cap - e.flow > 0 && level[u] > level[e.dst]) {
T f = augment(e.dst, t, min(cur, e.cap - e.flow));
if (f > 0) {
e.flow += f;
adj[e.dst][e.rev].flow -= f;
return f;
}
}
}
return 0;
}
int bfs(int s, int t) {
level.assign(n + 2, n + 2);
level[t] = 0;
queue<int> Q;
for (Q.push(t); !Q.empty(); Q.pop()) {
int u = Q.front();
if (u == s) break;
for (edge &e : adj[u]) {
edge &erev = adj[e.dst][e.rev];
if (erev.cap - erev.flow > 0 && level[e.dst] > level[u] + 1) {
Q.push(e.dst);
level[e.dst] = level[u] + 1;
}
}
}
return level[s];
}
const T oo = numeric_limits<T>::max();
T max_flow(int source, int sink) {
vector<T> delta(n + 2);
for (int u = 0; u < n; ++u)
for (auto &e : adj[u]) {
delta[e.src] -= e.low;
delta[e.dst] += e.low;
e.cap -= e.low;
e.flow = 0;
}
T sum = 0;
int s = n, t = n + 1;
for (int u = 0; u < n; ++u) {
if (delta[u] > 0) {
add_edge(s, u, 0, delta[u]);
sum += delta[u];
} else if (delta[u] < 0)
add_edge(u, t, 0, -delta[u]);
}
add_edge(sink, source, 0, oo);
T flow = 0;
while (bfs(s, t) < n + 2) {
iter.assign(n + 2, 0);
for (T f; (f = augment(s, t, oo)) > 0;) flow += f;
}
if (flow != sum) return -1;
for (int u = 0; u < n; ++u)
for (auto &e : adj[u]) {
e.cap += e.low;
e.flow += e.low;
edge &erev = adj[e.dst][e.rev];
erev.cap -= e.low;
erev.flow -= e.low;
}
adj[sink].pop_back();
adj[source].pop_back();
while (bfs(source, sink) < n + 2) {
iter.assign(n + 2, 0);
for (T f; (f = augment(source, sink, oo)) > 0;) flow += f;
}
return flow;
}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
map<pair<int, int>, int> mp;
string ans(n, 'b');
const int D = 2e5;
vector<int> l(D), r(D);
for (int i = 0, x, y; i < n; ++i) {
cin >> x >> y;
mp[{--x, --y}] = i;
++l[x];
++r[y];
}
int source = 2 * D, sink = source + 1;
dinic<int> d(sink + 1);
for (auto i : mp) d.add_edge(i.first.first, D + i.first.second, 0, 1);
int sl = 0, sr = 0;
for (int i = 0; i < D; ++i) {
sl += l[i] / 2, sr += r[i] / 2;
if (l[i]) d.add_edge(source, i, l[i] / 2, l[i] - l[i] / 2);
if (r[i]) d.add_edge(D + i, sink, r[i] / 2, r[i] - r[i] / 2);
}
int f = d.max_flow(source, sink);
assert(f >= max(sl, sr));
for (int i = 0; i < D; ++i)
for (auto &j : d.adj[i])
if (j.dst != source && j.dst < sink && j.flow == j.cap)
ans[mp[{i, j.dst - D}]] = 'r';
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int w[500010], c[500010], a[500010], day;
long long ans;
double dot;
void qsort(int l, int r, int s) {
int first = (l + r) >> 1;
int i = l, j = r, m = c[first], v = w[first];
if (l == r) {
long long sum = m * 1LL * s;
ans += sum / v;
dot += (sum % v) * 1. / v;
return;
}
while (i <= j) {
while ((c[i]) * 1LL * v < w[i] * 1LL * m) i++;
while ((c[j]) * 1LL * v > w[j] * 1LL * m) j--;
if (i <= j) {
swap(c[i], c[j]);
swap(w[i], w[j]);
swap(a[i], a[j]);
i++, j--;
}
}
j = max(j, l);
long long sum = 0, cnt = 0;
for (int k = l; k <= j; k++) cnt += c[k], sum += w[k];
if (sum >= s)
qsort(l, j, s);
else
ans += cnt, qsort(j + 1, r, s - sum);
}
int main() {
int i, j, k, h, t;
int n, m, s;
while (~scanf("%d%d%d", &n, &m, &s)) {
for (i = 1; i <= m; i++) scanf("%d", &w[i]);
for (i = 1; i <= m; i++) scanf("%d", &c[i]);
for (i = 1; i <= m; i++) scanf("%d", &a[i]);
ans = 0;
dot = 0;
for (day = 0; day < n; day++) {
if (day)
for (j = 1; j <= m; j++) c[j] -= a[j];
qsort(1, m, s);
ans += (int)dot;
dot -= (int)dot;
}
char buff[20];
sprintf(buff, "%.15lf", dot);
printf("%I64d%s\n", ans, buff + 1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
string toStr(T s) {
ostringstream os;
os << s;
return os.str();
}
template <class T>
char* toCharArr(T n) {
char* s;
sprintf(s, "%ld", n);
return s;
}
int a[1010][1010];
int main() {
int n, m, x, y;
memset(a, 0, sizeof a);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
for (int j = -1; j <= 1; j++) {
for (int k = -1; k <= 1; k++) {
if ((++a[x + j][y + k]) == 9) {
cout << i;
return 0;
}
}
}
}
cout << -1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::string::size_type sz;
string s, t;
while (getline(cin, t)) {
s += t;
}
int plus = 0, minus = 0;
int size = s.size();
vector<int> v;
v.push_back(1);
string numx;
for (int i = 0; i < size; i++) {
if (s[i] == '+') {
plus++;
v.push_back(1);
}
if (s[i] == '-') {
minus++;
v.push_back(-1);
}
if (s[i] == '=') {
i = i + 1;
while (i < size) {
numx += s[i];
i++;
}
}
}
int num = stoi(numx);
int s1 = plus;
int s2 = minus;
int sum = plus - minus + 1;
if (!((num * (s1 + 1) - s2) >= num && ((s1 + 1) - num * s2) <= num)) {
cout << "Impossible";
} else {
cout << "Possible" << endl;
for (int i = 0; i < (int)v.size(); ++i) {
if (v[i] > 0) {
if (sum < num) {
v[i] = min(num, num - (sum - 1));
sum += min(num, num - (sum - 1)) - 1;
}
} else if (v[i] < 0) {
if (sum > num) {
v[i] = -min(num, (sum + 1) - num);
sum -= min(num, (sum + 1) - num) - 1;
}
}
}
}
if (sum == num) {
cout << v[0];
for (int i = 1; i < (int)v.size(); ++i) {
cout << " " << (v[i] > 0 ? '+' : '-') << " " << abs(v[i]);
}
cout << " = " << num;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100010], b[100010];
long long dp[100010], s[100010];
int res;
int main() {
for (int i = 0; i < 100010; i++) s[i] = 0LL;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
s[a[i]]++;
}
sort(a, a + n);
int e = -1;
for (int i = 0; i < n; i++) {
if (i == 0 || a[i] != b[e]) {
e++;
b[e] = a[i];
}
}
memset(dp, 0, sizeof(dp));
dp[0] = b[0] * s[b[0]];
dp[1] = b[1] * s[b[1]];
if (b[1] != b[0] + 1)
dp[1] += dp[0];
else
dp[1] = max(dp[1], dp[0]);
for (int i = 2; i <= e; i++) {
if (b[i] == b[i - 1] + 1) {
dp[i] = max(dp[i - 2] + 1LL * b[i] * s[b[i]], dp[i - 1]);
} else {
dp[i] = max(dp[i - 2] + 1LL * b[i] * s[b[i]],
dp[i - 1] + 1LL * b[i] * s[b[i]]);
}
}
printf("%I64d\n", dp[e]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using std::max;
using std::min;
const int N = 5010;
int n, m, p[N], mx, cnt[N];
int main() {
scanf("%d%d", &n, &m);
for (int a, b, i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
if (b < a) b += n;
++cnt[a];
mx = max(cnt[a], mx);
p[a] = p[a] ? min(p[a], b - a) : b - a;
}
int ans = (mx - 1) * n;
for (int i = 1; i <= n; i++) {
int yuu = 0;
for (int j = i; j <= n; j++) {
if (cnt[j] == mx)
yuu = max(yuu, j + p[j] - i);
else if (cnt[j] == mx - 1) {
int tp = j + p[j];
if (tp > n) tp -= n;
if (tp > j) continue;
yuu = max(yuu, tp - i);
}
}
for (int j = 1; j < i; j++) {
if (cnt[j] == mx)
yuu = max(yuu, j + p[j] + n - i);
else if (cnt[j] == mx - 1) {
int tp = j + p[j];
yuu = max(yuu, tp - i);
}
}
printf("%d ", ans + yuu);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[110][3];
int f[55][55][55][55];
bool dfs(int len, int a, int b, int c) {
if (len == 1) return 1;
if (f[len][a][b][c]) return 0;
if (s[c][0] == s[b][0] || s[c][1] == s[b][1])
if (dfs(len - 1, len - 3, a, c)) return 1;
if (len > 3 && (s[c][0] == s[len - 3][0] || s[c][1] == s[len - 3][1]))
if (dfs(len - 1, c, a, b)) return 1;
f[len][a][b][c] = 1;
return 0;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i];
if (dfs(n, n - 2, n - 1, n))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s1, s2, t1, t2, l1, l2, res;
vector<int> a[3005];
int que[3005], d[3005][3005];
bool dau[3005];
void bfs(int s) {
int las = 1, fir = 1;
que[1] = s;
d[s][s] = 0;
while (las >= fir) {
int u = que[fir++];
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i];
if (d[s][v] == -1) {
d[s][v] = d[s][u] + 1;
que[++las] = v;
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
}
scanf("%d%d%d", &s1, &t1, &l1);
scanf("%d%d%d", &s2, &t2, &l2);
memset(d, 255, sizeof(d));
for (int i = 1; i <= n; i++) bfs(i);
if (d[s1][t1] > l1 || d[s2][t2] > l2) {
cout << -1;
return 0;
}
res = m - (d[s1][t1] + d[s2][t2]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
int kc1 = min(d[i][s1] + d[j][t1], d[i][t1] + d[j][s1]) + d[i][j];
int kc2 = min(d[i][s2] + d[j][t2], d[i][t2] + d[j][s2]) + d[i][j];
if (kc1 <= l1 && kc2 <= l2) res = max(res, m - (kc1 + kc2 - d[i][j]));
}
printf("%d", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void _DBG(const char *s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _DBG(const char *s, _T x, args... a) {
while (*s != ',') cerr << *s++;
cerr << " = " << x << ',';
_DBG(s + 1, a...);
}
const int N = 2e6 + 7;
const int M = 1e9 + 7;
int n, m, last, ans[N], lex[N];
vector<pair<int, int> > G[N];
bool vis[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
last = n;
for (int j = 1; j <= m; j++) {
int a, b;
cin >> a >> b;
vector<int> v;
int x = j;
while (x > 0) {
v.push_back(x % 10);
x /= 10;
}
reverse((v).begin(), (v).end());
int from = a;
for (int i = 0; i + 1 < (int)(v).size(); i++) {
G[from].push_back({++last, v[i]});
from = last;
}
G[from].push_back({b, v.back()});
from = b;
for (int i = 0; i + 1 < (int)(v).size(); i++) {
G[from].push_back({++last, v[i]});
from = last;
}
G[from].push_back({a, v.back()});
}
vector<int> que = {1};
vis[1] = true;
while (!que.empty()) {
vector<pair<pair<int, int>, pair<int, int> > > vec;
for (auto v : que) {
for (auto [u, c] : G[v]) {
if (!vis[u]) {
vec.push_back({{lex[v], c}, {v, u}});
}
}
}
sort((vec).begin(), (vec).end());
que.clear();
pair<int, int> l = {-1, -1};
int no = 0;
for (auto [a, b] : vec) {
if (a != l) no++;
auto [v, u] = b;
if (!vis[u]) {
vis[u] = true;
que.push_back(u);
lex[u] = no;
ans[u] = (10LL * ans[v] + a.second) % M;
}
l = a;
}
}
for (int i = 2; i <= n; i++) cout << ans[i] << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct matrixType {
int r, c;
long long matrix[2][2];
};
long long k;
int n, m, mod;
long long s[50005];
long long a[50005];
long long v[50005];
int rk[50005];
matrixType qhy;
matrixType e[64];
matrixType st[50005 << 2];
long long f[50005];
matrixType d;
matrixType operator*(matrixType a, matrixType b) {
int i, j, k;
d.r = a.r;
d.c = b.c;
for (i = 0; i < d.r; i++)
for (j = 0; j < d.c; j++) {
d.matrix[i][j] = 0;
for (k = 0; k < a.c; k++)
d.matrix[i][j] =
(d.matrix[i][j] + a.matrix[i][k] * b.matrix[k][j] % mod) % mod;
}
return d;
}
bool cmp(int x, int y) { return a[x] < a[y]; }
void build_st(int x, int l, int r) {
if (l == r) {
st[x].c = st[x].r = 2;
st[x].matrix[0][0] = 0;
st[x].matrix[1][0] = 1;
st[x].matrix[0][1] = s[l];
st[x].matrix[1][1] = s[l + 1];
} else {
build_st((x << 1), l, ((l + r) >> 1));
build_st((x << 1 | 1), ((l + r) >> 1) + 1, r);
st[x] = st[(x << 1)] * st[(x << 1 | 1)];
}
}
void change_st(int x, int l, int r, int p, int v, bool flag) {
if (l == r) {
st[x].matrix[flag][1] = v;
} else {
if (p <= ((l + r) >> 1))
change_st((x << 1), l, ((l + r) >> 1), p, v, flag);
else
change_st((x << 1 | 1), ((l + r) >> 1) + 1, r, p, v, flag);
st[x] = st[(x << 1)] * st[(x << 1 | 1)];
}
}
void standing_by() {
int i;
scanf("%lld%d", &k, &mod);
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%lld", &s[i]);
s[n] = s[0];
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%lld%lld", &a[i], &v[i]);
rk[i] = i;
}
sort(rk + 1, rk + 1 + m, cmp);
qhy.r = 1;
qhy.c = 2;
qhy.matrix[0][0] = 0;
qhy.matrix[0][1] = 1;
build_st(1, 0, n - 1);
e[0] = st[1];
for (i = 1; i < 64; i++) e[i] = e[i - 1] * e[i - 1];
}
matrixType qp;
void qpow(long long y) {
int i;
for (i = 0; y; y >>= 1, i++)
if (y & 1) qhy = qhy * e[i];
}
void complete() {
long long l, r;
int i, j;
for (l = 0, i = 1; l < k - k % n; l = r) {
if (i <= m && a[rk[i]] <= k - k % n) {
r = a[rk[i]] / n * n;
if (a[rk[i]] % n == 0) r -= n;
if (r > l) {
qpow((r - l) / n);
l = r;
r += n;
} else
r = l + n;
} else {
r = k - k % n;
qpow((r - l) / n);
break;
}
for (j = i; j <= m && a[rk[j]] >= l && a[rk[j]] <= r; j++) {
if (a[rk[j]] < r) change_st(1, 0, n - 1, a[rk[j]] % n, v[rk[j]], 0);
if (a[rk[j]] > l)
change_st(1, 0, n - 1, (a[rk[j]] + n - 1) % n, v[rk[j]], 1);
}
qhy = qhy * st[1];
for (; i < j; i++) {
if (a[rk[i]] < r)
change_st(1, 0, n - 1, a[rk[i]] % n, s[a[rk[i]] % n], 0);
if (a[rk[i]] > l)
change_st(1, 0, n - 1, (a[rk[i]] + n - 1) % n, s[a[rk[i]] % n], 1);
if (a[rk[i]] == r) break;
}
}
f[0] = qhy.matrix[0][0];
f[1] = qhy.matrix[0][1];
for (j = 0; j <= k % n; j++)
if (i <= m && a[rk[i]] == k - k % n + j) {
s[j] = v[rk[i]];
i++;
}
for (j = 2; j <= k % n; j++)
f[j] = (f[j - 1] * s[j - 1] % mod + f[j - 2] * s[j - 2] % mod) % mod;
printf("%lld\n", f[k % n]);
}
int main() {
standing_by();
complete();
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main(){
int a, b, c, n;
int p[1111], m[1111], k[1111], q[1111];
int data[333];
while(true){
cin >> a >> b >> c;
if(!a && !b && !c) break;
for(int i=1;i<=a+b+c;i++) data[i] = 2;
cin >> n;
for(int i=0;i<n;i++) cin >> p[i] >> m[i] >> k[i] >> q[i];
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(q[j]) data[p[j]] = data[m[j]] = data[k[j]] = q[j];
else{
if(data[p[j]] == 1 && data[m[j]] == 1) data[k[j]] = 0;
if(data[m[j]] == 1 && data[k[j]] == 1) data[p[j]] = 0;
if(data[p[j]] == 1 && data[k[j]] == 1) data[m[j]] = 0;
}
}
}
for(int i=1;i<=a+b+c;i++) cout << data[i] << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int pos[201];
int m[201], cd;
void inp() {
cin >> cd;
cd = cd * 2;
for (int i = 1; i <= cd; i++) {
cin >> m[i];
pos[m[i]] = i;
}
}
void calc() {
int kq = 0;
for (int i = 1; i <= cd; i += 2) {
int h = 0;
for (int e = pos[m[i]] - 1; e >= i + 1; e--) {
kq++;
swap(m[e], m[e + 1]);
}
for (int i = 1; i <= cd; i++) pos[m[i]] = i;
}
cout << kq;
}
int main() {
inp();
calc();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
set<pair<int, int> > s1, s2;
pair<int, int> b[N];
int a[N];
void add(int ind) {
auto it = s1.upper_bound({ind, N});
pair<int, int> u = *--it;
s1.erase(u);
s2.erase({u.second - u.first + 1, u.first});
if (ind != u.first) {
s1.insert({u.first, ind - 1});
s2.insert({ind - u.first, u.first});
}
if (ind != u.second) {
s1.insert({ind + 1, u.second});
s2.insert({u.second - ind, ind + 1});
}
return;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, ans, loc;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = {a[i], i};
}
sort(b, b + n, greater<pair<int, int> >());
ans = b[0].first + 1, loc = 1;
s1.insert({0, n - 1});
s2.insert({n, 0});
for (int i = 0; i + 1 < n; i++) {
add(b[i].second);
if (s2.begin()->first == (--s2.end())->first) {
if (s1.size() > loc)
loc = s1.size(), ans = b[i + 1].first + 1;
else if (s1.size() == loc)
ans = b[i + 1].first + 1;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define M 1777771
#define N 100005
using namespace std;
typedef unsigned long long ull;
typedef pair<ull,int> P;
typedef long long ll;
ll n,a,b,maxd[N];
vector<int> G[N];
map<ull,ll> S;
ull A[N];
int get_maxd(int x,int d){
int res=d;
rep(i,G[x].size())
res=max(res,get_maxd(G[x][i],d+1));
return maxd[x]=res;
}
P dfs(int x,int d){
ull res1=0;
int res2=d;
rep(i,G[x].size()){
P r=dfs(G[x][i],d+1);
res1+=r.first*A[maxd[x]-r.second];
res2=max(res2,r.second);
}
res1+=A[res2-d];
if(S.count(res1))S[res1]++;
else S[res1]=1;
return P(res1,res2);
}
int main(){
cin>>n;
rep(i,n-1){
cin>>a>>b;
G[a-1].push_back(b-1);
}
A[0]=1;
for(int i=1;i<N;i++)A[i]=A[i-1]*M;
get_maxd(0,0);
dfs(0,0);
ll ans=0;
map<ull,ll>::iterator ite=S.begin();
while(ite!=S.end()){
if((*ite).second>=2)
ans+=(*ite).second*((*ite).second-1)/2;
ite++;
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define MAX_N 200000
using namespace std;
typedef double dnt;
typedef long long lnt;
template <class T> inline void read(T &x) {
x = 0; int c = getchar(), f = 1;
for (; !isdigit(c); c = getchar()) if (c == 45) f = -1;
for (; isdigit(c); c = getchar()) (x *= 10) += f*(c-'0');
}
int n, l, r, s[MAX_N+5]; lnt w, a[MAX_N+5], f[MAX_N+5];
dnt k(int p, int q) {return (dnt)(f[p]-f[q]+a[p]*a[p]-a[q]*a[q])/(dnt)(a[p]-a[q])/2;}
int main() {
read(n), read(w), s[0] = 1;
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 2; i <= n; s[++r] = i++) {
while (l < r && k(s[l+1], s[l]) <= (dnt)a[i]) l++;
f[i] = f[s[l]]+(a[i]-a[s[l]])*(a[i]-a[s[l]])+w;
while (l < r && k(s[r], s[r-1]) >= k(i, s[r])) r--;
}
return printf("%lld\n", f[n]), 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
struct Point {
int x, y;
} p[maxn], p1[maxn];
int n;
double getk(Point x, Point y) { return ((double)y.y - x.y) / (y.x - x.x); }
bool onetwo() {
double k = getk(p[1], p[2]);
int cnt = 0;
for (int i = 3; i <= n; i++) {
if (getk(p[1], p[i]) == k) continue;
p1[cnt++] = p[i];
}
if (!cnt) return false;
for (int i = 1; i < cnt; i++)
if (getk(p1[0], p1[i]) != k) return false;
return true;
}
bool onethree() {
double k = getk(p[1], p[3]);
int cnt = 0;
for (int i = 2; i <= n; i++) {
if (getk(p[1], p[i]) == k) continue;
p1[cnt++] = p[i];
}
if (!cnt) return false;
for (int i = 1; i < cnt; i++)
if (getk(p1[0], p1[i]) != k) return false;
return true;
}
bool twothree() {
double k = getk(p[2], p[3]);
int cnt = 0;
if (getk(p[1], p[2]) != k) p1[cnt++] = p[1];
for (int i = 4; i <= n; i++) {
if (getk(p[2], p[i]) == k) continue;
p1[cnt++] = p[i];
}
if (!cnt) return false;
for (int i = 1; i < cnt; i++)
if (getk(p1[0], p1[i]) != k) return false;
return true;
}
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) scanf("%d", &p[i].y), p[i].x = i;
if (onetwo() || onethree() || twothree())
puts("Yes");
else
puts("No");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dadsadasda;
const int INF = 0x3f3f3f3f;
const long long LLINF = 1e18;
const int MAXN = 1e5 + 10;
int n, m, k;
vector<int> G[MAXN];
int deg[MAXN];
bool erased[MAXN];
queue<int> pos_cliq, pos_set;
void erase(int v) {
erased[v] = true;
for (auto u : G[v]) {
if (erased[u]) continue;
m--;
deg[u]--;
if (deg[u] < k - 1) erase(u);
}
}
void erase2(int v) {
erased[v] = true;
for (auto u : G[v]) {
if (erased[u]) continue;
deg[u]--;
if (deg[u] < k - 1) erase2(u);
if (deg[u] == k - 1) pos_cliq.push(u);
}
}
bool check_clique(int a) {
long long aux = k;
aux = (aux * (aux - 1)) >> 1;
if (aux > (long long)m) return false;
for (auto b : G[a]) {
if (erased[b]) continue;
int found = 0;
for (auto c : G[a]) {
if (erased[c]) continue;
auto it = lower_bound(G[b].begin(), G[b].end(), c);
if (it == G[b].end()) continue;
if (*it == c) found++;
}
if (found < k - 2) return false;
}
printf("2\n");
printf("%d ", a + 1);
for (auto b : G[a]) {
if (erased[b]) continue;
printf("%d ", b + 1);
}
printf("\n");
return true;
}
void solve() {
dadsadasda = scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < m; i++) {
int a, b;
dadsadasda = scanf("%d %d", &a, &b);
a--, b--;
G[a].push_back(b);
G[b].push_back(a);
deg[a]++, deg[b]++;
}
long long aux = k;
aux = (aux * (aux - 1)) >> 1;
if (aux > m) {
printf("-1\n");
return;
}
for (int i = 0; i < n; i++) {
if (!erased[i] && deg[i] < k - 1) erase(i);
}
for (int i = 0; i < n; i++) {
sort(G[i].begin(), G[i].end());
if (deg[i] == k - 1)
pos_cliq.push(i);
else
pos_set.push(i);
}
while (!pos_cliq.empty()) {
int v = pos_cliq.front();
pos_cliq.pop();
if (erased[v]) continue;
if (check_clique(v))
return;
else
erase2(v);
}
while (!pos_set.empty()) {
int v = pos_set.front();
pos_set.pop();
if (erased[v]) continue;
vector<int> ans;
for (int i = 0; i < n; i++) {
if (!erased[i]) ans.push_back(i);
}
printf("%d %d\n", 1, (int)ans.size());
for (auto x : ans) {
printf("%d ", x + 1);
}
printf("\n");
return;
}
printf("-1\n");
}
int main() {
int t;
dadsadasda = scanf("%d", &t);
while (t--) {
solve();
for (int i = 0; i < n; i++) {
erased[i] = false;
G[i].clear();
deg[i] = 0;
while (!pos_set.empty()) pos_set.pop();
while (!pos_cliq.empty()) pos_cliq.pop();
}
}
return 0;
}
| 2 |
#include <iostream>
#include <string>
int main()
{
std::string s;
std::cin >> s;
std::cout << s.substr(0, 4) << " " << s.substr(4, 13) << std::endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e9;
const long long infll = 1e18;
double eps = 0.0000001;
ifstream in("input.txt");
ofstream out("output.txt");
;
long long n;
vector<long long> c;
vector<long long> t;
void init() {
cin >> n;
c.resize(n);
t.resize(n);
for (long long i = 0; i < n; i++) cin >> c[i];
for (long long i = 0; i < n; i++) cin >> t[i];
}
void solve() {
multiset<long long> razn1, razn2;
for (long long i = 0; i < n - 1; i++) {
razn1.insert(c[i + 1] - c[i]);
razn2.insert(t[i + 1] - t[i]);
}
if (razn1 == razn2 && c[0] == t[0] && c[n - 1] == t[n - 1])
cout << "Yes";
else
cout << "No";
}
signed main() {
init();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma optimize("Ofast")
using namespace std;
int t, n, m, ql, qr;
struct node {
int val, add;
} tree[400005];
void push_up(int pos) {
tree[pos].val = tree[pos << 1].val & tree[pos << 1 | 1].val;
}
void push_down(int pos) {
if (tree[pos].add) {
tree[pos << 1].val |= tree[pos].add;
tree[pos << 1].add |= tree[pos].add;
tree[pos << 1 | 1].val |= tree[pos].add;
tree[pos << 1 | 1].add |= tree[pos].add;
tree[pos].add = 0;
}
}
void UPD(int pos, int l, int r, int v) {
if (l > qr || r < ql) return;
if (tree[pos].val == r - l + 1) return;
if (ql <= l && r <= qr) {
tree[pos].val |= v;
tree[pos].add |= v;
return;
}
push_down(pos);
int mid = (l + r) >> 1;
if (ql <= mid) UPD(pos << 1, l, mid, v);
if (mid < qr) UPD(pos << 1 | 1, mid + 1, r, v);
push_up(pos);
return;
}
int query(int pos, int l, int r) {
if (ql <= l && r <= qr) {
return tree[pos].val;
}
push_down(pos);
int mid = (l + r) >> 1, res = (1 << 30) - 1;
if (ql <= mid) res &= query(pos << 1, l, mid);
if (mid < qr) res &= query(pos << 1 | 1, mid + 1, r);
push_up(pos);
return res;
}
map<pair<long long, long long>, int> mp;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
int a, b, c, ok = 1;
while (m--) {
cin >> a >> b >> c;
if (mp.count({a, b})) {
if (mp[{a, b}] != c) ok = 0;
}
mp[{a, b}] = c;
if (!ok) continue;
ql = a;
qr = b;
int now = query(1, 1, n);
if ((c & now) == now)
UPD(1, 1, n, c - now);
else
ok = 0;
}
if (!ok)
cout << "NO\n";
else {
cout << "YES\n";
for (int i = 1; i <= n; i++) {
ql = qr = i;
cout << query(1, 1, n) << ' ';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, comp = 0, a[100005], b[100005], v[100005];
bool vis[100005];
set<int> s[100005];
void dfs(int u) {
if (vis[u]) return;
vis[u] = true;
s[comp].insert(u);
dfs(v[u]);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
for (int i = 0; i < n; i++) {
int l = 0, r = n - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (b[mid] == a[i]) {
v[i] = mid;
break;
} else if (b[mid] < a[i]) {
l = mid + 1;
} else {
r = mid - 1;
}
}
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
dfs(i);
comp++;
}
}
cout << comp << endl;
for (int i = 0; i < comp; i++) {
cout << s[i].size();
for (set<int>::iterator it = s[i].begin(); it != s[i].end(); it++) {
cout << ' ' << (*it + 1);
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long solve() {
long long n;
cin >> n;
vector<long long> v(n);
multiset<long long> s;
for (long long &i : v) {
cin >> i;
s.insert(i);
}
while (s.size() >= 2) {
auto it = s.begin(), it1 = s.end();
it1--;
if (*it1 - *it <= 1) return (*it1 - *it);
long long x = *it, y = *it1;
s.erase(it);
s.erase(it1);
if ((x + y) & 1) {
s.insert((x + y) / 2);
s.insert((x + y) / 2 + 1);
} else {
s.insert((x + y) / 2);
s.insert((x + y) / 2);
}
}
return 0;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) cout << solve() << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void read_input() {}
long long int b[2001][2001];
long long int c[2001][2001];
void solving() {
int n, m, k, x, y;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> x >> y;
if (c[x][y] == 0) {
cout << x << " " << y << "\n";
c[x][y] = 1;
continue;
}
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++) {
int u = b[x + i][y + i] - max(i, -i) - max(j, -j);
if (u > b[x][y]) b[x][y] = u - 1;
}
for (int d = b[x][y];; d++) {
for (int x2 = max(1, x - d); x2 <= min(x + d, n); x2++) {
int d2 = d - max(x - x2, x2 - x);
if (y - d2 > 0 && (c[x2][y - d2] == 0)) {
cout << x2 << " " << y - d2 << "\n";
c[x2][y - d2] = 1;
b[x][y] = d;
goto abc;
}
if ((y + d2 < m + 1) && (c[x2][y + d2] == 0)) {
cout << x2 << " " << (y + d2) << "\n";
c[x2][y + d2] = 1;
b[x][y] = d;
goto abc;
}
}
}
abc:;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
read_input();
int t = 1;
for (int i = 1; i <= t; i++) {
solving();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, c;
cin >> n >> m >> c;
vector<long long> a(n);
vector<long long> b(m);
vector<long long> ans(n);
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < m; i++) cin >> b[i];
for (long long i = 0; i < b.size(); i++) {
ans[i] += b[i];
if (i < m - 1) ans[i + n - m + 1] += -1 * b[i];
}
for (long long i = 1; i < n; i++) ans[i] = ans[i] + ans[i - 1];
for (long long i = 0; i < n; i++) ans[i] = (a[i] + ans[i]) % c;
for (auto i : ans) cout << i << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
int a[n];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int height = 1;
if (a[0]) height++;
for (int i = 1; i < n; i++) {
if (!a[i] && !a[i - 1]) {
height = 0;
break;
} else if (a[i] && a[i - 1])
height += 5;
else if (a[i] && !a[i - 1])
height++;
}
if (height)
printf("%d\n", height);
else
printf("-1\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline void kmp(const char *s, int *p, int n) {
p[0] = -1;
for (int i = 1; i < n; i++) {
int x = p[i - 1];
while (x != -1 && s[x + 1] != s[i]) {
x = p[x];
}
if (s[x + 1] == s[i]) {
p[i] = x + 1;
} else {
p[i] = -1;
}
}
for (int i = 0; i < n; i++) p[i]++;
}
inline void kmp(const char *s, int *p) { kmp(s, p, strlen(s)); }
inline void findAllOccurrences(const char *where, int size_where,
const char *what, int size_what,
std::vector<int> &result) {
int total_size = size_what + size_where + 1;
char *s = new char[total_size + 1];
int *p = new int[total_size];
for (int i = 0; i < size_what; i++) s[i] = what[i];
s[size_what] = '$';
for (int i = 0; i < size_where; i++) s[i + 1 + size_what] = where[i];
s[total_size] = 0;
kmp(s, p);
for (int i = size_what + 1; i < total_size; i++) {
if (p[i] == size_what) {
result.push_back(i - 2 * size_what);
}
}
delete (s);
delete (p);
}
const int MOD = 1e9 + 7;
const int N = 211111;
char s[N], t[N];
int dp[N], cdp[N];
int main() {
vector<int> ocs;
gets(s);
gets(t);
int n = strlen(s), m = strlen(t);
findAllOccurrences(s, n, t, m, ocs);
if ((int)(ocs.size()) == 0) {
cout << 0 << endl;
return 0;
}
memset(dp, 0, sizeof(dp));
memset(cdp, 0, sizeof(cdp));
dp[n] = 1;
cdp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
int l = -1, r = (int)(ocs.size()) - 1;
while (r - l > 1) {
int tt = (l + r) / 2;
if (ocs[tt] < i) {
l = tt;
} else {
r = tt;
}
}
assert(r >= 0 && r < ocs.size());
if (i <= ocs[r]) {
dp[i] = (cdp[ocs[r] + m] + dp[i + 1]) % MOD;
} else {
dp[i] = 1;
}
cdp[i] = (cdp[i + 1] + dp[i]) % MOD;
}
cout << (dp[0] - 1 + MOD) % MOD << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110, M = 110;
int a[N][M];
bool comp(pair<int, int> x, pair<int, int> y) {
return a[x.first][x.second] < a[y.first][y.second];
}
int n, m;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, -1, 0, 1};
bool sos(int x, int y) {
for (int i = (0); i < (4); ++i) {
if (dx[i] + x < n && 0 <= dx[i] + x && dy[i] + y < m && 0 <= dy[i] + y) {
if (a[dx[i] + x][dy[i] + y] == a[x][y]) return true;
}
}
return false;
}
void solve() {
cin >> n >> m;
vector<pair<int, int>> v;
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) {
cin >> a[i][j];
v.push_back(make_pair(i, j));
}
sort((v).begin(), (v).end(), comp);
int col = 1, pc = -1;
for (int i = (0); i < ((int)(v.size())); ++i) {
int x = v[i].first, y = v[i].second;
if ((a[x][y] != pc)) col ^= 1, pc = a[x][y];
if (sos(x, y) && (col == (x + y) % 2)) a[x][y]++;
}
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (m); ++j) cout << a[i][j] << ' ';
cout << "\n";
}
cout << "\n";
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx2")
using namespace std;
const long long maxn = 5e5 + 5, MOD = 998244353;
long long ans[maxn], dp[maxn];
bool ma[maxn][31];
long long one[maxn], zero[maxn];
long long F[maxn + 1];
void add(long long pos, long long x) {
if (!pos) {
F[0] += x;
return;
}
for (; pos <= maxn; pos += pos & -pos) F[pos] += x;
}
long long get(long long l, long long r) {
if (l != 1)
return (get(1, r) - get(1, l - 1) + (l == 0 ? F[0] : 0) + 5ll * MOD) % MOD;
long long res = 0;
for (; r > 0; r -= r & -r) res += F[r];
return res % MOD;
}
signed de[maxn];
struct event {
signed L, R, B;
};
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k, m;
cin >> n >> k >> m;
long long ANS = 1;
vector<event> V;
for (long long i = 0; i < m; i++) {
signed L, R, X;
cin >> L >> R >> X;
V.push_back({L, R, X});
for (long long j = 0; j < k; j++) ma[i][j] = (X >> j & 1);
}
for (long long i = 0; i < k; i++) {
memset(F, 0, sizeof F);
memset(one, 0, sizeof one);
memset(zero, 0, sizeof zero);
memset(de, 0, sizeof de);
long long ans = 1;
for (long long j = 0; j < m; j++) {
if (ma[j][i])
one[V[j].L]++, one[V[j].R + 1]--;
else
de[V[j].R] = max(de[V[j].R], V[j].L);
}
signed LAST = 0;
for (long long j = 0; j <= maxn; j++) assert(F[j] == 0);
add(0, 1);
long long one_ = 0;
for (long long j = 1; j <= n; j++) {
one_ += one[j];
if (!one_) add(j, get(LAST, j - 1));
LAST = max(LAST, de[j]);
}
ANS *= get(LAST, n);
ANS %= MOD;
}
cout << ANS;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
long long n,sum[100001],pr[100001],ans;
std::map <long long,int>ps;
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>sum[i];pr[i]=sum[i];
}
sort(pr+1,pr+n+1);
for(int i=1;i<=n;i++)
ps[pr[i]]=i;
for(int i=1;i<=n;i++)
if(i%2!=ps[sum[i]]%2)
ans++;
ans/=2;
cout<<ans;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s, tmp;
void in(string s) {
for (int i = 1; i <= 4 - s.size(); i++) cout << 0;
cout << s;
}
int main() {
scanf("%d\n", &n);
for (int i = 1; i <= n; i++) {
getline(cin, s);
list<string> a, b;
int j = s.find("::", 0);
if (j == -1) j = s.size();
tmp = "";
for (int k = 0; k < j; k++)
if (s[k] == ':') {
a.push_back(tmp);
tmp = "";
} else
tmp.push_back(s[k]);
if (tmp != "") a.push_back(tmp);
tmp = "";
for (int k = j + 2; k < s.size(); k++)
if (s[k] == ':') {
b.push_back(tmp);
tmp = "";
} else
tmp.push_back(s[k]);
if (tmp != "") b.push_back(tmp);
vector<string> ans;
for (typeof(a.begin()) it = a.begin(); it != a.end(); it++)
ans.push_back(*it);
for (int j = 1; j <= 8 - (int)a.size() - (int)b.size(); j++)
ans.push_back("0");
for (typeof(b.begin()) it = b.begin(); it != b.end(); it++)
ans.push_back(*it);
for (int j = 0; j < ans.size(); j++) {
if (j < 7) {
in(ans[j]);
cout << ":";
} else {
in(ans[j]);
cout << endl;
}
}
}
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main() {
int x;
cin >> x;
cout << (x==7 || x==5 || x==3 ? "YES": "NO");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b,c,x,y;
cin>>a>>b>>c>>x>>y;
int z=max(x,y);
int min1 = 1e10;
for(int i=0;i<=z;i++){
int d = 2*c*i + a * max(0,x-i) + b * max(0,y-i);
min1 = min(min1, d);
}
cout<<min1<<endl;
} | 0 |
#include <iostream>
using namespace std;
int main(){
string str,str2;
while( cin >> str >> str2,(str[0] - '0')+(str2[0] - '0') ){
int hit = 0,brow = 0;
for(int i = 0 ; i < str.size() ; i++){
if(str[i] == str2[i])hit++;
}
for(int i = 0 ; i < 4 ; i++ ){
for(int j = 0 ; j < 4 ; j++ ){
if(str[i] == str2[j])brow++;
}
}
cout << hit << " " << brow - hit << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int pp(int *a, int p, int r) {
int x = a[r], i = p - 1, buf;
for (int j = p; j < r; ++j)
if (a[j] < x) {
i++;
buf = a[i];
a[i] = a[j];
a[j] = buf;
}
if (a[i + 1] != a[r]) {
buf = a[i + 1];
a[i + 1] = a[r];
a[r] = buf;
}
return i + 1;
}
void sort(int *a, int p, int r) {
if (p < r) {
int q = pp(a, p, r);
sort(a, p, q - 1);
sort(a, q + 1, r);
}
}
int main() {
int n, a, *b, kol = 0, kol1 = 0;
scanf("%d", &n);
b = new int[100];
for (int i = 0; i < 100; i++) b[i] = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a);
b[a - 1]++;
}
for (int i = 0; i < 100; i++) {
kol += b[i] / 4;
b[i] -= b[i] / 4 * 4;
}
for (int i = 0; i < 100; i++)
if (b[i] >= 2) kol1++;
kol += kol1 / 2;
printf("%d", kol);
delete[] b;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dp[100005][2];
string s;
void solve() {
cin >> s;
memset(dp, 0, sizeof(dp));
int ans1, ans2;
for (int i = 1; i <= (int)s.size(); i++) {
if (s[i - 1] <= 90)
dp[i][0] = dp[i - 1][0];
else
dp[i][0] = dp[i - 1][0] + 1;
if (s[i - 1] >= 97)
dp[i][1] = dp[i - 1][1];
else
dp[i][1] = min(dp[i - 1][1] + 1, dp[i][0]);
}
cout << dp[(int)s.size()][1] << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(NULL);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string top = "qwertyuiop", mid = "asdfghjkl;", bottom = "zxcvbnm,./", s;
char pos;
cin >> pos;
cin >> s;
if (pos == 'L') {
for (int i = 0; i < s.length(); i++) {
for (int j = 9; j >= 0; j--) {
if (s[i] == top[j]) {
s[i] = top[j + 1];
}
if (s[i] == mid[j]) {
s[i] = mid[j + 1];
}
if (s[i] == bottom[j]) {
s[i] = bottom[j + 1];
}
}
}
} else {
for (int x = 0; x < s.length(); x++) {
for (int y = 0; y < 10; y++) {
if (s[x] == top[y]) {
s[x] = top[y - 1];
} else if (s[x] == mid[y]) {
s[x] = mid[y - 1];
} else if (s[x] == bottom[y]) {
s[x] = bottom[y - 1];
}
}
}
}
cout << s;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[43][3][3];
long long cost[3][3];
int main(void) {
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) {
cin >> cost[i][j];
dp[0][i][j] = 0;
}
int n;
cin >> n;
for (int s = 1; s <= n; s++) {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
int c = 3 - (i + j);
long long a = dp[s - 1][i][c] + cost[i][j] + dp[s - 1][c][j];
long long b = dp[s - 1][i][j] + cost[i][c] + dp[s - 1][j][i] +
cost[c][j] + dp[s - 1][i][j];
dp[s][i][j] = min(a, b);
}
}
}
}
cout << dp[n][0][2] << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (scanf("%d", &n) != EOF) {
int x;
int res = 1;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
if (x == 1) {
res = -1;
}
}
printf("%d\n", res);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 9, mod = 1e9 + 7, inf = 1e18;
vector<pair<long long, long long>> vc[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
bool f = true;
for (int i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
vc[u].push_back({v, i});
vc[v].push_back({u, i});
if (vc[v].size() > 2 || vc[u].size() > 2) f = false;
}
if (f)
for (int i = 0; i < n - 1; i++) cout << i << "\n";
else {
for (int i = 1; i <= n; i++) {
if (vc[i].size() > 2) {
int ed[n + 3], nd = 0;
memset(ed, -1, sizeof ed);
for (auto x : vc[i]) ed[x.second] = nd++;
for (int i = 0; i < n - 1; i++)
if (ed[i] == -1) ed[i] = nd++;
for (int i = 0; i < n - 1; i++) cout << ed[i] << "\n";
return 0;
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define maxn 200000
int n, cnt, fa[maxn];
set <int> E[maxn];
int read() {
int x = 0, k = 1;
char c; c = getchar();
while(c < '0' ||c > '9') { if(c == '-') k = -1; c = getchar(); }
while(c >= '0' &&c <= '9') x = x * 10 + c - '0', c = getchar();
return x * k;
}
struct node {
int u, v;
node(int a = 0, int b = 0) {
u = a, v = b;
}
}; queue <node> q;
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
int main() {
n = read(); int t = (n - 1) * 2;
for(int i = 1; i <= t; i ++) {
int u = read(), v = read();
if(!E[u].count(v)) E[u].insert(v), E[v].insert(u);
else q.push(node(u, v));
}
for(int i = 1; i <= n; i ++) fa[i] = i;
while(!q.empty()) {
node now = q.front(); q.pop(); cnt ++;
int x = find(now.u), y = find(now.v);
if(E[x].size() < E[y].size()) swap(x, y);
for(set <int> :: iterator it = E[y].begin(); it != E[y].end(); it ++)
if(*it != x) {
int u = x, v = *it;
E[v].erase(y);
if(!E[u].count(v)) E[u].insert(v), E[v].insert(u);
else q.push(node(u, v));
}
E[x].erase(y), fa[y] = x;
}
if(cnt == n - 1) puts("YES");
else puts("NO");
return 0;
} | 0 |
#include <bits/stdc++.h>
int add(int num) {
int sum = 0;
while (num > 0) {
sum += num % 10;
num /= 10;
}
return sum;
}
int main() {
int num, i, num1, flag = 1;
scanf("%d", &num);
while (flag) {
if (add(num) % 4 == 0) {
printf("%d", num);
flag = 0;
} else
num++;
}
}
| 1 |
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int b;
cin>>b;
cout<<"ABC"<<b;
}
| 0 |
#include<stdio.h>
#include<stdlib.h>
struct node{
struct node *right;
struct node *left;
struct node *parent;
int key;
};
typedef node* Node;
#define NIL NULL
node array[500000];
int size=0;
Node root = NIL;
Node treeMinimum(Node x){
while(x->left!=NIL)x=x->left;
return x;
}
Node treeSearch(Node u, int k){
Node i=u;
while(i!=NIL){
if(i->key==k)return i;
else if(i->key<k)i=i->right;
else i=i->left;
}
return NIL;
}
Node treeSuccessor(Node x){
if(x->right!=NIL)return treeMinimum(x->right);
Node y=x->parent;
while(y!=NIL&&x==y->right){
x=y;
y=y->parent;
}
return y;
}
void treeDelete(Node z){
Node y;
Node x;
if(z->left==NIL||z->right==NIL)y=z;
else y=treeSuccessor(z);
if(y->left!=NIL)x=y->left;
else x=y->right;
if(x!=NIL)x->parent=y->parent;
if(y->parent==NIL)root=x;
else if(y==y->parent->left)y->parent->left=x;
else y->parent->right=x;
if(y!=z)z->key=y->key;
}
void insert(int k){
Node y = NIL;
Node x = root;
Node z;
z = &array[size++];
z->key = k;
z->left = NIL;
z->right = NIL;
while(x!=NIL){
y=x;
if(z->key<x->key)x=x->left;
else x=x->right;
}
z->parent=y;
if(y==NIL)root=z;
else if(z->key<y->key)y->left=z;
else y->right=z;
}
void inorder(Node u){
if(u==NIL)return;
inorder(u->left);
printf(" %d",u->key);
inorder(u->right);
}
void preorder(Node u){
if(u==NIL)return;
printf(" %d",u->key);
preorder(u->left);
preorder(u->right);
}
int main(){
int n,x;
char str[20];
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%s", str);
if(str[0]=='f'){
scanf("%d",&x);
Node t=treeSearch(root,x);
if (t!=NIL) printf("yes\n");
else printf("no\n");
}else if(str[0]=='i'){
scanf("%d",&x);
insert(x);
}else if(str[0]=='p'){
inorder(root);
printf("\n");
preorder(root);
printf("\n");
}else if(str[0]=='d'){
scanf("%d",&x);
treeDelete(treeSearch(root,x));
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void yala_bena() {
cin.tie(0);
std::ios::sync_with_stdio(0);
}
const int m_r = 199999;
double pii = 3.1415926536;
int main() {
yala_bena();
double a, b, c, d, ans1, ans2;
cin >> a >> b >> c >> d;
ans1 = (double)a / b;
ans2 = (double)(1 - c / d) * (1 - a / b);
cout << fixed << setprecision(12) << (double)ans1 / (1 - ans2) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
const int LIM = 100;
struct Node {
int val;
int order;
int cnt;
Node *left, *right;
bool vis;
};
typedef Node *NodeP;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
Node mem[2 * MAXN + 7];
int last_mem = 0;
deque<NodeP> trash_bin;
NodeP new_node(int val) {
NodeP temp;
if (trash_bin.size() > 0) {
temp = trash_bin.back();
trash_bin.pop_back();
} else {
mem[last_mem].order = uniform_int_distribution<int>(0, 1e9)(rng);
temp = &mem[last_mem];
last_mem++;
}
temp->val = val;
temp->cnt = 1;
temp->left = NULL;
temp->right = NULL;
temp->vis = false;
return temp;
}
void delete_node(NodeP temp) { trash_bin.push_back(temp); }
int cnt(NodeP t) {
if (!t) {
return 0;
}
return t->cnt;
}
void update_cnt(NodeP t) {
if (t) {
t->cnt = cnt(t->left) + 1 + cnt(t->right);
}
}
void split(NodeP t, NodeP &l, NodeP &r, int x, int add) {
if (t == NULL) {
l = NULL;
r = NULL;
} else {
int key = add + 1 + cnt(t->left);
if (key >= x) {
split(t->left, l, t->left, x, add);
r = t;
} else {
split(t->right, t->right, r, x, add + 1 + cnt(t->left));
l = t;
}
}
update_cnt(t);
}
void merge(NodeP &t, NodeP l, NodeP r) {
if (l == NULL) {
t = r;
} else if (r == NULL) {
t = l;
} else {
if (l->order > r->order) {
merge(l->right, l->right, r);
t = l;
} else {
merge(r->left, l, r->left);
t = r;
}
}
update_cnt(t);
}
void insert(NodeP &t, NodeP x, int xkey) {
if (t == NULL) {
t = x;
} else {
NodeP t1, t2;
split(t, t1, t2, xkey, 0);
merge(t, t1, x);
merge(t, t, t2);
}
update_cnt(t);
}
void erase(NodeP &t, int xkey, int add) {
if (t != NULL) {
int key = add + 1 + cnt(t->left);
if (key == xkey) {
NodeP temp = t;
merge(t, t->left, t->right);
delete_node(temp);
} else if (key > xkey) {
erase(t->left, xkey, add);
} else {
erase(t->right, xkey, add + 1 + cnt(t->left));
}
}
update_cnt(t);
}
int calc(NodeP t, int len) {
if (t) {
return max(calc(t->left, len + 1), calc(t->right, len + 1));
}
return len;
}
NodeP root = NULL;
bool numbers[MAXN + 7];
int last = 1;
bool move(int x, int y) {
if (root != NULL) {
NodeP t = root;
while (t->left != NULL) {
t = t->left;
}
if (numbers[y] == true and t->val != y) {
return false;
} else if (numbers[y] == false and t->val != -1) {
return false;
}
}
erase(root, 1, 0);
NodeP temp = new_node(y);
insert(root, temp, x);
numbers[y] = true;
return true;
}
void print() {
stack<NodeP> st;
st.push(root);
while (st.size() > 0) {
NodeP t = st.top();
t->vis = true;
if (t->left and t->left->vis == false) {
st.push(t->left);
continue;
}
st.pop();
if (t->val != -1) {
printf("%d ", t->val);
} else {
while (numbers[last] == true) {
last++;
}
printf("%d ", last);
last++;
}
if (t->right) {
st.push(t->right);
}
}
}
int x[MAXN + 7];
int y[MAXN + 7];
void heapify(NodeP &root) {
NodeP maxnode = root;
if (root->left and root->left->order > maxnode->order) {
maxnode = root->left;
}
if (root->right and root->right->order > maxnode->order) {
maxnode = root->right;
}
if (maxnode != root) {
swap(root->order, maxnode->order);
heapify(maxnode);
}
}
void build(NodeP &root, int ss, int se) {
if (ss > se) {
return;
}
root = new_node(-1);
if (ss != se) {
int mid = (ss + se) >> 1;
build(root->left, ss, mid - 1);
build(root->right, mid + 1, se);
}
update_cnt(root);
heapify(root);
}
int main() {
int n, m;
cin >> n >> m;
build(root, 1, n);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x[i], &y[i]);
}
for (int i = m; i >= 1; i--) {
if (!move(y[i], x[i])) {
printf("-1\n");
return 0;
}
}
print();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool prime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
int main() {
long long n, ans;
cin >> n;
if (prime(n))
ans = 1;
else if (n % 2 == 0)
ans = 2;
else if (prime(n - 2))
ans = 2;
else
ans = 3;
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,i;cin>>N;
while(N){
i=1;
while(i*(i+1)/2<N)i++;
cout<<i<<endl;N-=i;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
double n,x;
int main(){
cin>>n>>x;
cout<<n / x<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void start(vector<int> &arr, pair<char, int> &prefAns, pair<char, int> &sufAns,
string &s) {
int i;
for (i = 0; i < s.size(); ++i) {
int cnt = 0;
while (i + 1 != s.size() && s[i] == s[i + 1]) {
++cnt;
++i;
}
arr[s[i]] = max(arr[s[i]], cnt + 1);
}
i = 0;
while (i + 1 != s.size() && s[i] == s[i + 1]) {
++i;
}
prefAns = {s[0], i + 1};
i = s.size() - 1;
while (i - 1 != -1 && s[i] == s[i - 1]) {
--i;
}
sufAns = {s[s.size() - 1], s.size() - i};
}
char same(string &s) {
int res = s[0];
for (auto c : s) {
if (res != c) {
return -1;
}
}
return res;
}
void relax(vector<int> &ans, pair<char, int> &prefAns, pair<char, int> &sufAns,
string &s) {
for (auto c : s) {
ans[c] = max(ans[c], (sufAns.first == c) * sufAns.second + 1 +
(prefAns.first == c) * prefAns.second);
}
}
int max(vector<int> &arr) {
int res = 0;
for (auto elem : arr) {
res = max(res, elem);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<string> arr(n);
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
vector<int> ans('z' + 1);
pair<char, int> prefAns;
pair<char, int> sufAns;
start(ans, prefAns, sufAns, arr[n - 1]);
bool flag = (same(arr[n - 1]) != -1);
for (int i = n - 2; i >= 0; --i) {
char c = same(arr[i]);
if (flag && (c != arr[n - 1][0])) {
c = arr[n - 1][0];
vector<int> tmpAns('z' + 1);
pair<char, int> tmpPrefAns;
pair<char, int> tmpSufAns;
start(tmpAns, tmpPrefAns, tmpSufAns, arr[i]);
ans[c] = ans[c] * (tmpAns[c] + 1) + tmpAns[c];
if (tmpPrefAns.first == c) {
prefAns = {
c, prefAns.second * (tmpPrefAns.second + 1) + tmpPrefAns.second};
}
if (tmpSufAns.first == c) {
sufAns = {c, sufAns.second * (tmpSufAns.second + 1) + tmpSufAns.second};
}
flag = false;
continue;
}
if (flag) {
ans[c] = ans[c] * (arr[i].size() + 1) + arr[i].size();
prefAns = {c, ans[c]};
sufAns = {c, ans[c]};
} else {
relax(ans, prefAns, sufAns, arr[i]);
}
}
cout << max(ans) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 50;
int n, m, S, dfn[N], idfn[N], cnt, ff[N], fa[N], g[N], st[N], tp, l[N], dep[N],
f[N][20], d[N], sz[N];
long long dis[N];
bool vis[N];
int ver[N * 2], edge[N * 2], nxt[N * 2], head[N], tot;
void add(int x, int y, int z) {
ver[++tot] = y;
edge[tot] = z;
nxt[tot] = head[x];
head[x] = tot;
}
struct node1 {
int x;
long long d;
bool friend operator<(node1 a, node1 b) { return a.d > b.d; }
};
priority_queue<node1> q;
struct node {
int ver[N * 2], nxt[N * 2], head[N], d[N], tot;
void add(int x, int y) {
ver[++tot] = y;
nxt[tot] = head[x];
head[x] = tot;
d[y]++;
}
} A, B, C;
int find(int x) {
if (fa[x] == x) return x;
int f = fa[x];
fa[x] = find(fa[x]);
g[x] = min(g[x], g[f]);
return fa[x];
}
void dfs(int x) {
idfn[dfn[x] = ++cnt] = x;
for (int i = A.head[x], y; i; i = A.nxt[i])
if (!dfn[y = A.ver[i]]) C.add(x, y), ff[y] = x, dfs(y);
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 18; ~i; i--)
if (dep[f[x][i]] >= dep[y]) x = f[x][i];
if (x == y) return x;
for (int i = 18; ~i; i--)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
int main() {
scanf("%d%d%d", &n, &m, &S);
for (int i = 1, x, y, z; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
add(x, y, z), add(y, x, z);
}
memset(dis, 0x3f, sizeof(dis));
q.push((node1){S, 0});
dis[S] = 0;
while (q.size()) {
int x = q.top().x;
q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (int i = head[x], y; i; i = nxt[i])
if (dis[y = ver[i]] > dis[x] + edge[i])
dis[y] = dis[x] + edge[i], q.push((node1){y, dis[y]});
}
for (int i = 1; i <= n; i++)
for (int j = head[i]; j; j = nxt[j])
if (dis[ver[j]] == dis[i] + edge[j]) A.add(i, ver[j]), B.add(ver[j], i);
dfs(S);
for (int i = 1; i <= n; i++) fa[i] = i, g[i] = 1e9;
for (int _ = cnt; _ > 1; _--) {
int x = idfn[_], mn = 1e9;
for (int i = B.head[x], y; i; i = B.nxt[i])
if (dfn[y = B.ver[i]] < dfn[x])
mn = min(mn, dfn[y]);
else
find(y), mn = min(mn, g[y]);
C.add(idfn[mn], x);
fa[x] = ff[x];
g[x] = mn;
}
st[tp = 1] = S;
while (tp) {
int x = st[tp--];
dep[x] = dep[l[x]] + 1;
f[x][0] = l[x];
d[l[x]]++;
for (int i = 0; i < 18; i++) f[x][i + 1] = f[f[x][i]][i];
for (int i = C.head[x], y; i; i = C.nxt[i]) {
if (!--C.d[y = C.ver[i]]) st[++tp] = y;
l[y] = l[y] ? lca(l[y], x) : x;
}
}
for (int i = 1; i <= cnt; i++)
if (!d[idfn[i]]) st[++tp] = idfn[i];
while (tp) {
int x = st[tp--], y = l[x];
sz[x]++;
if (!--d[y]) st[++tp] = y;
sz[y] += sz[x];
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (i != S) ans = max(ans, sz[i]);
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[n];
long long len[n];
unordered_map<int, int> rems[11];
bool validlen[11];
int temp;
for (int i = 0; i < 11; ++i) {
validlen[i] = false;
}
for (int i = 0; i < n; ++i) {
cin >> a[i];
temp = a[i];
len[i] = 0;
for (int r = 0; r < 10; ++r) {
if (temp > 0) {
len[i] += 1;
temp /= 10;
} else {
break;
}
}
validlen[len[i]] = true;
a[i] = a[i] % k;
}
long long pow10mod[11];
long long pow10 = 1;
for (int i = 0; i < 11; ++i) {
pow10mod[i] = (pow10 % k);
pow10 *= 10;
}
for (int j = 0; j < 11; ++j) {
if (!validlen[j]) continue;
for (int i = 0; i < n; ++i) {
rems[j][(a[i] * pow10mod[j]) % k] += 1;
}
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
ans += (long long)rems[len[i]][(k - a[i]) % k];
if ((a[i] * pow10mod[len[i]]) % k == (k - a[i]) % k) {
ans -= 1;
}
}
cout << ans << "\n";
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
int n,k;
cin>>n>>k;
string str1,str2;
cin>>str1;
cin>>str2;
map<int,int> m1;
map<int,int> m2;
for(int i=0;i<n;i++)
{
m1[int(str1[i])-97]++;
m2[int(str2[i])-97]++;
}
map<int,int> :: iterator it1,it2;
it1=m1.begin();
it2=m2.begin();
int no=0;
while(1)
{
if(it1->first==it2->first)
{
int x=min(it1->second,it2->second);
m1[it1->first]-=x;
m2[it2->first]-=x;
}
else
{
int y=it1->second;
if(it1->first<it2->first)
{
if(y>=k)
{
m1[it1->first]-=k;
m2[it2->first]-=k;
}
else
{
no+=1;
cout<<"No"<<endl;
break;
}
}
else
{
no+=1;
cout<<"No"<<endl;
break;
}
}
if(m1[it1->first]==0)
{
int x=it1->first;
it1++;
m1.erase(x);
}
if(m2[it2->first]==0)
{
int y=it2->first;
it2++;
m2.erase(y);
}
if(m1.size()==0 || m2.size()==0)
{
break;
}
}
if(no==0)
{
if(m1.size()==0 && m2.size()==0)
{
cout<<"Yes"<<endl;
}
else
{
cout<<"No"<<endl;
}
}
}
} | 3 |
#include <bits/stdc++.h>
int compare(const void *a, const void *b) {
return *((unsigned *)b) - *((unsigned *)a);
}
int main(int argc, char **argv) {
unsigned q;
unsigned n, *a, *b;
scanf("%d", &q);
while (q--) {
scanf("%d", &n);
a = (unsigned *)calloc(n, sizeof(unsigned));
b = (unsigned *)calloc(n, sizeof(unsigned));
unsigned i = 0, j = 0, k = 0;
for (i = 0; i < n; i++) {
unsigned num;
scanf("%d", &num);
if (i == 0)
a[k] = num;
else if (a[k] != num)
a[++k] = num;
}
n = k + 1;
qsort(a, n, sizeof(unsigned), compare);
unsigned max = a[0], next = 0;
k = i = 0;
do {
if (i <= n - 3 && a[i] + a[i + 1] + a[i + 2] < max)
break;
else if (i == n - 2 && a[i] + a[i + 1] < max)
break;
unsigned z = a[i];
while (i < (n - 1) && a[i] == a[i + 1]) i++;
for (j = i, k = 0; j < n; j++) {
if (z % a[j] != 0) b[k++] = a[j];
}
j = 0;
while (b[j]) {
next = z + b[j];
if (next > max) max = next;
k = j + 1;
while (b[k] && z + b[j] + b[k] > max) {
if (b[j] % b[k] != 0) max = z + b[j] + b[k];
k++;
}
j++;
}
memset(b, sizeof(unsigned) * j, 0);
} while (++i < n);
printf("%d\n", max);
free(a);
free(b);
}
return EXIT_SUCCESS;
}
| 6 |
#include <iostream>
#include <stdio.h>
#include <cstdio>
using namespace std;
int main()
{
double p, q;
double price = 0, quantity = 0, amount = 0;
while (scanf("%lf,%lf", &p, &q) != EOF) {
price += (p * q);
quantity += q;
amount++;
}
cout << (int)price << endl;
cout << (int)(quantity / amount + 0.5) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct my_heap {
priority_queue<int, vector<int>, greater<int> > p, q;
void insert(int v) { p.push(v); }
void del(int v) { q.push(v); }
int top() {
while (!q.empty() && p.top() == q.top()) {
p.pop();
q.pop();
}
return p.top();
}
} h[200000 + 5];
int n, m, q;
int a[200000 + 5];
vector<int> G[200000 + 5], T[200000 + 5];
void add_edge(vector<int> *E, int u, int v) {
E[u].push_back(v);
E[v].push_back(u);
}
int cnt = 0;
namespace DCC {
int tim;
bool ins[200000 + 5];
int dfn[200000 + 5], low[200000 + 5];
stack<int> st;
void tarjan(int x) {
st.push(x);
ins[x] = 1;
dfn[x] = low[x] = ++tim;
for (int y : G[x]) {
if (!dfn[y]) {
tarjan(y);
low[x] = min(low[x], low[y]);
if (dfn[x] <= low[y]) {
cnt++;
int z;
do {
z = st.top();
st.pop();
ins[z] = 0;
add_edge(T, z, cnt);
} while (z != y);
add_edge(T, x, cnt);
}
} else
low[x] = min(low[x], dfn[y]);
}
}
void ini() {
cnt = n;
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i);
}
}
} // namespace DCC
namespace HLD {
struct segment_tree {
struct node {
int l;
int r;
int v;
} tree[200000 * 4 + 5];
void push_up(int pos) {
tree[pos].v = min(tree[pos << 1].v, tree[pos << 1 | 1].v);
}
void build(int l, int r, int pos) {
tree[pos].l = l;
tree[pos].r = r;
tree[pos].v = 0x3f3f3f3f;
if (l == r) return;
int mid = (l + r) >> 1;
build(l, mid, pos << 1);
build(mid + 1, r, pos << 1 | 1);
push_up(pos);
}
void update(int upos, int uval, int pos) {
if (tree[pos].l == tree[pos].r) {
tree[pos].v = uval;
return;
}
int mid = (tree[pos].l + tree[pos].r) >> 1;
if (upos <= mid)
update(upos, uval, pos << 1);
else
update(upos, uval, pos << 1 | 1);
push_up(pos);
}
int query(int L, int R, int pos) {
if (L <= tree[pos].l && R >= tree[pos].r) return tree[pos].v;
int mid = (tree[pos].l + tree[pos].r) >> 1;
int ans = 0x3f3f3f3f;
if (L <= mid) ans = min(ans, query(L, R, pos << 1));
if (R > mid) ans = min(ans, query(L, R, pos << 1 | 1));
return ans;
}
} Tr;
int tim;
int fa[200000 + 5], sz[200000 + 5], son[200000 + 5], top[200000 + 5],
dfn[200000 + 5], deep[200000 + 5];
void dfs1(int x, int f) {
fa[x] = f;
sz[x] = 1;
deep[x] = deep[f] + 1;
for (int y : T[x]) {
if (y != f) {
dfs1(y, x);
sz[x] += sz[y];
if (sz[y] > sz[son[x]]) son[x] = y;
}
}
}
void dfs2(int x, int t) {
top[x] = t;
dfn[x] = ++tim;
if (son[x]) dfs2(son[x], t);
for (int y : T[x]) {
if (y != fa[x] && y != son[x]) {
dfs2(y, y);
}
}
}
void ini() {
dfs1(1, 0);
dfs2(1, 1);
Tr.build(1, cnt, 1);
for (int i = 1; i <= n; i++) {
if (fa[i]) h[fa[i]].insert(a[i]);
}
for (int i = 1; i <= cnt; i++) {
if (i <= n)
Tr.update(dfn[i], a[i], 1);
else
Tr.update(dfn[i], h[i].top(), 1);
}
}
void change(int x, int val) {
int tmp = a[x];
a[x] = val;
Tr.update(dfn[x], val, 1);
if (fa[x]) {
h[fa[x]].del(tmp);
h[fa[x]].insert(val);
Tr.update(dfn[fa[x]], h[fa[x]].top(), 1);
}
}
int query(int x, int y) {
int ans = 0x3f3f3f3f;
while (top[x] != top[y]) {
if (deep[top[x]] < deep[top[y]]) {
swap(x, y);
}
ans = min(ans, Tr.query(dfn[top[x]], dfn[x], 1));
x = fa[top[x]];
}
if (deep[x] > deep[y]) swap(x, y);
ans = min(ans, Tr.query(dfn[x], dfn[y], 1));
if (x > n) ans = min(ans, a[fa[x]]);
return ans;
}
} // namespace HLD
int main() {
int u, v;
char ch[2];
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &u, &v);
add_edge(G, u, v);
}
DCC::ini();
HLD::ini();
for (int i = 1; i <= q; i++) {
scanf("%s %d %d", ch, &u, &v);
if (ch[0] == 'A')
printf("%d\n", HLD::query(u, v));
else
HLD::change(u, v);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 1000 * 100 + 100;
long long a[MAXn], n, m, w, h, k, H;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
cin >> m;
k = 1;
H = a[1];
for (int i = 0; i < m; i++) {
cin >> w >> h;
cout << max(a[w], H) << endl;
if (w <= k) {
H = H + h;
k = w;
} else {
if (H > a[w]) {
H = h + H;
k = w;
} else {
H = a[w] + h;
k = w;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const int maxn = 1e6 + 10;
int main() {
vector<bool> prime(maxn + 1, true);
vector<int> primes;
prime[0] = prime[1] = false;
for (int i = 2; i <= maxn; i++) {
if (!prime[i]) continue;
primes.push_back(i);
if (i * 1LL * i <= maxn) {
for (int j = i * i; j <= maxn; j += i) {
prime[j] = false;
}
}
}
int x2;
cin >> x2;
vector<int> x2primes;
for (int i = 2; i * i <= x2; i++) {
if (prime[i] && x2 % i == 0) x2primes.push_back(i);
if (x2 % i == 0 && prime[x2 / i]) x2primes.push_back(x2 / i);
}
int result = INT_MAX;
for (int pr : x2primes) {
for (int x1 = x2 - pr + 1; x1 <= x2; x1++) {
int mx = 0;
for (int i = 2; i * i <= x1; i++) {
if (x1 % i == 0) {
if (prime[i]) mx = i;
if (prime[x1 / i]) {
mx = x1 / i;
break;
}
}
}
result = min(result, max(3, x1 - mx + 1));
}
}
cout << result << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int maxn = 1005;
using namespace std;
map<int, int> mp;
int main() {
int a[maxn];
int num, jishu;
cin >> num >> jishu;
for (int i = 0; i < num; i++) cin >> a[i];
sort(a, a + num);
int ans = 0;
while (1) {
if (a[0] == jishu) break;
for (int i = 0; i < num; i++)
if (a[i] != a[i + 1] && a[i] < jishu) a[i]++;
ans++;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int n, ans, md = 998244353, num[1000010], b[1000010], c[1000010], inv[1000010],
p[1000010], q[1000010], r[1000010];
int power(int x, int p) {
int num = 1;
while (p) {
if (p & 1) num = (long long)num * x % md;
x = (long long)x * x % md;
p >>= 1;
}
return num;
}
int main() {
scanf("%d", &n);
num[0] = inv[0] = b[0] = p[0] = r[0] = 1;
for (int i = 1; i <= n; ++i) num[i] = (long long)num[i - 1] * i % md;
for (int i = 1; i <= n; ++i) b[i] = (long long)b[i - 1] * num[i] % md;
c[n] = power(b[n], md - 2);
for (int i = n - 1; i; --i) c[i] = (long long)num[i + 1] * c[i + 1] % md;
for (int i = 1; i <= n; ++i) inv[i] = (long long)b[i - 1] * c[i] % md;
for (int i = 0; i <= n + 1; ++i) q[i] = (i & 1 ? md - 1 : 1);
for (int i = 1; i <= n; ++i) p[i] = (long long)p[i - 1] * 3 % md;
for (int i = 1; i <= n; ++i) r[i] = (long long)r[i - 1] * p[n] % md;
for (int i = 1; i <= n; ++i)
ans = (ans + (long long)q[i + 1] *
((long long)num[n] * inv[i] % md * inv[n - i] % md) % md *
p[i] % md * r[n - i] % md) %
md;
ans = (ans << 1) % md;
for (int i = 0; i < n; ++i) {
long long x =
(power((1 + md - p[i]) % md, n) + md - (long long)q[n] * r[i] % md) %
md;
ans = (ans + 3ll * q[i + 1] % md *
((long long)num[n] * inv[i] % md * inv[n - i] % md) % md *
x % md) %
md;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int d[4][109];
int main() {
string s1, s2;
cin >> s1 >> s2;
int n = s1.size();
auto get = [=](int a) { return 2 * (s1[a] == 'X') + (s2[a] == 'X'); };
for (int i = 0; i < n; i++) {
for (int j = 0; j < 4; j++) {
d[j][i] = -300;
}
}
d[get(0)][0] = 0;
for (int i = 1; i < n; i++) {
if ((1 & get(i)) == 0) {
d[1 | get(i)][i] = max(d[1 | get(i)][i], d[0][i - 1] + 1);
}
if ((2 & get(i)) == 0) {
d[2 | get(i)][i] = max(d[2 | get(i)][i], d[0][i - 1] + 1);
}
if (get(i) == 0) {
d[3][i] = max(d[3][i], d[1][i - 1] + 1);
d[3][i] = max(d[3][i], d[2][i - 1] + 1);
}
for (int j = 0; j < 4; j++) {
d[get(i)][i] = max(d[get(i)][i], d[j][i - 1]);
}
}
int ans = 0;
for (int i = 0; i < 4; i++) {
ans = max(ans, d[i][n - 1]);
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
long long S;
cin >> n >> S;
struct adj {
int v, w, c;
};
vector<vector<adj>> g(n);
for (int i = 0; i < n - 1; ++i) {
int u, v, w, c;
cin >> u >> v >> w >> c;
--u;
--v;
g[u].push_back({v, w, c});
g[v].push_back({u, w, c});
}
vector<long long> len[2];
long long tot = 0;
function<int(int, int)> dfs = [&](int u, int p) {
if (g[u].size() == 1 && u != 0) {
return 1;
}
int sum = 0;
for (auto [v, w, c] : g[u])
if (v != p) {
int leaves = dfs(v, u);
tot += 1LL * leaves * w;
while (w) {
len[c - 1].push_back(1LL * (w + 1) / 2 * leaves);
w /= 2;
}
sum += leaves;
}
return sum;
};
dfs(0, -1);
tot = max(0LL, tot - S);
int ans = (tot ? numeric_limits<int>::max() : 0);
for (int i = 0; i < 2; ++i) {
sort(len[i].rbegin(), len[i].rend());
for (int j = 0; j < len[i].size(); ++j) {
if (j) len[i][j] += len[i][j - 1];
if (len[i][j] >= tot) {
ans = min(ans, (i + 1) * (j + 1));
}
}
}
for (int i = 0; i < len[1].size(); ++i) {
int j = lower_bound(len[0].begin(), len[0].end(), tot - len[1][i]) -
len[0].begin();
int cost = 2 * (i + 1) + (j + 1);
if (j < len[0].size()) ans = min(ans, cost);
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int tc;
cin >> tc;
while (tc--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> bin(int num, int typs) {
vector<int> v;
while (num > 0) {
v.push_back(num % 2);
num /= 2;
}
for (int i = v.size(); i < typs; i++) {
v.push_back(0);
}
return v;
}
int main() {
int typs, plyrs, diff, cnt = 0, diffbit = 0;
cin >> typs >> plyrs >> diff;
int army;
vector<vector<int> > v;
for (int i = 0; i <= plyrs; i++) {
cin >> army;
v.push_back(bin(army, typs));
}
for (int i = 0; i < v.size() - 1; i++) {
diffbit = 0;
for (int j = 0; j < v[i].size(); j++) {
if (v[i][j] != v[v.size() - 1][j]) diffbit++;
}
if (diffbit <= diff) cnt++;
}
cout << cnt;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,t,p[110]={},dp[102][4][4]={};
cin>>n>>t;
for(int i=0;i<t;i++){
int a,b;
cin>>a>>b;
p[a]=b;
}
if(p[1]&&p[2])dp[3][p[2]][p[1]]=1;
else if(p[2])for(int i=1;i<4;i++)dp[3][p[2]][i]=1;
else if(p[1])for(int i=1;i<4;i++)dp[3][i][p[1]]=1;
else
for(int i=1;i<4;i++)
for(int j=1;j<4;j++)dp[3][i][j]=1;
for(int i=3;i<=n;i++)
for(int j=1;j<4;j++) //1
for(int k=1;k<4;k++){//2
if(p[i]==j&&j==k)continue;
if(p[i])dp[i+1][p[i]][j]=(dp[i+1][p[i]][j]+dp[i][j][k])%10000;
else
for(int l=1;l<4;l++){
if(j==k&&k==l)continue;
dp[i+1][l][j]=(dp[i+1][l][j]+dp[i][j][k])%10000;
}
}
int ans=0;
for(int i=1;i<4;i++)
for(int j=1;j<4;j++)ans+=dp[n+1][i][j];
cout<<ans%10000<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> a;
vector<long long> b;
int32_t main() {
cout.precision(numeric_limits<double>::max_digits10);
a.push_back(0);
b.push_back(0);
long long n, i, choice, sum = 0;
cin >> n;
while (n--) {
cin >> choice;
if (choice == 1) {
long long range, addval;
cin >> range >> addval;
sum += addval * range;
b[range - 1] += addval;
} else if (choice == 2) {
long long newele;
cin >> newele;
sum += newele;
a.push_back(newele);
b.push_back(0);
} else {
if (b[b.size() - 1] == 0) {
b.pop_back();
sum -= a[a.size() - 1];
a.pop_back();
} else {
b[b.size() - 2] += b[b.size() - 1];
sum -= (a[a.size() - 1] + b[b.size() - 1]);
a.pop_back();
b.pop_back();
}
}
cout << 1.0 * sum / (a.size()) << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const int maxn = 1e5 + 5;
string s;
map<char, int> c;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> s;
for (int i = 0; i < s.length(); ++i) {
c[s[i]]++;
}
bool check = true;
int t = 0;
for (int i = 1; i < s.length(); ++i) {
if (s[i] != s[i - 1]) {
if (s[i] == 'a' || (s[i] == 'b' && s[i - 1] == 'c') ||
(s[i] == 'c' && s[i - 1] == 'a')) {
check = false;
break;
}
}
}
if (check && c['a'] && c['b'] && (c['c'] == c['a'] || c['c'] == c['b'])) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int maxn = 100100;
long long exponentiation(long long A, long long B, long long MOD) {
long long ans = 1;
for (; B; A = (A * A) % MOD, B >>= 1)
if (B & 1) ans = (ans * A) % MOD;
return ans;
}
pair<int, int> tree[maxn << 2];
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
return {1ll * a.first * b.first % mod, a.second + b.second};
}
void upd(int pos, int v) {
for (pos++; pos < maxn << 2; pos += pos & -pos)
tree[pos] = tree[pos] + make_pair(v, 1);
}
void update(int pos, int v) { upd(pos + 2 * maxn - 100, v); }
void ree(int pos) {
for (pos++; pos < maxn << 2; pos += pos & -pos) tree[pos] = make_pair(1, 0);
}
void remove(int pos) { ree(pos + 2 * maxn - 100); }
void clear() {
for (int e = 0; e < maxn << 2; e++) tree[e] = {1, 0};
}
pair<int, int> sum(int pos) {
pair<int, int> ruu = {1ll, 0};
for (pos++; pos; pos -= pos & -pos) ruu = ruu + tree[pos];
return ruu;
}
pair<int, int> query(int x, int y) {
pair<int, int> down = sum(x + 2 * maxn - 101);
pair<int, int> up = sum(y + 2 * maxn - 100);
return make_pair(
1ll * exponentiation(down.first, mod - 2, mod) * up.first % mod,
up.second - down.second);
}
int online[maxn], sz[maxn];
int color[maxn], clam[maxn];
int u[maxn], v[maxn], x[maxn], c[maxn];
vector<int> g[maxn];
vector<long long> res;
void init(int cur, int p) {
sz[cur] = 1;
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt]) {
init(nxt, cur);
sz[cur] += sz[nxt];
}
}
}
int get_centroid(int cur, int p, int w) {
int biggest = -1;
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt] && (biggest == -1 || sz[biggest] < sz[nxt]))
biggest = nxt;
}
if (biggest == -1 || sz[biggest] * 2 <= w) return cur;
return get_centroid(biggest, cur, w);
}
const int zx = 100000;
void count0(int cur, int p, int r, int b, int co) {
pair<int, int> mul = query(-2 * zx, 2 * r - b);
if (mul.second) {
res.back() *= 1ll * mul.first * exponentiation(co, mul.second, mod) % mod;
res.back() %= mod;
}
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt]) {
count0(nxt, cur, r + 1 - c[d], b + c[d], 1ll * co * x[d] % mod);
}
}
}
void add0(int cur, int p, int r, int b, int co) {
update(b - 2 * r, co);
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt])
add0(nxt, cur, r + 1 - c[d], b + c[d], 1ll * co * x[d] % mod);
}
}
void rem0(int cur, int p, int r, int b) {
remove(b - 2 * r);
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt]) rem0(nxt, cur, r + 1 - c[d], b + c[d]);
}
}
void find0(int cur) {
init(cur, -1);
cur = get_centroid(cur, -1, sz[cur]);
update(0, 1);
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (online[nxt]) continue;
count0(nxt, cur, 1 - c[d], c[d], x[d]);
add0(nxt, cur, 1 - c[d], c[d], x[d]);
}
remove(0);
rem0(cur, -1, 0, 0);
online[cur] = 1;
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (online[nxt]) continue;
find0(nxt);
}
}
void count1(int cur, int p, int r, int b, int co) {
pair<int, int> mul = query(2 * b - r + 1, 2 * zx + 1);
if (mul.second) {
res.back() *= 1ll * mul.first * exponentiation(co, mul.second, mod) % mod;
res.back() %= mod;
}
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt]) {
count1(nxt, cur, r + 1 - c[d], b + c[d], 1ll * co * x[d] % mod);
}
}
}
void add1(int cur, int p, int r, int b, int co) {
update(r - 2 * b, co);
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt])
add1(nxt, cur, r + 1 - c[d], b + c[d], 1ll * co * x[d] % mod);
}
}
void rem1(int cur, int p, int r, int b) {
remove(r - 2 * b);
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (nxt != p && !online[nxt]) rem1(nxt, cur, r + 1 - c[d], b + c[d]);
}
}
void find1(int cur) {
init(cur, -1);
cur = get_centroid(cur, -1, sz[cur]);
update(0, 1);
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (online[nxt]) continue;
count1(nxt, cur, 1 - c[d], c[d], x[d]);
add1(nxt, cur, 1 - c[d], c[d], x[d]);
}
remove(0);
rem1(cur, -1, 0, 0);
online[cur] = 1;
for (int d : g[cur]) {
int nxt = u[d];
if (nxt == cur) nxt = v[d];
if (online[nxt]) continue;
find1(nxt);
}
}
int main() {
int n;
scanf("%d", &n);
for (int e = 0; e < n - 1; e++) {
scanf("%d %d %d %d", u + e, v + e, x + e, c + e);
u[e]--;
v[e]--;
g[u[e]].push_back(e);
g[v[e]].push_back(e);
}
clear();
memset(online, 0, sizeof(online));
res.push_back(1ll);
find0(0);
memset(online, 0, sizeof(online));
res.push_back(1ll);
find1(0);
cout << res[0] * exponentiation(res[1], mod - 2, mod) % mod << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 12;
long long fib[max_n];
long long mat[2][2];
long long ini[2];
long long m;
void mul1(long long a[][2], long long b[][2]) {
long long c[2][2];
c[0][0] = a[0][0];
c[0][1] = a[0][1];
c[1][0] = a[1][0];
c[1][1] = a[1][1];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
a[i][j] = 0;
for (int k = 0; k < 2; k++) {
a[i][j] += c[i][k] * b[k][j];
}
a[i][j] %= m;
}
}
}
void mul2(long long a[][2]) {
long long c[2][2];
c[0][0] = a[0][0];
c[0][1] = a[0][1];
c[1][0] = a[1][0];
c[1][1] = a[1][1];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
a[i][j] = 0;
for (int k = 0; k < 2; k++) {
a[i][j] += c[i][k] * c[k][j];
}
a[i][j] %= m;
}
}
}
int main() {
fib[1] = fib[2] = 1;
long long l, r, k;
cin >> m >> l >> r >> k;
long long g = 1;
g = (r - (l - 1)) / k;
long long maxg = g;
for (g; g * k <= r - (l - 1) + g + 1 && g <= r;) {
g = r / (r / g);
if (g * k <= r - (l - 1) + (l - 1) % g) maxg = g;
g++;
}
mat[0][0] = mat[0][1] = mat[1][0] = 1;
ini[0] = ini[1] = 1;
long long n = maxg;
long long tem[2][2] = {};
tem[0][0] = tem[1][1] = 1;
if (n <= 2) {
cout << fib[n] % m << endl;
} else {
n -= 2;
while (n) {
if (n % 2 == 1) {
mul1(tem, mat);
}
mul2(mat);
n /= 2;
}
long long ret = tem[0][0] + tem[0][1];
ret %= m;
cout << ret << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-10;
const int MOD = 998857459;
const int INF = 0x3f3f3f3f;
const int maxn = 3e5 + 10;
const int maxm = 5e6 + 10;
int n, k, op[maxn][2], p[maxn << 1], val[maxn << 1];
char str[maxn];
int find(int first) {
return p[first] == first ? p[first] : p[first] = find(p[first]);
}
void merge(int first, int second) {
if (first == second) return;
val[second] += val[first];
p[first] = second;
}
int main() {
cin >> n >> k;
scanf("%s", str + 1);
for (int i = 1, sz, a; i <= k; ++i) {
scanf("%d", &sz);
while (sz--) {
scanf("%d", &a);
op[a][bool(op[a][0])] = i;
}
val[i] = 1;
p[i] = i;
p[i + k] = i + k;
}
val[0] = INF;
int now = 0;
for (int i = 1; i <= n; ++i) {
int fa = find(op[i][0]), fb = find(op[i][1]);
int rfa = find(op[i][0] + k), rfb = find(op[i][1] + k);
if (!op[i][0]) goto out;
if (str[i] == '1') {
if (op[i][1]) {
if (fa == fb) goto out;
now -= min(val[fa], val[rfa]);
now -= min(val[fb], val[rfb]);
merge(fa, fb);
merge(rfa, rfb);
now += min(val[fb], val[rfb]);
} else {
now -= min(val[fa], val[rfa]);
merge(fa, find(0));
now += val[rfa];
}
} else {
if (op[i][1]) {
if (fa == rfb) goto out;
now -= min(val[fa], val[rfa]);
now -= min(val[fb], val[rfb]);
merge(fa, rfb);
merge(fb, rfa);
now += min(val[rfb], val[rfa]);
} else {
now -= min(val[fa], val[rfa]);
merge(rfa, find(0));
now += val[fa];
}
}
out:
printf("%d\n", now);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dis[1000009];
queue<int> q;
int main() {
ios::sync_with_stdio(0);
memset(dis, -1, sizeof(dis));
cin >> n >> m;
dis[n] = 0;
q.push(n);
while (!q.empty()) {
int u = q.front();
q.pop();
if (u < 1 || u > 10000) continue;
if (dis[u - 1] == -1) {
dis[u - 1] = dis[u] + 1;
q.push(u - 1);
}
if (u < m && dis[u * 2] == -1) {
dis[u * 2] = dis[u] + 1;
q.push(u * 2);
}
}
cout << dis[m] << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const int INF = 1e9;
struct Tree {
struct Node {
pair<int, int> res;
pair<int, int> mnl;
pair<int, int> mnr;
int updl;
int updr;
};
vector<Node> data;
int sz;
void init(int n) {
sz = n;
data.resize(sz * 4);
for (int i = 0; i < sz * 4; i++) {
data[i].res = make_pair(INF, -1);
data[i].mnl = make_pair(INF, -1);
data[i].mnr = make_pair(INF, -1);
data[i].updl = data[i].updr = -1;
}
}
void apply(int v, int rr, int value, int type) {
if (type == 1) {
data[v].updl = value;
data[v].mnl = make_pair(-value - (rr - 1), 1);
data[v].res = data[v].mnr;
data[v].res.first -= value;
} else if (type == 2) {
data[v].updr = value;
data[v].mnr = make_pair(value - (rr - 1), 1);
data[v].res = data[v].mnl;
data[v].res.first += value;
} else
assert(false);
}
void push(int v, int ll, int rr) {
if (data[v].updl != -1) {
apply(v * 2 + 1, (ll + rr) / 2, data[v].updl, 1);
apply(v * 2 + 2, rr, data[v].updl, 1);
data[v].updl = -1;
}
if (data[v].updr != -1) {
apply(v * 2 + 1, (ll + rr) / 2, data[v].updr, 2);
apply(v * 2 + 2, rr, data[v].updr, 2);
data[v].updr = -1;
}
}
Node merge(Node r1, Node r2) {
Node g;
g.updl = g.updr = -1;
pair<int, int> res;
pair<int, int> mnl;
pair<int, int> mnr;
res = make_pair(min(r1.res.first, r2.res.first), 0);
if (res.first == r1.res.first) res.second += r1.res.second;
if (res.first == r2.res.first) res.second += r2.res.second;
mnl = make_pair(min(r1.mnl.first, r2.mnl.first), 0);
if (mnl.first == r1.mnl.first) mnl.second += r1.mnl.second;
if (mnl.first == r2.mnl.first) mnl.second += r2.mnl.second;
mnr = make_pair(min(r1.mnr.first, r2.mnr.first), 0);
if (mnr.first == r1.mnr.first) mnr.second += r1.mnr.second;
if (mnr.first == r2.mnr.first) mnr.second += r2.mnr.second;
g.res = res;
g.mnl = mnl;
g.mnr = mnr;
return g;
}
void set(int v, int ll, int rr, int l, int r, int value, int type) {
if (r <= ll || rr <= l) return;
if (l <= ll && rr <= r) {
apply(v, rr, value, type);
return;
}
push(v, ll, rr);
set(v * 2 + 1, ll, (ll + rr) / 2, l, r, value, type);
set(v * 2 + 2, (ll + rr) / 2, rr, l, r, value, type);
data[v] = merge(data[v * 2 + 1], data[v * 2 + 2]);
}
void set(int l, int r, int value, int type) {
set(0, 0, sz, l, r, value, type);
}
};
int n;
int a[N];
Tree t;
void read() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
a[x] = y;
}
}
void solve() {
t.init(n);
vector<pair<int, int> > stackL;
vector<pair<int, int> > stackR;
stackL.push_back(make_pair(-1, n));
stackR.push_back(make_pair(n, n));
long long answer = 0;
for (int i = n - 1; i >= 0; i--) {
int h = a[i];
for (; !stackL.empty() && h < stackL.back().first; stackL.pop_back())
;
assert(!stackL.empty());
t.set(i, stackL.back().second, h, 1);
stackL.push_back(make_pair(h, i));
for (; !stackR.empty() && h > stackR.back().first; stackR.pop_back())
;
assert(!stackR.empty());
t.set(i, stackR.back().second, h, 2);
stackR.push_back(make_pair(h, i));
auto r = t.data[0].res;
assert(r.first >= -i);
if (r.first == -i) answer += r.second;
}
cout << answer << endl;
}
void printAns() {}
void stress() {}
int main() {
if (1) {
for (int tt = 0; tt < 1; tt++) {
read();
solve();
printAns();
}
} else {
stress();
}
return 0;
}
| 6 |
#include<iostream>
#include<vector>
#include<cassert>
#include<algorithm>
using namespace std;
#define rep(i, n) for ( int i = 0; i < n; i++ )
#define MAX 100
#define INFTY (1<<21)
void dijkstra( int n, int G[MAX][MAX], vector<int> p[MAX] ){
int d[MAX];
bool visited[MAX];
rep(i, n) p[i].clear();
rep(i, n){
d[i] = INFTY;
visited[i] = false;
}
d[0] = 0;
int cnt = 0;
while(1){
int minv = INFTY;
int u = -1;
rep(i, n){
if ( !visited[i] && minv > d[i] ) {
u = i;
minv = d[i];
}
}
if ( u == -1 ) break;
visited[u] = true;
cnt++;
rep(v, n){
if ( !visited[v] && G[u][v] != INFTY ){
int cost = d[u] + G[u][v];
if ( cost == d[v] ){
p[v].push_back(u);
} else if ( cost < d[v] ){
p[v].clear();
p[v].push_back(u);
d[v] = cost;
}
}
}
}
assert( cnt == n );
}
void tsort( int n, int u, bool T[MAX][MAX], vector<int> &order, bool visited[MAX], vector<int> p[MAX] ){
visited[u] = true;
rep(v, n) if ( T[u][v] && !visited[v]) tsort(n, v, T, order, visited, p);
if ( u == 0 || u == n-1 || p[u].size() > 0 ){
order.push_back(u);
}
}
void parse( int n, int u, vector<int> p[MAX], bool inpath[MAX]){
inpath[u] = true;
for ( int i = 0; i < p[u].size(); i++ ){
int v = p[u][i];
if ( !inpath[v] )parse(n, v, p, inpath);
// parse(n, v, p, inpath);
}
}
void makeTree(int n, bool T[MAX][MAX], vector<int> p[MAX], int q){
bool inpath[MAX];
rep(i, n) inpath[i] = false;
parse(n, n-1, p, inpath);
rep(i, n) rep(j, n) T[i][j] = false;
rep(v, n){
rep(i, p[v].size()){
int u = p[v][i];
if ( inpath[u] && inpath[v] ) T[u][v] = true;
}
}
vector<int> order;
bool visited[MAX];
rep(i, n) visited[i] = false;
order.clear();
tsort(n, 0, T, order, visited, p);
reverse(order.begin(), order.end());
double forward[MAX], back[MAX];
rep(i, n) forward[i] = back[i] = 0.0;
//rep(i,n) cout << order[i] << " ";
//cout << endl;
assert( order[0] == 0 );
assert( order[order.size()-1] == n-1 );
forward[order[0]] = 1;
for ( int i = 0; i < order.size(); i++ ){
int u = order[i];
rep(v, n){
if ( T[u][v] ) forward[v] += forward[u];
}
}
for ( int i = 0; i < n; i++ ){
if ( 0 == i ) continue;
forward[i] /= forward[n-1];
}
rep(i, n) visited[i] = false;
order.clear();
// Tt
bool tmp[MAX][MAX];
/*
rep(i, n){
rep(j, n) cout << T[i][j] << " ";
cout << endl;
}*/
rep(i, n) rep(j, n) tmp[j][i] = T[i][j];
rep(i, n) rep(j, n) T[i][j] = tmp[i][j];
/*
rep(i, n){
rep(j, n) cout << T[i][j] << " ";
cout << endl;
}
cout << endl;
*/
tsort(n, n-1, T, order, visited, p);
reverse(order.begin(), order.end());
// rep(i, n) cout << order[i] << " ";
// cout << endl;
assert( order[0] == n-1 );
assert( order[order.size()-1] == 0 );
back[order[0]] = 1.0;
for ( int i = 0; i < order.size(); i++ ){
int u = order[i];
rep(v, n){
if ( T[u][v] ) back[v] += back[u];
}
}
double base = 1.0; // back[0];
for ( int i = 0; i < n; i++ ){
if ( i == n-1 ) continue;
// back[i] = back[i]/back[0];
back[i] = back[i]/base;
}
/*
rep(i, n){
//printf("%.4lf %.4lf %.4lf\n", forward[i], back[i], forward[i]*back[i]);
printf("%.8lf\n", forward[i]*back[i]);
}
cout << endl;
*/
int req;
rep(i, q){
cin >> req;
assert( 0 < req && req < n-1 );
printf("%.12lf\n", forward[req]*back[req]);
//printf("%.12lf * %.2lf = %.12lf\n", forward[req], back[req], forward[req]*back[req]);
}
cout << endl;
}
int main(){
int n, m, q, G[MAX][MAX], s, t, c;
bool T[MAX][MAX];
vector<int> p[MAX];
while(1){
cin >> n >> m >> q;
if ( n == 0 && m == 0 && q == 0) break;
rep(i, n) rep(j, n) G[i][j] = INFTY;
rep(i, m){
cin >> s >> t >> c;
G[s][t] = G[t][s] = c;
}
dijkstra(n, G, p);
makeTree(n, T, p, q);
}
} | 0 |
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<set>
#include<map>
#include<iostream>
using namespace std;
#define re register
#define ll long long
inline int gi()
{
int f=1,sum=0;char ch=getchar();
while(ch>'9' || ch<'0'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0' && ch<='9'){sum=(sum<<3)+(sum<<1)+ch-'0';ch=getchar();}
return f*sum;
}
typedef pair<ll,int>pli;
typedef pair<int,int>pii;
#define mp make_pair
const int N=100010;
ll d[N];int n,siz[N];vector<pii>ans;pli p[N];
int main()
{
n=gi();
for(int i=1;i<=n;i++)scanf("%lld",&d[i]),p[i].first=d[i],p[i].second=i,siz[i]=1;
sort(p+1,p+n+1);ll dis=0;
for(int i=n;i>1;i--)
{
ll nd=p[i].first-n+(siz[p[i].second]<<1);
int pos=lower_bound(p+1,p+n+1,mp(nd,0))-p;
if(p[pos].first!=nd)return puts("-1"),0;
int u=p[i].second,v=p[pos].second;
ans.push_back(mp(u,v));siz[v]+=siz[u];
dis+=siz[u];
}
if(dis!=p[1].first)return puts("-1"),0;
for(pii now:ans)printf("%d %d\n",now.first,now.second);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long p, q, b;
long long gcd(long long a, long long b) { return a == 0 ? b : gcd(b % a, a); }
long long read() {
long long num = 0, w = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') w = -1;
ch = getchar();
}
while (isdigit(ch)) {
num = num * 10 + ch - 48;
ch = getchar();
}
return num * w;
}
int main() {
n = read();
for (int i = 0; i < n; i++) {
p = read(), q = read(), b = read();
long long g = gcd(p, q);
p /= g;
q /= g;
long long orq = -1;
while (orq != q) {
orq = q;
g = gcd(q, b);
while (q % g == 0) {
if (g == 1) goto out;
q /= g;
}
}
out:
if (q == 1)
cout << "Finite\n";
else
cout << "Infinite\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 11;
vector<int> v[N];
int a[N];
int d[20][N], tin[N], tout[N], timee, sz[N];
int gl[N], num[N], nn;
int deep[N];
int n;
void dfs(int l, int pr) {
d[0][l] = pr;
deep[l] = deep[pr] + 1;
timee++;
sz[l] = 1;
tin[l] = timee;
for (int j = 1; j < 19; j++) d[j][l] = d[j - 1][d[j - 1][l]];
for (int j = 0; j < v[l].size(); j++) {
dfs(v[l][j], l);
sz[l] += sz[v[l][j]];
}
tout[l] = timee;
}
inline bool pred(int l, int r) {
if (tin[l] <= tin[r] && tout[r] <= tout[l]) return 1;
return 0;
}
inline int lca(int l, int r) {
if (pred(l, r)) return l;
if (pred(r, l)) return r;
for (int j = 19; j >= 0; j--)
if (d[j][l] != 0 && (!pred(d[j][l], r))) l = d[j][l];
return d[0][l];
}
inline int dist(int l, int r) {
int p = lca(l, r);
return deep[l] + deep[r] - deep[p] * 2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
v[1].push_back(2);
v[1].push_back(3);
v[1].push_back(4);
n = 4;
for (int i = 1; i <= q; i++) {
int l;
cin >> l;
a[i] = l;
v[l].push_back(n + 1);
v[l].push_back(n + 2);
n += 2;
}
dfs(1, 0);
n = 4;
int x = 2, y = 3;
for (int i = 1; i <= q; i++) {
n++;
if (dist(x, n) > dist(x, y)) y = n;
if (dist(y, n) > dist(x, y)) x = n;
n++;
if (dist(x, n) > dist(x, y)) y = n;
if (dist(n, y) > dist(x, y)) x = n;
cout << dist(x, y) << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
long long n, Index;
long long ans;
long long d[] = {5, 50, 500, 5000, 50000,
500000, 5000000, 50000000, 500000000, 5000000000};
long long c[] = {0, 9, 99, 999, 9999, 99999,
999999, 9999999, 99999999, 999999999, 9999999999};
void init() {
scanf("%lld", &n);
for (int i = 0; i < 10; i++) {
if (n < d[i]) break;
Index++;
}
if (Index == 0) {
printf("%lld\n", n * (n - 1) / 2);
} else {
for (int i = 0; i < (2 * n) / (c[Index] + 1); i++) {
long long m = i * (c[Index] + 1) + c[Index];
long long tmp;
if (m - 1 < n)
tmp = m / 2;
else
tmp = (n - (m + 1) / 2 + 1);
ans += tmp;
}
printf("%lld\n", ans);
}
}
int main(int argc, char** argv) {
init();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<long long> v(n);
vector<long long> psum;
for (int i = 0; i < n; ++i) cin >> v[i];
sort(v.begin(), v.end());
psum = v;
for (int i = 1; i < n; ++i) psum[i] += psum[i - 1];
long double ans = 0;
int ansMedian = 0;
int ansSz = 0;
for (int i = 0; i < n; ++i) {
int s = 0, e = min(i, n - i - 1);
while (s <= e) {
int mid = (s + e) / 2;
long double allsum = psum[i];
if (i - mid - 1 >= 0) allsum -= psum[i - mid - 1];
allsum += psum[n - 1];
allsum -= psum[n - 1 - mid];
long double mean = 1.0 * allsum / (2.0 * mid + 1);
long double skewness = mean - v[i];
if (skewness >= ans) {
ans = skewness;
ansMedian = i;
ansSz = mid;
}
if (i - mid - 1 >= 0) {
long double nxt = (v[i - mid - 1] + v[n - 1 - mid]) / 2.0;
if (nxt >= mean) {
s = mid + 1;
} else {
e = mid - 1;
}
} else {
e = mid - 1;
}
}
}
cout << 2 * ansSz + 1 << endl;
for (int i = ansMedian - ansSz; i <= ansMedian; ++i) cout << v[i] << " ";
for (int i = n - ansSz; i < n; ++i) cout << v[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
using ll = long long;
const int maxn = 1e6 + 5;
int n, m, q;
int p[maxn];
pair<int, int> E[maxn];
pair<int, int> Q[maxn];
bool deleted[maxn];
int par[maxn];
int parent(int x) {
if (par[x] == x) return x;
return par[x] = parent(par[x]);
}
vector<int> g[maxn];
void join(int u, int v) {
u = parent(u);
v = parent(v);
if (u == v) return;
++n;
par[n] = n;
par[u] = n;
par[v] = n;
g[n].push_back(u);
g[n].push_back(v);
}
int tin[maxn], tout[maxn];
int timer = 0;
void dfs(int at) {
tin[at] = ++timer;
for (int to : g[at]) {
dfs(to);
}
tout[at] = timer;
}
pair<int, int> t[4 * maxn];
void upd(int v, int tl, int tr, int i, pair<int, int> val) {
if (tl == tr) {
t[v] = val;
} else {
int tm = (tl + tr) / 2;
if (i <= tm) {
upd(2 * v, tl, tm, i, val);
} else {
upd(2 * v + 1, tm + 1, tr, i, val);
}
t[v] = max(t[2 * v], t[2 * v + 1]);
}
}
pair<int, int> qry(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl) {
return {0, 0};
}
if (l <= tl && tr <= r) {
return t[v];
}
int tm = (tl + tr) / 2;
return max(qry(2 * v, tl, tm, l, r), qry(2 * v + 1, tm + 1, tr, l, r));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
cin >> p[i];
}
for (int i = 1; i <= m; i++) {
cin >> E[i].first >> E[i].second;
}
for (int i = 1; i <= q; i++) {
cin >> Q[i].first >> Q[i].second;
if (Q[i].first == 2) {
deleted[Q[i].second] = true;
}
}
for (int i = 1; i <= n; i++) {
par[i] = i;
}
for (int i = m; i >= 1; i--) {
if (!deleted[i]) {
join(E[i].first, E[i].second);
}
}
for (int i = q; i >= 1; i--) {
int type = Q[i].first;
if (type == 2) {
int id = Q[i].second;
join(E[id].first, E[id].second);
} else {
Q[i].second = parent(Q[i].second);
}
}
for (int i = 1; i <= n; i++) {
if (parent(i) == i) {
dfs(i);
}
}
for (int i = 1; i <= n; i++) {
upd(1, 1, n, tin[i], make_pair(p[i], tin[i]));
}
for (int i = 1; i <= q; i++) {
int type = Q[i].first;
if (type == 1) {
int curP = Q[i].second;
pair<int, int> res = qry(1, 1, n, tin[curP], tout[curP]);
cout << res.first << "\n";
if (res.first == 0) {
continue;
}
int loc = res.second;
upd(1, 1, n, loc, {0, 0});
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int INF = 1e9;
using namespace std;
int main() {
long long n, ans = 0, numb;
char f;
cin >> n >> f;
if (n % 2 == 0) {
if (n / 2 % 2 == 0)
numb = n / 2;
else
numb = n / 2 + 1;
} else {
if ((n - 1) / 2 % 2 == 0)
numb = n / 2 + 1;
else
numb = n / 2;
}
ans = (numb - 1) * 6;
ans += (numb - 1) / 2 * 4;
if ((numb) % 2 == 0) ++ans;
string s = "0fedabc";
ans += s.find(f);
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
#pragma GCC optimize("03")
using namespace std;
vector<pair<int, int> > vxy;
int n;
int mx = 0;
int my = 0;
pair<int, int> okx(int dif) {
int x = mx - dif;
x = max(0, x);
int y = my;
for (int i = 0; i < n; i++)
if (vxy[i].first < x) y = max(y, vxy[i].second + (x - vxy[i].first));
y -= dif;
y = max(0, y);
if (!x && !y) {
x++;
y++;
}
bool res = 1;
for (int i = 0; i < n; i++) {
int xx = vxy[i].first;
int yy = vxy[i].second;
if (xx >= x && yy >= y) {
int ma = max(xx - x, yy - y);
res &= (ma <= dif);
} else if (xx < x && yy < y) {
int ma = max(x - xx, y - yy);
res &= (ma <= dif);
} else if (xx < x) {
int ma = x - xx + yy - y;
res &= (ma <= dif);
} else {
int ma = xx - x + y - yy;
res &= (ma <= dif);
}
}
if (res) {
return pair<int, int>(x, y);
}
return pair<int, int>(-(long long)(2e9), -(long long)(2e9));
}
pair<int, int> oky(int dif) {
int y = my - dif;
y = max(0, y);
int x = mx;
for (int i = 0; i < n; i++)
if (vxy[i].second < y) x = max(x, vxy[i].first + (y - vxy[i].second));
x -= dif;
x = max(0, x);
if (!x && !y) {
x++;
y++;
}
bool res = 1;
for (int i = 0; i < n; i++) {
int xx = vxy[i].first;
int yy = vxy[i].second;
if (xx >= x && yy >= y) {
int ma = max(xx - x, yy - y);
res &= (ma <= dif);
} else if (xx < x && yy < y) {
int ma = max(x - xx, y - yy);
res &= (ma <= dif);
} else if (xx < x) {
int ma = x - xx + yy - y;
res &= (ma <= dif);
} else {
int ma = xx - x + y - yy;
res &= (ma <= dif);
}
}
if (res) {
return pair<int, int>(x, y);
}
return pair<int, int>(-(long long)(2e9), -(long long)(2e9));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
set<string> ss;
for (int i = 0; i < n; i++) {
string second;
cin >> second;
ss.insert(second);
}
n = ss.size();
if (n == 1) {
cout << (0) << '\n';
cout << (*ss.begin()) << '\n';
return 0;
}
for (auto second : ss) {
int x = 0;
int y = 0;
int len = second.size();
for (int j = 0; j < len; j++) {
if (second[j] == 'N') x++;
if (second[j] == 'B') y++;
}
vxy.push_back(pair<int, int>(x, y));
mx = max(mx, x);
my = max(my, y);
}
int res = 0;
for (int po = (1 << 19); po; po >>= 1)
if (okx(res + po).first == -(long long)(2e9) &&
oky(res + po).first == -(long long)(2e9))
res += po;
res++;
pair<int, int> p1 = okx(res);
pair<int, int> p2 = oky(res);
cout << (res) << '\n';
if (p1.first != -(long long)(2e9)) {
for (int i = 0; i < p1.first; i++) cout << 'N';
for (int i = 0; i < p1.second; i++) cout << 'B';
cout << '\n';
} else {
for (int i = 0; i < p2.first; i++) cout << 'N';
for (int i = 0; i < p2.second; i++) cout << 'B';
cout << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int l = 0, r = 0, d = 0, u = 0;
cin >> s;
if (s.size() % 2 != 0)
cout << "-1";
else {
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'L')
l += 1;
else if (s[i] == 'R')
r += 1;
else if (s[i] == 'U')
u += 1;
else if (s[i] == 'D')
d += 1;
}
if ((l - r) % 2 == 0 && (u - d) % 2 == 0)
cout << abs(l - r) / 2 + abs(u - d) / 2;
else
cout << abs(l - r) / 2 + abs(u - d) / 2 + 1;
}
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
long long int MOD = 998244353;
long long int NUM = 1e9 + 7;
void solve() {
int n;
cin >> n;
cout << (n / 2) + 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const int N = 5000;
vector<int> v, k;
bool can(int x) {
int rnk = 0;
for (auto i : v) {
if (i <= x) rnk++;
}
for (auto i : k) {
if (i > 0 && i <= x)
rnk++;
else if (i < 0 && abs(i) <= rnk)
rnk--;
}
if (rnk)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
v.assign(n, 0);
k.assign(q, 0);
for (auto &x : v) cin >> x;
int add = n, rmv = 0;
for (auto &x : k) {
cin >> x;
if (x > 0)
add++;
else
rmv++;
}
if (add == rmv) {
cout << 0;
return 0;
}
int ans = 0, l = 1, r = 1e6;
while (l <= r) {
int mid = l + (r - l) / 2;
if (can(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = int(1e5) + 10;
const int MOD = int(1e9) + 7;
int mul(int a, int b) { return (a * 1ll * b) % MOD; }
int add(int a, int b) {
a = a + b;
if (a >= MOD) a -= MOD;
return a;
}
int power(int a, int p) {
int ret = 1;
while (p) {
if (p & 1) ret = mul(ret, a);
a = mul(a, a);
p >>= 1;
}
return ret;
}
int inv(int x) { return power(x, MOD - 2); }
int dp[N][2], up[N][2], ans;
vector<int> g[N];
void dfs1(int x, int p) {
int p1 = 1, p2 = 1, isLeaf = 1;
for (auto y : g[x]) {
if (y == p) continue;
isLeaf = 0;
dfs1(y, x);
p1 = mul(p1, dp[y][0]);
p2 = mul(p2, dp[y][1]);
}
dp[x][0] = add(p1, p2);
dp[x][1] = add(p1, p2);
if (isLeaf) {
dp[x][0] = dp[x][1] = 1;
}
}
void dfs2(int x, int p) {
int p1 = 1, p2 = 1;
for (auto y : g[x]) {
if (y == p) continue;
p1 = mul(p1, dp[y][0]);
p2 = mul(p2, dp[y][1]);
}
ans = add(ans, mul(p1, up[x][0]));
ans = add(ans, mul(p2, up[x][1]));
for (auto y : g[x]) {
if (y == p) continue;
p1 = mul(p1, inv(dp[y][0]));
p2 = mul(p2, inv(dp[y][1]));
if (x == p && (int)(g[x].size()) == 1) {
up[y][0] = 1;
} else {
up[y][0] = add(mul(p1, up[x][0]), mul(p2, up[x][1]));
}
up[y][1] = up[y][0];
dfs2(y, x);
p1 = mul(p1, dp[y][0]);
p2 = mul(p2, dp[y][1]);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs1(1, 1);
up[1][0] = 1;
up[1][1] = 1;
dfs2(1, 1);
printf("%d\n", ans);
return 0;
}
| 5 |
#include<queue>
#include<cstdio>
using namespace std;
typedef long long ll;
const int maxn=100000,mod=1000000007;
const ll inf=0x3f3f3f3f3f3f3f3f;
int n,m,s,t,ans; queue<int> q;
struct hnode{
int id; ll v;
bool operator<(const hnode &t)const{
return v>t.v;
}
};
struct edge{int to,len;};
priority_queue<hnode> hp;
struct graph{
vector<edge> g[maxn+10]; ll dis[maxn+10]; int dz[maxn+10],f[maxn+10];
vector<edge> z[maxn+10];
void add(int u,int v,int w){
g[u].push_back((edge){v,w});
g[v].push_back((edge){u,w});
}
void dijkstra(int s){
for(int i=1;i<=n;++i) dis[i]=i==s?0:inf;
hp.push((hnode){s,0});
for(;!hp.empty();){
hnode x=hp.top(); hp.pop(); if(x.v>dis[x.id]) continue;
for(int i=0;i<g[x.id].size();++i){
edge e=g[x.id][i];
if(x.v+e.len<dis[e.to]){
dis[e.to]=x.v+e.len; hp.push((hnode){e.to,dis[e.to]});
}
}
}
}
void addeg(int u,int v,int w){z[u].push_back((edge){v,w}); ++dz[v];}
void buildnew(){
for(int i=1;i<=n;++i)
for(int j=0;j<g[i].size();++j){
edge e=g[i][j]; if(dis[i]+e.len==dis[e.to]) addeg(i,e.to,e.len);
}
}
void topsort(int s){
f[s]=1; for(int i=1;i<=n;++i) if(!dz[i]) q.push(i);
for(;!q.empty();q.pop()){
int x=q.front();
for(int i=0;i<z[x].size();++i){
int e=z[x][i].to; (f[e]+=f[x])%=mod;
if(!--dz[e]) q.push(e);
}
}
}
}g,rg;
int main(){
scanf("%d%d%d%d",&n,&m,&s,&t);
for(int i=1;i<=m;++i){
int l,r,w; scanf("%d%d%d",&l,&r,&w);
g.add(l,r,w); rg.add(l,r,w);
}
g.dijkstra(s); rg.dijkstra(t);
g.buildnew(); rg.buildnew();
ll d=g.dis[t];
g.topsort(s); rg.topsort(t); ans=1ll*g.f[t]*rg.f[s]%mod;
for(int i=1;i<=n;++i){
for(int j=0;j<g.g[i].size();++j){
edge e=g.g[i][j];
if(g.dis[i]+e.len+rg.dis[e.to]==d&&g.dis[i]*2<d&&g.dis[e.to]*2>d){
ll now=1ll*g.f[i]*rg.f[e.to]%mod;
ans-=1ll*now*now%mod;
ans=(ans+mod)%mod;
}
}
if(g.dis[i]+rg.dis[i]==d&&g.dis[i]*2==d){
ll now=1ll*g.f[i]*rg.f[i]%mod;
ans-=1ll*now*now%mod;
ans=(ans+mod)%mod;
}
}
printf("%d",ans);
} | 0 |
#include<iostream>
#include<cstdio>
#include<cstring>
template<typename T>inline void check_max(T a,T &b){if(a>b)b=a;}
typedef long long ll;
const int N=101000;
ll s[N],t[N];
ll ans;
int n,k;
int main()
{
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++)
{
scanf("%lld",&s[i]);
t[i]=t[i-1];
if(s[i]>0)t[i]+=s[i];
s[i]+=s[i-1];
}
ans=0;
for(int i=k;i<=n;i++)
check_max(std::max(s[i]-s[i-k],0ll)+t[i-k]+t[n]-t[i],ans);
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void print(int num) {
switch (num) {
case 1:
cout << "x^y^z";
break;
case 2:
cout << "x^z^y";
break;
case 3:
cout << "(x^y)^z";
break;
case 4:
cout << "(x^z)^y";
break;
case 5:
cout << "y^x^z";
break;
case 6:
cout << "y^z^x";
break;
case 7:
cout << "(y^x)^z";
break;
case 8:
cout << "(y^z)^x";
break;
case 9:
cout << "z^x^y";
break;
case 10:
cout << "z^y^x";
break;
case 11:
cout << "(z^x)^y";
break;
case 12:
cout << "(z^y)^x";
break;
}
}
int main() {
double x, y, z;
cin >> x >> y >> z;
int ans = 0;
double can = -1 * (1e12);
double tmp;
if (x > 1) {
tmp = z * log(y) + log(log(x));
if (tmp - can > 1e-12) {
can = tmp;
ans = 1;
}
tmp = y * log(z) + log(log(x));
if (tmp - can > 1e-12) {
can = tmp;
ans = 2;
}
tmp = log((y * z)) + log(log(x));
if (tmp - can > 1e-12) {
can = tmp;
ans = 3;
}
}
if (y > 1) {
tmp = z * log(x) + log(log(y));
if (tmp - can > 1e-12) {
can = tmp;
ans = 5;
}
tmp = x * log(z) + log(log(y));
if (tmp - can > 1e-12) {
can = tmp;
ans = 6;
}
tmp = log((x * z)) + log(log(y));
if (tmp - can > 1e-12) {
can = tmp;
ans = 7;
}
}
if (z > 1) {
tmp = y * log(x) + log(log(z));
if (tmp - can > 1e-12) {
can = tmp;
ans = 9;
}
tmp = x * log(y) + log(log(z));
if (tmp - can > 1e-12) {
can = tmp;
ans = 10;
}
tmp = log(y * x) + log(log(z));
if (tmp - can > 1e-12) {
can = tmp;
ans = 11;
}
}
if (x <= 1 && y <= 1 && z <= 1) {
tmp = pow(y, z) * log(x);
if (tmp - can > 1e-12) {
can = tmp;
ans = 1;
}
tmp = pow(z, y) * log(x);
if (tmp - can > 1e-12) {
can = tmp;
ans = 2;
}
tmp = (y * z) * log(x);
if (tmp - can > 1e-12) {
can = tmp;
ans = 3;
}
tmp = pow(x, z) * log(y);
if (tmp - can > 1e-12) {
can = tmp;
ans = 5;
}
tmp = pow(z, x) * log(y);
if (tmp - can > 1e-12) {
can = tmp;
ans = 6;
}
tmp = (x * z) * log(y);
if (tmp - can > 1e-12) {
can = tmp;
ans = 7;
}
tmp = pow(x, y) * log(z);
if (tmp - can > 1e-12) {
can = tmp;
ans = 9;
}
tmp = pow(y, x) * log(z);
if (tmp - can > 1e-12) {
can = tmp;
ans = 10;
}
tmp = (y * x) * log(z);
if (tmp - can > 1e-12) {
can = tmp;
ans = 11;
}
}
print(ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e4 + 5;
int n, m, G, R, d[MN], dis[MN][1005];
deque<pair<int, int> > q;
int main() {
scanf("%d%d", &n, &m);
for (register int i = 1; i <= m; i++) scanf("%d", d + i);
sort(d + 1, d + 1 + m);
scanf("%d%d", &G, &R);
memset(dis, -1, sizeof(dis));
dis[1][0] = 0;
q.push_front(make_pair(1, 0));
while (!q.empty()) {
register pair<int, int> v = q.front();
q.pop_front();
if (v.first > 1) {
register int val = d[v.first] - d[v.first - 1] + v.second;
if (val < G) {
if (dis[v.first - 1][val] < 0) {
dis[v.first - 1][val] = dis[v.first][v.second];
q.push_front(make_pair(v.first - 1, val));
}
}
if (val == G) {
if (dis[v.first - 1][0] < 0) {
dis[v.first - 1][0] = dis[v.first][v.second] + 1;
q.push_back(make_pair(v.first - 1, 0));
}
}
}
if (v.first < m) {
register int val = d[v.first + 1] - d[v.first] + v.second;
if (val < G) {
if (dis[v.first + 1][val] < 0) {
dis[v.first + 1][val] = dis[v.first][v.second];
q.push_front(make_pair(v.first + 1, val));
}
}
if (val == G) {
if (dis[v.first + 1][0] < 0) {
dis[v.first + 1][0] = dis[v.first][v.second] + 1;
q.push_back(make_pair(v.first + 1, 0));
}
}
}
}
register long long Ans = -1, Res;
for (register int i = 0; i < G; i++) {
if (dis[m][i] < 0) continue;
Res = 1ll * dis[m][i] * (G + R) + i;
if (!i && dis[m][i]) Res -= R;
if (Ans < 0 || Ans > Res) Ans = Res;
}
printf("%lld\n", Ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double PI = acos(-1);
const int maxn = 2005;
const int inf = 0x3fffffff;
const int mod = 1000000007;
int n, m;
bool x[maxn], y[maxn];
int cx, cy;
double f[maxn][maxn];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int xx, yy;
scanf("%d%d", &xx, &yy);
x[xx] = y[yy] = 1;
}
for (int i = 1; i <= n; i++) {
cx += x[i];
cy += y[i];
}
cx = n - cx;
cy = n - cy;
for (int i = 1; i <= n; i++) {
f[0][i] = f[0][i - 1] + n * 1.0 / i;
f[i][0] = f[i - 1][0] + n * 1.0 / i;
}
for (int i = 1; i <= cx; i++)
for (int j = 1; j <= cy; j++) {
double tt = f[i - 1][j - 1] * i * j + f[i - 1][j] * i * (n - j) +
f[i][j - 1] * (n - i) * j + n * n;
tt /= (n * j + n * i - i * j);
f[i][j] = tt;
}
printf("%.10f\n", f[cx][cy]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string p, z;
cin >> p;
cin >> z;
for (int i = 0; i < p.length(); i++) {
if (p[i] >= 'A' && p[i] <= 'Z') p[i] = tolower(p[i]);
}
for (int i = 0; i < z.length(); i++) {
if (z[i] >= 'A' && z[i] <= 'Z') z[i] = tolower(z[i]);
}
cout << p.compare(z);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using std::abs;
using std::bitset;
using std::cerr;
using std::cin;
using std::copy;
using std::cout;
using std::deque;
using std::endl;
using std::fill;
using std::fixed;
using std::greater;
using std::istream;
using std::lower_bound;
using std::make_pair;
using std::map;
using std::max;
using std::min;
using std::multiset;
using std::next_permutation;
using std::nth_element;
using std::ostream;
using std::pair;
using std::priority_queue;
using std::queue;
using std::reverse;
using std::rotate;
using std::set;
using std::sort;
using std::string;
using std::swap;
using std::tie;
using std::tuple;
using std::unique;
using std::unordered_map;
using std::unordered_set;
using std::upper_bound;
using std::vector;
int const INF = (int)1e9;
long long const INFL = (long long)1e18;
long double const PI = 3.1415926535897932384626433832795028;
struct Point {
long long x, y;
Point() {}
Point(long long x, long long y) : x(x), y(y) {}
};
bool compx(Point const& a, Point const& b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
}
bool compy(Point const& a, Point const& b) {
return a.y < b.y || (a.y == b.y && a.x < b.x);
}
long long dist2(Point const& a, Point const& b) {
long long dx = a.x - b.x;
long long dy = a.y - b.y;
return dx * dx + dy * dy;
}
struct Node {
int type;
int x1, y1;
int x2, y2;
vector<Point> p;
Node *L, *R;
};
int const MAX_IN_LEAF = 333;
bool inside(long long p, long long begin, long long end) {
return begin <= p && p <= end;
}
long long dist2(long long p, long long begin, long long end) {
if (inside(p, begin, end)) {
return 0;
}
long long dist = min(abs(p - begin), abs(p - end));
return dist * dist;
}
long long dist2(Point const& a, Node* v) {
if (!v) {
return INFL;
}
if (v->type == 2) {
long long ret = INFL;
for (auto p : v->p) {
long long now = dist2(a, p);
if (now > 0) {
ret = min(ret, now);
}
}
return ret;
} else {
if (inside(a.x, v->x1, v->x2)) {
return dist2(a.y, v->y1, v->y2);
} else if (inside(a.y, v->y1, v->y2)) {
return dist2(a.x, v->x1, v->x2);
} else {
return min({dist2(a, Point(v->x1, v->y1)), dist2(a, Point(v->x1, v->y2)),
dist2(a, Point(v->x2, v->y1)),
dist2(a, Point(v->x2, v->y2))});
}
}
}
template <typename RAI>
Node* build(RAI a, RAI b, int type) {
int n = b - a;
Node* ret = new Node();
ret->x1 = min_element(a, b, compx)->x;
ret->y1 = min_element(a, b, compy)->y;
ret->x2 = max_element(a, b, compx)->x;
ret->y2 = max_element(a, b, compy)->y;
if (n <= MAX_IN_LEAF) {
ret->type = 2;
ret->p = vector<Point>(a, b);
ret->L = NULL;
ret->R = NULL;
return ret;
}
int ln = n / 2;
nth_element(a, a + ln, a + n, type == 0 ? compx : compy);
ret->type = type;
ret->p = {a[ln]};
ret->L = build(a, a + ln, !type);
ret->R = build(a + ln, b, !type);
return ret;
}
long long closest(Node* tree, Point const& p) {
long long res = INFL;
set<pair<long long, Node*>> q;
q.emplace(dist2(p, tree), tree);
while (!q.empty()) {
long long cur = q.begin()->first;
if (cur >= res) {
break;
}
Node* v = q.begin()->second;
q.erase(q.begin());
if (v->type == 2) {
res = cur;
} else {
q.emplace(dist2(p, v->L), v->L);
q.emplace(dist2(p, v->R), v->R);
}
}
return res;
}
void solve() {
int n;
scanf("%d", &n);
vector<Point> a(n);
long long sum = 0;
for (int i = 0; i < n; ++i) {
long long y;
scanf("%lld", &y);
sum += y;
a[i] = Point(i, sum);
}
Node* tree = build(a.begin(), a.end(), 0);
long long ans = INFL;
for (auto p : a) {
ans = min(ans, closest(tree, p));
}
cout << ans << endl;
}
int main() {
cout.precision(15);
cout << fixed;
cerr.precision(6);
cerr << fixed;
srand(1510);
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
int n, k;
cin >> n >> k;
vector<int> vec(n);
vector<int> ans(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
vec[i]--;
}
for (int i = 0; i < n; i++) {
ans[i] += min(n - 1, i + k) - max(0, i - k) + 1;
if (vec[i] != -1) {
ans[i] += ans[vec[i]];
ans[i] -= max(0, min((vec[i] + k), n - 1) - max((i - k), 0) + 1);
}
}
for (int i = 0; i < n; i++) {
cout << ans[i] << ' ';
}
cout << endl;
}
| 2 |
#include<iostream>
#include<map>
using namespace std;
int main(){
map<int,int> pset;
int n,m,d,t;
bool can=true;
cin >> n;
for(int i=0;i<n;i++){
cin >> d;
pset[d]++;
}
cin >> m;
for(int i=0;i<m;i++){
cin >> t;
if(pset[t]>0){
pset[t]--;
}else{
can=false;
}
}
if(can) cout << "YES\n";
else cout <<"NO\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
void solve() {
long long n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) cout << s[n - 1];
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.