solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
int main() {
int n;
cin >> n >> ws;
char s[1001];
scanf("%s", &s);
int h = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'H') h++;
}
int _min = INF;
for (int i = 0; i < n; i++) {
int ans = 0;
for (int j = 0; j < h; j++) {
if (s[(i + j) % n] == 'T') ans++;
}
_min = min(ans, _min);
}
cout << _min;
return 0;
}
| 3 |
#include<iostream>
using namespace std;
int main(){
int i,p;
int f[100];
int n;
cin>>n;
for(i=0;i<n;i++){
cin>>f[i];}
for(p=0;p<n-1;p++){
cout<<f[n-p-1]<<" ";}
cout<<f[0]<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double x[101], ans, tt, t;
bool cmp(double a, double b) { return a > b; }
int main() {
int n, i, j, k;
while (cin >> n) {
for (i = 0; i < n; i++) cin >> x[i];
sort(x, x + n, cmp);
ans = 0;
t = 0;
for (k = 0; k < n; k++) {
t = 0;
for (i = 0; i <= k; i++) {
tt = 1.000000000;
for (j = 0; j <= k; j++) {
if (j == i)
tt *= x[j];
else
tt *= (1 - x[j]);
}
t += tt;
}
ans = max(ans, t);
}
printf("%.12lf\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long Linf = 1e18 + 5;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
T abs(T a) {
return a > 0 ? a : -a;
}
int read() {
int res = 0;
int neg;
while (true) {
char ch = getchar();
if (ch >= '0' && ch <= '9' || ch == '-') {
if (ch == '-')
neg = -1;
else
neg = 1, res = ch - '0';
break;
}
}
while (true) {
char ch = getchar();
if (ch >= '0' && ch <= '9')
res *= 10, res += ch - '0';
else
break;
}
return res * neg;
}
void write(int x) {
static char buf[20];
int nn = 0;
if (x < 0) putchar('-'), x *= -1;
while (x) {
buf[++nn] = x % 10 + '0';
x /= 10;
}
for (int(i) = (nn); (i) >= (1); (i)--) putchar(buf[i]);
putchar('\n');
}
const int MAXN = 1e5 + 5;
int ar[MAXN];
int sum[MAXN];
int main() {
int n = read(), m = read();
for (int(i) = (1); (i) <= (n); (i)++) {
ar[i] = read() * read();
sum[i] = sum[i - 1] + ar[i];
}
for (int(i) = (1); (i) <= (m); (i)++)
printf("%d\n", lower_bound(sum + 1, sum + 1 + n, read()) - sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
int as[110];
long long memo[100][50000];
long long calc(long long n, int pos) {
if (n < 50000 && memo[pos][n] != -1) {
return memo[pos][n];
}
long long v = n / as[pos];
long long ret = v;
if (pos != 0) {
if (v >= as[0]) {
ret -= calc(v, pos - 1);
}
ret += calc(n, pos - 1);
}
if (n < 50000) {
memo[pos][n] = ret;
}
return ret;
}
int main() {
long long n, k;
while (cin >> n >> k) {
memset((memo), -1, sizeof(memo));
for (int i = 0; i < (int)(k); i++) {
cin >> as[i];
}
sort(as, as + k);
cout << n - calc(n, k - 1) << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isprime[1000006], vis[100005];
vector<pair<int, int> > v[100005];
void print(int x) {
if (!vis[x]) {
vis[x] = true;
int sz = v[x].size();
for (int i = 0; i < sz; i++) {
printf("%d %d %d\n", x, v[x][i].first, v[x][i].second);
print(v[x][i].first);
}
}
}
int main() {
for (int i = 0; i < 1000006; i++) isprime[i] = true;
isprime[0] = isprime[1] = false;
for (int i = 2; i * i < 1000006; i++) {
if (isprime[i]) {
for (int j = i * i; j < 1000006; j += i) {
isprime[j] = false;
}
}
}
int n, m;
scanf("%d %d", &n, &m);
int w;
for (int i = n - 1; i < 1000006; i++) {
if (isprime[i]) {
w = i;
break;
}
}
for (int i = 1; i < n - 1; i++) {
v[i].push_back({i + 1, 1});
}
v[n - 1].push_back({n, w - n + 2});
m -= n - 1;
for (int i = 1; i < n && m; i++) {
for (int j = i + 2; j <= n && m; j++, m--) {
v[i].push_back({j, 1000000000});
}
}
printf("%d %d\n", w, w);
print(1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
using matrix = vector<vector<long long>>;
const long long MAXN = 1e6 + 100;
bitset<MAXN> used;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long m, h1, a1, x1, y1, h2, a2, x2, y2;
cin >> m >> h1 >> a1 >> x1 >> y1 >> h2 >> a2 >> x2 >> y2;
long long len_a = -1, len_b = -1, add_a = -1, add_b = -1;
for (long long i = 1;; ++i) {
used[h1] = true;
h1 = (x1 * h1 + y1) % m;
if (used[h1]) {
break;
}
if (h1 == a1) {
add_a = i;
break;
}
}
used.reset();
for (long long i = 1;; ++i) {
used[h2] = true;
h2 = (x2 * h2 + y2) % m;
if (used[h2]) {
break;
}
if (h2 == a2) {
add_b = i;
break;
}
}
if (add_a == -1 || add_b == -1) {
cout << -1;
return 0;
}
if (add_a == add_b) {
cout << add_a;
return 0;
}
used.reset();
for (long long i = 1;; ++i) {
h1 = (x1 * h1 + y1) % m;
if (used[h1]) {
break;
}
if (h1 == a1) {
len_a = i;
break;
}
used[h1] = true;
}
used.reset();
for (long long i = 1;; ++i) {
h2 = (x2 * h2 + y2) % m;
if (used[h2]) {
break;
}
if (h2 == a2) {
len_b = i;
break;
}
used[h2] = true;
}
if (len_a == -1 && len_b == -1) {
cout << -1;
return 0;
}
long long ans = (1ll << 60ll);
if (len_a != -1) {
for (long long i = 1; i <= MAXN; ++i) {
long long cur = add_a + len_a * i;
if (len_b != -1) {
if (cur >= add_b && (cur - add_b) % len_b == 0) {
ans = min(ans, cur);
}
} else {
if (cur == add_b) {
ans = min(ans, cur);
}
}
}
}
if (len_b != -1) {
for (long long i = 1; i <= MAXN; ++i) {
long long cur = add_b + len_b * i;
if (len_a != -1) {
if (cur >= add_a && (cur - add_a) % len_a == 0) {
ans = min(ans, cur);
}
} else {
if (cur == add_a) {
ans = min(ans, cur);
}
}
}
}
cout << (ans == (1ll << 60ll) ? -1 : ans);
}
| 3 |
#include<bits/stdc++.h>
#define int long long
#define for0(i, n) for(int i = 0; i < (n); i++)
#define for1(i, n) for(int i = 1; i <= (n);i++)
using namespace std;
int m, a[10], b[10], n, g, ans[1010];
void f(int sum, int i) {
if (sum > 1000)return;
if (i == m) {
ans[sum]++; return;
}
for0(p, b[i] + 1) f(sum + a[i] * p, i + 1);
}
int get() { int r; cin >> r; return r; }
signed main() {
while (cin >> m, m) {
for0(i, m)cin >> a[i] >> b[i];
for0(i, 1001)ans[i] = 0;
f(0, 0);
cin >> g;
while (g--)cout << ans[get()] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXV = 2000;
const int MAXE = 500000;
const int INF = (int)1e7 + 10;
struct E {
int to, co;
E(int t = 0, int c = 0) : to(t), co(c) {}
} eg[2 * MAXE];
struct Flow {
vector<int> e[MAXV];
int ei, v;
void init(int n) {
v = n;
ei = 0;
for (int i = 0; i < n; i++) e[i] = vector<int>();
}
void add(int a, int b, int c) {
eg[ei] = E(b, c);
e[a].push_back(ei);
ei++;
eg[ei] = E(a, 0);
e[b].push_back(ei);
ei++;
}
int d[MAXV], qu[MAXV], ql, qr;
bool BFS() {
memset(d, -1, v * sizeof(int));
ql = qr = 0;
qu[qr++] = 0;
d[0] = 0;
while (ql < qr && d[v - 1] == -1) {
int n = qu[ql++];
vector<int> &v = e[n];
for (int i = v.size() - 1; i >= 0; i--) {
int u = v[i];
if (d[eg[u].to] == -1 && eg[u].co > 0) {
d[eg[u].to] = d[n] + 1;
qu[qr++] = eg[u].to;
}
}
}
return d[v - 1] != -1;
}
int ptr[MAXV];
int go(int n, int p) {
if (n == v - 1) return p;
vector<int> &u = e[n];
int temp;
for (int i = ptr[n]; i < ((int)(u).size()); i++) {
if (d[n] + 1 != d[eg[u[i]].to] || eg[u[i]].co == 0) continue;
if ((temp = go(eg[u[i]].to, min(p, eg[u[i]].co))) == 0) continue;
eg[u[i]].co -= temp;
eg[u[i] ^ 1].co += temp;
ptr[n] = i;
return temp;
}
ptr[n] = ((int)(u).size());
return 0;
}
int max_flow() {
int ans = 0, temp;
while (BFS()) {
for (int i = 0; i < v; i++) ptr[i] = 0;
while ((temp = go(0, INF)) > 0) ans += temp;
}
return ans;
}
} flow;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
char s[25][25];
int num[25][25];
int d[25][25];
vector<pair<pair<int, int>, int> > man, wom;
int n, m, space;
bool check(long long c) {
int sink = 1 + ((int)(man).size()) + space + space + ((int)(wom).size());
flow.init(sink + 1);
for (int i = 0; i < ((int)(man).size()); i++) {
memset(d, -1, sizeof(d));
queue<pair<int, int> > que;
d[man[i].first.first][man[i].first.second] = 0;
que.push(man[i].first);
while (!que.empty()) {
pair<int, int> t = que.front();
que.pop();
int nd = d[t.first][t.second] + 1;
flow.add(
i + 1,
num[t.first][t.second] + ((int)(man).size()) + ((int)(man).size()),
1);
for (int j = 0; j < 4; j++) {
int nx = t.first + dx[j], ny = t.second + dy[j];
if (num[nx][ny] && d[nx][ny] == -1 && 1ll * nd * man[i].second <= c) {
d[nx][ny] = nd;
que.push(make_pair(nx, ny));
}
}
}
}
for (int i = 0; i < ((int)(wom).size()); i++) {
memset(d, -1, sizeof(d));
queue<pair<int, int> > que;
d[wom[i].first.first][wom[i].first.second] = 0;
que.push(wom[i].first);
while (!que.empty()) {
pair<int, int> t = que.front();
que.pop();
int nd = d[t.first][t.second] + 1;
flow.add(((int)(man).size()) + ((int)(man).size()) + space +
num[t.first][t.second],
((int)(man).size()) + i + 1, 1);
for (int j = 0; j < 4; j++) {
int nx = t.first + dx[j], ny = t.second + dy[j];
if (num[nx][ny] && d[nx][ny] == -1 && 1ll * nd * wom[i].second <= c) {
d[nx][ny] = nd;
que.push(make_pair(nx, ny));
}
}
}
}
for (int i = 1; i <= ((int)(man).size()); i++)
flow.add(0, i, 1), flow.add(((int)(man).size()) + i, sink, 1);
for (int i = 1; i <= space; i++)
flow.add(((int)(man).size()) + ((int)(man).size()) + i,
((int)(man).size()) + ((int)(man).size()) + space + i, 1);
return flow.max_flow() >= ((int)(man).size());
}
int main() {
int boy, girl, r, c, t, max_t = -1;
scanf("%d%d%d%d", &n, &m, &boy, &girl);
if (!(boy == girl - 1 || girl == boy - 1)) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] == '.') num[i][j] = ++space;
if (space < max(boy, girl)) {
puts("-1");
return 0;
}
scanf("%d%d%d", &r, &c, &t);
max_t = max(max_t, t);
if (boy == girl - 1)
man.push_back(make_pair(make_pair(r, c), t));
else
wom.push_back(make_pair(make_pair(r, c), t));
for (int i = 0; i < boy; i++) {
scanf("%d%d%d", &r, &c, &t);
max_t = max(max_t, t);
man.push_back(make_pair(make_pair(r, c), t));
}
for (int i = 0; i < girl; i++) {
scanf("%d%d%d", &r, &c, &t);
max_t = max(max_t, t);
wom.push_back(make_pair(make_pair(r, c), t));
}
assert(((int)(man).size()) == ((int)(wom).size()));
long long L = 0, R = 1ll * max_t * n * m, M;
while (L <= R) {
M = (L + R) / 2;
if (check(M))
R = M - 1;
else
L = M + 1;
}
if (L > 1ll * max_t * n * m)
puts("-1");
else
printf("%I64d\n", L);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
int l = 0;
int h = n;
while (l < h - 1) {
int m = (l + h) / 2;
long long val = 1ll * (n - m) * (n - m + 1);
val /= 2;
val -= m;
if (val < k) {
h = m;
} else {
l = m;
}
}
long long val = 1ll * (n - l) * (n - l + 1);
val /= 2;
val -= l;
if (val == k) {
cout << l << '\n';
} else {
cout << h << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int a, b;
cin >> a;
cin >> b;
if (a > b) {
cout << b << " " << (a - b) / 2 << endl;
} else {
cout << a << " " << (b - a) / 2 << endl;
}
return 0;
}
| 1 |
//Bokan ga bokka--nn!!
//Daily Lunch Special Tanoshii !!
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <functional>
#include <iostream>
#include <map>
#include <set>
using namespace std;
typedef pair<int,int> P;
typedef pair<int,P> P1;
typedef pair<P,P> P2;
typedef long long ll;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 2000000000
#define s(x) scanf("%d",&x)
#define rep(i,x) for(int i=0;i<x;i++)
int dp[105];
int m[105]={};
int u[105][2]={};
int v[105][2]={};
int a[105]={};
int gcd(int a,int b)
{
if(a%b==0) return b;
return gcd(b,a%b);
}
int main()
{
while(1)
{
int n;
scanf("%d",&n);
if(!n) return 0;
queue<int>que;
for(int i=1;i<=n;i++)
{
int aa,b,c,d;
scanf("%d %d %d %d",&aa,&b,&c,&d);
u[i][0]=c;
u[i][1]=d;
if(c)a[i]++;
if(d)a[i]++;
int di=gcd(aa,b);
v[i][0]=aa/di;
v[i][1]=b/di;
if(!a[i]) que.push(i);
}
fill(dp,dp+105,1);
int ret;
while(!que.empty())
{
int r=que.front(); que.pop();
int bas=1;
for(int i=0;i<2;i++)
{
if(u[r][i])
{
int f=dp[u[r][i]]/gcd(dp[u[r][i]],v[r][1-i]);
bas=bas/gcd(bas,f)*f;
}
}
dp[r]=bas*(v[r][0]+v[r][1]); ret=dp[r];
for(int i=1;i<=n;i++)
{
if(u[i][0]==r || u[i][1]==r)
{
a[i]--;
if(!a[i]) que.push(i);
}
}
}
printf("%d\n",ret);
}
}
| 0 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 101;
int n, w, v[maxn], tot[maxn];
int main() {
while (scanf("%d%d", &n, &w) != EOF) {
if (n == 0) break;
for (int i = 1; i <= n; ++i) {
scanf("%d", v + i);
}
sort(v + 1, v + 1 + n);
int cnt = v[n] / w + 1;
memset(tot, 0, sizeof(tot));
for (int i = 1; i <= n; ++i) {
tot[v[i] / w] += 1;
}
int height = *max_element(tot, tot + cnt);
double ans = 0;
for (int i = 0; i < cnt; ++i) {
ans += (double)tot[i] / height * (1 - (double)i / (cnt - 1));
}
ans += 0.01;
printf("%.10lf\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed;
cout.precision(12);
solve();
return 0;
}
template <typename T>
void sc(T& x) {
cin >> x;
}
template <typename Head, typename... Tail>
void sc(Head& head, Tail&... tail) {
cin >> head;
sc(tail...);
}
template <typename T>
void pr(const T& x) {
cout << x << '\n';
}
template <typename Head, typename... Tail>
void pr(const Head& head, const Tail&... tail) {
cout << head << ' ';
pr(tail...);
}
const int MAX_SUM = 5e5 + 10;
bool vis[MAX_SUM];
void solve() {
fill(vis, vis + MAX_SUM, false);
int n, d;
sc(n, d);
vector<int> oks;
oks.push_back(0);
for (int i = 0; i < n; i++) {
int x;
sc(x);
for (int j = ((int)oks.size()) - 1; j >= 0; j--) {
if (x + oks[j] < MAX_SUM && !vis[x + oks[j]]) {
oks.push_back(x + oks[j]);
vis[x + oks[j]] = true;
}
}
}
sort(oks.begin(), oks.end());
int ans = 0, cur = 0;
while (true) {
int idx =
upper_bound(oks.begin(), oks.end(), oks[cur] + d) - oks.begin() - 1;
if (idx >= ((int)oks.size()) || idx == cur) {
break;
}
ans++;
cur = idx;
}
pr(oks[cur], ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, w, f[1005], ans, cnt, t;
char a[1005][15][15];
vector<int> v[1005];
struct rec {
int x, y, z;
} e[1050005];
bool operator<(rec a, rec b) { return (a.z < b.z); }
int find(int x) {
if (f[x] == x)
return x;
else
return (f[x] = find(f[x]));
}
void dfs(int x, int fa) {
if (x > 0) cout << x << " " << fa << "\n";
for (auto y : v[x])
if (y != fa) dfs(y, x);
}
int main() {
cin >> n >> m >> k >> w;
for (int i = 1; i <= k; ++i) {
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= m; ++k) cin >> a[i][j][k];
e[++cnt].x = 0, e[cnt].y = i, e[cnt].z = n * m;
for (int j = 1; j <= i - 1; ++j) {
int sum = 0;
for (int k = 1; k <= n; ++k)
for (int l = 1; l <= m; ++l)
if (a[j][k][l] != a[i][k][l]) sum += w;
e[++cnt].x = i, e[cnt].y = j, e[cnt].z = sum;
}
}
sort(e + 1, e + cnt + 1);
for (int i = 0; i <= k; ++i) f[i] = i;
for (int i = 1; i <= cnt; ++i) {
int p = find(e[i].x), q = find(e[i].y);
if (p != q) {
f[p] = q;
ans += e[i].z;
v[e[i].x].push_back(e[i].y), v[e[i].y].push_back(e[i].x);
++t;
if (t == k) break;
}
}
cout << ans << "\n";
dfs(0, -1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4111;
long long x, ans, dp;
set<pair<long long, long long> > aa;
int main(int argc, char** argv) {
cin >> x;
for (long long i = 1; i < 2097153; i++) {
if ((6 * x + i * i * i - i) % (3 * i * i + 3 * i) == 0) {
if (i <= (6 * x + i * i * i - i) / (3 * i * i + 3 * i)) {
aa.insert(make_pair(i, (6 * x + i * i * i - i) / (3 * i * i + 3 * i)));
aa.insert(make_pair((6 * x + i * i * i - i) / (3 * i * i + 3 * i), i));
}
}
}
cout << aa.size() << endl;
for (set<pair<long long, long long> >::iterator i = aa.begin(); i != aa.end();
i++)
cout << (*i).first << " " << (*i).second << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double INF = 1e100;
struct PT {
long long x, y;
PT() {}
PT(long long x, long long y) : x(x), y(y) {}
PT(const PT &p) : x(p.x), y(p.y) {}
PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
PT operator*(long long c) const { return PT(x * c, y * c); }
PT operator/(long long c) const { return PT(x / c, y / c); }
};
long long dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
long long dist2(PT p, PT q) { return dot(p - q, p - q); }
long long cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
ostream &operator<<(ostream &os, const PT &p) {
return os << "(" << p.x << "," << p.y << ")";
}
const int N = 2005;
int l[N], r[N], y[N];
double project(PT O, PT dir) {
assert(dir.y != 0);
double d = -1.0 * O.y / dir.y;
return O.x + d * dir.x;
}
int n;
double check(PT dir, double d) {
double mx = -1e100, mn = 1e100;
for (int i = 1; i <= n; i++) {
PT A(l[i], y[i]), B(r[i], y[i]);
double a = project(A, dir);
double b = project(B, dir);
mx = max(mx, max(a, b));
mn = min(mn, min(a, b));
if (mx - mn > d) return INF;
}
return mx - mn;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << setprecision(10) << fixed;
cin >> n;
for (int i = 1; i <= n; i++) cin >> l[i] >> r[i] >> y[i];
vector<pair<PT, PT>> bad;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (y[i] <= y[j]) continue;
PT A(l[i], y[i]), B(r[i], y[i]);
PT C(l[j], y[j]), D(r[j], y[j]);
PT AD = D - A, BC = C - B;
assert(cross(BC, AD) > 0);
bad.push_back({BC, AD});
}
}
if (bad.empty()) {
PT OY(0, -1);
cout << check(OY, INF) << endl;
return 0;
}
sort(bad.begin(), bad.end(), [](pair<PT, PT> l, pair<PT, PT> r) {
return cross(l.first, r.first) > 0;
});
vector<pair<PT, PT>> merged;
for (auto R : bad) {
if (merged.empty())
merged.push_back(R);
else {
auto cur = merged.back();
if (cross(cur.second, R.first) >= 0)
merged.push_back(R);
else if (cross(cur.second, R.second) >= 0)
merged.back().second = R.second;
}
}
vector<PT> cands;
for (auto pr : merged) {
PT A = pr.first;
PT B = pr.second;
cands.push_back(A);
cands.push_back(B);
}
mt19937 rng(2323423);
shuffle(cands.begin(), cands.end(), rng);
double ans = INF;
for (PT X : cands) {
ans = min(ans, check(X, ans));
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
const long long INF = 1 << 30;
const int mod = 1e9 + 7;
int s[maxn];
int pre[maxn];
void solve() {
int n, w, mixx = 0, maxx = 0;
cin >> n >> w;
for (int i = 1; i <= n; i++) {
cin >> s[i];
pre[i] += s[i] + pre[i - 1];
mixx = min(mixx, pre[i]);
maxx = max(maxx, pre[i]);
}
if (maxx - mixx > w) {
cout << 0 << endl;
} else {
cout << w - (maxx - mixx) + 1 << endl;
}
return;
}
int main() {
int cas = 1, t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, a, b;
cin >> k >> a >> b;
string s;
cin >> s;
int n = s.length();
if ((n < k * a) || (n > k * b)) {
cout << "No solution\n";
} else {
int v[300] = {0};
for (int i = 1; i <= k; i++) {
v[i] = a;
}
int sum = k * a;
while (sum != n) {
for (int i = 1; i <= k && sum != n; i++) {
if (v[i] < b) {
v[i]++;
sum++;
}
}
}
for (int i = 1; i <= k; i++) {
v[i] += v[i - 1];
}
for (int i = 1; i <= k; i++) {
for (int j = v[i - 1]; j < v[i]; j++) {
cout << s[j];
}
cout << endl;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n;
map<int, int> vis;
long long ans = 0;
void dfs(long long x) {
if (x > n) return;
if (vis[x]) return;
vis[x] = 1;
ans++;
dfs(x * 10);
dfs(x * 10 + 1);
}
int main() {
cin >> n;
dfs(1);
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void FastInputOutput() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long binaryToDecimal(string n) {
string num = n;
long long dec_value = 0;
int base = 1;
int len = num.length();
for (int i = len - 1; i >= 0; i--) {
if (num[i] == '1') dec_value += base;
base = base * 2;
}
return dec_value;
}
std::string toBinary(long long n) {
std::string r;
while (n != 0) {
r = (n % 2 == 0 ? "0" : "1") + r;
n /= 2;
}
return r;
}
string ToString(unsigned long long i) {
ostringstream oss;
oss << i;
return oss.str();
}
std::string remove_char(std::string str, char ch) {
str.erase(std::remove(str.begin(), str.end(), ch), str.end());
return str;
}
bool isPrime(int n) {
if (n <= 1) return false;
for (int i = 2; i < n; i++)
if (n % i == 0) return false;
return true;
}
int minSum(int arr[], int n, int k) {
int res = 0, id = 0;
int maxx = INT_MAX;
for (int i = 0; i < n - k; i++) {
for (int j = i; j < i + k; j++) {
res += arr[j];
}
if (res < maxx) {
maxx = res;
id = i + 1;
}
res = 0;
}
return id + 1;
}
int main() {
FastInputOutput();
string LETTRES = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string cons = "bcdfghjklmnpqrstvxzt";
string vowel = "aoyeui";
int n, m, pos = 0, t = 15000001;
cin >> n >> m;
int arr[n];
arr[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
arr[i] += arr[i - 1];
}
for (int i = m; i <= n; i++) {
if (t > arr[i] - arr[i - m]) {
t = arr[i] - arr[i - m];
pos = i;
}
}
cout << pos - m + 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
string s, a;
getline(cin, s);
getline(cin, a);
long long n = s.size();
long long j = 0;
map<char, long long> mp;
for (long long i = 0; i < n; i++) mp[s[i]]++;
long long ans = 1;
for (long long i = 0; i < a.size(); i++) {
if (a[i] != ' ' && !mp[a[i]])
ans = 0;
else
mp[a[i]]--;
}
if (ans)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101;
int n, m, k, a[N];
int read() {
int d = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') d = (d << 3) + (d << 1) + c - 48, c = getchar();
return d * f;
}
void judge() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
int main() {
n = read();
m = read();
k = read();
for (int i = 1; i <= n; i++) a[i] = read();
int ans = 1e9;
for (int i = 0; i <= n; i++) {
int x = m - i, y = m + i;
if (x >= 1 && a[x] != 0 && a[x] <= k) ans = min(ans, i * 10);
if (y <= n && a[y] != 0 && a[y] <= k) ans = min(ans, i * 10);
}
printf("%d", ans);
return 0;
}
| 1 |
// {{{ by shik
#include <bits/stdc++.h>
#include <unistd.h>
#define SZ(x) ((int)(x).size())
#define ALL(x) begin(x),end(x)
#define REP(i,n) for ( int i=0; i<int(n); i++ )
#define REP1(i,a,b) for ( int i=(a); i<=int(b); i++ )
#define FOR(it,c) for ( auto it=(c).begin(); it!=(c).end(); it++ )
#define MP make_pair
#define PB push_back
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
typedef vector<int> VI;
#ifdef SHIK
template<typename T>
void _dump( const char* s, T&& head ) { cerr<<s<<"="<<head<<endl; }
template<typename T, typename... Args>
void _dump( const char* s, T&& head, Args&&... tail ) {
int c=0;
while ( *s!=',' || c!=0 ) {
if ( *s=='(' || *s=='[' || *s=='{' ) c++;
if ( *s==')' || *s==']' || *s=='}' ) c--;
cerr<<*s++;
}
cerr<<"="<<head<<", ";
_dump(s+1,tail...);
}
#define dump(...) do { \
fprintf(stderr, "%s:%d - ", __PRETTY_FUNCTION__, __LINE__); \
_dump(#__VA_ARGS__, __VA_ARGS__); \
} while (0)
template<typename Iter>
ostream& _out( ostream &s, Iter b, Iter e ) {
s<<"[";
for ( auto it=b; it!=e; it++ ) s<<(it==b?"":" ")<<*it;
s<<"]";
return s;
}
template<typename A, typename B>
ostream& operator <<( ostream &s, const pair<A,B> &p ) { return s<<"("<<p.first<<","<<p.second<<")"; }
template<typename T>
ostream& operator <<( ostream &s, const vector<T> &c ) { return _out(s,ALL(c)); }
template<typename T, size_t N>
ostream& operator <<( ostream &s, const array<T,N> &c ) { return _out(s,ALL(c)); }
template<typename T>
ostream& operator <<( ostream &s, const set<T> &c ) { return _out(s,ALL(c)); }
template<typename A, typename B>
ostream& operator <<( ostream &s, const map<A,B> &c ) { return _out(s,ALL(c)); }
#else
#define dump(...)
#endif
template<typename T>
void _R( T &x ) { cin>>x; }
void _R( int &x ) { scanf("%d",&x); }
void _R( long long &x ) { scanf("%" PRId64,&x); }
void _R( double &x ) { scanf("%lf",&x); }
void _R( char &x ) { scanf(" %c",&x); }
void _R( char *x ) { scanf("%s",x); }
void R() {}
template<typename T, typename... U>
void R( T& head, U&... tail ) {
_R(head);
R(tail...);
}
template<typename T>
void _W( const T &x ) { cout<<x; }
void _W( const int &x ) { printf("%d",x); }
template<typename T>
void _W( const vector<T> &x ) {
for ( auto i=x.cbegin(); i!=x.cend(); i++ ) {
if ( i!=x.cbegin() ) putchar(' ');
_W(*i);
}
}
void W() {}
template<typename T, typename... U>
void W( const T& head, const U&... tail ) {
_W(head);
putchar(sizeof...(tail)?' ':'\n');
W(tail...);
}
#ifdef SHIK
#define FILEIO(...)
#else
#define FILEIO(name) do {\
freopen(name ".in","r",stdin); \
freopen(name ".out","w",stdout); \
} while (0)
#endif
// }}}
double rp() {
int p;
R(p);
return p/100.0;
}
double p[6],q[6];
double f( double x ) {
double s=0;
REP(i,6) s+=max(x*p[i],(1-x)*q[i]);
dump(x,s);
return s;
}
int main() {
REP(i,6) p[i]=rp();
REP(i,6) q[i]=rp();
vector<double> v;
v.PB(0);
v.PB(0.5);
v.PB(1);
REP(i,6) if ( p[i]+q[i]!=0 ) v.PB(q[i]/(p[i]+q[i]));
double mi=1;
for ( auto x:v ) mi=min(mi,f(x));
printf("%.14f\n",mi);
return 0;
}
| 0 |
#include<cstdio>
#include<algorithm>
#define N_ 201000
using namespace std;
int n, m, K, UF[N_], C[N_], R[N_], RC;
long long Res;
int Find(int a) {
return a == UF[a] ? a : UF[a] = Find(UF[a]);
}
struct Edge {
int a, b, c;
bool operator<(const Edge &p)const {
return c < p.c;
}
}E[N_];
int main() {
scanf("%d%d%d", &n, &m, &K);
int i, c = K, a, b, d;
for (i = 1; i <= n; i++) {
scanf("%d", &C[i]);
if (!C[i])C[i] = ++c;
}
for (i = 1; i <= c; i++)UF[i] = i;
for (i = 0; i < m; i++) {
scanf("%d%d%d", &E[i].a, &E[i].b, &E[i].c);
}
sort(E, E + m);
for (i = 0; i < m; i++) {
a = Find(C[E[i].a]), b = Find(C[E[i].b]);
if (a != b) {
R[RC++] = E[i].c;
UF[a] = b;
}
}
if (RC < K - 1) {
printf("-1\n");
return 0;
}
sort(R, R + RC);
for (i = 0; i < K - 1; i++)Res += R[i];
printf("%lld\n", Res);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int MaxN = 150, MaxL = (MaxN + 32 - 1) / 32, NA = -1, MaxC = 0x3F3F3F3F;
const int MaxD = 4, MaxBuf = 123456;
const int dx[MaxD] = {-1, 0, 1, 0}, dy[MaxD] = {0, -1, 0, 1};
const char dz[MaxD] = {'L', 'U', 'R', 'D'};
typedef unsigned int table[MaxN][MaxL];
table a;
table d;
table f[2];
char s[MaxBuf];
int k, m, n, x, y;
int main(void) {
int b, i, j, l;
char ch;
bool ok;
while (scanf(" %d %d %d", &n, &m, &k) != EOF) {
memset(a, 0, sizeof(a));
memset(d, 0, sizeof(d));
x = y = NA;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
scanf(" %c", &ch);
switch (ch) {
case 'E':
x = i;
y = j;
d[i][j >> 5] |= 1u << (j & 31);
case '.':
a[i][j >> 5] |= 1u << (j & 31);
break;
case '#':
break;
default:
assert(false);
break;
}
}
b = 0;
memmove(f[b], a, sizeof(table));
scanf(" %s", s);
for (l = 0; l <= k; l++) {
b ^= 1;
table& cur = f[!b];
table& next = f[b];
memset(next, 0, sizeof(table));
ok = true;
for (i = 0; ok && i < n; i++)
for (j = 0; ok && j < MaxL; j++)
if (cur[i][j] != d[i][j]) ok = false;
if (ok) break;
if (l == k) continue;
ch = s[l];
switch (ch) {
case 'L':
for (i = 0; i < n; i++) {
for (j = 0; j < MaxL; j++) next[i][j] |= (cur[i][j] >> 1) & a[i][j];
for (j = 1; j < MaxL; j++)
next[i][j - 1] |=
((cur[i][j] & 1u) << 31) & (a[i][j - 1] & (1u << 31));
}
for (i = 0; i < n; i++) {
for (j = 0; j < MaxL; j++)
next[i][j] |= cur[i][j] & ((~a[i][j]) << 1);
for (j = 1; j < MaxL; j++)
next[i][j] |=
(cur[i][j] & 1u) & (((~a[i][j - 1]) & (1u << 31)) >> 31);
}
break;
case 'U':
for (i = 1; i < n; i++)
for (j = 0; j < MaxL; j++)
next[i - 1][j] |= cur[i][j] & a[i - 1][j];
for (i = 1; i < n; i++)
for (j = 0; j < MaxL; j++) next[i][j] |= cur[i][j] & ~a[i - 1][j];
break;
case 'R':
for (i = 0; i < n; i++) {
for (j = 0; j < MaxL; j++) next[i][j] |= (cur[i][j] << 1) & a[i][j];
for (j = 0; j < MaxL - 1; j++)
next[i][j + 1] |= (cur[i][j] >> 31) & a[i][j + 1] & 1u;
}
for (i = 0; i < n; i++) {
for (j = 0; j < MaxL; j++)
next[i][j] |= cur[i][j] & ((~a[i][j]) >> 1);
for (j = 0; j < MaxL - 1; j++)
next[i][j] |= ((cur[i][j] >> 31) & (~a[i][j + 1]) & 1u) << 31;
}
break;
case 'D':
for (i = 0; i < n - 1; i++)
for (j = 0; j < MaxL; j++)
next[i + 1][j] |= cur[i][j] & a[i + 1][j];
for (i = 0; i < n - 1; i++)
for (j = 0; j < MaxL; j++) next[i][j] |= cur[i][j] & ~a[i + 1][j];
break;
default:
assert(false);
break;
}
}
if (l > k) l = NA;
printf("%d\n", l);
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
using ll = long long;
int mod = 1000000000+7;
int main(){
int d;
cin>>d;
int c[26];
rep(i,26)cin>>c[i];
int lastd[26]={};
int s[d][26];
rep(i,d){
rep(j,26)cin>>s[i][j];
}
int t[d];
rep(i,d){
cin>>t[i];
t[i]--;
}
ll ans=0;
rep(i,d){
ans+=s[i][t[i]];
lastd[t[i]]=i+1;
rep(j,26){
ans-=c[j]*(i+1-lastd[j]);
}
cout<<ans<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, scc, ind;
int dfn[100005], low[100005], instack[100005];
int belong[100005];
int sum[100005];
vector<int> v[100005];
stack<int> st;
void tarjan(int x) {
dfn[x] = low[x] = ++ind;
instack[x] = 1;
st.push(x);
for (int i = 0; i < v[x].size(); i++) {
int V = v[x][i];
if (!dfn[V]) {
tarjan(V);
low[x] = min(low[x], low[V]);
} else if (instack[V])
low[x] = min(low[x], dfn[V]);
}
if (dfn[x] == low[x]) {
static int now;
scc++;
while (now != x) {
now = st.top();
st.pop();
instack[now] = 0;
belong[now] = scc;
sum[scc]++;
}
}
}
int father[100005], flag[100005];
int findf(int x) { return father[x] == x ? x : father[x] = findf(father[x]); }
void mergef(int x, int y) {
father[x] = y;
sum[y] += sum[x];
flag[y] |= flag[x];
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) {
static int x, y;
x = read(), y = read();
v[x].push_back(y);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
int ans = 0;
for (int i = 1; i <= scc; i++)
if (sum[i] > 1) flag[i] = 1;
for (int i = 1; i <= scc; i++) father[i] = i;
for (int i = 1; i <= n; i++)
for (int j = 0; j < v[i].size(); j++) {
int V = v[i][j];
if (belong[i] != belong[V]) {
static int x, y, fx, fy;
x = belong[i], y = belong[V];
fx = findf(x), fy = findf(y);
if (fx != fy) mergef(fx, fy);
}
}
for (int i = 1; i <= scc; i++)
if (findf(i) == i) {
ans += sum[i] - 1;
if (flag[i]) ans++;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
vector<long long> a(n / 2);
for (long long& x : a) cin >> x;
vector<long long> ans(n);
long long p = 0;
for (long long i = 0; i < n / 2; i++) {
long long mn = LLONG_MAX;
for (long long j = 1; j * j <= a[i]; j++) {
if (a[i] % j) continue;
if (j == a[i] / j) continue;
if (j % 2 != (a[i] / j) % 2) continue;
long long ta = a[i] / j;
ta -= j;
ta /= 2;
if (ta <= 0) continue;
if (ta * ta > p) {
mn = min(ta, mn);
}
}
if (mn == LLONG_MAX) {
cout << "No";
return 0;
}
ans[i * 2] = mn * mn;
ans[i * 2 + 1] = ans[i * 2] + a[i];
p = ans[i * 2 + 1];
}
for (long long i = n - 2; i > -1; i--) ans[i + 1] -= ans[i];
cout << "Yes" << endl;
for (long long& x : ans) cout << x << " ";
}
| 5 |
#include<iostream>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<string>
#include<algorithm>
#include<utility>
#include<math.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
const int INF = pow(10, 8);
int main(){
int n, m;cin>>n>>m;char z;
vector<vector<int> > dis(n, vector<int>(n, INF));
for(int i=0;i<m;i++){
int a, b, c, d;cin>>a>>z>>b>>z>>c>>z>>d;
a--;b--;
dis[a][b]=c;dis[b][a]=d;
}
for(int i=0;i<n;i++)dis[i][i]=0;
int s, g, v, p;cin>>s>>z>>g>>z>>v>>z>>p;s--;g--;
int ans=v-p;
for(int k=0;k<n;k++){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
dis[i][j]=min(dis[i][j], dis[i][k]+dis[k][j]);
}
}
}
ans -= dis[s][g]+dis[g][s];
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int depth[N];
vector<int> g[N];
int k, n;
int minleaf[N];
bool leaf(int u) { return u != 1 and g[u].size() == 0; }
void dfs(int u, int d) {
depth[u] = d;
if (leaf(u))
minleaf[u] = d;
else
minleaf[u] = 0x3f3f3f3f;
for (int v : g[u]) {
dfs(v, d + 1);
minleaf[u] = min(minleaf[u], minleaf[v]);
}
}
int cnt[N];
void dfs2(int u) {
if (leaf(u)) {
cnt[u] = 1;
return;
}
for (int v : g[u]) dfs2(v);
if (minleaf[u] - depth[u] >= k) return;
for (int v : g[u]) cnt[u] += cnt[v];
}
int solve(int u) {
if (leaf(u)) return 1;
int sum = 0;
for (int v : g[u]) sum += cnt[v];
int ans = 0;
for (int v : g[u]) ans = max(ans, sum - cnt[v] + solve(v));
return ans;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
g[p].push_back(i);
}
dfs(1, 0);
dfs2(1);
printf("%d\n", solve(1));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3100;
int n, m;
int d[N];
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> d[i];
}
if (m == 0) {
puts("YES");
return 0;
}
sort(d, d + m);
if (d[0] == 1 || d[m - 1] == n) {
puts("NO");
return 0;
}
for (int i = 0; i < m - 2; i++) {
if (d[i] + 1 == d[i + 1] && d[i + 1] + 1 == d[i + 2]) {
puts("NO");
return 0;
}
}
puts("YES");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, c = 0, s = 0;
cin >> n;
if (n % 3 == 0) {
s = n / 3;
c = s * 2;
}
if (n % 3 != 0) {
s = n / 3;
c = (s * 2) + 1;
}
cout << c << "\n";
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
template<typename T>
map<T, Int> factorize(T x){
map<T, Int> res;
for(Int i=2;i*i<=x;i++){
while(x%i==0){
x/=i;
res[i]++;
}
}
if(x!=1) res[x]++;
return res;
}
template<typename T>
vector<T> compress(vector<T> v){
sort(v.begin(),v.end());
v.erase(unique(v.begin(),v.end()),v.end());
return v;
}
template<typename T>
map<T, Int> dict(const vector<T> &v){
map<T, Int> res;
for(Int i=0;i<(Int)v.size();i++)
res[v[i]]=i;
return res;
}
//INSERT ABOVE HERE
signed main(){
Int n;
cin>>n;
vector<Int> v;
for(Int i=1;i*i<=n;i++){
if(n%i) continue;
v.emplace_back(i);
if(i!=1) v.emplace_back(n/i);
}
v=compress(v);
auto m=factorize(n);
cout<<m.size()<<" "<<v.size()<<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long n,x;
cin>>n>>x;
long long t=n-x,ans=0,tmp;
while(x){
ans+=t/x*x*3;
tmp=x;
x=t%x;
t=tmp;
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int a[N];
int main() {
int n, i;
long long sol1 = 0, sol2 = 0, s = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) {
if (a[i] == 0) {
sol1 += s;
} else
++s;
}
s = 0;
for (i = n; i; i--) {
if (a[i] == 1) {
sol2 += s;
} else
++s;
}
sol1 = min(sol1, sol2);
printf("%I64d", sol1);
}
| 1 |
#include <iostream>
using namespace std;
int main(){
int p[33]={1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
int k;
cin>>k;
cout<<p[k-1]<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, r;
double dist(double a, double b, double c, double d) {
return sqrt((a - c) * (a - c) + (b - d) * (b - d));
}
bool small(double rad) {
double x = 0, y = rad + r;
double ini = 0.1, fim = 180;
int iter = 200;
while (iter--) {
double meio = (ini + fim) / 2;
double dr = meio * acos(-1) / 180.0;
double nx = x * cos(dr) - y * sin(dr);
double ny = x * sin(dr) + y * cos(dr);
if (dist(x, y, nx, ny) < rad * 2)
ini = meio;
else
fim = meio;
}
if (ini * n < 360.0) return true;
return false;
}
int main() {
scanf("%d %d", &n, &r);
double ini = 0.00001, fim = 1000;
int iter = 200;
while (iter--) {
double meio = (ini + fim) / 2;
if (small(meio))
ini = meio;
else
fim = meio;
}
printf("%.10f\n", ini);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 7;
vector<long long> g[MAXN];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
long long n, s;
cin >> n >> s;
for (long long i = 0; i < n - 1; ++i) {
long long u, v;
cin >> u >> v;
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
long long l = 0;
for (long long i = 0; i < n; ++i) {
l += (g[i].size() == 1);
}
cout << 2 * (long double)(s) / l << '\n';
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
const int maxn=311,maxt=200011;
int n,m,t,s[maxn],w[maxn][maxn],a[maxt],b[maxt];
void init(){
scanf("%d%d%d",&n,&m,&t);
for (int i=1;i<=m;++i) scanf("%d",s+i);
for (int i=1;i<=n;++i) for (int j=1;j<=m;++j) scanf("%d",&w[i][j]);
for (int i=1;i<=t;++i) scanf("%d%d",a+i,b+i);
}
bool check(int t){
static int sx[maxn]; memcpy(sx,s,sizeof(s));
static int wx[maxn][maxn]; memset(wx,0,sizeof(w));
for (int i=1;i<=t;++i){
--sx[b[i]]; ++wx[a[i]][b[i]];
}
static bool vis[maxn]; memset(vis,0,sizeof(vis));
for (int t=1;t<=n;++t){
for (int i=1;i<=n;++i) if (!vis[i]){
bool flag=1;
for (int j=1;j<=m;++j) if (wx[i][j]+max(0,sx[j])<w[i][j]){flag=0; break;}
if (flag){
vis[i]=1;
for (int j=1;j<=m;++j) sx[j]+=wx[i][j];
}
}
}
for (int i=1;i<=n;++i) if (!vis[i]) return true;
return false;
}
void work(){
int t=1,w=::t;
while (t<=w){
int mid=(t+w)>>1;
if (check(mid)) w=mid-1;else t=mid+1;
}
printf("%d\n",w==::t?-1:w+1);
}
int main(){
init();
work();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool valid = true;
vector<int> seq;
vector<int> pos[200010];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
pos[x].push_back(i + 1);
}
int x = 0;
for (int i = 0; i < n; i++) {
while (x >= 0 && pos[x].empty()) {
x -= 3;
}
if (x < 0) {
cout << "Impossible" << endl;
return 0;
}
seq.push_back(pos[x].back());
pos[x].pop_back();
x++;
}
cout << "Possible" << endl;
for (int i = 0; i < n - 1; ++i) {
cout << seq[i] << " ";
}
cout << seq[n - 1] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse3,sse4,popcnt,abm,mmx")
using namespace std;
const int N = (int)5e5 + 7, MOD = (int)1e9 + 7;
int n, k;
pair<pair<int, int>, int> a[N];
map<int, long long> mp;
long long cnt;
deque<int> v;
bool cmp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
return a.second < b.second;
}
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i].first.first;
a[i].second = i;
}
for (int i = 1; i <= n; i++) {
cin >> a[i].first.second;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
mp[a[i].first.first] = cnt + a[i].first.second;
if ((int)v.size() < k) {
v.push_back(a[i].first.second);
cnt += a[i].first.second;
continue;
}
sort(v.begin(), v.end());
if (v[0] < a[i].first.second) {
v.push_back(a[i].first.second);
sort(v.begin(), v.end());
v.erase(v.begin());
cnt = 0;
for (int j = 0; j < (int)v.size(); j++) {
cnt += v[j];
}
}
}
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; i++) {
cout << mp[a[i].first.first] << ' ';
}
exit(0);
}
| 2 |
#include <bits/stdc++.h>
int f[1024][1024];
bool p[10][10];
int main() {
int n, m, k, i, j, s, x, y, ans = 0;
scanf("%d %d %d", &n, &m, &k);
memset(p, false, sizeof(p));
memset(f, 0, sizeof(f));
for (i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
x--;
y--;
p[x][y] = p[y][x] = true;
f[(1 << x) | (1 << y)][(1 << x) | (1 << y)] = 1;
}
f[0][0] = 1;
for (i = 1; i < (1 << n); i++)
for (j = 1; j < i; j++)
if (f[i][j] != 1) {
s = 0;
for (x = 0; x < n; x++)
if (j & (1 << x)) s++;
if (s) {
for (x = 0; x < n; x++)
if ((i & (1 << x)) && !(j & (1 << x)))
for (y = 0; y < n; y++)
if ((j & (1 << y)) && p[x][y])
f[i][j] += f[i ^ (1 << y)][j ^ (1 << x) ^ (1 << y)] +
f[i ^ (1 << y)][j ^ (1 << y)];
f[i][j] /= s;
}
}
for (i = 0; i < (1 << n); i++) {
s = 0;
for (j = 0; j < n; j++)
if ((i & (1 << j)) != 0) s++;
if (s == k) ans += f[(1 << n) - 1][i];
}
printf("%d", ans);
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
void yes() {
cout << "Yes"
<< "\n";
}
void no() {
cout << "No"
<< "\n";
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
struct FAIL {
FAIL() {
cout << "CHANGE!!!"
<< "\n";
}
};
long long pow_fast(long long x, long long y) {
if (y == 0) {
return 1;
}
if (y % 2) {
return x * pow_fast(x, y - 1) % MOD;
}
long long t = pow_fast(x, y / 2);
return t * t % MOD;
}
vector<int> divisors;
vector<int> prime_divisors;
long long g(int x) { return pow_fast(2, x - 1); }
long long mebius(int x) {
int res = 0;
for (int prime : prime_divisors) {
if (x % prime == 0) {
x /= prime;
res ^= 1;
if (x % prime == 0) {
return 0;
}
}
}
if (!res) {
return 1;
}
return -1;
}
long long f(int x) {
long long res = 0;
for (int div : divisors) {
res += (mebius(div) * g(x / div)) % MOD;
res += MOD;
res %= MOD;
}
return res;
}
vector<int> get_divisors(int n) {
int s = sqrt(n);
vector<int> div;
for (int i = (1); i < (s + 1); ++i) {
if (n % i == 0) {
div.push_back(i);
}
}
vector<int> div2;
for (auto i : div) {
div2.push_back(n / i);
}
if (div2.back() == div.back()) {
div2.pop_back();
}
reverse(div2.begin(), div2.end());
div.insert(div.end(), div2.begin(), div2.end());
return div;
}
vector<int> get_prime_divisors(int n) {
int s = sqrt(n);
vector<int> res;
for (int i = (2); i < (s + 1); ++i) {
if (n % i == 0) {
res.push_back(i);
while (n % i == 0) {
n /= i;
}
}
}
if (n > 1) {
res.push_back(n);
}
return res;
}
int main() {
int k, n;
cin >> k >> n;
if (n % k) {
cout << 0;
return 0;
}
n /= k;
divisors = get_divisors(n);
prime_divisors = get_prime_divisors(n);
cout << f(n);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s, s1;
cin >> s;
for (int i = 4; i <= s - 4; i++) {
for (int j = 2; j <= sqrt(i); j++)
if (i % j == 0)
for (int k = 2; k <= sqrt(s - i); k++)
if ((s - i) % k == 0) {
printf("%d %d", i, s - i);
return 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline int msbp(int x) { return 31 - __builtin_clz(x); }
inline int msb(int x) { return 1 << msbp(x); }
const int INF = 0x3f3f3f3f;
long long n, xl, xm, xr, yl, ym, yr;
void query(long long x, long long y) {
int res;
cout << x << ' ' << y << endl;
cin >> res;
if (res == 0)
exit(0);
else if (res == 1) {
if (xm == x) {
xm = xr;
yr = ym;
}
xl = x + 1;
} else if (res == 2) {
if (ym == y) {
ym = yr;
xr = xm;
}
yl = y + 1;
} else {
xm = x;
ym = y;
}
}
long double area(long double x1, long double x2, long double y1,
long double y2) {
return (y1 - y2) * (x1 - x2);
}
signed main() {
ios::sync_with_stdio(false);
cin >> n;
xm = xr = ym = yr = n + 1;
while (xl < xm + 1 && yl < ym + 1) {
long double sa = area(xl, xm, yl, ym);
long double sb = area(xl, xm, ym, yr);
long double sc = area(xm, xr, yl, ym);
long long xh = (xl + xm) / 2, yh = (yl + ym) / 2;
if (sa >= sb - sc && sa >= sc - sb) {
query(xh, yh);
} else if (sb > sa + sc) {
query(xh, ym);
} else if (sc > sa + sb) {
query(xm, yh);
} else {
assert(false);
}
}
query(xl, yl);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, i, r = 0, a, m = 0;
cin >> n >> k;
long long b[n + 1];
b[0] = 0;
for (i = 1; i <= n; i++) {
cin >> a;
b[i] = b[i - 1] + a;
if (b[i] - b[m] <= k) {
r = max(r, i - m);
} else
m++;
}
cout << r;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
inline bool mina(A &x, B y) {
return (x > y) ? (x = y, 1) : 0;
}
template <typename A, typename B>
inline bool maxa(A &x, B y) {
return (x < y) ? (x = y, 1) : 0;
}
int N, M, K;
char S[(100004)];
int P[10][(100004)];
int main() {
cin >> N >> K >> M;
scanf("%s", S);
for (int _b = (N), i = (0); i < _b; ++i) {
int a = i % K;
int b = i / K;
P[a][b + 1] = P[a][b] + S[i] - '0';
}
for (int _b = (M), i = (0); i < _b; ++i) {
int l, r;
scanf("%d %d", &l, &r);
--l;
--r;
int res = 0;
for (int _b = (K), j = (0); j < _b; ++j) {
int a = (l + j) % K;
int b = (l + j) / K;
int c = (r + j + 1) / K;
int t = P[a][c] - P[a][b];
if (j + 1 == K) t = (r - l + 1) / K - t;
res += t;
}
printf("%d\n", res);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct _ {
long long x, y, a;
bool operator<(const _ &ob) const { return x < ob.x; }
} a[1000010];
long long b[1000010];
struct point {
long long x, y;
};
long long dp[1000010];
deque<point> q;
long long calc(point x, long long k) { return x.x * -k + x.y; }
long long slope(point a, point b) { return (b.y - a.y) / (b.x - a.x + 1e-10); }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int i;
for (i = 1; i <= n; ++i) {
cin >> a[i].x >> a[i].y >> a[i].a;
}
sort(a + 1, a + 1 + n);
for (i = 1; i <= n; ++i) b[i] = a[i].x * a[i].y - a[i].a;
q.push_back((point){0, 0});
for (i = 1; i <= n; ++i) {
long long d = b[i] / a[i].y;
while (q.size() > 1) {
if (calc(q[1], a[i].y) >= calc(q[0], a[i].y))
q.pop_front();
else
break;
}
dp[i] = calc(q[0], a[i].y) + b[i];
point tmp = (point){a[i].x, dp[i]};
while (q.size() > 1) {
if (slope(q[q.size() - 2], q.back()) < slope(q.back(), tmp))
q.pop_back();
else
break;
}
q.push_back(tmp);
}
long long max_ = 0;
for (i = 1; i <= n; ++i) max_ = max(max_, dp[i]);
cout << max_ << '\n';
return 0;
}
| 5 |
#include <iostream>
#include <queue>
using namespace std;
int main() {
int k; cin >> k;
queue<long long> q;
for (int i = 1; i <= 9; ++i) q.push(i);
int cnt = 0;
while (true) {
++cnt;
long long t = q.front(); q.pop();
if (cnt == k) {
cout << t << endl;
break;
}
for (int i = -1; i < 2; ++i) {
int d = t % 10 + i;
if (0 <= d && d <= 9) q.push(t * 10 + d);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define all(a)(a).begin(),(a).end()
using namespace std;
typedef long long ll;
int check(vector<vector<int>>& v) {
int k = 0;
for (int i = 1; i < v.size(); ++i) {
int x = 0;
for (int j = 0; j < v[0].size(); ++j) x += (v[i][j] != v[0][j]);
if (x > 4) return x;
k = max(k, x);
}
return k;
}
signed main() {
#ifdef _DEBUG
freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int n, m; cin >> n >> m;
vector<vector <int>> v(n, vector<int>(m));
vector <int> q;
for (auto& i : v) for (auto& j : i) cin >> j;
int k = 0, a = 0, b = 0;
for (int i = 1; i < v.size(); ++i) {
int x = 0;
for (int j = 0; j < v[0].size(); ++j) x += (v[i][j] != v[0][j]);
k = max(k, x);
if (x > 2) q.push_back(i), (x == 3 ? a : b)++;
}
if (k > 4 || a >= 10000) { // магия, превращающая 02:28:51 в 00:01:47 ъйэъйъ(
cout << "No\n"; exit(0);
}
if (k <= 2) {
cout << "Yes\n";
for (auto& i : v[0]) cout << i << ' '; exit(0);
}
for (int iii = 0; iii < q.size(); ++iii) {
int i = q[iii];
vector<int> p, pp;
for (int j = 0; j < m; ++j) if (v[0][j] != v[i][j]) p.push_back(j), pp.push_back(v[0][j]);
for (int j = 0; j < p.size(); ++j) {
for (int jj = 0; jj < p.size(); ++jj) {
v[0][p[j]] = v[i][p[j]], v[0][p[jj]] = v[i][p[jj]];
if (check(v) <= 2) {
cout << "Yes\n";
for (auto& kk : v[0]) cout << kk << ' '; exit(0);
}
v[0][p[j]] = pp[j], v[0][p[jj]] = pp[jj];
}
}
for (int hh = 0; hh < iii; ++hh) {
int ii = q[hh];
vector<int> p1, pp1;
for (int j = 0; j < m; ++j) if (v[0][j] != v[ii][j]) p1.push_back(j), pp1.push_back(v[0][j]);
for (int j = 0; j < p.size(); ++j) {
for (int jj = 0; jj < p1.size(); ++jj) {
if (p[j] != p1[jj]) {
v[0][p[j]] = v[i][p[j]], v[0][p1[jj]] = v[ii][p1[jj]];
if (check(v) <= 2) {
cout << "Yes\n";
for (auto& kk : v[0]) cout << kk << ' '; exit(0);
}
v[0][p[j]] = pp[j], v[0][p1[jj]] = pp1[jj];
}
}
}
}
}
cout << "No\n"; // ну ой
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
long long int x;
cin >> x;
long long int mn = (s[0] - '0') * 10 + (s[1] - '0');
mn *= 60;
mn += (s[3] - '0') * 10 + (s[4] - '0');
mn += x;
long long int minute = mn % 60;
long long int hour = mn / 60;
if (hour >= 24) {
hour %= 24;
}
if (hour < 10) cout << "0";
cout << hour << ":";
if (minute < 10) cout << "0";
cout << minute << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
template <class T>
inline void umin(T &x, T y) {
x = x < y ? x : y;
}
template <class T>
inline void umax(T &x, T y) {
x = x > y ? x : y;
}
inline unsigned int R() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
int n, m;
struct yzr {
double p[3333], val, qz[3333];
vector<vector<double> > f;
void init() {
for (register int i = (1); i <= (n); i++) p[i] /= 1000;
f.resize(1);
f[0].resize(n + 1);
f[0][0] = 1;
for (register int i = (1); i <= (n); i++)
f[0][i] = f[0][i - 1] * (1 - p[i]);
qz[0] = f[0][n];
val = 1 - qz[0];
}
void upd() {
f.push_back(vector<double>());
int j = ((int)f.size()) - 1;
f[j].resize(n + 1);
f[j][0] = 0;
for (register int i = (1); i <= (n); i++)
f[j][i] = f[j - 1][i - 1] * p[i] + f[j][i - 1] * (1 - p[i]);
qz[j] = qz[j - 1] + f[j][n];
val = 1 - qz[j];
}
} a[303];
priority_queue<pair<double, int> > heap;
int main() {
read(n);
read(m);
for (register int i = (1); i <= (n); i++)
for (register int j = (1); j <= (m); j++) {
int x;
read(x);
a[j].p[i] = x;
}
for (register int i = (1); i <= (m); i++)
a[i].init(), heap.push(pair<double, int>(a[i].val, i));
double res = 0;
for (register int i = (1); i <= (n); i++) {
pair<double, int> tmp = heap.top();
heap.pop();
res += tmp.first;
a[tmp.second].upd();
heap.push(pair<double, int>(a[tmp.second].val, tmp.second));
}
printf("%.9lf", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> b(1, 0);
int l = 0, r = 0;
while (l < n) {
while (r + 1 < n && a[r] != a[r + 1]) r++;
b.push_back(r - l + 1);
l = ++r;
}
b.push_back(0);
int ans = 0;
for (int i = 0; i + 2 < b.size(); i++) {
ans = max(ans, b[i] + b[i + 1] + b[i + 2]);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <vector>
using namespace std;
const int kMod = 1000000007;
int solution(const string &s) {
//TODO: check if s is valid
int n = s.length();
vector<int> f(4, 0);
f[0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 2; j >= 0; --j) {
if (s[i] == '?') {
f[j + 1] = (f[j + 1] * 3LL + f[j]) % kMod;
} else if (s[i] == 'A' + j) {
f[j + 1] = (f[j + 1] + f[j]) % kMod;
}
}
if (s[i] == '?') f[0] = f[0] * 3LL % kMod;
}
return f[3];
}
int main() {
string s;
cin >> s;
cout << solution(s) <<endl;
return 0;
}
| 0 |
#include<string>
#include<iostream>
#include<vector>
#include<map>
#include<algorithm>
#define all(c) c.begin(),c.end()
#define pb push_back
using namespace std;
typedef pair<int,string> P;
int main(){
int n;
while(cin>>n,n){
vector<P> ans(n);
vector<vector<int> > v(n);
map<int,int> mp;
int m,x;
for(int i=0;i<n;i++){
string s;
cin>>s>>m;
ans[i]=P(0,s);
for(int j=0;j<m;j++){
cin>>x;
v[i].pb(x);
mp[x]++;
}
}
for(int i=0;i<n;i++){
for(int j=0;j<v[i].size();j++){
ans[i].first=ans[i].first+n-mp[v[i][j]]+1;
}
}
sort(all(ans));
cout<<ans[0].first<<" "<<ans[0].second<<endl;
}
return 0;
}
| 0 |
#include<iostream>
using namespace std;
typedef long long int LL;
const LL MAX=(LL)1<<60;
LL x[200005];
LL t[200005];
int main(){
LL n,m;
LL a,b,c;
LL i,j,k;
LL s=(LL)1<<60;
cin>>n>>m;
for(i=0;i<n;i++){
cin>>x[i];
if(i==0)t[i]=x[i];
else t[i]=t[i-1]+x[i];
}
for(i=1;i<=n;i++){
a=m*(i+n);
for(j=n-1,k=0;j>=0;j-=i,k++){
if(k==0)a+=t[j]*(LL)5;
else if(k>1)a+=t[j]*(LL)2;
if(a>MAX)break;
}
if(s>a)s=a;
}
cout<<s<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int n;
string s;
int main() {
cin >> n >> s;
int MAX = 0;
for (int i = 1; i < s.size(); i++) {
if (s[i] >= s[MAX])
MAX = i;
else {
printf("YES\n%d %d\n", MAX + 1, i + 1);
return 0;
}
}
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, s, d = 1, c = 0;
scanf("%d", &n);
s = n / 2;
for (i = 0; i < n;) {
for (j = 0; j < s; j++) {
printf("*");
}
for (j = 0; j < d; j++) {
printf("D");
}
for (j = 0; j < s; j++) {
printf("*");
}
i++;
if (i == (n / 2) + 1) c = 1;
if (c == 0) {
d += 2;
s--;
} else if (c == 1) {
d -= 2;
s++;
}
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, d, i, j, c, e = 0;
cin >> n >> d;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (j != i) {
c = abs(a[j] - a[i]);
if (c <= d) e++;
}
}
}
cout << e << endl;
return;
}
int main() { solve(); }
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int momen, skip;
cin >> momen >> skip;
int ou = 0;
int cur = 1;
for (int i = 0; i < momen; i++) {
int l, r;
cin >> l >> r;
int nc = (l - cur) / skip;
cur += nc * skip;
ou += (r - cur) + 1;
cur = r + 1;
}
cout << ou << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400010, LGN = 20, LGN1 = LGN - 1;
int wt[N];
int prt[N][LGN];
long long sum[N][LGN];
void change(int u, int v, int w);
int query(int u, long long x);
int main() {
long long last = 0;
int n, cnt = 1;
scanf("%d", &n);
while (n--) {
int opt;
long long p, q;
scanf("%d%lld%lld", &opt, &p, &q);
p ^= last;
q ^= last;
if (opt == 1)
change(++cnt, p, q);
else
printf("%lld\n", last = query(p, q));
}
return 0;
}
void change(int u, int v, int w) {
wt[u] = w;
for (int i = LGN1; i >= 0; --i)
if (wt[prt[v][i]] < w && prt[v][i] != 0) v = prt[v][i];
if (wt[prt[v][0]] >= w && wt[v] < w && prt[v][0] != 0) v = prt[v][0];
if (wt[v] >= w) prt[u][0] = v;
sum[u][0] = w;
for (int i = 1; i < LGN; ++i) {
prt[u][i] = prt[prt[u][i - 1]][i - 1];
sum[u][i] = sum[u][i - 1] + sum[prt[u][i - 1]][i - 1];
}
}
int query(int u, long long x) {
int ret = 0;
for (int i = LGN1; i >= 0; --i)
if (prt[u][i] != 0 && sum[u][i] <= x) {
x -= sum[u][i];
u = prt[u][i];
ret += 1 << i;
}
if (wt[u] <= x) ++ret;
return ret;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
map<string, string> users;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
string oldU, newU;
cin >> oldU >> newU;
if (users[oldU] != "")
users[newU] = users[oldU];
else
users[newU] = oldU;
users.erase(oldU);
}
cout << users.size() << endl;
for (auto it : users) cout << it.second << " " << it.first << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double pi = 3.141592653589793238462643383279;
vector<long long> res;
void brute(int pos, int cnt, long long cur) {
if (pos == 18) {
res.push_back(cur);
return;
}
brute(pos + 1, cnt, cur * 10);
if (cnt < 3) {
for (int i = 1; i <= 9; ++i) brute(pos + 1, cnt + 1, cur * 10 + i);
}
}
void solve() {
long long L, R;
cin >> L >> R;
cout << upper_bound((res).begin(), (res).end(), R) -
lower_bound((res).begin(), (res).end(), L);
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long testCases = 1;
brute(0, 0, 0);
res.push_back(1000000000000000000);
cin >> testCases;
while (testCases--) {
solve();
cout << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int tri[20];
void pre() {
tri[0] = 1;
for (int i = 1; i < 19; i++) tri[i] = tri[i - 1] * 2;
}
int indexer(int i, int n) {
int index = 0;
for (int j = 0; j < 19; j++) {
if (i + tri[j] > n) break;
index = i + tri[j];
}
return index - 1;
}
int main() {
int n;
vector<int> arr;
cin >> n;
pre();
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
arr.push_back(temp);
}
int last_index_odd, last_index_evens;
if (n % 2 == 0) {
last_index_evens = n - 1;
last_index_odd = n - 2;
} else {
last_index_odd = n - 1;
last_index_evens = n - 2;
}
int sum = 0;
for (int i = 0; i < n - 1; i++) {
int get_index = indexer(i + 1, n);
arr[get_index] += arr[i];
sum += arr[i];
arr[i] = 0;
cout << sum << endl;
}
}
| 1 |
#include <bits/stdc++.h>
void input(std::size_t &n, std::vector<int> &nums) {
std::cin >> n;
nums.resize(n);
for (size_t i = 0; i < n; i++) {
std::cin >> nums[i];
}
}
void output(std::vector<char> &res) {
if (res.empty()) {
std::cout << "NO" << std::endl;
} else {
std::cout << "YES" << std::endl;
for (auto r : res) {
std::cout << r;
}
std::cout << std::endl;
}
}
std::vector<char> solve(std::size_t n, std::vector<int> &nums) {
std::unordered_map<int, int> counts;
for (auto n : nums) {
counts[n]++;
}
int uniques = 0, many = -1;
for (auto p : counts) {
if (p.second == 1)
uniques++;
else if (p.second >= 3)
many = p.first;
}
std::vector<char> res;
res.resize(n);
if (uniques % 2 == 0) {
int acnt = 0;
for (size_t i = 0; i < n; i++) {
if (counts[nums[i]] == 1 && acnt < uniques / 2) {
res[i] = 'A';
acnt++;
} else if (counts[nums[i]] == 1 && acnt == uniques / 2) {
res[i] = 'B';
} else {
res[i] = 'A';
}
}
return res;
} else if (many != -1) {
int acnt = 0;
for (size_t i = 0; i < n; i++) {
if (counts[nums[i]] == 1 && acnt < uniques / 2) {
res[i] = 'A';
acnt++;
} else if (counts[nums[i]] == 1) {
res[i] = 'B';
} else if (nums[i] == many) {
res[i] = 'A';
many = -1;
} else {
res[i] = 'B';
}
}
return res;
} else {
res.resize(0);
return res;
}
}
int main() {
std::size_t n = 0;
std::vector<int> nums;
input(n, nums);
std::vector<char> res = solve(n, nums);
output(res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[100010], n;
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
if (a[n]) {
printf("NO\n");
continue;
}
if (n == 1) {
printf("YES\n");
printf("0\n");
} else if (n == 2) {
if (a[1]) {
printf("YES\n");
printf("1->0\n");
} else {
printf("NO\n");
}
} else {
if (a[n - 1]) {
printf("YES\n");
for (int i = 1; i <= n - 1; i++) printf("%d->", a[i]);
printf("%d", a[n]);
} else {
int fg = -1;
for (int i = n - 2; i >= 1; i--)
if (!a[i]) {
fg = i;
break;
}
if (fg == -1) {
printf("NO\n");
continue;
}
printf("YES\n");
for (int i = 1; i < fg; i++) printf("%d->", a[i]);
for (int i = fg; i <= n - 2; i++) printf("(%d->", a[i]);
printf("%d", a[n - 1]);
for (int i = fg; i <= n - 2; i++) printf(")");
printf("->%d\n", 0);
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
long long n;
while (cin >> n) {
cout << 0 << " " << 0 << " " << n << endl;
}
return EXIT_SUCCESS;
}
| 1 |
#include <iostream>
using namespace std;
int cntPair[2002];
int ans[4002];
int main(){
for(int i = 0; i <= 1000; i++){
for(int j = 0; j <= 1000; j++){
cntPair[i + j]++;
}
}
for(int i = 0; i <= 2000; i++){
for(int j = 0; j <= 2000; j++){
ans[i + j] += cntPair[i] * cntPair[j];
}
}
int n;
while(cin >> n){
cout << ans[n] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1000000007;
int fpow(int a, int b) {
int ans = 1, t = a;
while (b) {
if (b & 1) ans = 1ll * ans * t % Mod;
t = 1ll * t * t % Mod;
b >>= 1;
}
return ans;
}
int f[5010];
int g[5010];
int a[5010];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
g[0] = 1;
int inv = fpow(n, Mod - 2);
for (int i = 1; i <= n; i++)
g[i] = 1ll * g[i - 1] * (k - i + 1) % Mod * (Mod - inv) % Mod;
f[0] = 1;
for (int i = 1; i <= n; i++)
for (int j = i; j > 0; j--) f[j] = (f[j] + 1ll * f[j - 1] * a[i]) % Mod;
int ans = 0;
for (int i = 0; i < n; i++) ans = (ans + 1ll * (Mod - g[n - i]) * f[i]) % Mod;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long alp = 0;
long long check(long long d, vector<long long> e, long long m, long long t,
long long n) {
long long ans = 0;
alp = 0;
long long con = 0, un = 1;
long long x = 0;
for (long long i = 0; i < n; i++) {
if (e[i] <= d && (ans + e[i]) > t) {
un = 0;
break;
}
if (e[i] <= d) {
ans += e[i];
con += e[i];
x++;
}
if (x == m) {
alp += m;
x = 0;
ans += con;
con = 0;
}
}
alp += x;
return un;
}
void run() {
long long n, m, t;
cin >> n >> m >> t;
vector<long long> as;
long long mi = 0, a, ma = 100000000000007;
for (long long i = 0; i < n; i++) {
cin >> a;
as.push_back(a);
mi = max(mi, a);
ma = min(ma, a);
}
long long init = ma, fin = mi;
long long d = (init + fin) / 2;
long long mz = ma;
while (fin > init) {
d = (fin + init) / 2;
if (check(d, as, m, t, n)) {
init = d + 1;
mz = max(mz, d);
} else {
fin = d;
}
}
if (check(init, as, m, t, n)) {
mz = init;
}
check(mz, as, m, t, n);
long long alp1 = alp;
long long j = mz + 1;
check(j, as, m, t, n);
long long alp2 = alp;
if (alp2 > alp1) mz = j;
mz = min(mz, t);
check(mz, as, m, t, n);
cout << alp << " " << mz << endl;
}
int main() {
long long t;
cin >> t;
for (long long i = 0; i < t; i++) run();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long linf = 1e18 + 5;
const int N = 1e5 + 5;
int n, a[N], odd, st, h[N];
bool fl(int k) {
memset(h, 0, sizeof(h));
int st = k, nd = k + 1;
if (k < n + 1 >> 1) nd = n - k + 1;
for (int i = 1; i <= st; i++) h[a[i]]++;
for (int i = nd; i <= n; i++) h[a[i]]--;
bool flag = *min_element(h + 1, h + n + 1) >= 0;
for (int i = st + 1; i <= nd - 1; i++)
flag &= a[i] == a[nd - 1 - (i - (st + 1))];
return flag;
}
bool fr(int k) {
memset(h, 0, sizeof(h));
int nd = k, st = k - 1;
if (k > n + 1 >> 1) st = n - k + 1;
for (int i = nd; i <= n; i++) h[a[i]]++;
for (int i = 1; i <= st; i++) h[a[i]]--;
bool flag = *min_element(h + 1, h + n + 1) >= 0;
for (int i = st + 1; i <= nd - 1; i++)
flag &= a[i] == a[nd - 1 - (i - (st + 1))];
return flag;
}
int main() {
ios ::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
h[a[i]]++;
}
for (int i = 1; i <= n; i++) odd += h[i] & 1;
if (odd != n % 2) return cout << 0 << '\n', 0;
int st = 1;
while (st <= n / 2 and a[st] == a[n - st + 1]) st++;
st--;
if (st >= n / 2) return cout << (long long)n * (n + 1) / 2 << '\n', 0;
long long ans = 0;
int l = 1, r = n;
while (l < r) {
int m = l + r >> 1;
if (fl(m))
r = m;
else
l = m + 1;
}
ans += (long long)(st + 1) * (n - l + 1);
l = 1, r = n;
while (l + 1 < r) {
int m = l + r >> 1;
if (fr(m))
l = m;
else
r = m - 1;
}
if (fr(r)) l = r;
ans += (long long)(st + 1) * l;
ans -= (long long)(st + 1) * (st + 1);
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k, dp[103][10003], C[103][103];
long long m;
int Plus(long long x, long long y) {
return (x += y) >= 1000000007 ? x % 1000000007 : x;
}
int mul(long long x, long long y) {
return (x *= y) >= 1000000007 ? x % 1000000007 : x;
}
int qpow(int x, long long y) {
int ans = 1;
while (y) {
if (y & 1) ans = mul(ans, x);
x = mul(x, x);
y >>= 1;
}
return ans;
}
int main() {
C[1][0] = C[1][1] = 1;
for (int i = 2; i <= 100; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = Plus(C[i - 1][j], C[i - 1][j - 1]);
}
}
cin >> n >> m >> k;
long long T = (m - 1) / n;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int l = 0; l <= min(n, k); l++) {
int syk = qpow(C[n][l], T + (T * n + i <= m));
for (int j = l; j <= k; j++) {
dp[i][j] = Plus(dp[i][j], mul(dp[i - 1][j - l], syk));
}
}
}
cout << dp[n][k] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int main() {
cin >> n;
cout << (n - 2) * (n - 2) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char str[100005];
unsigned int dp[50005];
int main() {
int n;
scanf("%d\n", &n);
gets(str);
dp[0] = 1;
int cnt = 0;
for (int i = 1; i <= n; ++i) {
if (str[i - 1] == '?') {
unsigned int add = dp[0];
dp[0] = 0;
int up = min(i, n / 2);
for (int j = 1; j <= up; ++j) {
dp[j - 1] += dp[j];
swap(add, dp[j]);
}
} else {
++cnt;
for (int j = min(i, n / 2); j >= 0; --j) dp[j + 1] = dp[j];
dp[0] = 0;
}
}
for (int i = (n / 2 - cnt); i > 0; --i) dp[0] *= 25;
cout << dp[0] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#include <stdio.h>
using namespace std ;
int main(){
long double A,B;
cin>>A;
cin>>B;
if(A>B)
cout<<"GREATER";
else if(A<B)
cout<<"LESS";
else
cout<<"EQUAL";
return 0;
}
| 0 |
/*
Author: zxy_hhhh
date: 2020/03/13
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cctype>
#include<cmath>
#include<set>
#include<vector>
#include<map>
#include<queue>
#include<iostream>
#define ll long long
inline ll rd() {
ll _x=0;int _ch=getchar(),_f=1;
for(;!isdigit(_ch)&&(_ch!='-')&&(_ch!=EOF);_ch=getchar());
if (_ch=='-'){_f=0;_ch=getchar();}
for(;isdigit(_ch);_ch=getchar()) _x=_x*10+_ch-'0';
return _f?_x:-_x;
}
void write(ll _x){if (_x>=10) write(_x/10),putchar(_x%10+'0'); else putchar(_x+'0'); }
inline void wrt(ll _x,char _p){if (_x<0) putchar('-'),_x=-_x; write(_x); if (_p) putchar(_p);}
#define maxn 200005
int dis[maxn],Fa[maxn];
std::vector<int> G1[maxn],G2[maxn];
int n,A,B;
void dfs(int u,int fa) {
Fa[u]=fa;
for(auto i:G2[u]) if (i!=fa) {
dis[i]=dis[u]+1;
dfs(i,u);
}
}
int ans;
void DFS(int u,int fa,int D) {
if (dis[u]<=D) return ;
ans=std::max(ans,dis[u]*2);
for(auto i:G1[u]) if (i!=fa) {
if (!(Fa[u]==i||Fa[i]==u||Fa[u]==Fa[i]||Fa[Fa[i]]==u||Fa[Fa[u]]==i))
ans=1e9;
DFS(i,u,D+1);
}
}
int main() {
n=rd();A=rd(),B=rd();
for(int i=2;i<=n;i++) {
int x=rd(),y=rd();
G1[x].push_back(y);
G1[y].push_back(x);
}
for(int i=2;i<=n;i++) {
int x=rd(),y=rd();
G2[x].push_back(y);
G2[y].push_back(x);
}
dfs(B,0);
DFS(A,0,0);
if (ans>1e8) wrt(-1,'\n');
else wrt(ans,'\n');
}
| 0 |
#include<set>
#include<deque>
#include<queue>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<functional>
#define fir first
#define sec second
#define mp make_pair
#define mt make_tuple
#define pub push_back
using namespace std;
typedef long long int llint;
const llint one = 1;
const llint big = (one<<30);
void solve(int R,int ans[]){
int W,H,X,Y,i,j,a,x,y,l;
tuple<int,int,int> t;
vector<vector<int>> lev;
vector<vector<int>> floa;//false->????????¢?´¢???????????????true ?????\?????????
priority_queue<tuple<int,int,int>,vector<tuple<int,int,int>>,greater<tuple<int,int,int>>> que;//???????????????
scanf("%d %d %d %d",&W,&H,&X,&Y);
lev.resize(H+2);
floa.resize(H+2);
for(i=0;i<H+2;i++){ lev[i].resize(W+2);floa[i].resize(W+2); }
for(i=0;i<H+2;i++){
for(j=0;j<W+2;j++){
floa[i][j]=0;
}
}
for(i=0;i<W+2;i++){ lev[0][i]=big; }
for(i=1;i<H+1;i++){
lev[i][0]=big;
for(j=1;j<W+1;j++){ scanf("%d",&a);lev[i][j]=a; }
lev[i][W+1]=big;
}
for(i=0;i<W+2;i++){ lev[H+1][i]=big; }
que.push(mt(1,Y,X));floa[Y][X]=1;
if(R>W*H){
for(i=W*H+1;i<=R;i++){
ans[i]=big;
}
R=W*H;
}
for(i=1;i<=R;i++){
t=que.top();
l=get<0>(t);
y=get<1>(t);
x=get<2>(t);
que.pop();
if(floa[y+1][x]==0){ floa[y+1][x]=1;que.push(mt(lev[y+1][x],y+1,x)); }
if(floa[y-1][x]==0){ floa[y-1][x]=1;que.push(mt(lev[y-1][x],y-1,x)); }
if(floa[y][x+1]==0){ floa[y][x+1]=1;que.push(mt(lev[y][x+1],y,x+1)); }
if(floa[y][x-1]==0){ floa[y][x-1]=1;que.push(mt(lev[y][x-1],y,x-1)); }
ans[i]=max(l,ans[i-1]);
}
return;
}
bool Q(void){
int ans=big,i,R;
static int keia[100001]={0};//1????????????????????§i????¨?????????????????????????????¨???¬??????
static int keib[100001]={0};//2???)ry
scanf("%d",&R);
if(R==0){
return false;
}
solve(R,keia);
solve(R,keib);
for(i=0;i<=R;i++){
ans=min(ans,keia[i]+keib[R-i]);
}
printf("%d\n",ans);
return true;
}
int main(void){while(Q()){}return 0;}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
string s1, s2;
cin >> s1;
cin >> s2;
int mex = 0;
for (int i = 0; i < n; i++) {
if (s1[i] != s2[i]) {
mex += 2;
continue;
}
if (i == n - 1) {
if (s1[i] == '0') mex++;
break;
}
if (s1[i] == s2[i]) {
if (s1[i + 1] == s2[i + 1] && s1[i] != s1[i + 1]) {
mex += 2;
i++;
continue;
}
if (s1[i + 1] == s2[i + 1] && s1[i] == s1[i + 1]) {
if (s1[i] == '0') mex += 1;
}
if (s1[i + 1] != s2[i + 1] && s1[i] == '0') mex++;
}
}
cout << mex << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000007;
char s[maxn];
int n, cnt, a[maxn];
bool check(int p, bool need_touch) {
int x = 0, maxv = 0;
bool touched = 0;
for (int i = 1, _c = cnt; i <= _c; i++) {
maxv = max(maxv, x);
x += a[i];
if (x <= p) {
x = p + 1;
touched = 1;
}
}
return (x > maxv) && (!need_touch || touched);
}
int main() {
cnt = 0;
gets(s + 1);
n = strlen(s + 1);
int x = 1;
while (x <= n) {
int y = x;
while (y < n && s[y + 1] == s[x]) ++y;
a[++cnt] = y - x + 1;
if (s[x] == 'L') a[cnt] *= -1;
x = y + 1;
}
if (a[cnt] < 0)
for (int i = 1, _c = cnt; i <= _c; i++) a[i] *= -1;
if (check(-n - 1, 0)) {
puts("1");
return 0;
}
int res = 0;
int l = -n, r = -1, mid, pos = 0;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid, 1)) {
pos = mid;
r = mid - 1;
} else
l = mid + 1;
}
res -= pos;
cout << res << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long a = (m % 2 == 0) ? (m / 2 - 1) : m / 2;
long long b = m / 2 + 1;
if (a > 0 && b <= n) {
cout << min(a, n - b + 1);
} else
cout << "0";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ans = 0;
cin >> n >> m;
int a[101];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
int suma = 0;
int sumb = 0;
for (int j = l; j <= r; j++) {
if (a[j] > 0) {
suma = suma + a[j];
} else {
sumb = sumb + a[j];
}
}
if (suma + sumb > 0) {
ans = ans + (suma + sumb);
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
A cvt(B x) {
stringstream ss;
ss << x;
A y;
ss >> y;
return y;
}
int n, w, h;
int main() {
scanf("%d %d %d", &n, &w, &h);
map<int, vector<pair<int, int> > > diag, exits;
for (int i = 0; i < (int)(n); i++) {
int g, p, t;
scanf("%d %d %d", &g, &p, &t);
int x, y;
if (g == 1) {
x = p;
y = -t;
exits[x + y].push_back({x, -h});
} else {
x = -t;
y = p;
exits[x + y].push_back({w, -y});
}
diag[x + y].push_back({x, i});
}
vector<pair<int, int> > out(n);
for (auto kv : diag) {
vector<pair<int, int> > d = kv.second;
vector<pair<int, int> > e = exits[kv.first];
sort((e).begin(), (e).end());
sort((d).begin(), (d).end());
for (int i = 0; i < (int)(d.size()); i++) {
out[d[i].second] = {e[i].first, -e[i].second};
}
}
for (int i = 0; i < (int)(n); i++) {
printf("%d %d\n", out[i].first, out[i].second);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int rnd() { return (rand() << 16) ^ rand(); }
struct node {
int min, max, x, y, val;
node *l, *r;
node(int x, int val)
: min(val), max(val), x(x), val(val), y(rnd()), l(NULL), r(NULL) {}
};
typedef node* treap;
int get_min(treap t) {
if (t == NULL) return 2000000000;
return t->min;
}
int get_max(treap t) {
if (t == NULL) return -2000000000;
return t->max;
}
void up_min(treap t) {
if (t != NULL) t->min = min(t->val, min(get_min(t->l), get_min(t->r)));
}
void up_max(treap t) {
if (t != NULL) {
t->max = max(t->val, max(get_max(t->l), get_max(t->r)));
}
}
treap merge(treap a, treap b) {
if (a == NULL) return b;
if (b == NULL) return a;
if (a->y > b->y) {
a->r = merge(a->r, b);
up_min(a);
up_max(a);
return a;
} else {
b->l = merge(a, b->l);
up_min(b);
up_max(b);
return b;
}
}
pair<treap, treap> split(treap t, int x) {
if (t == NULL) return make_pair(t, t);
if (x <= t->x) {
pair<treap, treap> p = split(t->l, x);
t->l = p.second;
up_min(t);
up_max(t);
return make_pair(p.first, t);
} else {
pair<treap, treap> p = split(t->r, x);
t->r = p.first;
up_min(t);
up_max(t);
return make_pair(t, p.second);
}
}
treap add(treap t, int x, int val) {
treap p = new node(x, val);
return merge(t, p);
}
int dif(treap t, int l, int r) {
pair<treap, treap> p = split(t, l);
pair<treap, treap> q = split(p.second, r + 1);
int x = q.first->max - q.first->min;
t = merge(p.first, merge(q.first, q.second));
return x;
}
int main() {
int n, k, i, l = 1, r = 1, a = 0, h;
vector<int> ans;
cin >> n >> k;
treap t = NULL;
for (i = 1; i <= n; i++) {
cin >> h;
t = add(t, i, h);
}
while (l <= n) {
r++;
if (r > n || dif(t, l, r) > k) {
if (r - l > a) a = r - l;
l++;
}
}
for (i = 1; i <= n - a + 1; i++) {
if (dif(t, i, i + a - 1) <= k) ans.push_back(i);
}
cout << a << ' ' << ans.size();
for (i = 0; i < ans.size(); i++) {
cout << endl << ans[i] << ' ' << ans[i] + a - 1;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("O8")
#pragma GCC optimization("unroll-loops")
using namespace std;
const long long int N = 5e4 + 20, mod = 1e9, inf = 4e18, maxm = 2e5 + 20;
const long double eps = 0.0001;
int n, m;
long long int G, S;
pair<pair<long long int, long long int>, pair<long long int, long long int> >
e[N];
int par[N];
set<pair<long long int, long long int> > adj[N];
bool vis[N];
int mat[400][400];
long long int mx = 0, x, y;
multiset<long long int> st;
int getpar(int v) {
if (par[v] == v) return v;
return par[v] = getpar(par[v]);
}
inline bool merge(int u, int v) {
if (getpar(u) == getpar(v)) return 0;
par[par[u]] = par[v];
return 1;
}
bool dfs(int v, int p) {
vis[v] = 1;
for (pair<long long int, long long int> u : adj[v]) {
if (u.first == p) continue;
if (vis[u.first]) {
mx = u.second;
x = v;
y = u.first;
return 1;
}
if (dfs(u.first, v)) {
if (mx < u.second) {
mx = u.second;
x = v;
y = u.first;
}
return 1;
}
}
return 0;
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> G >> S;
for (int i = 1; i < n + 1; i++) par[i] = i;
for (int i = 0; i < m; i++)
cin >> e[i].second.first >> e[i].second.second >> e[i].first.first >>
e[i].first.second;
sort(e, e + m);
long long int val = inf;
int cnt = n;
for (int i = 0; i < m; i++) {
int u = e[i].second.first, v = e[i].second.second;
if (u == v) continue;
if (merge(u, v)) {
cnt--;
adj[u].insert({v, e[i].first.second});
adj[v].insert({u, e[i].first.second});
mat[u][v] = e[i].first.second;
mat[v][u] = mat[u][v];
st.insert(-e[i].first.second);
} else {
adj[u].insert({v, e[i].first.second});
adj[v].insert({u, e[i].first.second});
if (mat[u][v]) {
if (mat[u][v] <= e[i].first.second) {
adj[u].erase({v, e[i].first.second});
adj[v].erase({u, e[i].first.second});
continue;
}
adj[u].erase({v, mat[u][v]});
adj[v].erase({u, mat[u][v]});
auto it = st.find(-mat[u][v]);
st.erase(it);
mat[u][v] = e[i].first.second;
mat[v][u] = mat[u][v];
adj[v].insert({u, mat[u][v]});
adj[u].insert({v, mat[u][v]});
st.insert(-mat[u][v]);
if (cnt == 1)
val = min(val, G * e[i].first.first - S * (*(st.begin())));
continue;
}
for (int i = 1; i < n + 1; i++) vis[i] = 0;
mx = 0;
dfs(u, -1);
mat[u][v] = e[i].first.second;
mat[v][u] = mat[u][v];
adj[x].erase({y, mx});
adj[y].erase({x, mx});
mat[y][x] = 0;
mat[x][y] = 0;
st.insert(-e[i].first.second);
auto it = st.find(-mx);
st.erase(it);
}
if (st.size() > n - 1) cout << st.size() << " ";
if (cnt == 1) val = min(val, G * e[i].first.first - S * (*(st.begin())));
}
if (cnt != 1) {
cout << -1;
return 0;
}
cout << val;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using i32 = int;
using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f64 = double;
using f80 = long double;
long long power(long long a, long long b, long long p) {
if (!b) return 1;
long long t = power(a, b / 2, p);
t = t * t % p;
if (b & 1) t = t * a % p;
return t;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long px, py;
long long d = exgcd(b, a % b, px, py);
x = py;
y = px - a / b * py;
return d;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <class T>
inline void freshmin(T &a, const T &b) {
if (a > b) a = b;
}
template <class T>
inline void freshmax(T &a, const T &b) {
if (a < b) a = b;
}
template <class T>
void print(const T &a) {
for (auto x : a) printf("%d ", x);
puts("");
}
const int MAXN = 500010;
const int MAXK = 30;
const int INF = 1000000000;
const int B = 31;
const int MOD = 1000000007;
const double pi = 3.1415926535897932384626433;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int days[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool leap(int y) { return y % 4 == 0 && y % 100 != 0 || y % 400 == 0; }
int n, m;
int a[MAXN], b[MAXN];
void solve() {
int n, p;
cin >> n >> p;
for (int k = 1; k <= 1000000; ++k) {
n -= p;
if (n <= 0) break;
int m = __builtin_popcount(n);
if (m <= k && k <= n) {
printf("%d\n", k);
return;
}
}
puts("-1");
}
int main() {
int T;
T = 1;
while (T--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long pw(long long b, long long n, long long m = mod, long long a = 1) {
while (n) {
if (n & 1) a = a * b % m;
b = b * b % m;
n >>= 1;
}
return a;
}
long long a[1000006], fac[1000006], ifac[1000006], inv[1000006];
map<long long, int> cnt;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i % mod;
ifac[n] = pw(fac[n], mod - 2);
for (int i = n - 1; i >= 0; --i) ifac[i] = ifac[i + 1] * (i + 1) % mod;
for (int i = 2; i <= n; ++i) inv[i] = ifac[i] * fac[i - 1] % mod;
for (int i = 0; i < n; ++i) cin >> a[i], ++cnt[a[i]];
sort(a, a + n);
int nn = unique(a, a + n) - a;
long long ans = 0;
int all = n;
for (int i = 0; i < nn - 1; ++i) {
int app = cnt[a[i]];
ans += app * inv[all] % mod * fac[n] % mod * a[i] % mod;
all -= app;
}
cout << ans % mod << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long cnt = 0;
for (long long i = 0; i < s.size(); i++) {
if ((i + 4) < s.size() && s.substr(i, 5) == "Danil") {
cnt++;
}
if ((i + 3) < s.size() && s.substr(i, 4) == "Olya") {
cnt++;
}
if ((i + 4) < s.size() && s.substr(i, 5) == "Slava") {
cnt++;
}
if ((i + 2) < s.size() && s.substr(i, 3) == "Ann") {
cnt++;
}
if ((i + 5) < s.size() && s.substr(i, 6) == "Nikita") {
cnt++;
}
}
if (cnt == 1) {
cout << "YES";
} else {
cout << "NO";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int M = (1 << 7) + 10;
long long dp[N][M];
int id[N], c[N], n, p, k;
long long a[N];
long long s[N][M];
bool cmp(long long x, long long y) { return a[x] > a[y]; }
int js(int x) {
int ans = 0;
while (x) {
ans += (x & 1);
x >>= 1;
}
return ans;
}
int main() {
for (int i = 0; i < M; i++) c[i] = js(i);
scanf("%d%d%d", &n, &p, &k);
int m = (1 << p);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]), id[i] = i;
sort(id + 1, id + 1 + n, cmp);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= p; j++) scanf("%lld", &s[i][j]);
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++) {
int gs = (i - 1 - c[j]);
if (gs < k) {
if (dp[i - 1][j] != -1) dp[i][j] = dp[i - 1][j] + a[id[i]];
} else {
if (dp[i - 1][j] != -1) dp[i][j] = dp[i - 1][j];
}
for (int t = 0; t < p; t++) {
if (((j >> t) & 1) && dp[i - 1][j ^ (1 << t)] != -1) {
dp[i][j] = max(dp[i][j], dp[i - 1][j ^ (1 << t)] + s[id[i]][t + 1]);
}
}
}
}
printf("%lld\n", dp[n][m - 1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int i, j, m, n, p, k, k1 = 1, fox[205], que[2000005 * 15], st, ed, flow[205],
cost[205], vis[205], fa[205], ans;
char c[2000005], S[2000005];
int sum[205][205];
struct Node {
int ed, before, flow, cost;
} s[2000005];
void add(int p1, int p2, int flow, int cost) {
s[++k1].ed = p2;
s[k1].flow = flow;
s[k1].cost = cost;
s[k1].before = fox[p1];
fox[p1] = k1;
s[++k1].ed = p1;
s[k1].flow = 0;
s[k1].cost = -cost;
s[k1].before = fox[p2];
fox[p2] = k1;
}
int spfa() {
int l, r, p, i;
l = r = 1;
que[1] = st;
memset(flow, -1, sizeof(flow));
flow[st] = 100000000;
memset(cost, 60, sizeof(cost));
memset(vis, 0, sizeof(vis));
vis[st] = 1;
cost[st] = 0;
for (; l <= r; l++) {
p = que[l];
for (i = fox[p]; i; i = s[i].before)
if (s[i].flow)
if (cost[p] + s[i].cost < cost[s[i].ed]) {
cost[s[i].ed] = s[i].cost + cost[p];
flow[s[i].ed] = min(flow[p], s[i].flow);
fa[s[i].ed] = i;
if (!vis[s[i].ed]) {
vis[s[i].ed] ^= 1;
que[++r] = s[i].ed;
}
}
vis[p] ^= 1;
}
if (flow[ed] == -1) return 0;
return 1;
}
void doit() {
int i, p;
for (i = ed; i != st; i = s[p ^ 1].ed) {
p = fa[i];
s[p].flow -= flow[ed];
s[p ^ 1].flow += flow[ed];
}
}
int get(char x) {
if (x >= 'a') return x - 'a';
return x - 'A' + 26;
}
char Find(int x) {
if (x < 26) return 'a' + x;
return 'A' + x - 26;
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", c);
scanf("%s", S);
for (i = 0; i < n; ++i) sum[get(c[i])][get(S[i])]++;
st = 2 * k;
ed = st + 1;
for (i = 0; i < k; ++i) add(st, i, 1, 0);
for (i = 0; i < k; ++i) add(i + k, ed, 1, 0);
for (i = 0; i < k; ++i)
for (j = 0; j < k; ++j) add(i, j + k, 1, -sum[i][j]);
for (; spfa();) ans += cost[ed] * flow[ed], doit();
printf("%d\n", -ans);
for (i = 0; i < k; ++i)
for (j = fox[i]; j; j = s[j].before)
if (s[j].flow == 0 && s[j].ed < 2 * k) {
printf("%c", Find(s[j].ed - k));
break;
}
puts("");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int par[N], par1[N], T, vis[N], n, m, w[N], x[N], y[N];
bool ans[N];
vector<pair<int, int>> e[N], q[N];
int get(int u) { return u == par[u] ? u : par[u] = get(par[u]); }
int gett(int u) {
return (vis[u] != T ? vis[u] = T, par1[u] = par[u] : 0),
(u == par1[u] ? u : par1[u] = gett(par1[u]));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) par[i] = i;
for (int i = 0, a, b, c; i < m; i++)
scanf("%d%d%d", x + i, y + i, w + i), e[w[i]].push_back({--x[i], --y[i]});
scanf("%d", &n);
for (int i = 0, a, b; i < n; i++) {
scanf("%d", &a);
while (a--) scanf("%d", &b), --b, q[w[b]].push_back({i, b});
}
for (int i = 1, last; i < N; i++) {
last = -1;
for (auto j : q[i]) {
if (last != j.first) T++, last = j.first;
int a = gett(x[j.second]), b = gett(y[j.second]);
if (a == b)
ans[last] = 1;
else
par1[a] = b;
}
for (auto j : e[i]) par[get(j.second)] = get(j.first);
}
for (int i = 0; i < n; i++) puts(ans[i] ? "NO" : "YES");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> hungarian(vector<vector<int> > w, int n) {
int lx[n], ly[n], skojx[n], skojy[n];
int markx[n], marky[n], slack[n], par[n], q[n];
for (int i = 0; i < n; i++) {
skojx[i] = skojy[i] = -1;
ly[i] = 0;
lx[i] = *max_element(w[i].begin(), w[i].end());
}
for (int k = 0; k < n; k++) {
int v = -1, qb = 0, qe = 0;
for (int i = 0; i < n; i++) {
marky[i] = markx[i] = 0;
slack[i] = -1;
if (skojx[i] == -1) q[qe++] = i;
}
while (v == -1) {
while (qb < qe) {
int i = q[qb++];
markx[i] = 1;
for (int j = 0; j < n; j++)
if (!marky[j] &&
(slack[j] == -1 || slack[j] > lx[i] + ly[j] - w[i][j])) {
if ((slack[j] = lx[par[j] = i] + ly[j] - w[i][j]) == 0) {
marky[j] = 1;
if (skojy[j] != -1)
q[qe++] = skojy[j];
else {
v = j;
goto koniec;
}
}
}
}
int x = -1;
for (int i = 0; i < n; i++)
if (!marky[i] && (x == -1 || slack[i] < x)) x = slack[i];
for (int i = 0; i < n; i++) {
if (markx[i]) lx[i] -= x;
if (marky[i])
ly[i] += x;
else if ((slack[i] -= x) == 0) {
marky[i] = 1;
if (skojy[i] != -1)
q[qe++] = skojy[i];
else
v = i;
}
}
}
koniec:
while (v != -1) {
int y = skojx[par[v]];
skojx[par[v]] = v;
skojy[v] = par[v];
v = y;
}
}
return vector<int>(skojx, skojx + n);
}
int n, k;
int num[1007];
char jak[1007];
vector<vector<int> > tab;
vector<vector<int> > daj;
vector<int> sko;
int wyn;
char wcz1[2000007];
char wcz2[2000007];
int main() {
scanf("%d%d", &n, &k);
for (int i = 'a'; i <= 'z'; i++) {
num[i] = i - 'a';
jak[num[i]] = i;
}
for (int i = 'A'; i <= 'Z'; i++) {
num[i] = i - 'A' + 26;
jak[num[i]] = i;
}
tab.push_back(vector<int>{});
for (int i = 0; i < k; i++) tab[0].push_back(0);
for (int i = 1; i < k; i++) tab.push_back(tab[0]);
scanf("%s%s", wcz1 + 1, wcz2 + 1);
for (int i = 1; i <= n; i++) tab[num[wcz1[i]]][num[wcz2[i]]]++;
daj = tab;
sko = hungarian(daj, k);
for (int i = 0; i < k; i++) wyn += tab[i][sko[i]];
printf("%d\n", wyn);
for (int i = 0; i < k; i++) printf("%c", jak[sko[i]]);
printf("\n");
return 0;
}
| 3 |
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
struct Info{
bool operator<(const struct Info &arg) const{
if(x != arg.x){
return x < arg.x;
}else{
return y < arg.y;
}
}
double x,y,r;
};
int N;
Info info[100001];
bool compare_y(Info left,Info right){
return left.y < right.y;
}
double calc_dist(int a,int b){
return sqrt((info[a].x-info[b].x)*(info[a].x-info[b].x)+(info[a].y-info[b].y)*(info[a].y-info[b].y))-(info[a].r+info[b].r);
}
double calc_y_dist(int a,int b){
return (info[b].y-info[b].r)-(info[a].y+info[a].r);
}
double closest_pair(Info* array,int tmp_N){
if(tmp_N <= 1)return DBL_MAX;
int mid = tmp_N/2;
double x = array[mid].x;
double dist = min(closest_pair(array,mid),closest_pair(array+mid,tmp_N-mid));
inplace_merge(array,array+mid,array+tmp_N,compare_y);
vector<int> V;
int left,right,m,search_left;
for(int i = 0; i < tmp_N; i++){
for(int k = 0; k < min((int)V.size(),2); k++){
dist = min(dist,calc_dist(V[V.size()-1-k],i));
}
V.push_back(i);
}
return dist;
}
void func(){
for(int i = 0; i < N; i++){
scanf("%lf %lf %lf",&info[i].r,&info[i].x,&info[i].y);
}
sort(info,info+N);
printf("%.10lf\n",closest_pair(info,N));
}
int main(){
while(true){
scanf("%d",&N);
if(N == 0)break;
func();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline pair<int, int> operator+(pair<int, int> &A, pair<int, int> B) {
return make_pair(A.first + B.first, A.second + B.second);
}
inline pair<int, int> swap(pair<int, int> &A) {
return make_pair(A.second, A.first);
}
inline int min(pair<int, int> &A) { return min(A.first, A.second); }
inline void wypisz(pair<int, int> &A) {
cout << A.first << " " << A.second << endl;
}
int n, x, yz, xz;
pair<int, int> v[1111][1111];
pair<int, int> res[1111][1111][2];
int wyp[1111][1111][2];
bool zero;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> x;
if (x == 0) {
zero = true;
yz = i;
xz = j;
v[i][j] = make_pair(1000, 1000);
} else {
while (x % 2 == 0) {
x /= 2;
v[i][j].first++;
}
while (x % 5 == 0) {
x /= 5;
v[i][j].second++;
}
}
if (i == 1) {
if (j == 1) {
res[1][1][0] = v[1][1];
wyp[1][1][0] = 1;
res[1][1][1] = swap(v[1][1]);
wyp[1][1][1] = 1;
} else {
res[1][j][0] = res[1][j - 1][0] + v[1][j];
wyp[1][j][0] = 1;
res[1][j][1] = res[1][j - 1][1] + swap(v[1][j]);
wyp[1][j][1] = 1;
}
} else {
if (j == 1) {
res[i][1][0] = res[i - 1][1][0] + v[i][1];
wyp[i][1][0] = -1;
res[i][1][1] = res[i - 1][1][1] + swap(v[i][1]);
wyp[i][1][1] = -1;
} else {
if (res[i - 1][j][0] < res[i][j - 1][0]) {
res[i][j][0] = res[i - 1][j][0] + v[i][j];
wyp[i][j][0] = -1;
} else {
res[i][j][0] = res[i][j - 1][0] + v[i][j];
wyp[i][j][0] = 1;
}
if (res[i - 1][j][1] < res[i][j - 1][1]) {
res[i][j][1] = res[i - 1][j][1] + swap(v[i][j]);
wyp[i][j][1] = -1;
} else {
res[i][j][1] = res[i][j - 1][1] + swap(v[i][j]);
wyp[i][j][1] = 1;
}
}
}
}
}
int rr;
if (min(res[n][n][0]) < min(res[n][n][1])) {
rr = 0;
} else
rr = 1;
if (min(res[n][n][rr]) > 1 && zero) {
cout << 1 << endl;
for (int i = 1; i < yz; i++) cout << "L";
for (int i = 1; i < n; i++) cout << "D";
for (int i = yz; i < n; i++) cout << "L";
cout << endl;
return 0;
}
cout << min(res[n][n][rr]) << endl;
int x = n, y = n;
vector<char> vec;
while (x > 0 && y > 0) {
if (wyp[x][y][rr] == 1) {
vec.push_back('R');
y--;
} else if (wyp[x][y][rr] == -1) {
vec.push_back('D');
x--;
} else {
cout << "DUPA\n";
return 0;
}
}
for (int i = vec.size() - 2; i >= 0; i--) cout << vec[i];
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
int suma, unde;
int A[602], B[602];
int niv[602][602], vecA[602], vecB[602];
bool vizA[602], vizB[602], done[602];
inline void prost() {
while (1)
;
}
inline int calc2(int v[], int left, int right, int st, int dr) {
printf("? %d\n", right - left + dr - st + 2);
for (int i = left; i <= right; i++) printf("%d ", v[i]);
for (int i = st; i <= dr; i++) printf("%d ", v[i]);
printf("\n");
fflush(stdout);
int ans;
scanf("%d", &ans);
if (ans == -1) prost();
return ans;
}
inline int calc(int v[], int left, int right) {
if (left == right) return 0;
printf("? %d\n", right - left + 1);
for (int i = left; i <= right; i++) printf("%d ", v[i]);
printf("\n");
fflush(stdout);
int ans;
scanf("%d", &ans);
if (ans == -1) prost();
return ans;
}
inline bool ceva(int left, int right) {
int aux = calc(B, left, right);
printf("? %d\n", A[0] + right - left + 1);
for (int i = 1; i <= A[0]; i++) printf("%d ", A[i]);
for (int i = left; i <= right; i++) printf("%d ", B[i]);
printf("\n");
fflush(stdout);
int ans;
scanf("%d", &ans);
if (ans == -1) prost();
return ans - suma - aux > 0;
}
inline bool checkNiv() {
if (niv[unde][0] == 0) return 0;
if (calc(niv[unde], 1, niv[unde][0])) return 0;
return 1;
}
void dfs(int st, int dr) {
if (st == dr) {
done[B[st]] = 1;
niv[unde][++niv[unde][0]] = B[st];
} else {
int m = (st + dr) / 2;
if (ceva(st, m)) {
dfs(st, m);
if (ceva(m + 1, dr)) dfs(m + 1, dr);
} else
dfs(m + 1, dr);
}
}
inline bool muchie(int nod, int v[], int st, int dr) {
printf("? %d\n", dr - st + 2);
for (int i = st; i <= dr; i++) printf("%d ", v[i]);
printf("%d\n", nod);
fflush(stdout);
int ans;
scanf("%d", &ans);
if (ans == -1) prost();
return ans;
}
void go(int nod, bool viz[], int v[], int st, int dr) {
if (st == dr)
viz[v[st]] = 1;
else {
int m = (st + dr) / 2;
if (muchie(nod, v, st, m)) {
go(nod, viz, v, st, m);
if (muchie(nod, v, m + 1, dr)) go(nod, viz, v, m + 1, dr);
} else
go(nod, viz, v, m + 1, dr);
}
}
inline void findCiclu() {
int st = 1, dr = niv[unde][0];
bool ok = 1;
while (ok) {
int m = (st + dr) / 2;
if (calc(niv[unde], st, m))
dr = m;
else if (calc(niv[unde], m + 1, dr))
st = m + 1;
else
ok = 0;
}
ok = 1;
int left = st, right = (st + dr) / 2;
st = right + 1;
while (st < dr) {
int m = (st + dr) / 2;
if (calc2(niv[unde], left, right, st, m))
dr = m;
else
st = m + 1;
}
while (left < right) {
int m = (left + right) / 2;
if (calc2(niv[unde], left, m, st, dr))
right = m;
else
left = m + 1;
}
int nodulA = niv[unde][left], nodulB = niv[unde][st];
ok = 1;
int poz = unde - 1, rad = 0;
while (ok) {
vecA[++vecA[0]] = nodulA;
vecB[++vecB[0]] = nodulB;
go(nodulA, vizA, niv[poz], 1, niv[poz][0]);
go(nodulB, vizB, niv[poz], 1, niv[poz][0]);
for (int i = 1; i <= niv[poz][0]; i++)
if (vizA[niv[poz][i]] && vizB[niv[poz][i]])
rad = niv[poz][i], ok = 0;
else if (vizA[niv[poz][i]])
nodulA = niv[poz][i];
else if (vizB[niv[poz][i]])
nodulB = niv[poz][i];
poz--;
}
printf("N %d\n", 2 * vecA[0] + 1);
for (int i = 1; i <= vecA[0]; i++) printf("%d ", vecA[i]);
printf("%d", rad);
for (int i = vecB[0]; i > 0; i--) printf(" %d", vecB[i]);
printf("\n");
}
int main() {
int n;
scanf("%d", &n);
niv[0][++niv[0][0]] = 1;
done[1] = 1;
while (checkNiv()) {
unde++;
A[0] = B[0] = 0;
for (int i = 1; i <= n; i++)
if (done[i])
A[++A[0]] = i;
else
B[++B[0]] = i;
suma = calc(A, 1, A[0]);
if (B[0] > 0) dfs(1, B[0]);
}
if (niv[unde][0] == 0) {
for (int i = 1; i <= n; i++)
if (done[i] == 0) prost();
int ans = 0;
for (int i = 0; i < unde; i += 2) ans += niv[i][0];
printf("Y %d\n", ans);
for (int i = 0; i < unde; i += 2)
for (int j = 1; j <= niv[i][0]; j++) printf("%d ", niv[i][j]);
printf("\n");
} else
findCiclu();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
ifstream in("in.txt");
ofstream out("out.txt");
vector<int> lst1, lst2, lst3;
int main(void) {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
string str;
int x;
cin >> str >> x;
if (str == "ATK")
lst1.push_back(x);
else
lst2.push_back(x + 1);
}
lst3.resize(m);
for (int &x : lst3) cin >> x;
int ans = 0;
sort(lst1.begin(), lst1.end());
sort(lst2.begin(), lst2.end());
sort(lst3.begin(), lst3.end());
for (int i = 1; i <= min((int)lst1.size(), m); i++) {
bool ok = true;
for (int j = 0; j < i && ok == true; j++) {
if (lst1[j] > lst3[m - (i - j)]) ok = false;
}
if (ok == true) {
int cst = 0;
for (int j = 0; j < i; j++) cst += lst3[m - j - 1] - lst1[j];
ans = max(ans, cst);
}
}
bool ok = true;
for (int x : lst2) {
if (lst3.size() == 0 || lst3.back() < x)
ok = false;
else
lst3.erase(lower_bound(lst3.begin(), lst3.end(), x));
}
ok &= (lst1.size() <= lst3.size());
for (int i = 0; i < lst1.size() && ok == true; i++) {
if (lst1[i] > lst3[lst3.size() - (lst1.size() - i)]) ok = false;
}
if (ok == true)
ans = max(ans, accumulate(lst3.begin(), lst3.end(), 0, plus<int>()) -
accumulate(lst1.begin(), lst1.end(), 0, plus<int>()));
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int i, j;
char c[55][55];
bool used[55][55];
int dx[] = {1, 0, 0, -1}, dy[] = {0, -1, 1, 0};
void dfs(int x, int y, int in) {
used[x][y] = true;
for (int i = 0; i < 4; i++) {
if (i == in) {
continue;
}
int xx = dx[i] + x, yy = dy[i] + y;
if (c[xx][yy] == c[x][y]) {
if (used[xx][yy]) {
cout << "Yes" << '\n';
exit(0);
}
dfs(xx, yy, 3 - i);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
cin >> c[i][j];
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (!used[i][j]) {
dfs(i, j, 5);
}
}
}
cout << "No" << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void Read(T &x) {
char c = getchar();
bool f = false;
for (x = 0; !isdigit(c); c = getchar()) {
if (c == '-') {
f = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (f) {
x = -x;
}
}
template <typename T>
inline bool CheckMax(T &a, const T &b) {
return a < b ? a = b, true : false;
}
template <typename T>
inline bool CheckMin(T &a, const T &b) {
return a > b ? a = b, true : false;
}
const int N = 400005;
int n, cnt_x, cnt_y, x[N], y[N], x_l[N], x_r[N], y_l[N], y_r[N],
val_max[N << 2], val_min[N << 2];
bool chk[N], see[N];
vector<pair<int, int> > eve[N];
set<int> s[N << 2];
inline void PushUp(int x) {
for (; !s[x].empty() && chk[*s[x].rbegin()]; s[x].erase(*s[x].rbegin()))
;
int son_max = max(val_max[x << 1], val_max[x << 1 | 1]),
son_min = min(val_min[x << 1], val_min[x << 1 | 1]),
cur_max = s[x].empty() ? -1 : *s[x].rbegin();
if (cur_max > son_max) {
if (see[cur_max] || cur_max < son_min) {
val_max[x] = -1;
} else {
val_max[x] = cur_max;
}
} else {
val_max[x] = son_max;
}
val_min[x] = max(cur_max, son_min);
}
inline void Modify(int x, int l, int r, int ql, int qr, int v) {
if (l == ql && r == qr) {
if (v) {
s[x].insert(v);
}
PushUp(x);
return;
}
int mid = l + r >> 1;
if (qr <= mid) {
Modify(x << 1, l, mid, ql, qr, v);
} else if (ql > mid) {
Modify(x << 1 | 1, mid + 1, r, ql, qr, v);
} else {
Modify(x << 1, l, mid, ql, mid, v),
Modify(x << 1 | 1, mid + 1, r, mid + 1, qr, v);
}
PushUp(x);
}
int main() {
Read(n);
for (int i = 1; i <= n; ++i) {
Read(x_l[i]), Read(y_l[i]);
Read(x_r[i]), Read(y_r[i]);
x[++cnt_x] = x_l[i], x[++cnt_x] = x_r[i];
y[++cnt_y] = y_l[i], y[++cnt_y] = y_r[i];
}
sort(x + 1, x + cnt_x + 1), cnt_x = unique(x + 1, x + cnt_x + 1) - x - 1;
sort(y + 1, y + cnt_y + 1), cnt_y = unique(y + 1, y + cnt_y + 1) - y - 1;
for (int i = 1; i <= n; ++i) {
x_l[i] = lower_bound(x + 1, x + cnt_x + 1, x_l[i]) - x;
x_r[i] = lower_bound(x + 1, x + cnt_x + 1, x_r[i]) - x;
y_l[i] = lower_bound(y + 1, y + cnt_y + 1, y_l[i]) - y;
y_r[i] = lower_bound(y + 1, y + cnt_y + 1, y_r[i]) - y;
eve[x_l[i]].push_back(make_pair(i, 0)),
eve[x_r[i]].push_back(make_pair(i, 1));
}
memset(val_max, -1, sizeof val_max);
for (int i = 1; i <= cnt_x; ++i) {
for (auto e : eve[i]) {
int p = e.first, o = e.second;
if (o) {
chk[p] = true;
}
Modify(1, 1, cnt_y, y_l[p], y_r[p] - 1, o ? 0 : p);
}
while (val_max[1] >= val_min[1]) {
int p = val_max[1];
see[p] = true;
Modify(1, 1, cnt_y, y_l[p], y_r[p] - 1, 0);
}
}
int ans = 1;
for (int i = 1; i <= n; ++i) {
if (see[i]) {
++ans;
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long int a[5000005];
long long int b[5000005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
for (long long int i = 0; i < n; i++) cin >> a[i];
long long int aminm = *min_element(a, a + n);
for (long long int i = 0; i < n; i++) cin >> b[i];
long long int bminm = *min_element(b, b + n);
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
long long int delta = a[i] - aminm;
ans += a[i] - aminm;
b[i] -= delta;
if (b[i] > bminm) ans += b[i] - bminm;
}
cout << ans << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int qu[1005];
bool res[1005];
struct nv {
int a;
int b;
int c;
};
nv ap[10005];
void Nhap() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> qu[i];
cin >> m;
for (int i = 1; i <= m; i++) cin >> ap[i].a >> ap[i].b >> ap[i].c;
}
bool ss(nv x, nv y) { return ((x.b < y.b) || (x.b == y.b && x.c < y.c)); }
int main() {
Nhap();
int ans = 0;
sort(ap + 1, ap + m + 1, ss);
int temp = -1;
for (int i = 1; i <= m; i++) {
if (qu[ap[i].a] > qu[ap[i].b] && ap[i].b != temp) {
res[ap[i].b] = true;
ans += ap[i].c;
temp = ap[i].b;
}
}
int dem = 0;
for (int i = 1; i <= n; i++) {
if (res[i] == false) dem++;
if (dem >= 2) {
cout << -1;
return 0;
}
}
cout << ans;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.