solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long INF64 = 1e18;
clock_t time_p = clock();
void time() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
void doc() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
fast();
string s;
cin >> s;
long long i, j;
long long n = s.length();
long long m = 0, idx = -1, x = 0, y = 0;
for (i = 0; i < n; i++) {
if (s[i] == '(') {
x++;
y = 0;
for (j = i + 1; j < n; j++) {
if (s[j] == ')') y++;
}
if (y >= x) {
if (x > m) {
m = x;
idx = i;
}
}
}
}
vector<long long> ans;
for (i = 0; i <= idx; i++)
if (s[i] == '(') ans.emplace_back(i + 1);
for (i = n - 1, j = 0; i >= 0 and j < m; i--)
if (s[i] == ')') {
ans.emplace_back(i + 1);
j++;
}
sort(ans.begin(), ans.end());
if (ans.size() == 0) {
cout << "0";
exit(0);
}
cout << "1" << endl << ans.size() << endl;
for (auto i : ans) cout << i << " ";
cout << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using i128 = long long;
const int MN = 103, MA = 1e4 + 3;
i128 all[MN][MA], freq[MN], ree[MN][MA];
int main() {
int n, sum = 0, dis = 0;
scanf("%d", &n);
all[0][0] = 1;
for (int i = 1; i <= 100; i++) ree[i][0] = 1;
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
sum += a;
if (++freq[a] == 1) ++dis;
for (int k = freq[a] * a; k >= a; k -= a) ree[a][k] += ree[a][k - a];
for (int j = i; j >= 1; j--)
for (int k = sum; k >= a; k--) all[j][k] += all[j - 1][k - a];
}
if (dis <= 2) return !printf("%d\n", n);
int ret = 0;
for (int i = 1; i <= 100; i++) {
for (int j = 1; j <= freq[i]; j++) {
if (all[j][j * i] == ree[i][j * i] ||
all[n - j][sum - j * i] == ree[i][j * i]) {
ret = max(ret, j);
}
}
}
printf("%d\n", ret);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define FOR( i, m, n ) for( int (i) = (m); (i) < (n); (i)++ )
#define REP( i, n ) FOR( i, 0, n )
#define ALL( a ) (a).begin(), (a).end()
int main(void){
while( 1 ){
string g; cin >> g;
if( g == "#") break;
int y, m, d; cin >> y >> m >> d;
if( y <= 30 ){
cout << g << " " << y << " " << m << " " << d << endl;
}else if( y == 31&& m <= 4 ){
cout << g << " " << y << " " << m << " " << d << endl;
}else{
cout << '?' << " " << y - 30 << " " << m << " " << d << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200000;
const int MAX_P = 6;
const int MAX_E = 500000;
struct GCDSolver {
int v[1 + MAX_N];
bool exista[1 + MAX_N];
vector<int> primes[1 + MAX_E];
int popcnt[1 << MAX_P], lsb[1 << MAX_P], prod[1 << MAX_P], fr[MAX_E];
int size;
long long goodpairs;
void init() {
for (int d = 2; d <= MAX_E; ++d)
if (primes[d].empty())
for (int i = d; i <= MAX_E; i += d) primes[i].push_back(d);
for (int i = 1; i < (1 << MAX_P); ++i) {
popcnt[i] = popcnt[i & (i - 1)] + 1;
if (i % 2 == 1)
lsb[i] = 0;
else
lsb[i] = lsb[i / 2] + 1;
}
}
bool existaNr(int i) { return exista[i]; }
void insert(int i) {
int val = v[i], allmsk = (1 << (int)primes[val].size()) - 1;
prod[0] = 1;
for (int msk = 1; msk < (1 << (int)primes[val].size()); ++msk) {
prod[msk] = prod[msk ^ (1 << lsb[msk])] * primes[val][lsb[msk]];
if (popcnt[msk] % 2 == 1)
goodpairs += fr[prod[msk]];
else
goodpairs -= fr[prod[msk]];
fr[prod[msk]]++;
}
exista[i] = true;
size++;
}
void erase(int i) {
int val = v[i], allmsk = (1 << (int)primes[val].size()) - 1;
prod[0] = 1;
for (int msk = 1; msk < (1 << (int)primes[val].size()); ++msk) {
prod[msk] = prod[msk ^ (1 << lsb[msk])] * primes[val][lsb[msk]];
fr[prod[msk]]--;
if (popcnt[msk] % 2 == 1)
goodpairs -= fr[prod[msk]];
else
goodpairs += fr[prod[msk]];
}
exista[i] = false;
size--;
}
long long queryPairs() {
return (long long)size * (size - 1) / 2 - goodpairs;
}
} solver;
int main() {
int n, m, x;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &solver.v[i]);
solver.init();
for (int i = 0; i < m; ++i) {
scanf("%d", &x);
if (solver.existaNr(x))
solver.erase(x);
else
solver.insert(x);
printf("%lld\n", solver.queryPairs());
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n, a, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> a;
if (i * a % 2) ans++;
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
char ch[N];
int n;
long long m, k;
int a[N];
int main() {
int T;
cin >> T;
while (T--) {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int flag = 0;
for (int i = 1; i < n; i++) {
if (a[i + 1] > a[i] + k) {
int d = a[i + 1] - a[i];
if (d - k > m) {
flag = 1;
break;
} else {
m -= d - k;
}
} else {
m += min(1LL * a[i], a[i] - (a[i + 1] - k));
}
}
if (flag)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, s = 0;
cin >> n >> m;
int ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar, ar + n);
for (int i = 0; i < m; i++) {
if (ar[i] < 0) {
s += ar[i];
}
}
cout << abs(s) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, d;
vector<int> v;
cin >> n >> d;
v.resize(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int last_day;
for (last_day = 1; last_day < n && d >= last_day * v[last_day];
last_day++) {
d -= last_day * v[last_day];
v[0] += v[last_day];
}
if (last_day != n) {
v[0] += d / last_day;
}
cout << v[0] << endl;
}
return 0;
}
| 1 |
#if 0
time: 50min
using priority_queue(reverse) to save time.
#endif
#include <iostream>
#include <queue>
#include <algorithm>
#include <utility>
using namespace std;
const int Inf = 10000*100000+100;
int a,b,V,E,R,S,Start[500000+10],To[500000+10],Dis[500000+10],N[500000+10];
int Ans[100000+10];
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > Q;
int main() {
cin >> V >> E >> R;
for (int i=1; i<=E; i++){
cin >> S >> To[i] >> Dis[i];
N[i] = Start[S];
Start[S] = i;
}
fill(Ans,Ans+100010,Inf);
Ans[R] = 0;
Q.push(make_pair(0,R));
while(!Q.empty()){
a = Q.top().first;
b = Q.top().second;
Q.pop();
if (Ans[b] == a){
for(int i=Start[b]; i; i=N[i]){
int t = To[i];
if (a+Dis[i] < Ans[t]){
Ans[t] = a+Dis[i];
Q.push(make_pair(Ans[t],t));
}
}
}
}
for (int i=0; i<V; i++){
if (Ans[i] < Inf){
cout << Ans[i] << endl;
}else{
cout << "INF" << endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200010];
struct fenwick {
vector<int> F;
int N;
void init(int n) {
N = n;
F.clear();
F.resize(N + 1);
}
void add(int k, int v) {
if (k == 0) return;
while (k <= N) {
F[k] += v;
k += k & -k;
}
}
int sum(int k) {
int s = 0;
while (k >= 1) {
s += F[k];
k -= k & -k;
}
return s;
}
} f;
long long calc(int k) {
int h = 0, l = 0;
f.init(200010 * 2);
for (int i = 0; i < n; ++i) {
l += a[i] < k;
h += a[i] >= k;
f.add(h - l + 200010, 1);
}
long long ret = 0;
int cur = 0;
h = l = 0;
for (int i = 0; i < n; ++i) {
ret += f.sum(2 * 200010) - f.sum(cur + 200010);
l += a[i] < k;
h += a[i] >= k;
f.add(h - l + 200010, -1);
cur += (a[i] >= k) - (a[i] < k);
}
assert(f.sum(2 * 200010) == 0);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
cout << calc(m) - calc(m + 1) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
bool debug = true;
using namespace std;
long long pow(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) {
res *= a;
}
a *= a;
n >>= 1;
}
return res;
}
int main(void) {
if (0) {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
int n, i, j, k;
scanf("%d", &n);
vector<long long> a(n);
for (i = 0; i < n; i++) scanf("%lld", &a[i]);
long long base = a[0], tmp;
while ((base % 2) == 0) base >>= 1;
while ((base % 3) == 0) base /= 3;
vector<pair<int, int>> b;
for (i = 0; i < n; i++) {
tmp = a[i];
j = k = 0;
while ((tmp % 2) == 0) {
tmp >>= 1;
j++;
}
while ((tmp % 3) == 0) {
tmp /= 3;
k++;
}
b.push_back(make_pair(k, j));
}
sort(b.begin(), b.end(), [](pair<int, int> &left, pair<int, int> &right) {
return ((left.first > right.first) ||
(left.first == right.first && left.second < right.second));
});
long long ans = base;
ans *= pow((long long)3, (long long)b[0].first);
ans *= pow((long long)2, (long long)b[0].second);
printf("%lld ", ans);
for (i = 1; i < n; i++) {
if (b[i].first == b[i - 1].first - 1) ans /= 3;
if (b[i].second == b[i - 1].second + 1) ans <<= 1;
printf("%lld ", ans);
}
printf("\n");
}
| 4 |
#include <bits/stdc++.h>
int a[1000];
char c[1000];
int main() {
int n, i;
scanf("%d\n", &n);
for (i = (0); i < (n - 1); i++) c[i] = getchar();
a[0] = 1;
for (i = (0); i <= (n - 2); i++) {
if (c[i] == 'R')
a[i + 1] = a[i] + 1;
else if (c[i] == '=')
a[i + 1] = a[i];
else
a[i + 1] = 1;
}
for (i = (n - 2); i >= (0); i--) {
if (c[i] == 'L') {
if (a[i] <= a[i + 1]) a[i] = a[i + 1] + 1;
} else if (c[i] == '=')
if (a[i] < a[i + 1]) a[i] = a[i + 1];
}
printf("%d", a[0]);
for (i = (1); i < (n); i++) printf(" %d", a[i]);
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string str;
cin >> str;
int arr[26] = {0};
for (int i = 0; i < n; i++) {
arr[str[i] - 'a']++;
if (arr[str[i] - 'a'] > m) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
clock_t begin_time = clock();
int t;
cin >> t;
for (int tcase = 0; tcase < t; ++tcase) {
int b, p, f, h, c;
cin >> b >> p >> f >> h >> c;
int mh, mc;
int tot = min(p + f, b / 2);
int ans = 0;
if (tot == p + f) {
ans = p * h + f * c;
} else {
if (h > c) {
ans = min(p, tot) * h + (tot - min(p, tot)) * c;
} else {
ans = min(f, tot) * c + (tot - min(f, tot)) * h;
}
}
cout << ans << "\n";
}
clock_t end_time = clock();
double elapsed_secs = double(end_time - begin_time) / CLOCKS_PER_SEC;
cerr << "Exec time: " << elapsed_secs << " s" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >>N;
vector<int> b(N);
vector<int> c(0);
for (int i=0; i<N; i++)
cin >>b.at(i);
while (b.size()>0) {
int i;
for (i=b.size()-1; i>=0; i--) {
if (i+1==b.at(i)) {
b.erase(b.begin()+i);
c.push_back(i+1);
break;
}
}
if (-1==i) {
cout <<-1 <<endl;
return 0;
}
}
for (int i=c.size()-1; i>=0; i--)
cout <<c.at(i) <<endl;
return 0;
}
| 0 |
#include<iostream>
#include<vector>
#include<cstdio>
#include<utility>
#include<cmath>
using namespace std;
int main(){
int n, k=1;
vector< pair<int,int> > points;
while( cin >> n, n ){
points.clear();
for( int i=0; i<n; i++ ){
int x, y;
cin >> x >> y;
points.push_back( make_pair(x,y) );
}
points.push_back( make_pair( points[0].first, points[0].second ) );
double sum=0;
for( int i=0; i+1<points.size(); i++ ){
sum += ((points[i].second+points[i+1].second)*(points[i+1].first-points[i].first))/2.0;
}
printf("%d %.1f\n", k++, fabs(sum) );
}
return 0;
} | 0 |
#include<bits/stdc++.h>
#define low(x) (x&(-x))
using namespace std;
typedef unsigned long long ll;
const int N=2005;
struct bit{
ll z[32];
void flip(int x){
z[x>>6]^=1ull<<(x&63);
}
bool getv(int x){
return z[x>>6]&(1ull<<(x&63));
}
}f[N][N],v,h[N],g[N];
void operator^=(bit &a,bit b){
for (int i=0;i<32;i++)a.z[i]^=b.z[i];
}
void operator&=(bit &a,bit b){
for (int i=0;i<32;i++)a.z[i]&=b.z[i];
}
void operator|=(bit &a,bit b){
for (int i=0;i<32;i++)a.z[i]|=b.z[i];
}
const int P=67;
int Mrk[P];
void init_Mrk(){
Mrk[1]=0;
for (int i=1,now=1;i<=64;i++)
Mrk[now=now*2%P]=i;
}
int getid(ll x){return Mrk[x%P];}
typedef pair<int,int> pi;
pi d[2001000];
int w[N*2],ne[N*2],la[N],t,n,m,d1;
int E;
void link(int x,int y){
w[++t]=y;
ne[t]=la[x];
la[x]=t;
}
void dfs(int x,int fa){
v.flip(x);
f[E][x]=v;
for (int y=la[x];y;y=ne[y]){
int z=w[y];
if (z==fa)continue;
dfs(z,x);
f[E][x]|=f[E][z];
}
v.flip(x);
}
void add(int x,int y){
g[x].flip(y);
g[y].flip(x);
h[x].flip(y);
h[y].flip(x);
d[d1++]=make_pair(x,y);
}
int main(){
init_Mrk();
cin>>n>>m;
for (int i=1;i<n;i++){
int x,y;
scanf("%d%d",&x,&y);
link(x,y);
link(y,x);
}
for (E=1;E<=n;E++)dfs(E,0);
for (int i=1;i<=n;i++){
for (int j=1;j<i;j++){
f[i][j]|=f[j][i];
f[j][i]|=f[i][j];
}
}
for (int i=1;i<=n;i++)
for (int j=1;j<=n;j++)
if (i!=j)g[i].flip(j);
int ans=0;
while (m--){
int x,y;
scanf("%d%d",&x,&y);
if (h[x].getv(y))continue;
add(x,y);
for (int i=0;i<d1;i++){
int x=d[i].first,y=d[i].second;
bit z=f[x][y];
z&=g[x];z&=h[y];
for (int k=0;k<32;k++){
for (ll p=z.z[k];p;p-=low(p))
add(x,getid(low(p))+(k<<6));
}
z=f[x][y];
z&=h[x];z&=g[y];
for (int k=0;k<32;k++){
for (ll p=z.z[k];p;p-=low(p))
add(y,getid(low(p))+(k<<6));
}
}
ans+=d1;
d1=0;
}
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long Min(long long x, long long y) {
if (x < y) return x;
return y;
}
inline long long Max(long long x, long long y) {
if (x > y) return x;
return y;
}
inline void read(long long &x) {
x = 0;
long long f = 1;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = (x << 3) + (x << 1) + (s ^ 48);
s = getchar();
}
x *= f;
}
int main() {
long long JZM = 300;
while (JZM--) cout << "a";
cout << endl;
long long A;
cin >> A;
A = 300 - A;
JZM = 300;
while (JZM--) cout << "b";
cout << endl;
long long B;
cin >> B;
B = 300 - B;
long long Len = A + B;
long long Pre = B;
string Ans = "";
for (register int i = Len; i > 1; --i) {
cout << Ans << "b";
for (register int j = 1; j < i; ++j) cout << "a";
cout << endl;
long long Now;
cin >> Now;
if (!Now) return 0;
if (Now > Pre)
Ans += "a";
else
Ans += "b";
Pre = Min(Pre, Now);
}
if (Pre == 0)
Ans += "a";
else
Ans += "b";
cout << Ans << endl;
long long PPL;
cin >> PPL;
return 0;
}
| 4 |
#include <cstdio>
int main()
{
const int MAX = 7368791;
static bool flags[MAX + 1];
int m, n;
while (true)
{
scanf("%d %d", &m, &n);
if (m == 0 && n == 0)
{
break;
}
for (int i = 1; i <= MAX; ++i)
{
flags[i] = false;
}
for (int i = m, count = 0; count < n; ++i)
{
if (flags[i])
{
continue;
}
for (int j = i; j <= MAX; j += i)
{
flags[j] = true;
}
++count;
}
for (int year = m; year <= MAX; ++year)
{
if (!flags[year])
{
printf("%d\n", year);
break;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000000;
int countDiff[MAXN * 3];
int nums[MAXN];
int nNums;
int shifts;
long long minDiff;
long long diffs[MAXN];
int countNegative;
void handleShift(int n) {
int ind = nNums - n;
int former = nums[ind] - nNums;
int latter = nums[ind];
countDiff[nums[ind] + nNums - ind - 2]--;
countDiff[nums[ind] + nNums - ind - 2 + nNums]++;
long long currResult = diffs[n - 1];
currResult += abs(latter) - abs(former);
if (former < 0) {
countNegative--;
}
countNegative += countDiff[nNums - 2 + n];
currResult += countNegative;
currResult -= (nNums - countNegative);
diffs[n] = currResult;
if (diffs[n] < minDiff) {
minDiff = diffs[n];
shifts = n;
}
}
int main() {
scanf("%d", &nNums);
for (int i = 0; i < nNums; i++) {
scanf("%d", nums + i);
int diff = nums[i] - (i + 1);
minDiff += abs(diff);
countDiff[diff + (nNums - 1)]++;
if (diff < 0) {
countNegative++;
}
}
diffs[0] = minDiff;
for (int i = 1; i < nNums; i++) {
handleShift(i);
}
cout << minDiff << ' ' << shifts << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 99;
int n, m, q, u, v, deg[N], degin[N];
long long ans;
vector<int> g[N];
void change(int u, int v) {
ans -= 1ll * int(g[u].size()) * (deg[u] - int(g[u].size()));
g[u].push_back(v);
ans += 1ll * int(g[u].size()) * (deg[u] - int(g[u].size()));
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
;
if (v < u) swap(u, v);
g[u].push_back(v);
deg[u]++;
deg[v]++;
}
for (int i = 1; i < n + 1; i++)
ans += 1ll * int(g[i].size()) * (deg[i] - int(g[i].size()));
cout << ans << '\n';
cin >> q;
for (int i = 0; i < q; i++) {
cin >> u;
ans -= 1ll * int(g[u].size()) * (deg[u] - int(g[u].size()));
for (int i = 0; i < int(g[u].size()); i++) change(g[u][i], u);
g[u].clear();
cout << ans << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int powe(long long int n, long long int m) {
if (m == 0) return 1;
long long int t = powe(n, m / 2);
if (m % 2 == 0) return (t * t);
return (((t * t)) * n);
}
long long int mpowe(long long int n, long long int m) {
if (m == 0) return 1;
long long int t = powe(n, m / 2);
t %= 1000000007;
if (m % 2 == 0) return (t * t) % 1000000007;
return (((t * t) % 1000000007) * n) % 1000000007;
}
long long int logtwo(long long int n) {
if (n == 1) return 0;
return logtwo(n / 2) + 1;
}
long long int A[200000 + 1];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long int n, d, i, sum = 0, dt;
cin >> n >> d;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
;
long long int c;
for (i = 1; i < n; i++) {
c = i;
dt = d / c;
if (a[i] < dt) {
sum += a[i];
d -= (a[i] * c);
} else {
sum += dt;
break;
}
}
sum += a[0];
cout << sum << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
bool simulate(int big) {
int i = 0, j = 0;
int arr[26];
bool check[26];
memset(arr, 0, sizeof(arr));
memset(check, false, sizeof(check));
for (j = 0; j < big && j < s.length(); ++j) {
arr[s[j] - 'a']++;
check[s[j] - 'a'] = true;
}
while (j < s.length()) {
arr[s[i] - 'a']--;
++i;
arr[s[j] - 'a']++;
for (int k = 0; k < 26; ++k) {
if (check[k] == true && arr[k] <= 0) {
check[k] = false;
}
}
j++;
}
for (int k = 0; k < 26; ++k) {
if (check[k]) {
return true;
}
}
return false;
}
int main() {
cin >> s;
int l = 0, r = 2e5, m;
while (l < r) {
m = (l + r) / 2;
if (simulate(m)) {
r = m;
} else {
l = m + 1;
}
}
cout << l << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j, count = 0;
cin >> n >> k;
char s[n];
char let[27] = "abcdefghijklmnopqrstuvwxyz";
for (i = 0; i < n; i++) cin >> s[i];
for (i = 0; i < 27; i++) {
for (j = 0; j < n; j++) {
if (s[j] == let[i]) {
s[j] = 0;
count++;
if (count == k) {
for (i = 0; i < n; i++)
if (s[i]) cout << s[i];
return 0;
}
}
}
}
for (i = 0; i < n; i++)
if (s[i]) cout << s[i];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Lem {
int m, v, id;
bool operator<(Lem b) const { return m < b.m || (m == b.m && v < b.v); }
};
int n, k, h;
Lem a[(100000 + 10)];
bool can(double t) {
int j = k;
for (int i(n - 1), _l(0); i >= _l; --i) {
if (j > 0 && (double)j * h / a[i].v - t <= -1e-7) j--;
}
return j == 0;
}
void putAns(double t) {
int ans[(100000 + 10)];
int j = k;
for (int i(n - 1), _l(0); i >= _l; --i) {
if (j > 0 && (double)j * h / a[i].v - t <= -1e-7) ans[--j] = a[i].id;
}
for (int i(0), _n(k - 1); i < _n; ++i) printf("%d ", ans[i]);
printf("%d\n", (ans[k - 1]));
}
int main() {
scanf("%d", &(n)), scanf("%d", &(k)), scanf("%d", &(h));
for (int i(0), _n(n); i < _n; ++i) scanf("%d", &(a[i].m)), a[i].id = i + 1;
for (int i(0), _n(n); i < _n; ++i) scanf("%d", &(a[i].v));
sort(a, a + n);
double l = 0, r = 1e10;
int cnt = 100;
while (cnt--) {
double mid = (l + r) / 2.0;
if (can(mid))
r = mid;
else
l = mid;
}
putAns(r);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const int maxm = 45;
const int N = 40;
vector<pair<int, int> > rec[maxn];
int GCD[maxm][maxm];
int val[maxm], lasl[maxm];
int n, m, cnt[maxn];
int main() {
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
for (int k = 1; k <= N; k++)
if (i % k == 0 && j % k == 0) GCD[i][j] = k;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &cnt[i]);
for (int x, j = 0; j < cnt[i]; j++) {
scanf("%d", &x);
rec[x].push_back(pair<int, int>(i, j));
}
}
for (int i = 1; i <= m; i++) {
int ans = 0, las = -1, sum = 0, beg = -1;
for (int j = 0; j < rec[i].size(); j++) {
int pos = rec[i][j].first, sz = cnt[pos];
int mod = rec[i][j].second;
if (pos != las + 1) {
sum = 1;
beg = pos;
for (int k = 1; k <= N; k++) val[k] = -1;
} else {
int maxlas = beg;
for (int k = 1; k <= N; k++)
if (val[k] != -1) {
int t = GCD[sz][k];
if (val[k] % t != mod % t) {
maxlas = max(maxlas, lasl[k] + 1);
val[k] = -1;
}
}
beg = maxlas;
sum = pos - maxlas + 1;
}
ans = max(ans, sum);
val[sz] = mod;
lasl[sz] = las = pos;
}
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long ans = 0;
long long n;
cin >> n;
for (long long i = 1; i <= 200; i *= 2) {
vector<long long> a1, a2;
for (long long j = 1; j < n + 1; j++) {
if (i & j) {
a1.push_back(j);
} else {
a2.push_back(j);
}
}
if (a1.size() == 0 || a2.size() == 0) break;
cout << a1.size() << " " << a2.size() << " ";
for (long long j : a1) {
cout << j << " ";
}
for (long long j : a2) {
cout << j << " ";
}
cout << endl << flush;
long long in;
cin >> in;
ans = max(in, ans);
}
cout << "-1 " << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, u;
long long max_up = 0;
long long max_down = 1;
cin >> n >> u;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n - 2; i++) {
int j = i + 1;
int k = upper_bound(arr.begin(), arr.end(), u + arr[i]) - arr.begin() - 1;
if (k <= j) continue;
long long up = arr[k] - arr[j];
long long down = arr[k] - arr[i];
if (up * max_down >= down * max_up) max_down = down, max_up = up;
}
if (max_up == 0)
cout << -1;
else {
cout << "0.";
for (int i = 0; i < 9; i++) {
max_up *= 10;
long long mod = max_up % max_down;
cout << max_up / max_down;
max_up = mod;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vll = vector<ll, ll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
ll modpow(ll a, ll b, ll mod = (ll)(1e9 + 7)) {
if (!b) return 1;
a %= mod;
return modpow(a * a % mod, b / 2, mod) * (b & 1 ? a : 1) % mod;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int DEBUG = 1;
const int mxn = 1e5 + 7, oo = 1e9;
int n;
int dp[mxn][2][3];
pii p[mxn][2][3];
string s;
void solve() {
n = s.length();
for (int i = 0; i < mxn; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 3; k++) dp[i][j][k] = oo;
dp[0][0][0] = 0;
for (int i = 0; i < n + 1; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 3; k++)
if (dp[i][j][k] != oo) {
if (i == n) continue;
if (j || s[i] != '0') {
(dp[i + 1][1][(k + s[i] - '0') % 3]) =
min((dp[i + 1][1][(k + s[i] - '0') % 3]), (dp[i][j][k]));
if (dp[i + 1][1][(k + s[i] - '0') % 3] == dp[i][j][k])
p[i + 1][1][(k + s[i] - '0') % 3] = pii(j, k);
}
(dp[i + 1][j][k]) = min((dp[i + 1][j][k]), (dp[i][j][k] + 1));
if (dp[i + 1][j][k] == dp[i][j][k] + 1) p[i + 1][j][k] = pii(j, k);
}
if (dp[n][1][0] == oo) {
for (int i = 0; i < n; i++)
if (s[i] == '0') {
cout << 0 << endl;
return;
}
cout << -1 << endl;
} else {
string r;
int j = 1, k = 0;
for (int i = n - 1; i >= 0; i--) {
pii bac = p[i + 1][j][k];
if (dp[i][bac.first][bac.second] == dp[i + 1][j][k]) r.push_back(s[i]);
j = bac.first;
k = bac.second;
}
reverse(begin(r), end(r));
cout << r << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
while (cin >> s) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = double;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << endl;
err(++it, args...);
}
const ll MODBASE = 1000000007LL;
const int MAXN = 100010;
const int MAXM = 100010;
const int MAXK = 510;
const int MAXQ = 200010;
int n, x, a[MAXN * 10];
bool f[MAXN * 10];
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cin >> n >> x;
if (n == 1) {
if (x == 1)
cout << 0;
else
cout << "1\n1";
return 0;
}
int N = 1;
if (x == 1)
a[1] = 2;
else
a[1] = 1;
while (1) {
for (int i = (1); i <= ((1 << n) - 1); i++) f[i] = true;
f[x] = false;
int g = 0;
for (int i = (N); i >= (1); i--) {
g = g ^ a[i];
f[g] = false;
int h = g ^ x;
f[h] = false;
}
int vt = 0;
for (int i = (1); i <= ((1 << n) - 1); i++)
if (f[i] == true) {
vt = i;
break;
}
if (!vt) break;
a[++N] = vt;
N = N * 2 - 1;
for (int i = (1); i <= (N / 2 + 1); i++) a[N - i + 1] = a[i];
}
cout << N << "\n";
for (int i = (1); i <= (N); i++) cout << a[i] << ' ';
return 0;
}
| 4 |
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
#include <math.h>
using namespace std;
int main(){
int n,a,b,c,d,e,f,g,h,x,y,z,w;
while(1){
cin >> n ;
if(n==0){
return 0;
}
for(int t=0;t<n;t++){
cin >>a>>b>>c>>d>>e>>f>>g>>h;
x=a*e-b*f-c*g-d*h;
y=a*f+b*e+c*h-d*g;
z=a*g-b*h+c*e+d*f;
w=a*h+b*g-c*f+d*e;
printf("%d %d %d %d\n",x,y,z,w);
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main(){
ios_base :: sync_with_stdio(false);
cin.tie(0);
int a, b, k;
cin >> a >> b >> k;
if(b == 1 && k != 0){
cout << "No\n";
return 0;
}
if(b == 1){
cout << "Yes\n";
string s = "1";
for(int i = 0 ; i < a ; i ++) s += "0";
cout << s << "\n" << s << "\n";
return 0;
}
if(a == 0){
if(k){
cout << "No\n";
return 0;
}
cout << "Yes\n";
string s = "";
for(int i = 0 ; i < b ; i ++) s += "1";
cout << s << "\n" << s << "\n";
return 0;
}
if(k == 0){
cout << "Yes\n";
string s = "";
for(int i = 0 ; i < b ; i ++) s += "1";
for(int i = 0 ; i < a ; i ++) s += "0";
cout << s << "\n" << s << "\n";
return 0;
}
// b >= 2
// pelo menos um zero em cada numero
// (k - 1) casas p preencher
if((b - 2) + (a - 1) < k - 1){
cout << "No\n";
return 0;
}
cout << "Yes\n";
int n = a + b;
vector<int> s(n, -1);
vector<int> t(n, -1);
s[n - 1] = 0;
s[n - k - 1] = 1;
s[0] = 1;
t[n - 1] = 1;
t[n - k - 1] = 0;
t[0] = 1;
a -= 1;
b -= 2;
for(int i = 0 ; i < n ; i ++){
if(s[i] == -1){
if(a){
s[i] = 0;
t[i] = 0;
--a;
} else {
s[i] = 1;
t[i] = 1;
--b;
}
}
}
for(int i = 0 ; i < n ; i ++)
cout << s[i];
cout << "\n";
for(int i = 0 ; i < n ; i ++)
cout << t[i];
cout << "\n";
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 85;
int n, V, now;
int sl[N], sr[N], lens[N], h[N * 2];
double ans[N][N];
void add(int x, int l, int r, double y) {
ans[x][l] += y;
ans[x][r + 1] -= y;
}
void trans(int x, int c, double F[N][N]) {
double g0 =
sr[x] > now + 1 ? 1.0 * (h[sr[x]] - h[max(now + 1, sl[x])]) / lens[x] : 0;
double g1 = sl[x] < now ? 1.0 * (h[min(now, sr[x])] - h[sl[x]]) / lens[x] : 0;
double g2 =
sl[x] <= now && sr[x] > now ? 1.0 * (h[now + 1] - h[now]) / lens[x] : 0;
for (int k = c + 1; k >= 1; k--) {
for (int t = c + 1 - k; t >= 1; t--)
F[k][t] = F[k][t] * g0 + F[k - 1][t] * g1 + F[k][t - 1] * g2;
F[k][0] = F[k][0] * g0 + F[k - 1][0] * g1;
}
for (int t = c + 1; t >= 1; t--) F[0][t] = F[0][t] * g0 + F[0][t - 1] * g2;
F[0][0] *= g0;
}
void solve(int l, int r, double F[N][N]) {
bool intersect = 0;
for (int i = l; i <= r; i++)
if (sl[i] <= now && sr[i] > now) {
intersect = 1;
break;
}
if (!intersect) return;
if (l == r) {
double pn = 1.0 * (h[now + 1] - h[now]) / lens[l];
for (int k = 0; k < n; k++)
for (int t = 0; k + t < n; t++)
add(l, k + 1, k + t + 1, F[k][t] * pn / (t + 1));
return;
}
int mid = (l + r) >> 1;
double FH[N][N];
memcpy(FH, F, sizeof(FH));
for (int i = r; i > mid; i--) trans(i, n - (i - l + 1), F);
solve(l, mid, F);
for (int i = l; i <= mid; i++) trans(i, n - (r - i + 1), FH);
solve(mid + 1, r, FH);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", sl + i, sr + i);
for (int i = 1; i <= n; i++)
lens[i] = sr[i] - sl[i], h[++V] = sl[i], h[++V] = sr[i];
sort(h + 1, h + V + 1);
V = unique(h + 1, h + V + 1) - (h + 1);
for (int i = 1; i <= n; i++)
sl[i] = lower_bound(h + 1, h + V + 1, sl[i]) - h,
sr[i] = lower_bound(h + 1, h + V + 1, sr[i]) - h;
for (now = 1; now < V; now++) {
double tmpf[N][N];
memset(tmpf, 0, sizeof(tmpf));
tmpf[0][0] = 1;
solve(1, n, tmpf);
}
for (int i = 1; i <= n; i++, puts(""))
for (int j = 1; j <= n; j++) printf("%.12lf ", ans[i][j] += ans[i][j - 1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using weight_t = int;
using capacity_t = int;
constexpr capacity_t inf = std::numeric_limits<capacity_t>::max() / 2;
struct edge {
int to;
weight_t w;
};
using edges = std::vector<edge>;
using graph = std::vector<edges>;
class gomory_hu {
public:
gomory_hu(int n) : built(false), cap(n, std::vector<capacity_t>(n)), gt(n) {}
void add_edge(int s, int t, capacity_t c) {
built = false;
cap[s][t] = cap[t][s] = c;
}
void build() {
const int n = cap.size();
std::vector<int> p(n), prev;
std::vector<capacity_t> w(n);
for (int s = 1; s < n; ++s) {
int t = p[s];
std::vector<std::vector<int>> f(n, std::vector<int>(n));
capacity_t total = 0;
while (true) {
std::queue<int> que;
que.push(s);
prev.assign(n, -1);
prev[s] = -2;
while (!que.empty() && prev[t] == -1) {
const int u = que.front();
que.pop();
for (int v = 0; v < n; ++v) {
if (prev[v] == -1 && cap[u][v] - (f[u][v] - f[v][u]) > 0) {
prev[v] = u;
que.push(v);
}
}
}
if (prev[t] == -1) break;
capacity_t inc = inf;
for (int v = t, u = prev[v]; u >= 0; v = u, u = prev[v]) {
inc = std::min(inc, cap[u][v] - (f[u][v] - f[v][u]));
}
for (int v = t, u = prev[v]; u >= 0; v = u, u = prev[v]) {
f[u][v] += inc;
}
total += inc;
}
w[s] = total;
for (int i = 0; i < n; ++i) {
if (i != s && prev[i] != -1 && p[i] == t) p[i] = s;
}
if (prev[p[t]] != -1) {
p[s] = p[t];
p[t] = s;
w[s] = w[t];
w[t] = total;
}
}
for (int s = 0; s < n; ++s) {
if (s == p[s]) continue;
gt[s].push_back(edge{p[s], w[s]});
gt[p[s]].push_back(edge{s, w[s]});
}
built = true;
}
std::vector<std::vector<weight_t>> all_pair_flow() const {
assert(built);
const int n = gt.size();
std::vector<std::vector<weight_t>> res(n, std::vector<weight_t>(n, inf));
for (int s = 0; s < n; ++s) {
std::function<void(int, int, int)> dfs = [&](int v, int p, weight_t w) {
res[s][v] = w;
for (auto const& e : gt[v]) {
if (e.to == p) continue;
dfs(e.to, v, std::min(w, e.w));
}
};
dfs(s, -1, inf);
}
return res;
}
graph get_tree() const { return gt; }
private:
bool built;
std::vector<std::vector<capacity_t>> cap;
graph gt;
};
using namespace std;
int main() {
int n, m;
cin >> n >> m;
gomory_hu gt(n);
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
gt.add_edge(a - 1, b - 1, c);
}
gt.build();
auto g = gt.get_tree();
int cost = 0;
vector<vector<bool>> used(n, vector<bool>(n));
function<vector<int>(int)> build_path = [&](int v) {
int use_u = -1, use_v = -1, use_w = inf;
function<void(int, int)> dfs = [&](int u, int p) {
for (auto const& e : g[u]) {
if (e.to == p || used[u][e.to]) continue;
if (e.w < use_w) {
use_u = u, use_v = e.to, use_w = e.w;
}
dfs(e.to, u);
}
};
dfs(v, -1);
if (use_u == -1) {
vector<int> res = {v};
return res;
}
used[use_u][use_v] = used[use_v][use_u] = true;
cost += use_w;
auto p1 = build_path(use_u), p2 = build_path(use_v);
p1.insert(end(p1), begin(p2), end(p2));
return p1;
};
const auto path = build_path(0);
cout << cost << endl;
for (int i = 0; i < n; ++i) {
cout << path[i] + 1 << " \n"[i + 1 == n];
}
}
| 5 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
using namespace std;
int main(){
int i, j, n, s, x, count;
vector<int> data;
while(1){
cin >> n >> s;
if(n == 0 && s == 0) break;
for(i=0; i<n; ++i){
cin >> x;
data.push_back(x);
}
sort(data.begin(), data.end(), greater<int>());
for(i=0, count=0; i<data.size(); ++i){
if(s <= data[i]){
count += (data.size()-1-i);
}else{
for(j=i+1; j<data.size(); ++j){
if(s >= data[i] + data[j]) break;
++count;
}
}
}
cout << count << endl;
data.clear();
}
return 0;
} | 0 |
#include "bits/stdc++.h"
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) (a).begin(),(a).end()
#define LL long long
int n;
LL m;
LL a[200000];
bool ok(int x){
FOR(i,x,n){
if(a[x+i]+a[2*n-1-(i-x)]<m)return false;
}
return true;
}
int main(){
cin>>n>>m;
REP(i,2*n)cin>>a[i];
sort(a,a+2*n);
int lb=0,ub=n;
while(lb<ub){
int mid = lb+(ub-lb)/2;
if(ok(mid)){
ub=mid;
}else{
lb=mid+1;
}
}
LL ret=0;
REP(i,lb)ret=max(ret,(a[i]+a[2*lb-1-i])%m);
FOR(i,lb,n)ret=max(ret,(a[lb+i]+a[2*n-1-(i-lb)])%m);
cout<<ret<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool vowel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') return 1;
return 0;
}
int main() {
string s;
cin >> s;
for (int i = 1; i < s.length(); i++) {
if (!vowel(s[i]) && !vowel(s[i - 1]) && s[i - 1] != 'n') {
cout << "NO";
return 0;
}
}
if (!vowel(s[s.length() - 1]) && s[s.length() - 1] != 'n') {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int inf = 1e9;
using namespace std;
const int maxn = 1e5 + 7;
int a[maxn] = {0};
char b[maxn];
int main() {
int n, r = inf, l = -inf;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
scanf("%s", b);
for (int i = 4; i < n; i++) {
if (b[i - 1] != b[i]) {
if (b[i] == '0') {
if (b[i - 2] == '1' && b[i - 3] == '1' && b[i - 4] == '1') {
sort(a + i - 4, a + i);
int tmp = min(a[i], a[i - 4]);
r = min(r, tmp - 1);
}
} else {
if (b[i - 2] == '0' && b[i - 3] == '0' && b[i - 4] == '0') {
sort(a + i - 4, a + i);
int tmp = max(a[i], a[i - 1]);
l = max(tmp + 1, l);
}
}
}
}
printf("%d %d\n", l, r);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e18;
const long long N = 1e5 + 1;
const long long mod = 1e9 + 7;
const long double ueps = 1E-7;
int mn, mx;
int n, a[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
mn++;
cin >> a[i];
if (mn > a[i])
mn = a[i];
else
a[i] = mn;
}
mn = 0;
for (int i = n; i >= 1; i--) {
mn++;
mn = min(mn, a[i]);
mx = max(mx, mn);
}
cout << mx << endl;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
long long int power(long long int x, long long int n) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % 1000000007;
x = (x * x) % 1000000007;
n = n / 2;
}
return result % 1000000007;
}
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long int inv(long long int a, long long int m) { return power(a, m - 2); }
long long int lcm(long long int a, long long int b) {
return a * b / (gcd(a, b));
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
string str, ch;
cin >> str;
cin >> ch;
bool x = true;
for (long long int i = 0; i < n; i++) {
if (str[i] != ch[i]) x = false;
}
if (x)
cout << 0 << '\n';
else if (n == 1) {
if (str[0] != ch[0])
cout << 1 << " " << 1 << '\n';
else
cout << 0 << '\n';
} else {
vector<long long int> vec;
long long int x = str[0] - '0';
for (long long int i = 0; i < n; i++) {
if ((long long int)(str[i] - '0') == x)
continue;
else {
vec.emplace_back(i);
x = 1 - x;
}
}
vector<long long int> v;
for (long long int i = n - 1; i >= 0; i--) {
if (x == (long long int)(ch[i] - '0'))
continue;
else {
v.emplace_back(i + 1);
x = 1 - x;
}
}
cout << (long long int)vec.size() + (long long int)v.size() << " ";
for (long long int i = 0; i < vec.size(); i++) cout << vec[i] << " ";
for (long long int i = 0; i < (long long int)v.size(); i++)
cout << v[i] << " ";
cout << '\n';
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[4][4];
long long f[4][4], dp[41][4][4];
int main() {
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++) scanf("%d", &a[i][j]), f[i][j] = a[i][j];
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++)
for (int k = 1; k <= 3; k++) f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
memset(dp, 63, sizeof(dp));
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++) dp[1][i][j] = f[i][j];
scanf("%d", &n);
for (int i = 2; i <= n; i++)
for (int j = 1; j <= 3; j++)
for (int k = 1; k <= 3; k++)
dp[i][j][k] =
min(dp[i - 1][j][6 - j - k] + dp[i - 1][6 - j - k][k] + a[j][k],
dp[i - 1][j][k] * 2 + dp[i - 1][k][j] + a[j][6 - j - k] +
a[6 - j - k][k]);
printf("%lld", dp[n][1][3]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MaxMask = (1 << 7);
const int N = 40 + 5;
const int INF = 1e8 + 10;
int dp[N][MaxMask][MaxMask], n, m;
int main(int argc, const char* argv[]) {
for (int i = 0; i < N; i++)
for (int j = 0; j < MaxMask; j++)
for (int k = 0; k < MaxMask; k++) dp[i][j][k] = INF;
cin >> n >> m;
if (n == 1 && m == 1) {
cout << 0;
return 0;
}
if (n > m) swap(n, m);
int mm = (1 << n);
int li = (1 << n) - 1;
for (int i = 0; i < mm; i++)
for (int j = 0; j < mm; j++) {
int check = ((i | j) | (i >> 1) | (i << 1));
if ((check & li) == li) {
dp[1][i][j] = __builtin_popcount(i);
}
}
for (int i = 1; i <= m; i++) {
for (int mask = 0; mask < mm; mask++)
for (int j = 0; j < mm; j++) {
if (dp[i][mask][j] == INF) continue;
int LIMIT = mm;
if (i == m - 1) LIMIT = 1;
for (int NewMask = 0; NewMask < LIMIT; NewMask++) {
int check = mask | j | NewMask | (j >> 1) | (j << 1);
if ((check & li) == li) {
dp[i + 1][j][NewMask] = min(dp[i + 1][j][NewMask],
dp[i][mask][j] + __builtin_popcount(j));
}
}
}
}
int ans = INF;
for (int k = 1; k <= m; k++)
for (int i = 0; i < mm; i++)
for (int j = 0; j < mm; j++) {
ans = min(ans, dp[m][i][j]);
}
cout << n * m - ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
void fmain() {
scanf("%d", &n);
int la = -1;
for (int(i) = 0; (i) < (int)(n); (i)++) {
scanf("%d", &k);
while (k % 2 == 0) k /= 2;
while (k % 3 == 0) k /= 3;
if (la == -1)
la = k;
else if (la != k) {
puts("NO");
return;
}
}
puts("YES");
}
int main() {
fmain();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s1[3];
set<int> s;
set<int> st;
int f[100100];
int used[100100];
int jud[100100];
int cnt;
int main() {
int n, m, i, j, k, l, flag;
scanf("%d%d", &n, &m);
memset(used, 0, sizeof(used));
cnt = 0;
flag = 0;
for (i = 1; i <= n; i++) f[i] = 1;
for (i = 1; i <= m; i++) {
scanf("%s%d", s1, &k);
used[k] = 1;
if (s1[0] == '+') {
if (!s.empty() || (flag == 1 && cnt != k)) f[k] = 0;
s.insert(k);
flag = 1;
if (f[k]) st.insert(k);
if (cnt > 0) {
if (cnt != k) f[cnt] = 0;
cnt = 0;
}
} else {
flag = 1;
if (cnt > 0) {
f[cnt] = 0;
cnt = 0;
}
if (s.find(k) != s.end()) {
s.erase(k);
} else {
while (!st.empty()) {
int u = *(st.begin());
f[u] = 0;
st.erase(u);
}
}
if (!s.empty())
f[k] = 0;
else
cnt = k;
}
}
int ans = 0;
for (i = 1; i <= n; i++) {
if (f[i] == 1) ans++;
}
printf("%d\n", ans);
for (i = 1; i <= n; i++) {
if (f[i] == 1) printf("%d ", i);
}
printf("\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int chkmax(T& a, T b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
template <class T>
int chkmin(T& a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class iterator>
void output(iterator begin, iterator end, ostream& out = cerr) {
while (begin != end) {
out << (*begin) << " ";
begin++;
}
out << endl;
}
template <class T>
void output(T x, ostream& out = cerr) {
output(x.begin(), x.end(), out);
}
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long xr, sum;
signed main() {
fast_io();
cin >> xr >> sum;
if (sum < xr || sum % 2 != xr % 2) {
cout << -1 << endl;
exit(0);
}
if (sum == 0 && xr == 0) {
cout << 0 << endl;
exit(0);
}
if (sum == xr) {
cout << 1 << endl;
cout << sum << endl;
exit(0);
}
long long _sum = sum;
long long a = xr, b = 0;
for (int i = 61; i >= 0; --i) {
if (((xr >> i) & 1LL) == 0) {
long long val = (1LL << i);
if (sum - xr >= 2 * val) {
sum -= 2 * val;
a += val;
b += val;
}
}
}
if (sum == xr) {
cout << 2 << endl;
cout << a << " " << b << endl;
exit(0);
}
cout << 3 << endl;
cout << xr << " " << (_sum - xr) / 2 << " " << (_sum - xr) / 2 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int H, W;
uint8_t d[2][190][190][190], pos[190][190][190], down[190][190];
char A[190][190];
int main() {
scanf("%d%d", &H, &W);
for (int i = 1; i <= H; ++i)
scanf("%s", A[i] + 1);
for (int i = H; i; --i)
for (int j = 1; j <= W; ++j)
if (i < H && A[i + 1][j] == A[i][j])
down[i][j] = down[i + 1][j];
else
down[i][j] = i;
for (int i = 1; i <= H; ++i)
for (int l = W; l; --l) {
d[0][i][l][l] = down[i][l];
int p = l - 1;
for (int r = l + 1; r <= W; ++r) {
d[0][i][l][r] = A[i][r] != A[i][l] ? 0 : min(d[0][i][l][r - 1], down[i][r]);
while (p + 1 < r && d[0][i][l][p + 1] > d[0][i][p + 2][r])
++p;
pos[i][l][r] = p;
}
}
if (d[0][1][1][W] == H) return puts("0"), 0;
for (int k = 1;; ++k) {
memset(d[k & 1], 0, sizeof d[k & 1]);
for (int i = 1; i <= H; ++i)
for (int l = W; l; --l)
for (int r = l, p = l - 1; r <= W; ++r) {
d[k & 1][i][l][r] = max({
d[k - 1 & 1][i][l][r],
d[k - 1 & 1][d[k - 1 & 1][i][l][r] + 1][l][r],
pos[i][l][r] >= l && pos[i][l][r] < r ? d[k - 1 & 1][i][pos[i][l][r] + 1][r] : (uint8_t)0,
pos[i][l][r] + 1 >= l && pos[i][l][r] + 1 < r ? d[k - 1 & 1][i][l][pos[i][l][r] + 1] : (uint8_t)0});
while (p + 1 < r && d[k & 1][i][l][p + 1] > d[k & 1][i][p + 2][r])
++p;
pos[i][l][r] = p;
}
if (d[k & 1][1][1][W] == H) return printf("%d\n", k), 0;
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int MAXN = 305;
int graph[MAXN][MAXN];
int n, m;
struct mat {
int a[MAXN][MAXN];
mat() {
for (int i = 1; i <= 300; i++)
for (int j = 1; j <= 300; j++) a[i][j] = -(int)1e9;
for (int i = 1; i <= 300; i++) a[i][i] = 0;
}
mat operator*(mat b) const {
mat r;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++)
r.a[i][j] = max(r.a[i][j], a[i][k] + b.a[k][j]);
return r;
}
} base[15];
mat power(mat x, int n) {
n--;
mat res = x;
while (n) {
if (n & 1) res = res * x;
x = x * x;
n >>= 1;
}
return res;
}
bool chk(mat &res) {
for (int i = 1; i <= n; i++)
if (res.a[i][i] > 0) return true;
return false;
}
signed main() {
cin.tie(0)->sync_with_stdio(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v, uv, vu;
cin >> u >> v >> uv >> vu;
base[0].a[u][v] = uv;
base[0].a[v][u] = vu;
}
for (int i = 1; i <= 9; i++) base[i] = base[i - 1] * base[i - 1];
if (!chk(base[9])) return cout << 0, 0;
mat res;
int ans = 0;
for (int i = 8; i >= 0; i--) {
mat pp = res * base[i];
if (!chk(pp)) {
res = pp;
ans += (1 << i);
}
}
cout << ans + 1;
}
| 2 |
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
#pragma GCC optimize ("-O3")
using namespace std; void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
typedef long long ll; const int inf = INT_MAX / 2; const ll infl = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a = b; return 1; } return 0; }
//---------------------------------------------------------------------------------------------------
/*---------------------------------------------------------------------------------------------------
∧＿∧
∧＿∧ （´<_｀ ） Welcome to My Coding Space!
（ ´_ゝ`） / ⌒i
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
---------------------------------------------------------------------------------------------------*/
string S;
int N;
//---------------------------------------------------------------------------------------------------
// state
// =0:none
// =1:5
// =2:51
// =3:51? (?!=5)
// =4:515
// =5:51?3達成済み
ll memo[20][6][2];
ll f(int cu, int state, int isless) {
if (cu == N) {
if (state == 5) return 1;
else return 0;
}
if (0 <= memo[cu][state][isless]) return memo[cu][state][isless];
int c = S[cu] - '0';
ll res = 0;
rep(i, 0, 10) {
if (!isless and c < i) continue;
int nxisless = isless;
if (i < c) nxisless = 1;
if (state == 0) {
if (i == 5) res += f(cu + 1, 1, nxisless);
else res += f(cu + 1, 0, nxisless);
}
else if (state == 1) {
if (i == 1) res += f(cu + 1, 2, nxisless);
else if (i == 5) res += f(cu + 1, 1, nxisless);
else res += f(cu + 1, 0, nxisless);
}
else if (state == 2) {
if (i == 5) res += f(cu + 1, 4, nxisless);
else res += f(cu + 1, 3, nxisless);
}
else if (state == 3) {
if (i == 3) res += f(cu + 1, 5, nxisless);
else if (i == 5) res += f(cu + 1, 1, nxisless);
else res += f(cu + 1, 0, nxisless);
}
else if (state == 4) {
if(i == 3) res += f(cu + 1, 5, nxisless);
else if(i == 1) res += f(cu + 1, 2, nxisless);
else if(i == 5) res += f(cu + 1, 1, nxisless);
else res += f(cu + 1, 0, nxisless);
}
else if (state == 5) {
res += f(cu + 1, 5, nxisless);
}
}
return memo[cu][state][isless] = res;
}
//---------------------------------------------------------------------------------------------------
void _main() {
cin >> S;
N = S.length();
rep(cu, 0, N + 1) rep(state, 0, 6) rep(isless, 0, 2) memo[cu][state][isless] = -1;
cout << f(0, 0, 0) << endl;
}
| 0 |
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define maxn 100005
using namespace std;
int n;
int main()
{
int ans=0;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
int x,k;
scanf("%d%d",&x,&k);
while(x%k)
{
x-=(x/k+1)*((x%k-1)/(x/k+1)+1);
}
ans^=(x/k);
}
if(ans)
printf("Takahashi\n");
else
printf("Aoki\n");
}
| 0 |
#include <iostream>
using namespace std;
long long X,Y;
int main(){
cin >> X >> Y;
if((X+Y>1 && abs(X-Y)<=1) || (X==0 && Y==0)) cout << "Brown" << endl;
else cout << "Alice" << endl;
} | 0 |
#define _USE_MATH_DEFINES
#define INF 10000000
#include <iostream>
#include <sstream>
#include <cmath>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P > PP;
static const double eps = 1e-8;
bool check(int i,string str){
string ans;
if(i%15==0) ans = "FizzBuzz";
else if(i%3==0) ans = "Fizz";
else if(i%5==0) ans = "Buzz";
else{
char buf[128];
sprintf(buf,"%d",i);
ans = buf;
}
return (ans == str);
}
int main(){
int m,n;
while(~scanf("%d %d",&m,&n)){
if(m==n && n==0) break;
list<int> player;
for(int i=1;i<=m;i++) player.push_back(i);
int alive = m;
for(int i=0,j=0;i<n;i++){
string str;
cin >> str;
if(alive>1 && !check(i+1,str)){
list<int>::iterator it = player.begin();
advance(it,j);
player.erase(it);
alive--;
}
else j++;
j %= alive;
}
for(list<int>::iterator it = player.begin(); it != player.end(); it++){
printf("%s%d",it == player.begin() ? "" : " ",*it);
}
printf("\n");
}
} | 0 |
#include <bits/stdc++.h>
int main() {
int a, b, i, j, count, n;
scanf("%d %d", &a, &b);
for (i = a, count = 0; i <= b; i++) {
for (n = i; n != 0;) {
j = n % 10;
if (j == 0 || j == 6 || j == 9) {
count = count + 6;
} else if (j == 1) {
count = count + 2;
} else if (j == 2 || j == 3 || j == 5) {
count = count + 5;
} else if (j == 4) {
count = count + 4;
} else if (j == 7) {
count = count + 3;
} else {
count = count + 7;
}
n = (n - j) / 10;
}
}
printf("%d", count);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int main() {
char s[1000006];
scanf("%s", &s);
int l = strlen(s);
long long ans = 0;
long long sumb = 0;
for (int i = l - 1; i >= 0; i--) {
if (s[i] == 'b') sumb++;
sumb %= mod;
if (s[i] == 'a') {
ans = (ans + sumb) % mod;
sumb = (sumb * 2) % mod;
}
}
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
class writeInfo{
public:
int from;
int to;
int discripter;
};
int main(){
int N;
bool fst=false;
while(cin>>N&&N!=0){
vector<writeInfo> info;
for(int i = 0; i < N; i++){
char order;
cin>>order;
if(order=='W'){
int discripter;
int leftWritingSize=0;
int finTo=0;
cin>>discripter>>leftWritingSize;
int prvPlace=0;
for(int j = 0; j < info.size(); j++){
if(leftWritingSize==0)
break;
// àµó«Xy[Xª³©Á½ç
if(prvPlace==info[j].from){
prvPlace=info[j].to+1;
finTo=info[j].to+1;
continue;
}
// ó«Xy[Xª Á½êA«ß龯«Þ
else{
int to=min(leftWritingSize,info[j].from-prvPlace);
leftWritingSize-=to;
writeInfo wi;
wi.discripter=discripter;
wi.from=prvPlace;
wi.to=prvPlace+to-1;
//info.push_back(wi);
info.insert(info.begin()+j,wi);
if(leftWritingSize==0)
break;
finTo=info[j].to+1;
prvPlace=info[j].to+1;
}
}
if(leftWritingSize>0){
writeInfo wi;
wi.discripter=discripter;
wi.from=finTo;
wi.to=finTo+leftWritingSize-1;
info.push_back(wi);
}
}
else if(order=='R'){
int secter;
cin>>secter;
bool isFind=false;
// from-toÌÔÉsecterª 驲×é
for(int j = 0; j < info.size(); j++){
if(info[j].from<=secter&&info[j].to>=secter){
cout<<info[j].discripter<<endl;
isFind=true;
break;
}
}
if(!isFind)
cout<<-1<<endl;
}
else if(order=='D'){
int discrepter;
cin>>discrepter;
// fBXNv^ªêv·éàÌð·×Äí
for(int j = info.size()-1; j>=0; j--){
if(info[j].discripter==discrepter){
info.erase(info.begin()+j);
}
}
}
}
cout<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n,m,a[1000];
cin>>n>>m;
for(int i=0;i<n;i++)cin>>a[i];
bool used[1000]={};
int p=0,ans=0;
while(!used[p]){
int mx=-1,mn=1e9,i=0;
while(i<m){
mn=min(a[(p+i)%n],mn);
mx=max(a[(p+i)%n],mx);
i++;
}
ans+=mx-mn;
used[p]=1;
p=(p+m)%n;
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf(" %d", &n);
vector<pair<int, int> > ans;
for (int i = 2; i <= n; ++i) {
ans.push_back({i, i - 1});
int val = i - 3;
if (val > 0) ans.push_back({val, i});
val -= 2;
while (val > 0) {
ans.push_back({val, i});
val -= 2;
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i)
printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int p1 = 233, p2 = 433;
long long a[2020][3], b[2020][3];
int nxt[2020];
char aa[2020][2020], bb[2020][2020];
long long hs[2020][3], hs2[2020][3];
map<pair<long long, long long>, int> vis;
int main() {
int ans, n, m, i, j, k;
long long sum1, sum2, tmp1, tmp2;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%s", aa[i] + 1);
}
for (i = 1; i <= m; i++) {
scanf("%s", bb[i] + 1);
}
tmp1 = 1;
for (i = 1; i <= m; i++) tmp1 = tmp1 * p1;
tmp2 = 1;
for (i = 1; i <= m; i++) tmp2 = tmp2 * p2;
for (i = 1; i <= n; i++) {
sum1 = 0, sum2 = 0;
for (j = 1; j <= m; j++) {
sum1 = sum1 * p1 + aa[i][j] - 'a' + 1;
sum2 = sum2 * p2 + aa[i][j] - 'a' + 1;
}
hs[i][1] = sum1;
hs[i][2] = sum2;
}
for (i = 1; i <= n - m + 1; i++) {
sum1 = 0, sum2 = 0;
for (j = 1; j <= m; j++) {
sum1 = sum1 * tmp1 + hs[i + j - 1][1];
sum2 = sum2 * tmp2 + hs[i + j - 1][2];
}
vis[make_pair(sum1, sum2)] = i;
}
for (i = 1; i <= n; i++) {
sum1 = 0, sum2 = 0;
for (j = 1; j <= m; j++) {
sum1 = sum1 * tmp1 + bb[j][i] - 'a' + 1;
sum2 = sum2 * tmp2 + bb[j][i] - 'a' + 1;
}
hs2[i][1] = sum1;
hs2[i][2] = sum2;
}
for (i = 1; i <= n - m + 1; i++) {
sum1 = 0, sum2 = 0;
for (j = 1; j <= m; j++) {
sum1 = sum1 * p1 + hs2[i + j - 1][1];
sum2 = sum2 * p2 + hs2[i + j - 1][2];
}
if (vis.count(make_pair(sum1, sum2))) {
printf("%d %d\n", vis[make_pair(sum1, sum2)], i);
return 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string s;
int ret;
void solve() {
int first, na, nb;
cin >> n >> k >> s;
first = 0;
na = 0;
nb = 0;
ret = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'a')
na++;
else
nb++;
if (min(na, nb) > k) {
if (s[first] == 'a')
na--;
else
nb--;
first++;
} else {
ret++;
}
}
cout << ret << endl;
}
int main() {
solve();
return 0;
}
| 3 |
#include<iostream>
#include<string>
using namespace std;
int main() {
int n; cin >> n;
int t = 0, h = 0;
for (int i = 0; i < n; i++){
string a, b; cin >> a >> b;
if (a == b){
t++;
h++;
}
else if (a > b){
t += 3;
}
else if (a < b) {
h += 3;
}
}
cout << t << ' ' << h << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, *p;
cin >> n;
p = new int[n];
for (int i = 0; i < n; i++) {
cin >> p[i];
}
sort(p, p + n);
int esum = 0, osum = 0;
for (int i = 0; i < n; i += 2) {
esum += p[i];
osum += p[i + 1];
}
cout << abs(esum - osum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a,cnt,i;
int main(){
while(i++<3){
char s;cin>>s;
if(s=='R')a=++cnt;
else cnt=0;
}
cout<<a<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main(){
int n;cin>>n;
cin>>s;
if (n%2==1 || s.substr(0,n/2)!=s.substr(n/2,n/2)) cout<<"No";
else cout<<"Yes";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> ans[100100];
int f[100100][2], cnt[100100];
char s[100100];
int n, m;
int main() {
scanf("%d\n", &n);
scanf("%s\n", &s);
scanf("%d\n", &m);
for (int i = 1; i <= n; i++) {
cnt[i] = cnt[i - 1] + (s[i - 1] == '?');
if (s[i - 1] != 'a') f[i][1] = f[i - 1][0] + 1;
if (s[i - 1] != 'b') f[i][0] = f[i - 1][1] + 1;
if (f[i][(m + 1) & 1] >= m) {
ans[i].first = ans[i - m].first + 1;
ans[i].second = ans[i - m].second - cnt[i] + cnt[i - m];
}
ans[i] = max(ans[i], ans[i - 1]);
}
printf("%d\n", -ans[n].second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define rep2D(l, r, n) \
for (int __repeat_gap = 0; __repeat_gap < n; ++__repeat_gap) \
for (l = 1, r = l + __repeat_gap; r <= n; ++l, ++r)
#define per2D(l, r, n) \
for (int __repeat_gap = n - 1; __repeat_gap > 0; --__repeat_gap) \
for (l = 1, r = l + __repeat_gap; r <= n; ++l, ++r)
typedef unsigned char u8;
const int N = 187;
int R, C;
int sum[N][N];
u8 ri[16][N][N][N], dn[16][N][N][N];
// right[k][r1][r2][c], down[k][c1][c2][r]
inline void up(u8 &x, const u8 y) {x < y ? x = y : 0;}
inline int S(int r1, int c1, int r2, int c2) {return sum[r2][c2] - sum[r2][c1 - 1] - sum[r1 - 1][c2] + sum[r1 - 1][c1 - 1];}
int main() {
int i, j, r1, r2, c1, c2, cur, la, ans;
char tmp[N]; u8 *f, *g;
scanf("%d%d", &R, &C);
for (i = 1; i <= R; ++i)
for (scanf("%s", tmp + 1), j = 1; j <= C; ++j)
sum[i][j] = sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1] + (tmp[j] & 1);
rep2D(r1, r2, R) {
f = ri[0][r1][r2], la = -1;
for (j = C; j; --j, la = cur)
cur = S(r1, j, r2, j), f[j] = (cur && cur != r2 - r1 + 1 ? j - 1 : cur == la ? f[j + 1] : j);
}
rep2D(c1, c2, C) {
f = dn[0][c1][c2], la = -1;
for (i = R; i; --i, la = cur)
cur = S(i, c1, i, c2), f[i] = (cur && cur != c2 - c1 + 1 ? i - 1 : cur == la ? f[i + 1] : i);
}
// main_loop
for (ans = 0; ans < 15 && ri[ans][1][R][1] < C; ) {
rep2D(r1, r2, R) {
f = ri[ans][r1][r2], g = ri[ans + 1][r1][r2];
for (j = 1; j <= C; ++j) up(g[j], f[j] == C ? C : f[f[j] + 1]), up(dn[ans + 1][j][g[j]][r1], r2);
}
rep2D(c1, c2, C) {
f = dn[ans][c1][c2], g = dn[ans + 1][c1][c2];
for (i = 1; i <= R; ++i) up(g[i], f[i] == R ? R : f[f[i] + 1]), up(ri[ans + 1][i][g[i]][c1], c2);
}
++ans;
per2D(r1, r2, R)
for (j = 1; j <= C; ++j)
up(ri[ans][r1][r2 - 1][j], ri[ans][r1][r2][j]), up(ri[ans][r1 + 1][r2][j], ri[ans][r1][r2][j]);
per2D(c1, c2, C)
for (i = 1; i <= R; ++i)
up(dn[ans][c1][c2 - 1][i], dn[ans][c1][c2][i]), up(dn[ans][c1 + 1][c2][i], dn[ans][c1][c2][i]);
}
ans += ri[ans][1][R][1] < C, printf("%d\n", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 404040;
int cnt, cnt2, cnt3, h, n, m;
struct Node {
int x, y, w, d, i;
} a[N];
bool cmp(Node x, Node y) { return x.d < y.d; }
vector<int> s[N];
vector<pair<int, int> > ss[N];
int dfn[N], low[N], viss[N], q[N], color[N], as[N];
map<int, int> sum, vis;
void jiantu(int x, int y) { s[x].push_back(y); }
void tarjan(int x) {
int c, i, y;
q[h++] = x, viss[x] = 1;
dfn[x] = low[x] = ++cnt2;
c = s[x].size();
for (i = 0; i < c; i++) {
y = s[x][i];
if (!dfn[y])
tarjan(y), low[x] = min(low[x], low[y]);
else if (viss[y])
low[x] = min(low[x], dfn[y]);
}
if (low[x] == dfn[x]) {
cnt3++;
while (1) {
h--;
color[q[h]] = cnt3;
viss[q[h]] = 0;
if (q[h] == x) {
q[h] = 0;
break;
}
q[h] = 0;
}
}
}
int check(int x) {
int i, ans = 1;
for (i = x + 1; i <= m; i++) jiantu(i + i, i + i - 1);
cnt2 = 0, cnt3 = 0;
memset(dfn, 0, sizeof(dfn));
memset(low, 0, sizeof(low));
memset(viss, 0, sizeof(viss));
memset(color, 0, sizeof(color));
for (i = 1; i <= cnt; i++)
if (!dfn[i]) h = 0, tarjan(i);
for (i = 1; i <= m; i++)
if (color[i + i - 1] == color[i + i]) ans = 0;
for (i = x + 1; i <= m; i++) s[i + i].pop_back();
return ans;
}
int erf(int l, int r) {
while (l <= r) {
int mid = l + r >> 1;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
return l;
}
void init() {
int c, i, y, j, pl;
cnt = m + m;
for (i = 1; i <= n; i++) {
c = ss[i].size();
for (j = 0; j < c; j++) {
y = ss[i][j].first;
pl = ss[i][j].second;
sum[a[pl].w]++;
if (sum[a[pl].w] == 3) {
puts("No");
exit(0);
} else if (sum[a[pl].w] == 2) {
jiantu(vis[a[pl].w] * 2 - 1, pl + pl);
jiantu(pl + pl - 1, vis[a[pl].w] * 2);
}
vis[a[pl].w] = pl;
}
for (j = 0; j < c; j++) sum[a[ss[i][j].second].w]--;
for (j = 0; j < c; j++) {
y = ss[i][j].second;
if (j != c - 1) {
cnt++;
if (j != 0) jiantu(cnt, cnt - 1);
jiantu(cnt, y + y - 1);
}
if (j != 0) {
if (j != c - 1)
jiantu(y + y, cnt - 1);
else
jiantu(y + y, cnt);
}
}
for (j = c - 1; j >= 0; j--) {
y = ss[i][j].second;
if (j != 0) {
cnt++;
jiantu(cnt, y + y - 1);
if (j != c - 1) jiantu(cnt, cnt - 1);
}
if (j != c - 1) {
if (j != 0)
jiantu(y + y, cnt - 1);
else
jiantu(y + y, cnt);
}
}
}
}
int main() {
int i, ans, cnt;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++)
scanf("%d%d%d%d", &a[i].x, &a[i].y, &a[i].w, &a[i].d), a[i].i = i;
sort(a + 1, a + m + 1, cmp);
for (i = 1; i <= m; i++)
ss[a[i].x].push_back(make_pair(a[i].y, i)),
ss[a[i].y].push_back(make_pair(a[i].x, i));
init();
ans = erf(0, m);
if (!check(ans)) {
puts("No");
return 0;
}
puts("Yes");
cnt = 0;
for (i = 1; i <= m; i++)
if (color[i + i - 1] > color[i + i]) as[++cnt] = a[i].i;
printf("%d %d\n", a[ans].d, cnt);
for (i = 1; i <= cnt; i++) printf("%d ", as[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll b[2010],a[2010];
int main()
{
ll i,j,k,m,n,x;
ll cnt,ans=1ll * 2010 * 1e9;
memset(a,0x3f,sizeof(a));
cin>>n>>x;
for(i=0; i<n; i++)
cin>>b[i];
for(i=0; i<n; i++)
{
cnt=0;
for(j=0; j<n; j++)
a[j]=min(a[j],b[(j-i+n)%n]);
for(j=0; j<n; j++)
cnt+=a[j];
ans=min(ans,i*x+cnt);
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void read(Tp &x) {
static char c;
static bool neg;
x = 0, c = getchar(), neg = false;
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (neg) {
x = -x;
}
}
const int N = 100000 + 5;
int n, k;
int head[N], E = 0;
struct Edge {
int to, next;
} e[N * 2];
inline void addEdge(int u, int v) {
e[++E] = (Edge){v, head[u]};
head[u] = E;
}
int dep[N], far[N], maxDep, maxDepNode;
bool vis[N];
int fa[N], dfn[N], tim = 0;
void dfs(int u, int far) {
fa[u] = far;
for (int i = head[u], v; i; i = e[i].next) {
v = e[i].to;
if (v != far) {
dfs(v, u);
}
}
dfn[++tim] = u;
}
int dp[N], ans[N];
inline int solve(int len) {
int res = 0;
fill(dp + 1, dp + n + 1, 1);
for (int i = 1, u, far; i <= n; ++i) {
u = dfn[i], far = fa[u];
if (far != 0 && dp[far] != -1) {
if (dp[u] != -1) {
if (dp[u] + dp[far] >= len) {
++res;
dp[far] = -1;
} else {
dp[far] = std::max(dp[far], dp[u] + 1);
}
}
}
}
return res;
}
int main() {
read(n);
int brute = (int)ceil(sqrt(n * log2(n)));
for (int i = 1, u, v; i < n; ++i) {
read(u), read(v);
addEdge(u, v);
addEdge(v, u);
}
dfs(1, 0);
ans[1] = n;
for (int i = 2; i <= brute; ++i) {
ans[i] = solve(i);
}
for (int i = brute + 1, l, r, mid, leftAns, res; i <= n; i = r + 1) {
l = i, r = n;
leftAns = solve(l);
while (l <= r) {
mid = (l + r) >> 1;
if (solve(mid) == leftAns) {
l = mid + 1;
res = mid;
} else {
r = mid - 1;
}
}
fill(ans + i, ans + res + 1, leftAns);
}
for (int i = 1; i <= n; ++i) {
printf("%d\n", ans[i]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
int m, a[400004];
long long pw[200002];
int main() {
cin >> s >> m;
int n = s.size();
for (int i = 0; i < n; i++) {
a[i] = s[i] - '0';
a[i + n] = a[i];
}
pw[0] = 1;
for (int i = 1; i < n; i++) {
pw[i] = (pw[i - 1] * 10) % m;
}
long long x = 0;
for (int i = 0; i < n; i++) {
x *= 10;
x += a[i];
x %= m;
}
long long ans = x;
for (int i = 0; i < n; i++) {
long long q = (a[i] * pw[n - 1]) % m;
x = (x - q + m) % m;
x *= 10;
x += a[i + n];
x %= m;
if (a[i + 1] > 0) ans = min(ans, x);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << "1 1\n";
cout << -a[0] << "\n1 1\n0\n1 1\n0\n";
return 0;
}
cout << "1 1\n" << -a[0] << "\n";
cout << "2 " << n << "\n";
for (int i = 0; i < n - 1; i++) {
cout << a[i + 1] * (n - 1);
if (i == n - 2)
cout << "\n";
else
cout << " ";
}
cout << "1 " << n << "\n";
cout << "0";
for (int i = 0; i < n - 1; i++) {
cout << " " << -a[i + 1] * n;
}
cout << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int be[1000001], en[1000001], nu[1000001];
int main() {
int n, i, a, l = 0, r = 0, o = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a;
if (be[a] == 0) {
be[a] = i;
en[a] = i;
nu[a] = 1;
} else {
en[a] = i;
nu[a]++;
}
}
for (i = 0; i < 1000001; i++)
if (o < nu[i] || (o == nu[i] && r - l > en[i] - be[i])) {
l = be[i];
r = en[i];
o = nu[i];
}
cout << l << " " << r << endl;
}
| 2 |
/*
直接想贪心
序列是从祖先到子树里扩展的
把一个点弄开后，肯定先把所有的 0 给弄进序列里
这启发我们将点合在一起，即选择了父亲一定再选儿子
考虑两端序列那个放在前面更优
发现结果是只要让 cnt_1 / cnt_0 尽量小就行
*/
#include <bits/stdc++.h>
#define N 200005
using namespace std;
int n;
int fa[N], x[N], y[N]; // x : cnt_1, y : cnt_0
int val[N], o;
namespace UFS {
int fa[N];
inline void init() { for(int i = 1; i <= n; ++i) fa[i] = i; }
inline int find(int u) { return fa[u] == u ? u : fa[u] = find(fa[u]); }
}
struct cmpNode {
bool operator () (const int &lhs, const int &rhs) {
if(lhs == 1 || rhs == 1) {
return lhs > rhs;
} else if(1LL * x[lhs] * y[rhs] == 1LL * x[rhs] * y[lhs]) {
return lhs < rhs;
} else {
return 1LL * x[lhs] * y[rhs] < 1LL * x[rhs] * y[lhs];
}
}
};
set<int, cmpNode> se;
int main() {
scanf("%d", &n);
for(int i = 2; i <= n; ++i)
scanf("%d", &fa[i]);
for(int i = 1; i <= n; ++i)
scanf("%d", &val[i]);
UFS::init();
for(int i = 1; i <= n; ++i) {
if(val[i]) {
++x[i];
} else {
++y[i];
}
se.insert(i);
}
long long ans = 0;
set<int, cmpNode>::iterator it;
for(int i = n; i > 1; --i) {
it = se.begin();
int u = *it, v = UFS::find(fa[u]);
UFS::fa[u] = v;
se.erase(u), se.erase(v);
ans += 1LL * y[u] * x[v];
x[v] += x[u], y[v] += y[u];
se.insert(v);
}
printf("%lld\n", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; ++i)
#define repn(i, n) for(int i = 1; i <= n; ++i)
#define all(x) x.begin(), x.end()
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
const int inf = 1e9;
int n, m, tt;
vi v;
char c;
const int mod = (int)1e9 + 7;
ll solve(){
ll ans = 1;
cin>>n>>m;
bool has = false;
rep(i, n){
rep(j, m){
cin>>c;
if(c == '0')has = true;
else ans = (2LL * ans) % mod;
}
}
if(has)return ans;
else return ans - 1;
}
int main(){
cin>>tt;
while(tt){
cout<<solve()<<endl;
tt--;
}
return 0;
}
//https://codeforces.com/blog/entry/91520
| 5 |
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,f[100][10],p[100][11],ans=-1e9;
cin>>n;
for(int i=0;i<n;i++)
for(int j=0;j<10;j++)
cin>>f[i][j];
for(int i=0;i<n;i++)
for(int j=0;j<11;j++)
cin>>p[i][j];
for(int i=1;i<(1<<10);i++){
int prof=0;
for(int j=0;j<n;j++){
int c=0;
for(int k=0;k<10;k++)
if(i&1<<k&&f[j][k])
c++;
prof+=p[j][c];
}
ans=max(prof,ans);
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef struct mytype {
long long int a, b;
} mytype;
bool myfn(const mytype &X, const mytype &Y) { return X.b * Y.a <= X.a * Y.b; }
int main() {
long double n, p;
cin >> n >> p;
vector<mytype> A(n);
long double aa = 0;
for (int i = 0; i < n; i++) {
cin >> A[i].a >> A[i].b;
aa += A[i].a;
}
if (aa <= p) {
cout << -1;
return 0;
}
long double low = 0, high = 1e14, pp, xx, mid, temp;
while (high - low > 1e-4) {
mid = (low + high) / 2.0;
temp = 0;
for (int i = 0; i < n; i++) {
xx = max((long double)0.0, mid * A[i].a - A[i].b);
temp = temp + xx;
}
pp = p * mid;
if (temp <= pp) {
low = mid;
} else {
high = mid;
}
}
if (round(low) == 1e14) {
cout << -1;
return 0;
}
cout << fixed << setprecision(10) << low;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
char ss[maxn][maxn];
int ans[maxn][maxn];
int vis[maxn][maxn];
char mm[maxn][maxn];
int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
int n, m;
struct node {
int x;
int y;
};
void paint(int x, int y, int d) {
if (d == 0) {
mm[x][y] = '^';
mm[x + 1][y] = 'v';
} else if (d == 1) {
mm[x][y] = 'v';
mm[x - 1][y] = '^';
} else if (d == 2) {
mm[x][y] = '<';
mm[x][y + 1] = '>';
} else {
mm[x][y] = '>';
mm[x][y - 1] = '<';
}
}
int isin(int a, int b) { return a >= 0 && a < n && b >= 0 && b < m; }
int main() {
cin >> n >> m;
int cont = 0;
for (int i = 0; i < n; i++) cin >> ss[i];
queue<node> que;
memset(ans, 0, sizeof ans);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (ss[i][j] == '.') {
if (isin(i + 1, j)) {
if (ss[i + 1][j] == '.') {
ans[i][j]++;
ans[i + 1][j]++;
}
}
if (isin(i, j + 1)) {
if (ss[i][j + 1] == '.') {
ans[i][j]++;
ans[i][j + 1]++;
}
}
if (ans[i][j] == 1) {
node tmp;
tmp.x = i;
tmp.y = j;
que.push(tmp);
}
cont++;
} else
mm[i][j] = '*';
}
int cnt = 0;
memset(vis, 0, sizeof vis);
while (!que.empty()) {
node tmp = que.front();
int nx = tmp.x, ny = tmp.y;
que.pop();
if (vis[nx][ny]) continue;
vis[nx][ny] = 1;
for (int i = 0; i < 4; i++) {
int dx = nx + dir[i][0];
int dy = ny + dir[i][1];
if (isin(dx, dy) && !vis[dx][dy] && ss[dx][dy] == '.') {
vis[dx][dy] = 1;
cnt += 2;
paint(nx, ny, i);
for (int k = 0; k < 4; k++) {
int tx = dx + dir[k][0];
int ty = dy + dir[k][1];
if (isin(tx, ty) && !vis[tx][ty] && ss[dx][dy] == '.') {
ans[tx][ty]--;
if (ans[tx][ty] == 1) {
node tt;
tt.x = tx;
tt.y = ty;
que.push(tt);
}
}
}
break;
}
}
}
if (cont == cnt) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << mm[i][j];
}
cout << endl;
}
} else
cout << "Not unique" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
string s[1000], s1, s2;
int cnt1[26] =
{
0,
},
cnt2[26] =
{
0,
},
objectCnt = 1;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
vector<string> obj;
string object = "";
for (int j = 0; j < s[0].length(); ++j) {
cnt1[s[0][j] - 'a'] = 1;
}
for (int i = 0; i < 26; ++i) {
if (cnt1[i]) {
object += ('a' + i);
}
}
obj.push_back(object);
for (int i = 1; i < n; ++i) {
object = "";
bool flag = false;
s2 = s[i];
for (int j = 0; j < s2.length(); ++j) {
cnt2[s2[j] - 'a'] = 1;
}
for (int j = 0; j < 26; ++j) {
if (cnt2[j]) {
object += ('a' + j);
}
cnt1[j] = cnt2[j];
cnt2[j] = 0;
}
vector<string>::iterator it = find(obj.begin(), obj.end(), object);
if (it == obj.end()) {
flag = true;
obj.push_back(object);
}
s1 = s2;
if (flag) objectCnt++;
}
printf("%d\n", objectCnt);
return 0;
}
| 1 |
#include <iostream>
#include <queue>
#include <stdio.h>
#include <vector>
using namespace std;
int main()
{
int n, q;
scanf("%d %d", &n, &q);
vector<queue<int> > vec(n);
int flag, t, x;
for (int i = 0; i < q; i++)
{
scanf("%d", &flag);
switch (flag) {
case 0:
scanf("%d %d", &t, &x);
vec[t].push(x);
break;
case 1:
scanf("%d", &t);
if (!vec[t].empty())
{
printf("%d\n",vec[t].front());
}
break;
case 2:
scanf("%d", &t);
if (!vec[t].empty())
{
vec[t].pop();
}
break;
default:
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int m = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
long long int n, l, k;
cin >> n >> l >> k;
vector<vector<long long int> > dp(n + 1, vector<long long int>(k + 1));
vector<long long int> a(n + 1);
vector<long long int> pos(n + 1);
vector<pair<long long int, long long int> > p;
vector<long long int> mul(n + 1);
for (int i = 0; i <= n - 1; i++) {
cin >> a[i];
p.push_back(make_pair(a[i], i));
}
sort(p.begin(), p.end());
long long int mu = l / n, re = l % n;
int ptr = 0;
for (int i = 0; i <= n - 1; i++) {
while (ptr < n - 1 && p[ptr + 1].first <= p[i].first) ptr++;
pos[i] = ptr;
dp[i][0] = 1;
if (p[i].second < re)
mul[i] = mu + 1;
else
mul[i] = mu;
}
long long int ans = 0;
for (int j = 1; j <= k; j++) {
for (int i = 0; i <= n - 1; i++) {
dp[i][j] = dp[pos[i]][j - 1];
long long int t = mul[i];
t -= (j - 1);
if (t < 0) t = 0;
t %= m;
ans = (ans + t * dp[i][j]) % m;
if (i) dp[i][j] += dp[i - 1][j];
dp[i][j] %= m;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> res(n);
for (auto &v : res) cin >> v;
int sum = 0, mini = INT_MAX, index = -1, i;
for (i = 0; i < n; i++) {
if (i < k) {
sum += res[i];
continue;
} else {
if (mini > sum) {
mini = sum;
index = i;
}
sum -= res[i - k];
sum += res[i];
}
}
if (mini > sum) index = i;
mini == INT_MAX ? cout << 1 : cout << (index - k + 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool prime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long int power(long long int x, long long int y) {
long long int temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
long long int no_of_factors(long long int n) {
long long int cnt = 0;
for (long long int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
cnt++;
else
cnt = cnt + 2;
}
}
return cnt;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool subsequence_checker(string str1, string str2, long long int m,
long long int n) {
if (m == 0) return true;
if (n == 0) return false;
if (str1[m - 1] == str2[n - 1])
return subsequence_checker(str1, str2, m - 1, n - 1);
return subsequence_checker(str1, str2, m, n - 1);
}
bool isPowerOfTwo(long long int x) { return x && (!(x & (x - 1))); }
struct test {
public:
long long int x, y, z;
};
bool compare(const test &aa, const test &bb) {
if (aa.x == bb.x) {
if (aa.y == bb.y) {
return aa.z < bb.z;
}
return aa.y < bb.y;
}
return aa.x < bb.x;
}
long long int inv(long long int a) {
long long int b = 998244353 - 2, ans = 1;
for (; b > 0; a = a * a % 998244353, b >>= 1)
if (b & 1) ans = ans * a % 998244353;
return ans;
}
long long int a_pow_b(long long int a, long long int b) {
long long int ans = 1;
for (; b > 0; a = a * a % 998244353, b >>= 1)
if (b & 1) ans = ans * a % 998244353;
return ans;
}
long long int ncr(long long int n, long long int m) {
if (m > n) return 0;
long long int up = 1, down = 1;
for (int i = n - m + 1; i < n + 1; i++) up *= i, up %= 998244353;
for (int i = 1; i < m + 1; i++) down *= i, down %= 998244353;
return up * inv(down) % 998244353;
}
void AcDegaYe() {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
long long int b[n];
for (long long int i = 0; i < n; i++) cin >> b[i];
vector<long long int> neg, pos;
for (long long int i = 0; i < n; i++) {
long long int val = a[i] - b[i];
if (val > 0) {
pos.push_back(val);
} else {
neg.push_back(abs(val));
}
}
long long int c = pos.size();
long long int ans = c * (c - 1);
ans /= 2;
sort(neg.begin(), neg.end());
sort(pos.begin(), pos.end());
for (long long int i = 0; i < c; i++) {
long long int val =
(lower_bound(neg.begin(), neg.end(), pos[i]) - neg.begin());
ans = ans + val;
}
cout << ans << endl;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
while (t--) {
AcDegaYe();
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
string s;
int n,sum=0,maxn=0;
int main(){
cin>>n>>s;
for(int i=0;i<n;i++){
if(s[i]=='D') sum--;
else sum++;
maxn=max(maxn,sum);
}
cout<<maxn<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
vector<pair<long long, string>> answer;
cin >> n >> m >> k;
long long r = 4 * n * m - 2 * (n + m);
if (k > r) {
cout << "NO";
return 0;
}
long long x = 1, y = 1;
while (k > 0 && x <= n) {
if (x % 2) {
answer.push_back({min(k, m - 1), "R"});
y = m;
k -= min(k, m - 1);
} else {
answer.push_back({min(k, m - 1), "L"});
y = 1;
k -= min(k, m - 1);
}
if (x == n) break;
if (k > 0) {
answer.push_back({1, "D"});
x++;
k--;
}
}
while (k > 0 && x > 1) {
if (x % 2) {
while (k >= 3 && y > 1) {
if (answer[answer.size() - 1].second == "UDL")
answer[answer.size() - 1].first++;
else
answer.push_back({1, "UDL"});
k -= 3;
y--;
}
if (y > 1) {
if (k == 1) answer.push_back({1, "U"});
if (k == 2) answer.push_back({1, "UD"});
k = 0;
}
if (!k) break;
answer.push_back({1, "U"});
x--;
k--;
} else {
while (k >= 3 && y < m) {
if (answer[answer.size() - 1].second == "UDR")
answer[answer.size() - 1].first++;
else
answer.push_back({1, "UDR"});
k -= 3;
y++;
}
if (y < m) {
if (k == 1) answer.push_back({1, "U"});
if (k == 2) answer.push_back({1, "UD"});
k = 0;
}
if (!k) break;
answer.push_back({1, "U"});
x--;
k--;
}
}
if (k > 0) answer.push_back({k, "L"});
vector<pair<long long, string>> newanswer;
for (int i = 0; i < answer.size(); i++)
if (answer[i].first > 0) newanswer.push_back(answer[i]);
cout << "YES" << '\n';
cout << newanswer.size() << '\n';
for (int i = 0; i < newanswer.size(); i++)
cout << newanswer[i].first << " " << newanswer[i].second << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char a[5][5];
int curlen;
int ans, factor;
bool pr[100000];
bool isPrime(int n) {
if (n == 2) return 1;
if (n % 2 == 0) return 0;
for (int i = 3; i * i <= n; i += 2)
if (n % i == 0) return 0;
return 1;
}
string get(int n) {
string ans = "";
while (n) {
ans += (char)(n % 10 + '0');
n /= 10;
}
reverse(ans.begin(), ans.end());
return ans;
}
void rec(int row, int col) {
if (row == curlen) {
ans += factor;
} else if (col == curlen) {
int number = 0;
for (int i = 0; i < row; i++) number = number * 10 + a[row][i] - '0';
number *= 10;
int fc = 1;
for (int i = row + 1; i < curlen; i++) {
number = number * 10 + a[row][i] - '0';
fc *= 10;
}
int add = 0;
for (int dig = 0; dig < 10; dig++) {
if (pr[number + dig * fc]) add++;
}
if (add) {
factor *= add;
rec(row + 1, row + 2);
factor /= add;
}
} else {
for (char i = '0'; i <= '9'; i++) {
a[row][col] = a[col][row] = i;
rec(row, col + 1);
}
}
}
int main() {
for (int i = 2; i < 99999; i++)
if (isPrime(i)) {
pr[i] = true;
}
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
string cur = get(n);
curlen = cur.size();
for (int i = 0; i < cur.size(); i++) {
a[0][i] = cur[i];
a[i][0] = cur[i];
}
ans = 0;
factor = 1;
rec(1, 2);
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace Tzh {
const int maxn = 1010;
const long double eps = 1e-8;
long long n;
long double m, a[maxn], b[maxn], ans = -1;
bool pan(long double x) {
long double now = m + x, w = x;
for (int i = 1; i <= n; i++) {
long double tmp = now / a[i];
now -= tmp, w -= tmp;
if (w < 0) return 0;
tmp = now / b[i + 1];
now -= tmp, w -= tmp;
if (w < 0) return 0;
}
return 1;
}
void work() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
b[n + 1] = b[1];
long double lt = 0, rt = 1e9 + 10;
while (lt <= rt) {
long double mid = (lt + rt) / 2.0;
if (pan(mid))
rt = mid - eps, ans = mid;
else
lt = mid + eps;
}
if (ans < 0)
cout << -1;
else
printf("%.10Lf", ans);
return;
}
} // namespace Tzh
int main() {
ios::sync_with_stdio(false);
Tzh::work();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int ppow(long long int base,long long int exp)
{ long long int result=1;
while (exp != 0) {
result *= base;
--exp;
}
return result;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int t,a,b,c,x,y,g,modx,mody;
cin>>t;
while(t--)
{
cin>>a>>b>>c;
g=1;
for(int i=2;i<=c;i++)
g*=10;
x=ppow(10,a-1)/g;
modx=ppow(10,a-1)%g;
if(modx!=0)
x++;
y=ppow(10,b-1)/g;
mody=ppow(10,b-1)%g;
if(mody!=0)
y++;
if(x>=y)
{
if(x%2==0)
x++;
if(y%2==1)
y++;
}
else
{
if(y%2==0)
y++;
if(x%2==1)
x++;
}
cout<<g*x<<' '<<g*y<<endl;
}
//cout<<pow(10,0);
return 0;
} | 2 |
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <ctime>
#define Rep(i, n) for (int i = 1; i <= n; i ++)
#define Rep0(i, n) for (int i = 0; i <= n; i ++)
#define RepG(i, x) for (int i = head[x]; i; i = edge[i].next)
#define v edge[i].to
#define mp(a, b) make_pair(a, b)
using namespace std;
const int N = 100010;
struct Edge{ int to, next;} edge[N * 2];
int head[N], num;
void add_edge(int a, int b) { edge[++ num] = (Edge){b, head[a]}, head[a] = num;}
int s[N], ans;
void dfs(int x, int f)
{
int tmp = 0;
RepG(i, x) if (v != f){
dfs(v, x);
int ts = (s[v] & s[x]), t0 = 20;
if (ts) {
while (!(ts & (1 << t0))) t0 --;
tmp = max(tmp, t0 + 1);
}
s[x] |= s[v];
}
if (tmp) Rep0(i, tmp - 1) if (s[x] & (1 << i)) s[x] ^= (1 << i);
for (int i = tmp; i <= 20; i ++){
if (!(s[x] & (1 << i))){
s[x] |= (1 << i), ans = max(ans, i);
break;
}
else s[x] ^= (1 << i);
}
}
int main()
{
int n;
scanf("%d", &n);
Rep(i, n - 1) {
int a, b;
scanf("%d%d", &a, &b);
add_edge(a, b); add_edge(b, a);
}
dfs(1, 0);
printf("%d\n", ans);
return 0;
}
| 0 |
#include<iostream>
using namespace std;
#define N 1000000
int main() {
int n;
cin>>n;
int a[N];
for(int i = 0; i < n; i++) cin>>a[i];
int i, j = 0;
for(i = 0; i < n-1; i++) {
if(a[i] <= a[n-1]) {
if(i != j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
j++;
}
}
for(int k = 0; k < j; k++) cout<<a[k]<<' ';
cout<<'['<<a[n-1]<<']'<<' ';
int k;
for(k = j+1; k < i; k++) cout<<a[k]<<' ';
cout<<a[j]<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int findd(string s1, string s2) {
long long h1 = 0, h2 = 0, x = 1;
int i, n = (int)s1.size(), m = (int)s2.size();
if (n < m) return -1;
for (i = 0; i < m; i++) h2 = h2 * 33 + s2[i] - 'a' + 1;
for (i = 0; i < n; i++) {
if (i < m) {
h1 = h1 * 33 + s1[i] - 'a' + 1;
x = x * 33;
if (i == m - 1)
if (h1 == h2) return 1;
} else {
h1 = h1 * 33 - (s1[i - m] - 'a' + 1) * x + s1[i] - 'a' + 1;
if (h1 == h2) return 1;
}
}
return -1;
}
string join(string s1, string s2) {
string st;
long long x, h1, h2;
int j, maxj = 0;
if (findd(s1, s2) != -1)
st = s1;
else {
h1 = h2 = 0;
x = 1;
for (j = 0; j < min(s1.size(), s2.size());) {
h1 = h1 * 33 + s2[j] - 'a' + 1;
h2 = h2 + (s1[s1.size() - 1 - j] - 'a' + 1) * x;
x = x * 33;
if (h1 == h2) {
j++;
maxj = max(j, maxj);
} else {
j++;
}
}
if (maxj == 0)
st = s1 + s2;
else {
st = s1;
for (j = maxj; j < s2.size(); j++) st += s2[j];
}
}
return st;
}
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int m;
string S[3], s1, s2, s3;
cin >> S[0] >> S[1] >> S[2];
m = (int)S[0].size() + (int)S[1].size() + (int)S[2].size();
vector<int> V = {0, 1, 2};
do {
s1 = S[V[0]];
s2 = S[V[1]];
s3 = S[V[2]];
s1 = join(s1, s2);
s1 = join(s1, s3);
m = min(m, (int)s1.size());
} while (next_permutation(V.begin(), V.end()));
cout << m;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
int ans[maxN], a[maxN];
vector<pair<int, int> > vc, que[maxN];
int fen[maxN];
void add(int p) {
for (p++; p < maxN; p += p & -p) fen[p]++;
return;
}
int get(int p) {
int res = 0;
for (; p > 0; p -= p & -p) res += fen[p];
return res;
}
int n;
int get_index(int t) {
int lo = 0, hi = n;
while (hi - lo > 1) {
int mid = (lo + hi) / 2;
if (get(mid) >= t)
hi = mid;
else
lo = mid;
}
return lo;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
vc.push_back({a[i], -i});
}
sort(vc.begin(), vc.end());
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int k, p;
cin >> k >> p;
que[k].push_back({p, i});
}
for (int i = 1; i <= n; i++) {
add(-vc[n - i].second);
for (auto X : que[i]) {
int p = get_index(X.first);
ans[X.second] = a[p];
}
}
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
vector<long long int> v;
long long int n, i, m;
cin >> n;
m = n;
for (i = 2; i <= sqrt(n); i++) {
if (n % i == 0) v.push_back(i);
while (n % i == 0) n = n / i;
}
if (n != 1) v.push_back(n);
if (m == 1)
cout << 1 << endl;
else if (m == 2)
cout << 2 << endl;
else if (m == 3)
cout << 3 << endl;
else if (v.size() > 1)
cout << 1 << endl;
else
cout << v[0] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
vector<int> adj[N], l[N];
int dist[N], n, m, k, ans[N], a[N], b[N], aa[N];
vector<vector<int> > vv;
void print(int lvl) {
if (lvl == 1) {
for (int i = 1; i <= m; i++) {
cout << ans[i];
}
cout << "\n";
--k;
if (!k) exit(0);
return;
}
for (int x : l[aa[lvl]]) {
ans[x] = 1;
print(lvl - 1);
ans[x] = 0;
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
a[i] = u;
b[i] = v;
}
dist[1] = 1;
queue<int> q;
q.push(1);
while (q.size()) {
int u = q.front();
q.pop();
for (int v : adj[u])
if (!dist[v]) {
dist[v] = dist[u] + 1;
q.push(v);
}
}
long long ans = 1;
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int j : adj[i]) {
if (dist[j] + 1 == dist[i]) ++cnt;
}
if (cnt) ans *= cnt;
ans = min(ans, 1LL * k);
aa[i] = i;
}
for (int i = 1; i <= m; i++) {
if (dist[a[i]] > dist[b[i]]) swap(a[i], b[i]);
if (dist[a[i]] + 1 == dist[b[i]]) {
l[b[i]].push_back(i);
}
}
cout << ans << endl;
k = min(1LL * k, ans);
print(n);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
long long mod = 1e9 + 7;
void solve() {
int n;
string s;
cin >> n >> s;
string t = s;
sort(t.begin(), t.end());
int ans = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] != t[i]) ans++;
}
printf("%d\n", ans);
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1e5 + 5;
const int inf = 1e9;
void solve() {
int n;
cin >> n;
string a, b;
cin >> a >> b;
int cnt1[26] = {};
int cnt2[26] = {};
for (int i = 0; i < n; i++) {
cnt1[a[i] - 'a']++;
cnt2[b[i] - 'a']++;
}
bool f = false;
for (int i = 0; i < 26; i++) {
if (cnt1[i] != cnt2[i]) {
cout << "NO" << endl;
return;
}
if (cnt1[i] >= 2) f = true;
}
if (f) {
cout << "YES" << endl;
return;
}
int mp[26];
for (int i = 0; i < n; i++) {
mp[a[i] - 'a'] = i;
}
int ar[n];
for (int i = 0; i < n; i++) {
ar[i] = mp[b[i] - 'a'];
}
int inv = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (ar[j] > ar[i]) inv++;
}
}
if (inv % 2 == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int main() {
int t = 1;
cin >> t;
while (t--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int N = 105;
int dp[N][2];
int inline add(int x, int y) {
int temp = x + y;
while (temp >= MOD) temp = temp - MOD;
return temp;
}
int inline add(int x, int y, int z) {
int temp = x + add(y, z);
while (temp >= MOD) temp = temp - MOD;
return temp;
}
void func(int d, int k) {
dp[0][0] = 1;
dp[0][1] = 0;
int i, j, l;
for (i = 1; i < d; i++) dp[i][1] = 0;
for (i = 1; i < N; i++) {
for (j = 1; j <= k && j <= i; j++) {
if (j < d) dp[i][0] = add(dp[i][0], dp[i - j][0]);
}
for (j = 1; j <= k && j <= i; j++) {
if (j >= d)
dp[i][1] = add(dp[i][1], dp[i - j][1], dp[i - j][0]);
else
dp[i][1] = add(dp[i][1], dp[i - j][1]);
}
}
return;
}
int main() {
int n, k, d;
cin >> n >> k >> d;
func(d, k);
cout << dp[n][1] << endl;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int n,m,sum,a[100];
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
cin>>a[i];
}
sort(a+1,a+1+n);
for(int i=n;i>=n-m+1;i--){
sum+=a[i];
}
cout<<sum;
return 0;
} | 0 |
#include <bits/stdc++.h>
const int MAX_N = 1e5;
int n, q;
long long a[MAX_N + 3], b[MAX_N + 3];
long long pref[MAX_N + 3];
long long t[MAX_N + 3];
long long prefpref[MAX_N + 3];
struct Node {
long long sum, max, lazy;
Node() {
sum = 0;
max = -LLONG_MAX;
lazy = -LLONG_MAX;
}
};
const int base = 1 << 19;
struct SegmentTree {
Node t[2 * base + 5];
SegmentTree() { 1 + 1; }
void pushDown(int v, int low, int high) {
long long x = t[v].lazy;
t[v].max = x;
long long range = (high - low + 1);
t[v].sum = range * x;
if (low != high) {
t[v * 2].lazy = x;
t[v * 2 + 1].lazy = x;
}
t[v].lazy = -LLONG_MAX;
}
int find(long long x, int v, int low, int high) {
if (t[v].lazy != -LLONG_MAX) pushDown(v, low, high);
if (low != high) {
if (t[v * 2].lazy != -LLONG_MAX) pushDown(v * 2, low, (low + high) / 2);
if (t[v * 2 + 1].lazy != -LLONG_MAX)
pushDown(v * 2 + 1, (low + high) / 2 + 1, high);
}
if (low == high) return low;
if (t[v * 2].max >= x)
return find(x, v * 2, low, (low + high) / 2);
else
return find(x, v * 2 + 1, (low + high) / 2 + 1, high);
}
void update(int low, int high, int L, int R, int v, long long x) {
if (low > high || L > R) return;
if (t[v].lazy != -LLONG_MAX) pushDown(v, low, high);
if (low > R || high < L) return;
if (low >= L && high <= R) {
t[v].lazy = x;
pushDown(v, low, high);
return;
}
int mid = (low + high) / 2;
update(low, mid, L, R, v * 2, x);
update(mid + 1, high, L, R, v * 2 + 1, x);
t[v].sum = (t[v * 2].sum + t[v * 2 + 1].sum);
t[v].max = std::max(t[v * 2].max, t[v * 2 + 1].max);
}
long long query(int low, int high, int L, int R, int v) {
if (low > high || L > R) return 0;
if (t[v].lazy != -LLONG_MAX) pushDown(v, low, high);
if (low > R || high < L) return 0;
if (low >= L && high <= R) return t[v].sum;
int mid = (low + high) / 2;
return query(low, mid, L, R, v * 2) + query(mid + 1, high, L, R, v * 2 + 1);
}
};
void input() {
std::cin >> n;
for (int i = 1; i <= n; i++) std::cin >> a[i];
for (int i = 1; i <= n - 1; i++) std::cin >> b[i];
pref[1] = 0;
for (int i = 2; i <= n; i++) pref[i] = (pref[i - 1] + b[i - 1]);
for (int i = 1; i <= n; i++) t[i] = a[i] - pref[i];
prefpref[0] = 0;
for (int i = 1; i <= n; i++) prefpref[i] = prefpref[i - 1] + pref[i];
}
SegmentTree tree;
int main() {
std::ios_base::sync_with_stdio(0);
std::cin.tie(NULL);
input();
for (int i = 1; i <= n; i++) tree.update(1, n, i, i, 1, t[i]);
std::cin >> q;
char c;
long long x, y;
while (q--) {
std::cin >> c >> x >> y;
if (c == '+') {
long long value = tree.query(1, n, x, x, 1);
if (tree.t[1].max < value + y)
tree.update(1, n, x, n, 1, value + y);
else {
int last = tree.find(value + y, 1, 1, n);
tree.update(1, n, x, last - 1, 1, value + y);
}
} else {
long long sum1 = tree.query(1, n, x, y, 1);
sum1 += (prefpref[y] - prefpref[x - 1]);
std::cout << sum1 << "\n";
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 233;
const int T = 314000000;
vector<int> a[maxn], b[maxn], t[maxn];
bool cbe[maxn];
int vis[maxn];
int ru[maxn], num[maxn], val[maxn];
priority_queue<pair<long long, int> > q;
long long f[maxn], d[maxn], INF;
long long work(int x) {
long long sum = val[x];
for (int i = 0; i < a[x].size(); i++) {
int y = a[x][i];
sum += f[y];
}
return sum;
}
long long dfs(int x) {
if (vis[x] == 1) return d[x];
if (vis[x] == -1) return d[x] = -2;
vis[x] = -1;
for (int i = 0; i < t[x].size(); i++) {
int y = t[x][i];
if (!cbe[y]) continue;
long long sum = val[y];
for (int j = 0; j < a[y].size(); j++) {
long long k = dfs(a[y][j]);
if (k == -2) {
vis[x] = 1;
return d[x] = -2;
}
sum += k;
if (sum > T) sum = T;
}
d[x] = max(d[x], sum);
}
vis[x] = 1;
return d[x];
}
int main() {
INF = 1;
INF <<= 60;
int m, n;
cin >> m >> n;
for (int i = 1; i <= n; i++) f[i] = 1, f[i] <<= 60;
memset(d, 0, sizeof(d));
for (int i = 1; i <= m; i++) {
int x, len, cnt = 0;
scanf("%d%d", &num[i], &len);
t[num[i]].push_back(i);
for (int j = 1; j <= len; j++) {
int y;
scanf("%d", &y);
if (y == -1)
cnt++;
else {
a[i].push_back(y);
b[y].push_back(i);
ru[i]++;
}
}
if (!ru[i]) {
q.push(make_pair(-cnt, i));
if (cnt < f[num[i]]) f[num[i]] = cnt;
if (cnt > d[num[i]]) d[num[i]] = cnt;
}
val[i] = cnt;
}
memset(cbe, 0, sizeof(cbe));
memset(vis, 0, sizeof(vis));
while (!q.empty()) {
int x = q.top().second;
q.pop();
x = num[x];
if (vis[x]) continue;
vis[x] = 1;
for (int i = 0; i < b[x].size(); i++) {
int y = b[x][i];
ru[y]--;
if (!ru[y]) {
cbe[y] = 1;
long long buf = work(y);
if (buf > T) buf = T;
if (buf < f[num[y]]) {
f[num[y]] = buf;
q.push(make_pair(-buf, y));
}
}
}
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
for (int i = 1; i <= n; i++) {
long long x = f[i], y = d[i];
if (x == INF) x = -1, y = -1;
printf("%I64d %I64d\n", x, y);
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s[100001] ={};
int cnt =0,cnt2 = 1;
int k;
string a;
cin >> a>>k;
while(cnt2 <6)
{
for(int j=0;j<a.size();j++)
{
s[cnt] = a.substr(j,cnt2);
cnt++;
}
cnt2++;
}
sort(s,s+100000);
unique(s,s+100000);
cout << s[k] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 7;
long long n, m, k, x, ans, cnt, a[N];
int f(long long x) { return (((x + 1) / 2) % 2) ^ (x % 2 ? 0 : x); }
int main() {
ios_base ::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x >> k;
ans ^= f(x - 1) ^ f(x + k - 1);
}
cout << (ans ? "tolik" : "bolik");
}
| 3 |
#include <iostream>
using namespace std;
int e[2][4];
int main()
{
double E[2];
while (cin >> E[0] >> E[1]){
for (int i = 0; i < 2; i++){
if (E[i] >= 1.1) e[i][0]++;
else if (E[i] >= 0.6) e[i][1]++;
else if (E[i] >= 0.2) e[i][2]++;
else e[i][3]++;
}
}
for (int i = 0; i < 4; i++){
cout << e[0][i] << ' ' << e[1][i] << endl;
}
return (0);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.