solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, c, i, j, k, p, l, m, n;
long long int l1, l2, r1, r2;
cin >> a >> b;
long long int info[b][3];
bool check = true;
for (i = 0; i < b; i++) {
cin >> info[i][0] >> info[i][1] >> info[i][2];
}
long long int verify[a];
for (i = 0; i < a; i++) verify[i] = false;
for (i = 0; i < b; i++) {
if (info[i][0] == 1) {
for (j = 0; j < b; j++) {
if (info[j][0] == 1 && j != i) {
l1 = info[i][1];
r1 = info[i][2];
l2 = info[j][1];
r2 = info[j][2];
if (l1 < l2 && r1 >= l2 && r1 <= r2) {
info[j][1] = l1;
info[i][2] = r2;
} else if (l1 >= l2 && l1 <= r2 && r1 <= r2) {
info[i][1] = l2;
info[i][2] = r2;
}
}
}
}
}
for (i = 0; i < b; i++) {
if (info[i][0] == 0) {
for (j = 0; j < b; j++) {
if (info[j][0] == 1) {
l1 = info[i][1];
r1 = info[i][2];
l2 = info[j][1];
r2 = info[j][2];
if (l1 >= l2 && r1 <= r2) {
check = false;
break;
}
}
}
}
}
if (!check) {
cout << "NO"
<< "\n";
} else {
cout << "YES" << '\n';
long long int final[a];
for (i = 0; i < b; i++) {
if (info[i][0] == 1) {
k = a - info[i][1] + 1;
for (j = info[i][1] - 1; j < info[i][2]; j++) {
verify[j] = k;
final[j] = k;
}
}
}
long long int count = 0;
j = a;
for (i = 0; i < a; i++, j--) {
if (verify[i] == 0) {
final[i] = j;
count++;
}
cout << final[i] << ' ';
}
cout << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool isSorted(vector<int> &a, int l, int r) {
for (int i = l + 1; i <= r; i++) {
if (a[i - 1] > a[i]) {
return false;
}
}
return true;
}
int solve(vector<int> &a, int l, int r) {
if (l == r) {
return 1;
}
int mid = (l + r) / 2;
int ret = max(solve(a, l, mid), solve(a, mid + 1, r));
if (isSorted(a, l, r)) {
ret = max(ret, r - l + 1);
}
return ret;
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cout << solve(a, 0, n - 1) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2000000000000000123LL;
const int Q = 1 << 20;
long long laz[Q << 1];
int to[Q];
long long cc, plaz = 0;
struct lent {
long long x, y;
void R() { scanf("%lld%lld", &x, &y); }
void Big() { x = y = inf; }
} p1[Q], p2[Q];
long long uni[Q];
int tpp;
long long len[Q];
int rty[Q];
long long L = 0, R = 0;
int tim = 0;
long long mx1[Q << 1], mx2[Q << 1];
void Deal(long long nl, long long nr, int ty) {
nl = nr - nl;
len[++tim] = nl;
rty[tim] = ty;
if (ty == 1) {
L -= nl;
uni[++tpp] = L;
plaz += nl;
} else if (ty == 2) {
R += nl;
uni[++tpp] = R;
plaz -= nl;
} else {
uni[++tpp] = -cc - plaz;
if (uni[tpp] < L || uni[tpp] > R) --tpp;
uni[++tpp] = cc - plaz;
if (uni[tpp] < L || uni[tpp] > R) --tpp;
}
}
void Upd(int now) {
mx1[now] = max(mx1[(now << 1)], mx1[(now << 1 | 1)]);
mx2[now] = max(mx2[(now << 1)], mx2[(now << 1 | 1)]);
}
void Init(int now, int l, int r) {
if (l == r) {
to[l] = now;
mx1[now] = 0, mx2[now] = -uni[l];
return;
}
Init((now << 1), l, ((l + r) >> 1)),
Init((now << 1 | 1), ((l + r) >> 1) + 1, r);
Upd(now);
}
void PDD(int now, long long v) { laz[now] += v, mx1[now] += v, mx2[now] += v; }
void Pd(int now) {
if (laz[now])
PDD((now << 1), laz[now]), PDD((now << 1 | 1), laz[now]), laz[now] = 0;
}
void MDF(int now, int l, int r, int x, int y, long long del) {
if (x <= l && y >= r) {
mx1[now] += del, mx2[now] += del;
laz[now] += del;
return;
}
Pd(now);
if (x <= ((l + r) >> 1)) MDF((now << 1), l, ((l + r) >> 1), x, y, del);
if (y > ((l + r) >> 1)) MDF((now << 1 | 1), ((l + r) >> 1) + 1, r, x, y, del);
Upd(now);
}
long long ex1, ex2;
void GS(int now, int l, int r, int x, int y) {
if (x <= l && y >= r) {
ex1 = max(ex1, mx1[now]), ex2 = max(ex2, mx2[now]);
return;
}
Pd(now);
if (x <= ((l + r) >> 1)) GS((now << 1), l, ((l + r) >> 1), x, y);
if (y > ((l + r) >> 1)) GS((now << 1 | 1), ((l + r) >> 1) + 1, r, x, y);
}
void Alpd(int now) {
if (!now) return;
Alpd(now >> 1);
Pd(now);
}
void Update(int now) {
if (!now) return;
Upd(now), Update(now >> 1);
}
int maxn;
long long GV(int pp) {
ex1 = -inf;
GS(1, 1, maxn, 1, pp);
long long rel = ex1;
ex2 = -inf;
if (pp < maxn) GS(1, 1, maxn, pp + 1, maxn);
rel = max(rel, ex2 + uni[pp]);
return rel;
}
void Back(int pp) {
int now = to[pp];
Alpd(now >> 1);
mx1[now] = GV(pp);
mx2[now] = mx1[now] - uni[pp];
Update(now >> 1);
}
int main() {
int n, m;
scanf("%d%d%lld", &n, &m, &cc);
for (int i = 1; i <= n; i++) p1[i].R();
p1[n + 1].Big();
for (int i = 1; i <= m; i++) p2[i].R();
p2[m + 1].Big();
for (int na = 1, nb = 1; na <= n || nb <= m;) {
if (p1[na].y < p2[nb].x) {
Deal(p1[na].x, p1[na].y, 1);
++na;
} else if (p2[nb].y < p1[na].x) {
Deal(p2[nb].x, p2[nb].y, 2);
++nb;
} else {
if (p1[na].x == p2[nb].x) {
long long en = min(p1[na].y, p2[nb].y);
Deal(p1[na].x, en, 3);
p1[na].x = p2[nb].x = en;
if (p1[na].x == p1[na].y) ++na;
if (p2[nb].x == p2[nb].y) ++nb;
} else if (p1[na].x < p2[nb].x) {
Deal(p1[na].x, p2[nb].x, 1);
p1[na].x = p2[nb].x;
} else {
Deal(p2[nb].x, p1[na].x, 2);
p2[nb].x = p1[na].x;
}
}
}
L = R = 0;
plaz = 0;
uni[++tpp] = 0;
sort(uni + 1, uni + tpp + 1);
maxn = unique(uni + 1, uni + tpp + 1) - uni - 1;
Init(1, 1, maxn);
for (int pn = 1; pn <= tim; pn++) {
long long nl = len[pn];
int ty = rty[pn];
if (ty == 1) {
MDF(1, 1, maxn, (lower_bound(uni + 1, uni + maxn + 1, L) - uni),
(lower_bound(uni + 1, uni + maxn + 1, R) - uni), nl);
L -= nl;
plaz += nl;
Back((lower_bound(uni + 1, uni + maxn + 1, L) - uni));
} else if (ty == 2) {
R += nl;
plaz -= nl;
Back((lower_bound(uni + 1, uni + maxn + 1, R) - uni));
} else {
long long pl = max(L, -cc - plaz), pr = min(R, cc - plaz);
pl = (lower_bound(uni + 1, uni + maxn + 1, pl) - uni),
pr = (lower_bound(uni + 1, uni + maxn + 1, pr) - uni);
long long pt = GV(pl), ppt = GV(pr);
Back(pl), Back(pr);
MDF(1, 1, maxn, (lower_bound(uni + 1, uni + maxn + 1, L) - uni),
(lower_bound(uni + 1, uni + maxn + 1, R) - uni), nl);
MDF(1, 1, maxn, pl, pr, nl);
}
}
printf("%lld", GV(maxn));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 600010;
struct point {
int x, y;
point() {}
point(int x, int y) : x(x), y(y) {}
bool operator<(const point &r) const {
if (x != r.x)
return x < r.x;
else
return y < r.y;
}
};
struct ASK {
int l, r, id;
} q[N];
int n, m, cnt = 0;
int sum[N], b[N], ans[N], pre[N], ts[N], t[N];
vector<point> a[N];
map<point, int> ma;
inline int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
inline void add(int x, int y) {
if (x == 0) return;
for (; x <= sum[n]; x += (x & (-x))) t[x] += y;
return;
}
inline int find(int x) {
int u = 0;
for (; x; x -= (x & (-x))) u += t[x];
return u;
}
inline bool cmp(ASK x, ASK y) { return x.r < y.r; }
int main() {
scanf("%d", &n);
for (int k = 1; k <= n; k++) {
int x;
scanf("%d", &x);
sum[k] = sum[k - 1] + x;
for (int i = 1; i <= x; i++) {
int u, v;
scanf("%d%d", &u, &v);
a[k].push_back(point(u, v));
}
a[k].push_back(a[k][0]);
for (int i = 0; i < a[k].size() - 1; i++) {
point u = point(a[k][i].x - a[k][i + 1].x, a[k][i].y - a[k][i + 1].y);
int v = gcd(abs(u.x), abs(u.y));
u.x /= v, u.y /= v;
if (ma.count(u))
b[sum[k - 1] + i + 1] = ma[u];
else
ma[u] = b[sum[k - 1] + i + 1] = ++cnt;
}
}
scanf("%d", &m);
for (int k = 1; k <= m; k++) {
scanf("%d%d", &q[k].l, &q[k].r);
q[k].l = sum[q[k].l - 1];
q[k].r = sum[q[k].r];
q[k].id = k;
}
sort(q + 1, q + 1 + m, cmp);
for (int k = 1; k <= sum[n]; k++) {
pre[k] = ts[b[k]];
ts[b[k]] = k;
}
int now = 1;
for (int k = 1; k <= sum[n]; k++) {
add(k, 1), add(pre[k], -1);
while (now <= m && q[now].r == k) {
ans[q[now].id] = find(q[now].r) - find(q[now].l);
now++;
}
}
for (int k = 1; k <= m; k++) printf("%d\n", ans[k]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long digit(long long n) {
long long ans = 0;
long long i = 0;
while (n > 0) {
long long tmp = n % 10;
if (tmp != 0) {
ans = ans + (tmp * pow(10, i));
i++;
}
n = n / 10;
}
return ans;
}
int main() {
char arr[8][8];
for (int i = 0; i < 8; i++) cin >> arr[i];
int w = 0, b = 0;
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) {
if (arr[i][j] >= 'A' && arr[i][j] < 'a' && arr[i][j] != '.') {
char c = arr[i][j];
if (c == 'Q') w += 9;
if (c == 'R') w += 5;
if (c == 'B' || c == 'N') w += 3;
if (c == 'P') w += 1;
} else if (arr[i][j] >= 'a' && arr[i][j] != '.') {
char c = arr[i][j];
if (c == 'q') b += 9;
if (c == 'r') b += 5;
if (c == 'b' || c == 'n') b += 3;
if (c == 'p') b += 1;
}
}
if (b > w)
cout << "Black";
else if (w > b)
cout << "White";
else
cout << "Draw";
}
| 1 |
#include <bits/stdc++.h>
inline long long MAX2(long long a, long long int b) {
return (a) > (b) ? (a) : (b);
}
inline long long MAX3(long long a, long long b, long long c) {
return (a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c));
}
inline long long MIN2(long long a, long long b) {
return (a) < (b) ? (a) : (b);
}
inline long long MIN3(long long a, long long b, long long c) {
return (a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c));
}
using namespace std;
int main() {
long long i, n, x;
long long a[100005];
cin >> n >> x;
long long sum = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (x == sum + n - 1)
cout << "YES";
else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100000;
int v[nmax + 2];
int main() {
int n, sol = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> v[i];
v[i] = min(v[i], v[i - 1] + 1);
}
for (int i = n; i >= 1; --i) {
v[i] = min(v[i], v[i + 1] + 1);
}
for (int i = 1; i <= n; ++i) {
sol = max(sol, v[i]);
}
cout << sol << "\n";
return 0;
}
| 4 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<string>
using namespace std;
#define rep(i,n) for(int i = 0 ; i < n ; i++)
int main(){
int n, k;
while(cin >> n >> k , n){
vector< string > vc(n);
for(int i = 0 ; i < n ; i++ ) cin >> vc[i];
set< string > ret;
if(k == 1){
rep(i,n) ret.insert(vc[i]);
}else if(k == 2){
rep(i,n) rep(j,n) if(i!=j) ret.insert(vc[i]+vc[j]);
}else if(k == 3){
rep(i,n) rep(j,n) if(i!=j) rep(k,n) if(i!=k&&j!=k) ret.insert(vc[i]+vc[j]+vc[k]);
}else if(k == 4){
rep(i,n) rep(j,n) if(i!=j) rep(k,n) if(i!=k&&j!=k) rep(l,n) if(i!=l&&j!=l&&k!=l) ret.insert(vc[i]+vc[j]+vc[k]+vc[l]);
}
cout << ret.size() << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int mxN = 100010;
vector<int> g[mxN];
int vis[mxN];
int h[mxN];
int mn[mxN], mnI[mxN];
bool f = false;
vector<int> res;
vector<int> at;
vector<int> st;
void dfs(int v) {
assert(!vis[v]);
vis[v] = 1;
mn[v] = h[v];
mnI[v] = v;
st.push_back(v);
for (auto u : g[v]) {
if (vis[u] == 1) {
if (!f) {
int cur = st.size() - 1;
while (u != st[cur]) {
res.push_back(st[cur--]);
}
assert(u == st[cur]);
res.push_back(u);
at.clear();
at.resize(res.size(), 0);
reverse(res.begin(), res.end());
f = true;
} else {
int lo = 0, hi = res.size() - 1, to = res.size();
while (lo <= hi) {
int md = (lo + hi) >> 1;
if (vis[res[md]] == 1)
lo = md + 1;
else
hi = md - 1, to = md;
}
while ((int)res.size() > to) {
at.pop_back();
res.pop_back();
}
lo = 0, hi = res.size() - 1, to = res.size();
while (lo <= hi) {
int md = (lo + hi) >> 1;
if (h[res[md]] < h[u])
lo = md + 1;
else
hi = md - 1, to = md;
}
if (!at.empty()) at[0]--;
if (to < (int)at.size()) at[to]++;
}
if (h[u] <= mn[v]) {
mn[v] = h[u];
mnI[v] = u;
}
} else if (vis[u] == 2) {
if (vis[mnI[u]] == 1) {
int lo = 0, hi = res.size() - 1, toa = res.size(), tob = res.size();
while (lo <= hi) {
int md = (lo + hi) >> 1;
if (vis[res[md]] == 1)
lo = md + 1;
else
hi = md - 1, toa = md;
}
lo = 0, hi = res.size() - 1;
while (lo <= hi) {
int md = (lo + hi) >> 1;
if (h[res[md]] < h[u])
lo = md + 1;
else
hi = md - 1, tob = md;
;
}
if (toa < (int)at.size()) at[toa]--;
if (tob < (int)at.size()) at[tob]++;
}
if (mn[u] <= mn[v]) {
mn[v] = mn[u];
mnI[v] = mnI[u];
}
} else {
h[u] = h[v] + 1;
dfs(u);
if (mn[u] <= mn[v]) {
mn[v] = mn[u];
mnI[v] = mnI[u];
}
}
}
st.pop_back();
vis[v] = 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N, M, u, v;
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> u >> v;
u--, v--;
g[u].push_back(v);
}
f = false;
for (int i = 0; i < N; i++)
if (!vis[i]) dfs(i);
u = -2;
int cur = 0;
for (int i = 0; i < (int)res.size(); i++) {
cur += at[i];
if (cur >= 0) u = res[i];
}
cout << u + 1 << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
const int mod = (int)1e9 + 7;
int n;
int dp[2][8][8][2];
string in[3];
int main() {
cin >> n;
for (int i = 0; i < (int)3; i++) cin >> in[i];
int cur = 0, next = 1;
dp[0][0][0][0] = 1;
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)3; j++) {
memset(dp[next], 0, sizeof(dp[next]));
for (int bit1 = 0; bit1 < (int)8; bit1++)
for (int bit2 = 0; bit2 < (int)8; bit2++)
for (int k = 0; k < (int)2; k++) {
int &now = dp[cur][bit1][bit2][k];
if (!now) continue;
int nk = k;
if (i < n - 1 && in[j][i + 1] == 'O' && (bit1 & bit2 & 1 << j))
nk = 1;
int nbit1 = bit1 & ~(1 << j);
int nbit2 = bit2 & ~(1 << j);
if (in[j][i] != '.' || (bit1 & 1 << j))
(dp[next][nbit1][nbit2][nk] += now) %= mod;
if (i < n - 1 && !(bit1 & 1 << j) && in[j][i] == '.' &&
in[j][i + 1] == '.') {
int nnk = nk || i && in[j][i - 1] == 'O';
(dp[next][bit1 | 1 << j][bit2 | 1 << j][nnk] += now) %= mod;
}
if (j < 2 && !(bit1 & 1 << j) && !(bit1 & 1 << j + 1) &&
in[j][i] == '.' && in[j + 1][i] == '.') {
if (j == 0 && in[j + 2][i] == 'O') nk = 1;
if (j == 1 && in[j - 1][i] == 'O') nk = 1;
(dp[next][nbit1 | 1 << j + 1][nbit2][nk] += now) %= mod;
}
}
swap(cur, next);
}
long long ans = 0;
for (int j = 0; j < (int)8; j++) ans += dp[cur][0][j][1];
cout << ans % mod << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
typedef long long ll;
typedef vector<ll> vl;
int main(){
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
cout << fixed << setprecision(10);
/*--------------------------------*/
ll q;cin>>q;
rep(i,q){
ll x,y;
cin>>x>>y;
if(x>y)swap(x,y);
ll ans=x-1;
long double k=sqrt(x*y-0.75)-x+0.5;
ll lk=k;
ans+=k+(x*y-1)/(x+k);
if(x==y)cout<<ans<<endl;
else cout<<ans-1<<endl;
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
long long a[n],b[n];
for(int i=0;i<n;i++){
cin>>a[i];
b[i]=a[i];
}
sort(b,b+n);
int cnt=0;
for(int i=0;i<n;i++){
int p=lower_bound(b,b+n,a[i])-b;
if(i%2!=p%2) cnt++;
}
cout<<cnt/2;
}
| 0 |
#include <cstdio>
using namespace std;
struct HIT
{
char number[128];
int yen;
};
char cmp(char str[], char hit[])
{
for (int i = 0; i < 8; i++){
if (str[i] != hit[i] && hit[i] != '*'){
return 0;
}
}
return 1;
}
int main()
{
int n, m;
HIT hit[128];
char str[128];
while (scanf("%d %d", &n, &m), n){
for (int i = 0; i < n; i++){
scanf("%s %d", hit[i].number, &hit[i].yen);
}
int sum = 0;
for (int i = 0; i < m; i++){
scanf("%s", str);
for (int j = 0; j < n; j++){
if (cmp(str, hit[j].number) == 1){
sum += hit[j].yen;
break;
}
}
}
printf("%d\n", sum);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long int a, b;
cin >> a >> b;
cout << fixed << setprecision(10);
long double ans, x, y;
x = a;
y = b;
if (x < y) {
cout << "-1";
return 0;
}
if (x == y) {
ans = x;
cout << ans;
} else {
long double a1 = x + y, a2 = x - y;
int k = a1 / y;
if (k % 2 == 1) k--;
long double kk = k;
ans = a1 / kk;
k = a2 / y;
if (k % 2 == 1) k--;
if (k != 0) {
double kk = k;
ans = min(ans, a2 / kk);
}
cout << ans;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=55, mod=1e9+7;
inline int add(int x,int y) {return (x+y>=mod) ? (x+y-mod) : (x+y);}
inline int mul(int x,int y) {return (LL)x*y%mod;}
inline void add1(int &x,int y) {x=add(x,y);}
int n,f[N][N],c[N][N];
int main() {
cin>>n;
f[1][0]=f[1][1]=1;
for(int i=0;i<=n;i++) c[i][0]=1;
for(int i=1;i<=n;i++)
for(int j=1;j<=i;j++)
c[i][j]=add(c[i-1][j-1],c[i-1][j]);
for(int i=1;i<n;i++)
for(int j=0;j<=i;j++) if(f[i][j])
for(int x=0;x+i<=n;++x)
for(int y=0;x+y+i<=n;++y) if((x+y) && (x+y>=j) && (!((x+y-j)&1)))
add1(f[i+x+y][abs((x+y-j)/2+j-x)],mul(f[i][j],mul(c[i+x+y][x+y],c[x+y][x])));
cout<<f[n][0]<<'\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
void solve() {
int n, d, m;
cin >> n >> d >> m;
while (m--) {
int x, y;
cin >> x >> y;
bool a = ((x + y - d) >= 0);
bool b = ((x + y - (2 * n) + d) <= 0);
bool c = ((x - y - d) <= 0);
bool e = ((x - y + d) >= 0);
bool f = (((a & b) & c) & e);
if (f)
printf("YES\n");
else
printf("NO\n");
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
string str;
cin >> str;
bool flag = false;
if (str[0] == '?' || str[str.length() - 1] == '?') flag = true;
for (int i = 0; i < str.length(); i++) {
if (i + 1 >= str.length()) continue;
string temp = str.substr(i, 2);
if (temp == "??") {
flag = true;
}
if (temp == "MM" || temp == "YY" || temp == "CC") {
cout << "No";
return 0;
}
if (i + 2 >= str.length()) continue;
temp = str.substr(i, 3);
if (temp == "M?M" || temp == "C?C" || temp == "Y?Y") {
flag = true;
}
}
if (flag) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| 1 |
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int t,n,a,b;
int main(){
cin>>t;
while(t--){
cin>>a>>b>>n;
if(n==1)cout<<"YES"<<endl;
else if(n>1e8)cout<<"NO"<<endl;
else{
int c = a * b;
int k=1;
if(n%2==1)n+=1;
while(c%2==0 ){k*=2;c/=2;}
if(n<=k)cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s[5] = {"Sheldon", "Leonard", "Penny", "Rajesh", "Howard"};
int i, n;
cin >> n;
for (i = 1; n > 5 * i; i *= 2) n -= 5 * i;
cout << s[(n - 1) / i] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool a[101][101];
int main() {
int n, k;
int m;
cin >> n >> k;
int xx = (k + 1) >> 1, yy = (k + 1) >> 1;
while (n--) {
cin >> m;
int x, y, min = INT32_MAX;
for (int i = 1; i <= k; ++i) {
for (int j = 1; j <= k - m + 1; ++j) {
bool flag = true;
int sum = 0;
for (int l = j; l < j + m; ++l) {
if (a[i][l]) {
flag = false;
break;
}
sum += abs(i - xx) + abs(l - yy);
}
if (flag && sum < min) min = sum, x = i, y = j;
}
}
if (min == INT32_MAX)
cout << -1 << endl;
else {
for (int j = y; j < y + m; ++j) a[x][j] = 1;
printf("%d %d %d\n", x, y, y + m - 1);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
char s[1011], ss[1011];
int id[1011], a[1011][1011], sz[1011];
int n, m, w[12], nw[1011], cw[1011];
int dp[1011], ndp[1011], pos[12], cnt[12], it[12];
vector<int> v[10];
int main() {
scanf("%s", s);
n = strlen(s);
reverse(s, s + n);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%s", ss);
sz[i] = strlen(ss);
reverse(ss, ss + sz[i]);
for (int j = 0; j < sz[i]; j++) a[i][j] = ss[j] - '0';
}
for (int i = 0; i < 10; i++) scanf("%d", &w[i]);
for (int i = 0; i < m; i++) {
for (int j = n; j < sz[i]; j++) nw[i] += w[a[i][j]];
a[i][n]++;
sz[i] = max(sz[i], n + 1);
for (int j = n; a[i][j] >= 10; j++) a[i][j] = 0, a[i][j + 1]++;
if (a[i][sz[i]]) sz[i]++;
for (int j = n; j < sz[i]; j++) cw[i] += w[a[i][j]];
}
for (int i = 0; i <= m; i++) id[i] = i;
for (int i = 1; i <= m; i++) dp[i] = -1;
for (int i = 0; i < n; i++) {
memset(ndp, -1, sizeof(ndp));
for (int i = 0; i < 10; i++) v[i].clear(), it[i] = 0, cnt[i] = 0;
for (int j = 0; j < m; j++) {
v[a[id[j]][i]].push_back(id[j]);
cnt[a[j][i]]++;
}
for (int i = 8; i >= 0; i--) pos[i] = pos[i + 1] + v[i + 1].size();
for (int t = 0; t <= m; t++) {
int j = id[t];
if (dp[t] >= 0) {
int mn = Imx;
for (int v = 0; v < 10; v++) {
if (s[i] != '?' && s[i] != '0' + v || i == n - 1 && v == 0) continue;
int cur = dp[t];
for (int k = 0; k < 10; k++) cur += cnt[k] * w[(k + v) % 10];
int nxt = pos[9 - v] + it[9 - v];
ndp[nxt] = max(ndp[nxt], cur);
}
}
cnt[a[j][i]]--;
cnt[(a[j][i] + 1) % 10]++;
it[a[j][i]]++;
}
swap(dp, ndp);
for (int j = 9; j >= 0; j--)
for (int t = 0; t < v[j].size(); t++) id[pos[j] + t] = v[j][t];
}
int sum = 0, ans = 0;
for (int i = 0; i < m; i++) sum += nw[i];
for (int i = 0; i <= m; i++) {
if (dp[i] != -1) ans = max(ans, dp[i] + sum);
sum += cw[id[i]] - nw[id[i]];
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> p(n + 1);
for (int i = 1; i <= n; i++) {
cin >> p[i];
}
vector<int> pal(256);
vector<int> used(256, 0);
vector<int> ost(256);
for (int i = 0; i <= 255; i++) {
pal[i] = i;
}
for (int i = 1; i <= n; i++) {
if (used[p[i]] == 0) {
int now = k;
int t;
for (t = p[i]; t >= 0 && p[i] - t + 1 <= k; t--) {
if (used[t]) {
break;
}
}
if (t < 0) {
t = 0;
for (int j = t; j <= p[i]; j++) {
used[j] = 1;
pal[j] = pal[t];
ost[j] = k - (p[i] - t + 1);
}
} else if (used[t]) {
if (ost[t] >= p[i] - t) {
int temp = ost[t];
for (int j = p[i]; j >= t; j--) {
pal[j] = pal[t];
used[j] = 1;
ost[j] = temp - p[i] + t;
}
} else {
for (int j = t + 1; j <= p[i]; j++) {
pal[j] = pal[t + 1];
used[j] = 1;
ost[j] = k - p[i] + t;
}
}
} else {
for (int j = t + 1; j <= p[i]; j++) {
pal[j] = pal[t + 1];
used[j] = 1;
ost[j] = 0;
}
}
}
}
for (int i = 1; i <= n; i++) {
cout << pal[p[i]] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, j, ans;
cin >> n;
int hash[367][2];
for (i = 0; i < 367; i++) {
hash[i][0] = 0;
hash[i][1] = 0;
}
for (j = 0; j < n; j++) {
char sex;
int start, end;
cin >> sex >> start >> end;
if (sex == 'F') {
for (i = start; i <= end; i++) hash[i][0] += 1;
} else {
for (i = start; i <= end; i++) hash[i][1] += 1;
}
}
ans = INT_MIN;
for (i = 0; i < 367; i++) {
long long int temp = (hash[i][0] <= hash[i][1]) ? hash[i][0] : hash[i][1];
if (temp > ans) ans = temp;
}
cout << ans * 2 << endl;
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main() {
int A,B,K;
cin >> A >> B >> K;
for(int i=A; i <= B; i++){
if( i < A+K || B-K < i )
cout << i << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, init, n) for (int i = init; i < (n); i++)
#define ALL(obj) (obj).begin(), (obj).end()
using namespace std;
using ll = long long int;
using P = pair<int, int>;
using T = tuple<int, int, int>;
using edge = struct
{
int to, cost;
};
const int MOD = 1e9 + 7;
const int iINF = 1e9;
const long long int llINF = 1e18;
const double PI = acos(-1.0);
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll dp[1010][1010];
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
string t, b;
cin >> t >> b;
dp[0][0] = 1;
REP(i, t.size())
{
REP(j, b.size() + 1)
{
dp[i + 1][j] = (dp[i + 1][j] + dp[i][j]) % MOD;
if(j != b.size() && t[i] == b[j])
{
dp[i + 1][j + 1] = (dp[i + 1][j + 1] + dp[i][j]) % MOD;
}
}
}
cout << (dp[t.size()][b.size()] % MOD) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int maxn = 1e6 + 10;
int n, m;
bool g[50][50];
void dfs(int p, int cur, int val, vector<int> &vec) {
if (p == 5) {
for (int i : vec) printf("%d ", i);
exit(0);
}
for (int i = cur; i <= n; i++) {
bool ok = 1;
for (int j = 0; j < p; j++) ok &= g[i][vec[j]] == val;
if (ok) vec[p] = i, dfs(p + 1, i + 1, val, vec);
}
}
int main() {
cin >> n >> m;
n = min(n, 48);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if (max(u, v) <= 48) g[u][v] = g[v][u] = 1;
}
vector<int> a(5);
dfs(0, 1, 0, a);
dfs(0, 1, 1, a);
puts("-1");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int n, m, a[1010][1010], ra[1010][1010], rb[1010][1010], ca[1010][1010],
cb[1010][1010], w[1010];
void Solve(int n, int *w, int *a, int *b) {
static int len, c[1010];
for (int i = 1; i <= n; ++i) {
c[i] = w[i];
}
sort(c + 1, c + n + 1);
len = unique(c + 1, c + n + 1) - c - 1;
for (int i = 1; i <= n; ++i) {
w[i] = lower_bound(c + 1, c + len + 1, w[i]) - c;
a[i] = w[i] - 1;
b[i] = len - w[i];
}
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
a[i][j] = read();
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
w[j] = a[i][j];
}
Solve(m, w, ra[i], rb[i]);
}
for (int j = 1; j <= m; ++j) {
for (int i = 1; i <= n; ++i) {
w[i] = a[i][j];
}
Solve(n, w, ca[j], cb[j]);
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
printf("%d ", max(ca[j][i], ra[i][j]) + max(cb[j][i], rb[i][j]) + 1);
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char a[500010];
int n, m;
void chang(int s) {
if (s == 0) {
a[s]++;
if (a[s] >= 'A' + m) a[s] = 'A';
while (a[s] == a[s + 1]) {
a[s]++;
if (a[s] >= 'A' + m) a[s] = 'A';
}
} else if (s == n - 1) {
a[s]++;
if (a[s] >= 'A' + m) a[s] = 'A';
while (a[s] == a[s - 1]) {
a[s]++;
if (a[s] >= 'A' + m) a[s] = 'A';
}
} else {
a[s]++;
if (a[s] >= 'A' + m) a[s] = 'A';
while (a[s] == a[s - 1] || a[s] == a[s + 1]) {
a[s]++;
if (a[s] >= 'A' + m) a[s] = 'A';
}
}
}
int main() {
while (~scanf("%d%d", &n, &m)) {
scanf("%s", a);
int ans = 0, ans1 = 0;
if (m == 2) {
int a1 = 0, a2 = 0, b1 = 0, b2 = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (a[i] == 'A')
a1++;
else
b1++;
} else {
if (a[i] == 'A')
a2++;
else
b2++;
}
}
if ((a2 + b1) > (a1 + b2)) {
printf("%d\n", a1 + b2);
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
printf("B");
else
printf("A");
}
printf("\n");
} else {
printf("%d\n", a2 + b1);
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
printf("A");
else
printf("B");
}
printf("\n");
}
continue;
}
for (int i = 1; i < n; i++) {
if (a[i] == a[i - 1] && a[i] != a[i + 1])
chang(i - 1), ans++;
else if (a[i] == a[i + 1] && a[i] != a[i - 1])
chang(i + 1), ans++;
else if (a[i] == a[i + 1] && a[i] == a[i - 1])
chang(i), ans++;
}
printf("%d\n%s\n", ans, a);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, s;
int main() {
scanf("%lld%lld%lld", &n, &k, &s);
if ((n - 1) * k < s) {
printf("NO\n");
return 0;
} else if (k > s) {
printf("NO\n");
return 0;
}
printf("YES\n");
long long sum = s;
int flag = 0;
long long now = 1;
long long x = n - 1;
while (k) {
if (sum - x < k - 1) {
break;
} else {
if (now == 1)
now = n;
else
now = 1;
sum -= x;
}
if (flag) {
printf(" %lld", now);
} else {
flag = 1;
printf("%lld", now);
}
k--;
}
if (sum != 0) {
if (now == 1) {
if ((sum - k + 1) != 0) {
printf(" %lld", now + (sum - k + 1));
now += sum - k + 1;
k--;
}
int p = 0;
while (k--) {
if (p == 0) {
printf(" %lld", ++now);
} else {
printf(" %lld", --now);
}
p = !p;
}
} else {
if ((sum - k + 1) != 0) {
printf(" %lld", now - (sum - k + 1));
now -= (sum - k + 1);
k--;
}
int p = 0;
while (k--) {
if (p == 0) {
printf(" %lld", --now);
} else {
printf(" %lld", ++now);
}
p = !p;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long A, B, c, d, E, F;
int read();
bool zc(long long fz, long long fm) { return !(fz % fm); }
bool ask(long long a, long long b, long long e, long long f) {
if (!e && !f) return a == c & b == d;
if (!e) return zc(c - a, f) & zc(d - b, f);
if (!f) return zc(c - a, e) & zc(d - b, e);
long long fx = e * (c - a) + f * (d - b);
long long fy = f * (c - a) + e * (b - d);
long long fm = e * e + f * f;
fx = fx < 0 ? -fx : fx;
fy = fy < 0 ? -fy : fy;
return zc(fx, fm) & zc(fy, fm);
}
int main() {
A = read(), B = read(), c = read();
d = read(), E = read(), F = read();
if (ask(A, B, E, F))
return puts("YES"), 0;
else if (ask(A, B, -F, E))
return puts("YES"), 0;
else if (ask(A, B, F, -E))
return puts("YES"), 0;
else if (ask(A, B, -E, -F))
return puts("YES"), 0;
else if (ask(-B, A, E, F))
return puts("YES"), 0;
else if (ask(-B, A, -F, E))
return puts("YES"), 0;
else if (ask(-B, A, F, -E))
return puts("YES"), 0;
else if (ask(-B, A, -E, -F))
return puts("YES"), 0;
else if (ask(B, -A, E, F))
return puts("YES"), 0;
else if (ask(B, -A, -F, E))
return puts("YES"), 0;
else if (ask(B, -A, F, -E))
return puts("YES"), 0;
else if (ask(B, -A, -E, -F))
return puts("YES"), 0;
else if (ask(-A, -B, E, F))
return puts("YES"), 0;
else if (ask(-A, -B, -F, E))
return puts("YES"), 0;
else if (ask(-A, -B, F, -E))
return puts("YES"), 0;
else if (ask(-A, -B, -E, -F))
return puts("YES"), 0;
else
puts("NO");
return 0;
}
int read() {
int x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') f = (c == '-') ? -1 : f, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
int ans = 0, x, f;
string q = "", w;
for (int i = 0; i < n; i++) {
if (i >= m - 1) {
f = 1;
for (int j = i - m + 1; j <= i; j++) {
if (s[j] != t[j - i + m - 1]) {
f = 0;
break;
}
}
if (f) {
ans++;
s[i] = '#';
}
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
const long long BIG = 1e18;
long long ans = BIG;
const int prime[10] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
vector<int> tmp;
long long mi(int x, int y) {
long long ret = 1ll;
for (int i = 0; i < y; i++) {
ret *= (long long)x;
if (ret >= BIG) return BIG;
}
return ret;
}
void solve(int par, int curn) {
if (curn == 1) {
long long a = 1ll;
for (int i = tmp.size() - 1; i >= 0; i--) {
if (tmp[i] > 1) a *= mi(prime[tmp.size() - 1 - i], tmp[i] - 1);
if (a >= ans || a < 0) {
return;
}
}
if (a < ans) ans = a;
return;
}
for (int i = par; i <= curn; i++) {
if (curn % i == 0) {
tmp.push_back(i);
solve(i, curn / i);
tmp.pop_back();
}
}
return;
}
int main() {
cin >> n;
solve(2, n);
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int T, A, B, C, D, k;
bool check(int x) {
int a = A - x, b = B - (x - 1) / k;
return b <= (long long)(a + 1) * k;
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d %d %d %d", &A, &B, &C, &D), k = ceil(1.0 * max(A, B) / (min(A, B) + 1));
int l = 0, r = A;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (check(mid)) l = mid; else r = mid - 1;
}
if (check(r)) l = r;
int a = A - l, b = B - (l - 1) / k;
l = l + (l - 1) / k, r = l + b - (long long)a * k + 1;
for (int i = C; i <= min(l, D); i++)
if (i % (k + 1) == 0) printf("B"); else printf("A");
for (int i = max(C, l + 1); i <= D; i++)
if ((i - r) % (k + 1) == 0) printf("A"); else printf("B");
puts("");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200 * 1000 + 10;
const int LGN = 20;
string s = "";
int cs;
int sz[MAXN];
int psz[MAXN];
int r[LGN][MAXN];
int who[MAXN];
int rmq[LGN][MAXN];
int lg[MAXN];
int suf[MAXN];
void calWho() {
int n = s.size();
for (int i = 1; i < MAXN; i++) psz[i] = psz[i - 1] + sz[i - 1] + 1;
for (int i = 0; i < n; i++) {
int x = suf[i];
int d = 0, u = cs;
while (d < u - 1) {
int mid = (d + u) / 2;
if (psz[mid] <= x)
d = mid;
else
u = mid;
}
who[i] = d;
}
}
int n;
int lcps(int a, int b) {
if (a == b) return n - a;
int ans = 0;
for (int i = LGN - 1; i >= 0; i--)
if (r[i][a] == r[i][b]) ans += (1 << i), a += (1 << i), b += (1 << i);
return ans;
}
int lcp(int a, int b) {
if (a == b) return n - suf[a];
if (a > b) swap(a, b);
int p = lg[b - a];
return min(rmq[p][a], rmq[p][b - (1 << p)]);
}
int suf_po;
bool cmp(int a, int b) {
if (r[suf_po][a] != r[suf_po][b]) return (r[suf_po][a] < r[suf_po][b]);
int x = a + (1 << suf_po) < n ? r[suf_po][a + (1 << suf_po)] : -1;
int y = b + (1 << suf_po) < n ? r[suf_po][b + (1 << suf_po)] : -1;
return x < y;
}
void calSuf() {
for (int i = 0; i < n; i++) r[0][i] = s[i];
for (int i = 0; i < n; i++) suf[i] = i;
for (int i = 1; i < LGN; i++) {
suf_po = i - 1;
sort(suf, suf + n, cmp);
for (int j = 0; j < n; j++)
r[i][suf[j]] = (j && !cmp(suf[j - 1], suf[j])) ? r[i][suf[j - 1]] : j + 1;
}
for (int i = 0; i < n - 1; i++) rmq[0][i] = lcps(suf[i], suf[i + 1]);
for (int i = 1; i < LGN; i++)
for (int j = 0; j + (1 << i) <= n - 1; j++)
rmq[i][j] = min(rmq[i - 1][j], rmq[i - 1][j + (1 << (i - 1))]);
}
int cnt[MAXN];
long long int fans[MAXN];
int tah[MAXN];
int bs(int x, int y) {
int d = -1, u = x;
while (d < u - 1) {
int mid = (d + u) / 2;
if (lcp(mid, x) >= y)
u = mid;
else
d = mid;
}
return u;
}
int main() {
{
for (int i = 2; i <= MAXN; i++) lg[i] = lg[i >> 1] + 1;
}
ios::sync_with_stdio(false);
int k;
cin >> n >> k;
cs = n;
for (int i = 0; i < n; i++) {
string st;
cin >> st;
sz[i] = st.size();
s += st;
if (i != n - 1) s += "$";
}
n = s.size();
calSuf();
calWho();
int ss = s.size();
{
int p1, p2 = 0;
int kk = 0;
memset(tah, -1, sizeof tah);
for (p1 = 0; p1 < ss; p1++) {
while (p2 < ss && kk < k) {
cnt[who[p2]]++;
if (cnt[who[p2]] == 1) kk++;
p2++;
}
if (kk < k) break;
tah[p1] = p2 - 1;
cnt[who[p1]]--;
if (!cnt[who[p1]]) kk--;
}
}
for (int i = 0; i < ss; i++) {
int ml = psz[who[i]];
int d = 0, u = sz[who[i]] - (suf[i] - ml) + 1;
while (d < u - 1) {
int mid = (d + u) / 2;
int boz = bs(i, mid);
if (tah[boz] != -1 && lcp(tah[boz], i) >= mid)
d = mid;
else
u = mid;
}
fans[who[i]] += d;
}
for (int i = 0; i < cs; i++) cout << fans[i] << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string a, l, r;
int ll[3000000], rr[3000000];
int kmp[3000000];
long long dp[2000002];
long long sums[2000002];
void build(string str, int arr[]) {
int n = (int)str.length();
for (int i = 1, L = 0, R = 0; i < n; ++i) {
if (i <= R) arr[i] = min(R - i + 1, arr[i - L]);
while (i + arr[i] < n && str[arr[i]] == str[i + arr[i]]) ++arr[i];
if (i + arr[i] - 1 > R) L = i, R = i + arr[i] - 1;
}
}
long long getVal(int index) {
int len = a.length();
if (len - index < l.length()) return 0;
int x, y;
if (a[index] == '0') {
if (l == "0") {
x = index;
y = index;
x++;
y++;
return ((sums[x] - (y <= len ? sums[y + 1] : 0)) + 998244353) % 998244353;
} else
return 0;
}
x = (index + l.length());
int val = ll[l.length() + 1 + index];
if (val < l.length() && a[index + val] < l[val]) x++;
y = index + r.length();
if (len - index < r.length())
y = len;
else {
val = rr[r.length() + 1 + index];
if (val < r.length() && a[index + val] > r[val]) y--;
}
if (x > y) return 0;
return ((sums[x] - (y < len ? sums[y + 1] : 0)) + 998244353) % 998244353;
}
int main() {
cin >> a >> l >> r;
build(l + "$" + a, ll);
build(r + "$" + a, rr);
sums[a.length()] = 1;
dp[a.length()] = 1;
for (int i = a.length() - 1; i >= 0; i--) {
dp[i] = getVal(i);
sums[i] = dp[i];
sums[i] = (sums[i] + sums[i + 1]) % 998244353;
}
cout << dp[0] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5+10;
pair<int,int> a[N];
int main() {
int n;
scanf("%d",&n);
for (int i=0;i<n;i++) {
int x;
scanf("%d",&x);
a[i] = {x,i};
}
sort(a,a+n);
int ans = 0;
for (int i=0;i<n;i++) if ((a[i].second^i)&1) ans++;
printf("%d\n",ans/2);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, l, m, n, d, res = 0, s;
cin >> k >> l >> m >> n >> d;
for (int i = 1; i <= d; ++i) {
if (i % k == 0 || i % l == 0 || i % m == 0 || i % n == 0) ++res;
}
cout << res << "\n";
return 0;
}
| 1 |
#include<iostream>
#include<map>
#include<algorithm>
using namespace std;
int main() {
int n;
cin >> n;
map<string, int> s;
string S;
for (int i = 0; i < n; i++) {
cin >> S;
s[S]++;
}
int m;
cin >> m;
string T;
for (int i = 0; i < m; i++) {
cin >> T;
s[T]--;
}
int mx = 0;
for (auto p : s) {
mx = max(p.second, mx);
}
cout << mx << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
long long f(int d) {
long long t, cnt, ans;
t = cnt = ans = 0;
for (int i = 0; i < a.size(); i++) {
cnt++;
ans += max(0LL, a[i] - t);
if (cnt == d) {
cnt = 0;
t++;
}
}
return ans;
}
int main() {
long long n, m;
cin >> n >> m;
a.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.rbegin(), a.rend());
if (f(n) < m) {
cout << -1;
return 0;
}
int l = 0, r = n;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (f(mid) < m) {
l = mid;
} else {
r = mid;
}
}
cout << r;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
map<vector<long long>, long long> memo;
vector<char> ops;
long long solve(int op, vector<long long> s) {
if (op == 3) return *(s.begin());
if (memo.count(s)) return memo[s];
long long ret = 1LL << 62;
int n = s.size();
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (i + 1); (j) < (n); ++(j)) {
auto s2 = s;
if (ops[op] == '+') {
long long sum = s[i] + s[j];
s2.erase(find(s2.begin(), s2.end(), s[i]));
s2.erase(find(s2.begin(), s2.end(), s[j]));
s2.push_back(sum);
} else {
long long prod = s[i] * s[j];
s2.erase(find(s2.begin(), s2.end(), s[i]));
s2.erase(find(s2.begin(), s2.end(), s[j]));
s2.push_back(prod);
}
ret = min(ret, solve(op + 1, s2));
}
return memo[s] = ret;
}
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
vector<long long> s = {a, b, c, d};
ops = vector<char>(3);
for (char& c : ops) cin >> c;
cout << solve(0, s) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void desperate_optimization(int precision) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(precision);
}
int flow[2005][2005];
long long n;
stack<long long> re;
int main() {
desperate_optimization(10);
cin >> n;
long long lo = 1;
long long maxi = 0;
while (lo <= n) {
lo *= 3LL;
maxi++;
}
maxi--;
long long tmp = n;
while (tmp) {
re.push(tmp % 3);
tmp /= 3;
}
lo = 1;
long long hi = 2;
vector<long long> last;
for (int i = maxi; i >= 0; i--) {
long long tr = re.top();
re.pop();
if (tr == 0) continue;
long long now = lo;
for (int j = 0; j < i; j++) {
hi++;
flow[now][hi] = flow[hi][now] = 1;
hi++;
flow[now][hi] = flow[hi][now] = 1;
hi++;
flow[now][hi] = flow[hi][now] = 1;
hi++;
flow[hi - 1][hi] = flow[hi][hi - 1] = 1;
flow[hi - 2][hi] = flow[hi][hi - 2] = 1;
flow[hi - 3][hi] = flow[hi][hi - 3] = 1;
now = hi;
}
for (int j = i; j < maxi; j++) {
hi++;
flow[now][hi] = flow[hi][now] = 1;
now = hi;
hi++;
flow[now][hi] = flow[hi][now] = 1;
now = hi;
}
if (tr == 2) {
hi++;
flow[now][hi] = flow[hi][now] = 1;
hi++;
flow[now][hi] = flow[hi][now] = 1;
hi++;
flow[hi - 2][hi] = flow[hi][hi - 2] = 1;
flow[hi - 1][hi] = flow[hi][hi - 1] = 1;
} else {
hi++;
flow[now][hi] = flow[hi][now] = 1;
now = hi;
hi++;
flow[now][hi] = flow[hi][now] = 1;
}
last.push_back(hi);
}
for (int i = 0; i < last.size(); i++) {
int nx = last[i];
flow[nx][2] = flow[2][nx] = 1;
}
cout << hi << '\n';
for (int i = 1; i <= hi; i++) {
for (int j = 1; j <= hi; j++) cout << ((flow[i][j] == 1) ? 'Y' : 'N');
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = (s << 1) + (s << 3) + ch - '0';
ch = getchar();
}
return s * w;
}
namespace OPT {
char opt[50];
}
inline void pt(long long x) {
int top = 0;
if (x < 0) {
putchar('-');
x = -x;
}
do OPT::opt[++top] = x % 10 + '0';
while (x /= 10);
while (top) putchar(OPT::opt[top--]);
}
int n;
long long ans;
int main() {
scanf("%d", &n);
printf("2\n");
for (long long i = 2; i <= n; ++i) {
ans = (i + 2) * i * i + 1;
printf("%lld\n", ans);
}
return 0;
}
| 1 |
#include<cstdio>
#include<cstring>
#include<algorithm>
int n,m;
int a[100001];
int fa[100001];
int us[100001],val[100001],num[100001],re[100001],p,cnt;
int gf(int x){return fa[x]==x?x:(fa[x]=gf(fa[x]));}
long long ans=0;
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
for(int i=1;i<=n;i++) fa[i]=i;
for(int i=1,x,y;i<=m;i++) scanf("%d%d",&x,&y),x++,y++,fa[gf(y)]=gf(x);
for(int i=1;i<=n;i++) if(fa[i]==i) cnt++;
if(n<cnt*2-2) return !puts("Impossible");
if(cnt==1) return !puts("0");
for(int i=1;i<=n;i++) val[i]=2147483647;
for(int i=1;i<=n;i++){
int x=gf(i);
if(a[i]<val[x]) val[x]=a[i],num[x]=i;
}
for(int i=1;i<=n;i++){
if(val[i]<2147483647) ans+=1ll*val[i];
if(num[i]) us[num[i]]=1;
}
for(int i=1;i<=n;i++) if(!us[i]) re[++p]=a[i];
std::sort(re+1,re+p+1);
for(int i=1;i<=cnt-2;i++) ans+=1ll*re[i];
printf("%lld\n",ans);
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
using Weight=long long;
struct Edge{
int to;
Weight cost;
};
const Weight INF=1e12;
using Edges=vector<Edge>;
using Graph=vector<Edges>;
vector<int> isLeaf;
Weight removal(int v,int pre,Graph& g){
auto res=0;
for(int i=0;i<g[v].size();++i){
if(g[v][i].to!=pre){
res+=removal(g[v][i].to,v,g);
}
}
if(res==0){
isLeaf[v]=true;
res+=g[v][0].cost;
}
return res;
}
Weight way(int v,int pre,Graph &g){
if(isLeaf[v]){
return -g[v][0].cost;
}
Weight res=0;
for(int i=0;i<g[v].size();i++){
if(g[v][i].to==pre) continue;
res=max(res,g[v][i].cost+way(g[v][i].to,v,g));
}
return res;
}
int main(){
int n;
while(cin>>n,n){
Graph org(n);
vector<int> p(n);
for(int i=1;i<n;i++){
cin>>p[i];
p[i]--;
}
Weight sum=0;
vector<Weight> d(n);
for(int i=1;i<n;i++) cin>>d[i];
for(int i=1;i<n;i++){
org[i].push_back(Edge{p[i],d[i]});
org[p[i]].push_back(Edge{i,d[i]});
sum+=d[i];
}
Weight res=INF;
for(int root=0;root<n;root++){
isLeaf.assign(n,0);
auto g=org;
auto ret=removal(root,-1,g);
auto minu=way(root,-1,g);
res=min(res,sum*3-ret*2-minu);
}
cout<<res<<endl;
}
return 0;
}
| 0 |
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
const int MAXN = 10000;
int n;
int vs[MAXN];
int d[MAXN];
void bfs(int s,vector<vector<int> > &g){
queue<int> q;
q.push(s);
fill(d,d+MAXN,-1);
d[s] = 0;
while(!q.empty()){
int current = q.front();q.pop();
for(int next:g[current]){
if(d[next] < 0){
q.push(next);
d[next] = d[current] + 1;
}
}
}
}
int main(){
cin >> n;
vector<vector<int> > g(n+1);
for(int i = 1;i <= n;i++){
int u,k;
cin >> u >> k;
for(int j = 0; j < k;j++){
int v;
cin >> v;
g[u].push_back(v);
}
}
bfs(1,g);
for(int i = 1;i <= n;i++){
cout << i << ' ' << d[i] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
long long t;
long long mex(vector<long long> &v) {
sort(v.begin(), v.end());
long long ans = 0;
for (long long x : v)
if (x == ans) ans++;
return ans;
}
long long main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> t;
while (t--) {
long long n;
cin >> n;
string s1, s2;
cin >> s1 >> s2;
vector<long long> dp(n);
function<long long(long long, long long)> get_mex = [&](long long i,
long long delta) {
vector<long long> v;
for (long long j = 0; j < delta; j++) {
v.push_back(s1[i - j] - '0');
v.push_back(s2[i - j] - '0');
}
return mex(v);
};
for (long long i = 0; i < n; i++) {
for (long long prv = i - 1; prv >= i - 2; prv--) {
long long delta = i - prv;
if (prv == -1) {
dp[i] = max(dp[i], get_mex(i, delta));
} else if (prv < -1) {
continue;
} else {
dp[i] = max(dp[i], dp[prv] + get_mex(i, delta));
}
}
}
cout << dp[n - 1] << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
const int maxn = 1000000 + 5;
struct Point {
long long x, y;
};
bool operator<(const Point &a, const Point &b) {
if (a.x == b.x) return a.y < b.y;
return a.x < b.x;
}
class Convex {
public:
int n;
Point p[maxn];
void readin() {
scanf("%d", &n);
int x, y;
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
p[i].x = x;
p[i].y = y;
}
}
};
Convex p1, p2, p3;
int pk[maxn];
int m, size;
Point pts[maxn];
pair<pair<long long, long long>, int> q[maxn];
bool R[maxn];
Point add(Point a, Point b) {
Point c;
c.x = a.x + b.x;
c.y = a.y + b.y;
return c;
}
void add_points(Convex &a, Convex &b) {
int k = 0;
for (int i = 0; i < a.n; i++) {
Point src = a.p[i];
Point dest = a.p[(i + 1) % a.n];
long long gx = src.y - dest.y;
long long gy = -(src.x - dest.x);
if (i == 0) {
long long best = -1;
int bestk = -1;
for (int k = 0; k < b.n; k++) {
long long current = gx * b.p[k].x + gy * b.p[k].y;
if (k == 0 || current < best) best = current, bestk = k;
}
k = bestk;
}
while (1) {
long long current = gx * b.p[k].x + gy * b.p[k].y;
int k2 = (k + 1) % b.n;
long long next = gx * b.p[k2].x + gy * b.p[k2].y;
if (next < current)
k = k2;
else
break;
}
pk[i] = k;
}
for (int i = 0; i < a.n; i++) {
int src = pk[(i + a.n - 1) % a.n];
int dest = pk[i];
pts[size++] = add(a.p[i], b.p[(src + b.n - 1) % b.n]);
pts[size++] = add(a.p[i], b.p[(dest + 1) % b.n]);
for (int k = src; k != dest; k = (k + 1) % b.n)
pts[size++] = add(a.p[i], b.p[k]);
pts[size++] = add(a.p[i], b.p[dest]);
}
}
long long cross(Point a, Point b, Point c) {
return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
}
void merge_convex(Convex &a, Convex &b, Convex &c) {
size = 0;
add_points(a, b);
add_points(b, a);
sort(pts, pts + size);
c.n = 0;
for (int i = 0; i < size; i++) {
for (; c.n >= 2 && cross(c.p[c.n - 2], c.p[c.n - 1], pts[i]) <= 0; c.n--)
;
c.p[c.n++] = pts[i];
}
int tm = c.n;
for (int i = size - 1; i >= 0; i--) {
for (; c.n >= tm + 1 && cross(c.p[c.n - 2], c.p[c.n - 1], pts[i]) <= 0;
c.n--)
;
c.p[c.n++] = pts[i];
}
c.n--;
}
int main() {
p1.readin();
p2.readin();
merge_convex(p1, p2, p3);
p2.readin();
merge_convex(p2, p3, p1);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
q[i] = make_pair(make_pair((long long)x * 3, (long long)y * 3), i);
}
sort(q, q + m);
int k_min = 0, k_max = 0;
for (int i = 0; i < p1.n; i++) {
if (p1.p[i].x < p1.p[k_min].x) k_min = i;
if (p1.p[i].x > p1.p[k_max].x) k_max = i;
}
for (int i = 0; i < m; i++) R[i] = false;
int k1 = k_min, k2 = k_min;
long long min_x = p1.p[k_min].x;
long long max_x = p1.p[k_max].x;
for (; p1.p[(k2 + p1.n - 1) % p1.n].x == min_x; k2 = (k2 + p1.n - 1) % p1.n)
;
for (int i = 0; i < m; i++)
if (q[i].first.first == min_x)
R[q[i].second] =
(q[i].first.second >= p1.p[k1].y && q[i].first.second <= p1.p[k2].y);
else if (q[i].first.first > min_x && q[i].first.first < max_x) {
for (; p1.p[(k2 + p1.n - 1) % p1.n].x <= q[i].first.first;
k2 = (k2 + p1.n - 1) % p1.n)
;
for (; p1.p[(k1 + 1) % p1.n].x <= q[i].first.first; k1 = (k1 + 1) % p1.n)
;
Point key;
key.x = q[i].first.first;
key.y = q[i].first.second;
R[q[i].second] =
cross(p1.p[k2], p1.p[(k2 + p1.n - 1) % p1.n], key) <= 0 &&
cross(p1.p[k1], p1.p[(k1 + 1) % p1.n], key) >= 0;
} else if (q[i].first.first == max_x) {
for (; p1.p[k2].x != max_x; k2 = (k2 + p1.n - 1) % p1.n)
;
for (; p1.p[k1].x != max_x; k1 = (k1 + 1) % p1.n)
;
R[q[i].second] =
(q[i].first.second >= p1.p[k1].y && q[i].first.second <= p1.p[k2].y);
}
for (int i = 0; i < m; i++)
if (R[i])
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& num) {
num = 0;
bool f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
num = num * 10 + ch - '0';
ch = getchar();
}
num = f ? num : -num;
}
template <class T>
inline void write(T x, char ch) {
int s[100];
if (x == 0) {
putchar('0');
putchar(ch);
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
int num = 0;
while (x) {
s[num++] = (x % 10);
x = x / 10;
}
for (int i = (num - 1); i >= (0); i--) putchar(s[i] + '0');
putchar(ch);
}
const double pi = acos(-1);
const double eps = 1e-8;
int cnt = 0;
int sum[100005 * 40], ch[100005 * 40][2];
int n;
int last[100005], rt[100005], pre[100005];
void insert(int& o, int p, int l, int r, int q, int d) {
if (!o) o = ++cnt;
sum[o] = sum[p] + d;
if (l == r) return;
int mid = (((l) + (r)) >> 1);
if (q <= mid) {
ch[o][1] = ch[p][1];
insert(ch[(o)][0], ch[(p)][0], l, mid, q, d);
}
if (q > mid) {
ch[o][0] = ch[p][0];
insert(ch[(o)][1], ch[(p)][1], mid + 1, r, q, d);
}
}
int query(int o, int l, int r, int L, int R) {
if (L <= l && r <= R) return sum[o];
int mid = (((l) + (r)) >> 1), res = 0;
if (L <= mid) res += query(ch[(o)][0], l, mid, L, R);
if (R > mid) res += query(ch[(o)][1], mid + 1, r, L, R);
return res;
}
int climb(int o, int l, int r, int p) {
if (l == r) return p >= sum[o] ? l : l + 1;
int mid = (((l) + (r)) >> 1);
if (p >= sum[ch[(o)][1]])
return climb(ch[(o)][0], l, mid, p - sum[ch[(o)][1]]);
else
return climb(ch[(o)][1], mid + 1, r, p);
}
int a[100005];
int main() {
read(n);
for (int i = (1); i <= (n); i++) {
read(a[i]);
pre[i] = last[a[i]], last[a[i]] = i;
}
for (int i = (1); i <= (n); i++) {
insert(rt[i], rt[i - 1], 1, n, i, 1);
if (pre[i]) {
int root = 0;
insert(root, rt[i], 1, n, pre[i], -1);
rt[i] = root;
}
}
for (int i = (1); i <= (n); i++) {
int s = n, ans = 0;
while (s) {
s = climb(rt[s], 1, n, i) - 1;
ans++;
}
write(ans, ' ');
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<bool> fe(100005, true);
vector<int> f(100005, 0);
vector<pair<int, int> > ans;
vector<int> pos(100005, 0);
vector<int> a(100005, 0);
void sieve() {
fe[0] = false;
fe[1] = false;
for (int i = 2; i < sqrt(100005); i++) {
if (fe[i] == true) {
for (int j = i * i; j < 100005; j = j + i) {
fe[j] = false;
}
}
}
for (int i = 2; i < 100005; i++) {
if (fe[i] == true) {
f[i] = i;
} else {
f[i] = f[i - 1];
}
}
}
int main() {
sieve();
int n;
cin >> n;
int r;
for (int i = 1; i <= n; i++) {
cin >> r;
a[i] = r;
pos[r] = i;
}
int j = 1;
while (j != n) {
if (pos[j] == j) {
j++;
continue;
}
int temp = pos[j] + 1 - f[pos[j] - (j - 1)];
int t = pos[j];
a[pos[j]] = a[temp];
pos[j] = temp;
pos[a[temp]] = t;
a[temp] = j;
ans.push_back(make_pair(temp, t));
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100090;
struct Ans {
int x, y;
} ans[MAXN];
int ans_num;
int d[MAXN], degree[MAXN];
int r[MAXN];
int k, n;
int cmp(int i, int j) { return d[i] < d[j]; }
void clear_queue(queue<int> &Q) {
while (!Q.empty()) Q.pop();
}
queue<int> Q[2];
void solve() {
memset(degree, 0, sizeof(degree));
sort(r, r + n, cmp);
ans_num = 0;
clear_queue(Q[0]);
clear_queue(Q[1]);
Q[0].push(r[0]);
int qc = 0;
int now = 0;
bool flag = true;
for (int i = 1; i < n && flag; i++) {
int v = r[i];
if (d[v] != (now + 1)) {
clear_queue(Q[qc]);
qc ^= 1;
now++;
}
if (Q[qc].empty()) {
flag = false;
break;
}
int u = Q[qc].front();
Q[qc].pop();
if ((degree[u] == k) || (d[v] != d[u] + 1)) {
flag = false;
break;
}
ans[ans_num].x = u;
ans[ans_num].y = v;
ans_num++;
degree[u]++;
degree[v]++;
Q[qc].push(u);
Q[1 ^ qc].push(v);
}
if (flag && (ans_num == n - 1)) {
printf("%d\n", ans_num);
for (int i = 0; i < ans_num; i++)
printf("%d %d\n", ans[i].x + 1, 1 + ans[i].y);
} else {
printf("-1\n");
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", d + i);
r[i] = i;
}
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int NS = (int)1e5+4;
int N, M;
struct UN{
int par, rk;
}un[NS];
int arr[NS][3];
long long out[NS];
int fd(int x){
return x==un[x].par? x:un[x].par=fd(un[x].par);
}
int main(){
scanf("%d %d", &N, &M);
for(int i=0;i<M;++i) scanf("%d %d", arr[i], arr[i]+1);
for(int i=1;i<=N;++i) un[i].par = i, un[i].rk = 1;
long long ans = (long long)N*(N-1)/2;
for(int i=M-1;i>=0;--i){
out[i] = ans;
int pa = fd(arr[i][0]), pb = fd(arr[i][1]);
if(pa!=pb){
ans -= (long long)un[pa].rk*un[pb].rk;
if(un[pa].rk>un[pb].rk){
un[pb].par = pa, un[pa].rk += un[pb].rk;
}
else{
un[pa].par = pb, un[pb].rk += un[pa].rk;
}
}
}
for(int i=0;i<M;++i) printf("%lld\n", out[i]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, r, flag;
int f[110], g[110], h[110];
vector<int> a[110], gen;
void dfs(int x, int y) {
if (flag) return;
int i;
f[x] = 1;
g[++r] = x;
for (i = 0; i < a[x].size(); i++) {
int A = a[x][i];
if (A == y) continue;
if (f[A]) {
for (; g[r] != A; r--) gen.push_back(g[r]);
gen.push_back(A);
flag = 1;
return;
}
dfs(A, x);
if (flag) return;
}
f[x] = 0;
r--;
}
int get(int x) { return h[x] == x ? x : h[x] = get(h[x]); }
inline void fail() {
printf("NO\n");
exit(0);
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) h[i] = i;
for (i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
h[get(x)] = get(y);
}
dfs(1, 0);
if (!flag) fail();
int s = 0;
for (i = 1; i <= n; i++) s += get(i) == i;
if (s > 1) fail();
if (m != n) fail();
printf("FHTAGN!\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
int ans{0};
vector<int> pos(k + 1, 0);
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
pos[x] = i + 1;
}
for (int i = 0; i < n; i++)
for (int i = 0; i < m; i++) {
int p;
cin >> p;
ans += pos[p];
for (int i = 1; i <= k; i++)
if (pos[i] < pos[p]) pos[i]++;
pos[p] = 1;
}
cout << ans;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int h,w,a,i,j,k,ans=0;
cin>>h>>w;
vector<vector<int>> c(10,vector<int>(10));
for(i=0;i<10;i++) for(j=0;j<10;j++) cin>>c.at(i).at(j);
for(k=0;k<10;k++) for(i=0;i<10;i++) for(j=0;j<10;j++) c.at(i).at(j)=min(c.at(i).at(j),c.at(i).at(k)+c.at(k).at(j));
for(i=0;i<h;i++){
for(j=0;j<w;j++){
cin>>a;
if(a!=-1) ans+=c.at(a).at(1);
}
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 10;
const long long K = 7e2 + 10;
const long long inf = 1e9;
const long long mod = 1e9 + 7;
long long q;
long long k;
vector<pair<long long, long long> > g[N];
long long G;
long long B;
long long dfs(long long v = 0, long long cst = 0, long long p = -1) {
long long sz = 0;
for (auto pr : g[v])
if (pr.first != p) sz += dfs(pr.first, pr.second, v);
++sz;
if (p != -1) {
G += (sz % 2) * cst;
B += min(sz, 2 * k - sz) * cst;
}
return sz;
}
void solve() {
cin >> k;
for (long long i = 0; i <= 2 * k; ++i) g[i].clear();
G = 0;
B = 0;
for (long long i = 0; i < 2 * k - 1; ++i) {
long long v, u, t;
cin >> v >> u >> t;
--v;
--u;
g[v].emplace_back(u, t);
g[u].emplace_back(v, t);
}
dfs();
cout << G << " " << B << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> q;
while (q--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 0)
cout << "1";
else {
map<int, int> m;
m[0] = 6;
m[1] = 8;
m[2] = 4;
m[3] = 2;
int i = n % 4;
cout << m[i];
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, ans, i, sum = 2;
cin >> n;
for (i = 1; i <= n; i++) {
if (i == 1) {
printf("2\n");
continue;
}
ans = i * (i + 1) * (i + 1) - i + 1;
printf("%lld\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
int p = 0, l = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '-')
l++;
else
p++;
}
if (p == 0 || l == 0)
cout << "YES";
else if (l < p)
cout << "NO";
else if (p % l == 0 || l % p == 0)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[1000];
int main() {
int n, x, i = 0, j = 0, p, cnt;
cin >> n;
x = n;
while (x != 0) {
p = 1, cnt = 0;
while (p <= x) {
p = p * 2;
cnt++;
}
a[i] = cnt;
x = x - p / 2;
i++;
}
for (j = 0; j < i; j++) cout << a[j] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long ara[2003], co[2003], fact[2003], val[2003];
long long bigmod(long long b, long long p) {
if (!p) return 1ll;
long long ret = bigmod(b, p / 2);
ret = (ret * ret) % 1000000007ll;
if (p & 1ll) ret = (ret * b) % 1000000007ll;
return ret;
}
int main() {
fact[0] = 1ll;
for (long long i = 1; i <= 2000; i++)
fact[i] = (fact[i - 1] * i) % 1000000007ll;
long long n, k;
scanf("%lld %lld", &n, &k);
for (int i = 0; i < n; i++) scanf("%lld", &ara[i]);
if (k) {
co[0] = 1;
for (long long i = 1; i < n; i++) {
long long p = i + k - 1;
long long q = i;
long long nume = 1ll;
for (long long j = p - q + 1; j <= p; j++)
nume = (nume * j) % 1000000007ll;
long long deno = fact[q];
deno = bigmod(deno, 1000000007ll - 2);
co[i] = (nume * deno) % 1000000007ll;
}
for (int i = 0; i < n; i++)
for (int j = 0, l = i; j <= i; j++, l--)
val[i] = (val[i] + co[j] * ara[l]) % 1000000007ll;
for (int i = 0; i < n; i++) printf("%lld ", val[i]);
puts("");
} else {
for (int i = 0; i < n; i++) printf("%lld ", ara[i]);
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y, ans1 = 0, ans2 = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y;
if (x > y)
ans1++;
else if (x < y)
ans2++;
}
if (ans1 == ans2)
cout << "Friendship is magic!^^" << endl;
else if (ans1 > ans2)
cout << "Mishka" << endl;
else
cout << "Chris" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int m = 0, maxi = 0, n = 0, u = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'A' || s[i] == 'E' || s[i] == 'I' || s[i] == 'O' ||
s[i] == 'U' || s[i] == 'Y') {
u = 0;
for (int j = i + 1; j < s.size(); j++) {
if (s[j] == 'A' || s[j] == 'E' || s[j] == 'I' || s[j] == 'O' ||
s[j] == 'U' || s[j] == 'Y') {
break;
} else
m++;
}
} else
u++;
if (u >= n) {
n = u;
}
if (m >= maxi) maxi = m;
m = 0;
}
if (n > maxi)
cout << n + 1;
else
cout << maxi + 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main(int argc, const char* argv[]) {
int n, v;
std::cin >> n >> v;
std::vector<int> t;
for (int i = 0; i < n; i++) {
int k;
std::cin >> k;
bool result = false;
for (int j = 0; j < k; j++) {
int s;
std::cin >> s;
if (s < v) result = true;
}
if (result) t.push_back(i + 1);
}
std::cout << t.size() << std::endl;
if (t.size() > 0) {
std::cout << t[0];
for (int i = 1; i < t.size(); i++) std::cout << " " << t[i];
std::cout << std::endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct people {
int a, d, id;
bool operator<(people other) const {
if (a != other.a) return a > other.a;
return id < other.id;
}
};
people s[111];
int n;
int main() {
int i, j, ans = 0;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d%d", &s[i].a, &s[i].d);
s[i].id = i;
}
sort(s + 1, s + 1 + n);
vector<int> ret;
for (i = 1; i <= n; ++i) {
if (s[i].d < 0) {
ret.push_back(s[i].id);
}
}
for (auto v : ret) {
for (i = 1; i <= n; ++i) {
if (s[i].id == v) {
j = i;
while (j < n &&
(s[j].a + s[j].d < s[j + 1].a ||
(s[j].a + s[j].d == s[j + 1].a && s[j].id > s[j + 1].id))) {
swap(s[j], s[j + 1]);
ans++;
j++;
}
s[j].a = s[j].a + s[j].d;
break;
}
}
}
ret.clear();
for (i = n; i >= 1; --i) {
if (s[i].d > 0) {
ret.push_back(s[i].id);
}
}
for (auto v : ret) {
for (i = n; i >= 1; --i) {
if (s[i].id == v) {
j = i;
while (j > 1 &&
(s[j].a + s[j].d > s[j - 1].a ||
(s[j].a + s[j].d == s[j - 1].a && s[j].id < s[j - 1].id))) {
swap(s[j], s[j - 1]);
ans++;
j--;
}
s[j].a = s[j].a + s[j].d;
break;
}
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <set>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <cstdlib>
#include <complex>
#define REP(i,n) for(int i=0; i<(int)(n); i++)
inline int getInt(){ int s; scanf("%d", &s); return s; }
using namespace std;
typedef complex<double> P;
int main(){
while(const int n = getInt()){
vector<P> pos(n);
vector<double> v(n);
REP(i,n){
const int x = getInt();
const int y = getInt();
v[i] = getInt();
pos[i] = P(x, y);
}
const double r = 0.99;
P p(0, 0);
auto calc = [&](P p){
auto mx = make_pair(0.0, 0);
REP(i,n) mx = max(mx, make_pair(abs(p - pos[i]) / v[i], i));
return mx;
};
for(double d = 1000; d > 1e-8; d *= r){
auto mx = calc(p).second;
p += (pos[mx] - p) / abs(pos[mx] - p) * d;
}
printf("%.8f\n", calc(p).first);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> son[200005];
int w[200005];
void init() {}
void dfs(int u, long long &odd, long long &even) {
int len = son[u].size();
if (len % 2 == 0) {
even = 0;
for (int i = 0; i < len; ++i) {
long long o, e;
dfs(son[u][i], o, e);
even += o;
}
odd = even + w[u];
} else {
odd = 0;
long long diff = 1e6;
for (int i = 0; i < len; ++i) {
long long o, e;
dfs(son[u][i], o, e);
odd += o;
diff = min(diff, o - e);
}
even = odd - diff;
odd = max(odd, even + w[u]);
}
}
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int u, w;
scanf("%d%d", &u, &w);
if (u > 0) son[u].push_back(i);
::w[i] = w;
}
long long f, g;
dfs(1, f, g);
cout << max(f, g) << endl;
}
int main() {
init();
solve();
return 0;
}
| 2 |
#include<stdio.h>
int main(void)
{
int i,n,s[2000],p[2000],q[2000],r[2000],c[2000],p2,q2,r2,c2,flg;
scanf("%d",&n);
while(n!=0){
flg=0;
for(i=0;i<n;i++){
scanf("%d %d %d %d",&s[i],&p[i],&q[i],&r[i]);
c[i]=p[i]*4+q[i]*9+r[i]*4;
}
scanf("%d %d %d %d",&p2,&q2,&r2,&c2);
for(i=0;i<n;i++){
if(p[i]<=p2&&q[i]<=q2&&r[i]<=r2&&c[i]<=c2){
printf("%d\n",s[i]);
flg=1;
}
}
if(flg==0) printf("NA\n");
scanf("%d",&n);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> even(100001);
vector<int> odd(100001);
int main() {
int n;
cin >> n;
for (int i = 0, v; i * 2 < n; i++) {
cin >> v;
even[v]++;
cin >> v;
odd[v]++;
}
int ef = 0, es = 0, of = 0, os = 0;
for (int i = 0; i < 100001; i++) {
if (even[i] > even[ef]) {
es = ef;
ef = i;
} else if (even[i] > even[es])
es = i;
if (odd[i] > odd[of]) {
os = of;
of = i;
} else if (odd[i] > odd[os])
os = i;
}
if (ef != of) {
cout << n - even[ef] - odd[of] << endl;
} else
cout << min(n - even[es] - odd[of], n - even[ef] - odd[os]) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, n, m, k, t, x, y, d, s, a[100], b[100];
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> k;
a[k]++;
}
for (i = 1; i <= n; i++) {
cin >> k;
b[k]++;
}
for (i = 1; i <= 5; i++) {
if ((a[i] + b[i]) % 2 != 0) {
cout << -1;
return 0;
}
t += abs(a[i] - b[i]) / 2;
}
cout << t / 2;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
map<string, int> Name;
int dp[1 << 16], cnt[1 << 16], ret, rid;
int n, m;
inline void chkmin(int &x, int y) {
if (y < x) x = y;
}
void init() {
scanf("%d", &n);
char st[15];
for (int i = 1; i <= n; i++) {
scanf("%s", st);
Name[st] = i;
}
for (int i = 1; i <= ((1 << (n)) - 1); i++) cnt[i] = __builtin_popcount(i);
ret = INF;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int len;
scanf("%d", &len);
for (int i = 0; i <= ((1 << (n)) - 1); i++) dp[i] = INF;
int state = 0;
dp[0] = 0;
for (int i = 0; i < len; i++) {
scanf("%s", st);
if (!Name.count(st) || (state & (1 << ((Name[st]) - 1)))) continue;
int t = Name[st];
state = (state & ((1 << (t)) - 1)) | (1 << ((t)-1));
for (int s = 0; s <= ((1 << (n)) - 1); s++)
if (!(s & (1 << ((t)-1))) && dp[s] < INF)
chkmin(dp[s | (1 << ((t)-1))],
dp[s] + cnt[s & (((1 << (n)) - 1) - ((1 << (t)) - 1))]);
}
if (dp[((1 << (n)) - 1)] < ret) ret = dp[((1 << (n)) - 1)], rid = i;
}
}
void print() {
if (ret == INF) {
puts("Brand new problem!");
return;
}
ret = n * (n - 1) / 2 - ret + 1;
printf("%d\n[:", rid);
for (int i = 0; i < ret; i++) putchar('|');
puts(":]");
}
int main() {
init();
print();
return 0;
}
| 4 |
#include "bits/stdc++.h"
using namespace std;
int main() {
int N;
cin >> N;
map<int,int>mp;
for (int n = 0;n<N;++n) {
int num;
cin >> num;
mp[num] = n;
}
set<int>S;
S.insert(-1);
S.insert(N);
long long ans = 0;
for (int n = N; n > 0; --n) {
int num = mp[n];
S.insert(num);
int l1, l2;
{
set<int>::iterator it = S.find(num);
it--;
l2 = *it;
if (-1 != *it) {
it--;
}
l1 = *it;
}
int r1, r2;
{
set<int>::iterator it = S.find(num);
it = S.find(num);
it++;
r1 = *it;
if (N != *it) {
it++;
}
r2 = *it;
}
ans += (long long)n*(r2 - r1)*(num-l2);
ans += (long long)n*(l2 - l1)*(r1-num);
}
cout << ans <<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
string s;
int main()
{
cin>>s;
if(s[0]=='Y'&&s[1]=='A'&&s[2]=='K'&&s[3]=='I')
cout<<"Yes";
else cout<<"No";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 123456 + 5;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const int BASE = 31;
int N, M;
vector<int> G[MAXN];
bool attack[MAXN];
int maxLevel, minNode1 = MAXN, minNode2 = MAXN, sumEdges;
bool canGo[MAXN];
void findDiameter1(int p, int r, int level) {
for (int i = 0; i < G[r].size(); ++i) {
int u = G[r][i];
if (u != p) {
findDiameter1(r, u, level + 1);
if (canGo[u]) canGo[r] = 1;
}
}
if (attack[r]) {
canGo[r] = 1;
if (level == maxLevel) {
minNode1 = min(r, minNode1);
} else if (level > maxLevel) {
maxLevel = level;
minNode1 = r;
}
}
}
void findDiameter2(int p, int r, int level) {
for (int i = 0; i < G[r].size(); ++i) {
int u = G[r][i];
if (u != p && canGo[u]) {
sumEdges += 2;
findDiameter2(r, u, level + 1);
}
}
if (attack[r]) {
if (level == maxLevel) {
minNode2 = min(r, minNode2);
} else if (level > maxLevel) {
maxLevel = level;
minNode2 = r;
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
int u, v;
for (int i = 0; i < N - 1; ++i) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 0; i < M; ++i) {
cin >> u;
attack[u] = 1;
}
findDiameter1(-1, u, 0);
findDiameter2(-1, minNode1, 0);
cout << min(minNode1, minNode2) << '\n';
cout << sumEdges - maxLevel << '\n';
return 0;
}
| 4 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<deque>
#include<climits>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define IINF (INT_MAX)
#define MAX 110
using namespace std;
struct Data{
int x,y,cost;
Data(int x=IINF,int y=IINF,int cost=IINF):x(x),y(y),cost(cost){}
};
int H,W,N,ix,iy,ox,oy;
int dx[] = {0,2,0,-2};
int dy[] = {2,0,-2,0};
bool G[MAX][MAX];
bool used[MAX][MAX];
inline bool isValid(int nx,int ny){ return ( 0 <= nx && nx <= 2*W && 0 <= ny && ny <= 2*H ); }
int getValue(){
if( ix == ox && iy == oy )return 0;
rep(i,2*H+1)rep(j,2*W+1)used[i][j] = false;
deque<Data> deq;
deq.push_back(Data(ix,iy,0));
used[iy][ix] = true;
while(!deq.empty()){
Data data = deq.front(); deq.pop_front();
int x = data.x, y = data.y;
rep(i,4){
int nx = x + dx[i],ny = y + dy[i];
int mx = (x+nx) / 2, my = (y+ny) / 2;
if(!isValid(nx,ny) || G[my][mx] || used[ny][nx])continue;
used[ny][nx] = true;
if( nx == ox && ny == oy )return data.cost + 1;
deq.push_back(Data(nx,ny,data.cost+1));
}
}
return IINF;
}
int main(){
cin >> W >> H >> N;
rep(i,2*H+1)G[i][0] = G[i][2*W] = true;
rep(i,2*W+1)G[0][i] = G[2*H][i] = true;
rep(i,N){
int sx,sy,dx,dy;
cin >> sx >> sy >> dx >> dy;
sx <<= 1, sy <<= 1, dx <<= 1, dy <<= 1;
REP(y,min(sy,dy),max(sy,dy)+1)REP(x,min(sx,dx),max(sx,dx)+1) G[y][x] = true;
}
cin >> ix >> iy >> ox >> oy;
ix <<= 1, iy <<= 1,ox <<= 1, oy <<= 1;
ix++,iy++,ox++,oy++;
int tmp = getValue();
int ans = 0;
rep(y,2*H+1)rep(x,2*W+1){
if( y == 0 || x == 0 || y == 2*H || x == 2*W || G[y][x] )continue;
if( ( !(y&1) && !(x&1) ) || ( (y&1) && (x&1) ) )continue;
G[y][x] = true;
int cost = getValue();
if(cost != IINF)ans = max(ans,cost-tmp);
G[y][x] = false;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
string trans(const string& s) {
string t;
for (char ch : s) {
if ((ch - '0') & 1)
t += '1';
else
t += '0';
}
int i = 0;
while (i < t.size() - 1 && t[i] == '0') ++i;
t = t.substr(i);
return t;
}
int main() {
int n;
string action, s;
unordered_map<string, int> m;
cin >> n;
while (n--) {
cin >> action >> s;
s = trans(s);
if (action == "+") {
++m[s];
} else if (action == "-") {
--m[s];
} else {
cout << m[s] << '\n';
}
}
}
| 1 |
#include <bits/stdc++.h>
struct {
inline operator int() {
int x;
return scanf("%d", &x), x;
}
inline operator long long() {
long long x;
return scanf("%lld", &x), x;
}
} read;
long long key(long long p, long long k) {
if (p == 1) return k * (k + 1) >> 1;
long long np = (p - 1) / k + 1;
long long l = (np - 1) * (k * k + 1) + ((p - 1) % k) * k + 1, r = l + k - 1;
long long ke = key(np, k);
long long res = (l + r) * k >> 1;
if (l <= ke and ke <= r) return res - ke + r + 1;
if (ke <= l) return res + k;
return res;
}
int main() {
int T = read;
while (T--) {
long long n = read, k = read;
long long p = (n - 1) / (k * k + 1) + 1;
long long ke = key(p, k);
if (n == ke)
printf("%lld\n", (k + 1) * p);
else {
long long l, r;
if (ke < n)
l = p + 1, r = (p - 1) * k + (n - 2) % (k * k + 1) / k;
else
l = p, r = (p - 1) * k + (n - 1) % (k * k + 1) / k;
printf("%lld\n", n + (r - l + 1));
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int c[500005], maxn;
inline int lowbit(int x) { return x & (-x); }
void change(int pos, int val) {
while (pos) c[pos] = max(c[pos], val), pos -= lowbit(pos);
}
int maxx(int pos) {
int ans = -1;
while (pos <= maxn) ans = max(ans, c[pos]), pos += lowbit(pos);
return ans;
}
struct node {
int b[3], num;
} w[500005];
bool cmp0(node x, node y) { return x.b[0] < y.b[0]; }
bool cmp1(node x, node y) { return x.b[1] > y.b[1]; }
int main() {
int i, j;
while (cin >> n) {
for (i = 0; i < n; i++) scanf("%d", &w[i].b[0]);
for (i = 0; i < n; i++) scanf("%d", &w[i].b[1]);
for (i = 0; i < n; i++) scanf("%d", &w[i].b[2]);
sort(w, w + n, cmp0);
int rank = 1;
w[0].num = 1;
for (i = 1; i < n; i++) {
if (w[i].b[0] == w[i - 1].b[0])
w[i].num = rank;
else
w[i].num = ++rank;
}
sort(w, w + n, cmp1);
for (i = 1; i <= rank; i++) c[i] = -1;
maxn = rank;
i = 0;
int ans = 0;
while (i < n) {
for (j = i; j < n && w[i].b[1] == w[j].b[1]; j++)
if (maxx(w[j].num + 1) > w[j].b[2]) ans++;
for (j = i; j < n && w[i].b[1] == w[j].b[1]; j++)
change(w[j].num, w[j].b[2]);
i = j;
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = atan(1.0) * 4;
const long long int MOD = 1e9 + 7;
char arr[60][60];
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, 1, -1};
int checked[60][60];
bool good = false;
int n, m;
void dfs(int i, int j, int bef_x, int bef_y) {
if (!checked[i][j]) {
checked[i][j] = true;
for (int i1 = 0; i1 < 4; i1++) {
int x = i + dx[i1];
int y = j + dy[i1];
if ((x == bef_x && y == bef_y) || x < 0 || x >= n || y < 0 || y >= m ||
arr[x][y] != arr[i][j])
continue;
if (checked[x][y])
good = true;
else
dfs(x, y, i, j);
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> arr[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (!checked[i][j]) dfs(i, j, n, m);
if (good) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, p[1001];
double f[1001][1001];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &p[i]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i != j) f[i][j] = p[i] > p[j] ? 1 : 0;
for (int i = 1, a, b; i <= m; ++i) {
scanf("%d%d", &a, &b);
f[a][b] = f[b][a] = 0.5;
for (int j = 1; j <= n; ++j)
if (j != a && j != b) {
f[j][a] = f[j][b] = f[j][a] * 0.5 + f[j][b] * 0.5;
f[a][j] = f[b][j] = 1 - f[j][a];
}
}
double ans = 0;
for (int i = 1; i < n; ++i)
for (int j = i + 1; j <= n; ++j) ans += f[i][j];
printf("%.9lf", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e12;
const long long MOD = 1e9 + 7;
long long sq(long long num) { return num * num; }
long long mod_pow(long long x, long long n) {
if (n == 0) return 1;
if (n == 1) return x % MOD;
long long res = sq(mod_pow(x, n / 2));
res %= MOD;
if (n % 2 == 1) {
res *= x;
res %= MOD;
}
return res;
}
long long mod_add(long long a, long long b) { return (a + b) % MOD; }
long long mod_sub(long long a, long long b) { return (a - b + MOD) % MOD; }
long long mod_mul(long long a, long long b) { return a * b % MOD; }
long long n;
int main() {
cin >> n;
if (n % 2)
cout << "Ehab" << endl;
else
cout << "Mahmoud" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
solve();
return 0;
}
void solve() {
int i, n;
cin >> n;
if (n == 1 || n == 2) {
cout << 1 << "\n" << 1;
return;
} else if (n == 3) {
cout << 2 << "\n" << 1 << " " << 3;
return;
} else {
cout << n << "\n";
for (i = n; i > 0; i--) {
if (i & 1) {
cout << i << " ";
}
}
for (i = n; i > 0; i--) {
if (!(i & 1)) {
cout << i << " ";
}
}
}
}
| 1 |
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; (i) < (int)(n); ++ (i))
#define REP3(i, m, n) for (int i = (m); (i) < (int)(n); ++ (i))
#define REP_R(i, n) for (int i = (int)(n) - 1; (i) >= 0; -- (i))
using namespace std;
constexpr int MAX_N = 2000;
int solve(int n, const vector<bitset<MAX_N> > & wins) {
vector<bitset<MAX_N> > dpl(n);
vector<bitset<MAX_N> > dpr(n);
REP_R (l, n) REP3 (r, l, n) {
if (l == r) {
dpl[r][l] = true;
dpr[l][r] = true;
} else {
dpl[r][l] = (wins[l] & dpr[l + 1] & dpl[r]).any();
dpr[l][r] = (wins[r] & dpr[l] & dpl[r - 1]).any();
}
}
return (dpr[0] & dpl[n - 1]).count();
}
int main() {
int n; cin >> n;
assert (n <= MAX_N);
vector<bitset<MAX_N> > wins(n);
REP (i, n) {
REP (j, i) {
char c; cin >> c;
wins[i][j] = c - '0';
wins[j][i] = not wins[i][j];
}
}
cout << solve(n, wins) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[31];
int main()
{
dp[0] = 1;
dp[1] = 1;
dp[2] = 2;
for(int i = 3; i <= 30; i++){
dp[i] = dp[i-1] + dp[i-2] + dp[i-3];
}
int n;
while(cin >> n, n){
cout << dp[n] / 10 / 365 + 1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
const long long INF = 1 << 30;
const long long MOD = 1e9 + 7;
const int N = 1e6 + 10;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int x = n / 2, y = m / 2;
for (int i = 1; i <= x; ++i)
for (int j = 1; j <= m; ++j)
printf("%d %d\n%d %d\n", i, j, n - i + 1, m - j + 1);
if (n & 1) {
int y = m >> 1;
for (int i = 1; i <= y; ++i)
printf("%d %d\n%d %d\n", n / 2 + 1, i, n / 2 + 1, m - i + 1);
if (m & 1) printf("%d %d\n", n / 2 + 1, m / 2 + 1);
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int a,b,k,i;
int main(){
scanf("%d%d%d",&a,&b,&k);
for (i=a;i;i--)
if (a%i==0 && b%i==0){
k--;
if (!k) return printf("%d",i),0;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, h[3005][3005], Min[3005][3005], head, tail, que[3005 << 3];
long long x, y, z, g[9000010], ans;
int main() {
scanf("%d%d%d%d%lld%lld%lld%lld", &n, &m, &a, &b, &g[0], &x, &y, &z);
for (int i = 1; i <= 9000005; i++) g[i] = (g[i - 1] * x + y) % z;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) h[i][j] = g[(i - 1) * m + j - 1];
for (int i = 1; i <= n; i++) {
head = 1;
tail = 0;
for (int j = 1; j <= m; j++) {
while (head <= tail && que[head] <= j - b) head++;
while (head <= tail && h[i][que[tail]] >= h[i][j]) tail--;
que[++tail] = j;
Min[i][j] = h[i][que[head]];
}
}
for (int j = 1; j <= m; j++) {
head = 1;
tail = 0;
for (int i = 1; i <= n; i++) {
while (head <= tail && que[head] <= i - a) head++;
while (head <= tail && Min[que[tail]][j] >= Min[i][j]) tail--;
que[++tail] = i;
if (i >= a && j >= b) ans += Min[que[head]][j];
}
}
printf("%lld", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct rge {
T b, e;
};
template <class T>
rge<T> range(T i, T j) {
return rge<T>{i, j};
};
template <class A, class B>
ostream &operator<<(ostream &os, pair<A, B> p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream &operator<<(ostream &os, rge<T> d) {
os << "[";
for (auto it = d.b; it != d.e; it++) os << (it == d.b ? "" : ", ") << *it;
return os << "]";
}
const int N = 1e5 + 5;
const long long inf = 1e18;
long long stones[N], frogs[N];
int n, jump;
bool can(long long x) {
for (int i = (1); i <= ((n)); i += (+1)) {
frogs[i] = 0;
}
frogs[0] = x;
int l = 0, r = 1;
while (l < n) {
while (frogs[l] > 0) {
while (r <= n && stones[r] - frogs[r] <= 0) {
r++;
}
if (l + jump < r) {
return false;
}
long long add = min(frogs[l], stones[r] - frogs[r]);
frogs[r] += add;
frogs[l] -= add;
}
l++;
r = max(l + 1, r);
}
return true;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0), cout.precision(15);
cin >> n >> jump;
for (int i = (1); i <= ((n - 1)); i += (+1)) {
cin >> stones[i];
}
stones[n] = inf;
long long lo = 0, hi = inf;
while (lo + 1 < hi) {
long long mid = (lo + hi) / 2;
if (can(mid)) {
lo = mid;
} else {
hi = mid;
}
}
while (can(lo + 1)) {
lo++;
}
cout << lo << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, m, sa[1000010], sb[1000010];
long long ans = 1;
bool a[1000010], b[1000010];
int main()
{
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
{
int x;
scanf("%d", &x);
if (a[x])
{
puts("0");
return 0;
}
a[x] = 1;
}
for (int i = 1; i <= m; i++)
{
int x;
scanf("%d", &x);
if (b[x])
{
puts("0");
return 0;
}
b[x] = 1;
}
for (int i = n * m; i > 0; i--)
{
sa[i] = sa[i + 1] + a[i];
sb[i] = sb[i + 1] + b[i];
}
for (int i = 1; i <= n * m; i++)
{
if (a[i] && b[i])
continue;
else if (a[i])
{
ans = ans * sb[i] % mod;
}
else if (b[i])
{
ans = ans * sa[i] % mod;
}
else
{
ans = ans * ((sa[i] * sb[i] - n * m + i) % mod) % mod;
}
}
printf("%lld\n", ans);
}
| 0 |
#include<bits/stdc++.h>
#define LL long long
using namespace std;
const int N=505;
int n,p[N<<1],len;
LL a[N][N];
bool b[10005];
LL gcd(LL x,LL y) {
return y == 0 ? x : gcd(y,x % y);
}
int main(){
scanf("%d",&n);
if(n==2){
puts("4 7");
puts("23 10");
return 0;
}
for(int i=0;i<=n+1;i++)
for(int j=0;j<=n+1;j++)
a[i][j]=1LL;
for(int i=2;len<2*n;i++){
if(!b[i])p[++len]=i;
for(int j=1;j<=len&&p[j]*i<=10000;j++){
b[p[j]*i]=1;
if(i%p[j]==0)break;
}
}
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if((i+j)%2==0)a[i][j]*=p[(i+j)>>1];
}
}
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if((i+j)%2==0)a[i][j]*=p[((i-j+n+1)>>1)+n];
}
}
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if((i+j)%2){
LL u=a[i+1][j]/gcd(a[i+1][j],a[i][j+1])*a[i][j+1];
LL v=a[i-1][j]/gcd(a[i-1][j],a[i][j-1])*a[i][j-1];
a[i][j]=u/gcd(u,v)*v+1LL;
}
}
}
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
printf("%lld ",a[i][j]);
}
puts("");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt;
int head[205], Next[50005], vet[50005];
void add(int x, int y) {
cnt++;
Next[cnt] = head[x];
head[x] = cnt;
vet[cnt] = y;
}
struct node {
int id;
long long dis;
friend bool operator<(node a, node b) { return a.dis > b.dis; }
};
long long dis[205], f[205];
priority_queue<node> q;
void dij(int s) {
memset(dis, 0x3f, sizeof(dis));
memset(f, 0, sizeof(f));
dis[s] = 0;
f[s] = 1;
q.push((node){s, 0});
while (!q.empty()) {
node t = q.top();
q.pop();
if (t.dis > dis[t.id]) continue;
for (int i = head[t.id]; i; i = Next[i]) {
int v = vet[i];
if (dis[v] > t.dis + 1) {
dis[v] = t.dis + 1;
f[v] = f[t.id];
q.push((node){v, dis[v]});
} else if (dis[v] == t.dis + 1) {
f[v] += f[t.id];
}
}
}
}
int main() {
cin >> n >> m;
int x, y;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
add(x, y), add(y, x);
}
dij(1);
long long ans = f[n], t = f[n], len = dis[n];
for (int i = 2; i < n; i++) {
dij(i);
if (dis[1] + dis[n] == len) ans = max(ans, f[1] * f[n] * 2);
}
printf("%.12lf", 1.0 * ans / t);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int arr[1002], n, i, k, no_op = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
i = 0;
while (arr[i] != 1) {
i++;
}
k = i;
while (k < n) {
if (arr[k] == 0 && k == (n - 1)) break;
if (arr[k] == 1) {
no_op++;
k++;
}
if (arr[k] == 0 && arr[k + 1] == 1) {
no_op += 2;
k = k + 2;
} else if (arr[k] == 0 && arr[k + 1] == 0) {
while (k < n && arr[k] != 1) {
k++;
}
if (k < n) no_op++;
}
}
printf("%d", no_op);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
set<char> a;
set<char>::iterator itr;
for (int i = 0; i < s.size(); i++) {
a.insert(s[i]);
}
itr = a.begin();
cout << ((a.size() % 2 == 0) ? "CHAT WITH HER!" : "IGNORE HIM!");
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int a[100005];
void solve()
{
int n;cin>>n;
int mn=n,mx=0;
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
mn=min(mn,a[i]);
mx=max(mx,a[i]);
}
if(mx-mn>=2)
{
puts("No");
return ;
}
if(mn==mx&&mx==n-1)
{
puts("Yes");
return ;
}
int cnt1=0,cnt2=0;
for(int i=1;i<=n;i++)
if(a[i]==mx-1) cnt1++;
else cnt2++;
int p=mx-cnt1;
if(p*2>cnt2||p<=0)
{
puts("No");
return ;
}
puts("Yes");
}
int main()
{
// freopen("hat.in","r",stdin);
// freopen("hat.out","w",stdout);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int num, i, j, sortt, cart, tt;
char c;
cin >> num >> sortt;
int arr[num][sortt];
i = 0;
while (i < num) {
j = 0;
while (j < sortt) {
cin >> c;
if (c == 'P') {
arr[i][j++] = 0;
} else if (c == 'W') {
arr[i][j++] = 1;
} else {
arr[i][j++] = -1;
}
}
i++;
}
i = 0;
cart = 0;
while (i < num) {
j = 0;
while (j < sortt) {
if (arr[i][j] == 0) {
if (i - 1 >= 0 && arr[i - 1][j] == 1) {
cart++;
arr[i - 1][j] = -1;
} else if (i + 1 < num && arr[i + 1][j] == 1) {
cart++;
arr[i + 1][j] = -1;
} else if (j - 1 >= 0 && arr[i][j - 1] == 1) {
cart++;
arr[i][j - 1] = -1;
} else if (j + 1 < sortt && arr[i][j + 1] == 1) {
cart++;
arr[i][j + 1] = -1;
}
}
j++;
}
i++;
}
cout << cart;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int M, N;
cin >> M >> N;
cout << (N * M) / 2 << endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,M,sum=0;
cin>>N;
vector<int> A(N);
for(int &i:A){
cin>>i;
sum+=i;
}
cin>>M;
while(M--){
int P,X;
cin>>P>>X;
cout<<sum-A[P-1]+X<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 100111, inf = 1000111222;
int n, p[max_n], nxt[max_n], used[max_n], ans[max_n];
vector<int> g[max_n], g2[max_n];
bool dfs(int v) {
if (used[v]) {
return false;
}
used[v] = 1;
for (int to : g[v]) {
if (p[to] == -1) {
p[to] = v;
nxt[v] = to;
return true;
}
}
for (int to : g[v]) {
if (dfs(p[to])) {
p[to] = v;
nxt[v] = to;
return true;
}
}
return false;
}
void dfs2(int v) {
used[v] = 1;
for (int to : g2[v]) {
if (used[to] == 0) {
dfs2(to);
ans[to] = nxt[v];
}
}
}
int main() {
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
scanf("%d", &n);
for (int i = 0; i + 1 < n; ++i) {
int k;
scanf("%d", &k);
g[i].resize(k);
for (int &x : g[i]) {
scanf("%d", &x);
--x;
}
}
memset(nxt, -1, sizeof(nxt));
memset(p, -1, sizeof(p));
for (int run = 1; run; ) {
run = 0;
memset(used, 0, sizeof(used));
for (int i = 0; i + 1 < n; ++i) {
if (nxt[i] == -1 && dfs(i)) {
run = 1;
}
}
}
for (int i = 0; i + 1 < n; ++i) {
if (nxt[i] == -1) {
puts("-1");
return 0;
}
}
int root;
for (int i = 0; i < n; ++i) {
if (p[i] == -1) {
root = i;
break;
}
}
p[root] = n - 1;
nxt[n - 1] = root;
for (int i = 0; i + 1 < n; ++i) {
for (int to : g[i]) {
if (to != nxt[i]) {
g2[p[to]].push_back(i);
}
}
}
memset(used, 0, sizeof(used));
dfs2(n - 1);
for (int i = 0; i < n; ++i) {
if (!used[i]) {
puts("-1");
return 0;
}
}
for (int i = 0; i + 1 < n; ++i) {
printf("%d %d\n", nxt[i] + 1, ans[i] + 1);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111;
pair<int, int> a[N][N];
int res[N][N];
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = make_pair(i, j);
res[i][j] = 0;
}
}
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int row;
scanf("%d", &row);
row--;
pair<int, int> tmp = a[row][0];
for (int j = 0; j + 1 < m; j++) a[row][j] = a[row][j + 1];
a[row][m - 1] = tmp;
}
if (type == 2) {
int col;
scanf("%d", &col);
col--;
pair<int, int> tmp = a[0][col];
for (int j = 0; j + 1 < n; j++) a[j][col] = a[j + 1][col];
a[n - 1][col] = tmp;
}
if (type == 3) {
int row, col, val;
scanf("%d%d%d", &row, &col, &val);
row--, col--;
res[a[row][col].first][a[row][col].second] = val;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%d", res[i][j]);
putchar(j == m - 1 ? '\n' : ' ');
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<long long, long long>;
using vi = vector<long long>;
void slv() {
long long n, m, k;
cin >> n >> m >> k;
for (long long _ = 0; _ < k; _++) {
for (long long i = 0; i < m; i++) {
cout << (n / m) + (i < n % m) << " ";
for (long long j = 0; j < (n + (i < n % m ? m - 1 : 0)) / m; j++) {
cout << ((_ * (n % m) * ((n + m - 1) / m)) % n + i * (n / m) + j +
min(i, n % m)) %
n +
1
<< " ";
}
cout << "\n";
}
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long t;
cin >> t;
for (long long cs = 0; cs < t; cs++) slv();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
long long n;
int q[1000000];
int main() {
cin >> n;
if (n % 3 != 0) {
printf("0\n");
return 0;
}
n /= 3;
int o = 0;
for (int x = 2; (long long)x * x <= n; x++)
if (n % x == 0) {
q[o++] = x;
}
sort(q, q + o);
int ans = 0;
for (int i = 0; i < o && (long long)q[i] * q[i] * q[i] <= n; i++) {
int ab = q[i];
long long nn = n / ab;
for (int j = i; j < o && (long long)q[j] * q[j] <= nn; j++)
if (nn % q[j] == 0) {
int ac = q[j];
int bc = nn / ac;
if ((ab + ac + bc) % 2 == 0) {
int a = (ab + ac - bc) / 2;
int b = (ab + bc - ac) / 2;
int c = (ac + bc - ab) / 2;
if (a > 0 && b > 0 && c > 0 && a <= b && b <= c) {
if (a == b && b == c)
ans++;
else if (a == b || b == c)
ans += 3;
else
ans += 6;
}
}
}
}
cout << ans << endl;
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.