solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long linf = 1LL << 62;
const int MAX = 510000;
long long dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
long long dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const double pi = acos(-1);
const double eps = 1e-7;
template <typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
template <typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <typename T>
inline void print(T &a) {
for (int i = 0; i < (a.size()); i++) cout << a[i] << " ";
cout << "\n";
}
template <typename T1, typename T2>
inline void print2(T1 a, T2 b) {
cout << a << " " << b << "\n";
}
template <typename T1, typename T2, typename T3>
inline void print3(T1 a, T2 b, T3 c) {
cout << a << " " << b << " " << c << "\n";
}
long long pcount(long long x) { return __builtin_popcountll(x); }
const int mod = 1e9 + 7;
void solve() {
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < (n); i++) cin >> a[i];
bool f = false;
for (int i = 0; i < (n - 1); i++) {
if (a[i] < a[i + 1]) {
if (f) {
puts("NO");
return;
}
} else {
f = true;
}
}
puts("YES");
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int t = 1;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 105;
int num[Maxn];
int n;
inline void swap(int &x, int &y) {
int c = x;
x = y;
y = c;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j < n - i + 1; j++)
if (num[j] > num[j + 1]) {
swap(num[j], num[j + 1]);
printf("%d %d\n", j, j + 1);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const long long mod = 998244353;
long long binpow(long long a, long long n) {
if (n == 0) return 1;
if (n % 2 != 0)
return binpow(a, n - 1) * a;
else {
long long b = binpow(a, n / 2);
return b * b;
}
}
long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
bool check(vector<int> a, vector<int> b) {
for (int i = 0; i < 26; i++)
if (b[i] > a[i]) return false;
return true;
}
void solve() {
int n, m, k;
cin >> n >> m >> k;
if (m < n || k < n)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
long long dp[11][66][1 << 12], a[66];
long long b, le, ri;
long long dfs(int pos, int now, int lead, int limit) {
if (pos == -1 && now == 0) return 1;
if (pos == -1) return 0;
if (!lead && !limit && dp[b][pos][now] != -1) return dp[b][pos][now];
int up = limit ? a[pos] : b - 1;
long long ans = 0;
for (int i = 0; i <= up; i++) {
if (lead && i == 0)
ans += dfs(pos - 1, now, lead && i == 0, limit && i == a[pos]);
else
ans += dfs(pos - 1, now ^ (1 << i), lead && i == 0, limit && i == a[pos]);
}
if (!lead && !limit) dp[b][pos][now] = ans;
return ans;
}
long long solve(long long x) {
int pos = 0;
while (x) {
a[pos++] = x % b;
x /= b;
}
long long ans = 0;
ans = dfs(pos - 1, 0, true, true);
return ans;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
memset(dp, -1, sizeof dp);
while (t--) {
cin >> b >> le >> ri;
cout << solve(ri) - solve(le - 1) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class... S>
void dbs(string str, T t, S... s) {
int idx = str.find(',');
cout << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream& operator<<(ostream& os, const map<S, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
using namespace std;
void manage(vector<pair<int, int> >& ranges) {
if (ranges.empty()) {
return;
}
vector<pair<int, int> > ret;
sort(ranges.begin(), ranges.end());
int curL = ranges[0].first, curR = ranges[0].second;
for (int i = 1; i < ranges.size(); i++) {
pair<int, int> now = ranges[i];
if (curR >= now.first) {
curR = max(now.second, curR);
} else {
ret.push_back({curL, curR});
curL = ranges[i].first, curR = ranges[i].second;
}
}
ret.push_back({curL, curR});
ranges = ret;
}
vector<vector<pair<int, int> > > intV, intH;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N, M, K;
cin >> N >> M >> K;
set<int> huhx, huhy;
vector<pair<int, pair<int, int> > > cutV, cutH;
for (int i = 0; i < K; i++) {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
if (x1 < x2) cutV.push_back({y1, {x1, x2}}), huhy.insert(y1);
if (y1 < y2) cutH.push_back({x1, {y1, y2}}), huhx.insert(x1);
}
map<int, int> compx, compy, icx, icy;
int cnt = 0;
for (int i : huhx) {
compx[i] = cnt;
icx[cnt] = i;
cnt++;
}
intH.resize(cnt);
cnt = 0;
for (int i : huhy) {
compy[i] = cnt;
icy[cnt] = i;
cnt++;
}
intV.resize(cnt);
for (auto u : cutV) {
intV[compy[u.first]].push_back(u.second);
}
for (auto u : cutH) {
intH[compx[u.first]].push_back(u.second);
}
for (auto& u : intV) {
manage(u);
}
for (auto& u : intH) {
manage(u);
}
int gr = 0;
if ((N - huhx.size()) % 2 == 0) {
gr ^= M;
}
if ((M - huhy.size()) % 2 == 0) {
gr ^= N;
}
vector<int> fucx, fucy;
for (int i = 0; i < intH.size(); i++) {
int xc = icx[i];
int lc = 0;
int xx = 0;
for (auto u : intH[i]) {
if (lc < u.first) {
xx += u.first - lc;
}
lc = u.second;
}
if (lc < M) {
xx += M - lc;
}
fucx.push_back(xx);
gr ^= xx;
}
for (int i = 0; i < intV.size(); i++) {
int yc = icy[i];
int lc = 0;
int xx = 0;
for (auto u : intV[i]) {
if (lc < u.first) {
xx += u.first - lc;
}
lc = u.second;
}
if (lc < N) {
xx += N - lc;
}
fucy.push_back(xx);
gr ^= xx;
}
int vx = -1;
for (int i = 1; i < N; i++) {
if (huhx.find(i) == huhx.end()) {
vx = i;
break;
}
}
int vy = -1;
for (int i = 1; i < M; i++) {
if (huhy.find(i) == huhy.end()) {
vy = i;
break;
}
}
vector<pair<int, pair<int, int> > > horz, verts;
if (vx != -1) {
horz.push_back({vx, {0, M}});
}
if (vy != -1) {
verts.push_back({vy, {0, N}});
}
if (gr == 0) {
cout << "SECOND";
} else {
cout << "FIRST\n";
if (verts.size() && (N ^ gr) < N) {
cout << 0 << ' ' << vy << ' ' << N - (N ^ gr) << ' ' << vy << endl;
return 0;
}
if (horz.size() && (M ^ gr) < M) {
cout << vx << ' ' << 0 << ' ' << vx << ' ' << M - (M ^ gr) << endl;
return 0;
}
for (int i = 0; i < huhx.size(); i++) {
if ((fucx[i] ^ gr) > fucx[i]) {
continue;
}
int xx = icx[i];
int req = fucx[i] - (fucx[i] ^ gr);
int st = 0, del = 0;
intH[i].push_back({M, M});
for (int j = 0; j < intH[i].size(); j++) {
if (st - del >= req) {
st = del + req;
break;
}
st = intH[i][j].first;
if (j) {
del += intH[i][j - 1].second - intH[i][j - 1].first;
}
}
if (st - del >= req) {
st = del + req;
}
cout << xx << ' ' << 0 << ' ' << xx << ' ' << st << endl;
return 0;
;
}
for (int i = 0; i < huhy.size(); i++) {
if ((fucy[i] ^ gr) > fucy[i]) {
continue;
}
int xx = icy[i];
int req = fucy[i] - (fucy[i] ^ gr);
int st = 0, del = 0;
intV[i].push_back({N, N});
for (int j = 0; j < intV[i].size(); j++) {
if (st - del >= req) {
st = del + req;
break;
}
st = intV[i][j].first;
if (j) {
del += intV[i][j - 1].second - intV[i][j - 1].first;
}
}
if (st - del >= req) {
st = del + req;
}
cout << 0 << ' ' << xx << ' ' << st << ' ' << xx << endl;
return 0;
;
}
}
return 0;
}
| 8 |
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cctype>
using namespace std;
template <typename T>
inline void read(T&x){
x=0; char temp=getchar(); bool f=false;
while(!isdigit(temp)){if(temp=='-') f=true; temp=getchar();}
while(isdigit(temp)){x=(x<<1)+(x<<3)+temp-'0'; temp=getchar();}
if(f) x=-x;
}
template <typename T>
void print(T x){
if(x<0) putchar('-'),x=-x;
if(x>9) print(x/10);
putchar(x%10+'0');
}
const int MAXN = 2e7+5;
//basic
int c,d,x;
//Solve
int prime[MAXN],val[MAXN]; int cnt;
bool judge[MAXN];
inline void Sieve(){
for(register int i=2;i<=20000000ll;i++){
if(!judge[i]) prime[++cnt]=i,val[i]=1;
for(register int j=1;j<=cnt&&prime[j]*i<=20000000ll;j++){
judge[prime[j]*i]=true;
if(i%prime[j]==0){val[i*prime[j]]=val[i]; break;}
val[i*prime[j]]=val[i]+1;
}
}
}
inline int Calc(int share){
if((x/share+d)%c!=0) return 0;
int lim=(x/share+d)/c;
return 1<<val[lim];
}
inline int Solve(){
int res=0;
for(register int share=1;share*share<=x;share++)
if(x%share==0){
res+=Calc(share);
if(x/share!=share) res+=Calc(x/share);
}
return res;
}
int main(){
int T; read(T);
Sieve();
while(T--){
read(c),read(d),read(x);
print(Solve()),puts("");
}
// system("pause");
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
int fn();
int isLock(int i);
int n, arr[1000009];
char input[1000009];
int main() {
scanf("%s", input);
n = strlen(input);
memset(arr, 0, sizeof(arr));
for (int i = 0; i < n; i++)
if (input[i] == '1') arr[i] = 1;
printf("%d\n", fn());
return 0;
}
int fn() {
int ret = 0;
int lock = 0;
int firstTaken = 999999999;
int firstLock = 999999999;
for (int i = 0; i < n; i++) {
if (lock == 0) {
lock = isLock(i);
if (lock) firstLock = min(firstLock, i);
} else {
ret++;
lock = 0;
firstTaken = min(firstTaken, i);
}
}
if (firstTaken > 0 && firstLock > 0 && lock) ret++;
if (ret == 0) ret++;
return ret;
}
int isLock(int i) {
int curr = arr[i];
int before = 0;
if (i - 1 >= 0)
before = arr[i - 1];
else
before = arr[n - 1];
return curr != before;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
int f[N], n, T, a[N], bit[512], g[N];
void update(int i, int x) {
for (; i < 512; i += i & -i) bit[i] = max(bit[i], x);
}
int get(int i) {
int res = 0;
for (; i > 0; i -= i & -i) res = max(res, bit[i]);
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
srand(time(0));
cin >> n >> T;
for (int i = 0; i < int(n); i++) cin >> a[i];
for (int i = 0; i < int(n * 10000); i++) a[i] = a[i % n];
if (T < 10000) {
int fmax = 0;
for (int i = 0; i < int(n * T); i++) {
f[i] = get(a[i]) + 1;
update(a[i], f[i]);
if (f[i] > f[fmax]) fmax = i;
}
cout << f[fmax] << endl;
return 0;
}
int m = 200;
int ans = 0;
for (int v = 0; v < int(n); v++) {
memset(bit, 0, sizeof(bit));
int fmax = 0, gmax = n * m - 1;
f[fmax] = g[gmax] = 0;
for (int i = 0; i < int(n * m); i++) {
if (a[i] <= a[v]) {
f[i] = get(a[i]) + 1;
update(a[i], f[i]);
if (f[i] > f[fmax]) fmax = i;
}
}
memset(bit, 0, sizeof(bit));
for (int i = (n * m - 1); i >= (0); i--) {
if (a[i] >= a[v]) {
g[i] = get(400 - a[i]) + 1;
update(400 - a[i], g[i]);
if (g[i] > g[gmax]) gmax = i;
}
}
int cnt = 0;
for (int i = 0; i < int(n); i++)
if (a[i] == a[v]) cnt++;
ans = max(ans, f[fmax] + g[gmax] + cnt * (T - 2 * m));
}
cout << ans << endl;
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
#define MAXN 100005
#define lowbit(x) (x&-x)
#define reg register
typedef long long LL;
typedef unsigned long long uLL;
typedef unsigned int uint;
typedef pair<int,int> pii;
const LL INF=0x7f7f7f7f7f7f;
const int mo=998244353;
const double PI=acos(-1.0);
template<typename _T>
_T Fabs(_T x){return x<0?-x:x;}
template<typename _T>
void read(_T &x){
_T f=1;x=0;char s=getchar();
while(s>'9'||s<'0'){if(s=='-')f=-1;s=getchar();}
while('0'<=s&&s<='9'){x=(x<<3)+(x<<1)+(s^48);s=getchar();}
x*=f;
}
int n,head[MAXN],tot,k,pow2[MAXN],dp[305][605],tmp[605],sumx[605],sumy[605],ans;
struct edge{int to,nxt;}e[MAXN];
void addEdge(int u,int v){e[++tot]=(edge){v,head[u]};head[u]=tot;}
int add(int x,int y){return x+y<mo?x+y:x+y-mo;}
int qkpow(int a,int s){int t=1;while(s){if(s&1)t=1ll*a*t%mo;a=1ll*a*a%mo;s>>=1;}return t;}
void merge(int x,int y){
sumx[0]=dp[x][0];for(int i=1;i<=2*k;i++)sumx[i]=add(sumx[i-1],dp[x][i]);
sumy[0]=dp[y][0];for(int i=1;i<=2*k;i++)sumy[i]=add(sumy[i-1],dp[y][i]);
for(int i=0;i<k;i++){
tmp[i]=add(tmp[i],1ll*dp[x][i]*sumy[2*k-i-1]%mo);
tmp[i]=add(tmp[i],1ll*dp[y][i]*sumx[2*k-i-1]%mo);
if(i)tmp[i]=add(tmp[i],mo-1ll*dp[x][i]*sumy[i-1]%mo);
if(i)tmp[i]=add(tmp[i],mo-1ll*dp[y][i]*sumx[i-1]%mo);
tmp[i]=add(tmp[i],mo-1ll*dp[x][i]*dp[y][i]%mo);
}
for(int i=k;i<=2*k;i++){
tmp[i]=add(tmp[i],1ll*dp[x][i]*sumy[i]%mo);
tmp[i]=add(tmp[i],1ll*dp[y][i]*sumx[i]%mo);
if(i<2*k)tmp[i]=add(tmp[i],mo-1ll*dp[x][i]*sumy[2*k-i-1]%mo);
if(i<2*k)tmp[i]=add(tmp[i],mo-1ll*dp[y][i]*sumx[2*k-i-1]%mo);
tmp[i]=add(tmp[i],mo-1ll*dp[x][i]*dp[y][i]%mo);
}
for(int i=0;i<=2*k;i++)dp[x][i]=tmp[i],tmp[i]=sumx[i]=sumy[i]=0;
}
void dosaka(int u,int fa){
dp[u][k]=1;
for(int i=head[u];i;i=e[i].nxt){
int v=e[i].to;if(v==fa)continue;
dosaka(v,u);merge(u,v);
}
int sum=0;
for(int i=2*k;i;i--)sum=add(sum,dp[u][i]),dp[u][i]=dp[u][i-1];
dp[u][0]=add(dp[u][0],sum);
}
signed main(){
read(n);pow2[0]=1;for(int i=1;i<=n;i++)pow2[i]=add(pow2[i-1],pow2[i-1]);
for(int i=1,u,v;i<n;i++)read(u),read(v),addEdge(u,v),addEdge(v,u);
for(k=1;k<=n;k++){
for(int i=1;i<=n;i++)for(int j=0;j<=2*k;j++)dp[i][j]=0;dosaka(1,0);
int res=pow2[n];for(int i=0;i<=k;i++)res=add(res,mo-dp[1][i]);ans=add(ans,res);
}
ans=1ll*qkpow(pow2[n],mo-2)*add(ans,mo-1)%mo;
printf("%d\n",ans);
return 0;
}
/*
3/4*1+1/4*3
*/
| 12 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
long long int power(long long int x, long long int y) {
long long int ans = 1;
while (y) {
if (y & 1) ans *= x;
x *= x, y = y >> 1;
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
vector<long long int> v1, v2;
cout << (n - 1) / 2 << '\n';
for (long long int i = 0; i < (n - 1) / 2; i++) v1.push_back(a[i]);
for (long long int i = (n - 1) / 2; i < n; i++) v2.push_back(a[i]);
long long int i = 0, j = 0;
while (i < (long long int)v1.size() && j < (long long int)v2.size()) {
cout << v2[j] << ' ' << v1[i] << ' ';
i++, j++;
}
while (j < (long long int)v2.size()) cout << v2[j++] << ' ';
cout << '\n';
}
cerr << "Time elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> cnta(10005, 0);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, mmx = -1;
cin >> n;
vector<int> v(n), s2, s4;
for (int i = 0; i < n; i++) {
cin >> v[i];
cnta[v[i]]++;
if (cnta[v[i]] == 2) s2.push_back(v[i]);
}
for (int i = 0; i < s2.size(); i++) {
if (cnta[s2[i]] >= 4) {
s4.push_back(s2[i]);
break;
}
}
if (s4.size() != 0)
cout << s4[0] << " " << s4[0] << " " << s4[0] << " " << s4[0] << endl;
else {
sort(s2.begin(), s2.end());
int i1, i2;
long double mind = INT_MAX;
for (int i = 0; i < s2.size() - 1; i++) {
long double te = (long double)s2[i + 1] / (long double)s2[i];
if (te < mind) {
mind = te;
i1 = s2[i + 1];
i2 = s2[i];
}
}
cout << i1 << " " << i1 << " " << i2 << " " << i2 << endl;
}
for (int i = 0; i < n; i++) cnta[v[i]] = 0;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, s, x[5010], y[5010], i, j, a, b, c, f, ss;
long long mianji(long long i, long long j, long long k) {
long long x1 = x[k] - x[i], y1 = y[k] - y[i], x2 = x[k] - x[j],
y2 = y[k] - y[j];
return abs(x1 * y2 - x2 * y1);
}
int main() {
while (scanf("%lld %lld", &n, &s) != EOF) {
for (i = 1; i <= n; i++) scanf("%lld %lld", &x[i], &y[i]);
f = 1;
a = 1, b = 2, b = 3;
ss = mianji(a, b, c);
while (f) {
f = 0;
for (i = 1; i <= n; i++) {
if (ss < mianji(i, b, c)) {
ss = mianji(i, b, c);
a = i;
f = 1;
}
if (ss < mianji(a, i, c)) {
ss = mianji(a, i, c);
b = i;
f = 1;
}
if (ss < mianji(a, b, i)) {
ss = mianji(a, b, i);
c = i;
f = 1;
}
}
}
printf("%lld %lld\n", x[a] + x[b] - x[c], y[a] + y[b] - y[c]);
printf("%lld %lld\n", x[a] + x[c] - x[b], y[a] + y[c] - y[b]);
printf("%lld %lld\n", x[c] + x[b] - x[a], y[c] + y[b] - y[a]);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool mem[301][301];
int n;
vector<int> v(3, 0), v2(2);
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> v[i];
}
if (n == 1 || n == 3) {
if (v[0] ^ v[1] ^ v[2]) {
puts("BitLGM");
} else {
puts("BitAryo");
}
return 0;
}
for (int i = 0; i <= v[0]; i++) {
for (int j = 0; j <= v[1]; j++) {
bool &f = mem[i][j];
if (i + j == i || i + j == j) f = (i + j > 0);
int m = min(i, j);
for (int l = 1; l <= m && !f; l++) {
f |= (mem[i - l][j - l] ^ 1);
}
for (int l = 1; l <= i && !f; l++) {
f |= (mem[i - l][j] ^ 1);
}
for (int l = 1; l <= j && !f; l++) {
f |= (mem[i][j - l] ^ 1);
}
}
}
if (mem[v[0]][v[1]]) {
puts("BitLGM");
} else {
puts("BitAryo");
}
}
| 6 |
#include <bits/stdc++.h>
const int N = (int)1e5 + 228;
using namespace std;
int n, a[N], pref1[N], pref2[N];
vector<pair<int, int> > ans;
int calc(int k) {
int t1 = 0, t2 = 0, pos = 1;
while (pos <= n) {
if (pref1[n] - pref1[pos - 1] < k && pref2[n] - pref2[pos - 1] < k)
return -1;
int winner = 0;
int next = n;
if (pref1[n] - pref1[pos - 1] >= k) {
int l = pos - 1, r = n + 1, mid;
while (l < r - 1) {
mid = (l + r) / 2;
if (pref1[mid] - pref1[pos - 1] >= k)
r = mid;
else
l = mid;
}
winner = 1;
next = min(next, r);
}
if (pref2[n] - pref2[pos - 1] >= k) {
int l = pos - 1, r = n + 1, mid;
while (l < r - 1) {
mid = (l + r) / 2;
if (pref2[mid] - pref2[pos - 1] >= k)
r = mid;
else
l = mid;
}
if (r < next) {
next = r;
winner = 2;
}
}
if (winner == 1)
t1++;
else
t2++;
pos = next + 1;
}
if (t1 == t2) return -1;
if (t2 > t1 && a[n] == 1) return -1;
if (t2 < t1 && a[n] == 2) return -1;
return max(t1, t2);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
pref1[i] = pref1[i - 1];
pref2[i] = pref2[i - 1];
if (a[i] == 1)
pref1[i]++;
else
pref2[i]++;
}
for (int i = 1; i <= n; i++) {
int res = calc(i);
if (res != -1) ans.push_back({res, i});
}
sort(ans.begin(), ans.end());
printf("%d\n", (int)ans.size());
for (int i = 0; i < (int)ans.size(); i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int TN = 1;
void solve() {
long long n, k, a, b;
cin >> n >> k >> a >> b;
if (k == 1) {
cout << (n - 1) * a << "\n";
return;
}
long long n_copy = n;
long long ans = 0;
while (n_copy > 0) {
if (n_copy % k != 0) {
ans += a * (n_copy % k);
n_copy -= (n_copy % k);
} else {
ans += min(b, a * (n_copy - n_copy / k));
n_copy /= k;
}
}
cout << ans - a;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
while (TN--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, unsigned long long y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return (power(x, y / 2) * power(x, y / 2)) % 1000000007;
else
return (x * power(x, y / 2) * power(x, y / 2)) % 1000000007;
}
int main() {
string s;
cin >> s;
int l = s.length();
unsigned long long a = 0, ans = 0, c = 0;
for (int i = 0; i < l; i++) {
if (s[i] == 'a')
a++;
else if (s[i] == 'b' && a) {
ans += (power(2, a) - 1) % 1000000007;
ans %= 1000000007;
}
}
cout << ans % 1000000007 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void sprint(string s) {
for (int i = 0; i < s.size(); ++i) printf("%c", s[i]);
printf("\n");
}
int b[10];
int main() {
int n, m;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < m; ++i) {
int x;
cin >> x;
b[x]++;
}
for (int i = 0; i < n; ++i) {
if (b[a[i]] == 1) {
cout << a[i] << " ";
}
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 1;
string s;
cin >> n >> s;
for (int i = 1; i < n; i++)
if (s[i] != s[i - 1]) ans++;
cout << min(n, ans + 2);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first != b.first)
return a.first < b.first;
else
return a.second > b.second;
}
long long ex(long long n, long long ans) {
if (n == 1)
return ans;
else if (n % 2)
return (ans % ((1000000007)) * ex(n / 2, (ans * ans) % (1000000007))) %
(1000000007);
else
return ex(n / 2, (ans * ans) % (1000000007));
}
long long kmp(string x, long long m) {
vector<long long> pi(m, 0);
pi[0] = 0;
long long j = 0;
for (long long i = 1; i < m; i++) {
j = pi[i - 1];
while (j > 0 && x[i] != x[j]) j = pi[j - 1];
if (x[j] == x[i]) j++;
pi[i] = j;
}
return j;
}
string kmp1(string x, long long m) {
vector<long long> pi(m, 0);
pi[0] = 0;
long long ma = 0;
long long j = 0;
long long pos = 0;
for (long long i = 1; i < m; i++) {
j = pi[i - 1];
while (j > 0 && x[i] != x[j]) j = pi[j - 1];
if (x[j] == x[i]) j++;
pi[i] = j;
if (x[i] == '#') pos = i;
}
long long p = pos;
for (long long i = (pos); i < (m); ++i) {
if (pi[i] > ma) {
ma = pi[i];
p = i;
}
}
return x.substr(p - ma + 1, ma);
}
void dfs(vector<long long> adj[], long long fl[], long long i, long long& cn) {
fl[i] = 1;
cn++;
for (long long j = (0); j < (adj[i].size()); ++j) {
if (!fl[adj[i][j]]) {
dfs(adj, fl, adj[i][j], cn);
}
}
}
int isp(long long x) {
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) return 0;
return 1;
}
struct Compare {
bool operator()(long long const& p1, long long const& p2) {
if (p1 < p2) {
return true;
}
return false;
}
};
void solve() {
long long n, k;
string s;
cin >> n >> k >> s;
long long z = 0, o = 0;
for (long long i = (0); i < (k); ++i) {
int x = -1;
for (long long j = i; j < n; j += k) {
if (s[j] != '?') {
if (x != -1 && s[j] - '0' != x) {
cout << "NO";
return;
}
x = s[j] - '0';
}
}
if (x != -1) x == 0 ? z++ : o++;
}
if (max(o, z) > k / 2)
cout << "NO";
else
cout << "YES";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t1 = 1;
cin >> t1;
while (t1--) {
solve();
cout << "\n";
;
}
}
| 3 |
#include <bits/stdc++.h>
int n, m, l, k, s;
bool a[201][201];
int work(int q, int m) {
int i, j, x;
s = 0;
for (x = 3; x <= 100; x++) {
s += (x - 1) * (x - 2) / 2;
if (s > q) {
s -= (x - 1) * (x - 2) / 2;
break;
}
}
x--;
l = q - s;
for (i = m + 1; i <= m + x; i++)
for (j = i + 1; j <= m + x; j++) a[i][j] = a[j][i] = 1;
while (l) {
for (i = 1; i <= x; i++)
if (i * (i - 1) / 2 <= l && i * (i + 1) / 2 > l) {
l -= i * (i - 1) / 2;
x++;
for (j = m + 1; j <= m + i; j++) a[j][n + x] = a[n + x][j] = 1;
break;
}
}
n += x;
return l;
}
int main() {
int i, j;
scanf("%d", &k);
work(k, 0);
printf("%d\n", n);
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) printf("%d", a[i][j]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
int n, a[MAXN];
vector<int> op;
vector<vector<int> > outs;
bool ck() {
for (int i = 2; i <= n; ++i) {
if (a[i] < a[i - 1]) return false;
}
return true;
}
void swaps(int l, int r) {
int mid = (l + r) >> 1;
while (l <= mid) {
swap(a[l], a[r]);
++l;
--r;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
bool f = 0;
while (!ck()) {
op.clear();
if (f) {
for (int l = 1; l <= n; ++l) {
int r = l;
while (r < n && a[r + 1] > a[r]) ++r;
swaps(l, r);
op.push_back(r - l + 1);
l = r;
}
} else {
for (int l = 1; l <= n; ++l) {
int r = l;
while (r < n && a[r + 1] < a[r]) ++r;
swaps(l, r);
op.push_back(r - l + 1);
l = r;
}
}
swaps(1, n);
f ^= 1;
if (op.size() != 1) {
outs.push_back(op);
}
}
printf("%d\n", outs.size());
for (auto &it : outs) {
printf("%d", it.size());
for (auto &i : it) {
printf(" %d", i);
}
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char check(string s) {
for (int i = 0; i < 3; i++)
if (count(s.begin(), s.end(), 'a' + i) == 0) return 'a' + i;
return '0';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t, ans;
string s, s1 = "";
cin >> t;
while (t--) {
ans = 0;
cin >> s;
for (int i = 0; i < s.size() - 1; i++) {
s1.clear();
if (s[i] == '?') {
if ((i > 0) && (s[i - 1] != '?')) s1 += s[i - 1];
if (s[i + 1] != '?') s1 += s[i + 1];
s[i] = check(s1);
} else if (s[i] == s[i + 1]) {
ans = -1;
break;
}
}
if (ans == -1)
cout << ans << endl;
else {
if (s[s.size() - 1] == '?') {
s1 += s[s.size() - 2];
s[s.size() - 1] = check(s1);
}
cout << s << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<pair<int, int> > tab(n);
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
tab[i] = {a, b};
}
int ti = 0;
bool flag = false;
for (int i = 0; i < n; i++) {
if (flag)
ti = max(tab[i].first, ti);
else
ti = max(tab[i].first, ti + 1);
if (tab[i].second < ti) {
cout << "0 ";
flag = true;
} else {
cout << ti << " ";
flag = false;
}
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int LogN = 30;
const long long Lim = 1ll << LogN;
const int MAXN = 5e5 + 7;
const int MOD = 1e9 + 7;
inline void proc_status() {
ifstream t("/proc/self/status");
cerr << string(istreambuf_iterator<char>(t), istreambuf_iterator<char>())
<< endl;
}
template <typename T>
inline T read() {
T res = 0, flag = 1;
char in = getchar();
while (!isdigit(in)) {
if (in == '-') flag = -1;
in = getchar();
}
while (isdigit(in)) {
res = (res << 1) + (res << 3) + in - '0';
in = getchar();
}
return res * flag;
}
template <typename T>
inline void chkmax(T &a, T b) {
if (a < b) a = b;
}
template <typename T>
inline void chkmin(T &a, T b) {
if (a > b) a = b;
}
inline void Add(int &x, int y) {
x += y;
(x >= MOD) ? x -= MOD : 0;
}
int Q, n;
int a[MAXN];
int mul[MAXN], imul[MAXN];
long long rml[MAXN];
int sum[MAXN];
vector<pair<int, int> > qry[MAXN];
namespace DSU {
int f[MAXN];
inline void init() {
for (int i = 1; i < MAXN; ++i) f[i] = i;
}
int find(int x) { return (f[x] ^ x) ? f[x] = find(f[x]) : x; }
void merge(int x, int y) {
x = find(x);
y = find(y);
f[x] = y;
}
} // namespace DSU
inline void init() {
n = read<int>();
Q = read<int>();
for (int i = 1; i <= n; ++i) a[i] = read<int>();
for (int i = 1; i <= Q; ++i) {
int l = read<int>();
int r = read<int>();
qry[r].push_back(make_pair(l, i));
}
mul[0] = imul[0] = rml[0] = 1;
int inv = (MOD + 1) / 2;
for (int i = 1; i < MAXN; ++i) mul[i] = (mul[i - 1] << 1) % MOD;
for (int i = 1; i < MAXN; ++i) imul[i] = (long long)imul[i - 1] * inv % MOD;
for (int i = 1; i <= LogN; ++i) rml[i] = rml[i - 1] << 1;
for (int i = 1; i <= n; ++i)
sum[i] =
(sum[i - 1] + (long long)(a[i] + MOD) * mul[i - 1] % MOD + MOD) % MOD;
DSU::init();
}
int bel[MAXN];
struct BLK {
int psum, sum, r, len;
long long rval;
inline void pushval(long long x) {
if (rval >= Lim) return;
rval += x;
if (rval >= Lim) rval = Lim;
}
inline void INF() { rval = Lim; }
} blk[MAXN];
int tot;
inline int Query(int l, int r) {
int bl = bel[DSU::find(l)];
int br = bel[DSU::find(r)];
if (bl == br)
return (long long)(MOD + sum[r] - sum[l - 1]) * imul[l - 1] % MOD;
int res = 2ll * (blk[br].psum - blk[bl].psum + MOD) % MOD;
r = blk[bl].r;
return (res + (long long)(MOD + sum[r] - sum[l - 1]) * imul[l - 1] % MOD) %
MOD;
}
int ans[MAXN];
inline void solve() {
for (int i = 1; i <= n; ++i) {
if (a[i] < 0 || !tot) {
++tot;
blk[tot] = (BLK){(blk[tot - 1].psum + a[i] + MOD) % MOD,
(a[i] + MOD) % MOD, i, 1, a[i]};
bel[i] = tot;
int len = qry[i].size();
for (int j = 0; j < len; ++j)
ans[qry[i][j].second] = Query(qry[i][j].first, i);
continue;
}
if (a[i]) {
if (blk[tot].len >= LogN)
blk[tot].INF();
else if (blk[tot].rval + (long long)rml[blk[tot].len] * a[i] >= Lim)
blk[tot].INF();
else
blk[tot].pushval(rml[blk[tot].len] * a[i]);
Add(blk[tot].sum, (long long)(a[i] + MOD) * mul[blk[tot].len] % MOD);
}
blk[tot].psum = (blk[tot - 1].psum + blk[tot].sum) % MOD;
++blk[tot].len;
blk[tot].r = i;
DSU::merge(i - 1, i);
while (tot > 1 && blk[tot].rval >= 0) {
if (blk[tot].rval) {
if (blk[tot - 1].len >= LogN || blk[tot].rval >= Lim ||
blk[tot - 1].rval >= Lim)
blk[tot - 1].INF();
else if (blk[tot - 1].rval +
(long long)rml[blk[tot - 1].len] * blk[tot].rval >=
Lim)
blk[tot - 1].INF();
else
blk[tot - 1].pushval(rml[blk[tot - 1].len] * blk[tot].rval);
}
DSU::merge(blk[tot - 1].r, blk[tot].r);
Add(blk[tot - 1].sum,
(long long)blk[tot].sum * mul[blk[tot - 1].len] % MOD);
blk[tot - 1].r = i;
blk[tot - 1].len += blk[tot].len;
--tot;
blk[tot].psum = (blk[tot - 1].psum + blk[tot].sum) % MOD;
}
bel[i] = tot;
int len = qry[i].size();
for (int j = 0; j < len; ++j) {
ans[qry[i][j].second] = Query(qry[i][j].first, i);
}
}
for (int i = 1; i <= Q; ++i) {
printf("%d\n", ans[i]);
}
}
int main() {
init();
solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
template <class T>
inline T gethash(T h[], T power[], int l, int r) {
if (r < l) return (T)0;
return h[l] - h[r + 1] * power[r - l + 1];
}
struct data {
data() {}
bool friend operator<(data a, data b) { return 0; }
};
int n, m, k;
long long N, M, K;
int a[200005];
int b[200005];
int check(int x) {
unordered_set<int> st;
st.insert(x);
for (int i = 1; i < n; i++) {
x = x + a[i];
if (st.find(x) != st.end()) {
return 0;
}
if (x > n) return 0;
if (x <= 0) return 2;
st.insert(x);
}
return 1;
}
int main() {
int t, tc = 1;
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
scanf("%d", &a[i]);
}
int l = 1, h = n;
int ans = -1;
while (l <= h) {
int mid = (l + h) / 2;
int p = check(mid);
if (p == 1) {
ans = mid;
break;
} else if (p == 0) {
h = mid - 1;
} else {
l = mid + 1;
}
}
if (ans == -1) {
printf("%d", -1);
return 0;
}
printf("%d", ans);
for (int i = 1; i < n; i++) {
printf(" %d", ans + a[i]);
ans = ans + a[i];
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, k;
set<int> s;
deque<int> q;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
int id;
cin >> id;
if (s.find(id) != s.end()) continue;
if (s.size() != k) {
s.insert(id);
q.push_back(id);
} else {
int f = q.front();
q.pop_front();
s.erase(s.find(f));
q.push_back(id);
s.insert(id);
}
}
cout << q.size() << endl;
while (!q.empty()) {
int sol = q.back();
cout << q.back() << " ";
q.pop_back();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s, k, i, sss, top, bot, mid, res, dx, cnt, x, y, z;
vector<pair<int, int> > a[700], b[700];
int c[700], d[700], p[700], match[700];
bool found;
void dijkstra(int t, int x) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
q.push(pair<int, int>(0, x));
for (int i = 1; i <= n; ++i) d[i] = 1e9;
d[x] = 0;
while (q.size()) {
dx = q.top().first;
x = q.top().second;
q.pop();
if (d[x] != dx) continue;
b[t].push_back(pair<int, int>(x, dx));
for (int i = 0; i < a[x].size(); ++i)
if (d[a[x][i].first] > d[x] + a[x][i].second) {
d[a[x][i].first] = d[x] + a[x][i].second;
q.push(pair<int, int>(d[a[x][i].first], a[x][i].first));
}
}
}
void dfs(int x) {
for (int i = 0; i < b[x].size(); ++i) {
if (b[x][i].second > sss) return;
int y = b[x][i].first;
if (c[y] == cnt) continue;
c[y] = cnt;
if (match[y] == 0)
found = true;
else
dfs(match[y]);
if (found) {
match[y] = x;
return;
}
}
}
bool check(int mid) {
memset(match, 0, sizeof(match));
int res = 0;
sss = mid;
for (int i = 1; i <= s; ++i) {
cnt++;
found = false;
dfs(i);
if (found) res++;
}
return res >= k;
}
int main() {
scanf("%d %d %d %d", &n, &m, &s, &k);
for (i = 1; i <= s; ++i) scanf("%d", &p[i]);
for (i = 1; i <= m; ++i) {
scanf("%d %d %d", &x, &y, &z);
a[x].push_back(pair<int, int>(y, z));
a[y].push_back(pair<int, int>(x, z));
}
for (i = 1; i <= s; ++i) dijkstra(i, p[i]);
bot = 0;
top = 1731311;
res = -1;
memset(c, 0, sizeof(c));
cnt = 0;
while (bot <= top) {
mid = (bot + top) / 2;
if (check(mid)) {
res = mid;
top = mid - 1;
} else
bot = mid + 1;
}
printf("%d", res);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int mod = 998244353;
void flash() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(9);
}
void solve();
int32_t main() {
flash();
int t;
t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
void solve() {
long long n, k;
cin >> n >> k;
long long a[k];
for (int i = 0; i < k; i++) cin >> a[i];
long long ind = -1;
long long maxh = -1;
long long rem = 1e18;
for (int i = 0; i < k; i++) {
if (rem > n % a[i]) {
maxh = n / a[i];
ind = i;
rem = n % a[i];
}
}
cout << ind + 1 << " " << maxh;
return;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[200005];
int main() {
long long n, s, mn = 1e17;
scanf("%lld", &n), scanf("%lld", &s);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
mn = min(mn, a[i]);
}
long long cnt = 0, sum = 0, ans = 0;
while (s >= mn) {
sum = 0;
cnt = 0;
for (long long i = 1; i <= n; i++) {
if (a[i] <= s and s - sum - a[i] >= 0) {
sum += a[i];
cnt++;
}
}
if (sum > 0) {
ans += cnt * (s / sum);
s %= sum;
} else {
break;
}
}
printf("%lld\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
char arr[64];
int b = 0, w = 0;
for (int i = 0; i < 64; i++) {
cin >> arr[i];
if (arr[i] == 'Q')
w += 9;
else if (arr[i] == 'R')
w += 5;
else if (arr[i] == 'B')
w += 3;
else if (arr[i] == 'N')
w += 3;
else if (arr[i] == 'P')
w += 1;
else if (arr[i] == 'q')
b += 9;
else if (arr[i] == 'r')
b += 5;
else if (arr[i] == 'b')
b += 3;
else if (arr[i] == 'n')
b += 3;
else if (arr[i] == 'p')
b += 1;
}
if (b > w)
cout << "Black";
else if (w > b)
cout << "White";
else
cout << "Draw";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n, c;
cin >> n >> c;
long long a[n - 1], b[n - 1];
for (int i = 0; i < n - 1; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) cin >> b[i];
long long dp[2][n];
memset(dp, 0, sizeof(dp));
dp[0][1] = a[0], dp[1][1] = b[0] + c;
for (int i = 2; i < n; i++) {
long long val = min(dp[0][i - 1], dp[1][i - 1]);
dp[0][i] = val + a[i - 1];
dp[1][i] = min(dp[0][i - 1] + b[i - 1] + c, dp[1][i - 1] + b[i - 1]);
}
for (int i = 0; i < n; i++) cout << min(dp[0][i], dp[1][i]) << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, inf = 1e9;
vector<int> v[N], dcc[N];
struct Link {
int to, nxt;
} l[N << 1];
int n, m, Q, w[N], head[N], tot;
inline int read() {
int s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') f = ch == '-' ? -1 : f, ch = getchar();
while (ch >= '0' && ch <= '9')
s = (s << 1) + (s << 3) + (ch ^ 48), ch = getchar();
return s * f;
}
inline void add(int x, int y) {
l[++tot].to = y;
l[tot].nxt = head[x];
head[x] = tot;
}
int dfn[N], low[N], bl[N], cut[N], st[N], val[N], rt, now, tp, cnt;
void tarjan(int x) {
dfn[x] = low[x] = ++now;
st[++tp] = x;
int flag = 0;
for (auto y : v[x]) {
if (!dfn[y]) {
tarjan(y);
low[x] = min(low[x], low[y]);
if (low[y] >= dfn[x]) {
flag++;
if (x != rt || flag > 1) cut[x] = 1;
cnt++;
int z = 0;
do {
z = st[tp--];
bl[z] = cnt;
dcc[cnt].push_back(z);
add(z, cnt), add(cnt, z);
} while (z != y);
dcc[cnt].push_back(x);
add(x, cnt), add(cnt, x);
}
} else
low[x] = min(low[x], dfn[y]);
}
}
multiset<int> s[N];
int son[N], sz[N], top[N], fa[N], rk[N], id[N], d[N], node;
void dfs(int x, int f) {
sz[x] = 1;
fa[x] = f;
d[x] = d[f] + 1;
for (int i = head[x]; i; i = l[i].nxt) {
int y = l[i].to;
if (y == f) continue;
dfs(y, x);
sz[x] += sz[y];
if (sz[y] > sz[son[x]]) son[x] = y;
}
}
void dfs(int x, int f, int tp) {
top[x] = tp;
id[x] = ++node;
rk[node] = x;
if (!son[x]) return;
dfs(son[x], x, tp);
for (int i = head[x]; i; i = l[i].nxt) {
int y = l[i].to;
if (y == f || y == son[x]) continue;
dfs(y, x, y);
}
if (x <= n) return;
for (int i = head[x]; i; i = l[i].nxt)
if (l[i].to != f) s[id[x]].insert(w[l[i].to]);
}
int mx[N << 2];
void build(int k, int l, int r) {
if (l == r) return mx[k] = *(s[l].begin()), void();
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
mx[k] = min(mx[k << 1], mx[k << 1 | 1]);
}
void modify(int k, int l, int r, int pos) {
if (l == r) return mx[k] = *(s[l].begin()), void();
int mid = l + r >> 1;
if (mid >= pos) modify(k << 1, l, mid, pos);
if (mid < pos) modify(k << 1 | 1, mid + 1, r, pos);
mx[k] = min(mx[k << 1], mx[k << 1 | 1]);
}
int query(int k, int l, int r, int L, int R) {
if (L <= l && r <= R) return mx[k];
int mid = l + r >> 1, res = inf;
if (mid >= L) res = min(res, query(k << 1, l, mid, L, R));
if (mid < R) res = min(res, query(k << 1 | 1, mid + 1, r, L, R));
return res;
}
int get_ans(int x, int y) {
int ans = inf, fx = top[x], fy = top[y];
while (fx != fy) {
if (d[fx] < d[fy]) swap(x, y), swap(fx, fy);
ans = min(ans, query(1, 1, node, id[fx], id[x]));
x = fa[fx];
fx = top[x];
}
if (d[x] > d[y]) swap(x, y);
ans = min(ans, query(1, 1, node, id[x], id[y]));
if (x > n) ans = min(ans, w[fa[x]]);
return ans;
}
int main() {
n = read(), m = read(), Q = read();
for (int i = 1; i <= n; ++i) w[i] = read();
for (int i = 1; i <= m; ++i) {
int x = read(), y = read();
v[x].push_back(y);
v[y].push_back(x);
}
cnt = n;
for (int i = 1; i <= n; ++i)
if (!dfn[i]) rt = i, tarjan(i);
dfs(1, 0);
dfs(1, 0, 1);
for (int i = 1; i <= n; ++i) s[id[i]].insert(w[i]);
build(1, 1, node);
char opt[3];
for (int i = 1; i <= Q; ++i) {
scanf("%s", opt);
int x = read(), y = read();
if (opt[0] == 'A') printf("%d\n", get_ans(x, y));
if (opt[0] == 'C') {
s[id[x]].erase(w[x]);
s[id[fa[x]]].erase(w[x]);
w[x] = y;
s[id[x]].insert(w[x]);
s[id[fa[x]]].insert(w[x]);
modify(1, 1, node, id[x]);
modify(1, 1, node, id[fa[x]]);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long solve(long long x, long long d, long long num) {
long long res = x / d * num, left = x / d * d;
return res + min(num, x - left + 1);
}
int main() {
long long T;
scanf("%lld", &T);
while (T--) {
long long a, b, q;
scanf("%lld %lld %lld", &a, &b, &q);
if (a > b) swap(a, b);
long long d = a * b / gcd(a, b);
while (q--) {
long long x, y;
cin >> x >> y;
if (a == b) {
puts("0");
continue;
}
long long x0 = x % d, y0 = y - x + x0;
if (x0 == 0)
printf("%lld ", y - x + 1 - solve(y0, d, b));
else
printf("%lld ", y - x + 1 - solve(y0, d, b) + solve(x0 - 1, d, b));
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int maxn = 100;
int T, n, m;
int a[10000005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int a1 = a[n - 1] - a[1];
int a2 = a[n - 2] - a[0];
cout << min(a1, a2) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
cin >> a >> b;
if (abs(x1 - x2) % a == 0 && abs(y1 - y2) % b == 0 &&
(abs(abs(x1 - x2) / a - abs(y1 - y2) / b) % 2 == 0))
cout << "YES";
else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, M, R, num[200005], Z[200005][2], fa[200005];
int D[200005], U[200005], T[200005], V[200005], S[200005][2], W, P[200005];
vector<int> dn[200005];
void Ud(int x) {
T[x] = T[Z[x][0]] + T[Z[x][1]] + V[x];
D[x] =
min(T[Z[x][0]] + V[x], min(D[Z[x][0]], D[Z[x][1]] + T[Z[x][0]] + V[x]));
U[x] =
max(T[Z[x][0]] + V[x], max(U[Z[x][0]], U[Z[x][1]] + T[Z[x][0]] + V[x]));
}
void Ro(int x, int d) {
int t = fa[x];
Z[t][d ^ 1] = Z[x][d], fa[Z[x][d]] = t;
if (fa[t]) Z[fa[t]][Z[fa[t]][1] == t] = x;
fa[x] = fa[t], fa[t] = x, Z[x][d] = t, Ud(t), Ud(x);
}
void Sp(int x, int to) {
int t, d1, d2;
while ((t = fa[x]) - to)
if (fa[t] == to)
Ro(x, Z[t][0] == x);
else if ((d1 = (Z[fa[t]][0] == t)) ^ (d2 = (Z[t][0] == x)))
Ro(x, d2), Ro(x, d1);
else
Ro(t, d1), Ro(x, d2);
R = to ? R : x;
}
int Last(int x) {
Sp(x, 0);
for (x = Z[x][0]; Z[x][1]; x = Z[x][1])
;
return x;
}
int Next(int x) {
Sp(x, 0);
for (x = Z[x][1]; Z[x][0]; x = Z[x][0])
;
return x;
}
int De(int l, int r) {
int t, tl, tr, f;
tl = Last(l), tr = Next(r);
if (!(tl + tr)) {
return r;
} else if (!tl || !tr) {
f = (!tr), tr += tl;
Sp(tr, 0), t = Z[tr][f];
Z[tr][f] = fa[Z[tr][f]] = 0, Ud(tr);
return t;
}
Sp(tl, 0), Sp(tr, tl), t = Z[tr][0];
Z[tr][0] = fa[Z[tr][0]] = 0;
Ud(tr), Ud(tl);
return t;
}
void In(int x, int y) {
if (!x) {
R = y;
return;
}
int t = Next(x);
if (!t)
Z[x][1] = y, fa[y] = x, Ud(x);
else
Sp(t, x), Z[t][0] = y, fa[y] = t, Ud(t), Ud(x);
Sp(y, 0);
}
int Ask(int x, int k) {
for (k++;;)
if (D[Z[x][1]] + T[Z[x][0]] + V[x] <= k &&
U[Z[x][1]] + T[Z[x][0]] + V[x] >= k)
k -= T[Z[x][0]] + V[x], x = Z[x][1];
else if (T[Z[x][0]] + V[x] == k) {
Sp(x, 0);
return x == S[num[x]][0] ? num[x] : P[num[x]];
} else
x = Z[x][0];
}
int Dis(int x, int y) {
x = S[x][0], y = S[y][0];
if (x == y) return 0;
Sp(y, 0), Sp(x, y);
if (x == Z[y][1]) swap(x, y);
Sp(y, 0), Sp(x, y);
int t =
min(T[Z[x][0]] + V[x], min(D[Z[x][1]] + T[Z[x][0]] + V[x], T[x] + V[y]));
return T[Z[x][0]] + T[x] + V[x] + V[y] - t * 2;
}
void Tr(int x, int h) {
int t = x, par;
x = S[x][0], Sp(x, 0), par = Ask(Z[x][0], T[Z[x][0]] + V[x] - h - 1);
P[t] = par, t = De(S[t][0], S[t][1]);
In(Last(S[par][1]), t);
}
void Dfs(int x) {
S[x][0] = ++W, num[W] = x;
V[W] = T[W] = D[W] = U[W] = 1, In(R, W);
for (int i = 0; i < dn[x].size(); i++) P[dn[x][i]] = x, Dfs(dn[x][i]);
S[x][1] = ++W, num[W] = x;
V[W] = T[W] = D[W] = U[W] = -1, In(R, W);
}
int main() {
int i, j, t, get, tp, fr, to;
scanf("%d", &N), scanf("%d", &M);
for (i = 0; i <= 200005 - 5; i++) U[i] = -200005, D[i] = 200005;
for (i = 1; i <= N && scanf("%d", &j); i++)
while (j--) scanf("%d", &t), dn[i].push_back(t);
for (i = 1, Dfs(1); i <= M && scanf("%d", &tp); i++)
if (tp == 1)
scanf("%d", &fr), scanf("%d", &to), printf("%d\n", Dis(fr, to));
else if (tp == 2)
scanf("%d", &fr), scanf("%d", &to), Tr(fr, to);
else
scanf("%d", &fr), printf("%d\n", Ask(R, fr));
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T>
vector<T> prefixes(const C& v, T zero) {
vector<T> res(int((v).size()) + 1, zero);
for (int i = 0; i < (int((v).size())); i++) res[i + 1] = res[i] + v[i];
return res;
}
template <typename C, typename T>
vector<T> suffixes(const C& v, T zero) {
vector<T> res(int((v).size()) + 1, zero);
for (int i = (int((v).size())) - 1; i >= 0; i--) res[i] = v[i] + res[i + 1];
return res;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
void solve() {
int N, M, K;
re(N, M, K);
vi ht(N);
re(ht);
for (int i = 0; i < (N - 1); i++) {
int targ = max(0, ht[i + 1] - K);
if (targ - ht[i] > M) {
ps("NO");
return;
}
M += ht[i] - targ;
}
ps("YES");
}
int main() {
setIO();
int T;
re(T);
for (int t = 0; t < (T); t++) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
long long mod = 1e9 + 7;
bool visited[26][26];
int in[26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
string alphabet = "abcdefghijklmnopqrstuvwxyz";
cin >> n;
string s;
string ss;
cin >> s;
for (int i = 0; i < 26; ++i) {
for (int j = 0; j < 26; ++j) {
visited[i][j] = false;
}
}
for (int i = 0; i < 26; ++i) {
in[i] = 0;
}
for (int i = 1; i < n; ++i) {
cin >> ss;
bool ok = true;
int n = s.length();
int nn = ss.length();
int bb = min(n, nn);
int index = bb;
for (int i = 0; i < bb; ++i) {
if (ss[i] != s[i]) {
index = i;
break;
}
}
if (index != bb) {
if (!visited[s[index] - 'a'][ss[index] - 'a']) {
visited[s[index] - 'a'][ss[index] - 'a'] = true;
in[ss[index] - 'a']++;
}
} else {
if (n > nn) {
cout << "Impossible";
return 0;
}
}
s = ss;
}
queue<int> q;
for (int i = 0; i < 26; ++i) {
if (!in[i]) q.push(i);
}
vector<int> ans;
int compt = 0;
while (!q.empty()) {
compt++;
int u = q.front();
ans.emplace_back(u);
q.pop();
for (int i = 0; i < 26; ++i) {
if (visited[u][i]) {
--in[i];
if (in[i] == 0) {
q.push(i);
}
}
}
}
if (compt != 26) {
cout << "Impossible";
return 0;
} else {
for (int i = 0; i < 26; ++i) {
cout << char(ans[i] + 'a') << "";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s;
long long ans = 1;
void solve(int n) {
int best = 0, sum = 0;
int ok = -1;
for (int i = 0; i < min(s, n); ++i) {
int cnt = 0;
for (int j = i; j < n; j += s) {
++cnt;
}
if (ok == -1) {
ok = cnt;
}
if (ok == cnt) sum += ok;
}
ans *= sum;
}
int main() {
cin >> n >> m >> s;
solve(n);
solve(m);
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int f[100010];
int main() {
int n;
ios::sync_with_stdio(0);
cin >> n;
if (n <= 2)
cout << -1;
else if (n == 3)
cout << 210;
else {
f[1] = 1;
for (int i = (2), _b = (n); i <= _b; i++) f[i] = (f[i - 1] * 10) % 210;
int k = 210 - f[n];
double p = log10(k) + 1;
int digit = p;
cout << 1;
for (int i = (1), _b = (n - digit - 1); i <= _b; i++) cout << 0;
cout << k;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e17;
const int MAXM = 1e6 + 5;
const int MAXN = 1e6 + 4;
vector<pair<double, double> > v;
double p, ret = -1.0;
bool cal(double val) {
double tt = 0.00;
for (int i = 0; i < v.size(); i++) {
double a = v[i].first;
double b = v[i].second;
double totalcharge = a * val;
if (b > totalcharge) continue;
tt += ((totalcharge - b) / p);
}
return tt <= val;
}
int main() {
int n, k, i, j;
scanf("%d", &n);
scanf("%lf", &p);
for (i = 1; i <= n; i++) {
double x, y;
scanf("%lf%lf", &x, &y);
v.push_back(make_pair(x, y));
}
double hi = 1e16, lo = 0.00;
int cn = 0;
while (cn <= 500) {
double mid = (lo + hi) / 2.0;
if (cal(mid)) {
lo = mid + 0.0000001;
ret = mid;
} else {
hi = mid - 0.0000001;
if (hi <= 0) break;
}
cn++;
}
if (ret > 1e15)
printf("-1\n");
else
printf("%0.6lf\n", ret);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long p, k;
const int mod = 1e9 + 7;
long long cal(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) {
ans = (ans * a) % mod;
}
a = (a * a) % mod;
b /= 2;
}
return ans;
}
int main() {
scanf("%I64d %I64d", &p, &k);
if (k == 0) {
printf("%I64d\n", cal(p, p - 1));
} else if (k == 1) {
printf("%I64d\n", cal(p, p));
} else {
long long ret = 1;
for (long long i = k; i != 1; i = (i * k) % p) {
ret++;
}
ret = (p - 1) / ret;
printf("%I64d\n", cal(p, ret));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s[45];
int main() {
int n, p;
scanf("%d%d", &n, &p);
for (int i = 0; i < n; ++i) cin >> s[i];
reverse(s, s + n);
long long ans = 0;
long long k = 0;
for (int i = 0; i < n; ++i) {
k *= 2;
if (s[i] == "halfplus") k++;
ans += (k * p) / 2;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char str[105];
int main() {
scanf("%s", str + 1);
int len = strlen(str + 1);
vector<int> vec;
vec.push_back(0);
int ans = 0;
for (int i = 1; i <= len; ++i) {
if (str[i] == 'A' || str[i] == 'E' || str[i] == 'I' || str[i] == 'O' ||
str[i] == 'U' || str[i] == 'Y') {
vec.push_back(i);
ans = max(ans, i - vec[vec.size() - 2]);
}
}
ans = max(ans, 1 + len - vec[vec.size() - 1]);
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int count = 0;
int a, b, c;
cin >> a >> b >> c;
for (int i = 1; i <= a; i++) {
if ((i - 1) >= b && abs(i - a) <= c) {
count++;
}
}
cout << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
vector<int> arr(n);
for (int j = 0; j < n; j++) cin >> arr[j];
for (int j = 1; j < arr.size() - 1; j++) {
if (abs(arr[j] - arr[j - 1]) + abs(arr[j] - arr[j + 1]) <=
abs(arr[j - 1] - arr[j + 1])) {
arr.erase(arr.begin() + j);
j--;
}
}
int len = arr.size();
cout << len << '\n';
for (int j = 0; j < len; j++) cout << arr[j] << ' ';
cout << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1)
cout << 5;
else if (n == 2)
cout << 4;
else
cout << n - 2;
}
| 0 |
#include <bits/stdc++.h>
#include <iomanip>
#define FAST std::ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define DECIMAL(n) std::cout << std::fixed;std::cout << std::setprecision(n);
#define mod 1000000007
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define ALL(v) v.begin(), v.end()
#define SORT(v) sort(ALL(v))
#define REVERSE(v) reverse(ALL(v))
#define endl "\n"
#define maxc(v) max_element(all(v))
#define minc(v) min_element(all(v))
#define GCD(m,n) __gcd(m,n)
#define debug cerr<<"bhau"<<endl
#define debugv(x) cerr<<x<<endl
#define inputarr(a,n) for(int i=0;i<n;++i) cin>>a[i]
#define printarr(a,n) for(int i=0;i<n;++i) cout<<a[i]<<" "
#define initarr(a,n,x) for (int i=0;i<n;++i) a[i]=x
#define ll long long
#define ld long double
#define pii pair<ll, ll>
#define vi vector<ll>
#define vvi vector<vi >
#define vii vector<pii >
#define eps 1e-9
using namespace std;
//int a[100][100];
/*const int mx=1e6+1;
bool vis[mx]={false};
ll dist[mx];
vector<pii>adj[mx];
priority_queue<pii,vector<pii>,greater<pii> > pq;
void dijkstra()
{
pq.push(make_pair(0,1));
dist[1]=0;
while(!pq.empty())
{
ll u=pq.top().second;
pq.pop();
if(vis[u])
continue;
vis[u]=true;
vector<pii>::iterator it;
for(it=adj[u].begin();it!=adj[u].end();it++)
{
ll v=(*it).first;
ll weight =(*it).second;
//cout<<v<<" "<<dist[v]<<" "<<(dist[u]+weight)<<endl;
if( (dist[v]>dist[u]+weight))
{
dist[v]=dist[u]+weight;
pq.push(make_pair(dist[v],v));
}
}
}
}*/
/*int V,k;
struct node
{
ll src,dest;
ll wght;
};
ll par[105],rnk[105];
ll Find(ll nd)
{
if(par[nd]!=nd)
par[nd]=Find(par[nd]);
return par[nd];
}
void Union(ll nd1, ll nd2)
{
ll x=Find(nd1);
ll y=Find(nd2);
if(rnk[x]<rnk[y])
par[x]=y;
else if(rnk[x]>rnk[y])
par[y]=x;
else
{
par[y]=x;
rnk[x]++;
}
}
bool compare(node n1, node n2)
{
return n1.wght<n2.wght;
}
ll kruskal(vector<node> g, int n)
{
vector<node> mst;
for(int i=0;i<n;++i)
{
par[i]=i;
rnk[i]=0;
}
sort(g.begin(),g.end(),compare);
ll cnt=0,cnt1=0;
ll ans=0;
while(cnt!=n-1)
{
node ne=g[cnt1++];
int x=Find(ne.src);
int y=Find(ne.dest);
if(x!=y)
{
if(ans+ne.wght<=k)
{ans+=ne.wght;
mst.push_back(ne);
Union(x,y);
cnt++;}
else
{
break;
}
}
}
return cnt;
}
ll dis[105][105];
void floydWarshell(vector<node> g, int n)
{
for(int i=0;i<V;i++)
{
for(int j=0;j<V;j++)
{
dis[i][j]=9999;
}
}
for(int i=0;i<V;i++)
{
dis[i][i]=0;
}
for(int i=0;i<g.size();++i)
{
dis[g[i].src][g[i].dest]=g[i].wght;
//dis[g[i].dest][g[i].src]=g[i].wght;
}
for(int k=0;k<n;++k)
{
for(int i=0;i<n;++i)
{
for(int j=0;j<n;++j)
{
if(dis[i][k]+dis[k][j]<dis[i][j])
dis[i][j]=dis[i][k]+dis[k][j];
}
}
}
}
long di[105];
void bellmanford(vector<node> g,ll e)
{
for(int i=0;i<V;i++)
{
di[i]=LONG_MAX;
}
di[0]=0;
for(int i=0;i<V-1;i++)
{
for(int j=0;j<e;j++)
{
if(di[g[j].src]+g[j].wght<di[g[j].dest])
di[g[j].dest]=di[g[j].src]+g[j].wght;
}
}
}
void topological_sort()
{
for(ll i=1;i<=n;i++)
{
if(!in[i])
{
t.push(i);
}
}
while(!t.empty())
{
ll u=t.front();
t.pop();
ans.push_back(u);
for(auto i:v[u])
{
in[i]-=1;
val[i]+=val[u]/out[u];
if(in[i]==0)
{
t.push(i);
}
}
}
}
void dfs_util(ll u,vector<ll> g[],vector<bool> &visited)
{
visited[u]=true;
//int c=0;
for(int i=0;i<g[u].size();i++)
{
if(visited[g[u][i]]==false)
{
dfs_util(g[u][i],g,visited);
}
}
}
bool dfs(vector<ll> g[])
{
vector<bool> visited(V+1,false);
dfs_util(0,g,visited);
ll count=0;
for(int i=0;i<V;i++)
{
if(visited[i])
count++;
}
if(count==V)
return true;
else
return false;
}*/
/*void check(vector<ll> g[],ll *vis,ll u,bool &ans)
{
vis[u]=true;
for(int i=0;i<g[u].size();i++)
{
if(vis[g[u][i]]==0)
check(g,vis,g[u][i],ans);
else if(vis[g[u][i]]==1)
ans=true;
}
vis[u]=2;
}*/
//int T;
//char s[100007];
/* ll t;
cin>>t;
while(t--)
{
ll n,x,sum=0;
cin>>n>>x;
int a[n];
inputarr(a,n);
int count=1;
bool b=true;
while(b)
{
count++;
for(int i=0;i<n;i++)
{
if(a[i]%x==0 && (a[i]/x)!=0)
{
if(count!=1)
sum+=x*a[i];
else
sum+=a[i];
a[i]=a[i]/x;
}
else
{
b=false;
break;
}
}
//cout<<sum<<endl;
}
cout<<sum<<endl;
}*/
//ll t;
//const int mod = 1000000007;
ll nCr(ll n, ll k)
{
ll C[n + 1][k + 1];
ll i, j;
// Caculate value of Binomial Coefficient
// in bottom up manner
for (i = 0; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
// Base Cases
if (j == 0 || j == i)
C[i][j] = 1;
// Calculate value using previously
// stored values
else
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
return C[n][k];
}
bool isPalindrome(string str)
{
// Start from leftmost and rightmost corners of str
int l = 0;
int h = str.size() - 1;
// Keep comparing characters while they are same
while (h > l)
{
if (str[l++] != str[h--])
{
//printf("%s is Not Palindrome", str);
return false;
}
}
return true;
}
double squareRoot(ll number, int precision)
{
ll start = 0, end = number;
ll mid;
// variable to store the answer
double ans;
// for computing integral part
// of square root of number
while (start <= end) {
mid = (start + end) / 2;
if (mid * mid == number) {
ans = mid;
break;
}
// incrementing start if integral
// part lies on right side of the mid
if (mid * mid < number) {
start = mid + 1;
ans = mid;
}
// decrementing end if integral part
// lies on the left side of the mid
else {
end = mid - 1;
}
}
// For computing the fractional part
// of square root upto given precision
double increment = 0.1;
for (int i = 0; i < precision; i++) {
while (ans * ans <= number) {
ans += increment;
}
// loop terminates when ans * ans > number
ans = ans - increment;
increment = increment / 10;
}
return ans;
}
int main()
{
ll t;
cin>>t;
while(t--)
{
ll r,b,d;
cin>>r>>b>>d;
ll s=max(r,b);
ll q=min(r,b);
if(s<=(1+d)*q)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int sta[200010];
int dp[200010];
int n, m;
char u;
void scan(int &x) {
int f = 1;
while (u = getchar(), u < '0' || u > '9') {
if (u == '-') f = -1;
};
x = u - '0';
while (u = getchar(), u >= '0' && u <= '9') x = x * 10 + u - '0';
x *= f;
}
int main() {
int q;
scan(q);
while (q--) {
scan(n);
scan(m);
memset(dp, 0x3f, sizeof(dp));
for (int i = 1; i <= m; i++) {
scan(sta[i]);
}
sta[m + 1] = 0;
int ans = 0;
for (int i = 2; i <= m; i++) {
if (sta[i + 1] + 1 == sta[i]) {
i++;
} else
ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 1 << 19;
int n, m;
long long k, mn = 1e18, l[N], r[N];
long long lucky[M], dp1[M], dp2[M];
vector<int> vec[M];
inline long long Mul(long long a, long long b) {
return a && k / a < b ? k + 10 : a * b;
}
inline void Sum(long long &a, long long b) { a = min(a + b, k + 10); }
inline bool check(int L, int R) {
return lucky[R] - lucky[L] <= mn && dp1[L] + dp2[R] <= k;
}
inline void read_input() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
mn = min(mn, r[i] - l[i]);
}
}
inline void solve() {
int sz = 0;
long long sum = 0;
for (int i = 1; i < 19; i++)
for (int j = 0; j < 1 << i; j++, m++)
for (int p = i - 1; ~p; p--) (lucky[m] *= 10) += j >> p & 1 ? 7 : 4;
for (int i = 0; i < n; i++)
vec[lower_bound(lucky, lucky + m, l[i]) - lucky].push_back(i);
for (int i = m - 1; ~i; i--) {
Sum(sum, Mul(sz, lucky[i + 1] - lucky[i]));
for (auto p : vec[i + 1]) {
Sum(sum, l[p] - lucky[i]);
sz++;
}
dp1[i] = sum;
}
for (int i = sz = sum = 0; i < m; i++) vec[i].clear();
for (int i = 0; i < n; i++)
vec[lower_bound(lucky, lucky + m, r[i]) - lucky].push_back(i);
for (int i = 0; i < m; i++) {
Sum(sum, Mul(sz, (lucky[i] - lucky[i - 1])));
for (auto p : vec[i]) {
Sum(sum, lucky[i] - r[p]);
sz++;
}
dp2[i] = sum;
}
}
inline void write_output() {
int ans = 0;
for (int i = 0; i < m; i++) {
int L = i - 1, R = m;
while (L + 1 < R) {
int mid = L + R >> 1;
(check(i, mid) ? L : R) = mid;
}
ans = max(ans, L - i + 1);
}
cout << ans;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
read_input(), solve(), write_output();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int f(int x) { return x > 0 ? x : -x; }
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, s, k, ans = 1000000007, a[1005];
map<int, int> ma;
scanf("%d%d%d", &n, &s, &k);
for (int i = 1; i <= k; i++) scanf("%d", &a[i]), ma[a[i]] = 1;
for (int i = s; i >= max(1, s - 1005); i--)
if (!ma[i]) ans = min(ans, f(s - i));
for (int i = s; i <= min(n, s + 1005); i++)
if (!ma[i]) ans = min(ans, f(s - i));
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n = 0, k = 0, s = 0, t = 0;
pair<int, int> cars[200002];
int gas[200002];
bool check(int index) {
int v = cars[index].first;
int pos = 0, time = 0;
for (int i = 0; i <= k; i++) {
if (time > t || gas[i] - pos > v) return false;
int left = 0, right = gas[i] - pos + 1;
while (left != (right - 1)) {
int middle = (left + right) >> 1;
if (middle * 2 + (gas[i] - pos - middle) <= v)
left = middle;
else
right = middle;
}
time += left + (gas[i] - pos - left) * 2;
pos = gas[i];
}
if (time > t) return false;
return true;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 0; i < n; i++) scanf("%d%d", &cars[i].second, &cars[i].first);
sort(cars, cars + n);
for (int i = 0; i < k; i++) scanf("%d", gas + i);
sort(gas, gas + k);
gas[k] = s;
if (!check(n - 1)) {
printf("-1\n");
return 0;
}
int left = -1, right = n - 1;
while (left != (right - 1)) {
int middle = (left + right) >> 1;
if (check(middle))
right = middle;
else
left = middle;
}
int min_c = cars[right].second;
for (int i = right + 1; i < n; i++)
if (cars[i].second < min_c) min_c = cars[i].second;
printf("%d\n", min_c);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int get_n(int ang) {
for (int i = 1; i <= 180; i++) {
if (180 % i == 0) {
if (ang % (180 / i) == 0) {
int ans = 180 / i;
int n = ang / ans;
for (; n >= (i - 1); i *= 2)
;
return i;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T, ang;
cin >> T;
for (int i = 0; i < T; i++) {
cin >> ang;
cout << get_n(ang) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, now, sum, ansx, anss, mx;
int tt[1000005][26], ans[300005];
char s[5];
int jia(int aa, int bb) {
if (!aa) return bb;
if (!bb) return aa;
sum++;
int qwq = ++now;
for (int i = 0; i < 26; ++i) tt[qwq][i] = jia(tt[aa][i], tt[bb][i]);
return qwq;
}
void dfs(int rt, int dep) {
mx = max(mx, dep);
now = n + 1;
sum = 0;
int RT = now;
for (int i = 0; i < 26; ++i) RT = jia(RT, tt[rt][i]);
ans[dep] += sum;
for (int i = 0; i < 26; ++i)
if (tt[rt][i]) dfs(tt[rt][i], dep + 1);
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d%s", &x, &y, s);
tt[x][s[0] - 'a'] = y;
}
dfs(1, 1);
for (int i = 1; i <= mx; ++i)
if (ansx < ans[i]) ansx = ans[i], anss = i;
printf("%d\n%d", n - ansx, anss);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 2e5 + 3;
const int INF = 1e15;
int n, k;
int l[N];
int sum[N];
signed main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> l[i];
}
sort(l + 1, l + 1 + n, greater<int>());
sum[0] = 1, sum[1] = -1;
int pt = 1, total = 0;
for (int i = 0; i < N - 5; i++) {
sum[i + 1] += sum[i];
int cur = sum[i];
total += cur;
if (total >= k) {
cout << i << endl;
return 0;
} else if (total + sum[i + 1] >= k) {
cout << i + 1 << endl;
return 0;
}
while (cur >= 1 && pt <= n) {
int a = l[pt] / 2, b = l[pt] / 2;
if (l[pt] % 2 == 0) a -= 1;
pt += 1;
sum[i + 2] += 2;
sum[i + 2 + a]--;
sum[i + 2 + b]--;
cur -= 1;
total -= 1;
}
}
cout << -1 << endl;
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int count[4];
count[0] = 0;
count[1] = 0;
count[2] = 0;
count[3] = 0;
int position[4] = {0, 0, 0, 0};
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'R') position[0] = i % 4;
if (s[i] == 'B') position[1] = i % 4;
if (s[i] == 'Y') position[2] = i % 4;
if (s[i] == 'G') position[3] = i % 4;
}
for (int i = 0; i < s.length(); i++) {
if (s[i] == '!') {
if (i % 4 == position[0]) count[0]++;
if (i % 4 == position[1]) count[1]++;
if (i % 4 == position[2]) count[2]++;
if (i % 4 == position[3]) count[3]++;
}
}
cout << count[0] << " " << count[1] << " " << count[2] << " " << count[3]
<< endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n, m, k;
long long a[20000];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m >> k;
long long mn = inf;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (i % 2 == 1) {
mn = min(mn, a[i]);
}
}
if (n % 2 == 0) return cout << 0 << endl, 0;
if (m < (n + 1) / 2) return cout << 0 << endl, 0;
long long res = (n + 1) / 2;
long long cur = k * (m / res);
cout << min(mn, cur) << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using V = vector<T>;
template <typename T>
using VV = vector<V<T>>;
template <typename T>
istream& operator>>(istream& cin, V<T>& arr) {
for (T& val : arr) {
cin >> val;
}
return cin;
}
template <typename T>
ostream& operator<<(ostream& cout, V<T>& arr) {
for (T& val : arr) {
cout << val << " ";
}
return cout;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
long long p1, p2, p3, p4;
p1 = abs(y1 - (y2 - 1)) + abs(x1 - (x2 - 1));
p2 = abs(y1 - (y2 + 1)) + abs(x1 - (x2 - 1));
p3 = abs(y1 - (y2 + 1)) + abs(x1 - (x2 + 1));
p4 = abs(y1 - (y2 - 1)) + abs(x1 - (x2 + 1));
long long ans = p1 + p2;
ans = min(ans, p2 + p3);
ans = min(ans, p3 + p4);
ans = min(ans, p4 + p1);
ans += 6;
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const double pi = 3.1415926535897932, eps = 1e-6;
void chmax(int &x, int y) {
if (x < y) x = y;
}
void chmin(int &x, int y) {
if (x > y) x = y;
}
int T, n;
void solve() {
scanf("%d", &n);
double deg = 360.0 / (n + n);
double ans = 0;
for (int(i) = (1); (i) <= (n / 2); (i)++) {
double S = sin((deg * i - deg / 2.0) / 180.0 * pi);
ans += S;
}
double ans1 = 2 * ans + 1.0;
double rotate = deg / 4.0;
ans1 = ans1 * cos(rotate / 180.0 * pi);
printf("%.12lf\n", ans1);
}
int main() {
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char S[1000001];
int dp[1000001];
int ans, ansi;
int main() {
scanf("%s", S);
int N = strlen(S);
for (int i = 1; i < N; i++) {
if (S[i] == ')') {
if (dp[i - 1] > 0) {
if (S[i - dp[i - 1] - 1] == '(') {
dp[i] = dp[i - 1] + 2;
if (dp[i - dp[i - 1] - 2] > 0) dp[i] += dp[i - dp[i - 1] - 2];
}
} else {
if (S[i - 1] == '(') {
dp[i] = 2;
dp[i] += dp[i - 2];
}
}
}
}
for (int i = 0; i < N; i++) {
if (dp[i] == ans) {
ansi++;
} else if (dp[i] > ans) {
ans = dp[i];
ansi = 1;
}
}
if (ans == 0)
cout << 0 << ' ' << 1 << endl;
else
cout << ans << ' ' << ansi << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, ans;
cin >> n;
int arr[n + 1];
for (i = 1; i <= n; i++) {
cin >> arr[i];
}
sort(arr + 1, arr + 1 + n);
ans = n;
for (i = n / 2; i >= 1; i--) {
if (arr[i] * 2 <= arr[ans]) {
ans--;
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
int n, m;
int m1[60][60], m2[60][60];
int main() {
int i, j;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) scanf("%d", &m1[i][j]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) scanf("%d", &m2[i][j]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (m1[i][j] > m2[i][j]) {
int t1 = m1[i][j];
m1[i][j] = m2[i][j];
m2[i][j] = t1;
}
int fl = 1;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
if (i != 0 && (m1[i][j] <= m1[i - 1][j] || m2[i][j] <= m2[i - 1][j]))
fl = 0;
if (j != 0 && (m1[i][j] <= m1[i][j - 1] || m2[i][j] <= m2[i][j - 1]))
fl = 0;
}
if (fl)
printf("Possible\n");
else
printf("Impossible\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 30000;
long long f[maxn];
long long g[maxn];
int N, M, X[maxn], Y[maxn], P;
int Nextint() {
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
int x = 0;
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
void Sol(int x1, int y1, int x2, int y2) {
if (x1 == x2) {
if (x2 - x1 + y2 - y1 == N + M - 2) {
long long mx = 0;
for (int i = y1; i <= y2; i++) mx += (X[x1] + Y[i]) % P;
cout << mx << endl;
}
for (int i = y1; i < y2; i++) printf("S");
return;
}
int mid = (x1 + x2) / 2;
for (int i = y1; i <= y2; i++) f[i] = g[i] = 0;
for (int i = x1; i <= mid; i++) {
f[y1] += (X[i] + Y[y1]) % P;
for (int j = y1 + 1; j <= y2; j++) {
if (f[j] < f[j - 1]) f[j] = f[j - 1];
f[j] = f[j] + (X[i] + Y[j]) % P;
}
}
for (int i = x2; i > mid; i--) {
g[y2] += (X[i] + Y[y2]) % P;
for (int j = y2 - 1; j >= y1; j--) {
if (g[j] < g[j + 1]) g[j] = g[j + 1];
g[j] += (X[i] + Y[j]) % P;
}
}
long long mx = -1;
for (int i = y1; i <= y2; i++)
if (f[i] + g[i] > mx) mx = f[i] + g[i];
if (x2 - x1 + y2 - y1 == N + M - 2) cout << mx << endl;
for (int i = y1; i <= y2; i++)
if (f[i] + g[i] == mx) {
Sol(x1, y1, mid, i);
printf("C");
Sol(mid + 1, i, x2, y2);
return;
}
}
int main() {
scanf("%d%d%d", &N, &M, &P);
for (int i = 0; i < N; i++) X[i] = Nextint();
for (int i = 0; i < M; i++) Y[i] = Nextint();
Sol(0, 0, N - 1, M - 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char s[100001];
int count1[100001];
int count2[100001];
int count3[100001];
int main() {
scanf("%s", s);
int l1 = strlen(s);
for (int i = 0; i < l1; i++) {
count1[i + 1] = count1[i];
count2[i + 1] = count2[i];
count3[i + 1] = count3[i];
if (s[i] == 'x') {
count1[i + 1]++;
}
if (s[i] == 'y') {
count2[i + 1]++;
}
if (s[i] == 'z') {
count3[i + 1]++;
}
}
int q;
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
int l1 = (r - l + 1) / 3;
int mod1 = (r - l + 1) % 3;
int temp1 = count1[r] - count1[l - 1];
int temp2 = count2[r] - count2[l - 1];
int temp3 = count3[r] - count3[l - 1];
bool poss = false;
if ((r - l + 1) < 3) {
poss = true;
}
if (mod1 == 0) {
if (temp1 == temp2 && temp2 == temp3 && temp1 == l1) {
poss = true;
}
} else if (mod1 == 1) {
if (temp1 == l1 + 1 && temp2 == l1 && temp3 == l1) {
poss = true;
} else if (temp2 == l1 + 1 && temp1 == l1 && temp3 == l1) {
poss = true;
} else if (temp3 == l1 + 1 && temp2 == l1 && temp1 == l1) {
poss = true;
}
} else if (mod1 == 2) {
if (temp1 == l1 && temp2 == l1 + 1 && temp3 == l1 + 1) {
poss = true;
} else if (temp2 == l1 && temp1 == l1 + 1 && temp3 == l1 + 1) {
poss = true;
} else if (temp3 == l1 && temp2 == l1 + 1 && temp1 == l1 + 1) {
poss = true;
}
}
if (poss) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int func(int n) {
int k = 1;
while (k < n) {
k *= 2;
if (k > n) {
k /= 2;
break;
}
}
return k;
}
int main(int argc, char const *argv[]) {
int n, b, p, k = 1, n_games;
long long int bt = 0, pt = 0;
scanf("%d %d %d", &n, &b, &p);
pt = n * p;
if (n == 1) {
std::cout << 0 << " " << pt << std::endl;
return 0;
}
while (n > 1) {
k = func(n);
n_games = k / 2;
bt += (2 * b + 1) * n_games;
n = k / 2 + n - k;
k /= 2;
}
std::cout << bt << " " << pt << std::endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, x[5005], y[5005], m, d[5005][5005], a[5005];
bool dfs(int k, int t) {
if (a[k] != -1) return a[k] - t;
a[k] = t;
for (int i = 1; i <= n; i++)
if (d[k][i] > m && dfs(i, t ^ 1)) return 1;
return 0;
}
int ope() {
int ans = 1;
memset(a, -1, sizeof(a));
for (int i = 1; i <= n; i++) {
if (a[i] == -1) {
if (dfs(i, 0))
return 0;
else {
ans <<= 1;
if (ans >= 1000000007) ans -= 1000000007;
}
}
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", x + i, y + i);
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++)
d[i][j] = d[j][i] = abs(x[i] - x[j]) + abs(y[i] - y[j]);
}
int l = 0, r = 10002;
while (r - l > 1) {
m = (l + r) >> 1;
if (ope())
r = m;
else
l = m;
}
m = l;
if (!ope()) m = r;
printf("%d\n%d\n", m, ope());
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long r[1000005];
int main() {
long long n, m;
cin >> n >> m;
long long a[n + 1], b[n + 1];
long long c[m + 1], d[m + 1];
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i];
for (int i = 1; i <= m; i++) cin >> c[i] >> d[i];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (c[j] - a[i] >= 0)
r[c[j] - a[i]] = max(r[c[j] - a[i]], d[j] - b[i] + 1);
}
}
long long mx = 0, ans = 2000000;
for (int i = 1000000; i >= 0; i--) {
mx = max(mx, r[i]);
ans = min(ans, i + mx);
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, sum1 = 0, sum2 = 0, x = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
sum1 += a;
sum2 += b;
if ((a % 2) != (b % 2)) {
x++;
}
}
if (sum1 % 2 == 0 && sum2 % 2 == 0) {
cout << 0;
} else if (x % 2 == 0 && x > 0) {
cout << 1;
} else
cout << -1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k, count = 0, win = 0, lose = 0, draw = 0;
cin >> n;
string s;
for (int i = 0; i < n; i++) {
cin >> s >> win >> lose;
if (win >= 2400 && lose > win) {
return cout << "YES", 0;
}
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e4 + 20;
const int sq = 256;
const int qs = maxn / sq + 5;
const int maxb = 10;
vector<int> adj[maxn], tmp;
int x[maxn];
int a[maxn], ans[maxn][qs];
int l[maxn * maxb], r[maxn * maxb], t[maxn * maxb], mx[maxn * maxb];
int tah = 1, par[maxn], p[maxn], h[maxn];
bool is[maxn * maxb];
void add(int val, int val2) {
int pos = 0;
for (int i = 9; i >= -1; i--) {
t[pos]++;
mx[pos] = max(mx[pos], val2);
if (i < 0) return;
if (!l[pos]) {
l[pos] = tah++;
r[pos] = tah++;
t[l[pos]] = t[r[pos]] = 0;
mx[l[pos]] = mx[r[pos]] = -1;
l[l[pos]] = l[r[pos]] = 0;
}
if ((((val) >> (i)) & 1))
pos = r[pos];
else
pos = l[pos];
}
}
int get(int val, bool f) {
int pos = 0, res = 0;
for (int i = 9; i >= 0; i--) {
res = res * 2;
if ((((val) >> (i)) & 1)) {
if (t[l[pos]])
pos = l[pos];
else
pos = r[pos], res++;
} else {
if (t[r[pos]])
pos = r[pos], res++;
else
pos = l[pos];
}
}
return res * sq + mx[pos];
}
void dfs(int v) {
int u = v;
l[0] = 0;
tah = 1;
t[0] = 0;
mx[0] = -1;
for (int i = 0; i < sq; i++) {
add((a[u] ^ i) / sq, (a[u] ^ i) % sq);
if (u == p[u]) break;
u = p[u];
}
par[v] = u;
for (int i = 0; i < qs; i++) {
ans[v][i] = get(i, 0) ^ (sq * i);
int u = v, mxx = 0;
for (int j = 0; j < sq; j++) {
mxx = max(mxx, (a[u] ^ (j + sq * i)));
if (u == p[u]) break;
u = p[u];
}
}
for (auto u : adj[v])
if (u != p[v]) {
p[u] = v;
h[u] = h[v] + 1;
dfs(u);
}
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
adj[--a].push_back(--b);
adj[b].push_back(a);
}
dfs(0);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
int res = 0, now = 0, d = 0;
while (h[par[v]] > h[u]) {
res = max(res, ans[v][now]);
now++;
v = par[v];
}
d = now * sq;
while (h[v] > h[u]) {
res = max(res, a[v] ^ d);
d++;
v = p[v];
}
res = max(res, a[u] ^ d);
printf("%d\n", res);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 510;
int n, m;
string f[MAXN];
int dp[MAXN][26][26];
char g[MAXN][2];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> f[i];
for (int i = 0; i < n; i++) {
for (int a = 0; a < 26; a++)
for (int b = 0; b < 26; b++)
if (a != b) {
int ans = 0;
for (int j = 0; j < m; j++)
if ((j % 2 == 0 && f[i][j] - 'a' != a) ||
(j % 2 == 1 && f[i][j] - 'a' != b))
ans++;
if (i > 0) {
int mini = n * m;
for (int c = 0; c < 26; c++)
for (int d = 0; d < 26; d++)
if (c != d && c != a && d != b && dp[i - 1][c][d] < mini)
mini = dp[i - 1][c][d];
ans += mini;
}
dp[i][a][b] = ans;
}
}
int mini = dp[n - 1][0][1];
for (int a = 0; a < 26; a++)
for (int b = 0; b < 26; b++)
if (a != b && dp[n - 1][a][b] < mini) mini = dp[n - 1][a][b];
cout << mini << endl;
int pa = -1, pb = -1;
for (int i = n - 1; i > -1; i--) {
int mini = n * m, mina = -1, minb = -1;
for (int a = 0; a < 26; a++)
for (int b = 0; b < 26; b++)
if (a != b && a != pa && b != pb && dp[i][a][b] < mini) {
mini = dp[i][a][b];
mina = a;
minb = b;
}
pa = mina;
pb = minb;
g[i][0] = char('a' + pa);
g[i][1] = char('a' + pb);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << g[i][j % 2];
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 505;
int a[maxn][maxn], dp[maxn][maxn], sum[maxn][maxn];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
dp[i][j] = a[i][j];
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + a[i][j];
}
}
int ans = -1e9;
for (int size = 3; size <= n && size <= m; size += 2) {
for (int i = size, ii = 1; i <= n; i++, ii++) {
for (int j = size, jj = 1; j <= m; j++, jj++) {
dp[ii][jj] = sum[i][j] - sum[ii - 1][j] - sum[i][jj - 1] +
sum[ii - 1][jj - 1] - dp[ii + 1][jj + 1] - a[ii + 1][jj];
if (ans < dp[ii][jj]) ans = dp[ii][jj];
}
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long s, xo;
cin >> s >> xo;
long long an = (s - xo) / 2;
if (an < 0 || an * 2 != s - xo || (an & xo) != 0) {
cout << "0\n";
return 0;
}
long long x = xo;
long long ans = 0;
int kol = 0;
while (x) {
kol += (x & 1);
x /= 2;
}
ans = 1LL << kol;
if (an == 0) {
ans -= 2;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3003;
int n, m, k, vis[maxN], low[maxN], status[maxN], cnt;
vector<int> adj[maxN], dfsStack;
bool reach[maxN];
int query[maxN][maxN], k_th[maxN * maxN], ans[maxN * maxN];
vector<int> Q, link;
void dfs(int sta, int u) {
vis[u] = ++cnt;
low[u] = vis[u] + 1;
status[u] = 1;
dfsStack.push_back(u);
if (reach[u] && query[sta][u]) {
for (int ind = query[sta][u]; ind != -1; ind = link[ind]) {
if (k_th[Q[ind]] <= dfsStack.size())
ans[Q[ind]] = dfsStack[k_th[Q[ind]] - 1];
}
}
for (int v : adj[u]) {
if (status[v]) {
if (status[v] == 1) low[u] = min(low[u], vis[v]);
continue;
}
if (low[u] <= vis[u] || !reach[u]) reach[v] = false;
dfs(sta, v);
low[u] = min(low[u], low[v]);
}
status[u] = 2;
dfsStack.pop_back();
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
int u, v;
for (int i = 0; i < m; ++i) {
cin >> u >> v;
adj[u].push_back(v);
}
for (int u = 1, _b = n; u <= _b; ++u) sort(adj[u].begin(), adj[u].end());
int s, t;
Q.push_back(0), link.push_back(0);
for (int i = 0; i < k; ++i) {
cin >> s >> t >> k_th[i];
if (!query[s][t]) {
query[s][t] = (int)Q.size();
Q.push_back(i);
link.push_back(-1);
} else {
link.push_back(query[s][t]);
query[s][t] = (int)Q.size();
Q.push_back(i);
}
ans[i] = -1;
}
for (int u = 1, _b = n; u <= _b; ++u) {
cnt = 0;
for (int v = 1, _b = n; v <= _b; ++v)
low[v] = status[v] = vis[v] = 0, reach[v] = true;
dfsStack.clear();
dfs(u, u);
}
for (int i = 0; i < k; ++i) cout << ans[i] << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long mod = (int)1e9 + 7;
const int N = 1e6 + 100;
int n;
int op[N];
int zz[N];
int val[N];
char s[10];
vector<int> son[N];
void dfs(int u) {
for (int i = 0; i < son[u].size(); i++) dfs(son[u][i]);
if (op[u] == 1) {
int x = son[u][0], y = son[u][1];
val[u] = val[x] & val[y];
if (val[x] == 0 && val[y] == 1) zz[x] = 1;
if (val[x] == 1 && val[y] == 1) zz[x] = zz[y] = 1;
if (val[x] == 1 && val[y] == 0) zz[y] = 1;
} else if (op[u] == 2) {
int x = son[u][0], y = son[u][1];
val[u] = val[x] ^ val[y];
zz[x] = zz[y] = 1;
} else if (op[u] == 3) {
int x = son[u][0];
val[u] = 1 ^ val[x];
zz[x] = 1;
} else if (op[u] == 5) {
int x = son[u][0], y = son[u][1];
val[u] = val[x] | val[y];
if (val[x] == 1 && val[y] == 0) zz[x] = 1;
if (val[x] == 0 && val[y] == 1) zz[y] = 1;
if (val[x] == 0 && val[y] == 0) zz[x] = zz[y] = 1;
}
}
void dfs2(int u, int flag) {
zz[u] &= flag;
for (int i = 0; i < son[u].size(); i++) dfs2(son[u][i], zz[u]);
}
int main() {
scanf("%d", &n);
int u, v;
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
if (s[1] == 'A') {
scanf("%d%d", &u, &v);
son[i].push_back(u);
son[i].push_back(v);
op[i] = 1;
} else if (s[1] == 'X') {
scanf("%d%d", &u, &v);
son[i].push_back(u);
son[i].push_back(v);
op[i] = 2;
} else if (s[1] == 'N') {
scanf("%d", &u);
son[i].push_back(u);
op[i] = 3;
} else if (s[1] == 'I') {
op[i] = 4;
scanf("%d", &val[i]);
} else if (s[1] == 'O') {
op[i] = 5;
scanf("%d%d", &u, &v);
son[i].push_back(u);
son[i].push_back(v);
}
}
dfs(1);
zz[1] = 1;
dfs2(1, 1);
int ans[2];
ans[0] = val[1];
ans[1] = val[1] ^ 1;
for (int i = 1; i <= n; i++) {
if (op[i] == 4) {
printf("%d", ans[zz[i]]);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 500 + 5;
const long long INF = 1LL << 61;
const int mod = 1e9 + 7;
vector<vector<long long> > mat_mul(vector<vector<long long> > &A,
vector<vector<long long> > &B) {
vector<vector<long long> > C(A.size(), vector<long long>(B[0].size()));
for (int i = 0; i < A.size(); i++) {
for (int j = 0; j < B[0].size(); j++) {
C[i][j] = -INF;
for (int k = 0; k < B.size(); k++) {
C[i][j] = max(C[i][j], A[i][k] + B[k][j]);
}
}
}
return C;
}
vector<vector<long long> > mat_pow(vector<vector<long long> > A, long long n) {
if (n == 1) return A;
vector<vector<long long> > B = A;
n--;
while (n) {
if (n & 1) B = mat_mul(B, A);
A = mat_mul(A, A);
n >>= 1;
}
return B;
}
void mat_fill(vector<vector<long long> > &A, long long val) {
for (int i = 0; i < A.size(); i++) {
for (int j = 0; j < A[0].size(); j++) {
A[i][j] = val;
}
}
}
struct AC_machine {
int rear, root;
int Next[MX][26], Fail[MX], End[MX];
void Init() {
rear = 0;
root = New();
}
int New() {
rear++;
End[rear] = 0;
for (int i = 0; i < 26; i++) {
Next[rear][i] = -1;
}
return rear;
}
void Add(char *A, int x) {
int n = strlen(A), now = root;
for (int i = 0; i < n; i++) {
int id = A[i] - 'a';
if (Next[now][id] == -1) {
Next[now][id] = New();
}
now = Next[now][id];
}
End[now] += x;
}
vector<vector<long long> > Build() {
queue<int> Q;
Fail[root] = root;
for (int i = 0; i < 26; i++) {
if (Next[root][i] == -1) {
Next[root][i] = root;
} else {
Fail[Next[root][i]] = root;
Q.push(Next[root][i]);
}
}
while (!Q.empty()) {
int u = Q.front();
Q.pop();
End[u] += End[Fail[u]];
for (int i = 0; i < 26; i++) {
if (Next[u][i] == -1) {
Next[u][i] = Next[Fail[u]][i];
} else {
Fail[Next[u][i]] = Next[Fail[u]][i];
Q.push(Next[u][i]);
}
}
}
vector<vector<long long> > res(rear, vector<long long>(rear));
mat_fill(res, -INF);
for (int i = 1; i <= rear; i++) {
for (int j = 0; j < 26; j++) {
int ch = Next[i][j];
res[ch - 1][i - 1] = End[ch];
}
}
return res;
}
} AC;
int cost[MX];
char word[MX];
int main() {
AC.Init();
int n;
long long len;
scanf("%d%I64d", &n, &len);
for (int i = 1; i <= n; i++) {
scanf("%d", &cost[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%s", word);
AC.Add(word, cost[i]);
}
int rear = AC.rear;
vector<vector<long long> > A = AC.Build();
A = mat_pow(A, len);
long long ans = 0;
for (int i = 0; i < rear; i++) {
ans = max(ans, A[i][0]);
}
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200050;
int falen[maxn], siz[maxn], deg[maxn];
int us[maxn], vs[maxn], wss[maxn];
vector<int> g[maxn], len[maxn];
void dfs(int x, int fa, int fal) {
falen[x] = fal;
siz[x] = 1;
for (int i = 0; i < g[x].size(); i++) {
int y = g[x][i], w = len[x][i];
if (y != fa) {
dfs(y, x, w);
siz[x] += siz[y];
}
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long mn = 0, mx = 0;
int n;
scanf("%d", &n);
n *= 2;
for (int i = 1; i <= n; i++) {
g[i].clear();
len[i].clear();
falen[i] = siz[i] = deg[i] = 0;
}
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &us[i], &vs[i], &wss[i]);
int u = us[i], v = vs[i], w = wss[i];
g[u].push_back(v);
len[u].push_back(w);
g[v].push_back(u);
len[v].push_back(w);
deg[u]++;
deg[v]++;
mn += wss[i];
}
dfs(1, 0, 0);
for (int i = 1; i < n; i++) {
if (siz[i] % 2 == 0) mn -= falen[i];
mx += (long long)min(siz[i], n - siz[i]) * falen[i];
}
if (siz[n] % 2 == 0) mn -= falen[n];
mx += (long long)min(siz[n], n - siz[n]) * falen[n];
printf("%lld %lld\n", mn, mx);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[1010];
long long st[10] = {1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1989};
long long ten[15];
int main() {
ten[0] = 1;
for (int i = 1; i <= 12; i++) ten[i] = ten[i - 1] * 10;
int Tcase;
scanf("%d", &Tcase);
for (int T = 1; T <= Tcase; T++) {
scanf("%s", s);
long long n = strlen(s);
long long pos = n - 2, last = st[s[n - 1] - '0'], bit = 2,
now = s[n - 1] - '0', tmp;
while (s[pos] >= '0' && s[pos] <= '9') {
now = now + (s[pos] - '0') * ten[bit - 1];
tmp = now;
while (tmp <= last) {
tmp += ten[bit];
}
last = tmp;
pos--, bit++;
}
printf("%I64d\n", last);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for(int i = 0; i < int(n); i++)
void printV(vector<long long> a){ forn(i, a.size()) cout << a[i] << " "; cout << endl; }
int gcd (int a, int b) {
while (b) {
a %= b;
swap (a, b);
}
return a;
}
vector<int> arr(4*2*100000 + 10);
void build (int a[], int v, int tl, int tr) {
if (tl == tr)
arr[v] = a[tl];
else {
int tm = (tl + tr) / 2;
build (a, v * 2, tl, tm);
build (a, v * 2 + 1, tm + 1, tr);
arr[v] = gcd(arr[v*2], arr[v*2+1]);
}
}
int sum (int v, int tl, int tr, int l, int r) {
if (l > r)
return 0;
if (l == tl && r == tr)
return arr[v];
int tm = (tl + tr) / 2;
return gcd(sum (v*2, tl, tm, l, min(r, tm)),
sum (v*2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
bool check(int* a, int n){
for(int i = 1; i < n; ++i)
if(a[0] != a[i])
return false;
return true;
}
bool solv(int n, int k){
forn(i, n){
int x;
if(i + k < n)
x = sum(1, 0, n - 1, i, i + k);
else
x = gcd(sum(1, 0, n - 1, i, n - 1), sum(1, 0, n - 1, 0, k - (n - i)));
if(x != 1)
return false;
}
return true;
}
int main(){
int t;
cin >> t;
forn(tt, t){
int n;
cin >> n;
int a[n];
forn(i, n)
cin >> a[i];
int x = a[0];
for(int i = 1; i < n; ++i)
x = gcd(x, a[i]);
forn(i, n){
a[i] /= x;
//cout << a[i] << endl;
}
build(a, 1, 0, n - 1);
if(check(a, n)){
cout << "0\n";
continue;
}
int l = 0, r = n, k = 1;
while(l < r - 1){
k = (l + r)/2;
if(solv(n, k))
r = k;
else
l = k;
}
cout << r << endl;
}
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
int t;
int arr[10];
int main() {
cin >> t;
for (int zz = 0; zz < 1000; zz++)
;
for (int zz = 0; zz < 1000; zz++)
;
while (t--) {
int sum = 0;
for (int zz = 0; zz < 1000; zz++)
;
for (int zz = 0; zz < 1000; zz++)
;
bool f = false;
for (int zz = 0; zz < 1000; zz++)
;
cin >> arr[1] >> arr[2] >> arr[3] >> arr[4];
for (int i = 1; i <= 4; ++i) {
sum += arr[i];
}
if (sum % 3 != 0) {
f = true;
} else {
int ok = sum / 3;
for (int i = 1; i <= 3; ++i) {
if (arr[i] > ok) {
f = true;
}
}
}
for (int zz = 0; zz < 1000; zz++)
;
if (f == true) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
for (int zz = 0; zz < 1000; zz++)
;
for (int zz = 0; zz < 1000; zz++)
;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1E9;
const int MAXV = 200010;
int c, n;
vector<int> in;
int bef[MAXV];
int how[MAXV];
bool Simulate(int add) {
int v = c, last = oo;
while (true) {
if (v == 0) return false;
int a = bef[min(v, last - 1)];
if (add <= v && a < add)
v -= add, add = oo;
else {
if (a == -1) return true;
int take = min(how[a], v / a);
v -= take * a;
last = a;
}
}
}
int main() {
scanf("%d%d", &c, &n);
in.resize(n);
for (int& v : in) scanf("%d", &v);
memset(bef, -1, sizeof bef);
for (int i = 0; i < n; ++i) bef[in[i]] = in[i], ++how[in[i]];
for (int i = 1; i < MAXV; ++i)
if (bef[i] == -1) bef[i] = bef[i - 1];
int ans = oo;
for (int i = 1; i < c; ++i)
if (Simulate(i)) {
ans = i;
break;
}
if (ans == oo)
puts("Greed is good");
else
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int mmax, last;
vector<int> v;
map<int, int> m;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
m[x] = m[x - 1] + 1;
if (m[x] > mmax) {
mmax = m[x];
last = x;
}
}
cout << mmax << endl;
int x = last - mmax + 1;
for (int i = 0; i < v.size(); i++) {
if (v[i] == x) {
cout << i + 1 << " ";
x++;
}
if (x > last) {
break;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long l, r, sum;
vector<long long> vec;
void bt(long long x) {
if (x > 1e10) return;
if (x >= l) vec.push_back(x);
bt(x * 10 + 4);
bt(x * 10 + 7);
}
int main() {
cin >> l >> r;
bt(0);
sort(vec.begin(), vec.end());
for (int i = 0; i < vec.size(); i++) {
if (l > r) break;
if (vec[i] >= l) sum += min((r - l + 1), (vec[i] - l + 1)) * vec[i];
l = vec[i] + 1;
}
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long min(long long a, long long b) { return (a < b) ? a : b; }
long long max(long long a, long long b) { return (a > b) ? a : b; }
long long fp(long long a, long long b) {
if (b == 0) return 1;
long long x = fp(a, b / 2);
x = (x * x) % mod;
if (b & 1) x = (x * a) % mod;
return x;
}
auto random_add = [] {
char *p = new char;
delete p;
return uint64_t(p);
};
const uint64_t SEED =
chrono::steady_clock::now().time_since_epoch().count() * (random_add() | 1);
mt19937_64 rng(SEED);
const long long N = 2e5 + 5;
vector<array<long long, 2>> v[N];
map<long long, vector<long long>> ans;
void dfs(long long node, long long p, long long last) {
long long x = 1;
for (auto i : v[node]) {
if (i[0] == p) continue;
if (x == last) x++;
ans[x].push_back(i[1]);
dfs(i[0], node, x);
x++;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, x, y;
cin >> n;
for (long long i = 1; i < n; i++) {
cin >> x >> y;
v[x].push_back({y, i});
v[y].push_back({x, i});
}
dfs(1, -1, -1);
cout << ans.size() << "\n";
for (auto i : ans) {
cout << i.second.size() << " ";
for (auto j : i.second) cout << j << " ";
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double l, d, v, g, r;
enum state { red, green };
double wait(double t) {
state now = green;
while (t >= 0) {
if (green == now) {
if (t < g)
return 0.0;
else {
now = red;
t -= g;
}
}
if (red == now) {
if (t < r)
return r - t;
else {
now = green;
t -= r;
}
}
}
}
int main() {
cin >> l >> d >> v >> g >> r;
double answer = (d / v) + wait(d / v) + (l - d) / v;
printf("%.10f\n", answer);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x = 0, y = 0, f1 = 1;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
if (arr[i] == 29) x++;
if ((i - 1) >= 0 && arr[i - 1] == 30 && arr[i] == 30) {
f1 = 0;
y++;
}
if ((i - 2) >= 0 && arr[i - 2] == arr[i] && arr[i - 1] == arr[i]) {
f1 = 0;
y++;
}
}
if (x >= 2) f1 = 0;
int mon[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int mark[12] = {1, 3, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1};
if (f1 == 0) {
cout << "No" << endl;
return 0;
}
for (int i = 0; i < 12; i++) {
int j = 0, k = i;
while (j < n) {
if (arr[j] != 28 && arr[j] != 29 && arr[j] != mon[k]) {
break;
} else if ((arr[j] == 28 || arr[j] == 29) && mon[k] != 28)
break;
j++;
k = (k + 1) % 12;
}
if (j == n) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class heap_cmp {
public:
bool operator()(pair<int, int> &a, pair<int, int> &b) const {
return a.first != b.first ? (a.first < b.first) : (a.second >= b.second);
}
};
int64_t calc_sum(vector<int>::iterator start, vector<int>::iterator end,
int n_marks) {
int64_t result = 0;
for (auto ptr = start; ptr < end; ++ptr) {
result += n_marks - *ptr;
}
return result;
}
int64_t run(vector<int> &ary) {
int n = ary.size();
int n_marks = 0;
int64_t ans = 0;
priority_queue<pair<int, int>, vector<pair<int, int>>, heap_cmp> pqueue;
for (int i = 0; i < n; ++i) {
n_marks = max(n_marks, ary[i]);
pqueue.push({ary[i], i});
}
int ed = n;
for (; n_marks > 0; --n_marks) {
for (; !pqueue.empty() &&
(ed <= pqueue.top().second || n_marks < pqueue.top().first);
pqueue.pop()) {
continue;
}
if (pqueue.empty()) break;
auto cur = pqueue.top();
if (n_marks == cur.first) {
ans += calc_sum(ary.begin() + cur.second, ary.begin() + ed, n_marks);
ed = cur.second;
} else {
ans += calc_sum(ary.begin() + (ed - 1), ary.begin() + ed, n_marks);
ed--;
}
}
return ans;
}
char input(vector<int> &ary) {
int n, p;
int rc = scanf("%d", &n);
ary = vector<int>();
if (rc != EOF) {
for (int i = 0; i < n; ++i) {
scanf("%d", &p);
ary.push_back(p);
}
}
return rc;
}
int main() {
vector<int> ary;
while (input(ary) > 0) {
printf("%" PRId64 "\n", run(ary));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long arr[] = {1,
2,
4,
8,
16,
32,
64,
128,
256,
512,
1024,
2048,
4096,
8192,
16384,
32768,
65536,
131072,
262144,
524288,
1048576,
2097152,
4194304,
8388608,
16777216,
33554432,
67108864,
134217728,
268435456,
536870912,
1073741824,
2147483648,
4294967296,
8589934592,
17179869184,
34359738368,
68719476736,
137438953472,
274877906944,
549755813888,
1099511627776,
2199023255552,
4398046511104,
8796093022208,
17592186044416,
35184372088832,
70368744177664,
140737488355328,
281474976710656,
562949953421312,
1125899906842624};
int main() {
long long int n, k, i, st, r;
cin >> n >> k;
if (k % 2 == 1)
cout << 1 << endl;
else {
for (i = 2; i <= n; i++) {
r = arr[i];
st = arr[i - 1];
if ((k + st) % r == 0) {
cout << i << endl;
break;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
long long int dx[] = {0, 1, 0, -1, -1, 1, -1, 1};
long long int dy[] = {-1, 0, 1, 0, -1, 1, 1, -1};
const long long int MAXN = 2e6 + 5;
const long long int N = 2e6 + 5;
long long int n, m;
long long int binpow(long long int n, long long int p) {
long long int res = 1;
while (p > 0) {
if (p & 1) res = res * n;
n = n * n;
p >>= 1;
}
return res;
}
long long int power(long long int n, long long int p) {
long long int res = 1;
n %= 1000000007;
while (p > 0) {
if (p & 1) res = (res * n) % 1000000007;
n = (n * n) % 1000000007;
p >>= 1;
}
return res;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2);
}
long long int fact[MAXN], inv[MAXN], invfact[MAXN];
void initFactorials() {
fact[0] = 1;
for (long long int i = 1; i < MAXN; i++) {
fact[i] = (fact[i - 1] * i * 1LL) % 1000000007;
}
inv[1] = 1;
for (long long int i = 2; i < MAXN; i++)
inv[i] = inv[1000000007 % i] * (1000000007 - 1000000007 / i) % 1000000007;
invfact[0] = 1;
for (long long int i = 1; i < MAXN; i++)
invfact[i] = (invfact[i - 1] * inv[i]) % 1000000007;
}
long long int nCrMod(long long int n, long long int r) {
if (n < r) return 0;
if (r == 0) return 1;
long long int num = fact[n], den = (fact[r] * fact[n - r]) % 1000000007;
long long int inv = modInverse(den, 1000000007);
return (num * inv) % 1000000007;
}
void solve() {
long long int x, y, z;
cin >> n;
set<long long int> st;
for (long long int i = 0; i < n; i++) cin >> x, st.insert(x);
auto it = st.begin();
x = *it;
for (long long int i : st) {
if (i % x != 0) {
cout << -1 << "\n";
return;
}
}
cout << x;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char ch, ch2;
int n, mx, res, cnt, cnt2, t;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
cin >> ch2;
cnt = 1;
cnt2 = 0;
mx = t = 0;
res = 0;
for (int i = 2; i <= n; i++) {
cin >> ch;
if (ch == ch2) {
cnt++;
} else {
if (cnt >= 3) mx = 2;
if (cnt >= 2) cnt2++;
cnt = 1;
res++;
}
ch2 = ch;
}
if (cnt >= 3) mx = 2;
if (cnt >= 2) cnt2++;
res++;
if (cnt2 > 1)
t = 2;
else if (cnt2 == 1)
t = 1;
else
t = 0;
if (t > mx) mx = t;
res += mx;
cout << res << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000010, mod = 998244353;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
vector<int> g[N];
int n, m;
int st[N], cnt, tot;
bool dfs(int u, int state) {
st[u] = state;
tot++;
cnt += (state == 1);
for (auto e : g[u]) {
if (st[e] == -1) {
if (!dfs(e, state ^ 1)) return false;
} else if (st[e] == st[u]) {
return false;
}
}
return true;
}
int qmi(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = (long long)res * a % mod;
a = (long long)a * a % mod;
b >>= 1;
}
return res;
}
void solve() {
n = read(), m = read();
for (int i = 1; i <= n; ++i) g[i].clear(), st[i] = -1;
for (int i = 1; i <= m; ++i) {
int a = read(), b = read();
g[a].push_back(b);
g[b].push_back(a);
}
int ans = 1;
for (int i = 1; i <= n; ++i) {
if (st[i] != -1) continue;
cnt = tot = 0;
if (!dfs(i, 0)) {
ans = 0;
break;
}
ans = (long long)ans * ((qmi(2, cnt) + qmi(2, tot - cnt)) % mod) % mod;
}
cout << ans << '\n';
}
int main() {
int T = read();
while (T--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 5;
vector<pair<int, long long int> > adj[maxn];
int idx, id[maxn][2];
void build(int node, int l, int r, int type) {
id[node][type] = idx++;
if (l == r) {
if (type == 0) {
adj[id[node][type]].push_back(make_pair(l, 0));
} else {
adj[l].push_back(make_pair(id[node][type], 0));
}
return;
}
int mid = (l + r) / 2;
build(2 * node, l, mid, type);
build(2 * node + 1, mid + 1, r, type);
if (type == 0) {
adj[id[node][type]].push_back(make_pair(id[2 * node][type], 0));
adj[id[node][type]].push_back(make_pair(id[2 * node + 1][type], 0));
} else {
adj[id[2 * node][type]].push_back(make_pair(id[node][type], 0));
adj[id[2 * node + 1][type]].push_back(make_pair(id[node][type], 0));
}
return;
}
vector<int> vs;
void query(int node, int l, int r, int s, int e, int type) {
if (s > r || e < l) return;
if (s <= l && r <= e) {
vs.push_back(id[node][type]);
return;
}
int mid = (l + r) / 2;
query(2 * node, l, mid, s, e, type);
query(2 * node + 1, mid + 1, r, s, e, type);
return;
}
long long int dp[maxn];
bool visit[maxn];
void dijkstra(int s) {
dp[s] = 0;
priority_queue<pair<long long int, int>, vector<pair<long long int, int> >,
greater<pair<long long int, int> > >
q;
q.push(make_pair(dp[s], s));
while (!q.empty()) {
int i = q.top().second;
q.pop();
if (visit[i]) continue;
visit[i] = 1;
for (int j = 0; j < int(adj[i].size()); j++) {
int x = adj[i][j].first;
long long int w = adj[i][j].second;
if (dp[x] > dp[i] + w) {
dp[x] = dp[i] + w;
q.push(make_pair(dp[x], x));
}
}
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, q, s, type, u, v, l, r;
long long int w;
cin >> n >> q >> s;
for (int i = 1; i < maxn; i++) dp[i] = 1e17;
idx = n + 1;
build(1, 1, n, 0);
build(1, 1, n, 1);
while (q--) {
cin >> type;
if (type == 1) {
cin >> u >> v >> w;
adj[u].push_back(make_pair(v, w));
} else if (type == 2) {
cin >> u >> l >> r >> w;
vs.clear();
query(1, 1, n, l, r, 0);
for (int i = 0; i < int(vs.size()); i++) {
adj[u].push_back(make_pair(vs[i], w));
}
} else {
cin >> u >> l >> r >> w;
vs.clear();
query(1, 1, n, l, r, 1);
for (int i = 0; i < int(vs.size()); i++) {
adj[vs[i]].push_back(make_pair(u, w));
}
}
}
dijkstra(s);
for (int i = 1; i <= n; i++) {
if (dp[i] > 1e15) dp[i] = -1;
cout << dp[i] << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using llong = long long;
char buf[222222];
int getint() {
int n;
scanf("%d", &n);
return n;
}
long long qpow(long long a, long long b, long long c) {
long long p = 1;
while (b) {
if (b & 1) p = p * a % c;
a = a * a % c;
b >>= 1;
}
return p;
}
int main() {
scanf("%s", buf);
string s(buf);
llong m = getint();
llong r = 0;
for (int i = 0; i < s.size(); i++) {
r = r * 10 + (s[i] - '0');
r %= m;
}
llong ans = r;
for (int i = 0; i + 1 < s.size(); i++) {
r += m - (s[i] - '0') * qpow(10, s.size() - 1, m) % m;
r *= 10;
r += s[i] - '0';
r %= m;
if (s[i + 1] != '0') {
ans = min(ans, r);
}
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const double eps = 1e-8;
const int N = 1e5 + 10;
int t, n;
double ans, a;
double cal(double b) {
double rs = 0;
for (double i = b; i <= pi / 2; i += a) {
rs += cos(i);
}
return rs;
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
ans = 1e5;
a = pi / (double)n;
for (double i = 0, p; i < a; i += 0.00004) {
p = i;
while (p < pi / 2 && abs(pi / 2 - p) > eps) p += a;
p -= pi / 2;
ans = min(max(cal(i) + cal(a - i), cal(a - p) + cal(p)), ans);
}
printf("%.8lf\n", ans);
}
}
| 3 |
#include <bits/stdc++.h>
std::vector<std::pair<int, int>> v;
int t, n, nxt[100010], nt[100010];
std::vector<std::pair<int, int>> query(
std::vector<std::pair<int, int>> const &v) {
int k = v.size();
if (k == 0) return std::vector<std::pair<int, int>>();
printf("Q %d ", k);
for (auto const &u : v) printf("%d %d ", u.first, u.second);
puts("");
fflush(stdout);
static char s[100010];
scanf("%s", s);
std::vector<std::pair<int, int>> d;
for (int i = 0; i < k; i++)
if (s[i] == '1') d.emplace_back(v[i]);
return d;
}
int find(int x, int *f) {
while (x != f[x]) x = f[x] = f[f[x]];
return x;
}
std::vector<int> nw;
int col[100010];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) nxt[i] = i, nt[i] = 0;
v.clear();
for (int i = 1; i + 1 <= n; i += 2) v.emplace_back(i, i + 1);
v = query(v);
for (auto const &u : v) nxt[u.first] = u.second;
v.clear();
for (int i = 2; i + 1 <= n; i += 2) v.emplace_back(i, i + 1);
v = query(v);
for (auto const &u : v) nxt[u.first] = u.second;
for (int i = 1; i <= n; i++)
if (nxt[i] != i) nxt[i] = find(i, nxt);
nw.clear();
for (int i = 1; i <= n; i = nxt[i] + 1) nw.push_back(i);
if (nw.size() == 1U) {
printf("A %d 0 0\n", n);
for (int i = 1; i <= n; i++) printf("%d ", i);
puts("");
puts("");
puts("");
fflush(stdout);
continue;
}
v.clear();
for (unsigned i = 0; i + 2 < nw.size(); i++)
if (i % 4 < 2) v.emplace_back(nw[i], nw[i + 2]);
v = query(v);
for (auto const &u : v) nt[u.second] = 1;
v.clear();
for (unsigned i = 0; i + 2 < nw.size(); i++)
if (i % 4 > 1) v.emplace_back(nw[i], nw[i + 2]);
v = query(v);
for (auto const &u : v) nt[u.second] = 1;
std::vector<int> a[3];
a[0].push_back(0);
a[1].push_back(1);
col[0] = 0, col[1] = 1;
for (unsigned i = 2; i < nw.size(); i++)
if (nt[nw[i]])
col[i] = col[i - 2], a[col[i]].push_back(i);
else
col[i] = 3 - col[i - 1] - col[i - 2], a[col[i]].push_back(i);
int sum[3] = {0, 0, 0};
for (int i = 0; i < 3; i++)
for (auto const &p : a[i]) sum[i] += nxt[nw[p]] - nw[p] + 1;
printf("A %d %d %d\n", sum[0], sum[1], sum[2]);
for (int i = 0; i < 3; i++, puts(""))
for (auto const &p : a[i])
for (int i = nw[p]; i <= nxt[nw[p]]; i++) printf("%d ", i);
fflush(stdout);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bool sortinrev(const pair<long long, long long>& a,
const pair<long long, long long>& b) {
return (a.second > b.second);
}
int main() {
long long n;
cin >> n;
long long x, y;
vector<pair<long long, long long> > vec;
vector<pair<long long, long long> > vec1;
long long count = 0;
for (int i = 0; i < n; i++) {
cin >> x >> y;
vec.push_back(make_pair(x, y));
vec1.push_back(make_pair(x, y));
}
sort(vec.begin(), vec.end());
long long max = vec[0].second;
for (int i = 1; i < n; i++) {
if (vec[i].second < max)
count++;
else
max = vec[i].second;
}
cout << count << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C &a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C &a4, C b4) {
a4 = max(a4, b4);
}
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const long long MAX = 3e5 + 100;
long long n, t[MAX];
long long dp[MAX][2];
vector<long long> res;
bool ruszone[MAX];
long long RES = 0;
void rusz(long long i) {
if (i < 0 || i >= n - 1 || ruszone[i]) return;
ruszone[i] = 1;
long long pom = min(t[i], t[i + 1]);
RES += pom;
if (pom) {
res.push_back(i + 1);
t[i] -= pom;
t[i + 1] -= pom;
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
if (0) cout << fixed << setprecision(6);
cin >> n;
for (long long i = (0); i <= ((long long)(n)-1); i++) cin >> t[i];
for (long long i = (0); i <= ((long long)(n)-1); i++)
dp[i + 1][0] = dp[i + 1][1] = -1e18;
for (long long i = (0); i <= ((long long)(n)-1); i++) {
maxi(dp[i + 1][0], max(dp[i][0], dp[i][1]) - t[i]);
maxi(dp[i + 1][1], dp[i][0] + t[i]);
if (i > 1) {
if (t[i - 2] >= t[i - 1]) {
maxi(dp[i + 1][1], dp[i - 2][1] - t[i - 2] + t[i] + t[i - 1]);
}
if (t[i] >= t[i - 1]) {
maxi(dp[i + 1][0], dp[i - 1][1] + t[i - 1] - t[i]);
}
}
}
long long ak = 0;
if (dp[n][1] > dp[n][0]) {
ak = 1;
}
(dp[n][ak]);
vector<long long> xx;
for (long long i = n - 1; i > 0; i--) {
if (ak == 0 && dp[i + 1][0] == dp[i][0] - t[i]) {
xx.push_back(i - 2);
xx.push_back(i);
} else {
if (i > 1) {
if (ak == 1 && t[i - 2] >= t[i - 1] &&
dp[i + 1][1] == dp[i - 2][1] - t[i - 2] + t[i] + t[i - 1]) {
xx.push_back(i - 2);
i -= 2;
ak = !ak;
} else if (ak == 0 && t[i] >= t[i - 1] &&
dp[i + 1][0] == dp[i - 1][1] + t[i - 1] - t[i]) {
xx.push_back(i - 1);
i--;
}
}
ak = !ak;
}
}
for (long long el : xx) {
rusz(el);
}
for (long long i = (0); i <= ((long long)(n - 1) - 1); i++) {
rusz(i);
}
cout << ((long long)(res).size()) << "\n";
for (long long el : res) {
cout << el << "\n";
}
(RES);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = (int)1e5 + 2;
int dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
int vis[MAX];
long long ans = 0;
vector<vector<pair<int, int>>> edge(MAX);
int dfs(int i) {
vis[i] = 1;
int hold, maxx = 0;
for (int j = 0; j < (int)edge[i].size(); j++) {
if (vis[edge[i][j].first] == 0) {
hold = edge[i][j].second;
hold += dfs(edge[i][j].first);
maxx = max(maxx, hold);
}
}
return maxx;
}
int main() {
int n, x, y, w;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> x >> y >> w;
edge[x].push_back({y, w});
edge[y].push_back({x, w});
ans += 2 * w;
}
ans -= dfs(1);
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int modadd(long long int n, long long int m, long long int mod) {
long long int sum = ((n + m) % mod + mod) % mod;
return sum;
}
long long int modsub(long long int n, long long int m, long long int mod) {
long long int diff = ((n - m + mod) % mod + mod) % mod;
return diff;
}
long long int modpro(long long int n, long long int m, long long int mod) {
long long int pro = ((n * m) % mod + mod) % mod;
return pro;
}
long long int powmod(long long int x, long long int y, long long int mod) {
x %= mod;
y %= mod;
long long int res = 1;
while (y > 0) {
if (y & 1) res = modpro(res, x, mod);
y = y >> 1;
x = modpro(x, x, mod);
}
return res;
}
long long int moddiv(long long int n, long long int m, long long int mod) {
long long int a = powmod(m, mod - 2, mod);
long long int res = modpro(a, n, mod);
return res;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int n;
cin >> n;
stack<pair<long long int, long long int>> s;
long long int a;
cin >> a;
s.push(make_pair(a, 1));
pair<long long int, long long int> b;
long long int f = 0;
long long int m = 0;
for (long long int i = 0; i < n - 1; i++) {
cin >> a;
if (s.size() > 0) {
b = s.top();
s.pop();
if (b.first == a) {
m = max(m, a);
continue;
} else if (b.first > a) {
s.push(b);
s.push(make_pair(a, 1));
} else {
f = 1;
}
} else {
s.push(make_pair(a, 1));
}
}
if (f == 1) {
cout << "NO"
<< "\n";
return 0;
}
if (s.size() == 0) {
cout << "YES"
<< "\n";
return 0;
} else if (s.size() == 1) {
a = s.top().first;
if (a >= m) {
cout << "YES"
<< "\n";
return 0;
} else {
cout << "NO"
<< "\n";
return 0;
}
} else {
cout << "NO"
<< "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n >= k)
cout << ((n / k) + 1) * k << endl;
else
cout << k << endl;
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.