solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (ll i = 0; i < n; i++)
#define re return
#define fi first
#define mp make_pair
#define se second
#define sz(a) (int)a.size()
typedef long long ll;
const ll mod = 1e9 + 7, ma1 = 8, ma = 2 * 16 * 1024;
int n, nm, num[2 * ma];
vector<int> e[100000], reve[100000], use;
vector<int> nu, top, qq;
vector<pair<int, int> > a;
void dfs(int nu) {
use[nu] = 1;
for (int v : e[nu])
if (!use[v])
dfs(v);
top.push_back(nu);
}
void dfs1(int nu) {
use[nu] = 1;
qq.push_back(nu);
for (int v : reve[nu])
if (!use[v])
dfs1(v);
}
void add_edge(int l, int r, int nu) {
if (l > r) re;
if (l % 2) {
e[nu].push_back(num[l]);
reve[num[l]].push_back(nu);
re add_edge(l + 1, r, nu);
}
if (r % 2 == 0) {
e[nu].push_back(num[r]);
reve[num[r]].push_back(nu);
re add_edge(l, r - 1, nu);
}
add_edge(l / 2, r / 2, nu);
}
bool ok(int d) {
//cout << d << "\n";
forn (i, nm) {
reve[i].resize(0);
e[i].resize(0);
}
for (int j = ma - 1; j; j--) {
reve[num[2 * j]].push_back(num[j]);
reve[num[2 * j + 1]].push_back(num[j]);
e[num[j]].push_back(num[2 * j]);
e[num[j]].push_back(num[2 * j + 1]);
}
int j = 0;
forn (i, 2 * n) {
while (j < sz(a) && a[i].fi - a[j].fi > d)
j++;
//cout << j << " " << i << "\n";
add_edge(j + ma, i + ma - 1, (a[i].se ^ 1));
}
j = 2 * n - 1;
for (int i = 2 * n - 1; i >= 0; i--) {
while (j >= 0 && a[j].fi - a[i].fi > d)
j--;
//cout << i << ", " << j << "\n";
add_edge(i + ma + 1, j + ma, (a[i].se ^ 1));
}
// forn (i, nm) {
// cout << i << ", ";
// for (int v : e[i]) {
// cout << v << " ";
// }
// cout << "\n";
// }
use.assign(nm, 0);
top.resize(0);
forn (i, nm) {
if (!use[i])
dfs(i);
}
use.assign(nm, 0);
reverse(top.begin(), top.end());
forn (nu, nm) {
int i = top[nu];
if (!use[i]) {
qq.resize(0);
dfs1(i);
sort(qq.begin(), qq.end());
/*forn (i, sz(qq)) {
cout << qq[i] << " ";
}
cout << "\n";*/
forn (i, sz(qq) - 1) {
if (qq[i] == (qq[i + 1] ^ 1) && qq[i]+ 1 < 2 * n)
re false;
}
}
}
re true;
}
int main() {
iostream::sync_with_stdio(0);
//freopen("a.in", "r", stdin);
cin >> n;
forn (i, n) {
int x, y;
cin >> x >> y;
a.push_back(mp(x, 2 * i));
a.push_back(mp(y, 2 * i + 1));
}
forn (i, 2 * ma) {
num[i] = -1;
}
sort(a.begin(), a.end());
forn (i, 2 * n) {
num[i + ma] = a[i].se;
}
nm = 2 * n;
for (int i = 1; i < 2 * ma; i++) {
if (num[i] == -1) {
num[i] = nm;
nm++;
}
//cout << i << " k " << num[i] << "\n";
}
for (int j = ma - 1; j; j--) {
e[num[j]].push_back(num[2 * j]);
e[num[j]].push_back(num[2 * j + 1]);
}
// cout << ok(3);
// re 0;
int l = -1, r = 1000* 1000 * 1001;
while (r - l > 1) {
int mid = (l + r) / 2;
if (ok(mid))
l = mid;
else
r = mid;
}
cout << r << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 215;
const long long oo = 1e18 + 5;
const long long mod = 1e9 + 7;
bool div11(int b, int d) { return (b + 1) % d == 0; }
bool div3(int b, int d) { return b % d == 1; }
bool div2(int b, int d) {
for (int i = 2; i <= d; i++) {
if (d % i) continue;
if (b % i) return 0;
while (!(d % i)) d /= i;
}
return 1;
}
bool div6(int b, int d) {
vector<int> p;
for (int i = 2; i <= d; i++)
if (!(d % i)) {
int x = 1;
while (!(d % i)) d /= i, x *= i;
p.push_back(x);
}
vector<int> mask(p.size(), 0);
for (int i = 0; i < p.size(); i++) {
if (div2(b, p[i])) mask[i] |= 1;
if (div3(b, p[i])) mask[i] |= 2;
if (div11(b, p[i])) mask[i] |= 4;
if (!mask[i]) return 0;
}
return 1;
}
int b, d;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> b >> d;
if (div2(b, d)) {
cout << "2-type\n";
int sol = 1;
for (int i = 2; i <= d; i++) {
int aux = b, c1 = 0, c2 = 0;
if (!(d % i)) {
while (!(d % i)) d /= i, c2++;
while (!(aux % i)) aux /= i, c1++;
}
if (c1 < c2) sol = max(sol, 1 + (c2 - 1) / c1);
}
cout << sol << '\n';
} else if (div3(b, d))
cout << "3-type\n";
else if (div11(b, d))
cout << "11-type\n";
else if (div6(b, d))
cout << "6-type\n";
else
cout << "7-type\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, k1 = 0, k2 = 0, ans = 0;
int m[100];
int p[100];
cin >> a >> b;
for (int i = 0; i < a; i++) {
cin >> m[i];
if ((k1 == k2) && (k1 != 0)) {
p[ans] = abs(m[i] - m[i - 1]);
ans++;
}
if (m[i] % 2 == 0)
k1++;
else
k2++;
}
sort(p, p + ans);
if (ans == 0) {
cout << 0;
return 0;
}
int q = 0;
int ans2 = 0;
while ((b >= p[q]) && (q < ans)) {
ans2++;
b -= p[q];
q++;
}
cout << ans2;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[50], b[50];
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
memcpy(b, a, sizeof(a));
sort(b, b + n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i] == b[j]) {
if (j == n - 1)
printf("%d", b[0]);
else
printf("%d", b[j + 1]);
break;
}
}
if (i != n - 1) printf(" ");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double Pi = acos(-1);
const long long oo = (long long)(1e17);
vector<int> p;
vector<bool> used;
vector<vector<int>> g;
vector<vector<int>> comp;
vector<vector<int>> idx;
int cnt, n;
void dfs(int u, int com) {
comp[com].push_back(p[u]);
idx[com].push_back(u);
used[u] = 1;
for (int v : g[u])
if (!used[v]) dfs(v, com);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
p.resize(n);
g.resize(n);
for (int i = 0; i < n; i++) cin >> p[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
char x;
cin >> x;
if (x == '1') g[i].push_back(j);
}
used.resize(n);
comp.resize(n);
idx.resize(n);
for (int i = 0; i < n; i++)
if (!used[i]) {
dfs(i, cnt);
cnt++;
}
for (int i = 0; i < cnt; i++) {
sort(comp[i].begin(), comp[i].end());
sort(idx[i].begin(), idx[i].end());
}
vector<int> ans(n);
for (int i = 0; i < cnt; i++)
for (int j = 0; j < comp[i].size(); j++) ans[idx[i][j]] = comp[i][j];
for (int x : ans) cout << x << ' ';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
deque<int> deq;
vector<int> vec;
map<int, int> mp;
for (int i = 0; i < n; i++) {
int in;
cin >> in;
vec.push_back(in);
}
deque<int>::iterator ditr;
int flag = 0;
for (int i = 0; i < n; i++) {
if (!(mp[vec[i]])) {
if (deq.size() == k) {
int d = *(deq.end() - 1);
deq.pop_back();
mp[d] = 0;
}
deq.push_front(vec[i]);
mp[vec[i]]++;
}
}
cout << deq.size() << "\n";
for (ditr = deq.begin(); ditr != deq.end(); ditr++) cout << *ditr << " ";
}
| 2 |
#include<iostream>
using namespace std;
int main()
{
int n,k;
cin>>n>>k;
string s;
cin>>s;
s[k-1]+='a'-'A';
cout<<s;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
long long x, y;
Point() {}
Point(long long _x, long long _y) { x = _x, y = _y; }
Point operator-(const Point &q) const { return Point(x - q.x, y - q.y); }
long long operator&(const Point &q) const { return x * q.y - y * q.x; }
} p[2013];
bool vis[2013];
int per[2013];
string str;
int n;
int main() {
cin >> n;
long long s = -1;
for (int i = 0; i < n; i++) {
scanf("%lld%lld", &p[i].x, &p[i].y);
if (s == -1 || p[i].x < p[s].x || (p[i].x == p[s].x && p[i].y < p[i].y))
s = i;
}
vis[s] = 1, per[0] = s;
cin >> str;
for (int k = 1; k < n; k++) {
long long nex = -1, op = -1;
if (str[k - 1] == 'L') op = 1;
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
if (nex == -1 || ((p[nex] - p[s]) & (p[i] - p[s])) * op < 0) nex = i;
}
per[k] = nex, s = nex, vis[s] = 1;
}
for (int i = 0; i < n; i++)
if (!vis[i]) per[n - 1] = i;
for (int i = 0; i < n; i++) printf("%d ", per[i] + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, i, j;
bool ans = true;
string board[105];
cin >> n;
for (i = 0; i < n; i++) cin >> board[i];
for (i = 0; i < n && ans; i++) {
for (j = 0; j < n && ans; j++) {
x = 0;
if (i - 1 >= 0)
if (board[i - 1][j] == 'o') x++;
if (i + 1 < n)
if (board[i + 1][j] == 'o') x++;
if (j - 1 >= 0)
if (board[i][j - 1] == 'o') x++;
if (j + 1 < n)
if (board[i][j + 1] == 'o') x++;
if (x % 2 != 0) ans = false;
}
}
cout << (ans ? "YES" : "NO") << endl;
return 0;
}
| 1 |
#include <iostream>
int main() {
using namespace std;
int a,b;
cin >> a >> b;
cout << a*b << " " << a*2+b*2 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6;
int main() {
int n, l, r;
cin >> n >> l >> r;
long long mnSum = 0, mxSum = 0, curL = 1, curR = 1;
for (int i = 1; i <= n; i++) {
mnSum += curL;
mxSum += curR;
if (l) curL *= 2, l--;
if (!l) curL = 1;
if (r - 1) curR *= 2, r--;
}
cout << mnSum << " " << mxSum << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, a;
cin >> x;
a = x;
vector<int> v;
do {
v.push_back(x % 2);
x = x / 2;
} while (x > 0);
for (int i = v.size() - 1; i >= 0; i--) {
if (v[i] == 1) {
if (a % 2 == 0) {
cout << i + 1 << " ";
} else {
cout << i + 1 << " ";
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN=100000+5;
int n,m,dp[MAXN],x,y,deg[MAXN],ans;
vector<int> V[MAXN];
int main(){
cin>>n>>m;
for(int i=0;i<m;++i) cin>>x>>y,++deg[y],V[x].push_back(y);
queue<int> Q;
for(int i=1;i<=n;++i) if(!deg[i]) Q.push(i);
while(Q.size()){
int p=Q.front(); Q.pop();
for(int i=0;i<V[p].size();++i){
--deg[V[p][i]],dp[V[p][i]]=max(dp[V[p][i]],dp[p]+1),ans=max(ans,dp[V[p][i]]);
if(!deg[V[p][i]]) Q.push(V[p][i]);
}
}
cout<<ans<<'\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string str;
cin >> str;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
reverse(str.begin(), str.begin() + i);
}
}
cout << str;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i = 0, s = 2015;
printf("2000\n");
for (i = 1; i <= 1000; i++) printf("%d 1 %d 2\n", i, i);
for (i = 1000; i >= 1; i--) printf("%d 1 %d 2\n", i, i);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N;
int in[502], out[502], W[502], S[502], V[502];
int getmax[502][1002];
vector<int> in1[502], in2[502];
int getMax(int x, int w) {
if (getmax[x][w] != -1) return getmax[x][w];
if (w < W[x]) return 0;
getmax[x][w] = V[x];
vector<pair<int, int> > rem1, rem2;
for (auto i : in1[x]) {
int val = getMax(i, min(w - W[x], S[x]));
if (val != 0) rem1.push_back(make_pair(i, val));
}
for (auto i : in2[x]) {
int val = getMax(i, min(w - W[x], S[x]));
if (val != 0) rem2.push_back(make_pair(i, val));
}
vector<int> D(N + 1);
int maxadd = 0, till = 0, maxtill = 0;
for (int i = 0; i < int(rem1.size()); ++i) {
D[rem1[i].first] = rem1[i].second;
while (till < int(rem2.size()) &&
out[rem2[till].first] <= in[rem1[i].first]) {
maxtill = max(maxtill, D[rem2[till].first]);
++till;
}
D[rem1[i].first] += maxtill;
maxadd = max(maxadd, D[rem1[i].first]);
}
getmax[x][w] = V[x] + maxadd;
return getmax[x][w];
}
bool compare1(const int& i1, const int& i2) { return in[i1] < in[i2]; }
bool compare2(const int& i1, const int& i2) { return out[i1] < out[i2]; }
int main() {
cin.sync_with_stdio(false);
cin >> N >> S[0];
for (int i = 1; i <= N; ++i) cin >> in[i] >> out[i] >> W[i] >> S[i] >> V[i];
in[0] = 0, out[0] = 2 * N + 1;
for (int i = 0; i <= N; ++i) {
for (int j = 1; j <= N; ++j)
if (i != j && in[i] <= in[j] && out[j] <= out[i]) {
in1[i].push_back(j);
in2[i].push_back(j);
}
sort(in1[i].begin(), in1[i].end(), compare1);
sort(in2[i].begin(), in2[i].end(), compare2);
}
memset(getmax, -1, sizeof(getmax));
cout << getMax(0, S[0]) << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
int ans;
bool col;
string s, t;
int d1, d2, d3;
int main() {
cin >> d1 >> d2 >> d3;
cout << min(min(d1 + d2 + d3, d1 * 2 + d3 * 2),
min(d2 * 2 + d3 * 2, 2 * d1 + 2 * d2));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int p[105], q[105], s[105], t[105];
int n, k, t1, t2, i;
void c1() {
for (int j = 1; j <= n; j++) t[j] = s[q[j]];
for (int j = 1; j <= n; j++) s[j] = t[j];
}
void c2() {
for (int j = 1; j <= n; j++) t[q[j]] = s[j];
for (int j = 1; j <= n; j++) s[j] = t[j];
}
int main() {
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) scanf("%d", &q[i]);
for (i = 1; i <= n; i++) {
scanf("%d", &p[i]);
s[i] = i;
}
for (t1 = 0; t1 <= k; t1++) {
for (i = 1; i <= n && s[i] == p[i]; i++)
;
if (i == n + 1) break;
c1();
}
for (i = 1; i <= n; i++) s[i] = i;
for (t2 = 0; t2 <= k; t2++) {
for (i = 1; i <= n && s[i] == p[i]; i++)
;
if (i == n + 1) break;
c2();
}
if (t1 == 1 && t2 == 1 && k > 1)
cout << "NO" << endl;
else if (((k - t1) % 2 == 0 && t1) || ((k - t2) % 2 == 0 && t2))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
using Lint=long long;
const int INF=1e9;
int main()
{
int H,W,h,w; cin>>H>>W>>h>>w;
if(H%h==0 and W%w==0){ cout<<"No"<<endl; return 0; }
cout<<"Yes"<<endl;
Lint sum=0;
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
int x=0;
if(i%h==0 and j%w==0) x=INF-1;
else if(i%h==h-1 and j%w==w-1) x=-INF;
cout<<x<<(j==W-1? '\n':' ');
sum+=x;
}
}
// cout<<sum<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const long long LINF = INF * (long long)INF;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> ch(n);
for (int i = (0); i < (n); i++) {
ch[i] = i;
}
int ind = 0;
for (int i = (0); i < (k); i++) {
int a;
cin >> a;
int toRemove = (ind + a) % ch.size();
if (toRemove == ch.size() - 1) {
ind = 0;
} else {
ind = toRemove;
}
cout << ch[toRemove] + 1 << " ";
ch.erase(ch.begin() + toRemove);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e9 + 7;
long long n, m, k;
long long dp[105][100005];
long long c[105];
long long a[105][105];
int POW(long long a, long long pow) {
long long r = 1;
while (pow) {
if (pow % 2 == 1) {
r = r * a;
}
a = a * a;
pow /= 2;
r %= N;
a %= N;
}
return r;
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) {
c[i] = (m) / n;
if (m % n >= i) {
c[i]++;
}
}
a[0][0] = 1;
for (int i = 1; i <= 100; ++i) {
a[i][0] = a[i][i] = 1;
for (int j = 1; j < i; ++j) {
a[i][j] = (a[i - 1][j] + a[i - 1][j - 1]) % N;
}
}
long long s[105][105];
for (int i = 0; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
s[i][j] = POW(a[n][i], c[j]);
}
}
dp[0][0] = 1;
for (int i = 1; i <= 100; ++i) {
for (int j = 0; j <= min(n * i, k); ++j) {
for (int l = 0; l <= n && j >= l; ++l) {
dp[i][j] += (dp[i - 1][j - l] * s[l][i]) % N;
dp[i][j] %= N;
}
}
}
cout << dp[n][k] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
long long int n, i, s = 0, x, f, m;
cin >> n;
long long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
cin >> x >> f;
for (i = 0; i < n; i++) {
if (a[i] > x) {
m = a[i] - x;
if (m % (f + x) == 0)
s = s + m / (f + x);
else
s = s + m / (f + x) + 1;
}
}
cout << s * f;
return 0;
}
| 6 |
#include "bits/stdc++.h"
using namespace std;
int main(){
int N;
cin>>N;
cout<<((N/10)%111==0||(N%1000)%111==0?"Yes":"No")<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int M, K, N, S, Kin, cnt;
int a[500010];
int s[500010];
int b[500010];
int t[500010];
int main() {
scanf("%d%d%d%d", &M, &K, &N, &S);
for (int i = 1; i <= M; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= S; ++i) {
int t;
scanf("%d", &t);
s[t]++;
if (s[t] == 1) ++Kin;
}
int st = 1, en = 1;
b[a[1]]++;
if (b[a[1]] == s[a[1]]) ++cnt;
while (1) {
if (cnt == Kin && st - en + 1 >= K) {
if (st - en + 1 >= K)
if ((long long)(st - en + 1 - K + (en - 1) % K) <=
M - ((long long)N * K)) {
printf("%d\n", st - en + 1 - K + (en - 1) % K);
for (int i = 1; i <= (en - 1) % K; ++i) printf("%d ", i);
int tot = 0;
for (int i = en; i <= st; ++i) {
if (tot == st - en + 1 - K) break;
t[a[i]]++;
if (t[a[i]] > s[a[i]]) {
printf("%d ", i);
tot++;
}
}
puts("");
return 0;
}
b[a[en]]--;
if (b[a[en]] == s[a[en]] - 1) --cnt;
en++;
} else {
st++;
if (st > M) break;
b[a[st]]++;
if (b[a[st]] == s[a[st]]) ++cnt;
}
}
printf("-1\n");
}
| 4 |
#include <iostream>
#include <algorithm>
#include <vector>
int main()
{
int n; std::cin >> n;
int k; std::cin >> k;
int* T = new int[k];
for (int i=0; i<k; i++) std::cin >> T[i];
std::sort(T, T+k);
for (long long int i=0; i<(1<<(n-k)); i++) {
long long int index = 0;
std::vector<int> output;
long long int d = i;
for (int j=0, t=0; j<n; j++) {
if (k>0 && j==T[t]) {
output.push_back(j);
index += (1<<j);
t++;
}
else {
if ( (d&1) == 1 ) {
output.push_back(j);
index += (1<<j);
}
d >>= 1;
}
}
std::cout << index << ":";
for (std::vector<int>::iterator it = output.begin(); it != output.end(); ++it) std::cout << " " << *it;
std::cout << std::endl;
}
delete[] T;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int maxn = 1e6 + 5;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-8;
const double PI = acos(-1.0);
void header() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void solve() {
long long k;
cin >> k;
cout << "3 3\n";
cout << (1ll << 17) + k << " " << k << " " << k << '\n';
cout << (1ll << 17) << " " << (1ll << 17) << " " << (1ll << 17) + k << '\n';
cout << (1ll << 17) << " " << (1ll << 17) << " " << k << '\n';
}
int main() {
header();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, c = 0, n;
cin >> n;
char s[n];
for (i = 0; i < n; i++) {
cin >> s[i];
}
for (i = 0; i <= n; i++) {
if (s[i] == '1')
c++;
else {
cout << c;
c = 0;
}
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define MOD 998244353
using namespace std;
typedef long long ll;
ll best[3030][3030], a[3030], N, S;
int main() {
cin>>N>>S;
for(int i=1;i<=N;++i) {
cin>>a[i];
}
best[0][0] = 1;
for(int i=1;i<=N;++i) {
for(int j=0;j<=S;++j) {
best[i][j] = 2LL*best[i-1][j];
if(j >= a[i]) {
best[i][j] += best[i-1][j-a[i]];
}
best[i][j] %= MOD;
}
}
cout<<best[N][S]<<"\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e9 + 7;
long long n, m, ans;
void upd(long long &x, long long v) { x = (x + v) % Mod; }
int main() {
cin >> n >> m;
ans = (n % Mod) * (m % Mod) % Mod;
for (long long i = 1, j; i <= m; i = j + 1) {
long long now = n / i;
if (now > 0) {
j = n / now;
} else {
break;
}
j = min(j, m);
long long x = (j - i + 1);
long long y = (i + j);
if (x % 2 == 0) {
x /= 2;
} else {
y /= 2;
}
x %= Mod;
y %= Mod;
upd(ans, -x * y % Mod * (now % Mod) % Mod + Mod);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n][m], c[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
c[i][j] = 0;
}
}
for (int j = 0; j < m; j++) {
if (j == 0)
c[0][j] = a[0][j];
else
c[0][j] = a[0][j] + c[0][j - 1];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < m; j++) {
if (j == 0)
c[i][j] = (c[i - 1][j] + a[i][j]);
else {
c[i][j] = max(c[i - 1][j], c[i][j - 1]);
c[i][j] += a[i][j];
}
}
}
for (int j = 0; j < n; j++) {
cout << c[j][m - 1] << " ";
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int T, n;
string s;
int main() {
scanf("%d", &T);
for (int tc = 1; tc <= T; tc++) {
cin >> n >> s;
vector<int> v;
for (int i = 0, j = 0; i < n; i = j) {
while (j < n && s[i] == s[j]) j++;
v.push_back(j - i);
}
int ans = 0;
n = v.size();
for (int i = 0, j = 0; i < n; i++) {
while (j < n && v[j] <= 1) j++;
if (j < n)
v[j]--;
else
v[i++] = 0;
if (i < n) v[i] = 0;
ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int b, k;
int a[100005];
int cnt_odd = 0, cnt_even = 0;
ios_base::sync_with_stdio(false);
cin >> b >> k;
for (int i = 0; i < k; ++i) {
cin >> a[i];
if (a[i] % 2)
cnt_odd++;
else
cnt_even++;
}
if (b % 2 == 0) {
if (a[k - 1] % 2 == 1) {
cout << "odd";
return 0;
} else {
cout << "even";
return 0;
}
} else {
if (cnt_odd % 2 == 0) {
cout << "even";
} else {
cout << "odd";
}
}
return 0;
}
| 1 |
#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
int n,k;
int dp[102][4][2];
int yt[102];
void debug(){
for(int d=0;d<=n;d++){
printf("%2d ",d);
for(int i=1;i<=3;i++){
printf("(%5d,%5d) ",d,dp[d][i][0],dp[d][i][1]);
}
cout << endl;
}
}
int solve(){
if(yt[1] == 0){
dp[1][1][0] = dp[1][2][0] = dp[1][3][0] = 1;
}else{
dp[1][yt[1]][0] = 1;
}
for(int d=2;d<=n;d++){
for(int i=1;i<=3;i++){
if(yt[d] != 0 && yt[d] != i){ dp[d][i][0] = dp[d][i][1] = 0; continue; }
dp[d][i][1] = dp[d-1][i][0] % 10000;
dp[d][i][0] = 0;
for(int j=1;j<=3;j++){
if(i==j)continue;
dp[d][i][0] += (dp[d-1][j][0] + dp[d-1][j][1]) % 10000;
}
}
}
int ans = 0;
for(int i=1;i<=3;i++){
ans += (dp[n][i][0] + dp[n][i][1]) % 10000;
}
return ans % 10000;
}
int main(){
cin >> n >> k;
int a,b;
for(int i=0;i<k;i++){
cin >> a >> b;
yt[a] = b;
}
cout << solve() << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
int t = 1;
while (t--) {
string s;
long long a, c = 0;
cin >> s;
for (int i = 0; i < s.size(); i++)
if (s[i] % 4 == 0) c++;
for (int i = 0; i < s.size() - 1; i++) {
if ((s[i] * 10 + s[i + 1]) % 4 == 0) c += i + 1;
}
cout << c << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int a, b, c, d;
cin >> a >> b >> c >> d;
if (a > b && c > d) {
if ((a - b) % (c - d) == 0) {
cout << b + (((a - b) / (c - d)) * c) << endl;
} else {
cout << b + (((a - b) / (c - d) + 1) * c) << endl;
}
} else if (a <= b) {
cout << b << endl;
} else if (c <= d) {
cout << -1 << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
std::string s;
std::cin >> s;
std::string s2("hello ");
int p = 0;
for (char c : s) {
if (p < 5 && s2.at(p) == c) {
p++;
}
}
if (s2.at(p) == ' ') {
std::cout << "YES";
} else
std::cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50005, M = N * 17, mod = 1e9 + 7;
inline void gmin(int &x, int y) {
if (x > y) x = y;
}
inline void gmax(int &x, int y) {
if (x < y) x = y;
}
inline void ch(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
struct node {
int to, next, cap;
} p[M << 1];
int n, m, S, T, tot, cnt, head[M], st[M];
int dep[N], dp[N][17], num[N][17], fa[N];
bool vis[M];
vector<int> g[N], f[N], res;
queue<int> q;
void add(int x, int y, int z) {
p[++tot] = (node){y, head[x], z};
head[x] = tot;
p[++tot] = (node){x, head[y], 0};
head[y] = tot;
}
bool bfs() {
memset(st, 0, sizeof(st));
q.push(S);
st[S] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = head[x]; i; i = p[i].next) {
if (!p[i].cap) continue;
int y = p[i].to;
if (st[y]) continue;
q.push(y);
st[y] = st[x] + 1;
}
}
return st[T] > 0;
}
int dfs(int x, int f) {
if (x == T) return f;
int r = 0;
for (int i = head[x]; i; i = p[i].next) {
if (!p[i].cap) continue;
int y = p[i].to;
if (st[y] != st[x] + 1) continue;
int tmp = dfs(y, min(f - r, p[i].cap));
p[i].cap -= tmp;
p[i ^ 1].cap += tmp;
r += tmp;
if (r == f) break;
}
if (!r) st[x] = -2;
return r;
}
int dinic() {
int ans = 0, t;
while (bfs())
while (t = dfs(S, 0x3f3f3f)) ans += t;
return ans;
}
void dfs(int x) {
vis[x] = 1;
for (int i = 0; i < g[x].size(); i++) {
int y = g[x][i];
if (vis[y]) continue;
dep[y] = dep[x] + 1;
dp[y][0] = x;
fa[y] = f[x][i];
dfs(y);
}
}
void search(int x) {
if (vis[x]) return;
vis[x] = 1;
for (int i = head[x]; i; i = p[i].next)
if (p[i].cap) search(p[i].to);
}
void print(vector<int> a) {
sort(a.begin(), a.end());
printf("%d", (int)a.size());
for (auto i : a) printf(" %d", i);
puts("");
}
int main() {
tot = 1;
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
f[x].push_back(i);
f[y].push_back(i);
}
dfs(1);
for (int j = 1; j < 15; j++)
for (int i = 1; i <= n; i++) dp[i][j] = dp[dp[i][j - 1]][j - 1];
S = 0;
T = n * 16 + m + 10000;
cnt = m;
for (int i = 1; i <= n; i++)
if (dp[i][0]) num[i][0] = ++cnt, add(cnt, T, 1);
for (int j = 1; j < 15; j++)
for (int i = 1; i <= n; i++) {
if (!dp[i][j]) continue;
num[i][j] = ++cnt;
add(cnt, num[i][j - 1], 0x3f3f3f);
add(cnt, num[dp[i][j - 1]][j - 1], 0x3f3f3f);
}
for (int i = 1; i <= m; i++) {
add(S, i, 1);
int x, y, t;
scanf("%d%d", &x, &y);
if (dep[x] < dep[y]) swap(x, y);
t = dep[x] - dep[y];
for (int j = 0; j < 15; j++)
if (t & (1 << j)) add(i, num[x][j], 0x3f3f3f), x = dp[x][j];
if (x == y) continue;
for (int j = 14; ~j; j--)
if (dp[x][j] != dp[y][j])
add(i, num[x][j], 0x3f3f3f), add(i, num[y][j], 0x3f3f3f), x = dp[x][j],
y = dp[y][j];
add(i, num[x][0], 0x3f3f3f), add(i, num[y][0], 0x3f3f3f);
}
printf("%d\n", dinic());
memset(vis, 0, sizeof(vis));
search(S);
res.clear();
for (int i = 1; i <= m; i++)
if (!vis[i]) res.push_back(i);
print(res);
res.clear();
for (int i = 1; i <= n; i++)
if (dp[i][0] && vis[num[i][0]]) res.push_back(fa[i]);
print(res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 2000;
long long c[maxn], ans = -0x7fffffff, ansi, ansj, a[maxn], b[maxn], top, bot;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] < 0) {
b[top++] = i;
c[i] = c[i - 1];
} else
c[i] = c[i - 1] + a[i];
}
for (int i = 1; i <= n - 1; i++)
for (int j = n; j > i; j--) {
long long sum = 0;
if (a[i] == a[j]) {
if (a[i] < 0) {
sum = c[j] - c[i - 1] + a[i] * 2;
} else
sum = c[j] - c[i - 1];
if (sum > ans) {
ans = sum;
ansi = i;
ansj = j;
}
break;
}
}
while (bot < top && b[bot] <= ansi) bot++;
while (top > 0 && b[top - 1] >= ansj) top--;
cout << ans << ' ' << top - bot + ansi - 1 + n - ansj << endl;
for (int i = 1; i < ansi; i++) cout << i << ' ';
for (int i = bot; i < top; i++) cout << b[i] << ' ';
for (int i = ansj + 1; i <= n; i++) cout << i << ' ';
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main(){
int d,n,i,j;
cin >> d >> n;
if(n == 100)n++;
j = 1;
for(i = 0;i < d;i++) j *= 100;
n *= j;
cout << n << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9223372036854775807ll;
const int inf = 2147483647, dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
pair<int, int> a, b, c;
bool ok[1005][1005], ok2[1005][1005], ok3[1005][1005];
vector<pair<int, int> > sol;
bool check(pair<int, int> x) {
return x.first >= 0 && x.first <= 1000 && x.second >= 0 && x.second <= 1000 &&
!ok2[x.first][x.second];
}
bool isinside(pair<int, int> x, pair<int, int> y, pair<int, int> c) {
if (c.first >= min(x.first, y.first) && c.first <= max(x.first, y.first) &&
c.second >= min(x.second, y.second) &&
c.second <= max(x.second, y.second))
return true;
return false;
}
pair<int, int> lee(pair<int, int> start) {
memset(ok2, 0, sizeof(ok2));
queue<pair<int, int> > q;
ok2[start.first][start.second] = 1;
q.push(start);
while (!q.empty()) {
pair<int, int> now = q.front();
q.pop();
for (int d = 0; d < 4; ++d) {
pair<int, int> nxt = now;
nxt.first += dx[d];
nxt.second += dy[d];
if (check(nxt)) {
if (ok[nxt.first][nxt.second]) return nxt;
ok2[nxt.first][nxt.second] = 1;
q.push(nxt);
}
}
}
return {0, 0};
}
void add(pair<int, int> x) {
if (!ok3[x.first][x.second]) {
ok3[x.first][x.second] = 1;
sol.push_back(x);
}
}
void addsol(pair<int, int> x, pair<int, int> y) {
if (x.first > y.first) swap(x, y);
for (int i = x.first; i <= y.first; ++i) add(make_pair(i, x.second));
int xx = y.first;
for (int i = min(x.second, y.second); i <= max(x.second, y.second); ++i)
add(make_pair(xx, i));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> a.first >> a.second >> b.first >> b.second >> c.first >> c.second;
if (!isinside(b, c, a)) {
} else if (!isinside(a, c, b)) {
pair<int, int> x = a;
pair<int, int> y = b;
pair<int, int> z = c;
a = y;
b = x;
c = z;
} else {
pair<int, int> x = a;
pair<int, int> y = b;
pair<int, int> z = c;
a = z;
b = x;
c = y;
}
for (int i = min(b.first, c.first); i <= max(b.first, c.first); ++i)
for (int j = min(b.second, c.second); j <= max(b.second, c.second); ++j)
ok[i][j] = 1;
pair<int, int> now = lee(a);
addsol(a, now);
addsol(b, now);
addsol(now, c);
cout << sol.size() << "\n";
for (auto x : sol) cout << x.first << " " << x.second << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 110;
int x[MAX_N], N, nr[MAX_N];
int main() {
cin >> N;
for (int i = 1; i <= N; ++i) cin >> x[i];
sort(x + 1, x + N + 1);
int l = 1, r = N, ans = 0;
while (l <= r) {
int mid = (l + r) / 2, aux = 0, curr = 1;
bool ev = true;
for (int i = N; i >= N - mid + 1; --i) nr[++aux] = x[i];
for (int i = N - mid; i >= 1 && ev; --i) {
if (nr[curr] == 0)
ev = false;
else {
--nr[curr];
if (x[i] < nr[curr]) nr[curr] = x[i];
}
++curr;
if (curr > mid) curr = 1;
}
if (ev) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
cout << ans;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define MAX_N 111111
typedef long long int ll;
int W,H;int N;
ll A[MAX_N];ll B[MAX_N];
int main()
{
scanf("%d%d%d",&W,&H,&N);
for(int i=0;i<N;i++){
scanf("%lld%lld",&A[i],&B[i]);
}
if(N&1){
int n=N/2;ll x,y;vector<ll>X,Y;
for(int i=0;i<N;i++){
X.pb(A[i]);
Y.pb(B[i]);
}
sort(X.begin(),X.end());
sort(Y.begin(),Y.end());
x=X[n];y=Y[n];
ll ans=0;
ll M=0;
for(int i=0;i<N;i++){
M=max(M,abs(x-A[i])+abs(y-B[i]));
ans+=abs(x-A[i]);ans+=abs(y-B[i]);
}
printf("%lld\n%lld %lld\n",2*ans-M,x,y);
}
else{
int n=(N-1)/2;ll x[2],y[2];vector<ll>X,Y;
for(int i=0;i<N;i++){
X.pb(A[i]);
Y.pb(B[i]);
}
sort(X.begin(),X.end());
sort(Y.begin(),Y.end());
for(int i=0;i<2;i++){
x[i]=X[n+i];y[i]=Y[n+i];
}
ll ans[4]={0};
for(int j=0;j<2;j++){
for(int k=0;k<2;k++){
ll M=0;
for(int i=0;i<N;i++){
M=max(abs(x[j]-A[i])+abs(y[k]-B[i]),M);
ans[j*2+k]+=abs(x[j]-A[i]);ans[j*2+k]+=abs(y[k]-B[i]);
}
ans[j*2+k]*=2;
ans[j*2+k]-=M;
}
}
ll C=min(min(ans[0],ans[1]),min(ans[2],ans[3]));
printf("%lld\n",C);
for(int i=0;i<4;i++){
//printf("ans[%d]=%lld\n",i,ans[i]);
if(C==ans[i]){
printf("%lld %lld\n",x[i/2],y[i%2]);
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int mn = INT_MAX, mx = INT_MIN, amaz = 0;
for (int i = 0; i < n; i++) {
if (i != 0) {
if (arr[i] > mx) {
amaz++;
mx = arr[i];
}
if (arr[i] < mn) {
amaz++;
mn = arr[i];
}
}
if (i == 0) {
mx = arr[i];
mn = arr[i];
}
}
cout << amaz;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
const int INF = 1e9;
const int N = 2e6;
inline long long mul(long long a, long long b) {
long long tmp = (a * b - (long long)((long double)a / MOD * b + 1e-8) * MOD);
return tmp < 0 ? tmp + MOD : tmp;
}
long long qpow(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = mul(ret, a);
a = mul(a, a);
b >>= 1;
}
return ret;
}
void fwt_xor(long long a[], int n, int opt) {
for (int h = 1; h < n; h <<= 1)
for (int i = 0, p = h << 1; i < n; i += p)
for (int j = i; j < i + h; j++) {
long long x = a[j], y = a[j + h];
a[j] = (x + y >> opt) % MOD;
a[j + h] = (x - y + MOD >> opt) % MOD;
}
}
long long a[N], c[N];
int b[N];
int main() {
long long t;
int m, p;
scanf("%d%I64d%d", &m, &t, &p);
int n = 1 << m;
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
for (int i = 0; i <= m; i++) scanf("%d", &b[i]);
for (int i = 0; i < n; i++) c[i] = b[__builtin_popcount(i)];
MOD = (long long)p * n;
fwt_xor(a, n, 0);
fwt_xor(c, n, 0);
for (int i = 0; i < n; i++) {
a[i] = mul(a[i], qpow(c[i], t));
}
fwt_xor(a, n, 1);
for (int i = 0; i < n; i++) printf("%I64d\n", a[i] % p);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const int MAX = 5 * 1000 + 47;
const int MOD = 1000 * 1000 * 1000 + 7;
int A[10][10];
int P[10];
bool has(int i, int val) {
for (int j = (0); j < (6); j++) {
if (A[i][j] == val) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (6); j++) {
cin >> A[i][j];
}
}
int ans = -1;
for (int k = (1); k < (1001); k++) {
bool can = false;
for (int i = (0); i < (n); i++) {
P[i] = i;
}
do {
int x = k;
int ind = 0;
bool is = true;
while (x) {
if (!has(P[ind], x % 10)) {
is = false;
break;
}
ind++;
x /= 10;
}
if (is) {
can = true;
break;
}
} while (next_permutation(P, P + n));
if (!can) {
ans = k;
break;
}
}
cout << ans - 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Size = 1024;
const int mod2 = 998244353;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int maxn = 4e5 + 15;
const int base = 307;
long long a[maxn];
map<long long, long long> mp;
int main() {
long long n;
scanf("%lld", &n);
long long ans = 0;
for (long long i = 1; n >= i; i++) {
scanf("%lld", &a[i]);
ans += mp[a[i]];
for (long long j = 0; 40 >= j; j++) {
long long bit = (1ll << j);
mp[bit - a[i]]++;
}
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 1e5;
int n, eu[mxN], ev[mxN], ans[mxN];
vector<int> adj[mxN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i < n; ++i) {
cin >> eu[i] >> ev[i], --eu[i], --ev[i];
adj[eu[i]].push_back(i);
adj[ev[i]].push_back(i);
}
for (int i = 0; i < n; ++i) {
if (adj[i].size() <= 2) continue;
memset(ans, -1, 4 * n);
for (int j = 0; j < 3; ++j) ans[adj[i][j]] = j;
for (int i = 1, j = 3; i < n; ++i) {
if (ans[i] < 0) ans[i] = j++;
cout << ans[i] << "\n";
}
return 0;
}
for (int i = 1; i < n; ++i) cout << i - 1 << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
struct Node {
int l, r, del, s;
} t[MAX * 8];
struct node {
int v, next;
} g[MAX * 2];
int adj[MAX], l[MAX], r[MAX], e, n, m, level[MAX], idx, deg[MAX];
int E[MAX][2], tr[MAX * 2], st, f[MAX], cnt, id[MAX], h[MAX];
void add(int u, int v) {
g[e].v = v;
g[e].next = adj[u];
adj[u] = e++;
}
void dfs(int u, int fa, int d) {
int i, v;
l[u] = ++idx;
level[u] = d;
id[u] = ++cnt;
if (fa == st)
f[u] = u;
else
f[u] = f[fa];
for (i = adj[u]; i != -1; i = g[i].next) {
v = g[i].v;
if (v == fa) continue;
dfs(v, u, d + 1);
}
r[u] = ++idx;
if (fa == st) h[u] = cnt;
}
void up(int i, int del, int high) {
while (i <= high) {
tr[i] += del;
i += i & (-i);
}
}
int read(int i, int low) {
int res = 0;
while (i >= low) {
res += tr[i];
i -= i & (-i);
}
return res;
}
void update(int u, int v, int del) {
if (l[v] < l[u] && r[v] > r[u]) swap(u, v);
up(id[v], del, h[f[v]]);
}
int query(int u, int v) {
if (u == v) return 0;
bool flag = false;
if (l[u] < l[v] && r[u] > r[v]) flag = true;
if (l[v] < l[u] && r[v] > r[u]) {
flag = true;
swap(u, v);
}
if (flag) {
if (u != st) {
int x = read(id[v], id[f[v]]) - read(id[u], id[f[u]]);
if (x == level[v] - level[u])
return level[v] - level[u];
else
return -1;
} else {
int x = read(id[v], id[f[v]]);
if (x == level[v])
return level[v];
else
return -1;
}
} else {
int res = 0, x;
if (u != st) {
x = read(id[u], id[f[u]]);
if (x != level[u]) return -1;
res += level[u];
}
if (v != st) {
x = read(id[v], id[f[v]]);
if (x != level[v]) return -1;
res += level[v];
}
return res;
}
}
int main() {
int i, j, k, ty;
while (scanf("%d", &n) != EOF) {
memset(adj, -1, sizeof(adj));
e = 0;
memset(deg, 0, sizeof(deg));
memset(tr, 0, sizeof(tr));
for (i = 0; i < n - 1; i++) {
scanf("%d%d", &j, &k);
E[i + 1][0] = j;
E[i + 1][1] = k;
add(j, k);
add(k, j);
deg[j]++;
deg[k]++;
}
st = 1;
for (i = 2; i <= n; i++)
if (deg[i] > 2) {
st = i;
break;
}
idx = cnt = 0;
dfs(st, -1, 0);
scanf("%d", &m);
for (i = 1; i <= n; i++) {
if (i != st) {
up(id[i], 1, h[f[i]]);
}
}
while (m--) {
scanf("%d", &ty);
if (ty == 1) {
scanf("%d", &k);
update(E[k][0], E[k][1], 1);
} else if (ty == 2) {
scanf("%d", &k);
update(E[k][0], E[k][1], -1);
} else {
scanf("%d%d", &i, &j);
printf("%d\n", query(i, j));
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int Count(int a) {
int l = 0;
if (a / 10 == 0) {
return 1;
}
while (a / 10) {
l += 1;
a /= 10;
}
return l;
}
int main() {
int n = 0, a = 0, b = 0, c = 0, p = -1;
cin >> a >> b >> c;
int ans = 1;
int bl = Count(b);
for (int i = 1; i <= 1e6; i++) {
int u = Count(a);
if (u + 1 <= bl) a *= 10;
if (a < b && u == bl) a *= 10;
int h = a / b;
if (h == c) {
p = i;
break;
}
a -= b * h;
}
cout << p << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void printarray(long long int arr[], long long int n) {
for (long long int i = 0; i < n; i++) {
printf("%I64d ", arr[i]);
}
printf("\n");
}
int main() {
int n;
scanf("%d", &n);
pair<int, int> ap[n], bp[n];
for (int i = 0; i < n; i++) {
scanf("%d", &ap[i].first);
ap[i].second = i;
}
for (int i = 0; i < n; i++) {
scanf("%d", &bp[i].first);
bp[i].second = i;
}
sort(ap, ap + n);
sort(bp, bp + n);
int ans[n];
for (int i = 0; i < n; i++) {
ans[bp[i].second] = ap[n - 1 - i].first;
}
for (int i = 0; i < n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int n, k;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int i;
int bons = 0;
cin >> n >> k;
if (n == 2) {
}
if (k >= n) {
cout << -1 << '\n';
} else {
cout << n - k << " ";
for (i = 1; i <= n - k - 1; i++) {
cout << i << " ";
bons++;
}
for (i = n - k + 1; i <= n; i++) {
cout << i << " ";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,d;
cin >> N;
map<int,int> mp;
for(int i=0; i<N; ++i){
cin >> d;
mp[d]++;
}
cin >> N;
for(int i=0; i<N; ++i){
cin >> d;
if(--mp[d]<0){
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 0 |
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
vector<vector<int> > G;
vector<bool> used;
vector<int> rings;
int rec(int pos)
{
used[pos] = true; int ret = 1;
for(int i = 0; i < rings[pos]; i++)
{
if(!used[G[pos][i]])
{
ret = max(ret, rec(G[pos][i]) + 1);
}
}
used[pos] = false;
return ret;
}
int main()
{
int N, A, B;
while(true)
{
scanf("%d", &N);
if(N == 0) { break; }
G = vector<vector<int> >(100, vector<int>());
used = vector<bool>(100);
rings = vector<int>(100);
for(int i = 0; i < N; i++)
{
scanf("%d", &A); A--;
scanf("%d", &B); B--;
G[A].push_back(B);
G[B].push_back(A);
}
for(int i = 0; i < 100; i++)
{
rings[i] = G[i].size();
}
int nodes = 0;
for(int i = 0; i < 100; i++)
{
if(rings[i])
{
nodes++;
}
}
int ret = 0;
for(int i = 0; i < 100; i++)
{
ret = max(ret, rec(i));
if(ret == nodes) { break; }
}
printf("%d\n", ret);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = (long long)((1e5) + 100);
long long a;
long long n;
long long ans = -1;
signed main() {
cin >> n >> a;
while (n--) {
long long x, y;
cin >> x >> y;
if ((x * 100 + y) <= a * 100) ans = max(ans, (100 - y) % 100);
}
cout << ans << "\n";
}
| 1 |
#include<iostream>
#include<cmath>
using namespace std;
struct record
{
char t;
int w, l;
};
void sort( record* a, int n )
{
for( int i = 0; i < n; i++ )
for( int j = n - 1; j >= i + 1; j-- )
if( a[j].w > a[j-1].w )
{
record temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
}
for( int i = 0; i < n; i++ )
for( int j = n - 1; j >= i + 1; j-- )
if( a[j].w == a[j-1].w && a[j].l < a[j-1].l )
{
record temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
}
}
int main()
{
int n;
char d;
record team[10];
while( cin >> n )
{
if( n == 0 )
break;
for( int i = 0; i < n; i++ )
{
cin >> d;
team[i].t = d;
int a = 0, b = 0;
for( int j = 0; j < n - 1; j++ )
{
cin >> d;
if( d == '0' )
a++;
else if( d == '1' )
b++;
else if( d == '2' );
else;
}
team[i].w = a;
team[i].l = b;
}
sort( team, n );
for( int i = 0; i < n; i++ )
cout << team[i].t << endl;
}
return 0;
}
| 0 |
#include <cstdio>
using namespace std;
typedef long long LL;
const int N = 3010, mod = 1e9 + 7;
LL power(LL a, LL b)
{
LL c = 1;
for (; b; a = a * a % mod, b >>= 1)
if (b & 1) c = c * a % mod;
return c;
}
int n, q, x, y, a[N];
LL inv2 = power(2, mod - 2);
LL f[N][N], g[N][N];
int main()
{
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; ++ i)
scanf("%d", &a[i]);
for (int i = 1; i <= n; ++ i)
for (int j = 1; j <= n; ++ j)
f[i][j] = a[i] > a[j];
for (int i = 1; i <= q; ++ i)
{
scanf("%d %d", &x, &y);
for (int j = 1; j <= n; ++ j)
{
g[x][j] = (f[y][j] * inv2 + f[x][j] * inv2) % mod;
g[j][x] = (f[j][y] * inv2 + f[j][x] * inv2) % mod;
g[y][j] = (f[x][j] * inv2 + f[y][j] * inv2) % mod;
g[j][y] = (f[j][x] * inv2 + f[j][y] * inv2) % mod;
}
g[x][y] = (f[x][y] * inv2 + f[y][x] * inv2) % mod;
g[y][x] = (f[y][x] * inv2 + f[x][y] * inv2) % mod;
for (int j = 1; j <= n; ++ j)
{
f[x][j] = g[x][j], f[j][x] = g[j][x];
f[y][j] = g[y][j], f[j][y] = g[j][y];
}
}
LL ans = 0;
for (int i = 1; i < n; ++ i)
for (int j = i + 1; j <= n; ++ j)
(ans += f[i][j]) %= mod;
printf("%lld\n", ans * power(2, q) % mod);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, num;
};
node e[3001];
int n;
int ans = 0;
int father[3001];
int s[3001];
int outlet[3001];
int sum_out = 0;
bool cmp1(node xx, node yy) { return xx.num < yy.num; }
int find(int x) {
if (father[x] != x) {
father[x] = find(father[x]);
}
return father[x];
}
void unionset(int x, int y) {
father[x] = y;
s[y] += s[x];
outlet[y] += outlet[x];
return;
}
int main() {
int i, j, k;
int xx, yy;
cin >> n;
for (i = 1; i <= n - 1; i++) {
cin >> e[i].x >> e[i].y >> e[i].num;
}
sort(e + 1, e + n, cmp1);
for (i = 1; i <= n; i++) {
father[i] = i;
s[i] = 1;
cin >> outlet[i];
sum_out += outlet[i];
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
ans = e[1].num;
for (i = 1; i <= n - 2; i++) {
xx = find(e[i].x);
yy = find(e[i].y);
unionset(xx, yy);
if (sum_out - outlet[yy] < s[yy]) {
break;
} else {
ans = e[i + 1].num;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int m = n;
long long c = 1;
while (n > 0) {
n /= 10;
c *= 10;
}
c /= 10;
c *= (m / c) + 1;
cout << c - m;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn], b[maxn];
char c[maxn] = {0};
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i]--;
for (int i = 1; i <= n; i++) scanf("%d", &b[i]), b[i]--;
set<int> st1, st2;
vector<int> vt;
for (int i = 1; i <= n; i++) {
if (st1.count(b[i]))
st1.erase(b[i]);
else
st2.insert(b[i]);
if (st2.count(a[i]))
st2.erase(a[i]);
else
st1.insert(a[i]);
if (st1.empty() && st2.empty()) vt.push_back(i);
}
if (vt.size() < k) {
printf("NO\n");
return 0;
}
int l = 0;
char s = 'a';
for (int i = 0; i < vt.size(); i++) {
for (int j = l; j <= vt[i]; j++) c[a[j]] = s;
l = vt[i] + 1;
s += 1;
s = min('z', s);
}
printf("YES\n");
printf("%s\n", c);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int x;
int i;
int main() {
scanf("%d", &x);
if (x == 1)
printf("1\n");
else if (x == 2)
printf("3\n");
else if (x == 3)
printf("5\n");
else {
if (x % 2 == 1) --x;
if (x % 4 == 2) x += 2;
for (i = 1; i < 1000; i += 2) {
int maxi = ((i * i) + 1) / 2;
if (x <= maxi) break;
}
printf("%d\n", i);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
long long mn = 1000000000000;
for (int i = 0; i < n; i++) {
long long H = a[i].first;
long long W = 0;
int cnt = n / 2;
priority_queue<int> q;
for (int j = 0; j < n; j++) {
if (a[j].second > H) {
cnt--;
W += a[j].second;
if (a[j].first > H) W = 2000000000ll;
} else {
W += a[j].first;
if (a[j].first <= H) {
q.push(a[j].first - a[j].second);
}
}
}
while (cnt > 0 && q.top() > 0) {
W -= q.top();
q.pop();
cnt--;
}
if (cnt >= 0) mn = min(mn, W * H);
H = a[i].second;
W = 0;
cnt = n / 2;
q = priority_queue<int>();
for (int j = 0; j < n; j++) {
if (a[j].second > H) {
cnt--;
W += a[j].second;
if (a[j].first > H) W = 2000000;
} else {
W += a[j].first;
if (a[j].first <= H) {
q.push(a[j].first - a[j].second);
}
}
}
while (cnt > 0 && !q.empty() && q.top() > 0) {
W -= q.top();
q.pop();
cnt--;
}
if (cnt >= 0) mn = min(mn, W * H);
}
cout << mn << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int p, id;
int t;
friend bool operator<(const node &a, const node &b) { return a.p > b.p; }
} a[1010], b[1010];
vector<node> ans[1010];
int n, m;
int main() {
scanf("%d%d", &n, &m);
int an = 0, bn = 0;
for (int i = 0; i < n; i++) {
int p, t;
scanf("%d%d", &p, &t);
if (t == 1) {
a[an].p = p;
a[an].t = 1;
a[an++].id = i;
} else {
b[bn].p = p;
b[bn].t = 2;
b[bn++].id = i;
}
}
sort(a, a + an);
for (int i = 0; i < m; i++) ans[i].clear();
for (int i = 0; i < min(an, m); i++) ans[i].push_back(a[i]);
for (int i = m; i < an; i++) ans[m - 1].push_back(a[i]);
if (an < m) {
for (int i = an; i < m; i++) ans[i].push_back(b[i - an]);
for (int i = m - an; i < bn; i++) ans[m - 1].push_back(b[i]);
} else {
for (int i = 0; i < bn; i++) ans[m - 1].push_back(b[i]);
}
double tot = 0;
for (int i = 0; i < m; i++) {
int tmp = -1;
int flag = 0;
for (int j = 0; j < ans[i].size(); j++) {
if (ans[i][j].t == 1) flag = 1;
if (tmp < 0 || ans[i][j].p < tmp) tmp = ans[i][j].p;
tot += ans[i][j].p;
}
if (flag) tot -= tmp * 1.0 / 2.0;
}
printf("%.1lf\n", tot);
for (int i = 0; i < m; i++) {
int k = ans[i].size();
printf("%d", k);
for (int j = 0; j < k; j++) printf(" %d", ans[i][j].id + 1);
puts("");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define rep(i, a, n) for(int i = a; i < n; i++)
#define REP(i, n) rep(i, 0, n)
#define repb(i, a, b) for(int i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
#define int long long
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e12;
int b[100010];
int f[100010];
vector<int> G[100010];
int n, k;
set<int> st;
int dfs(int now){
if(G[now].size() == 0){
st.insert(now);
return 1;
}
int res = INF;
rep(i, 0, G[now].size()){
chmin(res, dfs(G[now][i]) + 1);
}
if(res <= k) st.insert(now);
return res;
}
signed main(){
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
vector<int> a(n);
rep(i, 0, n){
cin >> a[i]; a[i]--;
if(a[i] != -1){
b[a[i]]++;
G[a[i]].push_back(i);
}
}
// set<int> st;
rep(i, 0, n){
if(a[i] == -1){
st.insert(i);
dfs(i);
}
}
// cout << ans << endl;
cout << st.size() << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:36777216")
template <class T>
inline T &RD(T &);
template <class T>
inline void OT(const T &);
inline long long RD() {
long long x;
return RD(x);
}
inline double &RF(double &);
inline double RF() {
double x;
return RF(x);
}
inline char *RS(char *s);
inline char &RC(char &c);
inline char RC();
inline char &RC(char &c) {
scanf(" %c", &c);
return c;
}
inline char RC() {
char c;
return RC(c);
}
template <class T>
inline T &RDD(T &x) {
char c;
for (c = getchar(); c < '-'; c = getchar())
;
if (c == '-') {
x = '0' - getchar();
for (c = getchar(); '0' <= c && c <= '9'; c = getchar())
x = x * 10 + '0' - c;
} else {
x = c - '0';
for (c = getchar(); '0' <= c && c <= '9'; c = getchar())
x = x * 10 + c - '0';
}
return x;
}
inline long long RDD() {
long long x;
return RDD(x);
}
template <class T0, class T1>
inline T0 &RD(T0 &x0, T1 &x1) {
RD(x0), RD(x1);
return x0;
}
template <class T0, class T1, class T2>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2) {
RD(x0), RD(x1), RD(x2);
return x0;
}
template <class T0, class T1, class T2, class T3>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3) {
RD(x0), RD(x1), RD(x2), RD(x3);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6);
return x0;
}
template <class T0, class T1>
inline void OT(const T0 &x0, const T1 &x1) {
OT(x0), OT(x1);
}
template <class T0, class T1, class T2>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2) {
OT(x0), OT(x1), OT(x2);
}
template <class T0, class T1, class T2, class T3>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3) {
OT(x0), OT(x1), OT(x2), OT(x3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4, const T5 &x5) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4, const T5 &x5, const T6 &x6) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);
}
inline char &RC(char &a, char &b) {
RC(a), RC(b);
return a;
}
inline char &RC(char &a, char &b, char &c) {
RC(a), RC(b), RC(c);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d) {
RC(a), RC(b), RC(c), RC(d);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e) {
RC(a), RC(b), RC(c), RC(d), RC(e);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e, char &f) {
RC(a), RC(b), RC(c), RC(d), RC(e), RC(f);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e, char &f, char &g) {
RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g);
return a;
}
inline double &RF(double &a, double &b) {
RF(a), RF(b);
return a;
}
inline double &RF(double &a, double &b, double &c) {
RF(a), RF(b), RF(c);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d) {
RF(a), RF(b), RF(c), RF(d);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d, double &e) {
RF(a), RF(b), RF(c), RF(d), RF(e);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d, double &e,
double &f) {
RF(a), RF(b), RF(c), RF(d), RF(e), RF(f);
return a;
}
inline double &RF(double &a, double &b, double &c, double &d, double &e,
double &f, double &g) {
RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g);
return a;
}
inline void RS(char *s1, char *s2) { RS(s1), RS(s2); }
inline void RS(char *s1, char *s2, char *s3) { RS(s1), RS(s2), RS(s3); }
template <class T0, class T1>
inline void RDD(const T0 &a, const T1 &b) {
RDD(a), RDD(b);
}
template <class T0, class T1, class T2>
inline void RDD(const T0 &a, const T1 &b, const T2 &c) {
RDD(a), RDD(b), RDD(c);
}
template <class T>
inline void RST(T &A) {
memset(A, 0, sizeof(A));
}
template <class T>
inline void FLC(T &A, int x) {
memset(A, x, sizeof(A));
}
template <class T>
inline void CLR(T &A) {
A.clear();
}
template <class T0, class T1>
inline void RST(T0 &A0, T1 &A1) {
RST(A0), RST(A1);
}
template <class T0, class T1, class T2>
inline void RST(T0 &A0, T1 &A1, T2 &A2) {
RST(A0), RST(A1), RST(A2);
}
template <class T0, class T1, class T2, class T3>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
RST(A0), RST(A1), RST(A2), RST(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);
}
template <class T0, class T1>
inline void FLC(T0 &A0, T1 &A1, int x) {
FLC(A0, x), FLC(A1, x);
}
template <class T0, class T1, class T2>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x);
}
template <class T0, class T1, class T2, class T3>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x),
FLC(A6, x);
}
template <class T>
inline void CLR(priority_queue<T, vector<T>, less<T> > &Q) {
while (!Q.empty()) Q.pop();
}
template <class T>
inline void CLR(priority_queue<T, vector<T>, greater<T> > &Q) {
while (!Q.empty()) Q.pop();
}
template <class T0, class T1>
inline void CLR(T0 &A0, T1 &A1) {
CLR(A0), CLR(A1);
}
template <class T0, class T1, class T2>
inline void CLR(T0 &A0, T1 &A1, T2 &A2) {
CLR(A0), CLR(A1), CLR(A2);
}
template <class T0, class T1, class T2, class T3>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);
}
template <class T>
inline void CLR(T &A, int n) {
for (int i = 0; i < int(n); ++i) CLR(A[i]);
}
template <class T>
inline T &SRT(T &A) {
sort(A.begin(), A.end());
return A;
}
template <class T, class C>
inline T &SRT(T &A, C B) {
sort(A.begin(), A.end(), B);
return A;
}
template <class T>
inline T &UNQ(T &A) {
A.resize(unique(SRT(A).begin(), SRT(A).end()) - A.begin());
return A;
}
int MOD = 99990001;
const int INF = 0x3f3f3f3f;
const long long INFF = 1LL << 60;
const double EPS = 1e-9;
const double OO = 1e20;
const double PI = acos(-1.0);
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
template <class T>
inline void checkMin(T &a, const T b) {
if (b < a) a = b;
}
template <class T>
inline void checkMax(T &a, const T b) {
if (a < b) a = b;
}
template <class T>
inline void checkMin(T &a, T &b, const T x) {
checkMin(a, x), checkMin(b, x);
}
template <class T>
inline void checkMax(T &a, T &b, const T x) {
checkMax(a, x), checkMax(b, x);
}
template <class T, class C>
inline void checkMin(T &a, const T b, C c) {
if (c(b, a)) a = b;
}
template <class T, class C>
inline void checkMax(T &a, const T b, C c) {
if (c(a, b)) a = b;
}
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
template <class T>
inline T sqr(T a) {
return a * a;
}
template <class T>
inline T cub(T a) {
return a * a * a;
}
inline int ceil(int x, int y) { return (x - 1) / y + 1; }
inline int sgn(double x) { return x < -EPS ? -1 : x > EPS; }
inline int sgn(double x, double y) { return sgn(x - y); }
namespace BO {
inline bool _1(int x, int i) { return bool(x & 1 << i); }
inline bool _1(long long x, int i) { return bool(x & 1LL << i); }
inline long long _1(int i) { return 1LL << i; }
inline long long _U(int i) { return _1(i) - 1; };
inline int reverse_bits(int x) {
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa);
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc);
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0);
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00);
x = ((x >> 16) & 0x0000ffff) | ((x << 16) & 0xffff0000);
return x;
}
inline long long reverse_bits(long long x) {
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL);
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL);
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL);
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL);
x = ((x >> 16) & 0x0000ffff0000ffffLL) | ((x << 16) & 0xffff0000ffff0000LL);
x = ((x >> 32) & 0x00000000ffffffffLL) | ((x << 32) & 0xffffffff00000000LL);
return x;
}
template <class T>
inline bool odd(T x) {
return x & 1;
}
template <class T>
inline bool even(T x) {
return !odd(x);
}
template <class T>
inline T low_bit(T x) {
return x & -x;
}
template <class T>
inline T high_bit(T x) {
T p = low_bit(x);
while (p != x) x -= p, p = low_bit(x);
return p;
}
template <class T>
inline T cover_bit(T x) {
T p = 1;
while (p < x) p <<= 1;
return p;
}
inline int low_idx(int x) { return __builtin_ffs(x); }
inline int low_idx(long long x) { return __builtin_ffsll(x); }
inline int high_idx(int x) { return low_idx(reverse_bits(x)); }
inline int high_idx(long long x) { return low_idx(reverse_bits(x)); }
inline int clz(int x) { return __builtin_clz(x); }
inline int clz(long long x) { return __builtin_clzll(x); }
inline int ctz(int x) { return __builtin_ctz(x); }
inline int ctz(long long x) { return __builtin_ctzll(x); }
inline int parity(int x) { return __builtin_parity(x); }
inline int parity(long long x) { return __builtin_parityll(x); }
inline int lg2(int a) { return 31 - clz(a); }
inline int lg2(long long a) { return 63 - clz(a); }
inline int count_bits(int x) { return __builtin_popcount(x); }
inline int count_bits(long long x) { return __builtin_popcountll(x); }
} // namespace BO
using namespace BO;
template <class T>
inline T &RD(T &x) {
char c;
for (c = getchar(); c < '0'; c = getchar())
;
x = c - '0';
for (c = getchar(); '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
return x;
}
inline double &RF(double &x) {
scanf("%lf", &x);
return x;
}
inline char *RS(char *s) {
scanf("%s", s);
return s;
}
int Case;
template <class T>
inline void OT(const T &x) {
printf("%d ", x);
}
const int MAXN = int(4e5) + 9;
vector<vector<int> > eights, others;
bool vis[MAXN];
int rn, cn, vn, link[MAXN], diag1[MAXN], diag2[MAXN];
int rans[MAXN], cans[MAXN];
bool used[MAXN];
char tmp[MAXN * 2];
inline int vid(char s, int x) {
int b;
if (s == 'L')
b = 0;
else if (s == 'T')
b = rn;
else if (s == 'R')
b = vn;
else
b = vn + rn;
return b + x;
}
inline char getstr(int v) {
if (v < rn)
return 'L';
else if (v < vn)
return 'T';
else if (v < vn + rn)
return 'R';
else
return 'B';
}
inline int getpos(int v) {
if (v < rn)
return v;
else if (v < vn)
return v - rn;
else if (v < vn + rn)
return v - vn;
else
return v - vn - rn;
}
inline int cp(int v) { return v < vn ? v + vn : v - vn; }
void dfs(int u, vector<int> &cyc) {
if (vis[u]) return;
vis[u] = 1, cyc.push_back(u);
dfs(link[u], cyc), dfs(cp(u), cyc);
}
void dump(const vector<int> &cyc, char *str) {
for (int i = 0; i < cyc.size(); i++) str[i] = getstr(cyc[i]);
str[cyc.size()] = '\0';
}
int is_eight(const vector<int> &cyc) {
if (cyc.size() != 8) return 0;
char rep[10];
dump(cyc, rep);
if (!strcmp(rep, "LTBLRBTR")) return 1;
if (!strcmp(rep, "LBTLRTBR")) return 2;
return 0;
}
void gao_eight() {
for (int e = 0; e < int(int(eights.size())); ++e) {
const vector<int> &cyc = eights[e];
int type = is_eight(cyc);
if (type == 1) {
rans[e] = getpos(cyc[0]), rans[rn - e - 1] = getpos(cyc[3]);
cans[e] = getpos(cyc[1]), cans[cn - e - 1] = getpos(cyc[5]);
} else {
rans[rn - e - 1] = getpos(cyc[0]), rans[e] = getpos(cyc[3]);
cans[e] = getpos(cyc[1]), cans[cn - e - 1] = getpos(cyc[5]);
}
used[vid('L', e)] = used[vid('L', rn - e - 1)] = 1;
used[vid('R', e)] = used[vid('R', rn - e - 1)] = 1;
used[vid('T', e)] = used[vid('T', cn - e - 1)] = 1;
used[vid('B', e)] = used[vid('B', cn - e - 1)] = 1;
}
}
void gen_diag() {
vector<int> a1, a2;
for (int i = int(rn - 1); i >= int(0); --i)
if (!used[i]) a1.push_back(i);
for (int i = 0; i < int(cn); ++i)
if (!used[rn + i]) a1.push_back(rn + i);
for (int i = 0; i < int(rn); ++i)
if (!used[vn + i]) a1.push_back(vn + i);
for (int i = int(cn - 1); i >= int(0); --i)
if (!used[vn + rn + i]) a1.push_back(vn + rn + i);
for (int i = 0; i < int(rn); ++i)
if (!used[i]) a2.push_back(i);
for (int i = 0; i < int(cn); ++i)
if (!used[vn + rn + i]) a2.push_back(vn + rn + i);
for (int i = int(rn - 1); i >= int(0); --i)
if (!used[vn + i]) a2.push_back(vn + i);
for (int i = int(cn - 1); i >= int(0); --i)
if (!used[rn + i]) a2.push_back(rn + i);
for (int i = 0; i < int(int(a1.size())); ++i)
diag1[a1[i]] = a1[a1.size() - i - 1];
for (int i = 0; i < int(int(a2.size())); ++i)
diag2[a2[i]] = a2[a2.size() - i - 1];
}
void dfs_diag(int v, int *diag, vector<int> &arr) {
vis[v] = 1;
arr.push_back(v);
int u = diag[v];
int z = cp(v);
if (!vis[u]) dfs_diag(u, diag, arr);
if (!vis[z]) dfs_diag(z, diag, arr);
}
int lex_smallest_head(char s[], int n) {
for (int i = 0; i < n; i++) s[i + n] = s[i];
int i = 0, j = 1, k = 0;
while (j < n && k < n) {
if (s[i + k] == s[j + k])
k++;
else {
if (s[i + k] < s[j + k])
j += k + 1;
else
i += k + 1;
k = 0;
}
if (i == j) j++;
}
return i;
}
void shift(vector<int> &a, int o) {
vector<int> _a = a;
for (int i = 0; i < int(int(a.size())); ++i)
a[i] = _a[(i + o) % int(a.size())];
}
bool try_diag(int *diag) {
RST(vis);
vector<vector<int> > diags, origs;
for (int i = 0; i < int(vn); ++i)
if (!vis[i] && !used[i]) {
vector<int> arr;
dfs_diag(i, diag, arr);
dump(arr, tmp), shift(arr, lex_smallest_head(tmp, int(arr.size())));
diags.push_back(arr);
}
for (int o = 0; o < int(int(others.size())); ++o) {
vector<int> &arr = others[o];
dump(arr, tmp);
shift(arr, lex_smallest_head(tmp, int(arr.size())));
origs.push_back(arr);
}
if (int(diags.size()) != int(origs.size())) return 0;
SRT(diags), SRT(origs);
for (int i = 0; i < int(int(diags.size())); ++i)
if (int(diags[i].size()) != int(origs[i].size())) return 0;
for (int i = 0; i < int(int(diags.size())); ++i)
for (int j = 0; j < int(int(diags[i].size())); ++j) {
int v1 = origs[i][j], v2 = diags[i][j];
if (getstr(v1) != getstr(v2)) return 0;
char c = getstr(v1);
if (c == 'L' || c == 'R')
rans[getpos(v2)] = getpos(v1);
else
cans[getpos(v2)] = getpos(v1);
}
return 1;
}
bool gao_other() {
gen_diag();
return try_diag(diag1) || try_diag(diag2);
}
bool solve() {
for (int i = 0; i < int(vn); ++i)
if (!vis[i]) {
vector<int> cyc;
dfs(i, cyc);
if (is_eight(cyc))
eights.push_back(cyc);
else
others.push_back(cyc);
}
gao_eight();
return gao_other();
}
int main() {
for (int n____ = int(vn = RD(rn) + RD(cn)), i = 0; i < n____; ++i) {
char s1, s2;
int x1, x2;
RC(s1, s2), x1 = vid(s1, RD() - 1), x2 = vid(s2, RD() - 1);
link[x1] = x2, link[x2] = x1;
}
if (!solve())
puts("No solution");
else {
for (int i = 0; i < int(rn); ++i) OT(rans[i] + 1);
puts("");
for (int i = 0; i < int(cn); ++i) OT(cans[i] + 1);
puts("");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
int n;
cin >> n;
vector<int> odd;
vector<int> even;
for (int i = 0; i < n; i++) {
int ai;
cin >> ai;
if (ai % 2)
odd.push_back(ai);
else
even.push_back(ai);
}
if (!odd.size())
cout << 0;
else {
int num = odd.size() % 2 ? odd.size() : odd.size() - 1, ans = 0;
sort(odd.begin(), odd.end(), greater<int>());
sort(even.begin(), even.end(), greater<int>());
for (int i = 0; i < num; i++) ans += odd[i];
for (int i = 0; i < even.size(); i++) ans += even[i];
cout << ans;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
vector<int> v1, v2;
int main() {
ios::sync_with_stdio(0);
int n, y1;
cin >> n >> y1;
for (int i = 0; i < n; i++) {
int val;
cin >> val;
v1.push_back(val);
}
int m, y2;
cin >> m >> y2;
for (int i = 0; i < m; i++) {
int val;
cin >> val;
v2.push_back(val);
}
int ans = 2;
for (int dx = 1; dx < 1e9; dx *= 2) {
mp.clear();
int mod = 2 * dx;
for (int i = 0; i < n; i++) {
mp[v1[i] % mod]++;
}
for (int i = 0; i < m; i++) {
mp[(v2[i] + dx) % mod]++;
}
for (auto x : mp) ans = max(ans, x.second);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
string s[105], w;
int n;
char t;
bool vis[105];
map<int, bool> mp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size(); j++) s[i][j] = tolower(s[i][j]);
}
cin >> w >> t;
for (int i = 0; i < w.size(); i++) {
if (w[i] >= 'A' && w[i] <= 'Z') mp[i] = 1;
w[i] = tolower(w[i]);
}
for (int i = 0; i < n; i++) {
string tmp = w;
int sft = 0;
while (tmp.find(s[i]) != -1) {
int idx = tmp.find(s[i]);
for (int j = idx + sft; j < sft + idx + s[i].size(); j++) {
vis[j] = 1;
}
tmp = tmp.substr(idx + 1);
sft += idx + 1;
}
}
for (int i = 0; i < w.size(); i++) {
if (vis[i] == 1) {
if (w[i] != t)
w[i] = t;
else if (w[i] != 'a')
w[i] = 'a';
else
w[i] = 'b';
}
if (mp[i]) w[i] = toupper(w[i]);
}
cout << w << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define INF 1e18
#define int long long
#define Rep(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) Rep(i, 0, n)
#define all(a) (a).begin(), (a).end()
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> PP;
const int mod = 1000000007;
//const int mod = 998244353;
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
while (1)
{
string g;
cin >> g;
if (g == "#")
break;
int y, m, d;
cin >> y >> m >> d;
if (y > 31)
{
g = "?";
y -= 30;
}
else if (y == 31 && m >= 5)
{
g = "?";
y -= 30;
}
cout << g << " " << y << " " << m << " " << d << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long bp[65536 * 2];
long long check(long long len) {
long long i = 0;
long long cnt = 0;
while (i < n) {
long long j = i;
while (j < n and bp[j + 1] - bp[i] + 1 <= len) j++;
i = j + 1, cnt++;
}
return cnt <= k;
}
int main() {
scanf("%lld%lld%lld", &n, &m, &k);
long long ans = n;
multiset<long long> s;
for (int i = 0; i < n; i++) {
scanf("%lld", &bp[i]);
if (i) s.insert(bp[i] - bp[i - 1] - 1);
}
while (s.size() >= k) {
ans += *s.begin();
s.erase(s.begin());
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
char s[100010];
struct trie {
bool leaf;
trie *a[26];
trie() {
leaf = 0;
memset(a, 0, sizeof a);
}
};
trie *rt = new trie();
void insert(char *s) {
trie *r = rt;
for (int b, i = 0; s[i]; ++i) {
b = s[i] - 'a';
if (r->a[b] == 0) r->a[b] = new trie();
r = r->a[b];
}
r->leaf = true;
}
bool win(trie *r) {
bool ret = 0;
for (int i = 0; i < 26; ++i)
if (r->a[i]) ret |= win(r->a[i]);
return !ret;
}
bool lose(trie *r) {
bool ret = 0;
int c = 0;
for (int i = 0; i < 26; ++i)
if (r->a[i]) {
ret |= lose(r->a[i]);
++c;
}
if (!c) return 0;
return !ret;
}
int main(int argc, char **argv) {
scanf("%d%d", &n, &k);
while (n--) {
scanf("%s", s);
insert(s);
}
bool w = !win(rt);
bool l = !lose(rt);
if (!w && !l)
puts("Second");
else if (w && l)
puts("First");
else if (w && !l)
puts((k & 1) ? "First" : "Second");
else
puts("Second");
return 0;
}
| 4 |
#include<iostream>
#include<algorithm>
#include<string>
#include<set>
using namespace std;
int main(){
int m;
string s;
cin >> m;
for(int x=0;x<m;x++){
cin >> s;
set<string> ans;
for(int i=1;i<s.size();i++){
string a[2],b[2];
a[0] = a[1] = s.substr(0,i);
b[0] = b[1] = s.substr(i);
reverse(a[1].begin(),a[1].end());
reverse(b[1].begin(),b[1].end());
for(int j=0;j<2;j++){
for(int k=0;k<2;k++){
ans.insert(a[j]+b[k]);
ans.insert(b[j]+a[k]);
}
}
}
cout << ans.size() << endl;
}
}
| 0 |
#include<iostream>
using namespace std;
int main(){
string S;
cin>>S;
if(S=="ABC")cout<<"ARC"<<endl;
else cout<<"ABC"<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, k;
cin >> n >> k;
vector<pair<int, int> > v;
for (int(i) = 0; (i) < (int)(n); ++(i)) {
int temp;
cin >> temp;
v.push_back(make_pair(temp, i));
}
sort((v).begin(), (v).end());
int ans = 0;
vector<int> r;
for (int(i) = 0; (i) < (int)(n); ++(i)) {
if (k >= v[i].first) {
k -= v[i].first;
ans++;
r.push_back(v[i].second);
}
}
cout << ans;
if (r.size() > 0) {
cout << endl;
}
for (int(i) = 0; (i) < (int)(r.size()); ++(i)) {
cout << r[i] + 1;
if (i != (r.size() - 1)) {
cout << " ";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1e5 + 7;
vector<int> rastavi;
int is[NMAX], p[NMAX];
void er() {
for (int i = 1; i < NMAX; i++) is[i] = 1;
for (int i = 2; i < NMAX; i++) {
if (!is[i]) continue;
for (int j = 2 * i; j < NMAX; j += i) is[j] = 0;
}
int time = 0;
for (int i = 1; i < NMAX; i++)
if (is[i]) p[++time] = i;
}
vector<int> resenje;
int main() {
er();
int n, k;
scanf("%d%d", &n, &k);
int go = 1;
int d = 2;
while (d * d <= n) {
while (n % d == 0) {
n /= d;
rastavi.push_back(d);
}
d = p[++go];
}
if (n > 1) rastavi.push_back(n);
if (rastavi.size() < k) {
printf("-1");
return 0;
}
for (int i = 0; i < k - 1; i++) resenje.push_back(rastavi[i]);
int posl = 1;
for (int i = k - 1; i < rastavi.size(); i++) posl *= rastavi[i];
resenje.push_back(posl);
for (int i : resenje) printf("%d ", i);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 15;
struct Persistent {
int l, r, s;
Persistent() { l = r = s = 0; }
} t[N << 5];
int n, no, avail, root[N];
map<int, int> vis;
int squeeze(int x) {
if (vis.find(x) == vis.end()) vis[x] = ++no;
return vis[x];
}
int update(int pre, int b, int e, int pos, int v) {
int node = ++avail;
t[node] = t[pre];
if (b == e) {
t[node].s += v;
return node;
}
int m = (b + e) >> 1;
if (pos <= m)
t[node].l = update(t[node].l, b, m, pos, v);
else
t[node].r = update(t[node].r, m + 1, e, pos, v);
t[node].s = t[t[node].l].s + t[t[node].r].s;
return node;
}
int query(int node, int b, int e, int l, int r) {
if (e < l || b > r || b > e) return 0;
if (l <= b && e <= r) return t[node].s;
int m = (b + e) >> 1;
return query(t[node].l, b, m, l, r) + query(t[node].r, m + 1, e, l, r);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i += 1) {
int operation, t, x;
cin >> operation >> t >> x;
x = squeeze(x);
if (operation == 1) {
root[x] = update(root[x], 1, 1e9, t, +1);
} else if (operation == 2) {
root[x] = update(root[x], 1, 1e9, t, -1);
} else {
cout << query(root[x], 1, 1e9, 1, t) << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
int arr[MAXN];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
sort(arr + 1, arr + n + 1);
cout << (n - 1) / 2 << endl;
int lst = n;
int fst = 1;
for (int i = 1; i <= n; i++) {
if (i % 2) {
cout << arr[lst] << " ";
lst--;
} else {
cout << arr[fst] << " ";
fst++;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
int bs(long long int n) {
int mn = 0, mx = v.size(), mid;
while (mn <= mx) {
mid = (mn + mx) / 2;
if (v[mid] < n)
mn = mid + 1;
else if (v[mid] > n)
mx = mid - 1;
else
break;
}
if (v[mid] < n)
return mid;
else if (v[mid] >= n)
return mid - 1;
}
int main() {
int n, i, k, num;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> num;
v.push_back(num);
}
sort(v.begin(), v.end());
v.push_back(INT_MAX);
int ans = n;
for (i = 0; i < n; i++) {
if (v[i] == -1) continue;
if (bs(k * v[i]) + 1 != i && v[bs(k * v[i]) + 1] == k * v[i]) {
ans--;
v[bs(k * v[i]) + 1] = -1;
} else if (bs(k * v[i]) != i && v[bs(k * v[i])] == k * v[i]) {
ans--;
v[bs(k * v[i])] = -1;
}
}
cout << ans;
}
| 3 |
#include<iostream>
using namespace std;
int main(){
long long int s,c;
cin>>s>>c;
if(s>=c/2){
cout<<c/2<<endl;
}
if(c/2>s){
cout<<s+(c-s*2)/4<<endl;
}
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int main(void) {
int n;
cin>>n;
cout<<"ABC"<<n<<'\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ar[123], i, n, a, b, c, d, x, m, z = 1;
cin >> n;
for (i = 0; i < n; i++) cin >> ar[i];
for (i = 0; i < n; i++) {
for (m = i + 1; m < n; m++) {
a = ar[i] + ar[m];
for (x = 0; x < n; x++) {
if (ar[x] == a) {
cout << x + 1 << ' ' << max(i, m) + 1 << ' ' << min(i, m) + 1;
z = 0;
break;
}
}
if (z == 0) break;
}
if (z == 0) break;
}
if (z != 0) cout << -1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long inf = 1e18;
long long mod = 1e9 + 7;
long long delta = 10289;
const long long M = 320;
long long dp[M * M][M];
long long a[M * M];
int main() {
long long n;
cin >> n;
char c, v;
cin >> v;
long long a = 0, b = 0;
for (long long i = 1; i < n; i++) {
cin >> c;
a += (c == v);
b += (c != v);
v = c;
}
cout << 1 + b + min((long long)2, a);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110;
const int INF = 0x3f3f3f3f;
long long n, k, res, vis[26], f[MAXN][MAXN], lst[26];
char s[MAXN];
inline void run() {
cin >> n >> k >> s + 1;
f[0][0] = 1;
for (int i = (int)(1); i <= (int)(n); i++) {
f[i][0] = 1;
for (int j = (int)(1); j <= (int)(i); j++) {
f[i][j] = f[i - 1][j] + f[i - 1][j - 1];
if (lst[s[i] - 'a']) f[i][j] -= f[lst[s[i] - 'a'] - 1][j - 1];
}
lst[s[i] - 'a'] = i;
}
long long res = 0;
for (int i = (int)(n); i >= (int)(0); i--) {
long long cnt = min(k, f[n][i]);
res += cnt * (n - i);
k -= cnt;
if (!k) break;
}
cout << (k ? -1 : res) << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
run();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<int> distinctive;
bool Prime(int y) {
for (int i = 2; i <= sqrt(y); i++)
if (y % i == 0 && y != i) return false;
return true;
}
bool composite(int x) {
for (int i = 2; i <= sqrt(x); i++)
if (x % i == 0 && x != i) return true;
return false;
}
int main() {
for (int i = 2; i <= 500000; i++)
if (Prime(i)) distinctive.insert(i);
int number;
cin >> number;
int i = 4;
while (number) {
int temp = number - i;
if (composite(temp)) {
cout << min(temp, i) << " " << max(temp, i) << endl;
break;
} else {
i += 2;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1 << 12;
int a[4], ms[4], dp[1007][mx], b[1007];
char c[4][1007];
int main() {
int n, t, inf = 1e9 + 7;
scanf("%d", &n);
for (int i = 0; i < 4; i++) {
scanf("%d", &a[i]);
ms[i] = (1 << (i + 1)) - 1;
}
for (int i = 0; i < 4; i++) scanf("%s", &c[i]);
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 4; j++) b[i] += (c[j][i] == '*') << j;
for (int j = 0; j < mx; j++) dp[i][j] = inf;
}
dp[0][b[0] + (b[1] << 4) + (b[2] << 8)] = 0;
for (int i = 0; i < n; i++) {
for (int j = mx - 1; j >= 0; j--) {
if (dp[i][j] == inf) continue;
if (j % 16 == 0) {
t = (j >> 4) + (b[i + 3] << 8);
dp[i + 1][t] = min(dp[i + 1][t], dp[i][j]);
}
dp[i + 1][0] = min(dp[i + 1][0], dp[i][j] + a[3]);
for (int k = 0; k < 3; k++) {
for (int z = 0; z + k < 4; z++) {
t = j;
for (int p = 0; p <= k; p++) {
t &= ~(ms[k] << (p * 4 + z));
}
dp[i][t] = min(dp[i][t], dp[i][j] + a[k]);
}
}
}
}
printf("%d", dp[n][0]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MASK = 6561;
const int MAXN = 8;
const int oops = 1000;
int best2[1 << MAXN | 5];
int best[MASK + 5];
long long arr[MAXN + 5];
int n;
int base2(int mask) {
int ret = 0;
for (int b = 1; mask; b <<= 1, mask /= 3) ret += b * (mask % 3 == 1);
return ret;
}
int base3(int mask) {
int ret = 0;
for (int b = 1; mask; b *= 3, mask >>= 1) ret += b * (mask & 1);
return ret;
}
int getMax(int mask) {
int i = -1;
for (int c = 0; c < n; c++)
if ((mask & (1 << c)) && (i == -1 || arr[c] > arr[i])) i = c;
return i;
}
int factorize(long long num) {
int ret = 0;
for (int p = 2; 1LL * p * p <= num; p++)
while (num % p == 0) ret++, num /= p;
if (num > 1) ret++;
return ret;
}
int takeFrom(int newmask, int mask, int mi) {
int ret = 0;
for (int c = 0, b = 1; c < n; c++, b *= 3, mask /= 3) {
int d = mask % 3;
if (c == mi)
d = 2;
else if (newmask & (1 << c))
d = 0;
ret += b * d;
}
return ret;
}
int solve(int mask, long long root, int i) {
int& ret = best[mask];
if (~ret) return ret;
int binaryMask = base2(mask);
binaryMask -= (1 << i);
ret = binaryMask ? oops : factorize(root);
if (ret > 1 || root != arr[i]) ret++;
for (int newmask = binaryMask; newmask; newmask = newmask - 1 & binaryMask) {
int mi = getMax(newmask);
if (root % arr[mi]) continue;
ret = min(ret, solve(takeFrom(newmask, mask, mi), root / arr[mi], i) +
solve(base3(newmask), arr[mi], mi));
}
return ret;
}
int solve2(int mask) {
if (mask == 0) return 0;
int& ret = best2[mask];
if (~ret) return ret;
ret = oops;
for (int newmask = mask; newmask; newmask = newmask - 1 & mask) {
int i = getMax(newmask);
ret = min(ret, solve(base3(newmask), arr[i], i) + solve2(mask ^ newmask));
}
return ret;
}
int main() {
int c, c2;
scanf("%d", &n);
for (c = 0; c < n; c++) scanf("%I64d", &arr[c]);
memset(best, -1, sizeof(best));
memset(best2, -1, sizeof(best2));
int i = getMax((1 << n) - 1);
int ret =
min(solve2((1 << n) - 1) + 1, solve(base3((1 << n) - 1), arr[i], i));
printf("%d\n", ret);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<int, vector<int> > m;
int count(vector<int> &v1, vector<int> &v2) {
int temp = v1[0], counter = 1, i = 1, j = 0, b = 0;
while (i < v1.size() || j < v2.size()) {
if (!(!b && j < v2.size()) && !(b && i < v1.size())) break;
while (!b && j < v2.size()) {
if (v2[j] > temp) {
temp = v2[j];
counter++;
b++;
break;
}
j++;
}
while (b && i < v1.size()) {
if (v1[i] > temp) {
temp = v1[i];
counter++;
b--;
break;
}
i++;
}
}
return counter;
}
int main() {
int n, temp;
int j1 = 1, j2 = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> temp;
m[temp].push_back(j1);
j1++;
}
int res = 1;
for (map<int, vector<int> >::iterator it = m.begin(); it != m.end(); it++)
for (map<int, vector<int> >::iterator jt(it); jt != m.end(); jt++) {
res = max(res, count(jt->second, it->second));
res = max(res, count(it->second, jt->second));
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
struct edge {
int v, nxt;
} e[maxn << 1];
int head[maxn], kt;
int t[maxn], rt, n;
int ans[10], tot;
int sum;
template <typename T>
inline void read(T &x) {
char c;
int f = 1;
while (!isdigit(c = getchar())) (c == '-') && (f = -1);
x = c ^ 48;
while (isdigit(c = getchar())) x = (x << 1) + (x << 3) + (c ^ 48);
x *= f;
}
inline void add(int u, int v) {
e[++kt] = (edge){v, head[u]};
head[u] = kt;
}
void dfs(int u, int f) {
for (int i = head[u]; i; i = e[i].nxt)
if (e[i].v != f) {
dfs(e[i].v, u);
t[u] += t[e[i].v];
}
if (t[u] == sum / 3) ans[++tot] = u, t[u] = 0;
}
int main() {
int x;
read(n);
for (int i = 1; i <= n; i++) {
read(x);
read(t[i]);
sum += t[i];
if (x)
add(x, i), add(i, x);
else
rt = i;
}
if (sum % 3) {
puts("-1");
return 0;
}
dfs(rt, 0);
if (tot <= 2)
puts("-1");
else
printf("%d %d\n", ans[1], ans[2]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dis[11][11][11][11];
int dp[11][11];
char s[2000006];
int main() {
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
memset(dp, 0x3f3f3f3f, sizeof dp);
for (int k = 0; k < 10; k++) {
dp[k][(k + i) % 10] = 1;
dp[k][(k + j) % 10] = 1;
}
for (int k = 0; k < 10; k++) {
for (int ii = 0; ii < 10; ii++) {
for (int jj = 0; jj < 10; jj++) {
dp[ii][jj] = min(dp[ii][jj], dp[ii][k] + dp[k][jj]);
}
}
}
memcpy(dis[i][j], dp, sizeof dp);
}
}
scanf("%s", s);
int n = strlen(s);
for (int i = 0; i < n; i++) {
s[i] -= '0';
}
for (int ii = 0; ii < 10; ii++) {
for (int jj = 0; jj < 10; jj++) {
int ans = 0;
for (int i = 1; i < n; i++) {
if (dis[ii][jj][s[i - 1]][s[i]] > 100) {
ans = -1;
break;
}
ans += dis[ii][jj][s[i - 1]][s[i]] - 1;
}
printf("%d%c", ans, jj == 9 ? '\n' : ' ');
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000009;
void solve() {
int n, m, ch = 0;
cin >> n >> m;
string second[n];
int cur = 0;
for (int i = 0; i < n; i++) {
cin >> second[i];
for (int j = 0; j < second[i].length(); j++) {
if (second[i][j] == 'A') ch = 1, cur++;
}
}
if (!ch) {
cout << "MORTAL\n";
return;
}
if (cur == n * m) {
cout << "0\n";
return;
}
cur = 0, ch = 0;
for (int j = 0; j < m; j++) {
if (second[0][j] == 'A') ch = 1, cur++;
}
if (cur == m) {
cout << "1\n";
return;
}
cur = 0;
for (int j = 0; j < m; j++) {
if (second[n - 1][j] == 'A') ch = 1, cur++;
}
if (cur == m) {
cout << "1\n";
return;
}
cur = 0;
for (int j = 0; j < n; j++) {
if (second[j][0] == 'A') ch = 1, cur++;
}
if (cur == n) {
cout << "1\n";
return;
}
cur = 0;
for (int j = 0; j < n; j++) {
if (second[j][m - 1] == 'A') ch = 1, cur++;
}
if (cur == n) {
cout << "1\n";
return;
}
if (second[0][0] == 'A' || second[0][m - 1] == 'A' ||
second[n - 1][0] == 'A' || second[n - 1][m - 1] == 'A') {
cout << "2\n";
return;
}
for (int i = 0; i < n; i++) {
cur = 0;
for (int j = 0; j < m; j++) {
cur += (second[i][j] == 'A');
}
if (cur == m) {
cout << "2\n";
return;
}
}
for (int j = 0; j < m; j++) {
cur = 0;
for (int i = 0; i < n; i++) {
cur += (second[i][j] == 'A');
}
if (cur == n) {
cout << "2\n";
return;
}
}
if (ch == 1) {
cout << "3\n";
return;
}
cout << "4\n";
return;
}
int main() {
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 1000;
map<int, set<int>> pos;
vector<pair<int, int>> all_points;
int len;
vector<long long> tree[4 * MAXN];
vector<int> pos_y[4 * MAXN];
void build() {
for (int i = 0; i < all_points.size(); i++) {
int v = len + all_points[i].first;
int y = all_points[i].second;
pos_y[v].push_back(y);
tree[v].push_back(0);
}
for (int i = 0; i < MAXN; i++) {
sort(pos_y[i].begin(), pos_y[i].end());
}
for (int i = len - 1; i >= 1; i--) {
tree[i].resize(tree[2 * i].size() + tree[2 * i + 1].size());
pos_y[i].resize(pos_y[2 * i].size() + pos_y[2 * i + 1].size());
merge(pos_y[2 * i].begin(), pos_y[2 * i].end(), pos_y[2 * i + 1].begin(),
pos_y[2 * i + 1].end(), pos_y[i].begin());
}
}
void add_in_fenv(vector<long long>& f, int ind, int val) {
for (int i = ind; i < f.size(); i |= i + 1) {
f[i] += val;
}
}
long long sum_in_fenv(vector<long long>& f, int ind) {
long long ans = 0;
for (int i = ind; i >= 0; i = ((i + 1) & i) - 1) {
ans += f[i];
}
return ans;
}
long long sum_in_fenv(vector<long long>& f, int l, int r) {
if (l == 0) return sum_in_fenv(f, r);
return sum_in_fenv(f, r) - sum_in_fenv(f, l - 1);
}
void add(int x, int y, int val) {
int v = x + len;
while (v > 0) {
int ind_y = (int)distance(pos_y[v].begin(),
lower_bound(pos_y[v].begin(), pos_y[v].end(), y));
add_in_fenv(tree[v], ind_y, val);
v /= 2;
}
}
void fill() {
for (auto& it_pos : pos) {
auto& all_pos = it_pos.second;
if (all_pos.size() > 1) {
auto it = all_pos.begin();
it++;
auto la = all_pos.begin();
while (it != all_pos.end()) {
add(*la, *it, *it - *la);
it++;
la++;
}
}
}
}
long long find(int tl, int tr, int v, int l, int r, int d, int u) {
if (tl > tr) return 0;
if (tl == l && tr == r) {
int l_ind = (int)distance(pos_y[v].begin(),
lower_bound(pos_y[v].begin(), pos_y[v].end(), d));
int r_ind =
(int)distance(pos_y[v].begin(),
upper_bound(pos_y[v].begin(), pos_y[v].end(), u)) -
1;
return sum_in_fenv(tree[v], l_ind, r_ind);
}
int s = (l + r) / 2;
return find(tl, min(s, tr), 2 * v, l, s, d, u) +
find(max(s + 1, tl), tr, 2 * v + 1, s + 1, r, d, u);
}
vector<pair<int, pair<int, int>>> que;
int form[MAXN];
int clear_form[MAXN];
int main() {
int n, m;
cin >> n >> m;
for (len = 1; len < n; len *= 2)
;
for (int i = 0; i < n; i++) {
cin >> form[i];
pos[form[i]].insert(i);
clear_form[i] = form[i];
}
for (auto it_pos : pos) {
auto& all_pos = it_pos.second;
if (all_pos.size() > 1) {
auto it = all_pos.begin();
it++;
auto la = all_pos.begin();
while (it != all_pos.end()) {
all_points.push_back({*la, *it});
it++;
la++;
}
}
}
for (int i = 0; i < m; i++) {
int a, p, x;
cin >> a >> p >> x;
que.push_back({a, {p, x}});
if (a == 1) {
p--;
int last_form = form[p];
if (last_form == x) continue;
auto it = pos[last_form].find(p);
assert(it != pos[last_form].end());
if (it != pos[last_form].begin()) {
auto pr_it = it;
pr_it--;
auto ne_it = it;
ne_it++;
if (ne_it != pos[last_form].end()) {
all_points.push_back({*pr_it, *ne_it});
}
}
pos[last_form].erase(it);
form[p] = x;
auto ne_it = pos[form[p]].lower_bound(p);
if (ne_it != pos[form[p]].end()) {
all_points.push_back({p, *ne_it});
}
if (ne_it != pos[form[p]].begin()) {
auto pr_it = ne_it;
pr_it--;
all_points.push_back({*pr_it, p});
}
pos[form[p]].insert(p);
}
}
for (int i = 0; i < n; i++) {
form[i] = clear_form[i];
}
pos.clear();
for (int i = 0; i < n; i++) {
pos[form[i]].insert(i);
}
build();
fill();
for (int i = 0; i < m; i++) {
int a = que[i].first;
if (a == 1) {
int p = que[i].second.first;
int x = que[i].second.second;
p--;
int last_form = form[p];
if (last_form == x) continue;
auto it = pos[last_form].find(p);
assert(it != pos[last_form].end());
if (it != pos[last_form].begin()) {
auto pr_it = it;
pr_it--;
add(*pr_it, p, *pr_it - p);
auto ne_it = it;
ne_it++;
if (ne_it != pos[last_form].end()) {
add(*pr_it, *ne_it, *ne_it - *pr_it);
}
}
{
auto ne_it = it;
ne_it++;
if (ne_it != pos[last_form].end()) {
add(p, *ne_it, p - *ne_it);
}
}
pos[last_form].erase(it);
form[p] = x;
auto ne_it = pos[form[p]].lower_bound(p);
if (ne_it != pos[form[p]].end()) {
add(p, *ne_it, *ne_it - p);
}
if (ne_it != pos[form[p]].begin()) {
auto pr_it = ne_it;
pr_it--;
add(*pr_it, p, p - *pr_it);
}
if (ne_it != pos[form[p]].begin() && ne_it != pos[form[p]].end()) {
auto pr_it = ne_it;
pr_it--;
add(*pr_it, *ne_it, *pr_it - *ne_it);
}
pos[form[p]].insert(p);
} else {
int l = que[i].second.first;
int r = que[i].second.second;
l--, r--;
cout << find(l + len, r + len, 1, len, len * 2 - 1, l, r) << "\n";
}
}
return 0;
}
| 3 |
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <string>
#define SIZE 200005
#define MOD 1000000007
using namespace std;
typedef long long int ll;
char str[SIZE];
ll dp[SIZE],rdp[SIZE];
ll solve(int n,int L)
{
dp[1]=1;
rdp[1]=1;
for(int i=2;i<=n;i++)
{
dp[i]=rdp[i-1]-(i-L-2<=0?0:rdp[i-L-2]);
if(dp[i]<0) dp[i]+=MOD;
rdp[i]=rdp[i-1]+dp[i];
if(rdp[i]>=MOD) rdp[i]-=MOD;
}
ll ret=0;
for(int i=0;i<=min(n-1,L);i++)
{
ret+=(ll) (i+1)*dp[n-i]%MOD;
if(ret>=MOD) ret-=MOD;
}
return ret;
}
ll solve2(int n)
{
dp[1]=1;
rdp[1]=1;
dp[2]=0;
rdp[2]=1;
for(int i=3;i<=n;i++)
{
dp[i]=rdp[i-2];
rdp[i]=rdp[i-1]+dp[i];
if(rdp[i]>=MOD) rdp[i]-=MOD;
}
ll ret=0;
for(int i=1;i<=n-1;i++)
{
ret+=(ll) (i+1)*dp[n-i]%MOD;
if(ret>=MOD) ret-=MOD;
}
return ret;
}
int main()
{
int n,m;
scanf("%d %d",&n,&m);
scanf("%s",&str);
bool R=false,B=false;
for(int i=0;i<m;i++)
{
if(str[i]=='R') R=true;
else B=true;
}
if(!B||!R) printf("%lld\n",(solve2(n)+1)%MOD);
else
{
if(n%2==1) puts("0");
else
{
int mn=n;
for(int i=0;i<m;)
{
if(str[i]!=str[0])
{
i++;
continue;
}
int f=i;
for(;i<m&&str[i]==str[f];i++);
int len=i-f;
//printf("%d\n",len);
if(f==0)
{
if(len%2==0) len++;
mn=min(mn,len);
}
else if(i<m&&len%2==1) mn=min(mn,len);
}
//printf("%d\n",mn);
printf("%lld\n",solve(n/2,mn/2)*2LL%MOD);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, m;
long long k;
long long a[22][22];
long long ans;
int tt;
map<long long, long long> up[22][22];
map<long long, long long> down[22][22];
queue<long long> q;
void up_dfs(int x, int y) {
int xx = x + 1, yy = y;
if (xx + yy <= tt) {
map<long long, long long>::iterator it;
for (it = up[x][y].begin(); it != up[x][y].end(); it++) {
up[xx][yy][(it->first) ^ a[xx][yy]] += up[x][y][it->first];
}
if (xx + yy < tt) up_dfs(xx, yy);
}
xx = x;
yy = y + 1;
if (xx + yy <= tt) {
map<long long, long long>::iterator it;
for (it = up[x][y].begin(); it != up[x][y].end(); it++) {
up[xx][yy][(it->first) ^ a[xx][yy]] += up[x][y][it->first];
}
if (xx + yy < tt) up_dfs(xx, yy);
}
}
void down_dfs(int x, int y) {
int xx = x - 1, yy = y;
if (xx > 0) {
map<long long, long long>::iterator it;
for (it = down[x][y].begin(); it != down[x][y].end(); it++) {
down[xx][yy][(it->first) ^ a[x][y]] += down[x][y][it->first];
}
if (xx + yy >= tt) down_dfs(xx, yy);
}
xx = x;
yy = y - 1;
if (yy >= 0) {
map<long long, long long>::iterator it;
for (it = down[x][y].begin(); it != down[x][y].end(); it++) {
down[xx][yy][(it->first) ^ a[x][y]] += down[x][y][it->first];
}
if (xx + yy > tt) down_dfs(xx, yy);
}
}
int main() {
while (cin >> n >> m >> k) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
ans = 0;
if (n > m)
tt = n - 1 - (n - m) / 2;
else
tt = m - 1 - (m - n) / 2;
int x, y;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
up[i][j].clear();
}
up[0][0][a[0][0]] = 1;
for (int i = 0; i <= tt; i++)
for (int j = 0; j + i <= tt; j++) {
if (i + j) {
x = i - 1;
y = j;
if (x >= 0) {
map<long long, long long>::iterator it;
for (it = up[x][y].begin(); it != up[x][y].end(); it++)
up[i][j][(it->first) ^ a[i][j]] += up[x][y][it->first];
}
x = i;
y = j - 1;
if (y >= 0) {
map<long long, long long>::iterator it;
for (it = up[x][y].begin(); it != up[x][y].end(); it++)
up[i][j][(it->first) ^ a[i][j]] += up[x][y][it->first];
}
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
down[i][j].clear();
}
down[n - 1][m - 1][k] = 1;
for (int i = n - 1; i >= 0; i--)
for (int j = m - 1; i + j >= tt; j--) {
if (i + j != n + m - 2) {
x = i + 1;
y = j;
if (x < n) {
map<long long, long long>::iterator it;
for (it = down[x][y].begin(); it != down[x][y].end(); it++)
down[i][j][(it->first) ^ a[x][y]] += down[x][y][it->first];
}
x = i;
y = j + 1;
if (y < m) {
map<long long, long long>::iterator it;
for (it = down[x][y].begin(); it != down[x][y].end(); it++)
down[i][j][(it->first) ^ a[x][y]] += down[x][y][it->first];
}
}
}
if (n > m) {
for (int j = 0; j < m; j++) {
int i = tt - j;
map<long long, long long>::iterator it;
for (it = up[i][j].begin(); it != up[i][j].end(); it++) {
ans += up[i][j][it->first] * down[i][j][it->first];
}
}
} else {
for (int i = 0; i < n; i++) {
int j = tt - i;
map<long long, long long>::iterator it;
for (it = up[i][j].begin(); it != up[i][j].end(); it++) {
ans += up[i][j][it->first] * down[i][j][it->first];
}
}
}
cout << ans << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ace_it(string& s) {
int sum = 1;
for (int i = 1; i < s.length(); i++) {
if (s[i] == '1')
sum += 10;
else
sum += s[i] - '0';
}
return sum;
}
int main() {
string s;
cin >> s;
cout << ace_it(s);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int len = (int)str.size();
int next = 0;
if (str[0] == 'h') {
cout << "http://";
next = 4;
} else {
cout << "ftp://";
next = 3;
}
int stop = 0;
for (int i = next; i < len; i++)
if (str[i] == 'r' && str[i + 1] == 'u' && i != next) {
stop = i;
break;
}
for (int i = next; i < stop; i++) cout << str[i];
cout << ".ru";
if (stop + 2 < len) {
cout << "/";
for (int i = stop + 2; i < len; i++) cout << str[i];
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
map<int, int>::iterator it;
int n, p;
void inc(int x) {
m[x]++;
if (m[x] == 2) {
m[x] = 0;
p--;
inc(x + 1);
}
}
int main() {
int i, x;
scanf("%d", &n);
p = n;
for (i = 0; i < n; i++) {
scanf("%d", &x);
inc(x);
}
it = m.end();
it--;
int v = (*it).first;
printf("%d", v + 1 - p);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long num[200010];
int main() {
long long n, k;
long long ans = 0;
scanf("%I64d%I64d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%I64d", &num[i]);
for (int i = 1; i <= n; i++) {
int tmp = (num[i] + num[i - 1]) / k;
if ((num[i] + num[i - 1]) % k <= num[i] && i != n) {
num[i] = (num[i] + num[i - 1]) % k;
} else if ((num[i] + num[i - 1]) % k > 0) {
num[i] = 0;
tmp++;
}
ans += tmp;
}
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mem[20];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long a, b, cnt = 0;
cin >> a >> b;
a *= b;
a--;
b--;
a /= b;
cout << a << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, odd = 0, even = 0, res = 0, i;
cin >> n;
int arr[n], evenArr[n], oddArr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (i = 0; i < n; i++) {
if (arr[i] % 2) {
evenArr[even++] = arr[i];
} else {
oddArr[odd++] = arr[i];
}
}
if (even > odd) {
even -= odd;
for (i = 0; i < even - 1; i++) {
res += evenArr[i];
}
} else if (odd > even) {
odd -= even;
for (i = 0; i < odd - 1; i++) {
res += oddArr[i];
}
} else {
res = 0;
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
void Correct() {
for (int i = 0; i < n - 1; i++) cout << i + 1 << " " << i + 2 << "\n";
}
void In_Correct() {
if (n % 2 == 0) {
for (int i = 2; i <= n / 2 + 1; i++)
cout << "1"
<< " " << i << "\n";
for (int i = n / 2 + 2; i <= n; i++)
cout << "2"
<< " " << i << "\n";
} else {
for (int i = 2; i <= (n / 2) + 1; i++)
cout << "1"
<< " " << i << "\n";
for (int i = (n / 2) + 2; i <= n; i++)
cout << "2"
<< " " << i << "\n";
}
}
int main() {
cin >> n;
if (n == 1 || n == 2 || n == 3 || n == 4 || n == 5)
cout << "-1"
<< "\n";
else
In_Correct();
Correct();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void prt(long long num) {
for (long long i = 0; i < 45; i++) {
if ((1ll << i) & num)
cout << "1";
else
cout << "0";
}
cout << "\n";
}
long long l, r, k, min_ = 1e12;
long long ar[5][5];
void ff(), ss(), tt(), fo();
int main() {
cin >> l >> r >> k;
ff(), ss(), tt(), fo();
long long ans1 = (ar[0][0]);
long long ans2 = (ar[1][0] ^ ar[1][1]);
long long ans3 = (ar[2][0] ^ ar[2][1] ^ ar[2][2]);
long long ans4 = (ar[3][0] ^ ar[3][1] ^ ar[3][2] ^ ar[3][3]);
if (k == 1) {
cout << ans1 << "\n" << 1 << "\n" << ans1 << "\n";
} else if (k == 2) {
if (ans1 < ans2)
cout << ans1 << "\n" << 1 << "\n" << ans1 << "\n";
else
cout << ans2 << "\n" << 2 << "\n" << ar[1][0] << " " << ar[1][1] << "\n";
} else if (k == 3) {
long long min_ = min({ans1, ans2, ans3});
if (min_ == ans1)
cout << ans1 << "\n" << 1 << "\n" << ans1 << "\n";
else if (min_ == ans2)
cout << ans2 << "\n" << 2 << "\n" << ar[1][0] << " " << ar[1][1] << "\n";
else if (min_ == ans3)
cout << ans3 << "\n"
<< 3 << "\n"
<< ar[2][0] << " " << ar[2][1] << " " << ar[2][2] << "\n";
} else {
long long min_ = min({ans1, ans2, ans3, ans4});
if (min_ == ans1)
cout << ans1 << "\n" << 1 << "\n" << ans1 << "\n";
else if (min_ == ans2)
cout << ans2 << "\n" << 2 << "\n" << ar[1][0] << " " << ar[1][1] << "\n";
else if (min_ == ans3)
cout << ans3 << "\n"
<< 3 << "\n"
<< ar[2][0] << " " << ar[2][1] << " " << ar[2][2] << "\n";
else
cout << ans4 << "\n"
<< 4 << "\n"
<< ar[3][0] << " " << ar[3][1] << " " << ar[3][2] << " " << ar[3][3]
<< "\n";
}
}
void ff() { ar[0][0] = l; }
void ss() {
long long min_ = 1e16;
for (long long i = l; i < r; i++) {
if (min_ > (i ^ (i + 1))) {
ar[1][0] = i, ar[1][1] = i + 1;
min_ = (i ^ (i + 1));
if (min_ == 1) break;
}
}
}
void tt() {
ar[2][0] = l, ar[2][1] = l + 1, ar[2][2] = l + 2;
long long bit = 0;
for (int i = 60; i >= 0; i--) {
if (l & (1ll << i)) {
bit = i;
break;
}
}
long long x = l;
long long y = l + (1ll << (bit + 1));
long long z = (1ll << (bit + 1));
y = (y ^ (1ll << (bit)));
z = (z ^ (1ll << (bit)));
if (y <= r && z <= r) ar[2][0] = x, ar[2][1] = y, ar[2][2] = z;
}
void fo() {
ar[3][0] = l, ar[3][1] = l + 1, ar[3][2] = l + 2, ar[3][3] = l + 3;
for (long long i = l; i < r - 2; i++) {
if ((i & 3) == 0 || (i & 3) == 2) {
ar[3][0] = i, ar[3][1] = i + 1, ar[3][2] = i + 2, ar[3][3] = i + 3;
break;
}
}
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.