solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
string s;
cin >> s;
long long int o = 0, e = 0;
if (n % 2 == 0) {
for (int i = 1; i < n; i += 2) {
if ((s[i] - '0') % 2 == 0) e++;
}
if (e > 0)
cout << 2 << "\n";
else
cout << 1 << "\n";
} else {
for (int i = 0; i < n; i += 2)
if ((s[i] - '0') % 2 != 0) o++;
if (o > 0)
cout << 1 << "\n";
else
cout << 2 << "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i ++)
#define rep1(i, n) for(int i = 1; i <= (int)(n); i ++)
#define MP make_pair
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int INF = 0x3f3f3f3f;
int n, m;
vector<int> hv[200005];
struct edge
{
int to, cap, rev;
}E[800005];
vector<int> G[200005];
void add_edge(int u, int v, int c)
{
E[m].to = v;
E[m].cap = c;
E[m].rev = m ^ 1;
G[u].push_back(m ++);
E[m].to = u;
E[m].cap = 0;
E[m].rev = m ^ 1;
G[v].push_back(m ++);
}
int dis[200005], cur[200005];
bool bfs()
{
rep1(i, 2 * n) dis[i] = -1;
queue<int> que;
que.push(0);
dis[0] = 0;
while(!que.empty()) {
int v = que.front();
que.pop();
rep(i, G[v].size()) {
int ce = G[v][i];
if(E[ce].cap > 0 && dis[E[ce].to] == -1) {
que.push(E[ce].to);
dis[E[ce].to] = dis[v] + 1;
}
}
}
if(dis[2 * n] == -1) return false;
rep(i, 2 * n + 1) cur[i] = 0;
return true;
}
int dfs(int v, int maxf)
{
if(v == 2 * n) return maxf;
if(maxf == 0) return 0;
int ret = 0;
for(; cur[v] < G[v].size(); cur[v] ++) {
int ce = G[v][cur[v]];
if(dis[E[ce].to] == dis[v] + 1 && E[ce].cap > 0) {
int cf = dfs(E[ce].to, min(maxf - ret, E[ce].cap));
E[ce].cap -= cf;
E[E[ce].rev].cap += cf;
ret += cf;
if(ret == maxf) break;
}
}
return ret;
}
int lp[200005], par[200005];
int dinic()
{
int ret = 0;
while(bfs()) ret += dfs(0, INF);
return ret;
}
int main()
{
scanf("%d", &n);
rep1(i, n - 1) {
int cs;
scanf("%d", &cs);
hv[i].resize(cs);
rep(j, cs) {
scanf("%d", &hv[i][j]);
add_edge(hv[i][j], i + n, 1);
}
add_edge(i + n, n * 2, 1);
}
rep1(i, n) add_edge(0, i, 1);
if(dinic() != n - 1) {
printf("-1\n");
return 0;
}
rep1(i, n) if(dis[i] == -1) {
printf("-1\n");
return 0;
}
rep1(i, 2 * n - 1) rep(j, G[i].size()) {
int ce = G[i][j];
if(E[ce].cap == 0 && dis[E[ce].to] == dis[i] - 1) {
par[i] = E[ce].to;
break;
}
}
rep1(i, n) if(par[i] != 0) lp[par[i] - n] = i;
rep1(i, n - 1) printf("%d %d\n", par[i + n], lp[i]);
return 0;
}
| 0 |
#include<iostream>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
cout<<a+1-b;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 1e6 + 10;
int n;
long long cnt[4][20][20];
int dp[N][20][3];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
int lg2 = log2(n);
dp[1][lg2][0] = 1;
if (pow(2, lg2 - 1) * 3 <= n) {
dp[1][lg2 - 1][1] = 1;
}
for (int i = 0; i <= lg2; ++i)
for (int j = 0; j <= 1; ++j) {
int value = pow(2, i) * pow(3, j);
int upper = n / value;
cnt[0][i][j] = upper;
for (int k = 1; k <= upper; ++k) {
cnt[1][i][j] += (k % 2 != 0);
cnt[2][i][j] += (k % 3 != 0);
}
}
for (int i = 1; i <= n; ++i)
for (int l2 = lg2; l2 >= 0; --l2)
for (int l3 = 1; l3 >= 0; --l3)
if (dp[i][l2][l3]) {
if (cnt[0][l2][l3] > i)
dp[i + 1][l2][l3] =
(dp[i + 1][l2][l3] +
(long long)dp[i][l2][l3] * (cnt[0][l2][l3] - i) % MOD) %
MOD;
if (l2 > 0) {
dp[i + 1][l2 - 1][l3] =
(dp[i + 1][l2 - 1][l3] +
(long long)dp[i][l2][l3] * cnt[1][l2 - 1][l3] % MOD) %
MOD;
}
if (l3 > 0) {
dp[i + 1][l2][l3 - 1] =
(dp[i + 1][l2][l3 - 1] +
(long long)dp[i][l2][l3] * cnt[2][l2][l3 - 1] % MOD) %
MOD;
}
}
cout << dp[n][0][0];
}
| 5 |
#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
#define REP(i, N) for(int i = 0; i < (int)N; ++i)
// 3 ** 11
int N, M;
int num[200000];
int dp[200000];
int encode(string s) {
int h = 0;
for(int i = 0; i < s.size(); i++) {
h = h * 3 + s[i] - '0';
}
return h;
}
void decode(int c, string &s) {
REP(i, M) {
s[M - 1 - i] = '0' + c % 3;
c /= 3;
}
}
int get_num(string str) {
int state = encode(str);
if( num[state] >= 0 ) return num[state];
int res = 0;
for(int i = 0; i < str.size(); i++) {
if( str[i] == '2' ) {
str[i] = '0';
res += get_num(str);
str[i] = '1';
res += get_num(str);
break;
}
}
return num[state] = res;
}
int rec(string s) {
int state = encode(s);
if( num[state] <= 1 ) return 0;
if( dp[state] >= 0 ) return dp[state];
int res = 999999;
for(int i = 0; i < s.size(); i++) {
if( s[i] == '2' ) {
int t = 0;
s[i] = '0';
t = max(t, 1 + rec(s));
s[i] = '1';
t = max(t, 1 + rec(s));
s[i] = '2';
res = min(t, res);
}
}
return dp[state] = res;
}
int main() {
for(;;) {
cin >> M >> N;
if( N == 0 && M == 0 ) break;
memset(num, -1, sizeof(num));
memset(dp, -1, sizeof(dp));
REP(i, N) {
string str;
cin >> str;
int key = encode(str);
num[key] = 1;
}
int three = 1;
REP(i, M) three *= 3;
string s(M, '_');
REP(state, three) {
decode(state, s);
get_num(s);
}
REP(i, M) s[i] = '2';
int ans = rec(s);
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
const int N = 100020;
using namespace std;
long long ans[N];
vector<long long> edges;
vector<long long> vertices;
long long vis[N];
long long w[N];
void dfs(long long v, vector<vector<long long> > &gr, vector<long long> &a,
vector<long long> &b, vector<long long> &c, long long here,
long long rt) {
vertices.push_back(v);
vis[v] = rt;
w[v] = here;
for (auto i : gr[v]) {
long long u = a[i] + b[i] - v;
edges.push_back(i);
if (vis[u] != rt) {
dfs(u, gr, a, b, c, c[i] - here, rt);
}
}
}
void solve(long long v, vector<vector<long long> > &gr, vector<long long> &a,
vector<long long> &b, vector<long long> &c, vector<long long> &col) {
edges.clear();
vertices.clear();
long long X = 1000000000;
dfs(v, gr, a, b, c, X, X);
long long limits = 0, tt = 0;
for (auto e : edges) {
if (w[a[e]] + w[b[e]] == c[e]) continue;
limits = 1;
long long xs = 0, other = 0;
if (w[a[e]] < 0) {
xs--;
other += w[a[e]] + X;
} else {
xs++;
other += w[a[e]] - X;
}
if (w[b[e]] < 0) {
xs--;
other += w[b[e]] + X;
} else {
xs++;
other += w[b[e]] - X;
}
if (xs == 0) {
cout << "NO\n";
exit(0);
}
tt = (c[e] - other) / xs;
}
if (limits == 0) {
vector<long long> val;
for (auto v : vertices) {
if (w[v] > 0) {
long long z = w[v] - X;
val.push_back(-z);
} else {
long long z = w[v] + X;
val.push_back(z);
}
}
sort((val).begin(), (val).end());
long long z = val[val.size() / 2];
vertices.clear();
edges.clear();
dfs(v, gr, a, b, c, z, z);
long long ok = 1;
for (auto e : edges) {
if (w[a[e]] + w[b[e]] != c[e]) {
ok = 0;
}
}
for (auto v : vertices) col[v] = 1;
assert(ok);
} else {
vertices.clear();
edges.clear();
dfs(v, gr, a, b, c, tt, tt);
long long ok = 1;
for (auto e : edges) {
if (w[a[e]] + w[b[e]] != c[e]) {
ok = 0;
}
}
for (auto v : vertices) col[v] = 1;
if (!ok) {
cout << "NO\n";
exit(0);
}
}
}
signed main() {
long long n, m;
cin >> n >> m;
vector<vector<long long> > graph(n);
vector<long long> a(m), b(m), c(m);
for (long long(i) = 0; (i) != (m); (i)++) {
cin >> a[i] >> b[i] >> c[i];
c[i] *= 2, a[i]--, b[i]--;
graph[a[i]].push_back(i);
graph[b[i]].push_back(i);
}
vector<long long> col(n);
for (long long(i) = 0; (i) != (n); (i)++) {
if (col[i] == 0) {
solve(i, graph, a, b, c, col);
}
}
printf("YES\n");
for (long long(i) = 0; (i) != (n); (i)++) printf("%.9f ", w[i] / 2.0);
}
| 1 |
#include<iostream>
#include<algorithm>
using namespace std;
int a[4]={6000,4000,3000,2000};
int main(void){
int t,n;
while(cin >> t >> n){
cout << a[t-1]*n << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
queue<pair<pair<int, int>, pair<int, int>>> q;
vector<vector<char>> g(n, vector<char>(n, '#'));
vector<vector<pair<int, int>>> a(n, vector<pair<int, int>>(n));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j].first >> a[i][j].second;
if (a[i][j].first != -1) {
a[i][j].first--;
a[i][j].second--;
}
if (a[i][j] == make_pair(i, j)) {
g[i][j] = 'X';
q.push({a[i][j], a[i][j]});
}
}
}
while (!q.empty()) {
auto [value, cur] = q.front();
q.pop();
if (cur.first > 0 && a[cur.first - 1][cur.second] == value &&
g[cur.first - 1][cur.second] == '#') {
g[cur.first - 1][cur.second] = 'D';
q.push({value, {cur.first - 1, cur.second}});
}
if (cur.first < n - 1 && a[cur.first + 1][cur.second] == value &&
g[cur.first + 1][cur.second] == '#') {
g[cur.first + 1][cur.second] = 'U';
q.push({value, {cur.first + 1, cur.second}});
}
if (cur.second > 0 && a[cur.first][cur.second - 1] == value &&
g[cur.first][cur.second - 1] == '#') {
g[cur.first][cur.second - 1] = 'R';
q.push({value, {cur.first, cur.second - 1}});
}
if (cur.second < n - 1 && a[cur.first][cur.second + 1] == value &&
g[cur.first][cur.second + 1] == '#') {
g[cur.first][cur.second + 1] = 'L';
q.push({value, {cur.first, cur.second + 1}});
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i < n - 1 && g[i][j] == '#' && g[i + 1][j] == '#' &&
a[i][j] == a[i + 1][j] && a[i][j] == make_pair(-1, -1)) {
g[i][j] = 'D';
g[i + 1][j] = 'U';
q.push({a[i][j], {i, j}});
q.push({a[i][j], {i + 1, j}});
} else if (j < n - 1 && g[i][j] == '#' && g[i][j + 1] == '#' &&
a[i][j] == a[i][j + 1] && a[i][j] == make_pair(-1, -1)) {
g[i][j] = 'R';
g[i][j + 1] = 'L';
q.push({a[i][j], {i, j}});
q.push({a[i][j], {i, j + 1}});
}
}
}
while (!q.empty()) {
auto [value, cur] = q.front();
q.pop();
if (cur.first > 0 && a[cur.first - 1][cur.second] == value &&
g[cur.first - 1][cur.second] == '#') {
g[cur.first - 1][cur.second] = 'D';
q.push({value, {cur.first - 1, cur.second}});
}
if (cur.first < n - 1 && a[cur.first + 1][cur.second] == value &&
g[cur.first + 1][cur.second] == '#') {
g[cur.first + 1][cur.second] = 'U';
q.push({value, {cur.first + 1, cur.second}});
}
if (cur.second > 0 && a[cur.first][cur.second - 1] == value &&
g[cur.first][cur.second - 1] == '#') {
g[cur.first][cur.second - 1] = 'R';
q.push({value, {cur.first, cur.second - 1}});
}
if (cur.second < n - 1 && a[cur.first][cur.second + 1] == value &&
g[cur.first][cur.second + 1] == '#') {
g[cur.first][cur.second + 1] = 'L';
q.push({value, {cur.first, cur.second + 1}});
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (g[i][j] == '#') {
cout << "INVALID";
return 0;
}
}
}
cout << "VALID\n";
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << g[i][j];
}
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> a, x;
vector<long long> minb, maxb;
vector<long long> v;
int main() {
int n;
long long t;
cin >> n >> t;
long long llmax = std::numeric_limits<long long>::max();
a.assign(n + 1, 0);
x.assign(n + 1, 0);
minb.assign(n + 1, 0);
maxb.assign(n + 1, llmax);
v.assign(n + 2, 0);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> x[i];
for (int i = 1; i <= n; i++) {
minb[i] = a[i] + t;
}
for (int i = 1; i <= n; i++) {
if (x[i] > i) {
v[i]++;
v[x[i]]--;
if (x[i] != n) {
maxb[x[i]] = min(maxb[x[i]], a[x[i] + 1] + t - 1);
}
} else if (x[i] < i) {
minb[x[i]] = max(minb[x[i]], a[i] + t);
maxb[x[i]] = min(maxb[x[i]], a[x[i]] + t - 1);
} else if (x[i] == i && i < n) {
maxb[i] = min(maxb[i], a[i + 1] + t - 1);
}
}
long long sum = 0;
for (int i = 1; i <= n; i++) {
sum += v[i];
if (sum > 0) {
minb[i] = max(minb[i], a[i + 1] + t);
}
}
for (int i = 1; i <= n; i++) {
if (minb[i] > maxb[i] || (i < n && maxb[i + 1] <= minb[i])) {
cout << "No" << endl;
return 0;
}
}
long long prev = 0;
string ans = "";
for (int i = 1; i <= n; i++) {
if (prev < minb[i]) {
ans += to_string(minb[i]);
prev = minb[i];
} else {
if (prev + 1 > maxb[i]) {
cout << "No" << endl;
return 0;
} else {
ans += to_string(prev + 1);
prev++;
}
}
ans += " ";
}
cout << "Yes" << endl;
cout << ans << endl;
return 0;
}
| 3 |
#include <cstdio>
double x1,x2,x3,x4,y1,y2,y3,y4;
int main()
{
while (scanf("%lf%lf%lf%lf%lf%lf%lf%lf", &x1,&y1,&x2,&y2,&x3,&y3,&x4,&y4) == 8) {
if (x1 > x4 || x2 < x3 || y1 > y4 || y2 < y3) puts("NO");
else puts("YES");
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main ()
{
int a;
cin>>a;
cout<<(a/500*1000)+a%500-a%5;
return 0;
}
| 0 |
#include <iostream>
#include <cmath>
using namespace std;
typedef double Real;
const Real EPS = 1e-5;
struct plane{
Real a, b, c, d;
plane() {}
plane(Real a, Real b, Real c, Real d) : a(a), b(b), c(c), d(d) {}
};
struct vect {
Real x, y, z;
vect(Real x = 0, Real y = 0, Real z = 0) : x(x), y(y), z(z) {}
void add(vect& a){
x += a.x;
y += a.y;
z += a.z;
}
void sub(vect& a){
x -= a.x;
y -= a.y;
z -= a.z;
}
void mul(Real a){
x *= a;
y *= a;
z *= a;
}
void div(Real a){
x /= a;
y /= a;
z /= a;
}
Real dot(vect& a){
return (x * a.x + y * a.y + z * a.z);
}
Real dot(plane a){
return (x * a.a + y * a.b + z * a.c);
}
Real length(){
return sqrt(x * x + y * y + z * z);
}
Real dist(vect& a){
vect c = *this;
c.sub(a);
return c.length();
}
Real& access(int a){
a %= 3;
if (a == 0) return x;
if (a == 1) return y;
if (a == 2) return z;
return x;
}
vect cross(vect& a){
vect ret;
vect u = *this, v = a;
ret.x = u.y * v.z - u.z * v.y;
ret.y = u.z * v.x - u.x * v.z;
ret.z = u.x * v.y - u.y * v.x;
return ret;
}
bool eq(vect& a){
return x == a.x && y == a.y && z == a.z;
}
};
ostream &operator<<(ostream &os, const vect &a) { os << "(" << a.x << ", " << a.y << ", " << a.z << ")"; return os; }
struct tri{
vect p0, p1, p2;
tri(vect a, vect b, vect c) : p0(a), p1(b), p2(c) {}
vect normal(){
Real a = ((p1.y - p0.y) * (p2.z - p0.z)) - ((p2.y - p0.y) * (p1.z - p0.z));
Real b = ((p1.z - p0.z) * (p2.x - p0.x)) - ((p2.z - p0.z) * (p1.x - p0.x));
Real c = ((p1.x - p0.x) * (p2.y - p0.y)) - ((p2.x - p0.x) * (p1.y - p0.y));
vect ret(a, b, c);
// cout << "ret : " << ret << ", length = " << ret.length() << endl;
ret.div(ret.length());
return ret;
}
Real area(){
Real a, b, c, s;
a = p0.dist(p1), b = p1.dist(p2), c = p2.dist(p0);
s = (a + b + c) / 2;
return sqrt(s * (s - a) * (s - b) * (s - c));
}
};
bool intersect(vect n, vect A, vect B, vect v1, vect *ret)
{
vect AP = v1; AP.sub(A);
vect BP = v1; BP.sub(B);
Real dot_APN = AP.dot(n), dot_BPN = BP.dot(n);
if (abs(dot_APN) < EPS && abs(dot_BPN) < EPS){
// cout << "double zero" << endl;
return false;
}
else if ((dot_APN - EPS <= 0.0 && 0.0 <= dot_BPN + EPS) || (dot_BPN - EPS <= 0.0 && 0.0 <= dot_APN + EPS)){
// RINPANA
}
else {
// cout << "same side" << endl;
return false;
}
vect AB = B; AB.sub(A);
Real h = abs(dot_APN) / (abs(dot_APN) + abs(dot_BPN));
// cout << "AP : " << AP << " BP : " << BP << endl;
// cout << "dot_APN = " << dot_APN << ", dot_BPN = " << dot_BPN << endl;
// cout << "AB : " << AB << endl;
ret->x = A.x + (AB.x * h);
ret->y = A.y + (AB.y * h);
ret->z = A.z + (AB.z * h);
return true;
}
int main()
{
Real x, y, z;
while (cin >> x){
if (cin.eof()) break;
cin >> y >> z; vect uaz_(x, y, z);
cin >> x >> y >> z; vect enemy_(x, y, z);
cin >> x >> y >> z; vect v1_(x, y, z);
cin >> x >> y >> z; vect v2_(x, y, z);
cin >> x >> y >> z; vect v3_(x, y, z);
tri barrier(v1_, v2_, v3_);
vect n = barrier.normal();
vect uaz = uaz_, v1 = v1_;
vect v = uaz_;
v.sub(enemy_);
uaz.sub(v1);
// cout << n << endl;
bool ok = true;
if (abs(v.dot(n)) < EPS){
// cout << "zero" << endl;
}
else {
// Real t = (uaz.dot(n)) / (v.dot(n));
// // cout << "DEBUG ***" << t << " " << dst << endl;
// if (t < 0){
// // cout << "back" << endl;
// ok = false;
// }
// else if (dst < t + EPS){
// // cout << "over" << endl;
// ok = false;
// }
vect inter;
if (!intersect(n, uaz_, enemy_, v1_, &inter)){
// NIKOMAKI
// cout << "empty" << endl;
}
else {
// cout << "intersect point : " << inter << endl;
// Q, v1, v2
Real a, b, c, s;
a = inter.dist(v1_), b = v1_.dist(v2_), c = v2_.dist(inter);
s = (a + b + c) / 2;
Real T1 = sqrt(s * (s - a) * (s - b) * (s - c));
// Q, v2, v3
a = inter.dist(v2_), b = v2_.dist(v3_), c = v3_.dist(inter);
s = (a + b + c) / 2;
Real T2 = sqrt(s * (s - a) * (s - b) * (s - c));
// Q, v3, v1
a = inter.dist(v3_), b = v3_.dist(v1_), c = v1_.dist(inter);
s = (a + b + c) / 2;
Real T3 = sqrt(s * (s - a) * (s - b) * (s - c));
// cout << T1 << " " << T2 << " " << T3 << " " << barrier.area() << endl;
if ((T1 + T2 + T3) < barrier.area() + EPS){
// inside
ok = false;
}
}
}
if (ok){
cout << "HIT" << endl;
}
else {
cout << "MISS" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& n) {
T X = 0, w = 1;
char ch = -1;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
X = (X << 3) + (X << 1) + ch - '0';
ch = getchar();
}
n = X * w;
}
char s[100010], s1[100010];
int main() {
int n;
cin >> n;
while (n--) {
cin >> s >> s1;
int l1 = strlen(s);
int l2 = strlen(s1);
int wz, ans = 0;
for (wz = l2 - 1; wz >= 0; wz--)
if (s1[wz] == '1') break;
for (int i = l1 - (l2 - wz); i >= 0; i--) {
if (s[i] == '1') {
ans = (l1 - 1 - i) - (l2 - 1 - wz);
break;
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[111];
int main() {
scanf("%d", &n);
for (int i = 0, _n = (n); i < _n; i++) scanf("%d", &a[i]);
sort(a, a + n);
int ac = 0, pen = 0, sum = 10;
for (int i = 0, _n = (n); i < _n; i++) {
if (sum + a[i] <= 720) {
ac++;
sum += a[i];
if (sum >= 360) pen += sum - 360;
}
}
printf("%d %d\n", ac, pen);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i;
cin >> t;
for (i = 0; i < t; i++) {
long long int r, g, b, w;
cin >> r >> g >> b >> w;
if (r % 2 == 0 && g % 2 == 0 && b % 2 == 0)
cout << "Yes";
else if (r % 2 != 0) {
if (g % 2 == 0 && b % 2 == 0 && w % 2 == 0)
cout << "Yes";
else if (w % 2 == 0) {
if (g % 2 != 0 && b % 2 != 0)
cout << "Yes";
else
cout << "No";
} else {
if ((g % 2 == 0 && b % 2 == 0) || g == 0 || b == 0)
cout << "No";
else
cout << "Yes";
}
} else if (g % 2 != 0) {
if (r % 2 == 0 && b % 2 == 0 && w % 2 == 0)
cout << "Yes";
else if (w % 2 == 0) {
if (r % 2 != 0 && b % 2 != 0)
cout << "Yes";
else
cout << "No";
} else {
if ((r % 2 == 0 && b % 2 == 0) || r == 0 || b == 0)
cout << "No";
else
cout << "Yes";
}
} else {
if (g % 2 == 0 && r % 2 == 0 && w % 2 == 0)
cout << "Yes";
else if (w % 2 == 0) {
if (g % 2 != 0 && r % 2 != 0)
cout << "Yes";
else
cout << "No";
} else {
if ((g % 2 == 0 && r % 2 == 0) || g == 0 || r == 0)
cout << "No";
else
cout << "Yes";
}
}
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void minimize(X &x, const Y &y) {
if (x > y) x = y;
}
template <class X, class Y>
void maximize(X &x, const Y &y) {
if (x < y) x = y;
}
template <class T>
T Abs(const T &x) {
return (x < 0 ? -x : x);
}
struct Node {
int cnt;
Node *child[2];
Node(int x = 0) {
cnt = x;
for (int i = 0, _n = (2); i < _n; i = i + 1) child[i] = NULL;
}
};
struct Query {
int type, value, limit;
Query() { type = value = limit = 0; }
void input(void) {
scanf("%d%d", &type, &value);
if (type == 3) scanf("%d", &limit);
}
};
Query queries[100100];
int numQuery;
Node *root;
void addNumber(int x) {
Node *p = root;
for (int i = (30 - 1), _a = (0); i >= _a; i = i - 1) {
int j = (((x) >> (i)) & 1);
if (p->child[j] == NULL) p->child[j] = new Node();
p = p->child[j];
}
}
void init(void) {
scanf("%d", &numQuery);
for (int i = 0, _n = (numQuery); i < _n; i = i + 1) queries[i].input();
root = new Node();
for (int i = 0, _n = (numQuery); i < _n; i = i + 1) {
if (queries[i].type == 1) addNumber(queries[i].value);
if (queries[i].type == 3) addNumber(queries[i].value ^ queries[i].limit);
}
}
void update(int x, int v) {
Node *p = root;
for (int i = (30 - 1), _a = (0); i >= _a; i = i - 1) {
int j = (((x) >> (i)) & 1);
assert(p->child[j] != NULL);
p = p->child[j];
p->cnt += v;
}
}
int answer(int value, int limit) {
Node *p = root;
int res = 0;
for (int i = (30 - 1), _a = (0); i >= _a; i = i - 1) {
assert(p != NULL);
int j = (((value ^ limit) >> (i)) & 1);
if ((((limit) >> (i)) & 1) && p->child[j ^ 1] != NULL)
res += p->child[j ^ 1]->cnt;
p = p->child[j];
}
return res;
}
void process(void) {
for (int i = 0, _n = (numQuery); i < _n; i = i + 1) {
if (queries[i].type != 3)
update(queries[i].value, queries[i].type == 1 ? 1 : -1);
else
printf("%d\n", answer(queries[i].value, queries[i].limit));
}
}
int main(void) {
init();
process();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, a[105], x, ans, l, r, m, k, s;
inline void up(long long& a, long long b) {
if (a > b) a = b;
}
inline long long sum(long long x) {
long long s = 0;
for (long long j = 1; j <= n; ++j) s += 1ll * (a[j] + x - 1) / x * x - a[j];
return s;
}
int main() {
cin >> n >> k;
for (i = 1; i <= n; ++i) cin >> a[i];
j = n + 1;
for (i = 1; x < 1ll << 40; i = x + 1) {
x = 1ll << 40;
for (j = 1; j <= n; ++j)
if (a[j] > i) up(x, (a[j] - 1) / ((a[j] - 1) / i));
if (sum(x) <= k)
ans = x;
else if (sum(i) <= k) {
l = i;
r = x;
while (l < r) {
m = (l + r + 1) >> 1;
if (sum(m) <= k)
l = m;
else
r = m - 1;
}
ans = l;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long dp[501][501], val[501][501];
void solve() {
long long n, i, j, k, len;
cin >> n;
vector<long long> arr(n);
for (i = 0; i < n; i++) cin >> arr[i];
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
dp[i][j] = INT_MAX;
if (i == j) dp[i][j] = 1, val[i][j] = arr[i];
}
for (len = 2; len <= n; len++) {
for (i = 0; i < n; i++) {
j = i + len - 1;
if (j >= n) continue;
for (k = i; k < j; k++) {
if (dp[i][k] == 1 && dp[k + 1][j] == 1 && val[i][k] == val[k + 1][j])
dp[i][j] = 1, val[i][j] = val[i][k] + 1;
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j]);
}
}
}
cout << dp[0][n - 1] << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int D[n];
for (int i = 0; i < n; i++) {
cin >> D[i];
}
int x, y;
cin >> x >> y;
int F[n];
F[n - 1] = D[n - 1];
for (int i = n - 2; i >= 0; i--) {
F[i] = D[i] + F[i + 1];
}
for (int i = 0; i < n; i = i + 1) {
if (F[i] <= y && F[i] >= x && F[0] - F[i] <= y && F[0] - F[i] >= x) {
cout << i + 1;
return 0;
}
}
cout << 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int c[500005];
int n, k;
struct fff {
int num;
int id;
};
fff f[500005];
bool cmp(fff a, fff b) {
if (a.num == b.num) return a.id < b.id;
return a.num < b.num;
}
int lowbit(int x) { return x & -x; }
void add(int x, int y) {
while (x <= n) {
c[x] = c[x] + y;
x = x + lowbit(x);
}
}
int sum(int x) {
int ans = 0;
while (x > 0) {
ans = ans + c[x];
x = x - lowbit(x);
}
return ans;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &f[i].num);
f[i].id = i + 1;
}
sort(f, f + n, cmp);
int changep = -1, inip = -1;
int ok = 1;
for (int i = 0; i < n; i++) {
int nowp = f[i].id;
if (changep != -1 && nowp == changep) nowp = inip;
if (nowp <= n - k && sum(nowp + k) == sum(nowp)) {
if (changep != -1) {
ok = 0;
break;
}
int maxm = -1;
for (int j = 0; j < i; j++) {
if (f[j].num > maxm) {
maxm = f[j].num;
inip = f[j].id;
}
}
if (maxm == -1) {
ok = 0;
break;
}
int yes = 0;
if (n + 1 - (nowp + k) <= k)
yes = 1;
else {
for (int j = 0; j < i; j++) {
if (f[j].num < maxm && f[j].id > nowp + k &&
f[j].id - (nowp + k) <= k) {
yes = 1;
break;
}
}
}
if (!yes) {
ok = 0;
break;
}
changep = nowp + k;
add(inip, -1);
add(changep, 1);
}
add(nowp, 1);
}
if (ok)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 6 |
#include <iostream>
using namespace std ;
int main(){
int n ; cin >> n ;
int cnt = 0 ;
for(int i=1;i<=n;i+=2){
int sub = 0 ;
for(int j=1;j<=i;j++){
if(i%j==0) sub++ ;
}
if(sub==8) cnt++ ;
}
cout << cnt << endl ;
}
| 0 |
#include <bits/stdc++.h>
int main(void) {
int players, m, h, time[1010], total = 0;
scanf("%d %d %d", &players, &m, &h);
h--;
for (int i = 0; i < m; i++) {
scanf("%d", &time[i]);
total += time[i];
}
if (total >= players) {
double tot = (double)(total - 1);
double aux = 1.;
for (int i = 1; i < players; i++, tot -= 1.0) {
aux *= (tot - (double)time[h] + 1.) / tot;
}
printf("%.9lf\n", 1. - aux);
} else
printf("-1.0\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int N;
cin >> N;
int64_t res = 0;
vector<vector<pair<int, int>>> K(N);
for (int i = 0; i < N; i++) {
int k, l, r;
cin >> k >> l >> r;
k--;
K[k].emplace_back(make_pair(l, r));
res += min(l, r);
}
priority_queue<int, vector<int>, greater<int>> que;
for (int k = 0; k < N; k++) {
for (auto& [l, r] : K[k]) {
if (l > r) {
que.push(l - r);
}
}
while ((int)que.size() > k + 1) {
que.pop();
}
}
while (!que.empty()) {
res += que.top();
que.pop();
}
for (int k = N - 1; k > -1; k--) {
for (auto& [l, r] : K[k]) {
if (r > l) {
que.push(r - l);
}
}
while ((int)que.size() > N - k - 1) {
que.pop();
}
}
while (!que.empty()) {
res += que.top();
que.pop();
}
cout << res << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
for (int i = 0; i < T; i++) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ft[1000002], ed[1000002], nt[1000002], L, vs[1000002], S;
void add(int a, int b) {
nt[++L] = ft[a];
ft[a] = L;
ed[L] = b;
}
int f[1000002][2], is[1000002], ntt[1000002][2], ls[1000002], tot, fl;
void dfs(int x, int o) {
f[x][o] = 1;
if (!is[x] && o == 1) {
fl = 1;
return;
}
for (int i = ft[x]; i; i = nt[i]) {
if (!f[ed[i]][o ^ 1]) ntt[x][o] = ed[i], dfs(ed[i], o ^ 1);
if (fl) return;
}
}
void isr(int x) {
vs[x] = 1;
for (int i = ft[x]; i; i = nt[i])
if (vs[ed[i]] == 1)
fl = 1;
else if (!vs[ed[i]])
isr(ed[i]);
vs[x] = 2;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int o, x;
scanf("%d", &o);
is[i] = o;
for (; o--;) scanf("%d", &x), add(i, x);
}
cin >> S;
dfs(S, 0);
if (fl) {
puts("Win");
for (int i = S, v = 0; i; i = ntt[i][v], v ^= 1) cout << i << ' ';
return puts(""), 0;
}
puts((isr(S), fl) ? "Draw" : "Lose");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, S, T, x, y, num;
int a[110][110], b[110][110], s[110], t[110], an[110], h[110], f[110],
c[110][110];
int dfs(int x, int y) {
if (h[x] == num) return f[x];
h[x] = num;
int i, ans = -1;
for (i = 1; i <= n; i++)
if (a[x][i] == 1 && a[x][i] + a[i][y] == a[x][y]) ans = max(ans, dfs(i, y));
if (ans < 0) ans = a[0][0];
f[x] = min(ans, an[x] + 1);
return f[x];
}
int main() {
scanf("%d%d%d%d", &n, &m, &S, &T);
memset(a, 60, sizeof(a));
for (i = 1; i <= n; i++) a[i][i] = 0;
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
a[x][y] = 1;
}
for (k = 1; k <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) a[i][j] = min(a[i][j], a[i][k] + a[k][j]);
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
for (j = 1; j <= n; j++)
if (a[x][j] < 1e9 && a[x][j] + a[j][y] == a[x][y]) b[i][a[x][j]]++;
for (j = 1; j <= n; j++)
if (a[x][j] < 1e9 && a[x][j] + a[j][y] == a[x][y] && b[i][a[x][j]] == 1)
c[i][j] = 1;
s[i] = x, t[i] = y;
}
memset(an, 60, sizeof(an));
an[T] = 0;
for (;;) {
int F = 0;
for (i = 1; i <= m; i++) {
for (j = 1; j <= n; j++)
if (c[i][j]) {
++num;
int A = dfs(j, t[i]);
if (A < an[j]) an[j] = A, F = 1;
}
}
if (!F) break;
}
printf("%d\n", an[S] > 1e9 ? -1 : an[S]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long len, ans, s0, s1, s2, fac[2001], invfac[2001], S[2001][2001],
lst[2001], n, a[2001], b[2001], pv[2001], nxt[2001], F[2001], f[2001],
G[2001], g[2001], h[2001], k[2001], K[2001], minn[2001];
int read() {
char c = 0;
int sum = 0;
while (c < '0' || c > '9') c = getchar();
while ('0' <= c && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
long long fast_pow(long long a, int b) {
if (b == 0) return 1;
if (b & 1)
return fast_pow(a * a % 998244353, b / 2) * a % 998244353;
else
return fast_pow(a * a % 998244353, b / 2);
}
long long A(int x, int y) { return fac[x] * invfac[x - y] % 998244353; }
long long C(int x, int y) {
return fac[x] * invfac[x - y] % 998244353 * invfac[y] % 998244353;
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i <= n; ++i) b[i] = read();
for (int i = 1; i <= n; ++i) nxt[i] = pv[i] = -1;
for (int i = 1; i <= n; ++i) {
nxt[a[i]] = b[i];
pv[b[i]] = a[i];
}
for (int i = 1; i <= n; ++i) {
lst[i] = i;
minn[i] = i;
while (nxt[lst[i]] != i && nxt[lst[i]] != 0 && nxt[lst[i]] != -1) {
lst[i] = nxt[lst[i]];
minn[i] = min(minn[i], lst[i]);
}
lst[i] = nxt[lst[i]];
}
for (int i = 1; i <= n; ++i) {
if (a[i] == 0 && b[i] > 0 && lst[b[i]] == -1) s1++;
if (a[i] == 0 && b[i] > 0 && lst[b[i]] == 0) s2++;
if (a[i] == 0 && b[i] == 0) s2++;
if (a[i] > 0 && lst[a[i]] == a[i] && minn[a[i]] == a[i]) ans++;
if (a[i] > 0 && lst[a[i]] == 0 && pv[a[i]] == -1) s0++;
}
fac[0] = 1;
for (int i = 1; i <= 2000; ++i) fac[i] = fac[i - 1] * i % 998244353;
invfac[2000] = fast_pow(fac[2000], 998244353 - 2);
for (int i = 1999; i >= 0; --i)
invfac[i] = invfac[i + 1] * (i + 1) % 998244353;
S[0][0] = 1;
for (int i = 1; i <= 2000; ++i)
for (int j = 1; j <= i; ++j)
S[i][j] =
(S[i - 1][j] * (i - 1) % 998244353 + S[i - 1][j - 1]) % 998244353;
for (int i = 0; i <= s0; ++i)
for (int j = i; j <= s0; ++j)
F[i] = (F[i] + C(s0, j) * S[j][i] % 998244353 * A(s0 - j + s2, s0 - j) %
998244353) %
998244353;
for (int i = 0; i <= s0; ++i)
for (int j = i; j <= s0; ++j) {
if ((j - i) % 2 == 0)
f[i] = (f[i] + F[j] * C(j, i) % 998244353) % 998244353;
else
f[i] = (f[i] - F[j] * C(j, i) % 998244353) % 998244353;
}
for (int i = 0; i <= s1; ++i)
for (int j = i; j <= s1; ++j)
G[i] = (G[i] + C(s1, j) * S[j][i] % 998244353 * A(s1 - j + s2, s1 - j) %
998244353) %
998244353;
for (int i = 0; i <= s1; ++i)
for (int j = i; j <= s1; ++j) {
if ((j - i) % 2 == 0)
g[i] = (g[i] + G[j] * C(j, i) % 998244353) % 998244353;
else
g[i] = (g[i] - G[j] * C(j, i) % 998244353) % 998244353;
}
for (int i = 0; i <= s2; ++i) h[i] = S[s2][i] * fac[s2] % 998244353;
for (int i = 0; i <= s0; ++i)
for (int j = 0; j <= s1; ++j)
k[i + j] = (k[i + j] + f[i] * g[j] % 998244353) % 998244353;
for (int i = 0; i <= s0 + s1; ++i)
for (int j = 0; j <= s2; ++j)
K[i + j] = (K[i + j] + k[i] * h[j] % 998244353) % 998244353;
puts("");
for (int i = n; i >= 1; --i) {
if (i < ans)
printf("%lld ", 0);
else
printf("%lld ", (K[i - ans] + 998244353) % 998244353);
}
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
bitset<maxn> pr;
void sieve(){
pr.set();
pr[0] = pr[1] = 0;
for(int i = 2; i*i < maxn; ++i){
if(pr[i])
for(int j = i*i; j < maxn; j+=i)
pr[j] = 0;
}
}
int main() {
sieve();
vector<int> suma(maxn, 0);
for(int i = 1; i < maxn; ++i) suma[i] = suma[i - 1] + (pr[i] and pr[(i + 1)/2]);
int q,l,r;
cin >> q;
while(q--){
cin >> l >> r;
cout << suma[r] - suma[l - 1] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 998244353;
long long int modpow(long long int x, long long int e) {
if (e == 1)
return x;
else if (e == 0)
return 1;
long long int res = modpow(x, e / 2);
res = res * res;
res %= mod;
if (e % 2 == 1) {
res *= x;
res %= mod;
}
return res;
}
long long int mulinv[100005], fac[100005], facinv[100005];
long long int choose(long long int x, long long int k) {
long long int a = x - k;
long long int res = fac[x];
res *= facinv[a];
res %= mod;
res *= facinv[k];
res %= mod;
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int n, m, t, a, b, c, h, d, x, y, z, i, j, k,
ans = 0, ans2 = 0, cur = 0, cur2 = 0, sum = 0, sum2 = 0, maxn;
string str = "", str2, str3;
cin >> n;
for (i = 1; i <= n; i++) mulinv[i] = modpow(i, mod - 2);
fac[0] = 1;
fac[1] = 1;
for (i = 2; i <= n; i++) {
fac[i] = fac[i - 1] * i;
fac[i] %= mod;
}
facinv[0] = facinv[1] = 1;
for (i = 2; i <= n; i++) {
facinv[i] = facinv[i - 1] * mulinv[i];
facinv[i] %= mod;
}
a = b = x = y = k = 0;
bool ok = true, ok2 = false, ok3 = false;
for (i = 0; i < n; i++) {
cin >> str;
if (str[0] == '?')
x++;
else if (str[0] == 'B')
a++;
if (str[1] == '?')
y++;
else if (str[1] == 'W')
b++;
if (str[0] == '?' && str[1] == '?') k++;
if (str == "BB" || str == "WW") ok = false;
if (str == "BW" || str == "B?" || str == "?W") ok2 = true;
if (str == "WB" || str == "W?" || str == "?B") ok3 = true;
}
if (a < b) {
swap(a, b);
swap(x, y);
}
sum = 0;
for (i = 0; i <= x; i++) {
c = a + i - b;
if (c > y) break;
z = choose(x, i) * choose(y, c);
z %= mod;
sum += z;
sum %= mod;
}
if (ok) {
sum2 = 1;
for (i = 0; i < k; i++) {
sum2 *= 2;
sum2 %= mod;
}
if (!(ok2 && ok3)) {
if (ok2 || ok3) {
sum2 += mod - 1;
sum2 %= mod;
} else {
sum2 += mod - 2;
sum2 %= mod;
}
}
sum += mod - sum2;
sum %= mod;
}
cout << sum;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1000000007;
vector<long long> G;
bool v[1000010];
long long a[1000010];
long long f[1000010];
long long p, k, i, j, ans;
void dfs(long long o, long long st) {
v[o] = 1;
if (!v[(o * k) % p]) {
dfs((o * k) % p, st + 1);
} else {
G.push_back(st);
a[st]++;
}
}
int main() {
scanf("%I64d%I64d", &p, &k);
if (k == 0) {
long long tem = 1;
for (i = 1; i < p; ++i) tem = (tem * p) % oo;
printf("%I64d\n", tem);
return 0;
}
for (i = 0; i < p; ++i) {
if (!v[i]) {
dfs(i, 1);
}
}
memset(v, 0, sizeof(v));
for (i = 0; i < G.size(); ++i) {
if (v[G[i]]) continue;
v[G[i]] = 1;
for (j = 1; j * j <= G[i]; ++j) {
if (G[i] % j) continue;
f[G[i]] = (f[G[i]] + a[j] * j) % oo;
if (j * j != G[i])
f[G[i]] = (f[G[i]] + (a[G[i] / j] * (G[i] / j)) % oo) % oo;
}
}
ans = 1;
for (i = 0; i < G.size(); ++i) {
ans = (ans * f[G[i]]) % oo;
}
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <iostream>
using namespace std;
int main() {
int i,j,k;
long n, s=1, M=1e9+7, a[1001]={0};
cin>>n;
for(i=2;i<=n;i++){
k=i;
for(j=2;k>1;){
if(k%j==0){
a[j]++;
k/=j;
}
else
j++;
}
}
for(auto x:a)
s = s*(x+1)%M;
cout<<s;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long Min(long long a, long long b) { return (a < b) ? a : b; }
long long Max(long long a, long long b) { return (a > b) ? a : b; }
long long gcd(long long m, long long n) {
if (n == 0)
return m;
else
return gcd(n, m % n);
}
long long lcm(long long m, long long n) { return m * n / gcd(m, n); }
vector<pair<char, long long> > v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long long n = s.length();
for (int i = 0; i < n; i++) {
v.push_back({s[i], i});
while (v.size() >= 2 && v[v.size() - 2].first == '1' &&
v.back().first == '0') {
v.pop_back();
v.pop_back();
}
}
for (auto t : v) {
s[t.second] = '0';
}
cout << s;
exit(0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a, b;
int solve(int d) {
int dd = d + d;
map<int, int> fa, fb;
for (int x : a) fa[x % dd]++;
for (int x : b) fb[x % dd]++;
int ans = 0;
for (auto it : fa) {
int i = it.first;
int tmp = fb[(i + d) % dd] + it.second;
ans = max(ans, tmp);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, y1;
cin >> n >> y1;
a.resize(n);
for (int i = 0; i < n; i++) cin >> a[i];
int m, y2;
cin >> m >> y2;
b.resize(m);
for (int i = 0; i < m; i++) cin >> b[i];
int ans = 2;
for (int i = 0; i < 31; i++) ans = max(ans, solve(1 << i));
swap(a, b);
for (int i = 0; i < 31; i++) ans = max(ans, solve(1 << i));
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, n, m;
cin >> n;
long long int re = 0, f = 0;
long long int cur = 0, pre = 0, sum = 0;
for (i = 0; i < n; i++) {
cin >> k;
long long int req = pre - k;
sum += req;
if (sum < 0) {
re = max(re, -sum);
}
pre = k;
}
cout << re << "\n";
}
| 2 |
#include <iostream>
using namespace std;
int main(){
int l,r,d;
cin>>l>>r>>d;
cout << (r/d)-((l-1)/d)<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b,k;
cin >> a >> b >> k;
for (int i = a; i<=b;i++){
if (i < a+k || i > b-k) cout << i << endl;
}
}
| 0 |
#include<iostream>
#include<string>
using namespace std;
int main(){
double x[4],y[4];
while(cin>>x[0]){
cin>>y[0];
for(int i=1;i<4;i++)
cin>>x[i]>>y[i];
if(x[0]<=x[3]&&y[1]>=y[2]&&x[1]>=x[2]&&y[0]<=y[3])
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 666;
const long long mod = 1e9 + 9;
char st[maxn];
long long quick_mod(long long a, long long n, long long mod) {
long long temp = 1;
while (n) {
if (n & 1) temp = (temp * a) % mod;
a = ((a % mod) * (a % mod)) % mod;
n >>= 1;
}
return (temp % mod + mod) % mod;
}
int main() {
int n, a, b, k, m;
scanf("%d %d %d %d", &n, &a, &b, &k);
scanf("%s", st);
m = n + 1;
int x = m / k, y, chx, xx;
long long aa, bb;
y = m % (x * k);
int len = k;
long long sum = 0, ans;
aa = quick_mod(a, k, mod);
bb = quick_mod(b, k, mod);
long long inv = (quick_mod(aa - bb, mod - 2, mod) + mod) % mod;
for (int i = 0; i < len; i++) {
chx = st[i] == '+' ? 1 : -1;
xx = (n - i) / k;
ans = (quick_mod(b, i, mod) * quick_mod(a, (n - i) % k, mod) + mod) % mod;
if (aa != bb)
ans = (((quick_mod(aa, xx + 1, mod) - quick_mod(bb, xx + 1, mod) + mod) %
mod * inv) %
mod) *
ans % mod;
else
ans = (aa * (xx + 1)) % mod * ans % mod;
sum = (sum + ((ans * chx) % mod) + mod) % mod;
sum = (sum + mod) % mod;
}
printf("%lld\n", (sum + mod) % mod);
}
| 1 |
#include <bits/stdc++.h>
int b[2][100000], c[2][100000], n, m, i, j, p, z = 1, f;
struct cd {
int x, y;
} a[100000];
bool cmp(cd a, cd b) { return a.x == b.x ? a.y < b.y : a.x < b.x; }
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
a[i].x--, a[i].y--;
}
std::sort(a, a + m, cmp);
for (i = 1; i < m; i++)
if (a[i].x != a[i - 1].x) c[1][p++] = i - 1, c[0][p] = i;
c[1][p++] = m - 1;
for (i = 0; i < p; i++) b[1][i] = n - 1;
if (!a[0].x) b[1][0] = a[0].y, c[1][0] = 0;
if (a[m - 1].x == n - 1) b[0][p - 1] = a[m - 1].y, c[0][p - 1] = m - 1;
while (z) {
z = 0;
for (i = 0; i < p; i++) {
if (i && b[0][i - 1] > b[0][i]) b[0][i] = b[0][i - 1], z = 1;
for (j = c[0][i]; j <= c[1][i]; j++) {
if (a[j].y == b[0][i]) b[0][i] = a[j].y + 1, c[0][i] = j, z = 1;
if (i && a[c[0][i - 1]].x + 1 == a[c[0][i]].x &&
b[1][i - 1] < b[1][i] && a[j].y <= b[1][i] && a[j].y >= b[1][i - 1])
b[1][i] = a[j].y - 1, c[1][i] = j, z = 1;
}
if (b[0][i] > b[1][i]) {
puts("-1");
return 0;
}
}
for (i = p - 1; i >= 0; i--) {
if (i != p - 1 && b[1][i + 1] < b[1][i]) b[1][i] = b[1][i + 1], z = 1;
for (j = c[1][i]; j >= c[0][i]; j--) {
if (a[j].y == b[1][i]) b[1][i] = a[j].y - 1, c[1][i] = j, z = 1;
if (i != p - 1 && a[c[0][i + 1]].x - 1 == a[c[0][i]].x &&
b[0][i + 1] > b[0][i] && a[j].y >= b[0][i] && a[j].y <= b[0][i + 1])
b[0][i] = a[j].y + 1, c[0][i] = j, z = 1;
}
if (b[0][i] > b[1][i]) {
puts("-1");
return 0;
}
}
}
printf("%d\n", n * 2 - 2);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, m, k, par[MAXN], color[MAXN];
vector<int> graph[MAXN], cycle;
bool visited[MAXN];
void dfs(int u) {
visited[u] = true;
for (int v : graph[u]) {
if (!cycle.empty()) return;
if (v == par[u]) continue;
if (visited[v]) {
for (int w = u; w != v; w = par[w]) cycle.push_back(w);
cycle.push_back(v);
} else {
color[v] = 1 - color[u];
par[v] = u;
dfs(v);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
graph[u].push_back(v);
graph[v].push_back(u);
}
dfs(1);
if (cycle.empty()) {
vector<int> vtx[2];
for (int u = 1; u <= n; ++u) vtx[color[u]].push_back(u);
int id = (vtx[0].size() > vtx[1].size()) ? 0 : 1;
puts("1");
for (int i = 0; i < (k + 1) / 2; ++i) printf("%d ", vtx[id][i]);
} else {
while (true) {
int p = cycle.size();
vector<int> ind(n + 1, -1);
for (int i = 0; i < p; ++i) ind[cycle[i]] = i;
vector<int> nxtCycle;
for (int i = 0; i < p; ++i) {
if (!nxtCycle.empty()) break;
int prv = cycle[(i + p - 1) % p], u = cycle[i],
nxt = cycle[(i + 1) % p];
for (int v : graph[u]) {
if (v != prv && v != nxt && ind[v] > i) {
int l = i, r = ind[v];
if (r - l <= n - (r - l)) {
for (int j = l; j <= r; ++j) nxtCycle.push_back(cycle[j]);
} else {
for (int j = 0; j <= l; ++j) nxtCycle.push_back(cycle[j]);
for (int j = r; j < p; ++j) nxtCycle.push_back(cycle[j]);
}
break;
}
}
}
if (nxtCycle.empty()) break;
cycle = nxtCycle;
}
if (cycle.size() <= k) {
puts("2");
printf("%d\n", cycle.size());
for (int u : cycle) printf("%d ", u);
} else {
puts("1");
for (int i = 0; i < (k + 1) / 2; ++i) printf("%d ", cycle[2 * i]);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long a, b, mod;
int main(int argc, char **argv) {
cin >> a >> b >> mod;
if (b + 1 >= mod) {
cout << 2 << endl;
return 0;
}
if (1000000000L % mod == 0) {
cout << 2 << endl;
return 0;
}
unsigned long long maxmod = mod - b - 1;
unsigned long long amod = 1000000000L % mod;
for (unsigned long long i = 1; i <= 10000000 && i <= a; i++) {
unsigned long long tmp = (amod * i) % mod;
if (tmp == 0) break;
if (tmp <= maxmod) {
printf("1 %09lld\n", i);
return 0;
}
}
cout << 2 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e2 + 10;
int a[MX], b[MX];
int main() {
int n;
cin >> n;
int x;
for (int i = 0; i < n; i++) {
cin >> x;
a[x]++;
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
b[x]++;
}
int ans = 0;
for (int i = 0; i < MX; i++) {
if (a[i] > 0) {
int p1 = 0, p2 = 0, p3 = 0;
while (a[i] > 0) {
if (b[i - 1] > 0) {
a[i]--;
b[i - 1]--;
ans++;
continue;
} else {
p1 = 1;
}
if (b[i] > 0) {
a[i]--;
b[i]--;
ans++;
continue;
} else {
p2 = 1;
}
if (b[i + 1] > 0) {
a[i]--;
b[i + 1]--;
ans++;
continue;
} else {
p3 = 1;
}
if (p1 && p2 && p3) {
break;
}
}
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline bool invowel(char ch) {
ch = tolower(ch);
return (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u');
}
inline bool isprime(int n) {
if (n < 2 || (n % 2 == 0 && n != 2)) return false;
for (int i = 3; i * i <= n; i += 2)
if (n % i == 0) return false;
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int t;
cin >> t;
while (t--) {
int i, n, pos, able, j;
cin >> n >> pos >> able;
vector<int> possible, tmp, v(n + 1), maxi(n + 1);
v[0] = -1;
for (i = 1; i <= n; i++) cin >> v[i];
tmp = v;
sort(tmp.rbegin(), tmp.rend());
possible.push_back(tmp[0]);
for (i = 1; i < n; i++)
if (tmp[i] != possible.back()) possible.push_back(tmp[i]);
if (able >= pos) able = pos - 1;
for (i = 1; i + (n - pos) <= n; i++) {
maxi[i] = max(v[i], v[i + (n - pos)]);
}
vector<vector<int>> var(n + 1);
tmp.clear();
for (i = 1; i + (n - able) - 1 <= n; i++) {
for (j = i; j + (n - pos) <= i + (n - able) - 1; j++) {
tmp.push_back(maxi[j]);
}
var[i] = tmp;
tmp.clear();
}
for (i = 1; i + (n - able) - 1 <= n; i++) {
sort(var[i].begin(), var[i].end());
}
int in = -1;
for (auto it : possible) {
int flag = 0;
for (i = 1; i + (n - able) - 1 <= n; i++) {
if (it <= *var[i].begin()) {
flag++;
break;
}
}
if (flag) {
in = it;
break;
}
}
cout << in << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 100;
const int maxn = 200005;
char s[maxn], t[maxn];
int main() {
bool flag1, flag2, br;
br = flag1 = flag2 = false;
int i, j, n, m;
scanf("%d%d", &n, &m);
scanf("%s", s);
scanf("%s", t);
if (n > m + 1) {
printf("NO\n");
return 0;
} else {
int cnt_s = 0, cnt_t = 0;
while (s[cnt_s] == t[cnt_t] && cnt_s < n && cnt_t < m) {
cnt_s++;
cnt_t++;
}
if (cnt_s == n && cnt_t == m) {
printf("YES\n");
return 0;
}
if (cnt_s == n) {
printf("NO\n");
return 0;
}
if (s[cnt_s] == '*')
;
else {
printf("NO\n");
return 0;
}
cnt_s = n - 1;
cnt_t = m - 1;
while (s[cnt_s] == t[cnt_t]) {
cnt_s--;
cnt_t--;
}
if (s[cnt_s] == '*') {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t, n, x;
int main() {
cin >> t;
for (int i = 1; i <= t; i++) {
cin >> n >> x;
cout << x * 2 << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 30010;
int n, m, k, x[N], y[N], nx[N], ny[N], tox[N], toy[N], pre[N], to[N * 20],
nxt[N * 20], w[N * 20], cnt = 0, start;
int dis[N], vis[N];
queue<int> q;
bool cmp1(int a, int b) {
if (x[a] != x[b])
return x[a] < x[b];
else
return y[a] < y[b];
}
bool cmp2(int a, int b) {
if (y[a] != y[b])
return y[a] < y[b];
else
return x[a] < x[b];
}
void makeedge(int a, int b, int c) {
to[cnt] = b, w[cnt] = c, nxt[cnt] = pre[a], pre[a] = cnt++;
}
int main() {
memset(pre, -1, sizeof(pre));
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
scanf("%d%d", &x[i], &y[i]);
if (x[i] == 1 && y[i] == 1) start = i;
}
for (int i = 1; i <= k; i++) nx[i] = ny[i] = i;
sort(nx + 1, nx + 1 + k, cmp1);
for (int i = 1; i <= k; i++) tox[nx[i]] = i;
sort(ny + 1, ny + 1 + k, cmp2);
for (int i = 1; i <= k; i++) toy[ny[i]] = i;
for (int i = 1; i <= k; i++) {
int l, r, u, d;
if (tox[i] > 1) {
l = nx[tox[i] - 1];
if (x[l] == x[i] && y[i] == y[l] + 1) makeedge(i, l, 0);
}
if (tox[i] < k) {
r = nx[tox[i] + 1];
if (x[r] == x[i] && y[i] == y[r] - 1) makeedge(i, r, 0);
}
if (toy[i] > 1) {
u = ny[toy[i] - 1];
if (y[u] == y[i] && x[i] == x[u] + 1) makeedge(i, u, 0);
}
if (toy[i] < k) {
d = ny[toy[i] + 1];
if (y[d] == y[i] && x[i] == x[d] - 1) makeedge(i, d, 0);
}
makeedge(i, x[i] + k, 1), makeedge(x[i] + k, i, 0);
if (x[i] > 1) makeedge(i, x[i] + k - 1, 1), makeedge(x[i] + k - 1, i, 0);
if (x[i] < n) makeedge(i, x[i] + k + 1, 1), makeedge(x[i] + k + 1, i, 0);
makeedge(i, n + y[i] + k, 1), makeedge(n + y[i] + k, i, 0);
if (y[i] > 1)
makeedge(i, n + y[i] + k - 1, 1), makeedge(n + y[i] + k - 1, i, 0);
if (y[i] < m)
makeedge(i, n + y[i] + k + 1, 1), makeedge(n + y[i] + k + 1, i, 0);
}
memset(dis, 0x3f, sizeof(dis));
q.push(start);
dis[start] = 0, vis[start] = 1;
while (!q.empty()) {
int a = q.front();
q.pop();
vis[a] = 0;
for (int it = pre[a]; ~it; it = nxt[it]) {
int b = to[it];
if (dis[b] > dis[a] + w[it]) {
dis[b] = dis[a] + w[it];
if (!vis[b]) q.push(b), vis[b] = 1;
}
}
}
int ans = 0x3f3f3f3f;
for (int i = 1; i <= k; i++) {
if (x[i] == n && y[i] == m)
ans = min(ans, dis[i]);
else if (x[i] == n && y[i] != m)
ans = min(ans, dis[i] + 1);
else if (x[i] != n && y[i] == m)
ans = min(ans, dis[i] + 1);
}
ans = min(ans, dis[n + k]), ans = min(ans, dis[n + m + k]);
if (ans == 0x3f3f3f3f) ans = -1;
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long C[100005];
unsigned long long sol;
int main() {
sol = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> C[i];
long long last = C[0], cont = 1;
for (int i = 1; i < n; i++)
if (C[i] != last) {
sol += (cont * (cont + 1)) / 2;
cont = 1;
last = C[i];
} else
cont++;
sol += cont * (cont + 1) / 2;
cout << sol << endl;
return 0;
}
| 2 |
#include "bits/stdc++.h"
using namespace std;
int main() {
long long N, K, A[100], MOD = 1000000007;
static long long DP[110][100010] = {};
DP[0][0] = 1;
cin >> N >> K;
for (int i = 0; i < N; i++) cin >> A[i];
for (int i = 0; i < N; i++) {
static long long SUM[100010] = {};
for (int j = 0; j <= K; j++) {
SUM[j + 1] = (SUM[j] + DP[i][j]) % MOD;
}
for (int j = 0; j <= K; j++) {
DP[i + 1][j] = (SUM[j + 1] - SUM[max(0LL, j - A[i])] + MOD) % MOD;
}
}
cout << DP[N][K] << endl;
}
| 0 |
#include <bits/stdc++.h>
struct SegTree {
struct Node {
int l = 0, r = 0;
std::pair<int, int> v = {0, -1}, p = {0, -1};
};
std::vector<Node> tree = {{}, {}};
void visit(int n, int l, int m, int r) {
if (!tree[n].l && l <= m) tree[n].l = tree.size(), tree.emplace_back();
if (!tree[n].r && m + 1 <= r) tree[n].r = tree.size(), tree.emplace_back();
setMax(tree[n].l, l, m, l, r, tree[n].p);
setMax(tree[n].r, m + 1, r, l, r, tree[n].p);
tree[n].p = Node().p;
}
void setMax(int n, int l, int r, int lq, int rq, std::pair<int, int> v) {
if (!n || r < lq || rq < l || rq < lq) {
return;
} else if (lq <= l && r <= rq) {
tree[n].v = std::max(tree[n].v, v);
tree[n].p = std::max(tree[n].p, v);
} else {
int m = l + (r - l) / 2;
visit(n, l, m, r);
setMax(tree[n].l, l, m, lq, rq, v);
setMax(tree[n].r, m + 1, r, lq, rq, v);
tree[n].v = std::max(tree[tree[n].l].v, tree[tree[n].r].v);
}
}
std::pair<int, int> getMax(int n, int l, int r, int lq, int rq) {
if (!n || r < lq || rq < l || rq < lq)
return Node().v;
else if (lq <= l && r <= rq)
return tree[n].v;
int m = l + (r - l) / 2;
visit(n, l, m, r);
return std::max(getMax(tree[n].l, l, m, lq, rq),
getMax(tree[n].r, m + 1, r, lq, rq));
}
};
int main() {
int n, m;
scanf("%d %d", &n, &m);
std::map<int, int> relpoint;
std::vector<std::vector<std::pair<int, int>>> intervals(n + 1);
for (int x = 0, i, l, r; x < m; ++x) {
scanf("%d %d %d", &i, &l, &r);
intervals[i].push_back({l, r});
relpoint[l] = relpoint[r] = 0;
}
int points = 0;
for (auto &kv : relpoint) kv.second = ++points;
SegTree tree;
tree.tree.reserve(points * 3);
std::vector<int> bptr(n + 1, -1);
for (int row = 1; row <= n; ++row) {
auto &v = intervals[row];
std::sort(v.begin(), v.end());
std::vector<std::pair<int, int>> ranges;
for (int i = 0, j; i < v.size(); i = j) {
int l = v[i].first, r = v[i].second;
for (j = i + 1; j < v.size() && v[j].first <= r; ++j)
r = std::max(r, v[j].second);
ranges.push_back({relpoint[l], relpoint[r]});
}
std::pair<int, int> dp = {0, -1};
for (auto &lr : ranges)
dp = std::max(dp, tree.getMax(1, 1, points, lr.first, lr.second));
for (auto &lr : ranges) {
tree.setMax(1, 1, points, lr.first, lr.second, {dp.first + 1, row});
}
bptr[row] = dp.second;
}
auto ans = tree.getMax(1, 1, points, 1, points);
printf("%d\n", n - ans.first);
for (int i = ans.second, j; i != -1;) i = bptr[j = i], bptr[j] = 0;
for (int row = 1; row <= n; ++row)
if (bptr[row] != 0) printf("%d ", row);
if (ans.first != n) printf("\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 500;
vector<int> edge[maxn];
vector<int> ans;
int ansv[maxn];
void dfs(int u, int depth, int father) {
for (auto v : edge[u]) {
if (v == father) {
continue;
}
dfs(v, depth + 1, u);
ansv[u] += ansv[v];
}
ans.push_back(depth - ansv[u]);
++ansv[u];
}
int main() {
int N, K;
cin >> N >> K;
for (int i = 0; i < N - 1; ++i) {
int u, v;
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
dfs(1, 0, 0);
sort(ans.begin(), ans.end(), greater<int>());
long long sum = 0;
for (int i = 0; i < K; ++i) {
sum += ans[i];
}
cout << sum << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
long long n, k;
int main() {
scanf("%lld%lld", &n, &k);
int cnt10 = 0;
int cnt2 = 0;
int cnt5 = 0;
long long m = n;
while (1) {
if (m % 10 == 0) {
cnt10++;
m /= 10;
} else
break;
}
while (1) {
if (m % 5 == 0) {
cnt5++;
m /= 5;
} else
break;
}
while (1) {
if (m % 2 == 0) {
cnt2++;
m /= 2;
} else
break;
}
if (cnt10 >= k)
printf("%lld\n", n);
else {
if (cnt2 > cnt5) {
k -= cnt10;
if (k <= cnt2) {
for (int i = 1; i <= k; i++) n *= 5;
} else {
for (int i = 1; i <= cnt2; i++) n *= 5;
for (int i = 1; i <= k - cnt2; i++) n *= 10;
}
printf("%lld\n", n);
} else {
k -= cnt10;
if (k <= cnt5) {
for (int i = 1; i <= k; i++) n *= 2;
} else {
for (int i = 1; i <= cnt5; i++) n *= 2;
for (int i = 1; i <= k - cnt5; i++) n *= 10;
}
printf("%lld\n", n);
}
}
return 0;
}
| 1 |
#include<iostream>
using namespace std;
typedef long long ll;
int main(){
ll q1,b,c1,c2,q2;
cin >> q1;
while(q1!=0){
cin >> b >> c1 >> c2 >> q2;
ll x1=0,x2=0,m=min(c1,c2);
bool f=false;
//cout << b-min(c1,c2)*q1 << endl;
if(c1<=c2){
if(b<c1*q2+c2*(q1-q2)) f=true;
while(b>=c1*(x1+1)&&x1<q2) x1++;
while(b>=c1*x1+c2*(x2+1)) x2++;
if(x1==0) f=true;
if(f) cout << "NA" << endl;
else cout << x1 << " " << x2 << endl;
cin >> q1;
}else{
if(b<m*q1) f=true;
ll s=c1-c2,sum=0;
sum=q1*m;
while(b-sum>=s*(x1+1)&&x1<q1&&x1<q2) {
x1++;
//cout << b-sum<<":"<<s*x1<<endl;
//cout << x1<<":"<<c1*x1<<endl;
}
if(x1==q1)
while(b>=c1*(x1+1)&&x1 + 1<=q2) x1++;
//while(b>=c1*x1+c2*(x2+1)) x2++;
if(x1==0) f=true;
x2=0;
while(b>=c1*x1+c2*(x2+1)) x2++;
if(f) cout << "NA" << endl;
else cout << x1 << " " << x2 << endl;
//cout << c1*x1+c2*x2 << endl;
cin >> q1;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 50;
struct bian {
int x, y, v;
} side[N];
struct node {
int x, y, v;
node() {}
node(int xx, int yy, int vv) {
x = xx;
y = yy;
v = vv;
}
} out[N << 2];
vector<int> vec[N];
bool vis[N];
int b[3], cnt, co;
void dfs(int x) {
if (vec[x].size() == 1) {
b[cnt++] = x;
return;
}
vis[x] = 1;
int len = vec[x].size();
for (int i = 0; i < len; i++) {
int tx = vec[x][i];
if (vis[tx]) continue;
dfs(tx);
break;
}
vis[x] = 0;
return;
}
void fun(int k) {
int x = side[k].x;
int y = side[k].y;
int x1, x2, y1, y2;
if (vec[x].size() == 1)
x1 = x2 = x;
else {
cnt = 0;
vis[x] = 1;
int len = vec[x].size();
for (int i = 0; i < len; i++) {
int tx = vec[x][i];
if (tx == y) continue;
dfs(tx);
if (cnt >= 2) break;
}
vis[x] = 0;
x1 = b[0];
x2 = b[1];
}
if (vec[y].size() == 1)
y1 = y2 = y;
else {
cnt = 0;
vis[y] = 1;
int len = vec[y].size();
for (int i = 0; i < len; i++) {
int ty = vec[y][i];
if (ty == x) continue;
dfs(ty);
if (cnt >= 2) break;
}
vis[y] = 0;
y1 = b[0];
y2 = b[1];
}
int v = side[k].v >> 1;
out[co++] = node(x1, y1, v);
out[co++] = node(x2, y2, v);
if (x1 != x2) out[co++] = node(x1, x2, -v);
if (y1 != y2) out[co++] = node(y1, y2, -v);
return;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &side[i].x, &side[i].y, &side[i].v);
vec[side[i].x].push_back(side[i].y);
vec[side[i].y].push_back(side[i].x);
}
for (int i = 1; i <= n; i++)
if (vec[i].size() == 2) {
printf("NO\n");
return 0;
}
printf("YES\n");
for (int i = 1; i < n; i++) fun(i);
printf("%d\n", co);
for (int i = 0; i < co; i++)
printf("%d %d %d\n", out[i].x, out[i].y, out[i].v);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e3;
long long n, m, cnt, b, ans, used[N], a[N][N], nn;
vector<double> v, v1;
string s, s2, s1;
map<double, int> mp;
set<long long> st;
char c;
double xx, x, z, zz;
vector<pair<long long, string> > p;
int main() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> c >> x >> c >> z >> c >> c >> zz;
xx = (x + z) / zz;
mp[xx]++;
v.push_back(xx);
}
for (long long i = 0; i < v.size(); i++) {
cout << mp[v[i]] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N,K,arr[50],zero;
int main(){
cin >> N >> K;
for (int i=0;i<N;i++){
cin >> arr[i];
}
sort(arr,arr+N);
cout << accumulate(arr+N-K,arr+N,zero);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int same[100100];
int tree[100100];
int m;
void add(int v) {
while (v <= m) {
tree[v]++;
v += (v & (v ^ (v - 1)));
}
}
int query(int v) {
int ret = 0;
while (v > 0) {
ret += tree[v];
v -= (v & (v ^ (v - 1)));
}
return ret;
}
int rev(int v) {
int ret = 0;
while (v) {
ret = ret * 10 + v % 10;
v /= 10;
}
return ret;
}
int gcd(int a, int b) {
if (a < b) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int beg, end, mid, n, i, j, k, x, w, top = 0;
pair<long long, int> ret = make_pair(100000000000LL, -1);
scanf("%d %d %d", &n, &m, &w);
end = m;
for (i = 1; i <= m; i++)
if (i == rev(i)) same[top++] = i;
for (i = 1; i <= n; i++) {
x = rev(i);
k = x / gcd(x, i);
if (x == i)
for (j = 0; j < top; j++) add(same[j]);
else
for (j = k; j <= m; j += k)
if (1LL * i * j == 1LL * x * rev(j)) add(j);
beg = 0;
while (beg < end) {
mid = (beg + end) / 2;
if (query(mid) < w)
beg = mid + 1;
else
end = mid;
}
if (query(beg) >= w) ret = min(ret, make_pair(1LL * i * beg, i));
}
if (ret.second == -1)
printf("-1\n");
else
printf("%d %d\n", ret.second, ret.first / ret.second);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
k--;
while (k--) {
long long N = n;
long long mx = -1, mi = 10;
while (N > 0) {
mx = max(mx, N % 10);
mi = min(mi, N % 10);
N /= 10;
}
n += (mi * mx);
if (mi == 0) break;
}
cout << n << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string input;
cin >> n;
cin >> input;
string output = "";
while (input.find("ogo") != -1) {
if (input.find("ogo") > 0) {
output += input.substr(0, input.find("ogo"));
input = input.substr(input.find("ogo"));
}
input = input.substr(input.find("ogo") + 3);
while (input.find("go") == 0) {
input = input.substr(2);
}
output += "***";
}
output += input;
cout << output;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int h;
cin >> h;
int a[h + 1];
for (int i = 0; i <= h; i++) {
cin >> a[i];
}
bool ok = true;
for (int i = 0; i < h; i++) {
if (a[i] > 1 && a[i + 1] > 1) {
ok = false;
break;
}
}
if (ok) {
cout << "perfect" << '\n';
} else {
cout << "ambiguous" << '\n';
cout << 0 << ' ';
int sum = 1;
for (int i = 1; i <= h; i++) {
for (int j = 0; j < a[i]; j++) {
cout << sum << ' ';
}
sum += a[i];
}
cout << '\n';
cout << 0 << ' ';
sum = 1;
for (int i = 1; i <= h; i++) {
for (int j = 0; j < a[i]; j++) {
cout << (!j && a[i - 1] > 1 && a[i] > 1 ? sum - 1 : sum) << ' ';
}
sum += a[i];
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 3, inf = 1e9 + 7;
int n, m, x, y, ans = inf;
int Arr[MAXN];
int psum[MAXN];
int dp[MAXN][MAXN][2];
int cnt[MAXN][2];
bool table[MAXN][MAXN];
int main() {
scanf("%d%d%d%d", &n, &m, &x, &y);
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
for (int j = 1; j <= m; j++) table[i][j] = (s[j - 1] == '#');
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) Arr[i] += table[j][i];
for (int i = 1; i <= m; i++) psum[i] = psum[i - 1] + Arr[i];
for (int i = 1; i <= m; i++) {
cnt[i][0] = cnt[i][1] = inf;
for (int j = x; j <= min(y, i); j++) {
dp[i][j][0] = psum[i] - psum[i - j] + cnt[i - j][1];
dp[i][j][1] = (j * n) - psum[i] + psum[i - j] + cnt[i - j][0];
cnt[i][0] = min(cnt[i][0], dp[i][j][0]);
cnt[i][1] = min(cnt[i][1], dp[i][j][1]);
}
}
for (int i = x; i <= min(y, m); i++)
ans = min({ans, dp[m][i][0], dp[m][i][1]});
printf("%d", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 100005;
vector<long long> cC[MAX_N];
bool finalCheck = false;
bool vis[MAX_N] = {0};
long long tV[MAX_N] = {0};
long long dC[MAX_N][2];
vector<long long> adj[MAX_N];
long long n, m;
void dfs(long long x, long long count, long long t) {
cC[count].push_back(x);
vis[x] = 1;
dC[count][t]++;
tV[x] = t;
for (int i = 0; i < adj[x].size(); i++)
if (!vis[adj[x][i]])
dfs(adj[x][i], count, 1 - t);
else if (tV[adj[x][i]] == tV[x]) {
finalCheck = true;
}
}
void process() {
long long count = 0, count_3 = 0;
;
for (int i = 1; i <= n; i++)
if (!vis[i]) {
count++;
dC[count][0] = dC[count][1] = 0;
dfs(i, count, 0);
count_3 += dC[count][0] * (dC[count][0] - 1) / 2 +
dC[count][1] * (dC[count][1] - 1) / 2;
}
if (finalCheck)
cout << "0 1" << endl;
else {
if (count_3 > 0)
cout << 1 << " " << count_3 << endl;
else
cout << 2 << " " << m * (n - 2) << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
if (m == 0) {
cout << 3 << " " << n * (n - 1) * (n - 2) / 6 << endl;
} else
process();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp[42][42][42][42];
int count_above[42][42];
int main() {
int n, m, q;
scanf("%d %d %d ", &n, &m, &q);
char a[n][m + 1];
for (int i = 0; i < n; i++) {
scanf(" %s ", a[i]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i - 1][j - 1] == '0') {
count_above[i][j] = 1;
count_above[i][j] += count_above[i - 1][j];
} else {
count_above[i][j] = 0;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = i; k <= n; k++) {
for (int l = j; l <= m; l++) {
if (k != i) dp[i][j][k][l] += dp[i][j][k - 1][l];
if (j != l) dp[i][j][k][l] += dp[i][j][k][l - 1];
if (k != i && j != l) dp[i][j][k][l] -= dp[i][j][k - 1][l - 1];
int mx = k - i + 1;
for (int t = l; t >= j; t--) {
mx = min(mx, count_above[k][t]);
dp[i][j][k][l] += mx;
}
}
}
}
}
for (int i = 0; i < q; i++) {
int p, j, k, l;
scanf("%d %d %d %d", &p, &j, &k, &l);
printf("%d\n", dp[p][j][k][l]);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n;
vector<int> p, m, pe;
cin >> n;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
if (temp == 1) {
p.push_back(i + 1);
} else if (temp == 2) {
m.push_back(i + 1);
} else
pe.push_back(i + 1);
}
int teams = min(min(p.size(), pe.size()), m.size());
cout << teams << endl;
for (int i = 0; i < teams; i++) {
cout << p[i] << " " << pe[i] << " " << m[i] << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[2010][2010], h[2010], n, m, cnt;
char s[2010];
string a[2010];
int calc(int l, int r) {
if (l == r) return n;
int md = min_element(h + l, h + r) - h, x = calc(l, md), y = calc(md + 1, r),
t = cnt++;
for (int i = 0; i < md - l + 2; i++)
for (int j = 0; j < r - md + 1; j++)
dp[t][i + j] = max(dp[t][i + j], h[md] * i * j + dp[x][i] + dp[y][j]);
return t;
}
int main() {
scanf("%d%d ", &n, &m);
for (int i = 0; i < n; i++) {
gets(s);
a[i] = s;
}
sort(a, a + n);
for (int i = 0; i < n - 1; i++) {
h[i] = min(a[i].size(), a[i + 1].size());
for (int j = 0; j < h[i]; j++)
if (a[i][j] != a[i + 1][j]) h[i] = j;
}
printf("%d\n", dp[calc(0, n - 1)][m]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 10;
long long t, n, k, b, ans, ans1;
vector<long long> sum;
vector<long long> v;
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> t;
while (t) {
ans = 0;
ans1 = 0;
v.clear();
sum.clear();
t--;
cin >> n >> k;
sum.push_back(0);
v.push_back(0);
for (long long a, i = 1; i <= n; i++) {
cin >> a;
v.push_back(a);
sum.push_back(sum[i - 1] + v[i]);
}
sum.push_back(1e17);
b = upper_bound(sum.begin(), sum.end(), k) - sum.begin() - 1;
ans = max(ans, b);
if (b == n) {
cout << 0 << endl;
} else {
long long b1 = b;
for (long long i = 0; i <= b1 + 1; i++) {
b = upper_bound(sum.begin(), sum.end(), k + v[i]) - sum.begin() - 1;
if (b > ans) {
ans1 = i;
ans = b;
}
}
cout << ans1 << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n;
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <typename T = int>
inline T readNxt() {
char c = nc();
T x = 0;
int f = 1;
for (; c > '9' || c < '0'; c = nc())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = nc())
;
x *= f;
return x;
}
int main() {
long long m, x;
cin >> n >> m;
while (m--) {
cin >> x;
while (1) {
if (x % 2) {
x++;
x /= 2;
break;
}
x += n - x / 2;
}
cout << x << "\n";
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
using namespace std;
void GG(){
puts("0"),exit(0);
}
const int N=1505,mod=998244353;
int a[2][N][N],c[N],pw[N*N],vi[N],n,m0,m1,sum;
vector<int> e[N];
char s[N];
void dfs(int u){
sum^=c[u],vi[u]=1;
for(auto v:e[u]) if(!vi[v]) dfs(v);
}
int solve(int m,int a[N][N]){
int res=0;
rep(i,1,m) rep(j,i+1,m) res+=!a[i][j];
if(m%2==0) return res;
rep(i,1,m) e[i].clear(),vi[i]=c[i]=0;
rep(i,1,m) rep(j,i+1,m)
if(a[i][j]==1) c[i]^=1,c[j]^=1;
else if(!a[i][j]) e[i].push_back(j),e[j].push_back(i);
rep(i,1,m) if(!vi[i]){
sum=0,res++,dfs(i);
if(sum) GG();
}
return res-m;
}
int main(){
scanf("%d",&n);
m0=(n+2)/2,m1=(n+1)/2;
rep(i,1,n-1){
scanf("%s",s+1);
rep(j,1,n-1){
if(s[j]=='?') continue;
int k=(i+j)&1,a=i,b=j,t=i+j-n;
if(a<b) swap(a,b);
if(t>0) a-=t,b-=t;
int aim=(s[j]=='x'?1:-1);
int u=(a-b)/2+1,v=(a+b)/2+1;
if(::a[k][u][v]){
if(::a[k][u][v]!=aim) GG();
continue;
}
::a[k][u][v]=aim;
}
}
pw[0]=1;
rep(i,1,n*n) pw[i]=pw[i-1]*2%mod;
cout<<pw[solve(m0,a[0])+solve(m1,a[1])]<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
int a[maxn], n, k;
int main() {
while (~scanf("%d%d", &n, &k)) {
int pos = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
long long ans = a[n] - a[1];
for (int i = n; i > 1; i--) {
a[i] -= a[i - 1];
}
sort(a + 2, a + n + 1);
k--;
for (int j = n; j > 1 && k; j--, k--) {
ans -= a[j];
}
printf("%I64d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#define dbug(x) cout<<#x<<"="<<x<<endl
using namespace std;
template <typename T> void read(T &t) {
t=0; char ch=getchar(); int f=1;
while ('0'>ch||ch>'9') { if (ch=='-') f=-1; ch=getchar(); }
do {(t*=10)+=ch-'0';ch=getchar();} while ('0'<=ch&&ch<='9'); t*=f;
}
const int maxn=2010;
int n,a[maxn],vis[maxn],tot,in[maxn];
priority_queue<int> q1; // big
queue<int> q2;
vector<int> g[maxn],h[maxn],ans;
int gcd(int x,int y) {
if (!x||!y) return x+y;
return gcd(y,x%y);
}
void dfs(int u) {
vis[u]=1;
for (int i=0,v;i<g[u].size();i++) {
v=g[u][i];
if (vis[v]) continue;
h[u].push_back(v);
in[v]++; dfs(v);
}
}
int main() {
//freopen("1.txt","r",stdin);
read(n); int u,v;
for (int i=1;i<=n;i++) read(a[i]);
sort(a+1,a+n+1);
for (int i=1;i<=n;i++)
for (int j=i+1;j<=n;j++)
if (gcd(a[i],a[j])>1)
g[i].push_back(j),g[j].push_back(i);
for (int i=1;i<=n;i++)
if (!vis[i]) dfs(i);
for (int i=1;i<=n;i++)
if (in[i]==0) q1.push(i);
while (!q1.empty()) {
u=q1.top(); q1.pop(); ans.push_back(u);
for (int j=0;j<h[u].size();j++) {
v=h[u][j]; in[v]--;
if (in[v]==0) q1.push(v);
}
}
for (int i=1;i<=n;i++) printf("%d ",a[ans[i-1]]); printf("\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int ans = 0, l;
size_t i = 0;
while (i < n) {
for (; i < n; i++) {
cin >> l;
if (l == 1) {
ans++;
i++;
break;
}
if (i == n - 1 && l == 0 && ans > 0) ans--;
}
for (; i < n; i++) {
cin >> l;
ans++;
if (l == 0) {
i++;
if (i >= n) ans--;
break;
}
}
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
printf("%.0f", ceil((a - b) * c / (double)b));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string g[160];
int b[160], e[160];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> g[i];
int y = 0;
for (int i = 0; i < n; i++) {
b[i] = m;
e[i] = -1;
for (int j = 0; j < m; j++) {
if (g[i][j] == 'W') {
b[i] = min(b[i], j);
y = i;
e[i] = max(e[i], j);
}
}
}
int x = 0, ans = 0;
for (int i = 0; i < y; i++) {
if (i % 2 == 0) {
int k = max(e[i], e[i + 1]);
if (k > x) {
ans += (k - x + 1);
x = k;
} else
ans++;
} else {
int k = min(b[i], b[i + 1]);
if (k < x) {
ans += (x - k + 1);
x = k;
} else
ans++;
}
}
int c = (y) % 2;
if (c) {
if (b[y] < x) ans += (x - b[y]);
} else if (e[y] > x)
ans += (e[y] - x);
cout << ans << endl;
return 0;
}
| 2 |
#include <iostream>
using namespace std;
#define min(x,y) (x>y?y:x)
int main(){
int n;
cin>>n;
for(int i=0;i<n;i++){
int x,y,b,p,sum=0,ssum=0;
cin>>x>>y>>b>>p;
sum=x*b+y*p;
if(b>=5 && p>=2){sum*=4;sum/=5;cout<<sum<<endl;continue;}
else if(b<5){
ssum=(p<2?sum+x*(5-b)+y*(2-p):sum+x*(5-b));
ssum*=4;ssum/=5;
}else if(p<2){
ssum=sum+y*(2-p);
ssum*=4;ssum/=5;
}
cout<<min(sum,ssum)<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, m, n) for (int i = m; i < n; i++)
#define rep(i, n) REP(i, 0, n)
using ld = long double;
constexpr ld EPS = 1e-12;
// Ax^2 + Bx + C = 0 (0 < x < R)
ld solve(ld A, ld B, ld C, ld R)
{
if (fabs(A) < EPS)
{
if(fabs(B) < EPS)
return 1e18;
ld ans = -C / B;
if (ans > 0 and ans < R + EPS)
return ans;
else
return 1e18;
}
ld D = B * B - 4.0 * A * C;
if (D < 0)
return 1e18;
ld ans1;
if (B > 0)
ans1 = (-B - sqrtl(D)) / 2.0 / A;
else
ans1 = (-B + sqrtl(D)) / 2.0 / A;
ld ans2 = C / (A * ans1);
if (ans1 > ans2)
swap(ans1, ans2);
if (ans1 > 0 and ans1 < R + EPS)
return ans1;
else if (ans2 > 0 and ans2 < R + EPS)
return ans2;
else
return 1e18;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(30) << setiosflags(ios::fixed);
while (1)
{
int n;
cin >> n;
if (n == 0)
break;
vector<ld> px(n), py(n), pz(n), vx(n), vy(n), vz(n), r(n), vr(n);
rep(i, n) cin >> px[i] >> py[i] >> pz[i] >> vx[i] >> vy[i] >> vz[i] >> r[i] >> vr[i];
vector<ld> disapp(n), ans(n);
vector<pair<ld, pair<int, int>>> v;
rep(i, n)
{
ans[i] = disapp[i] = r[i] / vr[i];
}
rep(i, n) REP(j, i + 1, n)
{
ld A = 0.0, B = 0.0, C = 0.0; // 距離の2乗が At^2 + Bt + C
C += (px[i] - px[j]) * (px[i] - px[j]);
C += (py[i] - py[j]) * (py[i] - py[j]);
C += (pz[i] - pz[j]) * (pz[i] - pz[j]);
B += 2.0 * (px[i] - px[j]) * (vx[i] - vx[j]);
B += 2.0 * (py[i] - py[j]) * (vy[i] - vy[j]);
B += 2.0 * (pz[i] - pz[j]) * (vz[i] - vz[j]);
A += (vx[i] - vx[j]) * (vx[i] - vx[j]);
A += (vy[i] - vy[j]) * (vy[i] - vy[j]);
A += (vz[i] - vz[j]) * (vz[i] - vz[j]);
ld P, Q;
ld D, E, F; // 半径の和の2乗が Dt^2 + Et + F
P = r[i] + r[j];
Q = -(vr[i] + vr[j]);
F = P * P, E = 2.0 * P * Q, D = Q * Q;
ld t = solve(A - D, B - E, C - F, min(disapp[i], disapp[j]));
v.push_back({t, {i, j}});
}
sort(begin(v), end(v));
vector<bool> used(n, false);
for (auto pp : v)
{
ld t = pp.first;
int i = pp.second.first;
int j = pp.second.second;
if (used[i] || used[j])
continue;
ans[i] = min(ans[i], t);
ans[j] = min(ans[j], t);
used[i] = used[j] = true;
}
rep(i, n) cout << ans[i] << "\n";
}
return 0;
}
| 0 |
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
struct edge
{
int v,nxt;
}e[2000005];
int tt,n,m,deg[500005],vis[500005],h[500005],t,d[500005];
int ans1[500005],ans2[500005],at,a[500005],bt,b[500005];
vector<int> val[500005];
void add(int u,int v)
{
// printf("add:u=%d,v=%d\n",u,v);
e[++t].v=v;
e[t].nxt=h[u];
h[u]=t;
}
void dfs(int u,int fa,int dep)
{
vis[u]=1;
d[u]=dep;
for(int i=h[u];i;i=e[i].nxt)
{
int v=e[i].v;
if(v==fa) continue;
dfs(v,u,dep+1);
}
}
bool cmp(const int x,const int y)
{
return d[x]>d[y];
}
int main()
{
scanf("%d",&tt);
while(tt--)
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
deg[i]=vis[i]=h[i]=0,val[i].clear();
t=at=0;
for(int i=1;i<=m;i++)
{
int u,v;
scanf("%d%d",&u,&v);
val[u].push_back(v);
val[v].push_back(u);
}
for(int i=1;i<=n;i++)
{
if((int)val[i].size()==n-1)
{
at++;
ans1[i]=ans2[i]=at;
continue;
}
if(deg[i]) continue;
sort(val[i].begin(),val[i].end());
int nw=1,sz=val[i].size();
if(nw==i) nw++;
for(int j=0;j<sz;j++)
{
int v=val[i][j];
if(nw!=v) break;
nw++;
if(nw==i) nw++;
}
add(i,nw);
add(nw,i);
deg[nw]++,deg[i]++;
}
for(int i=1;i<=n;i++)
if(!vis[i])
{
dfs(i,0,1);
}
for(int i=1;i<=n;i++)
a[i]=i;
sort(a+1,a+n+1,cmp);
/* for(int i=1;i<=n;i++)
printf("%d ",deg[i]);
printf("\n");*/
for(int i=1;i<=n;i++)
{
int u=a[i];
bt=0;
for(int j=h[u];j;j=e[j].nxt)
{
int v=e[j].v;
if(deg[v]==1)
b[++bt]=v;
}
if(!bt) continue;
deg[u]=0;
for(int j=h[u];j;j=e[j].nxt)
{
int v=e[j].v;
deg[v]--;
}
/* printf("u=%d\n",u);
for(int j=1;j<=bt;j++)
printf("%d ",b[j]);
printf("\n");*/
for(int j=1;j<=bt;j++)
{
ans1[b[j]]=at+j;
ans2[b[j]]=at+j+1;
}
ans1[u]=at+bt+1;
ans2[u]=at+1;
at+=(bt+1);
}
for(int i=1;i<=n;i++)
printf("%d ",ans1[i]);
printf("\n");
for(int i=1;i<=n;i++)
printf("%d ",ans2[i]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int ld, lud, ru, rud, ok;
long long lv, rv;
int siz;
data() { ld = lud = ru = rud = ok = lv = rv = siz = 0; }
};
struct node {
data val;
int l, r;
long long tag;
} t[1500005];
using namespace std;
int val[300005];
data operator+(const data &a, const long long &b) {
data ans = a;
ans.lv += b, ans.rv += b;
return ans;
}
data operator+(const data &a, const data &b) {
data ans;
ans.lv = a.lv, ans.rv = b.rv;
ans.siz = a.siz + b.siz;
if (a.ld == a.siz && a.rv > b.lv)
ans.ld = a.ld + b.ld;
else
ans.ld = a.ld;
if (b.ru == b.siz && b.lv > a.rv)
ans.ru = b.ru + a.ru;
else
ans.ru = b.ru;
ans.lud = a.lud;
if (a.lud == a.siz && a.rv > b.lv) ans.lud = max(ans.lud, a.lud + b.ld);
if (a.ru == a.siz && a.rv < b.lv) ans.lud = max(ans.lud, a.ru + b.lud);
ans.rud = b.rud;
if (b.lud == b.siz && b.lv > a.rv) ans.rud = max(ans.rud, a.ru + b.lud);
if (b.ld == b.siz && b.lv < a.rv) ans.rud = max(ans.rud, a.rud + b.ld);
ans.ok = max(a.ok, b.ok);
ans.ok = max(ans.ok, max(ans.lud, ans.rud));
ans.ok = max(ans.ok, max(ans.ld, ans.ru));
if (a.rv < b.lv) ans.ok = max(ans.ok, a.ru + b.lud);
if (a.rv > b.lv) ans.ok = max(ans.ok, a.rud + b.ld);
return ans;
}
void build_tree(int now, int l, int r) {
t[now].l = l, t[now].r = r, t[now].val.siz = 1;
if (l == r) {
t[now].val.ld = t[now].val.lud = t[now].val.ru = t[now].val.ok =
t[now].val.rud = 1;
t[now].val.lv = t[now].val.rv = val[l];
return;
}
int ls = now << 1, rs = ls | 1, mid = (t[now].l + t[now].r) >> 1;
build_tree(ls, l, mid);
build_tree(rs, mid + 1, r);
t[now].val = t[ls].val + t[rs].val;
}
void tagdown(int now) {
if (t[now].tag == 0) return;
int ls = now << 1, rs = ls | 1;
t[ls].val = t[ls].val + t[now].tag;
t[rs].val = t[rs].val + t[now].tag;
t[ls].tag += t[now].tag, t[rs].tag += t[now].tag;
t[now].tag = 0;
}
void change(int now, int l, int r, long long val) {
if (t[now].l >= l && t[now].r <= r) {
t[now].val = t[now].val + val;
t[now].tag += val;
return;
}
tagdown(now);
int ls = now << 1, rs = ls | 1, mid = (t[now].l + t[now].r) >> 1;
if (l <= mid) change(ls, l, r, val);
if (r > mid) change(rs, l, r, val);
t[now].val = t[ls].val + t[rs].val;
}
int main() {
int n, m, l, r;
long long x;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &val[i]);
build_tree(1, 1, n);
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
scanf("%d %d %I64d", &l, &r, &x);
change(1, l, r, x);
printf("%d\n", t[1].val.ok);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 9223372036854775807LL;
long long power(long long a, long long b) {
if (b == 0) return 1;
if (b % 2)
return a * power(a, b / 2) * power(a, b / 2);
else
return power(a, b / 2) * power(a, b / 2);
}
template <typename ForwardIterator, typename T>
ForwardIterator first_less_than(ForwardIterator first, ForwardIterator last,
T val) {
auto it = lower_bound(first, last, val);
return (it == first ? last : --it);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, cl, ce, v;
cin >> n >> m >> cl >> ce >> v;
vector<long long> l(cl), e(ce);
for (long long &i : l) cin >> i;
for (long long &i : e) cin >> i;
long long q;
cin >> q;
while (q--) {
long long x1, x2, y1, y2, ans = inf;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
long long fe = -1, le = -1, fs = -1, ls = -1;
auto it1 = lower_bound(l.begin(), l.end(), y1);
if (it1 != l.end()) fs = *it1;
auto it2 = first_less_than(l.begin(), l.end(), y2);
if (it2 != l.end()) ls = *it2;
auto it3 = lower_bound(e.begin(), e.end(), y1);
if (it3 != e.end()) fe = *it3;
auto it4 = first_less_than(e.begin(), e.end(), y2);
if (it4 != e.end()) le = *it4;
if (fs != -1) ans = min(ans, abs(x2 - x1) + abs(y2 - fs) + abs(y1 - fs));
if (ls != -1) ans = min(ans, abs(x2 - x1) + abs(y2 - ls) + abs(y1 - ls));
if (fe != -1)
ans = min(ans, (abs(x2 - x1) + v - 1) / v + abs(y2 - fe) + abs(y1 - fe));
if (le != -1)
ans = min(ans, (abs(x2 - x1) + v - 1) / v + abs(y2 - le) + abs(y1 - le));
if (x1 != x2)
cout << ans << endl;
else
cout << abs(y2 - y1) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mat[128][128];
long long dp1[128][128];
long long dp2[128][128];
long long n, m;
long long mx, minDis;
long long f1(long long u, long long d) {
if (u == 1 && d == 0) return 1;
if (u == 1 || d < 0) return 0;
long long &ref = dp1[u][d];
if (ref != -1) return ref;
ref = 0;
for (long long j = 1; j <= n; j++)
if (mat[j][u] == 1) ref += f1(j, d - 1);
return ref;
}
long long f2(long long u, long long d) {
if (u == n && d == 0) return 1;
if (u == n || d < 0) return 0;
long long &ref = dp2[u][d];
if (ref != -1) return ref;
ref = 0;
for (long long j = 1; j <= n; j++)
if (mat[j][u] == 1) ref += f2(j, d - 1);
return ref;
}
int main() {
while (cin >> n >> m) {
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++) mat[i][j] = 100000000;
while (m--) {
long long x, y;
cin >> x >> y;
mat[x][y] = mat[y][x] = 1;
}
memset(dp1, -1, sizeof dp1);
memset(dp2, -1, sizeof dp2);
dp1[1][0] = 1;
dp2[n][0] = 1;
minDis = 100;
for (long long i = 1; i <= n; i++) {
long long tmp = f1(n, i);
if (tmp != 0) {
minDis = i;
break;
}
}
long long all = f2(1, minDis);
mx = all;
for (long long k = 1; k <= n; k++)
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++)
if (j != k && j != i && i != k)
mat[i][j] = min(mat[i][j], mat[i][k] + mat[k][j]);
for (long long i = 2; i < n; i++) {
if (mat[1][i] + mat[i][n] == mat[1][n]) {
long long tmp = dp1[i][mat[1][i]] * dp2[i][mat[i][n]] * 2;
mx = max(mx, tmp);
}
}
printf("%.10lf\n", mx * 1.0 / all);
}
return 0;
}
| 3 |
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<set>
#define int long long
#define N 100010
#define ll long long
using namespace std;
ll f[N],l[N],r[N];
int k;
struct ODT{
#define it set<node>::iterator
struct node{
int r;
mutable int v;
node(int R=0,int V=0):r(R),v(V){}
bool operator< (const node &a)const{return r<a.r;}
};
set<node>s;
it split(int v)
{
it u=s.lower_bound(node(v));
if(u->r==v) return u;
else return s.insert(node(v,u->v)).first;
}
void change(int l,int r,int v)
{
if(l>r) return;
it lt=split(l-1),rt=split(r);
rt->v=v;
++lt;
s.erase(lt,rt);
}
ll answer(int v)
{
it u=s.lower_bound(node(v));
if(u->v) return f[u->v]+(v-r[u->v]+k)%k;
else return 0;
}
}o;
ll num[N],b[N],ans=1000000000000000ll;
signed main()
{
int n;
scanf("%lld%lld",&n,&k);
o.s.insert(ODT::node(-1));
o.s.insert(ODT::node(k-1));
for(int i=1;i<=n;i++) scanf("%lld%lld",&num[i],&b[i]),num[i]+=num[i-1];
for(int i=1;i<=n;i++)
if(b[i]==1)
{
if(2*(num[i]-num[i-1])>k){puts("-1");return 0;}
l[i]=(-2*num[i-1]%k+k)%k;
r[i]=(-2*num[i]%k+k)%k;
f[i]=o.answer(r[i]);
if(l[i]>r[i]) o.change(r[i]+1,l[i]-1,i);
else
{
o.change(0,l[i]-1,i);
o.change(r[i]+1,k-1,i);
}
}
for(int i=1;i<=n;i++)
if(b[i]) ans=min(ans,o.answer(l[i]));
printf("%lld",ans+2*num[n]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
int a[1001], b[1001], c[1001], cnt[1001], yh[1001], n, m, num, mod, tot;
long long mi[1001], ans;
int main() {
scanf("%d%d", &n, &m);
if ((n ^ m) & 1) {
puts("0");
return 0;
}
scanf("%d", &num);
for (int i = 1; i <= num; i++) {
scanf("%d%d%d", &a[i], &b[i], &c[i]),
(c[i] == -1) ? (c[i] = 1) : (c[i] = 0);
if (n < m) std::swap(a[i], b[i]);
}
scanf("%d", &mod);
mi[0] = 1;
for (int i = 1; i <= m; i++) mi[i] = (mi[i - 1] * 2ll) % mod;
if (n < m) std::swap(n, m);
for (int i = 1; i <= num; i++) cnt[a[i]]++, yh[a[i]] ^= c[i];
for (int i = 1; i <= n; i++)
if ((cnt[i] == m) && (yh[i] == 0)) return 0 * puts("0");
tot = 0, ans = 1;
for (int i = 1; i <= n; i++) {
if (cnt[i] == 0) {
tot++;
if (tot > 1) ans = (ans * mi[m - 1]) % mod;
} else if (cnt[i] == m)
continue;
else
ans = (ans * mi[m - cnt[i] - 1]) % mod;
}
printf("%lld", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, x, y;
vector<int> p;
set<int> q[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(nullptr));
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
q[x].insert(y);
q[y].insert(x);
}
for (int i = 1; i <= n; i++) {
p.push_back(i);
}
for (int i = 1; i <= 150; i++) {
random_shuffle(p.begin(), p.end());
int cur = 0;
for (int i = 0; i < n; i++) {
if (q[p[i]].find(p[(i + 1) % n]) == q[p[i]].end()) {
cur++;
}
}
if (cur >= m) {
int k = 0;
for (int i = 0; i < n && k < m; i++) {
if (q[p[i]].find(p[(i + 1) % n]) == q[p[i]].end()) {
cout << p[i] << " " << p[(i + 1) % n] << "\n";
k++;
}
}
return 0;
}
}
cout << "-1";
}
| 3 |
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll mod = (1e+9)+7;
const ll INF = (ll)1000000007 * 1000000007;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef long double ld;
typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<ll, ll> LP;
typedef pair<ld, ld> LDP;
int main(){
int n, m, t, p;
while (cin >> n >> m >> t >> p, n) {
int pepar[32][32],cop[32][32];
rep(i, m) {
rep(j, n) {
pepar[i][j] = 1;
}
}
rep(i, t) {
rep(j, 32) {
rep(k, 32) {
cop[j][k] = 0;
}
}
int d, c; cin >> d >> c;
if (d == 1) {
Rep(j, c, n) {
rep(k, m) {
cop[k][j - c] += pepar[k][j];
}
}
per(j, c) {
rep(k, m) {
cop[k][c - j - 1] += pepar[k][j];
}
}
n = max(n-c,c);
}
else {
Rep(k, c, m) {
rep(j, n) {
cop[k - c][j] += pepar[k][j];
}
}
per(k, c) {
rep(j, n) {
cop[c - k - 1][j] += pepar[k][j];
}
}
m = max(m - c, c);
}
rep(j, m) {
rep(k, n) {
pepar[j][k] = cop[j][k];
}
}
}
rep(i, p) {
int x, y; cin >> y >> x;
cout << pepar[x][y] << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, f;
int main() {
cin >> a >> b >> c >> d >> e >> f;
if (a == d || b == e || c == f)
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 110;
int T, n, m;
char mp[MAX_N][MAX_N];
map<int, int> ext;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", mp[i] + 1);
int ans = 1e9;
bool sideFlag = false, cornerFlag = false, tmp = true, Aflag = false,
AatSide = false;
int siz = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (mp[i][j] == 'A') {
Aflag = true;
AatSide |= ((i == 1 || i == n) || (j == 1 || j == m));
siz++;
}
if (siz == n * m) ans = 0;
if (Aflag) ans = min(ans, 4);
if (AatSide) ans = min(ans, 3);
for (int i = 1; i <= n; i++) tmp &= mp[i][1] == 'A';
sideFlag |= tmp, tmp = true;
for (int i = 1; i <= n; i++) tmp &= mp[i][m] == 'A';
sideFlag |= tmp, tmp = true;
for (int i = 1; i <= m; i++) tmp &= mp[1][i] == 'A';
sideFlag |= tmp, tmp = true;
for (int i = 1; i <= m; i++) tmp &= mp[n][i] == 'A';
sideFlag |= tmp, tmp = true;
cornerFlag = ((mp[1][1] == 'A') || (mp[1][m] == 'A') || (mp[n][1] == 'A') ||
(mp[n][m] == 'A'));
if (sideFlag) ans = min(ans, 1);
if (cornerFlag) ans = min(ans, 2);
ext[0] = true;
for (int j = 1; j <= m; j++)
for (int i = 1; i <= n + 1; i++)
if (mp[i][j] != 'A') {
ext[i - 1] = 1;
if (j == 1 || j == m) ext[i - 1] = 2;
break;
}
for (int j = 1; j <= m; j++)
for (int i = n; i >= 0; i--)
if (mp[i][j] != 'A' && ext[i]) {
if (ext[i] == 2)
ans = min(ans, 2);
else
ans = min(ans, 3);
break;
} else if (mp[i][j] != 'A')
break;
ext.clear();
ext[0] = true;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m + 1; j++)
if (mp[i][j] != 'A') {
ext[j - 1] = 1;
if (i == 1 || i == n) ext[j - 1] = 2;
break;
}
for (int i = 1; i <= n; i++)
for (int j = m; j >= 0; j--)
if (mp[i][j] != 'A' && ext[j]) {
if (ext[j] == 2)
ans = min(ans, 2);
else
ans = min(ans, 3);
break;
} else if (mp[i][j] != 'A')
break;
ext.clear();
if (ans == 1e9)
printf("MORTAL\n");
else
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void ckmin(T &a, const T &b) {
a = min(a, b);
}
template <typename T>
void ckmax(T &a, const T &b) {
a = max(a, b);
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
void sieve(vector<int> &spf) {
int n = spf.size();
for (int i = (2); i < (n); i++) {
if (!spf[i]) {
;
for (int j = i; j < n; j += i) spf[j] = i;
}
}
}
long long int power(long long int x, long long int y,
long long int m = 998244353) {
long long int ans = 1;
x %= m;
while (y) {
if (y & 1) ans = (x * ans) % m;
x = (x * x) % m;
y >>= 1;
}
return ans;
}
long long int ncr(vector<int> &fact, int n, int r) {
return (n >= r) ? (fact[n] *
(power(fact[r], 998244353 - 2) *
power(fact[n - r], 998244353 - 2) % 998244353) %
998244353)
: 0;
}
void solve() {
int n;
cin >> n;
string s;
vector<pair<int, int> > arr(n + 1);
arr[0] = {0, 0};
for (int i = (0); i < (n); i++) cin >> arr[i + 1].first >> arr[i + 1].second;
sort((arr).begin(), (arr).end());
for (int i = (1); i < (n + 1); i++) {
int dx = arr[i].first - arr[i - 1].first,
dy = arr[i].second - arr[i - 1].second;
if (dx < 0 || dy < 0) {
cout << "NO\n";
return;
}
for (int i = (0); i < (dx); i++) s.push_back('R');
for (int i = (0); i < (dy); i++) s.push_back('U');
}
cout << "YES\n" << s << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int z = 1;
cin >> z;
while (z--) {
solve();
}
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main(){
int n;
cin >> n;
int a[n];
for(int i = 0; i < n; i++) cin >> a[i];
for(int i = 0; i < n; i++) {
int v = a[i];
int j = i-1;
while(j >= 0 && a[j] > v) {
a[j+1] = a[j];
j--;
}
a[j+1] = v;
for(int i = 0; i < n; i++) {
cout << a[i];
if(i != n-1) cout << " ";
}
cout << endl;
}
return 0;
}
| 0 |
#include <stack>
#include <cctype>
#include <string>
#include <cstring>
#include <iostream>
using namespace std;
string s; int n, p[300], v[300], w[300];
int main() {
while (cin >> s >> n, s != "0") {
string t = string({ s[0] });
for (int i = 1; i < s.size(); i++) {
if (isdigit(s[i - 1]) && isalpha(s[i])) t += "(" + string({ s[i] }) + ")";
else t += s[i];
}
for (int i = 0; i < 300; i++) p[i] = 0, v[i] = 0, w[i] = 0;
int pos1 = 0, w1 = 0; s = "";
for (int i = 0; i < t.size(); i++) {
if (isdigit(t[i])) w1 = 10 * w1 + t[i] - 48;
else {
if (t[i] == '(') v[pos1] = w[pos1] = w1, w1 = 0;
s += t[i]; pos1++;
}
}
stack<int> st;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(') st.push(i);
if (s[i] == ')') p[i] = st.top(), p[st.top()] = i, st.pop();
}
int pos = 0;
for (int i = 0; i <= n; i++) {
while (pos < s.size()) {
if (s[pos] == '(') {
if (w[pos]) w[pos]--, pos++;
else w[pos] = v[pos], pos = p[pos] + 1;
}
else if (s[pos] == ')') pos = p[pos];
else {
if(i != n) pos++; break;
}
}
}
cout << (pos < s.size() ? s[pos] : '0') << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, u;
cin >> n >> u;
vector<long long> A(n);
for (long long i = 0; i < n; i++) cin >> A[i];
double final_answer = -9.00;
int flag = 0;
for (long long i = 0; i < n - 2; i++) {
long long temp = A[i] + u;
long long beg = i + 2;
long long end = n - 1;
long long ans = 0;
while (beg <= end) {
long long mid = (beg + end) / 2;
if (A[mid] <= temp) {
ans = max(mid, ans);
beg = mid + 1;
} else
end = mid - 1;
}
if (ans != 0) {
flag = 1;
double num = (A[ans] - A[i + 1]) * 1.0;
double deno = (A[ans] - A[i]) * 1.0;
double answerwa = num / deno;
final_answer = max(answerwa, final_answer);
} else
continue;
}
if (flag == 1)
cout << fixed << setprecision(9) << final_answer << "\n";
else
cout << -1 << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int x; cin>>x;
if(x/100*5>=x%100) cout<<1<<endl;
else cout<<0<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL<<62
#define inf 1000000007
ll cnt[26];
int main() {
string s;
cin>>s;
ll i=0;ll j=s.size()-1;
ll ans=0;
while(i<j){
if(s[i]==s[j]){
i++;j--;
continue;
}
else if(s[i]=='x'){
i++;ans++;
continue;
}
else if(s[j]=='x'){
j--;ans++;
continue;
}
cout << -1;
return 0;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
string s;
int l, r;
char c1, c2;
cin >> n >> m >> s;
while (m--) {
cin >> l >> r >> c1 >> c2;
for_each(s.begin() + l - 1, s.begin() + r, [c1, c2](char &c) {
if (c == c1) c = c2;
});
}
cout << s << endl;
return 0;
}
| 1 |
#include <iostream>
using namespace std;
typedef long long ll;
ll a, b, c, d, e, f, g;
int main(void){
// Your code here!
cin >> a >> b >> c >> d >> e >> f >> g;
if (a == 0 || d == 0 || e == 0){
cout << a - (a % 2) + b + d - (d % 2) + e - (e % 2) << endl;
return 0;
}
cout << a + b + d + e - ((((a % 2) + (d % 2) + (e % 2) == 1) || ((a % 2) + (d % 2) + (e % 2) == 2)) ? 1 : 0) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<vector<char> > a(6, vector<char>(8));
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 8; j++) {
cin >> a[i][j];
if (a[i][j] == '.') {
if (i == 0 || i == 1) {
if (j == 0 || j == 1 || j == 6 || j == 7) {
a[i][j] = '3';
} else {
a[i][j] = '4';
}
} else if (i == 2 || i == 3) {
if (j == 0 || j == 1 || j == 6 || j == 7) {
a[i][j] = '2';
} else {
a[i][j] = '3';
}
} else {
if (j == 0 || j == 1 || j == 6 || j == 7) {
a[i][j] = '1';
} else {
a[i][j] = '2';
}
}
}
}
}
int i_max, j_max;
int max = 0;
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 8; j++) {
if (a[i][j] != '*' && a[i][j] != '-') {
if ((int)a[i][j] > max) {
max = (int)a[i][j];
i_max = i;
j_max = j;
}
a[i][j] = '.';
}
}
}
a[i_max][j_max] = 'P';
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 8; j++) {
cout << a[i][j];
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int w, h;
pair<int, int> uno, dos;
cin >> w >> h >> uno.first >> uno.second >> dos.first >> dos.second;
int ans = w;
while (h) {
ans += h;
if (h == uno.second) ans -= uno.first;
if (h == dos.second) ans -= dos.first;
ans = max(ans, 0);
h--;
}
cout << ans << '\n';
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector<long long> a(n), b(n);
for(int i = 0; i < n; ++i) cin >> a[i];
for(int i = 0; i < n; ++i) cin >> b[i];
long long cnt = 0;
for(int i = 0; i < n; ++i){
if(a[i] <= b[i]) cnt += (b[i] - a[i]) / 2;
else cnt -= (a[i] - b[i]);
}
cout << (cnt >= 0 ? "Yes" : "No" ) << endl;
}
| 0 |
#include <bits/stdc++.h>
#define LL long long
#define mp make_pair
#define pb push_back
#define VI vector<int>
#define pii pair<int,int>
using namespace std;
set<int> app[30];
const int MAXN = 5e5;
char S[MAXN+10];
int n, q;
char Q[2];
void q1(){
int p;
scanf("%d %s", &p, Q);
char v = Q[0];
p--;
app[S[p]-'a'].erase(p);
S[p] = v;
app[S[p]-'a'].insert(p);
}
int q2(){
int l, r;
scanf("%d %d", &l, &r); l--; r--;
int tot = 0;
for(int i = 0; i < 26; i++){
auto lb = app[i].lower_bound(l);
if(lb != app[i].end() && *lb <= r) tot++;
}
return tot;
}
int main(){
scanf("%d %s %d", &n, S, &q);
for(int i = 0; i < n; i++){
app[S[i]-'a'].insert(i);
}
for(int i = 0; i < q; i++){
int qi;
scanf("%d", &qi);
if(qi == 1) q1();
else printf("%d\n", q2());
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, LOG = 70;
int n, power[LOG], between[LOG], extra[LOG], ende[LOG];
bool check(int x) {
int cur = x;
for (int i = 0; i < LOG; i++) {
extra[i] = power[i] - cur;
int newCur = min(cur, power[i + 1]);
ende[i] = cur - newCur;
cur = newCur;
}
int res = 0;
for (int i = LOG - 1; i >= 0; i--) {
res += ende[i];
res -= between[i];
res -= extra[i + 1];
if (res < 0) return false;
}
return res - extra[0] >= 0;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
long long x;
scanf("%lld", &x);
int cur = 0;
bool good = true;
while (x > 1) {
if (x & 1) good = false;
x >>= 1;
cur++;
}
if (good)
power[cur]++;
else
between[cur]++;
}
int l = 1, r = power[0];
while (l <= r) {
int m = (l + r) >> 1;
if (check(m))
r = m - 1;
else
l = m + 1;
}
if (l <= power[0]) {
for (int i = l; i <= power[0]; i++) printf("%d ", i);
} else {
printf("-1\n");
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
const int mod=924844033;
const int N=2010;
int sz,dp[N],f[2][N][2][2],T,jc[N];
typedef long long ll;
inline void reduce(int&x){x+=x>>31&mod;}
void init(){
jc[0]=1;
for(int i=1;i<N;++i)jc[i]=(ll)jc[i-1]*i%mod;
}
int last_n=-1;
void calc(int n){
if(n!=last_n){
memset(f,0,sizeof f);
f[0][0][1][0]=1;T=0;
for(int i=1;i<=n;++i){
T^=1;memset(f[T],0,sizeof f[T]);
for(int j=0;j<i;++j)
for(int k=0;k<2;++k)
for(int l=0;l<2;++l)if(f[!T][j][k][l]){
int v=f[!T][j][k][l];
reduce(f[T][j][l][0]+=v-mod);
reduce(f[T][j+1][l][1]+=v-mod);
if(!k)reduce(f[T][j+1][l][0]+=v-mod);
}
}
last_n=n;
}
for(int i=sz+n;i>=0;--i){
int v=0;
for(int j=0;j<=i&&j<=n;++j)
v=(v+(ll)dp[i-j]*(f[T][j][0][0]+f[T][j][1][0]))%mod;
dp[i]=v;
}
sz+=n;
}
int main(){
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int n,K;cin>>n>>K;init();
dp[0]=1;sz=0;
for(int i=1;i<=K;++i)calc((n-i)/K+1);
int ans=0;
for(int i=0;i<=n;++i){
int v=(ll)dp[i]*jc[n-i]%mod;
if(i&1)reduce(ans-=v);
else reduce(ans+=v-mod);
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 100100;
char s[N];
int n;
int main() {
scanf("%d %s", &n, s);
int bal = 0;
for (int i = 0; i < n - 10; i++) {
if (s[i] == '8')
bal++;
else
bal--;
}
if (bal > 0)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class bign {
public:
int d[30];
int deg;
};
int a[1000005], n;
long long f[1000005];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int vt = 1;
memset(f, 0, sizeof(f));
f[2] = abs(a[1] - a[2]);
for (int i = 3; i <= n; i++) {
if ((a[i - 2] <= a[i - 1] && a[i - 1] >= a[i]) ||
(a[i - 2] >= a[i - 1] && a[i - 1] <= a[i]))
vt = i - 1;
f[i] = max(f[vt - 1] + abs(a[i] - a[vt]), f[vt] + abs(a[i] - a[vt + 1]));
}
long long res = -1;
for (int i = 1; i <= n; i++) res = max(res, f[i]);
cout << res;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long K, statc;
default_random_engine e;
int qc;
bool query(long long l, long long r) {
qc++;
assert(qc <= 4499);
cout << l << " " << r << '\n';
fflush(stdout);
string ans;
cin >> ans;
if (l == r && ans[0] == 'Y') {
exit(0);
}
if (ans[0] == 'B') {
exit(0);
}
return ans[0] == 'Y';
}
long long randrange(long long l, long long r) {
long long mod = r - l + 1;
return l + e() % mod;
}
long long extl(long long x) { return max(1LL, x - K); }
long long extr(long long x) { return min(statc, x + K); }
int main() {
srand(time(NULL));
ios::sync_with_stdio(false);
cin >> statc >> K;
long long l = 1, r = statc;
while (true) {
long long w = r - l + 1;
if (w <= 7 * K) {
long long guess = randrange(l, r);
query(guess, guess);
} else {
long long mid = (l + r) / 2;
if (query(l, mid)) {
r = mid;
} else {
l = mid + 1;
}
}
l = extl(l);
r = extr(r);
}
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.