solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T>
inline T abs(T x) {
return x > T() ? x : -x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const long long inf = 1ll << 62;
const int N = 100100;
long long solve(vector<long long>& a, vector<long long>& b,
vector<long long>& c) {
long long res = inf;
for (auto tek : b) {
int idxa = upper_bound((a).begin(), (a).end(), tek) - a.begin() - 1;
if (idxa < 0) {
continue;
}
int idxc = lower_bound((c).begin(), (c).end(), tek) - c.begin();
if (idxc == ((int)(c).size())) {
continue;
}
umn(res, sqr(tek - a[idxa]) + sqr(tek - c[idxc]) + sqr(a[idxa] - c[idxc]));
}
return res;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
int t;
cin >> t;
for (int qqq = int(0); qqq < int(t); ++qqq) {
int na, nb, nc;
cin >> na >> nb >> nc;
vector<long long> a(na), b(nb), c(nc);
for (int i = int(0); i < int(na); ++i) {
cin >> a[i];
}
for (int i = int(0); i < int(nb); ++i) {
cin >> b[i];
}
for (int i = int(0); i < int(nc); ++i) {
cin >> c[i];
}
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
sort((c).begin(), (c).end());
long long ans = inf;
umn(ans, solve(a, b, c));
umn(ans, solve(a, c, b));
umn(ans, solve(b, a, c));
umn(ans, solve(b, c, a));
umn(ans, solve(c, a, b));
umn(ans, solve(c, b, a));
cout << ans << endl;
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
queue<int> stand[10];
int main(){
int n,m; cin>>n>>m;
for(int i=0;i<m;i++){
int a,b; cin>>a>>b;
if(a==1){
int mSize=100000, p=-1;
for(int i=0;i<n;i++){
if(mSize>stand[i].size()){
mSize=stand[i].size();
p=i;
}
}
stand[p].push(b);
}else if(a==0){
cout<<stand[b-1].front()<<endl;
stand[b-1].pop();
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long prev, l, r, p, k;
cin >> p >> k;
vector<int> res;
prev = p;
while (1) {
l = ceil(-(long double)prev / k);
r = ceil((long double)(k - prev) / k);
r--;
if (l > r) {
cout << -1;
return 0;
}
if (l >= k || r < 0) {
if (l >= k) {
res.push_back(prev + l * k);
prev = l;
} else {
res.push_back(prev + r * k);
prev = r;
}
} else if (l >= 0) {
long long temp = max(0LL, l);
res.push_back(prev + temp * k);
if (temp > 0) res.push_back(temp);
break;
}
}
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++) {
cout << res[i] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool remd[200000];
bool assigned[200000];
int main() {
int n, m;
cin >> n >> m;
if (m < n - 1) {
cout << "No" << endl;
return 0;
}
vector<pair<long long, long long> > ro;
vector<pair<pair<long long, long long>, int> > to;
for (int i = 0; i < (n); ++i) {
long long a, b;
cin >> a >> b;
ro.push_back(make_pair(a, b));
}
set<pair<pair<long long, long long>, int> > evs;
for (int i = 0; i < (n - 1); ++i) {
int j = i + 1;
long long d1 = ro[j].first - ro[i].second;
long long d2 = ro[j].second - ro[i].first;
to.push_back(make_pair(make_pair(d2, d1), i));
evs.insert(make_pair(make_pair(d1, 1), i));
evs.insert(make_pair(make_pair(d2, 3), i));
}
vector<pair<long long, int> > lens;
for (int i = 0; i < (m); ++i) {
long long nxt;
cin >> nxt;
lens.push_back(make_pair(nxt, i));
evs.insert(make_pair(make_pair(nxt, 2), i));
}
sort((lens).begin(), (lens).end());
set<pair<long long, int> > active;
vector<int> ans;
for (int i = 0; i < (n - 1); ++i) ans.push_back(0);
for (set<pair<pair<long long, long long>, int> >::iterator it = evs.begin();
it != evs.end(); ++it) {
pair<pair<long long, long long>, int> curr = *it;
int id = curr.second;
long long val = curr.first.first;
int ty = curr.first.second;
if (ty == 2) {
set<pair<long long, int> >::iterator nxt =
active.lower_bound(make_pair(val, 0));
if (nxt == active.end()) {
continue;
}
pair<long long, int> nor = *nxt;
ans[nor.second] = id + 1;
assigned[nor.second] = true;
remd[nor.second] = true;
active.erase(nxt);
} else if (ty == 1) {
active.insert(make_pair(to[id].first.first, id));
} else if (ty == 3) {
if (!remd[id]) {
active.erase(active.find(make_pair(val, id)));
remd[id] = true;
}
}
}
bool pass = true;
for (int i = 0; i < (n - 1); ++i) {
if (!assigned[i]) {
pass = false;
break;
}
}
if (!pass) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
for (int i = 0; i < (int((ans).size())); ++i) {
cout << ans[i] << " ";
}
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x = 0, y, i;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
x += (i % 3 != 0);
y = (i % 3 == 0) ? 3 : 0;
printf("%d %d\n", x, y);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y, i;
cin >> n >> x >> y;
string s;
int ans = 0;
cin >> s;
for (i = n - 1; i >= 0; i--) {
if (n - i - 1 == x) {
break;
} else if (n - i - 1 == y) {
if (s[i] == '0') {
ans++;
}
} else {
if (s[i] == '1') ans++;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
int s[32]={1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
cin>>k;
cout<<s[k-1]<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
const int N = 201000;
int pre[N];
inline int f(char x) { return x == '0' ? 0 : 1; }
int main() {
int T;
cin >> T;
while (T--) {
cin >> s;
int len = s.length();
int ans = 0;
pre[0] = 0;
for (int i = 1; i < len; i++) pre[i] = s[i - 1] == '0' ? pre[i - 1] + 1 : 0;
for (int i = 0; i < len; i++) {
int now = 0;
int fac = 1;
for (int j = i; j >= 0; j--) {
now = now + f(s[j]) * fac;
if (s[j] == '1') {
int c = now - (i - j + 1);
if (c >= 0 && pre[j] >= c) ans++;
}
fac <<= 1;
if (fac > 200000) break;
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b, x, y, m;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> a >> b >> x >> y;
m = 0;
m = max(max(max(max(m, ((a - x - 1) * b)), max(m, (x * b))),
max(m, ((b - y - 1) * a))),
max(m, (y * a)));
cout << m << endl;
}
return 0;
}
| 1 |
#include <cstdio>
#include <algorithm>
#include <vector>
int main() {
size_t n;
scanf("%zu", &n);
std::vector<int> a(n);
for (auto& ai: a) scanf("%d", &ai);
printf("%td\n", std::min_element(a.begin(), a.end())-a.begin()+1);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int nxt() {
int x;
scanf("%d", &x);
return x;
}
const int L = 21;
const int N = 1 << L;
struct Max2 {
int x, y;
Max2() : x(-1), y(-1) {}
void refresh(int z) {
if (z > x) {
y = x;
x = z;
} else if (z > y) {
y = z;
}
}
void refresh(const Max2& ot) {
refresh(ot.x);
refresh(ot.y);
}
};
Max2 d[N];
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n = nxt();
vector<int> a(n);
for (int i = 0; i < n; ++i) {
a[i] = nxt();
}
for (int i = n - 1; i >= 0; --i) {
d[a[i]].refresh(i);
}
for (int j = 0; j < L; ++j) {
for (int i = N - 1; i >= 0; --i) {
if (!(i & (1 << j))) {
d[i].refresh(d[i | (1 << j)]);
}
}
}
int ans = 0;
for (int i = 0; i < n - 2; ++i) {
int x = 0;
for (int j = L - 1; j >= 0; --j) {
if (a[i] & (1 << j)) {
continue;
}
if (d[x | (1 << j)].y > i) {
x |= 1 << j;
}
}
ans = max(ans, a[i] | x);
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 1e2 + 1;
int p, f, ans;
pair<int, int> person[maxN];
int main() {
cin >> p >> f;
for (int i = 0; i < p; i++) cin >> person[i].first >> person[i].second;
for (int i = p - 1; i > -1; i--)
ans = max(ans + (i == p - 1 ? f : person[i + 1].first) - person[i].first,
person[i].second);
cout << ans + person[0].first;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,z,x;
cin>>a>>z>>x;
cout <<x<<" "<<a<<" "<<z;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline int qr() {
int ret = 0, f = 0, c = getchar();
while (!isdigit(c)) f |= c == 45, c = getchar();
while (isdigit(c)) ret = ret * 10 + c - 48, c = getchar();
return f ? -ret : ret;
}
const int maxn = 1e5 + 5;
const int inf = 0x3f3f3f3f;
int r[maxn], siz[maxn], stk[maxn], top, n, m, cnt;
int Find(int x) { return x == r[x] ? x : Find(r[x]); }
int merge(int x, int y) {
x = Find(x), y = Find(y);
if (x == y) return 0;
if (siz[x] > siz[y]) swap(x, y);
cnt -= siz[x] & 1;
cnt -= siz[y] & 1;
r[x] = y;
siz[y] += siz[x];
stk[++top] = x;
cnt += siz[y] & 1;
return 1;
}
void undo(int x = 1e8) {
while (x--) {
int u = stk[top], v = r[u];
cnt -= siz[v] & 1;
siz[v] -= siz[u];
cnt += siz[v] & 1;
cnt += siz[u] & 1;
r[u] = u;
top--;
}
}
int ans[maxn * 3];
struct E {
int u, v, w;
} e[maxn * 3];
map<int, vector<int>> C;
void solve(int tl, int tr, int vl, int vr) {
if (vl > vr) return;
if (tl > tr) return;
int base = 0, backup1 = 0, sav1 = 0, ret = vr;
for (int t = tl; t <= ((tl + tr) >> 1); ++t)
if (e[t].w < vl) base += merge(e[t].u, e[t].v);
for (auto it = C.lower_bound(vl), ed = C.upper_bound(vr); it != ed; ++it)
for (auto t : it->second)
if (t <= ((tl + tr) >> 1)) {
if (cnt) backup1 += merge(e[t].u, e[t].v);
if (!cnt) {
ret = e[t].w;
goto nxt;
}
}
nxt:;
ans[((tl + tr) >> 1)] = ret;
undo(backup1);
solve(((tl + tr) >> 1) + 1, tr, vl, ret);
undo(base);
for (auto it = C.lower_bound(vl), ed = C.lower_bound(ret); it != ed; ++it)
for (auto t : it->second)
if (t < tl) sav1 += merge(e[t].u, e[t].v);
if (tl < ((tl + tr) >> 1)) solve(tl, ((tl + tr) >> 1) - 1, ret, vr);
undo(sav1);
}
int main() {
memset(ans, 0x3f, sizeof ans);
n = qr(), m = qr();
for (int t = 1; t <= n; ++t) r[t] = t, siz[t] = 1;
cnt = n;
for (int t = 1; t <= m; ++t)
e[t].u = qr(), e[t].v = qr(), e[t].w = qr(), C[e[t].w].push_back(t);
solve(1, m, 1, inf);
for (int t = 1; t <= m; ++t) printf("%d\n", ans[t] == inf ? -1 : ans[t]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxVal = 500 * 500;
bool arr[500 + 50][500 + 50][500 + 50];
int main() {
iostream::sync_with_stdio(0);
int n, k;
cin >> n >> k;
vector<int> inp(n);
for (int i = 0; i < n; i++) {
cin >> inp[i];
}
arr[0][0][0] = 1;
for (int i = 0; i < n; i++) {
for (int cur = 0; cur <= k; cur++) {
for (int z = 0; z <= k; z++) arr[i + 1][cur][z] |= arr[i][cur][z];
if (cur + inp[i] <= k) {
for (int z = 0; z + inp[i] <= k; z++)
arr[i + 1][cur + inp[i]][z + inp[i]] |= arr[i][cur][z];
for (int z = 0; z <= k; z++)
arr[i + 1][cur + inp[i]][z] |= arr[i][cur][z];
}
}
}
vector<int> ans;
for (int i = 0; i <= k; i++) {
if (arr[n][k][i]) ans.push_back(i);
}
cout << (int)ans.size() << endl;
for (auto el : ans) cout << el << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, r;
vector<vector<long long> > v;
long double solve() {
vector<vector<long double> > dp(n + 1, vector<long double>(r + 1, 0.l));
long double lo = 0, hi = (1e20), mid, eps = 1e-11;
while ((hi - lo) > eps) {
mid = (lo + hi) / 2.l;
for (int i = n - 1; i >= 0; i--) {
for (int j = r; j >= 0; j--) {
if (v[i][0] + j <= r) {
dp[i][j] = (dp[i + 1][v[i][0] + j] + v[i][0]) * (v[i][2] / 100.l);
if (v[i][1] + j <= r)
dp[i][j] +=
(dp[i + 1][v[i][1] + j] + v[i][1]) * (1.l - (v[i][2] / 100.l));
else
dp[i][j] += (v[i][1] + mid) * (1.l - (v[i][2] / 100.l));
} else
dp[i][j] = mid;
dp[i][j] = min(mid, dp[i][j]);
}
}
if (dp[0][0] == mid)
lo = mid;
else
hi = mid;
}
return mid;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> r;
v.assign(n, vector<long long>(3, 0));
for (int i = 0; i < n; i++) cin >> v[i][0] >> v[i][1] >> v[i][2];
cout << fixed << setprecision(10) << solve();
return 0;
}
| 3 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long lli;
typedef vector<lli> vll;
typedef pair<char,lli> pcl;
typedef vector<pcl> vec;
lli partition(vec& a,lli p,lli r){
lli x = a[r].second;
lli i = p;
for(lli j = p;j < r;j++){
if(a[j].second <= x){
swap(a[j],a[i++]);
}
}
swap(a[i],a[r]);
return i;
}
void qsort(vec& a,lli p,lli r){
if(p < r){
lli q = partition(a,p,r);
qsort(a,p,q-1);
qsort(a,q+1,r);
}
}
lli n;
vec a;
vec b;
void output(){
for(lli i = 0;i < n;i++) cout << a[i].first << " " << a[i].second << endl;
}
int main(){
cin >> n;
a = vec(n);
for(lli i = 0;i < n;i++) cin >> a[i].first >> a[i].second;
b = a;
qsort(a,0,n-1);
stable_sort(b.begin(),b.end(),[](pcl a,pcl b){
return a.second < b.second;
});
for(lli i = 0;i < n;i++){
if(a[i].first != b[i].first){
cout << "Not stable" << endl;
output();
return 0;
}
}
cout << "Stable" << endl;
output();
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
long long mod = a % b;
long long ans = b - mod;
if (mod == 0)
cout << 0 << endl;
else
cout << ans << endl;
}
}
| 4 |
#include<iostream>
using namespace std;
int main(){
char c;
cin>>c;
if(c=='A')
cout<<'T';
else if(c=='T')
cout<<'A';
else if(c=='C')
cout<<'G';
else if(c=='G')
cout<<'C';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double INF = 1e9;
const int N = 52;
double dp[N][N][N];
int n, a[N], b[N], id[N];
int cmp(int x, int y) { return a[x] > a[y]; }
void M(double& x, double y) { x = min(x, y); }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
id[i] = i;
}
for (int i = 1; i <= n; i++) cin >> b[i];
sort(id + 1, id + n + 1, cmp);
double l = 0, r = 1e8;
while (r - l > 1e-7) {
double mid = (l + r) / 2;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) fill(dp[i][j], dp[i][j] + N, INF);
dp[0][0][0] = 0;
for (int i = 0; i < n; i++) {
int i1 = id[i + 1], i2 = id[i];
for (int j = 0; j <= i; j++) {
for (int k = 0; k <= i; k++) {
if (dp[i][j][k] < INF - 1) {
if (a[i1] == a[i2]) {
if (k) M(dp[i + 1][j][k - 1], dp[i][j][k]);
if (j + 1 < N)
M(dp[i + 1][j + 1][k], dp[i][j][k] + a[i1] - mid * b[i1]);
} else {
if (j + k && j + k - 1 < N)
M(dp[i + 1][0][j + k - 1], dp[i][j][k]);
if (k + j < N)
M(dp[i + 1][1][k + j], dp[i][j][k] + a[i1] - mid * b[i1]);
}
}
}
}
}
double res = 1e9;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) res = min(res, dp[n][i][j]);
}
if (res < 0)
r = mid;
else
l = mid;
}
cout << fixed << setprecision(0) << ceil(l * 1000);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int n = 1e5+5;
int N, M;
vector<int> G[n];
bool vis[n];
bool col[n];
void DFS(int v, int pr, bool c){
col[v] = c;
vis[v] = true;
for(int j : G[v]){
//int j = p.first;
//bool cg = p.second;
if(!vis[j] && j != pr){
DFS(j, v, c);
}
}
}
int main(){
cin >> N >> M;
for(int i = 0; i < M; ++i){
int u,v,w;
cin >> u >> v >> w;
u--;v--;
G[u].push_back(v);
G[v].push_back(u);
}
int C = 0;
for(int i =0; i < N; ++i){
if(!vis[i]){
C++;
DFS(i, -1, true);
}
}
cout << C << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string S,T;
while(cin >> S >> T, S != "0" && T != "0"){
set<char> st;
for(char& c : S) st.insert(c);
int hit = 0;
int blow = 0;
for(int i = 0; i < T.size(); i++){
if(S[i] == T[i]) hit++;
else blow += st.count(T[i]);
}
cout << hit << " " << blow << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool Can(long long n, long long m, long long c) {
if (c / 2 < n) return false;
if (c / 3 < m) return false;
long long odd_threes = c / 3 - c / 6;
if (m <= odd_threes) {
m = 0;
return true;
}
m -= odd_threes;
long long even_used = m;
if (c / 2 - even_used < n)
return false;
else
return true;
}
int main() {
int n, m;
cin >> n >> m;
long long low = 1;
long long high = 1000000000000000000ll;
while (low < high) {
long long mid = (low + high) / 2;
if (Can(n, m, mid)) {
high = mid;
} else {
low = mid + 1;
}
}
cout << low << endl;
}
| 3 |
#include<iostream>
#include<string>
using namespace std;
int main(){
string a;
while(getline(cin,a)){
int i=0;
while(true){
bool t=false;
if(a[i]=='@'){
for(int j=0;j<a[i+1]-'0';j++)
cout<<a[i+2];
i+=2;
if(i>=a.size())
break;
t=true;
}
if(i>=a.size())
break;
if(t==false)
cout<<a[i];
i++;
if(i>=a.size())
break;
}
cout<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
namespace fft {
struct num {
long double x, y;
num() { x = y = 0; }
num(long double x, long double y) : x(x), y(y) {}
};
inline num operator+(num a, num b) { return num(a.x + b.x, a.y + b.y); }
inline num operator-(num a, num b) { return num(a.x - b.x, a.y - b.y); }
inline num operator*(num a, num b) {
return num(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
}
inline num conj(num a) { return num(a.x, -a.y); }
long long base = 1;
vector<num> roots = {{0, 0}, {1, 0}};
vector<long long> rev = {0, 1};
const long double PI = acosl(-1.0);
void ensure_base(long long nbase) {
if (nbase <= base) {
return;
}
rev.resize(1 << nbase);
for (long long i = 0; i < (1 << nbase); i++) {
rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (nbase - 1));
}
roots.resize(1 << nbase);
while (base < nbase) {
long double angle = 2 * PI / (1 << (base + 1));
for (long long i = 1 << (base - 1); i < (1 << base); i++) {
roots[i << 1] = roots[i];
long double angle_i = angle * (2 * i + 1 - (1 << base));
roots[(i << 1) + 1] =
num(cos((long double)angle_i), sin((long double)angle_i));
}
base++;
}
}
void fft(vector<num> &a, long long n = -1) {
if (n == -1) {
n = a.size();
}
assert((n & (n - 1)) == 0);
long long zeros = __builtin_ctz(n);
ensure_base(zeros);
long long shift = base - zeros;
for (long long i = 0; i < n; i++) {
if (i < (rev[i] >> shift)) {
swap(a[i], a[rev[i] >> shift]);
}
}
for (long long k = 1; k < n; k <<= 1) {
for (long long i = 0; i < n; i += 2 * k) {
for (long long j = 0; j < k; j++) {
num z = a[i + j + k] * roots[j + k];
a[i + j + k] = a[i + j] - z;
a[i + j] = a[i + j] + z;
}
}
}
}
vector<num> fa, fb;
vector<long long> multiply(vector<long long> &a, vector<long long> &b) {
long long need = a.size() + b.size() - 1;
long long nbase = 0;
while ((1 << nbase) < need) nbase++;
ensure_base(nbase);
long long sz = 1 << nbase;
if (sz > (long long)fa.size()) {
fa.resize(sz);
}
for (long long i = 0; i < sz; i++) {
long long x = (i < (long long)a.size() ? a[i] : 0);
long long y = (i < (long long)b.size() ? b[i] : 0);
fa[i] = num(x, y);
}
fft(fa, sz);
num r(0, -0.25 / sz);
for (long long i = 0; i <= (sz >> 1); i++) {
long long j = (sz - i) & (sz - 1);
num z = (fa[j] * fa[j] - conj(fa[i] * fa[i])) * r;
if (i != j) {
fa[j] = (fa[i] * fa[i] - conj(fa[j] * fa[j])) * r;
}
fa[i] = z;
}
fft(fa, sz);
vector<long long> res(need);
for (long long i = 0; i < need; i++) {
res[i] = fa[i].x + 0.5;
}
return res;
}
}; // namespace fft
long long n, m, k;
long long pre[200010], suf[200010];
long long v[200010];
long long ris = 0;
long long tot = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
long long som = 0;
vector<long long> a(k, 0), b(k, 0), c(k, 0);
for (long long i = 0; i < n; i++) {
cin >> v[i];
som = (som + v[i]) % k;
c[som]++;
}
for (long long i = 0; i < m - 1; i++) tot = (tot + som) % k;
long long sos = 0;
for (long long i = 0; i < n; i++) {
sos = (sos + v[i]) % k;
ris += pre[sos] + pre[(k - (som + tot) + k) % k];
if (sos == 0) ris++;
som = (som - v[i] + k) % k;
ris %= 1000000007;
pre[sos]++;
}
som = 0;
for (long long i = n - 1; i >= 0; i--) {
som = (som + v[i]) % k;
a[som]++;
}
long long kek = 0;
for (long long i = 0; i < m - 1; i++, kek = (kek + som) % k) {
b[kek]++;
}
if (k <= 1000) {
vector<long long> pro(k * 2, 0);
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++)
pro[i + j] = (pro[i + j] + a[i] * b[j]) % 1000000007;
a = pro;
for (long long i = 0; i < k; i++) {
for (long long j = i + k; j < (long long)a.size(); j += k) a[i] += a[j];
}
a.resize(k);
pro = vector<long long>(k * 2, 0);
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++)
pro[i + j] = (pro[i + j] + a[i] * c[j]) % 1000000007;
a = pro;
} else {
if (som != 0) {
a = fft::multiply(a, b);
for (long long i = 0; i < k; i++) {
for (long long j = i + k; j < (long long)a.size(); j += k) a[i] += a[j];
}
a.resize(k);
for (long long i = 0; i < (long long)a.size(); i++) a[i] %= 1000000007;
a = fft::multiply(a, c);
} else {
for (int i = 0; i < k; i++) a[i] = (a[i] * b[0]) % 1000000007;
a = fft::multiply(a, c);
}
}
for (long long i = 0; i < (long long)a.size(); i += k) {
ris = (ris + a[i]) % 1000000007;
}
cout << ((ris * m) % 1000000007 -
((tot + som) % k == 0 ? n * m - 1 : 0) % 1000000007 + 1000000007) %
1000000007
<< "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[101];
int b[101];
int storage[200001];
int storage2[200001];
int* value = storage + 100000;
int* prevalue = storage2 + 100000;
int n, k;
int main() {
scanf("%d%d", &n, &k);
int gtzero = 0, lezero = 0;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]), b[i] *= k;
for (int i = 0; i < n; i++) {
b[i] = a[i] - b[i];
if (b[i] > 0)
gtzero += b[i];
else
lezero += b[i];
}
for (int i = 0; i < sizeof(storage) / sizeof(int); i++) {
storage[i] = -19200000;
storage2[i] = -19200000;
}
value[0] = prevalue[0] = 0;
for (int i = 0; i < n; i++) {
int C = b[i];
for (int j = -10000; j <= 10000; j++) {
value[j] = max(prevalue[j], prevalue[j - b[i]] + a[i]);
}
memcpy(storage2, storage, sizeof(storage));
}
if (value[0] > 0)
printf("%d\n", value[0]);
else
printf("-1\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = 1000001000;
const long long INFLL = INF * 1LL * INF;
const int mod = 1000 * 1000 * 1000 + 7;
const int mod9 = 1000 * 1000 * 1000 + 9;
const int modr = 99990001;
const long double PI = 3.1415926535897932385;
template <class T>
void zero(T val, T& first) {
first = val;
}
template <class T, class... Targs>
void zero(T val, T& first, Targs&... Fargs) {
first = val;
zero(val, Fargs...);
}
template <class T, class T2>
std::istream& operator>>(std::istream& is, pair<T, T2>& p) {
return is >> p.first >> p.second;
}
template <class T>
std::istream& readN(T& first, int n, int st = 0) {
for (int i = st, iend = (st + n - 1); i <= iend; i++) cin >> first[i];
return cin;
}
template <class T>
std::istream& readS(set<T>& first, int n) {
T second = *first.rbegin();
for (int i = 0, iend = (n - 1); i <= iend; i++) {
cin >> second;
first.insert(second);
}
return cin;
}
template <class T>
std::istream& read(T& first) {
return cin >> first;
}
template <class T, class... Targs>
std::istream& read(T& first, Targs&... Fargs) {
return read(first), read(Fargs...);
}
template <class T, class T2>
std::ostream& operator<<(std::ostream& os, pair<T, T2> p) {
return os << p.first << " " << p.second;
}
template <class T>
std::ostream& operator<<(std::ostream& os, vector<T> v) {
bool f = true;
for (auto second : v) {
if (!f) os << ' ';
os << second;
f = false;
}
return os;
}
template <class T>
std::ostream& operator<<(std::ostream& os, set<T> v) {
bool f = true;
for (auto second : v) {
if (!f) os << ' ';
os << second;
f = false;
}
return os;
}
template <class T>
std::ostream& operator<<(std::ostream& os, multiset<T> v) {
bool f = true;
for (auto second : v) {
if (!f) os << ' ';
os << second;
f = false;
}
return os;
}
template <class T, class T2>
std::ostream& operator<<(std::ostream& os, map<T, T2> v) {
bool f = true;
for (pair<T, T2> second : v) {
if (!f) os << ' ';
os << second.first << "=>" << second.second;
f = false;
}
return os;
}
template <class T>
std::ostream& outV(T first, char del = ' ') {
bool f = true;
for (auto second : first) {
if (!f) cout << del;
cout << second;
f = false;
}
return cout;
}
template <class T>
std::ostream& outN(T first, int n = -1, int st = 0) {
for (int i = st, iend = (n == -1 ? (int)first.size() - 1 : st + n - 1);
i <= iend; i++) {
cout << first[i];
if (i < iend) cout << ' ';
}
return cout;
}
template <class T>
std::ostream& outAN(T first, int n = -1, int st = 0) {
for (int i = st, iend = (n - 1); i <= iend; i++) {
cout << first[i];
if (i < iend) cout << ' ';
}
return cout;
}
template <class T>
std::ostream& outA2(T first, int n, int m) {
for (int i = 0, iend = (n - 1); i <= iend; i++) {
for (int j = 0, jend = (m - 1); j <= jend; j++)
cout << first[i][j] << (j == m - 1 ? '\n' : ' ');
}
return cout;
}
template <class T>
std::ostream& out(T first) {
return cout << first;
}
template <class T, class... Targs>
std::ostream& out(T first, Targs... Fargs) {
return out(first) << " ", out(Fargs...);
}
template <typename T>
void srt(T& a, int st, int fn, bool isArr) {
sort(a + st, a + fn + 1);
}
template <class T>
void srt(T& a, int st = 0, int fn = 0) {
sort(a.begin() + st, fn ? a.begin() + fn + 1 : a.end());
}
template <typename T>
T rev_num(T a) {
T r = 0;
for (; a; a /= 10) r = r * 10 + a % 10;
return r;
}
template <typename T>
void rev(T& a, int st, int fn, bool isArr) {
reverse(a + st, a + fn + 1);
}
template <class T>
void rev(T& a, int st = 0, int fn = 0) {
reverse(a.begin() + st, fn ? a.begin() + fn + 1 : a.end());
}
long long sqr(long long a) { return a * a; };
long long sqr(int a) { return a * 1LL * a; };
long double sqr(long double a) { return a * a; };
long long sqDist(pair<long long, long long> first,
pair<long long, long long> second) {
return sqr(first.first - second.first) + sqr(first.second - second.second);
}
long double dist(pair<long long, long long> first,
pair<long long, long long> second) {
return sqrt(sqDist(first, second));
}
long long phi(int n) {
int res = n;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) {
while (n % i == 0) n /= i;
res -= res / i;
}
if (n > 1) res -= res / n;
return res;
}
long long bpm(long long a, long long n = -2, long long m = mod) {
n = n < 0 ? n + m : n;
long long r = 1;
while (n) {
if (n & 1) r = (r * a) % m;
a = (a * a) % m;
n >>= 1;
}
return r;
}
unsigned long long gcd(unsigned long long a, unsigned long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long gcd_cb(long long a, long long b, long long& first,
long long& second) {
if (!b) {
first = 1;
second = 0;
return a;
}
long long x1, y1, g;
g = gcd_cb(b, a % b, x1, y1);
first = y1;
second = x1 - a / b * y1;
return g;
}
vector<long long> fact;
void fact_prec(int n = 20) {
fact.resize(n + 1);
fact[0] = 1;
for (int i = 1, iend = (n); i <= iend; i++) {
fact[i] = fact[i - 1] * i;
}
}
vector<long double> factd;
void fact_precd(int n = 146) {
factd.resize(n + 1);
factd[0] = 1;
for (int i = 1, iend = (n); i <= iend; i++) {
factd[i] = factd[i - 1] * i;
}
}
string str(long long a) {
string r = "";
for (; a; a /= 10) r += a % 10 + '0';
rev(r);
return r;
}
template <class T>
int bitc(T first) {
int r = 0;
for (T d = first; d > 0; d >>= 1) {
r += d & 1;
}
return r;
}
const int N = 300005;
int gc(string s) {
return count(s.begin(), s.end(), 'a') + count(s.begin(), s.end(), 'e') +
count(s.begin(), s.end(), 'i') + count(s.begin(), s.end(), 'o') +
count(s.begin(), s.end(), 'u');
}
int main() {
string f, s, t;
getline(cin, f);
getline(cin, s);
getline(cin, t);
puts((gc(f) == 5 && gc(s) == 7 && gc(t) == 5) ? "YES" : "NO");
;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct tuhla {
int vertex;
long long cost;
};
vector<struct tuhla> v[100007];
long long dist[100007];
int used[100007];
int prv[100007];
bool operator<(struct tuhla p1, struct tuhla p2) { return (p1.cost > p2.cost); }
priority_queue<struct tuhla> q;
void dijkstra() {
struct tuhla u, e;
int i, sz;
for (i = 1; i <= n; i++) {
if (dist[i] == -1) {
continue;
}
u.vertex = i;
u.cost = dist[i];
q.push(u);
}
while (q.empty() == false) {
u = q.top();
q.pop();
if (dist[u.vertex] != u.cost) {
continue;
}
int sz = v[u.vertex].size();
for (i = 0; i < sz; i++) {
if (dist[v[u.vertex][i].vertex] == dist[u.vertex] + v[u.vertex][i].cost) {
prv[v[u.vertex][i].vertex] = 0;
}
if (dist[v[u.vertex][i].vertex] == -1 ||
dist[v[u.vertex][i].vertex] > dist[u.vertex] + v[u.vertex][i].cost) {
dist[v[u.vertex][i].vertex] = dist[u.vertex] + v[u.vertex][i].cost;
e.vertex = v[u.vertex][i].vertex;
e.cost = dist[v[u.vertex][i].vertex];
prv[e.vertex] = 0;
q.push(e);
}
}
}
}
void input() {
scanf("%d%d%d", &n, &m, &k);
int i;
struct tuhla u;
for (i = 1; i <= m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
u.vertex = y;
u.cost = z;
v[x].push_back(u);
u.vertex = x;
v[y].push_back(u);
}
for (i = 1; i <= n; i++) {
dist[i] = -1;
}
dist[1] = 0;
for (i = 1; i <= k; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (dist[x] == -1 || dist[x] > y) {
dist[x] = y;
prv[x] = i;
}
}
}
void solve() {
dijkstra();
int i;
int br = 0;
for (i = 2; i <= n; i++) {
used[prv[i]]++;
}
for (i = 1; i <= k; i++) {
if (used[i] == 0) {
br++;
}
}
printf("%d\n", br);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int main(void)
{
int w;
cin>>w;
cout<<w*32<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long a, b, c;
cin >> a >> b >> c;
cout << min(min(a + b + c, 2 * (a + b)), min(2 * (a + c), 2 * (b + c)));
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 52;
const int mod = 1000000007;
int n, k, li, hi;
struct node {
int x, y, id;
};
long long dp[maxn][maxn][2];
long long way[maxn][maxn][2];
long long c[maxn][maxn];
void bfs() {
memset(dp, -1, sizeof(dp));
memset(way, 0, sizeof(way));
dp[li][hi][0] = 0;
way[li][hi][0] = 1;
node now, next;
queue<node> q;
now.x = li, now.y = hi, now.id = 0;
q.push(now);
while (!q.empty()) {
now = q.front();
q.pop();
int xx = now.x, yy = now.y, ff = now.id;
for (int i = 0; i <= xx; i++) {
for (int j = 0; j <= yy; j++) {
if ((i + j) == 0 || (i + 2 * j) > k) continue;
int x = li - xx + i, y = hi - yy + j, f = 1 - ff;
if (dp[x][y][f] == -1) {
dp[x][y][f] = dp[xx][yy][ff] + 1;
way[x][y][f] = (way[x][y][f] +
c[xx][i] * way[xx][yy][ff] % mod * c[yy][j] % mod) %
mod;
next.x = x, next.y = y, next.id = f;
q.push(next);
} else if (dp[x][y][f] == dp[xx][yy][ff] + 1)
way[x][y][f] = (way[x][y][f] +
c[xx][i] * way[xx][yy][ff] % mod * c[yy][j] % mod) %
mod;
}
}
}
}
int main() {
scanf("%d%d", &n, &k);
k /= 50;
for (int i = 0; i <= n; i++) {
c[i][0] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
int a;
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
if (a == 50)
li++;
else
hi++;
}
bfs();
printf("%I64d\n%I64d\n", dp[li][hi][1], way[li][hi][1]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string S, T;
cin >> S >> T;
int ans = T.length();
for(int i=0; i<S.length()-T.length()+1; ++i){
int cnt = 0;
for(int j=0; j<T.length(); ++j){
if(T[j]!=S[j+i]) ++cnt;
}
ans = min(ans,cnt);
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, L;
int a[100010];
int memo[100010];
int f(int x) {
if (x == 0 || x == n + 1 || memo[x]) return memo[x];
int res = L - a[x];
if (a[x - 1] > a[x] && a[x] > a[x + 1]) {
res += f(x - 1);
} else if (a[x - 1] < a[x] && a[x] < a[x + 1]) {
res += f(x + 1);
} else if (a[x - 1] > a[x] && a[x] < a[x + 1]) {
res += max(f(x - 1), f(x + 1));
}
return memo[x] = res;
}
int main(void) {
cin >> n >> L;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 1; i <= n; i++) {
memo[i] = f(i);
ans = max(ans, memo[i]);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 100;
const int maxN = 5010;
int dp[maxN][maxN / 2][2][2];
int a[maxN];
int n;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
a[0] = -(int)1e9;
a[n + 1] = -(int)1e9;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= (n + 1) / 2; j++) {
for (int ok = 0; ok < 2; ok++) {
dp[i][j][ok][0] = INF;
dp[i][j][ok][1] = INF;
}
}
}
dp[0][0][0][0] = 0;
for (int i = 0; i + 1 <= n; i++) {
for (int j = 0; j <= (n + 1) / 2; j++) {
for (int last1 = 0; last1 < 2; last1++) {
for (int last2 = 0; last2 < 2; last2++) {
dp[i + 1][j][last2][0] =
min(dp[i + 1][j][last2][0], dp[i][j][last1][last2]);
if (last2 == 1) continue;
if (last1 == 0) {
int sh = 0;
if (a[i] >= a[i + 1]) sh = a[i] - a[i + 1] + 1;
int sh2 = 0;
if (a[i + 2] >= a[i + 1]) sh2 = a[i + 2] - a[i + 1] + 1;
dp[i + 1][j + 1][0][1] =
min(dp[i + 1][j + 1][0][1], dp[i][j][last1][last2] + sh + sh2);
} else {
int cur = 0;
if (i == 0) continue;
cur = min(a[i], a[i - 1] - 1);
int sh = 0;
if (cur >= a[i + 1]) sh = cur - a[i + 1] + 1;
int sh2 = 0;
if (a[i + 2] >= a[i + 1]) sh2 = a[i + 2] - a[i + 1] + 1;
dp[i + 1][j + 1][0][1] =
min(dp[i + 1][j + 1][0][1], dp[i][j][last1][last2] + sh + sh2);
}
}
}
}
}
for (int k = 1; k <= (n + 1) / 2; k++) {
int mn = dp[n][k][0][0];
for (int ok1 = 0; ok1 < 2; ok1++) {
for (int ok2 = 0; ok2 < 2; ok2++) {
mn = min(mn, dp[n][k][ok1][ok2]);
}
}
cout << mn << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int INF = 2e9;
const long long LNF = 9e18;
const int mod = 1e9 + 7;
const int maxn = 2e3 + 10;
int n, m, k;
bool val[maxn], pos[maxn];
long long C[maxn][maxn], A[maxn];
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x != -1) val[x] = pos[i] = 1;
}
k = m = 0;
for (int i = 1; i <= n; i++) {
if (!pos[i]) m++;
if (!pos[i] && !val[i]) k++;
}
A[0] = 1;
C[0][0] = 1;
for (int i = 1; i <= m; i++) {
A[i] = (1LL * i * A[i - 1]) % mod;
C[i][0] = 1;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
}
void solve() {
long long ans = A[m];
for (int i = 1; i <= k; i++) {
long long tmp = (1LL * C[k][i] * A[m - i]) % mod;
ans -= (i & 1) ? tmp : -tmp;
ans = (ans + mod) % mod;
}
cout << ans << endl;
}
int main() {
init();
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int level;
vector<int> child;
};
int nodes_per_level[100001] = {0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, p, sum = 1;
cin >> n;
node a[n + 1];
for (int i = 2; i <= n; i++) {
cin >> p;
a[p].child.push_back(i);
}
queue<int> q;
q.push(1);
a[1].level = 1;
while (!q.empty()) {
int i = q.front();
q.pop();
for (int j = 0, len = a[i].child.size(); j < len; j++) {
q.push(a[i].child[j]);
a[a[i].child[j]].level = a[i].level + 1;
nodes_per_level[a[a[i].child[j]].level]++;
}
}
for (int i = 2; i <= n; i++)
if (nodes_per_level[i] % 2 != 0) sum++;
cout << sum << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n >> m;
long A = 2l * n;
long B = 3l * m;
long C = min(A, B) / 6;
for (int c = 0; c < C; c++) {
if (A <= B + 1) {
A += 2;
} else {
B += 3;
}
C = min(A, B) / 6;
}
cout << max(A, B) << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
string str, ans;
int n, k;
cin >> n >> k;
cin >> str;
ans = str;
for (int i = k; i < n; i++) ans[i] = ans[i - k];
if (str <= ans) {
cout << ans.length() << endl;
cout << ans;
return;
}
for (int i = k - 1; i >= 0; i--) {
if (ans[i] != '9') {
int temp = ans[i] - '0';
ans[i] = (char)(temp + 1 + '0');
while (++i < k) ans[i] = '0';
break;
}
}
for (int i = k; i < n; i++) ans[i] = ans[i - k];
cout << ans.length() << endl;
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[12][12];
bool check() {
for (int i = 0; i < 10; i++) {
int cnt1 = 0;
for (int j = 0; j < 10; j++) {
if (s[i][j] == 'X')
cnt1++;
else {
if (cnt1 >= 5) return true;
cnt1 = 0;
}
}
if (cnt1 >= 5) return true;
}
for (int j = 0; j < 10; j++) {
int cnt1 = 0;
for (int i = 0; i < 10; i++) {
if (s[i][j] == 'X')
cnt1++;
else {
if (cnt1 >= 5) return true;
cnt1 = 0;
}
}
if (cnt1 >= 5) return true;
}
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
int x = i, y = j, cnt1 = 0;
while (1) {
if (x >= 10) break;
if (y >= 10) break;
if (s[x][y] == 'X')
cnt1++;
else {
if (cnt1 >= 5) return true;
cnt1 = 0;
}
x++;
y++;
}
if (cnt1 >= 5) return true;
}
}
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
int x = i, y = j, cnt1 = 0;
while (1) {
if (x < 0) break;
if (y < 0) break;
if (x >= 10) break;
if (y >= 10) break;
if (s[x][y] == 'X')
cnt1++;
else {
if (cnt1 >= 5) return true;
cnt1 = 0;
}
x--;
y--;
}
if (cnt1 >= 5) return true;
}
}
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
int x = i, y = j, cnt1 = 0;
while (1) {
if (x < 0) break;
if (y < 0) break;
if (x >= 10) break;
if (y >= 10) break;
if (s[x][y] == 'X')
cnt1++;
else {
if (cnt1 >= 5) return true;
cnt1 = 0;
}
x++;
y--;
}
if (cnt1 >= 5) return true;
}
}
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
int x = i, y = j, cnt1 = 0;
while (1) {
if (x < 0) break;
if (y < 0) break;
if (x >= 10) break;
if (y >= 10) break;
if (s[x][y] == 'X')
cnt1++;
else {
if (cnt1 >= 5) return true;
cnt1 = 0;
}
x--;
y++;
}
if (cnt1 >= 5) return true;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) cin >> s[i][j];
}
int flag = 0;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
if (s[i][j] == '.') {
s[i][j] = 'X';
bool ans = check();
if (ans == true)
flag = 1;
else
s[i][j] = '.';
}
}
}
if (flag)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
map<char,int> dic;
char tmp;
int cnt=0;
while(cin>>tmp){
dic[tmp]++;
cnt++;
}
if(cnt==dic.size())cout <<"yes"<<endl;
else cout <<"no"<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int A[300005], cum[300005], f[300005], fcum[300005], mark[300005];
vector<pair<int, int> > queries;
int mod(int a) {
a %= 1000000009;
if (a < 0) a += 1000000009;
return a;
}
int main() {
int n, q, type, l, r, a, b, ans, pos;
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
cum[i] = mod(cum[i - 1] + A[i]);
}
f[1] = f[2] = fcum[1] = 1;
fcum[2] = 2;
for (int i = 3; i < 300005; i++) {
f[i] = mod(f[i - 1] + f[i - 2]);
fcum[i] = mod(fcum[i - 1] + f[i]);
}
int sq = sqrt(q);
for (int big = 1; big <= q; big += sq) {
queries.clear();
for (int j = big; j <= min(big + sq - 1, q); j++) {
scanf("%d %d %d", &type, &l, &r);
if (type == 2) {
ans = mod(cum[r] - cum[l - 1]);
for (int k = 0; k < queries.size(); k++) {
if (queries[k].first > r || queries[k].second < l) continue;
if (l <= queries[k].first)
a = 1, pos = queries[k].first;
else
a = l - queries[k].first + 1, pos = l;
if (r <= queries[k].second)
b = (r - pos) + a;
else
b = (queries[k].second - pos) + a;
ans = mod(ans + (fcum[b] - fcum[a - 1]));
}
printf("%d\n", ans);
} else {
queries.push_back(make_pair(l, r));
mark[l]++;
mark[r + 1] = mod(mark[r + 1] - (f[r - l + 1] + f[r - l]) % 1000000009),
mark[r + 2] = mod(mark[r + 2] - f[r - l + 1]);
}
}
A[1] = mod(mark[1] + A[1]);
cum[1] = A[1];
for (int i = 2; i < 300005; i++) {
mark[i] = mod(mark[i] + ((mark[i - 1] + mark[i - 2]) % 1000000009));
A[i] = mod(mark[i] + A[i]);
cum[i] = mod(cum[i - 1] + A[i]);
mark[i - 2] = 0;
}
mark[300005 - 2] = mark[300005 - 1] = 0;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int x, y, z, t1, t2, t3;
cin >> x >> y >> z >> t1 >> t2 >> t3;
int walk = abs(x - y) * t1, elv = abs(x - z) * t2 + abs(x - y) * t2 + 3 * t3;
cout << (walk < elv ? "NO\n" : "YES\n");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9, -1, 0, -1};
char h[101];
int main() {
int q, w, e, r, t, sum = 0;
int e1, r1, c, v, c1, v1;
cin >> q;
cin >> h;
for (e = 0; e < 4; e++) {
for (r = 0; r < 3; r++) {
e1 = e;
r1 = r;
if (a[e1][r1] == -1) {
continue;
}
for (w = 1; w < q; w++) {
for (c = 0; c < 4; c++) {
for (v = 0; v < 3; v++) {
if (a[c][v] == h[w - 1] - 48) {
goto st;
}
}
}
st:
c1 = c;
v1 = v;
for (c = 0; c < 4; c++) {
for (v = 0; v < 3; v++) {
if (a[c][v] == h[w] - 48) {
goto st2;
}
}
}
st2:
e1 += c - c1;
r1 += v - v1;
if (!(((0 <= e1) && (e1 < 4)) && ((0 <= r1) && (r1 < 3)))) {
goto miss;
}
if (a[e1][r1] == -1) {
goto miss;
}
}
sum++;
miss:;
}
}
if (sum > 1) {
cout << "NO";
} else {
cout << "YES";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double Pi = acos(-1.0);
pair<int, int> toPoint[100011];
map<pair<int, int>, int> toIndex;
int N, lo[100011];
bool check(pair<int, int> a) {
if (!toIndex[a]) return false;
for (int dx = -1; dx <= 1; dx++) {
pair<int, int> n(a.first + dx, a.second + 1);
int id = toIndex[n];
if (id && lo[id] <= 1) return false;
}
return true;
}
int main() {
if (fopen("data.in", "r")) freopen("data.in", "r", stdin);
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d", &toPoint[i].first);
scanf("%d", &toPoint[i].second);
toIndex[toPoint[i]] = i;
}
for (int i = 1; i <= N; i++) {
pair<int, int> c = toPoint[i];
for (int dx = -1; dx <= 1; dx++) {
pair<int, int> n(c.first + dx, c.second - 1);
int ind = toIndex[n];
if (ind) lo[i]++;
}
}
set<int> ok;
for (int i = 1; i <= N; i++)
if (check(toPoint[i])) ok.insert(i);
int ans = 0;
for (int i = 1; i <= N; i++) {
int nxt = *(i % 2 ? --ok.end() : ok.begin());
ok.erase(nxt);
if (!check(toPoint[nxt])) {
i--;
continue;
}
toIndex[toPoint[nxt]] = 0;
pair<int, int> c = toPoint[nxt];
for (int dx = -1; dx <= 1; dx++) {
lo[toIndex[pair<int, int>(c.first + dx, c.second + 1)]]--;
if (check(pair<int, int>(c.first + dx, c.second - 1)))
ok.insert(toIndex[pair<int, int>(c.first + dx, c.second - 1)]);
}
ans = ((long long)ans * N + nxt - 1) % 1000000009;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
const long long int inf = 9e18;
const long double pi = 2 * acos(0.0);
const int N = 1000005;
long long int tes, n;
vector<long long int> sieve(N, 0);
void si() {
sieve[1] = 1;
for (int i = 2; i < N; i++) {
if (sieve[i] == 0) {
for (int j = i; j < N; j += i) {
sieve[j] = i;
}
}
}
}
long long int power(long long int x, long long int y) {
long long int res = 1ll;
while (y > 0) {
if (y & 1) res = res * x;
res %= 998244353;
y >>= 1;
x = x * x;
x %= 998244353;
}
return res;
}
long long int solve1(long long int start,
vector<vector<vector<long long int>>>& dp,
long long int curr_mask, long long int last,
vector<vector<long long int>>& arr,
vector<vector<long long int>>& brr) {
if (curr_mask + 1 == (1 << n)) return inf;
if (dp[start][curr_mask][last] != -inf) return dp[start][curr_mask][last];
long long int curr_cnt = __builtin_popcount(curr_mask);
;
for (int i = 0; i < n; i++) {
if (curr_mask >> i & 1) continue;
long long int temp =
min(arr[last][i], solve1(start, dp, curr_mask | (1 << i), i, arr, brr));
if (curr_cnt == n - 1) temp = min(temp, brr[start][i]);
dp[start][curr_mask][last] = max(dp[start][curr_mask][last], temp);
}
return dp[start][curr_mask][last];
}
void solve() {
long long int m, ans = 0;
cin >> n >> m;
vector<vector<long long int>> arr(n, vector<long long int>(n, inf)),
brr(n, vector<long long int>(n, inf)), crr(n, vector<long long int>(m));
vector<vector<vector<long long int>>> dp(
n,
vector<vector<long long int>>((1 << n), vector<long long int>(n, -inf)));
;
for (int i = 0; i < n; i++) {
;
for (int j = 0; j < m; j++) cin >> crr[i][j];
};
for (int i = 0; i < n; i++) {
;
for (int j = 0; j < n; j++) {
if (i == j) continue;
;
for (int k = 0; k < m; k++)
arr[i][j] = min(arr[i][j], abs(crr[i][k] - crr[j][k]));
}
};
for (int i = 0; i < n; i++) {
;
for (int j = 0; j < n; j++) {
if (i == j) continue;
;
for (int k = 1; k < m; k++)
brr[i][j] = min(brr[i][j], abs(crr[i][k] - crr[j][k - 1]));
}
}
if (n == 1) {
ans = inf;
;
for (int i = 1; i < m; i++) ans = min(ans, abs(crr[0][i] - crr[0][i - 1]));
cout << ans << "\n";
return;
};
for (int i = 0; i < n; i++)
ans = max(ans, solve1(i, dp, (1 << i), i, arr, brr));
cout << ans << "\n";
}
int32_t main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
tes = 2;
while (tes--) {
solve();
break;
}
}
| 6 |
#include <stdio.h>
int n, v, a[25][2], r; bool f[25];
void p1(int u) { if(!~u) return; printf(" %d", u), p1(a[u][0]), p1(a[u][1]); }
void p2(int u) { if(!~u) return; p2(a[u][0]), printf(" %d", u), p2(a[u][1]); }
void p3(int u) { if(!~u) return; p3(a[u][0]), p3(a[u][1]), printf(" %d", u); }
int main() {
scanf("%d", &n);
for(int i = 0; i < n; i++) scanf("%d", &v), scanf("%d%d", a[v], a[v] + 1), f[a[v][0]] = f[a[v][1]] = true;
for(int i = 0; i < n; i++) if(!f[i]) r = i;
puts("Preorder"); p1(r); puts("");
puts("Inorder"); p2(r); puts("");
puts("Postorder"); p3(r); puts("");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e8;
struct bigNum {
int a[20], len;
bigNum() {
len = 0;
memset(a, 0, sizeof a);
}
inline void operator=(int x) {
memset(a, 0, sizeof a);
a[0] = x;
len = 1;
}
inline void print() {
cout << a[len - 1];
for (int i = len - 2; i >= 0; i--) {
int k = mod / 10;
if (a[i] < 0) {
cout << "USAKDH" << endl;
}
while (a[i] < k) {
cout << 0;
k /= 10;
}
if (a[i]) {
cout << a[i];
}
}
cout << endl;
}
};
inline bigNum operator*(const bigNum &a, int x) {
bigNum ans;
ans.len = a.len;
int c = 0;
long long tmp;
for (int i = 0; i < a.len; i++) {
tmp = 1LL * a.a[i] * x + c;
ans.a[i] = tmp % mod;
c = tmp / mod;
}
if (c) {
ans.a[ans.len] = c;
c /= mod;
ans.len++;
}
return ans;
}
inline bigNum operator*(const bigNum &a, const bigNum &b) {
bigNum ans;
ans.len = a.len + b.len;
int c;
long long tmp;
for (int i = 0; i < a.len; i++) {
c = 0;
for (int j = 0; j < b.len; j++) {
tmp = 1LL * ans.a[i + j] + 1LL * a.a[i] * b.a[j] + c;
c = tmp / mod;
ans.a[i + j] = tmp % mod;
}
ans.a[i + b.len] = c;
}
if (ans.a[ans.len - 1] == 0) {
ans.len--;
}
return ans;
}
inline bool operator<(const bigNum &x, const bigNum &y) {
if (x.len != y.len) {
return x.len < y.len;
}
for (int i = x.len - 1; i >= 0; i--) {
if (x.a[i] != y.a[i]) {
return x.a[i] < y.a[i];
}
}
return false;
}
bigNum dp[707][707];
int sz[707];
vector<int> adj[707];
void dfs(int v, int p) {
sz[v] = adj[v].size() + 1;
int uncng = 1;
dp[v][1].a[0] = 1;
dp[v][1].len = 1;
for (auto u : adj[v]) {
if (u == p) continue;
dfs(u, v);
sz[v] = max(sz[v], sz[u] + 1);
for (int i = sz[v]; i > 1; i--) {
dp[v][i] = dp[v][i] * dp[u][0];
dp[v][i] = max(dp[v][i], dp[v][1] * dp[u][i - 1]);
dp[v][i] = max(dp[v][i], dp[v][i - 1] * dp[u][1]);
}
dp[v][1] = dp[v][1] * dp[u][0];
}
for (int i = 1; i <= sz[v]; i++) {
dp[v][0] = max(dp[v][0], dp[v][i] * i);
}
}
int main() {
int n;
cin >> n;
for (int i = 1, q, w; i < n; i++) {
cin >> q >> w;
adj[q].push_back(w);
adj[w].push_back(q);
}
dfs(1, -1);
dp[1][0].print();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x;
cin >> n >> k;
int *count = new int[k + 5];
for (int i = 0; i < k + 5; i++) count[i] = 0;
for (int i = 0; i < n; i++) {
cin >> x;
count[x]++;
}
int coins = 0;
while (count[k] != n) {
for (int i = k - 1; i >= 1; i--) {
if (count[i] > 0) {
count[i + 1]++;
count[i]--;
}
}
coins++;
}
cout << coins << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
int t, i, j;
double n, a, b, lo, hi, mid, mul;
cin >> t;
for (i = 0; i < t; i++) {
cin >> n;
lo = 0.0;
hi = n;
for (j = 0; j <= 100; j++) {
mid = (lo + hi) / 2.0;
a = mid;
b = n - mid;
mul = a * b;
if (mul - n > 1e-10) {
hi = mid;
} else if (n - mul > 1e-10) {
lo = mid;
}
}
if (abs(mid * (n - mid) - n) <= 1e-10) {
cout << "Y " << std::setprecision(12) << mid << ' '
<< std::setprecision(12) << n - mid << endl;
} else
cout << "N" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 100007;
vector<int> liczby;
int N;
void dane() {
cin >> N;
int i;
for ((i) = 0; (i) < (int)(N); (i)++) {
int a;
cin >> a;
liczby.push_back(a);
}
}
int main() {
dane();
int pocz = 0;
int kon = N - 1;
pocz++;
kon--;
int czeko1 = liczby[0];
int czeko2 = liczby[N - 1];
int ilosc1 = 1;
int ilosc2 = 0;
if (N != 1) ilosc2++;
while (pocz < kon + 1) {
if (czeko1 <= czeko2) {
czeko1 += liczby[pocz++];
ilosc1++;
} else {
czeko2 += liczby[kon--];
ilosc2++;
}
}
cout << ilosc1 << " " << ilosc2 << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, d[100 + 5];
void Process();
int main() {
Process();
return 0;
}
long long Make(long long x, long long p, long long q) {
long long k = 0ll;
for (long long i = 1; i <= q; ++i) k = (k << p) + x;
return k;
}
long long Check(long long p, long long q, long long k) {
if (Make(1ll << (p - 1ll), p, q) > k) return 0ll;
long long x = 1ll << (p - 1ll), y = (1ll << p), mid;
while (x + 1ll != y) {
mid = (x + y) / 2ll;
if (Make(mid, p, q) <= k)
x = mid;
else
y = mid;
}
return x - (1ll << (p - 1ll)) + 1ll;
}
long long Cal(long long k) {
long long S = 0ll;
for (long long i = 1; i <= 60; ++i) {
memset(d, 0, sizeof(d));
for (long long j = 1; j < i; ++j)
if (i % j == 0) {
d[j] = Check(j, i / j, k);
for (int l = 1; l < j; ++l)
if (j % l == 0) d[j] -= d[l];
S += d[j];
}
}
return S;
}
void Process() {
cin >> x >> y;
cout << Cal(y) - Cal(x - 1ll) << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using db = double;
void out(int x, int y) { printf("%d %d\n", x + 1, y + 1); }
int n;
void foo(int x) {
for (int i = 0; i < n; ++i) {
int j = (x - i + n) % n;
if (i < j) out(i, j);
}
}
int main() {
cin >> n;
if (n % 4 == 0) {
puts("YES");
for (int i = 0; i < n; i += 4) {
foo(i);
foo(i + 1);
foo(i + 3);
foo(i + 2);
}
} else if (n % 4 == 1) {
--n;
puts("YES");
for (int i = 0; i < n; i += 4) {
out(i, n);
foo(i);
foo(i + 1);
out(i + 1, n);
out(i + 3, n);
foo(i + 3);
foo(i + 2);
out(i + 2, n);
}
} else {
puts("NO");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, k, p;
vector<int> adj[maxn];
int h[maxn];
int total[maxn];
int hmax;
void dfs(int v, int par) {
++total[h[v]];
hmax = max(hmax, h[v]);
for (auto u : adj[v])
if (u != par) {
h[u] = h[v] + 1;
dfs(u, v);
}
}
int used[maxn];
bool ok(int x) {
int pointer = 2;
int cnt = 0;
long long cost = 0;
for (int depht = 2; depht <= hmax; ++depht) used[depht] = 0;
for (int depht = 2; depht <= hmax; ++depht) {
cost += cnt;
cnt += total[depht];
used[depht] = total[depht];
while (cost > p) {
if (!used[pointer]) ++pointer;
cost -= (depht - pointer);
--used[pointer];
--cnt;
}
if (cost <= p && cnt >= x) return true;
}
return false;
}
int bs() {
int L = 1;
int R = min(k, n - 1);
while (L < R) {
int mid = (L + R + 1) >> 1;
if (ok(mid))
L = mid;
else
R = mid - 1;
}
return R;
}
int solve() {
if (!k) return 0;
h[1] = 1;
dfs(1, -1);
return bs();
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> p;
for (int i = 1; i <= n - 1; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
cout << solve() << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void Weapons19() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
long long t = 0;
set<pair<long long, long long>> w;
void dfs(char k, char p, vector<string> &v, long long n, long long m,
long long a, long long b) {
if (a < 0 || b < 0 || a + 1 > n || b + 1 > m) return;
if (v[a][b] == '*') w.insert(make_pair(a, b));
if (v[a][b] != p) return;
t++;
v[a][b] = k;
dfs(k, p, v, n, m, a - 1, b);
dfs(k, p, v, n, m, a, b - 1);
dfs(k, p, v, n, m, a, b + 1);
dfs(k, p, v, n, m, a + 1, b);
}
int32_t main() {
Weapons19();
long long n, m;
cin >> n >> m;
vector<string> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
vector<vector<long long>> ans(n, vector<long long>(m, 0));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
t = 0;
if (v[i][j] == '.') {
dfs('B', '.', v, n, m, i, j);
for (auto a : w) {
ans[a.first][a.second] += t;
}
w.clear();
}
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (v[i][j] == 'B')
cout << '.';
else
cout << (ans[i][j] + 1) % 10;
}
cout << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int edge(int n, int x, int y) {
if (y == 0) return x;
if (y == n) return 2 * n + n - x;
if (x == n) return n + y;
if (x == 0) return 3 * n + n - y;
return -1;
}
int main() {
int n, x1, y1, x2, y2;
cin >> n >> x1 >> y1 >> x2 >> y2;
int e1, e2;
e1 = edge(n, x1, y1);
e2 = edge(n, x2, y2);
cout << ((((e1 - e2) < 0 ? -(e1 - e2) : (e1 - e2))) <
(((4 * n - e1 + e2) < (4 * n - e2 + e1) ? (4 * n - e1 + e2)
: (4 * n - e2 + e1)))
? (((e1 - e2) < 0 ? -(e1 - e2) : (e1 - e2)))
: (((4 * n - e1 + e2) < (4 * n - e2 + e1) ? (4 * n - e1 + e2)
: (4 * n - e2 + e1))));
return 0;
}
| 1 |
#include<cstdio>
#define MAX 50
int Pre[MAX];
int In[MAX];
int Post[MAX];
int pos = 0;
int p = 0;
int n;
void reconstruction(int l, int r)
{
if(l >= r)
return;
int root = Pre[pos++];
int m;
for(int i=0; i<n; i++)
{
if(In[i] == root)
{
m = i;
break;
}
}
reconstruction(l,m);
reconstruction(m+1,r);
Post[p++] = root;
}
int main()
{
//int n;
scanf("%d", &n);
for(int i=0; i<n; i++)
scanf("%d", &Pre[i]);
for(int i=0; i<n; i++)
scanf("%d", &In[i]);
reconstruction(0,n);
for(int i=0; i<p; i++)
{
if(i) printf(" ");
printf("%d",Post[i]);
}
printf("\n");
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define N 100005
typedef long long ll;
ll ans[N];
int main()
{
string s;
cin >> s;
int n = s.size();
int start = 0;
while(start < n){
int end = start;
while(s[end] == 'R') end++;
int r = end - 1;
int l = end;
while(s[end] == 'L') end++;
end--;
for(int i = start ; i <= end ; i++){
if(i % 2 == r % 2) ans[r]++;
else ans[l]++;
}
start = end + 1;
}
for(int i = 0 ; i < n ; i++)
cout << ans[i] << " ";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e5 + 10;
long long int rangeQuery(long long int segtree[], long long int qlow,
long long int qhigh, long long int low,
long long int high, long long int pos) {
if (qlow > qhigh) return 0;
if (qlow <= low && qhigh >= high) {
return segtree[pos];
}
if (qlow > high || qhigh < low) {
return 0;
}
long long int mid = (low + high) / 2;
return rangeQuery(segtree, qlow, qhigh, low, mid, 2 * pos + 1) +
rangeQuery(segtree, qlow, qhigh, mid + 1, high, 2 * pos + 2);
}
void update(long long int segtree[], long long int qlow, long long int qhigh,
long long int low, long long int high, long long int val,
long long int pos) {
if (qlow <= low && qhigh >= high) {
segtree[pos] = val;
return;
}
if (qlow > high || qhigh < low) {
return;
}
long long int mid = (low + high) / 2;
update(segtree, qlow, qhigh, low, mid, val, 2 * pos + 1);
update(segtree, qlow, qhigh, mid + 1, high, val, 2 * pos + 2);
segtree[pos] = segtree[2 * pos + 1] + segtree[2 * pos + 2];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int i, a[N + 10], ans[N + 10], seg[4 * N + 10], fre[N + 10];
memset(ans, 0, sizeof(ans));
memset(seg, 0, sizeof(seg));
memset(fre, 0, sizeof(fre));
for (i = 1; i <= n; i++) cin >> a[i];
if (n == 1) {
cout << "1"
<< "\n";
} else {
if (a[1] > a[2]) {
fre[a[1] - 1]++;
fre[a[2] - 1]++;
}
update(seg, a[1] - 1, a[1] - 1, 0, n - 1, 1, 0);
update(seg, a[2] - 1, a[2] - 1, 0, n - 1, 1, 0);
long long int maxi = max(a[1] - 1, a[2] - 1);
for (i = 3; i <= n; i++) {
long long int ele = a[i] - 1;
long long int tmp = rangeQuery(seg, ele + 1, n - 1, 0, n - 1, 0);
if (tmp == 1) fre[maxi]++;
if (tmp > 1) fre[ele]++;
maxi = max(maxi, ele);
update(seg, ele, ele, 0, n - 1, 1, 0);
}
long long int flag = 0, res = 0;
for (i = 0; i <= n - 1; i++) {
if (fre[i] >= 2) {
flag = 1;
}
if (fre[i] > fre[res]) res = i;
}
cout << res + 1 << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool helper(string &s, int n, int p) {
char maxi = (p - 1 + 'a');
for (int i = n - 1; i >= 0; i--) {
for (char c = s[i] + 1; c <= maxi; c++) {
if (i >= 1 && s[i - 1] == c) continue;
if (i >= 2 && s[i - 2] == c) continue;
s[i] = c;
for (int j = i + 1; j < n; j++) {
for (char ch = 'a'; ch <= maxi; ch++) {
if (j >= 1 && s[j - 1] == ch) continue;
if (j >= 2 && s[j - 2] == ch) continue;
s[j] = ch;
break;
}
}
cout << s;
return true;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, p;
cin >> n >> p;
string s;
cin >> s;
if (!helper(s, n, p)) cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500 + 10;
struct node {
int x, y;
};
int n, m, deg[N][N], sum[N][N], val[N][N];
int dis[N * N], fa[N * N];
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
string s[N];
int in(int x, int y) { return 0 <= x && x < n && 0 <= y && y < m; }
int find(int x) {
if (fa[x] == x) return x;
int anc = find(fa[x]);
dis[x] ^= dis[fa[x]];
return fa[x] = anc;
}
void con(int x, int y) {
sum[x][y] = 0;
for (int i = 0; i < 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (!in(nx, ny)) return;
sum[x][y] += val[nx][ny];
}
return;
}
int merge(int x, int y, int v) {
find(x), find(y);
v ^= dis[x] ^ dis[y];
x = find(x), y = find(y);
if (x == y) {
if (v == 0) return 1;
return 0;
}
dis[x] = v, fa[x] = y;
return 1;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n * m; i++) fa[i] = i, dis[i] = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < 4; k++) {
int x = i + dx[k], y = j + dy[k];
if (!in(x, y)) continue;
if (s[i][j] != s[x][y]) {
deg[i][j]++;
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'X' && deg[i][j] % 2 == 1) {
cout << "NO" << endl;
return 0;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] != 'X' || deg[i][j] != 2) continue;
vector<int> x, y;
for (int k = 0; k < 4; k++) {
int nx = i + dx[k], ny = j + dy[k];
if (!in(nx, ny) || s[nx][ny] == 'X') continue;
x.push_back(nx), y.push_back(ny);
}
for (int k = 1; k < int((x).size()); k++) {
assert(merge(((x[k - 1]) * m + y[k - 1]), ((x[k]) * m + y[k]), 1));
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] != 'X' || deg[i][j] != 4) continue;
vector<int> x, y;
for (int k = 0; k < 4; k++) {
int nx = i + dx[k], ny = j + dy[k];
if (!in(nx, ny) || s[nx][ny] == 'X') continue;
x.push_back(nx), y.push_back(ny);
}
for (int k = 1; k < int((x).size()); k++) {
assert(merge(((x[k - 1]) * m + y[k - 1]), ((x[k]) * m + y[k]), 1));
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'X') continue;
find(((i)*m + j));
sum[i][j] = val[i][j] = 1 + dis[((i)*m + j)] * 3;
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'X') con(i, j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << sum[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void File() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
void IO() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int main() {
IO();
int n;
int a, b, c, ans = 0;
cin >> a >> b >> c >> n;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
if (x > b && x < c) ans++;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long inline gcd(long long x, long long y) {
return !y ? (long long)abs(x) : gcd(y, x % y);
}
long long inline lcm(long long a, long long b) {
return ((long long)abs((a / gcd(a, b)) * b));
}
double inline cartesian_dist(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
long long bigmod(long long b, long long p, long long m) {
if (!p)
return 1 % m;
else if (p & 1)
return (((b % m) + m) % m * bigmod(b, p - 1, m)) % m;
else {
long long ret = bigmod(b, p / 2, m);
return (ret * ret) % m;
}
}
long long inverse(long long a, long long m) { return bigmod(a, m - 2, m); }
long long extended(long long a, long long m) {
long long oldr = a, r = m, oldans = 1, ans = 0, quotient;
while (r) {
quotient = oldr / r;
oldr = oldr - r * quotient;
swap(oldr, r);
oldans = oldans - ans * quotient;
swap(oldans, ans);
}
return ((oldans % m) + m) % m;
}
const double PI = acos(-1.0);
const double eps = 10E-12;
const long long MOD = 101LL;
const long long inf = 5 * (long long)1e18 + 5;
int n, k, t[(int)1e5 + 5], currL = 0, currR = 0;
int arr[(int)1e5 + 5], addF[(int)1e5 + 5], subB[(int)1e5 + 5],
cnt[(int)1e6 + 5];
map<long long, int> M;
long long sum[(int)1e5 + 5], res = 0, ans[(int)1e5 + 5];
vector<pair<pair<int, int>, pair<int, int> > > vec;
void updateRF(int r) {
while (currR < r) {
++currR;
res += (long long)cnt[subB[currR]];
++cnt[arr[currR]];
}
}
void updateLB(int l) {
while (currL > l) {
--currL;
res += (long long)cnt[addF[currL]];
++cnt[arr[currL]];
}
}
void updateLF(int l) {
while (currL < l) {
--cnt[arr[currL]];
res -= (long long)cnt[addF[currL]];
++currL;
}
}
void updateRB(int r) {
while (currR > r) {
--cnt[arr[currR]];
res -= (long long)cnt[subB[currR]];
--currR;
}
}
void calculateResult() {
++cnt[arr[0]];
for (int i = 0; i < vec.size(); i++) {
updateRF(vec[i].first.second);
updateLB(vec[i].second.first);
updateLF(vec[i].second.first);
updateRB(vec[i].first.second);
ans[vec[i].second.second] = res;
}
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
for (int i = 1; i <= n; i++) {
scanf("%lld", &sum[i]);
sum[i] *= (t[i] == 1) ? 1LL : -1LL;
sum[i] += sum[i - 1];
M[sum[i]];
M[sum[i] + (long long)k];
M[sum[i] - (long long)k];
}
M[sum[0]];
M[sum[0] + (long long)k];
M[sum[0] - (long long)k];
int id = 0;
for (map<long long, int>::iterator it = M.begin(); it != M.end(); it++)
it->second = ++id;
for (int i = 0; i <= n; i++) {
arr[i] = M[sum[i]];
addF[i] = M[sum[i] + (long long)k];
subB[i] = M[sum[i] - (long long)k];
}
int q, l, r;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d %d", &l, &r);
--l;
vec.push_back(make_pair(make_pair(l / 320, r), make_pair(l, i)));
}
sort(vec.begin(), vec.end());
calculateResult();
for (int i = 1; i <= q; i++) printf("%lld\n", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int64_t infll = 9223372036854775807LL;
bool doQuery(int64_t x, int64_t y) {
cout << 1 << " " << x << " " << y << endl;
fflush(stdout);
string s;
cin >> s;
return (s == "TAK");
}
int64_t doBinSearch(int64_t l, int64_t r) {
while (r != l) {
int64_t m = (l + r) / 2;
if (doQuery(m, m + 1)) {
r = m;
} else {
l = m + 1;
}
}
return r;
}
void solve() {
int64_t n, k;
cin >> n >> k;
int64_t dish1, dish2, dish2a, dish2b;
dish1 = doBinSearch(1, n);
if (dish1 == 1) {
dish2 = doBinSearch(2, n);
} else if (dish1 == n) {
dish2 = doBinSearch(1, n - 1);
} else {
dish2a = doBinSearch(1, dish1 - 1);
dish2b = doBinSearch(dish1 + 1, n);
dish2 = doQuery(dish2a, dish2b) ? dish2a : dish2b;
}
cout << 2 << " " << dish1 << " " << dish2 << endl;
fflush(stdout);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, x;
cin >> n >> x;
int ans = 0, now = 0;
for (int i = 1; i <= n; i++) {
int l, r;
cin >> l >> r;
now++;
ans += (l - now) % x;
ans += (r - l) + 1;
now = r;
}
cout << ans;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 1e9+7;
int main(){
int a,b,c,d,e,k; cin>>a>>b>>c>>d>>e>>k;
cout <<(e-a>k?":(":"Yay!")<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long k, p, n, m;
long long dp[100][5];
long long tmp[10];
long long ok = 0;
void print(char str[], long long num, long long len) {
if (str[1] == 'C') {
for (long long i = 2; i <= 2 * num; i += 2) {
str[i] = 'A';
str[i + 1] = 'C';
}
for (long long i = 2 * num + 2; i <= len - 1; i++) str[i] = 'Z';
} else {
for (long long i = 1; i <= 2 * num; i += 2) {
str[i] = 'A';
str[i + 1] = 'C';
}
for (long long i = 2 * num + 1; i <= len - 1; i++) str[i] = 'Z';
}
for (long long i = 1; i <= len; i++) printf("%c", str[i]);
printf("\n");
}
long long solve(long long x, long long y, long long status) {
long long hehe = status;
memset(dp, 0, sizeof(dp));
long long tt = 0;
memset(tmp, 0, sizeof(tmp));
while (status) {
tt++;
tmp[tt] = status % 2;
status /= 2;
}
long long tx;
long long ty;
tx = ty = 0;
if (tmp[2] && tmp[3]) tmp[4] = 1;
if (tmp[1]) {
return 0;
tx += 2;
}
if ((tmp[2] || tmp[3]) && (tmp[2] != tmp[3])) {
tx++;
ty++;
}
if (tmp[2] && tmp[3]) {
tx += 2;
ty += 2;
}
if (tmp[4] && tmp[3] == 0) {
ty += 2;
}
if (x * 2 + tx > n) return 0;
if (y * 2 + ty > m) return 0;
memset(dp, 0, sizeof(dp));
dp[1][1] = x;
dp[2][1] = y;
dp[3][1] = x + y;
dp[3][3] = tmp[2];
for (long long i = 4; i <= k; i++) {
for (long long j = 1; j <= 5; j++) dp[i][j] += dp[i - 1][j] + dp[i - 2][j];
if (i % 2 == 0)
dp[i][4] += tmp[3];
else
dp[i][5] += tmp[4];
}
long long tsum = 0;
for (long long j = 1; j <= 5; j++) tsum += dp[k][j];
if (tsum != p) return 0;
char ansa[105];
char ansb[105];
memset(ansa, 0, sizeof(ansa));
memset(ansb, 0, sizeof(ansb));
if (tmp[1]) {
ansa[1] = 'C';
ansa[n] = 'A';
}
if (tmp[2]) {
ansa[n] = 'A';
ansb[1] = 'C';
}
if (tmp[3]) {
ansa[1] = 'C';
ansb[m] = 'A';
}
if (tmp[4]) {
ansb[1] = 'C';
ansb[m] = 'A';
}
if (ansa[n] == '\0') ansa[n] = 'Z';
if (ansb[m] == '\0') ansb[m] = 'Z';
print(ansa, x, n);
print(ansb, y, m);
return 1;
}
int main() {
scanf("%I64d %I64d %I64d %I64d", &k, &p, &n, &m);
for (long long i = 0; i <= n / 2; i++) {
for (long long j = 0; j <= m / 2; j++) {
for (long long s = 0; s <= 15; s++)
if (solve(i, j, s)) return 0;
}
}
printf("Happy new year!\n");
return 0;
}
| 4 |
#include <iostream>
using namespace std;
const int INF = (1 << 30);
struct Edge {
int from, to, cost;
};
int main() {
int V, E, r;
cin >> V >> E >> r;
Edge edges[E];
for (int i = 0; i < E; ++i) {
int s, t, c;
cin >> s >> t >> c;
edges[i] = Edge({s, t, c});
}
int d[V];
fill(d, d + V, INF);
d[r] = 0;
for (int i = 0; i < V; ++i) {
for (int j = 0; j < E; ++j) {
Edge e = edges[j];
if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost) {
if (i == V - 1) {
cout << "NEGATIVE CYCLE" << endl;
return 0;
}
d[e.to] = d[e.from] + e.cost;
}
}
}
for (int i = 0; i < V; ++i) {
if (d[i] == INF) {
cout << "INF" << endl;
} else {
cout << d[i] << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
char str[10001];
int mem[1001][1001];
char GetMin(int m1, int m2) {
m1 -= 'a';
m2 -= 'a';
for (int i = 0; i < p; i++) {
if (i != m1 && i != m2) return i + 'a';
}
return 'a';
}
string nextString(string str, bool &isGood) {
isGood = true;
string res = str;
bool bOk = false;
for (int i = str.length() - 1; i >= 0; i--) {
char c = str[i] + 1;
while ((c - 'a') < p && c <= 'z') {
isGood = true;
if (i - 1 >= 0) {
if (c == res[i - 1]) {
isGood = false;
}
}
if (i - 2 >= 0) {
if (c == res[i - 2]) isGood = false;
}
if (isGood) {
bOk = true;
break;
}
c++;
}
if (bOk) {
res[i] = c;
int cnt = 0;
for (int j = i + 1; j < str.length(); j++) {
res[j] = GetMin((j - 1 >= 0) ? res[j - 1] : 'A',
(j - 2 >= 0) ? res[j - 2] : 'B');
cnt = (cnt + 1) % 3;
}
break;
} else {
res[i] = 'a';
}
}
if (!bOk) res = "";
return res;
}
bool IsPalin(string str) {
int l = str.length() - 1;
int i = 0;
if (l < 1) return false;
while (i < l) {
if (str[i++] != str[l--]) return false;
}
return true;
}
bool CheckSub(string str, int i, int j) {
return false;
if (i >= j || i >= str.length() || j < 0) return false;
if (mem[i][j]) return (mem[i][j] == 1);
bool r1, r2, r3;
r1 = r2 = r3 = false;
r1 = IsPalin(str.substr(i, (j - i) + 1));
if (!r1) r2 = CheckSub(str, i, j - 1);
if (!r1 && !r2) r3 = CheckSub(str, i + 1, j);
if (r1 || r2 || r3)
mem[i][j] = 1;
else
mem[i][j] = 2;
return r1 || r2 || r3;
}
bool preTest(string str) {
for (int i = 0; i < str.length() - 2; i++) {
if (str[i] == str[i + 1]) return true;
}
return false;
}
int main() {
bool bGotIt = false;
string str;
string res = "NO";
cin >> n >> p;
cin >> str;
string nxtString = str;
bool isGood;
while ((nxtString = nextString(str, isGood)) != "") {
str = nxtString;
memset(mem, 0, sizeof(mem));
if (CheckSub(nxtString, 0, nxtString.length() - 1) == false) {
res = nxtString;
break;
}
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int multiplicativeOrder(long long a, int Q) {
int res = 1;
for (int i = 1;; ++i) {
res = res * a % Q;
if (res == 1) return i;
}
return -1;
}
int power(long long a, int b, int MOD) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = res * a % MOD;
}
a = a * a % MOD;
b /= 2;
}
return res;
}
int main() {
int M, a, Q, N;
cin >> N >> M >> a >> Q;
int k = multiplicativeOrder(a, Q);
vector<int> pref(N, 0);
pref[0] = 1;
for (int i = 0; i + 1 < N; ++i) {
pref[i + 1] = pref[i] * (long long)(M - i) * power(i + 1, k - 2, k) % k;
}
for (int i = 1; i < N; ++i) {
pref[i] += pref[i - 1];
if (pref[i] >= k) pref[i] -= k;
}
for (int i = N - 1; i >= 0; --i) {
printf("%d ", power(a, pref[i], Q));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int sz = 2e5 + 10;
bool check(ll mid, ll n, ll k) {
ll pw = 1;
ll sum = 0;
while (mid / pw) {
sum += (mid / pw);
pw *= k;
}
return sum >= n;
}
int main() {
ll n, k;
ll l, r, mid;
while (cin >> n >> k) {
l = 1;
r = n;
for (int i = 0; i < 64; i++) {
mid = (l + r) >> 1;
if (check(mid, n, k)) {
r = mid;
} else {
l = mid + 1;
}
}
cout << mid << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1001001001;
const long long INFLL = 1001001001001001001LL;
template <typename T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <typename T>
void chmin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
void chmax(T& a, T b) {
if (a < b) a = b;
}
int xb[100050], yb[100050], xe[100050], ye[100050];
struct cut {
int A, B1, B2;
} C1[100050], C2[100050];
bool operator<(const cut& a, const cut& b) { return a.A < b.A; }
pair<int, int> P[200050];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int c1 = 0, c2 = 0;
for (int i = 0; i < k; ++i) {
scanf("%d%d%d%d", &xb[i], &yb[i], &xe[i], &ye[i]);
if (xb[i] == xe[i]) {
C1[c1].A = xb[i];
C1[c1].B1 = min(yb[i], ye[i]);
C1[c1].B2 = max(yb[i], ye[i]);
++c1;
} else {
C2[c2].A = yb[i];
C2[c2].B1 = min(xb[i], xe[i]);
C2[c2].B2 = max(xb[i], xe[i]);
++c2;
}
}
sort(C1, C1 + c1);
sort(C2, C2 + c2);
int ns = m - 1, ms = n - 1;
vector<int> rem1, xx, rem2, yy;
vector<vector<pair<int, int> > > sp1, sp2;
for (int i = 0; i < c1;) {
int j = i;
while (j < c1 && C1[i].A == C1[j].A) ++j;
int ps = 0;
for (int k = i; k < j; ++k) {
P[ps++] = make_pair(C1[k].B1, +1);
P[ps++] = make_pair(C1[k].B2, -1);
}
sort(P, P + ps);
int prev = 0, s = 0, r = 0;
sp1.push_back(vector<pair<int, int> >());
for (int k = 0; k < ps; ++k) {
if (s == 0) {
sp1.back().push_back(make_pair(prev, P[k].first));
r += P[k].first - prev;
}
s += P[k].second;
prev = P[k].first;
}
sp1.back().push_back(make_pair(prev, m));
r += m - prev;
rem1.push_back(r);
xx.push_back(C1[i].A);
--ms;
i = j;
}
for (int i = 0; i < c2;) {
int j = i;
while (j < c2 && C2[i].A == C2[j].A) ++j;
int ps = 0;
for (int k = i; k < j; ++k) {
P[ps++] = make_pair(C2[k].B1, +1);
P[ps++] = make_pair(C2[k].B2, -1);
}
sort(P, P + ps);
int prev = 0, s = 0, r = 0;
sp2.push_back(vector<pair<int, int> >());
for (int k = 0; k < ps; ++k) {
if (s == 0) {
sp2.back().push_back(make_pair(prev, P[k].first));
r += P[k].first - prev;
}
s += P[k].second;
prev = P[k].first;
}
sp2.back().push_back(make_pair(prev, n));
r += n - prev;
rem2.push_back(r);
yy.push_back(C2[i].A);
--ns;
i = j;
}
unsigned X = 0;
if (ms % 2 == 1) X ^= m;
if (ns % 2 == 1) X ^= n;
for (int i = 0; i < (int)rem1.size(); ++i) {
X ^= rem1[i];
}
for (int i = 0; i < (int)rem2.size(); ++i) {
X ^= rem2[i];
}
if (X == 0) {
puts("SECOND");
} else {
puts("FIRST");
if (ms > 0 && (unsigned)m > (unsigned)(m ^ X)) {
int mx = 1;
for (int i = 0; i < (int)xx.size(); ++i) {
if (xx[i] == mx) {
++mx;
}
}
int am = (unsigned)m - (unsigned)(m ^ X);
printf("%d 0 %d %d\n", mx, mx, am);
return 0;
} else if (ns > 0 && (unsigned)n > (unsigned)(n ^ X)) {
int ny = 1;
for (int i = 0; i < (int)yy.size(); ++i) {
if (yy[i] == ny) {
++ny;
}
}
int am = (unsigned)n - (unsigned)(n ^ X);
printf("0 %d %d %d\n", ny, am, ny);
return 0;
} else {
for (int i = 0; i < (int)rem1.size(); ++i) {
if ((unsigned)rem1[i] > (unsigned)(rem1[i] ^ X)) {
int am = (unsigned)rem1[i] - (unsigned)(rem1[i] ^ X);
int cur = 0;
for (int j = 0; j < (int)sp1[i].size(); ++j) {
int ss = sp1[i][j].second - sp1[i][j].first;
if (cur + ss >= am) {
int pt = am - cur + sp1[i][j].first;
printf("%d 0 %d %d\n", xx[i], xx[i], pt);
return 0;
}
cur += ss;
}
}
}
for (int i = 0; i < (int)rem2.size(); ++i) {
if ((unsigned)rem2[i] > (unsigned)(rem2[i] ^ X)) {
int am = (unsigned)rem2[i] - (unsigned)(rem2[i] ^ X);
int cur = 0;
for (int j = 0; j < (int)sp2[i].size(); ++j) {
int ss = sp2[i][j].second - sp2[i][j].first;
if (cur + ss >= am) {
int pt = am - cur + sp2[i][j].first;
printf("0 %d %d %d\n", yy[i], pt, yy[i]);
return 0;
}
cur += ss;
}
}
}
}
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
typedef pair<ll,ll> P;
typedef pair<ll,P> PP;
const ll MOD = 1e9+7;
int main(){
ll n,m;
while(cin>>n>>m,n){
ll a[1111];
for(int i=0;i<n;i++){
cin>>a[i];
}
ll ans=0;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
ll tmp=a[i]+a[j];
if(tmp>m)continue;
ans=max(ans,tmp);
}
}
if(ans)cout<<ans<<endl;
else cout<<"NONE"<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define sz(x) ((int) (x).size())
#define forn(i,n) for (int i = 0; i < int(n); ++i)
typedef long long ll;
typedef long long i64;
typedef long double ld;
const int inf = int(1e9) + int(1e5);
const ll infl = ll(2e18) + ll(1e10);
const int mod = 86400;
const int len = 10801;
int d[mod];
int main() {
#ifdef LOCAL
assert(freopen("h.in", "r", stdin));
#else
#endif
int n;
cin >> n;
int t = 0;
forn (i, n) {
int a, b;
cin >> a >> b;
t += a;
t %= mod;
d[t]++;
t += b;
}
int sum = 0;
forn (i, len)
sum += d[i];
int best = 0;
forn (i, mod) {
best = max(best, sum);
sum -= d[i];
sum += d[(i + len) % mod];
}
cout << best << '\n';
}
| 0 |
#include<iostream>
using namespace std;
int main() {
char a;
cin >> a;
if (a >= 'a' && a <= 'z')cout << 'a';
else cout << "A";
} | 0 |
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define fio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll long long
#define ull unsigned long long
#define ld long double
#define endl "\n"
#define ff first
#define ss second
#define pi pair<ll, ll>
#define PI 3.141592653589793238462643383279502884L
#define mp make_pair
#define pb push_back
#define fall(i, a, b) for (int i = a; i < b; i++)
#define sz(x) (ll) x.size()
#define all(x) x.begin(), x.end()
#define ed cout << "ed";
#define time_passed 1.0 * clock() / CLOCKS_PER_SEC
ll MOD = 1e9 + 7;
ll MOD1 = 1e9 + 123;
ll MOD2 = 1e9 + 321;
int main()
{
fio;
ll t, a, n, q, s, k, l, i, m, r, c, u, f, j, p, x, y, b, d;
c = 0;
vector<int>V;
int v[] = {1,11, 111, 1111, 11111, 111111, 1111111, 11111111, 111111111};
for(i=1;i<10;i++)
for(j=0;j<9;j++)
V.pb(v[j]*i);
sort(all(V));
cin >> t;
while (t--)
{
cin >> n;
cout << (upper_bound(all(V),n)-V.begin())<< endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define range(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, a) range(i, 0, a)
using namespace std;
int main() {
string a;
while(cin >> a) {
string b;
cin >> b;
int ans = 0;
rep (va, 2) {
string & s = va ? a : b,
& t = va ? b : a;
for (int i = s.size() - 1; i >= 0; i--) {
string tmp = "";
range (j, i, s.size()) tmp += s[j];
int cnt = 0;
rep (j, tmp.size()) {
if (tmp[j] == t[j]) {
cnt++;
ans = max(ans, cnt);
}
else {
cnt = 0;
}
}
}
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000, N = 300000;
int n, a[N + 5], lmax[N + 5], rmax[N + 5], lmin[N + 5], rmin[N + 5],
cnt[2 * N + 5];
long long ans;
void solve(int l, int r) {
if (l == r) {
ans++;
return;
}
int mi = (l + r) / 2;
rmin[mi + 1] = rmax[mi + 1] = a[mi + 1];
for (int i = mi + 2; i <= r; i++) {
rmin[i] = min(rmin[i - 1], a[i]);
rmax[i] = max(rmax[i - 1], a[i]);
}
lmin[mi] = lmax[mi] = a[mi];
for (int i = mi - 1; i >= l; i--) {
lmin[i] = min(lmin[i + 1], a[i]);
lmax[i] = max(lmax[i + 1], a[i]);
}
for (int i = l; i <= mi; i++) {
int t = lmax[i] - lmin[i] - mi + i;
if (t <= r - mi && t > 0 && lmin[i] < rmin[t + mi] &&
rmax[t + mi] < lmax[i])
ans++;
}
for (int i = mi + 1; i <= r; i++) {
int t = rmax[i] - rmin[i] + 1 - i + mi;
if (t <= mi - l + 1 && t > 0 && rmin[i] < lmin[mi - t + 1] &&
lmax[mi - t + 1] < rmax[i])
ans++;
}
int j = r, k = r;
for (int i = l; i <= mi; i++) {
for (; k > mi && rmax[k] > lmax[i]; k--) cnt[k - rmax[k] + N]++;
for (; j > k && rmin[j] < lmin[i]; j--) cnt[j - rmax[j] + N]--;
ans += cnt[i - lmin[i] + N];
}
for (; j > k; j--) cnt[j - rmax[j] + N]--;
j = r, k = r;
for (int i = l; i <= mi; i++) {
for (; k > mi && rmin[k] < lmin[i]; k--) cnt[k + rmin[k]]++;
for (; j > k && rmax[j] > lmax[i]; j--) cnt[j + rmin[j]]--;
ans += cnt[i + lmax[i]];
}
for (; j > k; j--) cnt[j + rmin[j]]--;
solve(l, mi);
solve(mi + 1, r);
}
int main() {
int x, y;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &x, &y);
a[x] = y;
}
solve(1, n);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long N = 200005;
vector<long long> vis(N);
vector<vector<long long>> adj(N);
void dfs(long long v) {
vis[v] = 1;
for (auto i : adj[v]) {
if (!vis[i]) {
dfs(i);
}
}
return;
}
bool isPrime(long long n) {
for (long long i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long factorial(long long n) {
return (n == 1 || n == 0) ? 1 : n * factorial(n - 1);
}
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res % mod;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b) * b); }
long long max(long long a, long long b) {
long long ans = a > b ? a : b;
return ans;
}
long long min(long long a, long long b) {
long long ans = a < b ? a : b;
return ans;
}
long long root(long long a[], long long i) {
while (a[i] != i) {
a[i] = a[a[i]];
i = a[i];
}
return i;
}
void unionn(long long a[], long long i, long long j) {
long long root_i = root(a, i);
long long root_j = root(a, j);
a[root_i] = root_j;
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
long long n, m;
cin >> n >> m;
string s, t;
cin >> s;
long long c = 0;
for (long long i = 0; i < s.length() - 1; i++) {
if (s[i] == s[i + 1] && s[i] == '.') c++;
}
for (long long i = 0; i < m; i++) {
long long x;
cin >> x;
x--;
char y;
cin >> y;
if (y == '.') {
if ((x == 0 && s[x + 1] == '.' && s[x] != '.') ||
(x == s.size() - 1 && s[x - 1] == '.' && s[x] != '.'))
c++;
else if (s[x - 1] == '.' && s[x + 1] == '.' && s[x] != '.')
c += 2;
else if ((s[x + 1] == '.' && s[x] != '.') ||
(s[x - 1] == '.' && s[x] != '.'))
c++;
} else {
if ((x == 0 && s[x + 1] == '.' && s[x] == '.') ||
(x == s.size() - 1 && s[x - 1] == '.' && s[x] == '.'))
c--;
else if (s[x - 1] == '.' && s[x + 1] == '.' && s[x] == '.')
c -= 2;
else if ((s[x + 1] == '.' && s[x] == '.') ||
(s[x - 1] == '.' && s[x] == '.'))
c--;
}
cout << c << "\n";
s[x] = y;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int main() {
fast();
long long n, k;
cin >> n >> k;
n++;
{
for (int i = 1; i < k + 1; i++)
if (n % i != 0) {
cout << "no";
return 0;
}
cout << "yes";
}
return 0;
}
| 3 |
#include <iostream>
#include <set>
#include <vector>
#include <algorithm>
int main()
{
int n;
while (true) {
std::cin >> n;
if (n==0) break;
std::set<int> rem;
for (int i=1; i<=n/2; i++) {
rem.insert((i*i)%n);
}
std::vector<int> v(n/2);
for (std::set<int>::iterator it1 = rem.begin(); it1 != rem.end(); ++it1) {
int a = *it1;
for (std::set<int>::iterator it2 = rem.begin(); it2 != rem.end(); ++it2) {
if (it1 == it2) continue;
int b = *it2;
int d = a-b;
if (d<0) d += n;
if (d>n/2) d = n - d;
v[d-1]++;
}
}
for (int i=0; i<n/2; i++) std::cout << v[i] << std::endl;
}
return 0;
}
| 0 |
#include <cstdio>
int ls[299999];
int main() {
int N;
scanf("%d",&N);
int ret=0;
for(int i=1;i<=N;i++) scanf("%d",&ls[i]);
for(int i=1;i<=N;i++) if(ls[ls[i]]==i) ret++;
printf("%d\n",ret/2);
return 0;
}
| 0 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define between(a,x,b) ((a)<=(x)&&(x)<=(b))
using namespace std;
int main(){
int d, x, y, p;
char a[16];
vector<int> D, DD;
scanf("%d", &d);
scanf("%d", &x);
rep(i, x){
scanf("%s%d", a, &p);
if(a[0] == 'D') D.push_back(p);
}
scanf("%d", &y);
rep(i, y){
scanf("%s%d", a, &p);
if(a[0]=='D' && a[1]=='D') DD.push_back(p);
}
sort(D.begin(), D.end(), greater<int>());
sort(DD.begin(), DD.end(), greater<int>());
int res = 0;
// fprintf(stderr, "input\n");
while(d){
int f = true;
// fprintf(stderr, "%d\n", d);
if(DD.empty() && D.empty()) break;
if(d >= 2 && !DD.empty()){
if((D.size() > 1 && D[0] + D[1] < DD[0]) || (D.size() == 1 && D[0] < DD[0]) || D.empty()){
res += DD[0];
DD.erase(DD.begin());
d -= 2;
f = false;
}
}
if(f && !D.empty()){
res += D[0];
D.erase(D.begin());
d--;
f = false;
}
if(f) break;
// if(DD.empty() && D.empty()) break;
}
printf("%d\n", res);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10, mod = 1e9 + 7;
long long n, dp[2][N], d[2][N], t[2][N];
vector<long long> ch[N];
void dfs(long long v) {
if (!ch[v].size()) {
dp[0][v] = 0;
dp[1][v] = 1;
return;
}
for (long long i : ch[v]) dfs(i);
d[0][0] = 1;
for (long long i = 1; i <= ch[v].size(); i++) {
long long u = ch[v][i - 1];
d[0][i] = ((dp[0][u] + 1) * d[0][i - 1] + dp[1][u] * d[1][i - 1]) % mod;
d[1][i] = ((dp[0][u] + 1) * d[1][i - 1] + dp[1][u] * d[0][i - 1]) % mod;
}
dp[0][v] = (2 * d[0][ch[v].size()]) % mod;
dp[1][v] = (2 * d[1][ch[v].size()]) % mod;
long long bad = dp[0][ch[v][0]] + 1;
for (long long i = 1; i < ch[v].size(); i++)
bad = (bad * (dp[0][ch[v][i]] + 1)) % mod;
dp[0][v] = (dp[0][v] - bad) % mod;
t[0][0] = 1;
t[1][0] = dp[1][ch[v][0]];
for (long long i = 1; i < ch[v].size(); i++) {
t[0][i] = (t[0][i - 1] + t[1][i - 1] * dp[1][ch[v][i]]) % mod;
t[1][i] = (t[1][i - 1] + t[0][i - 1] * dp[1][ch[v][i]]) % mod;
}
dp[1][v] = (dp[1][v] - t[1][(long long)ch[v].size() - 1]) % mod;
swap(dp[0][v], dp[1][v]);
}
int32_t main() {
cin >> n;
for (long long i = 1; i < n; i++) {
long long p;
cin >> p;
p--;
ch[p].push_back(i);
}
dfs(0);
cout << (((dp[0][0] + dp[1][0]) % mod) + mod) % mod;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 3000 + 10;
int n, m;
struct Person {
int id;
int p;
long long c;
Person() {}
Person(int id, int p, int c) : id(id), p(p), c(c) {}
bool operator<(const Person& a) const { return c < a.c; }
} person[MAXM];
struct Party {
int id;
int vote;
Person voter[MAXM];
} party[MAXM];
bool vis[MAXM];
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) party[i].id = i;
for (int i = 1; i <= n; i++) {
int p;
long long c;
cin >> p >> c;
person[i] = Person(i, p, c);
party[p].vote++;
party[p].voter[party[p].vote] = person[i];
}
int l = party[1].vote, r = party[1].vote;
for (int i = 2; i <= m; i++) {
r = max(party[i].vote, r);
}
r++;
if (l >= r) {
cout << 0 << endl;
} else {
long long ans = 3e12;
sort(person + 1, person + 1 + n);
for (int j = 2; j <= m; j++) {
sort(party[j].voter + 1, party[j].voter + 1 + party[j].vote);
}
for (int i = l; i <= r; i++) {
long long tempAns = 0;
int cnt = 0;
for (int j = 2; j <= m; j++) {
if (party[j].vote > i - 1) cnt += party[j].vote - (i - 1);
}
if (cnt > i - party[1].vote) {
continue;
} else {
memset(vis, 0, sizeof(vis));
for (int j = 2; j <= m; j++) {
if (party[j].vote <= i - 1) continue;
for (int k = 1; k <= party[j].vote - (i - 1); k++) {
vis[party[j].voter[k].id] = true;
tempAns += party[j].voter[k].c;
}
}
for (int j = 1, amt = 1; j <= n && amt <= i - party[1].vote - cnt;
j++) {
if (vis[person[j].id]) continue;
if (person[j].p == 1) continue;
tempAns += person[j].c;
amt++;
}
ans = min(ans, tempAns);
}
}
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << n / 2 + 1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
string st;
cin >> st;
int a[26] = {0};
for (int i = 0; i < st.length(); i++) {
a[st[i] - 97]++;
}
int f = 0, s = 0, d = 0;
for (int i = 0; i < 26; i++) {
if (a[i] > 0) {
s = i;
break;
}
}
for (int i = 25; i >= 0; i--) {
if (a[i] > 0) {
d = i;
break;
}
}
for (int i = s; i <= d; i++) {
if (a[i] != 1) {
f = 1;
break;
}
}
if (f == 1) {
cout << "NO" << endl;
} else {
cout << "Yes" << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long INF = 1e18;
long long n, m, sum = 0;
vector<long long> a(n);
bool f(long long k) {
long long q = (n - k) / k;
long long r = (n - k) % k;
long long tmp = sum;
long long idx = 0;
for (long long i = 0; i < r; i++) {
tmp -= min(q + 1, a[idx]);
idx++;
}
for (long long i = q; i >= 1; i--) {
for (long long j = 0; j < k; j++) {
tmp -= min(i, a[idx]);
idx++;
}
}
return m <= tmp;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
a.resize(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum < m) {
cout << -1 << endl;
return 0;
}
sort(a.begin(), a.end());
long long ng = 0, ok = n;
while (ok - ng > 1) {
long long mid = (ok + ng) / 2;
if (f(mid))
ok = mid;
else
ng = mid;
}
cout << ok << endl;
}
| 4 |
#include <bits/stdc++.h>
const int MX = 10010896;
const int lmt = 3164;
const int N = 10000001;
int flag[MX >> 6];
long long int seg_tree[2 * N];
int n = 5;
using namespace std;
using namespace std::chrono;
long long int extgcd(long long int a, long long int b, long long int& x,
long long int& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
int g = extgcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
}
void sieve() {
int i, j, k;
for (i = 3; i < lmt; i += 2)
if (!(flag[i >> 6] & (1 << ((i >> 1) & 31))))
for (j = i * i, k = i << 1; j < MX; j += k)
(flag[j >> 6] |= (1 << ((j >> 1) & 31)));
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
char a[n][m];
int b1 = 6;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> a[i][j];
}
bool x = 0;
for (int i = 0; i < n; i++) {
bool s = 0;
for (int j = 0; j < m; j++) {
if (a[i][j] == 'A') {
if (i == 0 && j == 0 || (i == n - 1 && j == m - 1) ||
(i == n - 1 && j == 0) || (i == 0 && j == m - 1)) {
b1 = (2 < b1) ? 2 : b1;
} else if (i == 0 || i == n - 1)
b1 = (3 < b1) ? 3 : b1;
else
b1 = (4 < b1) ? 4 : b1;
} else
s = 1;
}
if (!s) {
if (i == 0 || i == n - 1)
b1 = (1 < b1) ? 1 : b1;
else
b1 = (2 < b1) ? 2 : b1;
} else
x = 1;
}
if (!x) b1 = 0;
for (int i = 0; i < m; i++) {
bool s = 0;
for (int j = 0; j < n; j++) {
if (a[j][i] == 'A') {
if (i == 0 && j == 0 || (i == m - 1 && j == n - 1) ||
(i == m - 1 && j == 0) || (i == 0 && j == n - 1)) {
b1 = (2 < b1) ? 2 : b1;
} else if (i == 0 || i == m - 1)
b1 = (3 < b1) ? 3 : b1;
else
b1 = (4 < b1) ? 4 : b1;
} else
s = 1;
}
if (!s) {
if (i == 0 || i == m - 1)
b1 = (1 < b1) ? 1 : b1;
else
b1 = (2 < b1) ? 2 : b1;
}
}
if (b1 == 6)
cout << "MORTAL\n";
else
cout << b1 << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long convertToNum(string s) {
long long val = 0;
for (int i = 0; i < (s.size()); i++) val = val * 10 + s[i] - '0';
return val;
}
char bu[50];
string convertToString(int a) {
sprintf(bu, "%d", a);
return string(bu);
}
long long GCD(long long x, long long y) {
if (!x) return y;
if (!y) return x;
if (x == y) return x;
if (x < y)
return GCD(x, y % x);
else
return GCD(x % y, y);
}
long long POW(long long x, long long y, long long Base) {
if (!y) return 1;
long long u = POW(x, y / 2, Base);
u = (u * u) % Base;
if (y & 1)
return (u * x) % Base;
else
return u;
}
void extended_euclid(long long A, long long B, long long &x, long long &y) {
if (A == 1 && B == 0) {
x = 1;
y = 0;
return;
}
if (A < B)
extended_euclid(B, A, y, x);
else {
long long xx, yy;
extended_euclid(A % B, B, xx, yy);
x = xx;
y = yy - (A / B) * xx;
}
}
int N, M, tmp, minR = 996;
double C, first, X;
vector<int> v;
std::map<int, int> myMap;
string st;
vector<vector<unsigned long long> > f;
vector<unsigned long long> endAt, startAt;
int main() {
cin >> st;
for (int i = 0; i < st.size(); i++) v.push_back(0);
vector<unsigned long long> f0;
int n = st.size();
for (int i = 0; i < n; i++) endAt.push_back(0);
for (int i = 0; i < n; i++) startAt.push_back(0);
for (int i = 0; i < (n); i++) {
f0.clear();
for (int i = 0; i < n; i++) f0.push_back(0);
f.push_back(f0);
}
for (int i = 0; i < (n); i++) {
f[i][i] = 1;
}
int startI, startJ;
if (n % 2 == 0) {
startI = n / 2 - 1;
startJ = n / 2;
} else {
startI = n / 2;
startJ = n / 2;
}
for (int i = (n - 1); i >= (0); i--) {
for (int j = (0); j <= (n - 1); j++) {
bool x;
if (f[i][j]) continue;
if (i == n - 1)
x = true;
else if (j == 0)
x = true;
else if (j - i == 1)
x = true;
else
x = f[i + 1][j - 1] ? true : false;
f[i][j] = (st[i] == st[j] && x) ? 1 : 0;
}
}
startAt[n - 1]++;
for (int i = 0; i < (n - 1); i++) {
for (int j = (i); j <= (n - 1); j++) {
if (f[i][j] == 1) {
endAt[j]++;
startAt[i]++;
}
}
}
unsigned long long count = 0;
for (int i = 0; i < (n - 1); i++) {
unsigned long long l = endAt[i];
unsigned long long r = 0;
for (int j = (i + 1); j <= (n - 1); j++) {
r += startAt[j];
}
count += r * l;
}
cout << count;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const signed int inf = (signed)((1u << 31) - 1);
const signed long long llf = (signed long long)((1ull << 61) - 1);
const double eps = 1e-6;
const int binary_limit = 128;
template <typename T>
inline bool readInteger(T& u) {
char x;
int aFlag = 1;
while (!isdigit((x = getchar())) && x != '-' && x != -1)
;
if (x == -1) {
ungetc(x, stdin);
return false;
}
if (x == '-') {
x = getchar();
aFlag = -1;
}
for (u = x - '0'; isdigit((x = getchar())); u = (u << 1) + (u << 3) + x - '0')
;
ungetc(x, stdin);
u *= aFlag;
return true;
}
int n, m, k;
int* a;
int* sa;
int* b;
inline void init() {
readInteger(n);
readInteger(k);
a = new int[n + 1];
b = new int[k + 1];
sa = new int[n + 1];
sa[0] = 0;
for (int i = 1; i <= n; i++) {
readInteger(a[i]);
sa[i] = sa[i - 1] + a[i];
}
for (int i = 1; i <= k; i++) readInteger(b[i]);
}
int res;
inline void solve() {
sort(sa + 1, sa + n + 1);
res = m = unique(sa + 1, sa + n + 1) - sa - 1;
for (int i = 1; i <= m; i++) {
int s = b[1] - sa[i];
for (int j = 2; j <= k; j++) {
if (*lower_bound(sa + 1, sa + m + 1, b[j] - s) != b[j] - s) {
res--;
break;
}
}
}
printf("%d\n", res);
}
int main() {
init();
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
for (int i = a; i <= b; i++) {
string s = to_string(i);
int dc[10] = {0};
bool b = true;
for (char x : s) {
if (dc[x - '0'] > 0) {
b = false;
break;
} else {
dc[x - '0']++;
}
}
if (b) {
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, f, e = 0, g = 0;
char c[10], d[10];
scanf("%d %d", &a, &b);
g = a;
for (int i = 0; i < b; i++) {
scanf("%s %s %s", c, c, c);
scanf("%s %d", d, &f);
if (c[0] == 'r') {
if (e < f) e = f;
} else {
if (g > f - 1) g = f - 1;
}
}
if (e < g) {
printf("%d", g - e);
} else
printf("-1");
return 0;
}
| 1 |
#include <iostream>
using namespace std;
const int SIZE=500000;
int A[SIZE+1], H;
void maxheap(int v){
int l=v*2,r=v*2+1,lar;
int sto;
if(l<=H&&A[l]>A[v])lar=l;
else lar=v;
if(r<=H&&A[r]>A[lar])lar=r;
if(lar!=v){
sto=A[v];A[v]=A[lar];
A[lar]=sto;maxheap(lar);
}
return;
}
void buildmaxh(){
for(int i=H/2;i>=1;i--)maxheap(i);
return;
}
int main() {
cin>>H;
for(int i=1;i<=H;i++)cin>>A[i];
buildmaxh();
for(int i=1;i<=H;i++)cout<<" "<<A[i];
cout<<endl;
}
| 0 |
#ifndef ONLINE_JUDGE
#include "debug.cpp"
#endif
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define int long long
void solve();
int binaryConc(int x, int y);
string decToBinary(int n);
int binaryToDecimal(string n);
string decToBinary(int n)
{
string res = "";
int binaryNum[32];
int i = 0;
while (n > 0) {
binaryNum[i] = n % 2;
n = n / 2;
i++;
}
for (int j = i - 1; j >= 0; j--)
res += (binaryNum[j]) ? '1' : '0';
return res;
}
int binaryToDecimal(string n)
{
string num = n;
int dec_value = 0;
int base = 1;
int len = num.length();
for (int i = len - 1; i >= 0; i--) {
if (num[i] == '1')
dec_value += base;
base = base * 2;
}
return dec_value;
}
int binaryConc(int x, int y)
{
string binx = decToBinary(x);
string biny = decToBinary(y);
string binXplusY = binx + biny;
string binYplusX = biny + binx;
int yplusx = binaryToDecimal(binYplusX);
int xplusy = binaryToDecimal(binXplusY);
return xplusy - yplusx;
}
string helper(int d, int s)
{
string ans(d, '0');
for (int i = d - 1; i >= 0; i--) {
if (s >= 9) {
ans[i] = '9';
s -= 9;
}
else {
char c = (char)s + '0';
ans[i] = c;
s = 0;
}
}
return ans;
}
// bool check(int x, int y, int k)
// {
// int diff = abs(x)
// if (abs(x - y) <= 2 * k && !((x ^ y) & 1))
// return true;
// return false;
// }
// void solve() {
// deb("hi");
// }
// void sieve(int n, vector<int> &v, vector<bool> &prime)
// {
// for (int i = 2; i * i <= n; i++)
// {
// if (prime[i])
// {
// for (int j = i * i; j <= n; j += i)
// prime[j] = 0;
// }
// }
// for (int i = 2; i <= n; i++)
// {
// if (prime[i])
// {
// v.push_back(i);
// // st.insert(i);
// }
// }
// }
int power(int a, int b)
{
int res = 1;
while (b > 0)
{
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
// void brute()
// {
// int n, q, k;
// cin >> n >> q >> k;
// vector<int> a(n), v(n), pref(n + 1);
// for (int i = 0; i < n; i++)
// cin >> a[i];
// for (int i = 0; i < n; i++)
// {
// if (i == 0)
// v[i] = a[i + 1] - 2;
// else if (i == n - 1)
// v[i] = k - a[i];
// // else if (i == 1)
// // v[i] = a[i] - 1;
// else
// v[i] = a[i + 1] - a[i - 1] - 2;
// }
// for (int i = 0; i < n; i++)
// pref[i + 1] = v[i] + pref[i];
// // deb(pref);
// while (q--)
// {
// int l, r;
// cin >> l >> r;
// l--, r--;
// int ans = 0;
// if (l == r)
// {
// cout << k - 1 << "\n";
// continue;
// }
// for (int i = l; i <= r; i++)
// {
// if (i == l)
// ans += a[i + 1] - 2;
// else if (i == r)
// ans += k - a[i - 1] - 1;
// else
// ans += a[i + 1] - a[i - 1] - 2;
// }
// cout << ans << "\n";
// }
// }
void solve1()
{
int n;
cin >> n;
vector<int> b(n + 2);
set<int> st;
for (int i = 0; i < n + 2; i++)
{
cin >> b[i];
// st.insert(b[i]);
}
sort(b.begin(), b.end());
// deb(b);
int add = 0;
for (int i = 0; i < n; i++)
add += b[i];
if (add == b[n])
{
for (int i = 0; i < n; i++)
cout << b[i] << " ";
cout << "\n";
}
else
{
add += b[n];
int x = add - b[n + 1];
for (int i = 0; i < n; i++)
st.insert(b[i]);
// deb(add, x);
if (st.count(x))
{
bool f = 1;
for (int i = 0; i < n + 1; i++)
{
if (b[i] == x)
{
if (f)
{
f = 0;
continue;
}
}
cout << b[i] << " ";
}
cout << "\n";
}
else
cout << "-1\n";
}
}
void solve()
{
int n;
cin >> n;
vector<int> a(n), odd, even;
// int even = 0, odd = 0;
for (int i = 0; i < n; i++)
{
cin >> a[i];
if (a[i] & 1)
odd.push_back(a[i]);
else
even.push_back(a[i]);
}
for (auto x : even)
cout << x << " ";
for (auto x : odd)
cout << x << " ";
cout << "\n";
}
int32_t main()
{
IOS;
int t = 1;
cin >> t;
int i = 1;
// sieve(1e6 + 5);
while (t--)
{
// sieve(2021);
// cout << "Case #" << i << ": ";
solve();
// brute();
i++;}
return 0;
}
//
string findMin(int x, int Y)
{
string y = to_string(Y);
int n = y.size();
vector<int> p(n);
for (int i = 0; i < n; i++) {
p[i] = y[i] - '0';
if (i > 0)
p[i] += p[i - 1];
}
for (int i = n - 1, k = 0;; i--, k++) {
int d = 0;
if (i >= 0)
d = y[i] - '0';
for (int j = d + 1; j <= 9; j++) {
int r = (i > 0) * p[i - 1] + j;
if (x - r >= 0 and x - r <= 9 * k) {
string suf = helper(k, x - r);
string pre = "";
if (i > 0)
pre = y.substr(0, i);
char cur = (char)j + '0';
pre += cur;
return pre + suf;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 50;
const int maxm = 25 + 1;
const long long inf = 1e18;
int dp[maxn][maxn];
string dig[maxn];
int n, k;
pair<int, int> pre[maxn][maxn];
string num[10] = {
string("1110111"), string("0010010"), string("1011101"), string("1011011"),
string("0111010"), string("1101011"), string("1101111"), string("1010010"),
string("1111111"), string("1111011"),
};
inline void solve() {
dp[n + 1][k] = 10;
for (int i = (n); i >= (1); --i) {
for (int j = (0); j <= (k); ++j) {
for (int m = (9); m >= (0); --m) {
int nd, rl, ok;
nd = rl = 0;
ok = 1;
for (int p = (0); p < (7); ++p) {
if (num[m][p] == '1' && dig[i][p] == '1') {
}
if (num[m][p] == '1' && dig[i][p] == '0') {
nd++;
}
if (num[m][p] == '0' && dig[i][p] == '1') {
ok = 0;
}
if (num[m][p] == '0' && dig[i][p] == '0') {
}
}
if (ok) {
for (int p = (nd); p <= (nd); ++p) {
if (dp[i + 1][j + p] != -1) {
pair<int, int> e = pre[i][j];
if (dp[i][j] == -1) {
dp[i][j] = m;
pre[i][j].first = i + 1;
pre[i][j].second = j + p;
e = pre[i][j];
}
}
}
}
}
}
}
if (dp[1][0] == -1) {
cout << "-1\n";
return;
}
string ans;
pair<int, int> now = (pair<int, int>){1, 0};
while (now.first <= n) {
assert(dp[now.first][now.second] != -1);
ans.push_back(dp[now.first][now.second] + '0');
auto e = pre[now.first][now.second];
now = e;
}
cout << ans << endl;
}
int main(void) {
ios::sync_with_stdio(false);
cout.tie(nullptr);
;
cin >> n >> k;
for (int i = (1); i <= (n); ++i) {
cin >> dig[i];
}
memset(dp, -1, sizeof(dp));
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
int f(int a, int k) {
int c = 0;
while (a > 0) {
if (a % 10 == 4 || a % 10 == 7) {
++c;
}
a /= 10;
}
return c <= k;
}
int main(void) {
int a, n, k, i, ans = 0;
scanf("%d %d", &n, &k);
for (i = 0; i < n; ++i) {
scanf("%d", &a);
if (f(a, k)) {
++ans;
}
}
printf("%d\n", ans);
exit(EXIT_SUCCESS);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 3e5 + 10;
int N, A[MAX_N];
bool check(int x) {
int min_s = 0, s = 0;
for (int i = 1; i < N; i += 2) {
s += A[i];
bool succ = s >= min_s + x;
s -= A[i + 1];
if (succ) min_s = min(min_s, s);
}
s += A[N];
return s >= min_s + x;
}
int main() {
scanf("%d", &N);
int sum = 0;
for (int i = 1; i <= N; i++) scanf("%d", &A[i]), sum += A[i];
int ans = 0;
if (N % 2 == 0) {
for (int i = 1; i <= N; i += 2) ans += A[i];
if (ans < sum - ans) ans = sum - ans;
} else {
for (int i = 1; i <= N; i += 2) ans += A[i];
int base = 0;
for (int i = 2; i <= N; i += 2) base += A[i];
int l = 0, r = sum;
while (l != r) {
int m = (l + r) / 2;
if (check(m + 1)) l = m + 1;
else r = m;
}
ans = max(ans, base + l);
}
printf("%d %d\n", ans, sum - ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int M = 3e3 + 5;
const int inf = 1e9 + 5;
int a[M];
int dp[M][M];
int dp1[M];
int main() {
int n;
scanf("%d", &n);
int up = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
up = max(up, a[i]);
}
up += n;
dp[n][a[n]] = n;
for (int i = n - 1; i >= 1; i--) {
dp[i][a[i]] = i;
for (int j = a[i] + 1; j <= up; j++) {
int p1 = dp[i][j - 1], p2 = dp[p1 + 1][j - 1];
if (p1 && p2) dp[i][j] = p2;
}
}
for (int i = 1; i <= n; i++) dp1[i] = inf;
for (int i = 1; i <= n; i++) {
for (int j = a[i]; j <= up; j++) {
if (dp[i][j]) {
int p = dp[i][j];
dp1[p] = min(dp1[p], dp1[i - 1] + 1);
}
}
}
printf("%d\n", dp1[n]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int k = n;
for (int i = 0; i <= n; i++) {
for (int p = 0; p < k; p++) {
cout << " ";
}
k--;
for (int j = 0; j < i; j++) {
cout << j << " ";
}
cout << i;
for (int j = i - 1; j >= 0; j--) {
cout << " " << j;
}
cout << endl;
}
k = 1;
for (int i = n - 1; i >= 0; i--) {
for (int p = 0; p < k; p++) {
cout << " ";
}
k++;
for (int j = 0; j < i; j++) {
cout << j << " ";
}
cout << i;
for (int j = i - 1; j >= 0; j--) {
cout << " " << j;
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a,b;
cin>>a>>b;
if(b%a==0) cout<<a+b;
else cout<<b-a;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.