solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
const int MAXN = 100011;
int N, M;
int S;
long long T;
long long Tim[MAXN];
int Nxt(int Pos) {
long long ret = (long long)(Pos);
ret += (Pos < M) ? T : (-T);
--T;
return ((int)(ret % (long long)(N)) + N) % N;
}
int main() {
scanf("%d%d%d%I64d", &N, &M, &S, &T);
--S;
while (true) {
if (Tim[S]) T %= (Tim[S] - T);
Tim[S] = T;
if (T <= N) {
while (T) S = Nxt(S);
printf("%d\n", S + 1);
return 0;
}
for (int i = 0; i < N; ++i) S = Nxt(S);
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int n, r, a, arr[101];
vector<int> ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> r;
while (r--) {
cin >> a;
arr[a]++;
}
}
for (int i = 1; i < 101; i++) {
if (arr[i] == n) ans.push_back(i);
}
for (int i = 0; i < ans.size(); i++) cout << ans[i] << ' ';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline void EnableFileIO(const string& fileName, bool local = 0) {
if (fileName.empty()) return;
if (local) {
freopen((fileName + ".in").c_str(), "r", stdin);
freopen((fileName + ".out").c_str(), "w", stdout);
return;
}
freopen((fileName + ".in").c_str(), "r", stdin);
freopen((fileName + ".out").c_str(), "w", stdout);
}
const int INF = (1 << 30) - 1;
const long long LINF = (1LL << 61) - 1;
const double EPS = 1e-10, PI = acos(-1);
const int N = 55, D = 21;
int n;
string s[N];
long long poss[1 << D];
double f[1 << D];
int main() {
srand((int)time(0));
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
int mask = 0;
for (int p = 0; p < s[i].length(); p++) {
if (s[i][p] == s[j][p]) {
mask |= 1LL << p;
}
}
poss[mask] |= 1LL << i | 1LL << j;
}
}
int len = (int)s[0].length();
for (int i = (1 << len) - 1; i >= 0; i--) {
for (int j = 0; j < len; j++) {
if (~i >> j & 1) continue;
poss[i ^ (1LL << j)] |= poss[i];
}
}
for (int mask = (1 << len) - 1; mask >= 0; mask--) {
int cnt = 0;
if (!__builtin_popcountll(poss[mask])) continue;
for (int i = 0; i < len; i++) {
if (mask >> i & 1) continue;
int nmask = mask | 1LL << i;
f[mask] += f[nmask] * __builtin_popcountll(poss[nmask]) /
__builtin_popcountll(poss[mask]) +
1;
++cnt;
}
if (!cnt) continue;
f[mask] /= cnt;
}
printf("%.10lf\n", f[0]);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long memo[1001][101][2][2];
long long _pow[1001];
void pre() {
_pow[0] = 1;
for (int i = 1; i < 1001; i++) _pow[i] = (_pow[i - 1] * 10) % k;
}
long long F(int dig, int md, bool f1, bool f2) {
if (dig == 0) return f1;
if (memo[dig][md][f1][f2] != -1) return memo[dig][md][f1][f2];
long long ans = 0;
int i = ((dig == 1) ? 1 : 0);
for (; i < 10; i++) {
int mmd = ((i * _pow[n - dig]) + md) % k;
if (mmd == 0 && ((i == 0 && f2 == 1) || i > 0))
ans = (ans + F(dig - 1, 0, 1, 1)) % m;
else
ans = (ans + F(dig - 1, mmd, f1, f2)) % m;
}
return memo[dig][md][f1][f2] = ans;
}
int main() {
cin >> n >> k >> m;
memset(memo, -1, sizeof memo);
pre();
cout << F(n, 0, false, false) << "\n";
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long x, y;
cin >> x >> y;
if (y < n) {
cout << "-1" << endl;
} else {
vector<long long> a(n);
for (int i = 0; i < n - 1; i++) {
a[i] = 1;
}
a[n - 1] = y - (n - 1);
long long sum = (n - 1) + (long long)(y - (n - 1)) * (y - (n - 1));
if (sum >= x) {
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
} else {
cout << -1 << endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 100;
int num[N];
bool vis[N];
vector<int> v;
int n, k;
int main() {
scanf("%d %d", &n, &k);
int mn = 1e9 + 100;
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
if (num[i] < mn) {
mn = num[i];
vis[i] = true;
v.push_back(i);
}
}
v.push_back(n + 1);
num[n + 1] = 0;
int cnt = 0;
int mx = 0;
for (int i = 1; i < v.size(); i++) {
mx = max(mx, v[i] - v[i - 1]);
if (v[i] - v[i - 1] > k) cnt++;
}
if (cnt >= 2 || mx > 2 * k) {
puts("NO");
} else if (cnt == 0) {
puts("YES");
} else {
int tmp = -1;
for (int i = 1; i < v.size(); i++) {
if (v[i] - v[i - 1] > k) tmp = i;
}
bool ans = false;
if (tmp != v.size() - 1 && v[tmp + 1] - v[tmp - 1] <= 2 * k) ans = true;
if (tmp == 0 && v[1] <= 2 * k) tmp = true;
for (int i = v[tmp] + 1; i <= n; i++) {
if (vis[i]) continue;
if (num[i] < num[v[tmp - 1]] && num[i] > num[v[tmp]]) ans = true;
}
if (ans)
puts("YES");
else
puts("NO");
}
return 0;
}
| 17 |
#include <string>
#include <vector>
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<stack>
#include<queue>
#include<cmath>
#include<algorithm>
#include<functional>
#include<list>
#include<deque>
#include<bitset>
#include<set>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<cstring>
#include<sstream>
#include<complex>
#include<iomanip>
#include<numeric>
#include<cassert>
#include<random>
#define X first
#define Y second
#define pb push_back
#define rep(X,Y) for (int (X) = 0;(X) < (int)(Y);++(X))
#define reps(X,S,Y) for (int (X) = (int)(S);(X) < (int)(Y);++(X))
#define rrep(X,Y) for (int (X) = (int)(Y)-1;(X) >=0;--(X))
#define rreps(X,S,Y) for (int (X) = (int)(Y)-1;(X) >= (int)(S);--(X))
#define repe(X,Y) for ((X) = 0;(X) < (Y);++(X))
#define peat(X,Y) for (;(X) < (Y);++(X))
#define all(X) (X).begin(),(X).end()
#define rall(X) (X).rbegin(),(X).rend()
#define eb emplace_back
#define UNIQUE(X) (X).erase(unique(all(X)),(X).end())
#define Endl endl
#define NL <<"\n"
#define cauto const auto
using namespace std;
using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
template<class T> using vv=vector<vector<T>>;
template<class T> inline bool MX(T &l,const T &r){return l<r?l=r,1:0;}
template<class T> inline bool MN(T &l,const T &r){return l>r?l=r,1:0;}
//#undef NUIP
#ifdef NUIP
#include "benri.h"
#else
#define out(args...)
#endif
void ouT(ll x,int d=3){auto re=to_string(x);if((int)re.size()>d) re=x>0?"oo":"-oo";cout<<string(d-re.size(),' ')<<re<<",";}
#ifdef __cpp_init_captures
template<typename T>vector<T> table(int n, T v){ return vector<T>(n, v);}
template <class... Args> auto table(int n, Args... args){auto val = table(args...); return vector<decltype(val)>(n, move(val));}
#endif
template<class A,class B> pair<A,B> operator+(const pair<A,B> &p,const pair<A,B> &q){ return {p.X+q.X,p.Y+q.Y};}
template<class A,class B,class C,class D> pair<A,B>& operator+=(pair<A,B> &p,const pair<C,D> &q){ p.X+=q.X; p.Y+=q.Y; return p;}
template<class A,class B> pair<A,B> operator-(const pair<A,B> &p,const pair<A,B> &q){ return {p.X-q.X,p.Y-q.Y};}
template<class A,class B,class C,class D> pair<A,B>& operator-=(pair<A,B> &p,const pair<C,D> &q){ p.X-=q.X; p.Y-=q.Y; return p;}
template<class A,class B> istream& operator>>(istream &is, pair<A,B> &p){ is>>p.X>>p.Y; return is;}
template<class T=ll> T read(){ T re; cin>>re; return re;}
template<class T=ll> T read(const T &dec){ T re; cin>>re; return re-dec;}
template<class T=ll> vector<T> readV(const int sz){ vector<T> re(sz); for(auto &x:re) x=read<T>(); return re;}
template<class T=ll> vector<T> readV(const int sz, const T &dec){ vector<T> re(sz); for(auto &x:re) x=read<T>(dec); return re;}
vv<int> readG(const int &n,const int &m){ vv<int> g(n); rep(_,m){ cauto a=read<int>(1),b=read<int>(1); g[a].pb(b); g[b].pb(a);} return g;}
vv<int> readG(const int &n){ return readG(n,n-1);}
vv<int> readD(const int &n,const int &m){ vv<int> g(n); rep(_,m){ cauto a=read<int>(1),b=read<int>(1); g[a].pb(b); } return g;}
vv<int> readD(const int &n){ return readD(n,n-1);}
template<class T> vv<pair<int,T>> readG(const int &n,const int &m){ vv<pair<int,T>> g(n); rep(_,m){ cauto a=read<int>(1),b=read<int>(1); cauto c=read<T>(); g[a].eb(b,c); g[b].eb(a,c);} return g;}
template<class T> vv<pair<int,T>> readG(const int &n){ return readG<T>(n,n-1);}
template<class T> vv<pair<int,T>> readD(const int &n,const int &m){ vv<pair<int,T>> g(n); rep(_,m){ cauto a=read<int>(1),b=read<int>(1); cauto c=read<T>(); g[a].eb(b,c); } return g;}
template<class T> vv<pair<int,T>> readD(const int &n){ return readD<T>(n,n-1);}
#ifdef __cpp_init_captures
template<typename T> vector<T> readT(int n, T v){ return readV(n,v);}
template <class... Args> auto readT(int n, Args... args){ vector re(1,readT(args...));rep(_,n-1) re.eb(readT(args...)); return re;}
template<typename T, size_t... Is> void addadd(T& t1, const T& t2, integer_sequence<size_t, Is...>){ cauto l = { (get<Is>(t1) += get<Is>(t2), 0)... }; (void)l;}
template <typename...T>tuple<T...>& operator += (tuple<T...>& lhs, const tuple<T...>& rhs){ addadd(lhs, rhs, index_sequence_for<T...>{}); return lhs;}
template <typename...T>tuple<T...> operator +(tuple<T...> lhs, const tuple<T...>& rhs){ return lhs += rhs;}
template<typename T, size_t... Is> void subsub(T& t1, const T& t2, integer_sequence<size_t, Is...>){ cauto l = { (get<Is>(t1) -= get<Is>(t2), 0)... }; (void)l;}
template <typename...T>tuple<T...>& operator -= (tuple<T...>& lhs, const tuple<T...>& rhs){ subsub(lhs, rhs, index_sequence_for<T...>{}); return lhs;}
template <typename...T>tuple<T...> operator - (tuple<T...> lhs, const tuple<T...>& rhs){ return lhs -= rhs;}
template<class Tuple, size_t... Is> void read_tuple_impl(istream &is, Tuple& t, index_sequence<Is...>){((is >> get<Is>(t)), ...);}
template<class... Args> auto& operator>>(istream &is, tuple<Args...>& t){ read_tuple_impl(is, t, index_sequence_for<Args...>{}); return is;}
#endif
#define TT cauto TTT=read();rep(_,TTT)
const ll MOD=1e9+7; //998244353;
int ask(const int x){
cout<<x<<endl; cout.flush();
cauto re=read();
if(re<0) exit(0);
return re;
}
int main(){
ios_base::sync_with_stdio(false); cin.tie(0);
cout<<fixed<<setprecision(0);
TT{
cauto n=read();
cauto t=read();
cauto neg=
[&](int a){
int re=0;
for(int i=1;a;a/=t,i*=t){
cauto d=a%t;
if(d) re+=i*(t-d);
}
return re;
};
cauto add=
[&](int a,int b){
int re=0;
for(int i=1;a||b;a/=t,b/=t,i*=t){
auto d=a%t+b%t;
if(d>=t) d-=t;
re+=i*d;
}
return re;
};
int a=1;
int b=0;
rep(i,n){
cauto q=add(a>0?i:neg(i),b);
out(i,neg(i),b,q,1);
if(ask(q)) break;
a=-a;
b=add(neg(b),q);
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long int gc(long long int kl, long long int yu) {
long long int pp;
for (pp = min(kl, yu); pp >= 1; pp--) {
if (kl % pp == 0 && yu % pp == 0) break;
}
if (pp == 1)
return 1;
else
return 0;
}
int isP(long int hj) {
long int op;
for (op = 2; op <= sqrt(hj); op++) {
if (hj % op == 0) return 0;
}
return 1;
}
void swap(int *p, int *q) {
int tmp = *p;
*p = *q;
*q = tmp;
}
void tog(int *p) {
if (*p == 1)
*p = 0;
else
*p = 1;
}
int fdi(int hi) {
switch (hi) {
case 0:
return 6;
case 1:
return 2;
case 2:
return 5;
case 3:
return 5;
case 4:
return 4;
case 5:
return 5;
case 6:
return 6;
case 7:
return 3;
case 8:
return 7;
case 9:
return 6;
}
}
int main() {
long long int v1, cur, p, up, a, b, lc, la, max, c, e, preI, t1, t2, g, brk,
L, clbp, clb, et, jmp, u, l1, l2, sp, sq, nd, maxi, li, ri, tr, mp, og,
prev, lt1, lt2, n1, n2, c1, c2, jb, minI, min1, dp, p2, p3, ze, fst, lst,
min2, s, sm1, sm2, sm3, sr, sl, l, ln, rz, rn, car, eq, r, shr, ng, d, v,
curr, spl, fl, z, ev, od, t, m, ct, j, q, k, maxI, max1, max2, lt, md, f,
n, xP, xN, w, h, d2, d1, u1, u2, sm, i, x, y;
cin >> c >> v >> v1 >> a >> l;
cur = 0;
cur = v;
d = 1;
if (cur >= c)
cout << "1";
else {
for (i = 1;; i++) {
if ((v + (i * a)) > v1)
cur += (v1 - l);
else
cur += ((v + (i * a)) - l);
d++;
if (cur >= c) break;
}
cout << d;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9 + 5;
const long long ll_inf = 1e18 + 5;
template <typename T, typename T2>
ostream &operator<<(ostream &s, const pair<T, T2> &p) {
return s << p.first << ' ' << p.second << ' ';
}
template <typename T, typename T2>
istream &operator>>(istream &s, pair<T, T2> &p) {
return s >> p.first >> p.second;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<T> &v) {
for (auto it : v) s << it << ' ';
return s;
}
template <typename T>
istream &operator>>(istream &s, vector<T> &v) {
for (auto it = (v).begin(), it_ = (v).end(); it != it_; it++) s >> *it;
return s;
}
template <typename T>
void read_range(T beg, T end) {
while (beg != end) cin >> *beg++;
}
template <typename T>
void print_range(T beg, T end) {
while (beg != end) cout << *beg++ << ' ';
}
struct reader {
template <typename T>
reader &operator,(T &v) {
cin >> v;
return *this;
}
} rdr;
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << ", ";
return *this;
}
} dbg;
priority_queue<long long> row_max, col_max;
long long row[(int)(1e3 + 5)], col[(int)(1e3 + 5)];
long long row_m[(int)(1e6 + 5)], col_m[(int)(1e6 + 5)];
int main() {
ios_base::sync_with_stdio(false);
long long n, m, k, p;
rdr, n, m, k, p;
;
for (int i = 0, end = (n); i < end; i++)
for (int j = 0, end = (m); j < end; j++) {
int val;
rdr, val;
;
row[i] += val;
col[j] += val;
}
for (int i = 0, end = (n); i < end; i++) row_max.push(row[i]);
for (int i = 0, end = (m); i < end; i++) col_max.push(col[i]);
for (int i = 1; i <= k; i++) {
row_m[i] = row_max.top();
row_max.pop();
row_max.push(row_m[i] - p * m);
row_m[i] += row_m[i - 1];
}
for (int i = 1; i <= k; i++) {
col_m[i] = col_max.top();
col_max.pop();
col_max.push(col_m[i] - p * n);
col_m[i] += col_m[i - 1];
}
long long max_res = -ll_inf;
for (int i = 0, end = (k + 1); i < end; i++)
max_res = max(max_res, row_m[i] + col_m[k - i] - (i) * (k - i) * p);
cout << max_res;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[5];
for (int i = 1; i <= 4; i++) {
cin >> arr[i];
}
string s;
cin >> s;
int n = s.length();
int calories = 0;
for (int i = 0; i < n; i++) {
calories += arr[int(s[i]) - 48];
}
cout << calories;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e7;
struct fruit {
int weight;
int cost;
};
fruit fruits[110];
int dp[110][50010];
int N = 10000;
int rdp(int n_fruits, int total_weight) {
if (dp[n_fruits][N + total_weight] != -INF)
return dp[n_fruits][N + total_weight];
if (n_fruits == 0) {
return total_weight == 0 ? 0 : -INF;
}
dp[n_fruits][N + total_weight] =
max(rdp(n_fruits - 1, total_weight),
rdp(n_fruits - 1, total_weight - fruits[n_fruits].weight) +
fruits[n_fruits].cost);
return dp[n_fruits][N + total_weight];
}
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> fruits[i].cost;
}
for (int i = 1; i <= n; ++i) {
int b;
cin >> b;
fruits[i].weight = fruits[i].cost - k * b;
}
for (int i = 0; i < 110; ++i)
for (int j = 0; j < 50010; ++j) dp[i][j] = -INF;
dp[0][N] = 0;
int answer = rdp(n, 0);
cout << (answer > 0 ? answer : -1);
return 0;
}
| 11 |
#include <bits/stdc++.h>
int main() {
int x, y, f_ans = 1, f;
scanf("%d %d", &x, &y);
if (x <= y)
f = x;
else
f = y;
for (;;) {
f_ans = f_ans * f;
f--;
if (f == 0) break;
}
printf("%d", f_ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
struct tri {
long long num;
long long mini;
long long maxy;
};
bool isPrime(int num) {
bool flag = true;
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
flag = false;
break;
}
}
return flag;
}
int myXOR(int x, int y) { return (x | y) & (~x | ~y); }
int gcd(unsigned long long a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<int> primes;
void SieveOfEratosthenes(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p <= n; p++) {
if (prime[p] == true) {
primes.push_back(p);
}
}
}
void solve() {
int n, k;
cin >> n >> k;
k--;
int mat[n][n];
int c = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
mat[i][j] = c++;
}
}
for (int i = 0; i < n; i++) {
for (int j = k; j < n; j++) {
mat[i][j] = c++;
}
}
int sum = 0;
for (int i = 0; i < n; i++) {
sum += mat[i][k];
}
cout << sum << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << mat[i][j] << " ";
}
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dcmp(double a, double b) {
return fabs(a - b) <= 0.0000000001 ? 0 : (a > b) ? 1 : -1;
}
vector<string> v;
int m, f;
bool check(string s) {
int n = ((int)(s).size());
if (n >= 4 && s[n - 1] == 's' && s[n - 2] == 'o' && s[n - 3] == 'i' &&
s[n - 4] == 'l')
m = 1;
else if (n >= 3 && s[n - 1] == 'r' && s[n - 2] == 't' && s[n - 3] == 'e')
m = 1;
else if (n >= 6 && s[n - 1] == 's' && s[n - 2] == 'i' && s[n - 3] == 't' &&
s[n - 4] == 'i' && s[n - 5] == 'n' && s[n - 6] == 'i')
m = 1;
else if (n >= 6 && s[n - 1] == 's' && s[n - 2] == 'e' && s[n - 3] == 't' &&
s[n - 4] == 'i' && s[n - 5] == 'n' && s[n - 6] == 'i')
f = 1;
else if (n >= 5 && s[n - 1] == 'a' && s[n - 2] == 'l' && s[n - 3] == 'a' &&
s[n - 4] == 'i' && s[n - 5] == 'l')
f = 1;
else if (n >= 4 && s[n - 1] == 'a' && s[n - 2] == 'r' && s[n - 3] == 't' &&
s[n - 4] == 'e')
f = 1;
else
return 0;
if (m == f) return 0;
return 1;
}
int main() {
string line;
getline(cin, line);
stringstream ss(line);
string st;
while (ss >> st) {
v.push_back(st);
}
if (((int)(v).size()) == 1) {
m = 0;
f = 0;
int f = check(v[0]);
if (f) {
cout << "YES\n";
return 0;
} else {
cout << "NO\n";
return 0;
}
}
m = 0;
f = 0;
for (int i = 0; i < ((int)(v).size()); i++) {
if (!check(v[i])) {
cout << "NO\n";
return 0;
}
}
int fl = 0, adj = 0, no = 0, cntno = 0;
if (f) {
for (int i = 0; i < ((int)(v).size()); i++) {
string s = v[i];
int n = ((int)(s).size());
if (n >= 6 && s[n - 1] == 's' && s[n - 2] == 'e' && s[n - 3] == 't' &&
s[n - 4] == 'i' && s[n - 5] == 'n' && s[n - 6] == 'i') {
if (adj == 1 || no == 0) {
fl = 1;
break;
}
} else if (n >= 5 && s[n - 1] == 'a' && s[n - 2] == 'l' &&
s[n - 3] == 'a' && s[n - 4] == 'i' && s[n - 5] == 'l') {
adj = 1;
} else if (n >= 4 && s[n - 1] == 'a' && s[n - 2] == 'r' &&
s[n - 3] == 't' && s[n - 4] == 'e') {
no = 1;
adj = 0;
cntno++;
}
}
if (adj != 0 || cntno > 1) fl = 1;
} else {
for (int i = 0; i < ((int)(v).size()); i++) {
string s = v[i];
int n = ((int)(s).size());
if (n >= 4 && s[n - 1] == 's' && s[n - 2] == 'o' && s[n - 3] == 'i' &&
s[n - 4] == 'l') {
adj = 1;
} else if (n >= 3 && s[n - 1] == 'r' && s[n - 2] == 't' &&
s[n - 3] == 'e') {
no = 1;
adj = 0;
cntno++;
} else if (n >= 6 && s[n - 1] == 's' && s[n - 2] == 'i' &&
s[n - 3] == 't' && s[n - 4] == 'i' && s[n - 5] == 'n' &&
s[n - 6] == 'i') {
if (adj == 1 || no == 0) {
fl = 1;
break;
}
}
}
if (adj == 1 || cntno > 1) fl = 1;
}
if (fl)
cout << "NO\n";
else
cout << "YES\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a[n];
for (auto &it : a) {
cin >> it;
it++;
}
int dp[3][n];
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
dp[1][0] = !(a[0] == 2 || a[0] == 4);
dp[2][0] = !(a[0] == 3 || a[0] == 4);
for (int i = 1; i < n; i++) {
dp[0][i] = 1 + min({dp[0][i - 1], dp[1][i - 1], dp[2][i - 1]});
dp[1][i] = (!(a[i] == 2 || a[i] == 4)) + min(dp[0][i - 1], dp[2][i - 1]);
dp[2][i] = (!(a[i] == 3 || a[i] == 4)) + min(dp[0][i - 1], dp[1][i - 1]);
}
cout << min({dp[0][n - 1], dp[1][n - 1], dp[2][n - 1]}) << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
template <class T>
using V = vector<T>;
template <class T>
using VV = V<V<T>>;
template <class T>
using VVV = V<VV<T>>;
template <class T>
T chmax(T& l, const T& r) {
l = max(l, r);
}
template <class T>
ostream& operator<<(ostream& os, const V<T>& v) {
os << "[";
for (auto d : v) os << d << ", ";
return os << "]";
}
using D = ll;
const D EPS = 0;
int sgn(D a) { return (a < -EPS) ? -1 : (a > EPS); }
int sgn(D a, D b) { return sgn(a - b); }
struct Pt2 {
D x, y;
Pt2(D _x = D(), D _y = D()) : x(_x), y(_y) {}
Pt2 operator+(const Pt2& r) const { return Pt2(x + r.x, y + r.y); }
Pt2 operator-(const Pt2& r) const { return Pt2(x - r.x, y - r.y); }
Pt2 operator*(const Pt2& r) const {
return Pt2(x * r.x - y * r.y, x * r.y + y * r.x);
}
Pt2 operator*(const D& r) const { return Pt2(x * r, y * r); }
Pt2 operator/(const D& r) const { return Pt2(x / r, y / r); }
Pt2& operator+=(const Pt2& r) { return *this = *this + r; }
Pt2& operator-=(const Pt2& r) { return *this = *this - r; }
Pt2& operator*=(const Pt2& r) { return *this = *this * r; }
Pt2& operator*=(const D& r) { return *this = *this * r; }
Pt2& operator/=(const D& r) { return *this = *this / r; }
Pt2 operator-() const { return Pt2(-x, -y); }
bool operator<(const Pt2& r) const {
return 2 * sgn(x, r.x) + sgn(y, r.y) < 0;
}
bool operator==(const Pt2& r) const { return sgn((*this - r).rabs()) == 0; }
D norm() const { return x * x + y * y; }
D rabs() const { return max(std::abs(x), std::abs(y)); }
pair<D, D> to_pair() const { return make_pair(x, y); }
};
ostream& operator<<(ostream& os, const Pt2& p) {
return os << "P(" << p.x << ", " << p.y << ")";
}
using P = Pt2;
D cross(P a, P b) { return a.x * b.y - a.y * b.x; }
D dot(P a, P b) { return a.x * b.x + a.y * b.y; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << fixed;
int n, k;
cin >> n >> k;
k--;
V<P> ps(n);
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
ps[i] = P(x, y);
}
sort(ps.begin(), ps.end(), [&](P a, P b) {
if (a.y != b.y) return a.y < b.y;
return a.x > b.x;
});
ll ans = 0;
for (int s = k; s < n; s++) {
P st = ps[s];
sort(ps.begin(), ps.begin() + s,
[&](P a, P b) { return cross(a - st, b - st) > 0; });
VV<int> vid(s);
for (int i = 0; i < s; i++) {
V<int> buf;
for (int j = i + 1; j < s; j++) buf.push_back(j);
sort(buf.begin(), buf.end(), [&](int l, int r) {
return cross(ps[l] - ps[i], ps[r] - ps[i]) > 0;
});
for (int d : buf) {
while (vid[i].size() && vid[i].back() > d) vid[i].pop_back();
vid[i].push_back(d);
}
}
static ll dp[202][52][202];
for (int i = 0; i < s; i++) {
for (int uc = 0; uc <= k; uc++) fill_n(dp[i][uc], 202, -TEN(18));
dp[i][1][0] = 0;
}
for (int i = 0; i < s; i++) {
int m = int(vid[i].size());
for (int j = 0; j < m; j++) {
int ni = vid[i][j];
int nj = lower_bound(
vid[ni].begin(), vid[ni].end(), ps[ni] - ps[i],
[&](int a, P b) { return cross(ps[a] - ps[ni], b) > 0; }) -
vid[ni].begin();
ll cng = cross(ps[i] - st, ps[ni] - st);
for (int uc = 1; uc <= k; uc++) {
chmax(dp[i][uc][j + 1], dp[i][uc][j]);
if (uc < k) {
chmax(dp[ni][uc + 1][nj], dp[i][uc][j] + cng);
}
}
}
ans = max(ans, dp[i][k][m]);
}
}
string s = to_string(ans / 2);
if (ans % 2)
s += ".50";
else
s += ".00";
cout << s << endl;
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
char S[100005];
int main() {
int N;
int len, K;
scanf("%d%d\n", &N, &K);
gets(S);
int grass, insect;
for (int i = 0; i < N; i++) {
if (S[i] == 'G')
grass = i;
else if (S[i] == 'T')
insect = i;
}
if (grass > insect) swap(grass, insect);
while (grass + K <= insect) {
grass += K;
if (S[grass] == '#') {
printf("NO\n");
return 0;
} else if (grass == insect) {
printf("YES\n");
return 0;
}
}
printf("NO\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O2")
vector<long long int> ar[1000001];
long long int vis[1000001], dis[1000001], level[1000001];
const int MAX_SIZE = 1000001;
const int N = 2000010;
const int mod = 1e9 + 7;
vector<int> isprime(MAX_SIZE, true);
vector<int> prime;
vector<int> SPF(MAX_SIZE);
long long int fact[N];
void manipulated_seive(int N) {
isprime[0] = isprime[1] = false;
for (int i = 2; i < N; ++i) {
if (isprime[i]) {
prime.push_back(i);
SPF[i] = i;
}
for (int j = 0;
j < (int)prime.size() && i * prime[j] < N && prime[j] <= SPF[i]; ++j) {
isprime[i * prime[j]] = false;
SPF[i * prime[j]] = prime[j];
}
}
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
unordered_map<long long int, long long int> myp;
void primeFactors(long long int n) {
while (n % 2 == 0) {
myp[2]++;
n = n / 2;
}
for (long long int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
myp[i]++;
n = n / i;
}
}
if (n > 2) myp[n]++;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int findlcm(long long int a, long long int b) {
return a * b / gcd(a, b);
}
long long int power(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b % 2) res *= a;
a *= a;
b /= 2;
}
return res;
}
long long int power_mod(long long int a, long long int b, long long int p) {
long long int res = 1;
while (b) {
if (b % 2) {
res *= a;
res %= p;
}
a *= a;
a %= p;
b /= 2;
}
return res;
}
long long int mod_inverse(long long int x) {
return power_mod(x, mod - 2, mod);
}
long long int nCr(long long int n, long long int r) {
if (r == 0) return 1;
long long int a = fact[n];
long long int b = mod_inverse(fact[n - r]);
long long int c = mod_inverse(fact[r]);
return (((a * b) % mod) * c) % mod;
}
void fun() {
long long int n;
cin >> n;
long long int preP = INT_MAX, preC = INT_MAX;
long long int cP, cC, flag = 0;
for (long long int i = 1; i <= n; i++) {
cin >> cP >> cC;
if (i != 1) {
if (cP == preP && cC > preC) {
flag = 1;
}
if (cP >= preP && cC >= preC && cC <= cP) {
} else {
flag = 1;
}
long long int dC = cC - preC;
long long int dP = cP - preP;
if (dC > dP) flag = 1;
}
if (i == 1) {
if (cC <= cP) {
} else {
flag = 1;
}
}
preP = cP, preC = cC;
}
if (flag == 1) {
cout << "NO" << '\n';
return;
}
cout << "YES" << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
unsigned long long int t;
cin >> t;
while (t--) {
cout << fixed;
cout << setprecision(10);
fun();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 105;
long long n;
long long a[N];
map<long long, long long> m;
long long dp[N][N * N];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
m[a[i]]++;
}
if (m.size() <= 2) {
cout << n;
return 0;
}
dp[0][0] = 1;
for (auto &it : m) {
long long f = it.second;
for (long long i = n; i >= 1; i--) {
for (long long j = 10000; j >= 0; j--) {
for (long long k = 1; k <= min(f, i) && k * it.first <= j; k++) {
dp[i][j] += dp[i - k][j - k * it.first];
dp[i][j] = min(dp[i][j], (long long)1e9);
}
}
}
}
long long ans = 0;
for (auto &it : m) {
long long f = it.second;
for (long long i = 1; i <= f; i++)
if (dp[i][i * it.first] == 1) ans = max(ans, i);
}
cout << ans;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int Mod = 1e9 + 7;
struct Point {
long long x, y;
};
void ans(int v) {
cout << v << endl;
exit(0);
}
struct P3 {
Point a, b, c, ta, tb, tc;
P3(Point x, Point y, Point z) : a(x), b(y), c(z) {}
void refresh(bool transpose) {
if (transpose) {
ta.x = a.y;
ta.y = a.x;
tb.x = b.y;
tb.y = b.x;
tc.x = c.y;
tc.y = c.x;
} else {
ta = a;
tb = b;
tc = c;
}
}
};
void test(P3 p3) {
Point a = p3.ta, b = p3.tb, c = p3.tc;
if (a.x == b.x && a.x == c.x) ans(1);
if (a.x == b.x && (c.y <= min(a.y, b.y) || c.y >= max(a.y, b.y))) ans(2);
}
int solve() {
Point a, b, c;
cin >> a.x >> a.y;
cin >> b.x >> b.y;
cin >> c.x >> c.y;
P3 p3(a, b, c);
p3.refresh(false);
test(p3);
p3.refresh(true);
test(p3);
p3 = P3(a, c, b);
p3.refresh(false);
test(p3);
p3.refresh(true);
test(p3);
p3 = P3(b, a, c);
p3.refresh(false);
test(p3);
p3.refresh(true);
test(p3);
p3 = P3(b, c, a);
p3.refresh(false);
test(p3);
p3.refresh(true);
test(p3);
p3 = P3(c, a, b);
p3.refresh(false);
test(p3);
p3.refresh(true);
test(p3);
p3 = P3(c, b, a);
p3.refresh(false);
test(p3);
p3.refresh(true);
test(p3);
ans(3);
return 0;
}
int main() {
std::ios_base::sync_with_stdio(false);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx2,avx")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
int scan() { return getchar(); }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(long double &a) { cin >> a; }
void scan(string &a) { cin >> a; }
template <class T>
void scan(vector<T> &);
template <class T>
void scan(vector<T> &a) {
for (auto &i : a) scan(i);
}
template <class T>
void scan(T &a) {
cin >> a;
}
void IN() {}
template <class Head, class... Tail>
void IN(Head &head, Tail &...tail) {
scan(head);
IN(tail...);
}
string stin() {
string s;
cin >> s;
return s;
}
template <class T, class S>
inline bool chmax(T &a, S b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class S>
inline bool chmin(T &a, S b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
vector<int> iota(int n) {
vector<int> a(n);
iota(begin(a), end(a), 0);
return a;
}
template <class T>
void UNIQUE(vector<T> &x) {
sort(begin(x), end(x));
x.erase(unique(begin(x), end(x)), x.end());
}
int in() {
int x;
cin >> x;
return x;
}
long long lin() {
unsigned long long x;
cin >> x;
return x;
}
void print() { putchar(' '); }
void print(bool a) { cout << a; }
void print(int a) { cout << a; }
void print(long long a) { cout << a; }
void print(char a) { cout << a; }
void print(string &a) { cout << a; }
void print(double a) { cout << a; }
template <class T>
void print(const vector<T> &);
template <class T, size_t size>
void print(const array<T, size> &);
template <class T, class L>
void print(const pair<T, L> &p);
template <class T, size_t size>
void print(const T (&)[size]);
template <class T>
void print(const vector<T> &a) {
if (a.empty()) return;
print(a[0]);
for (auto i = a.begin(); ++i != a.end();) {
cout << " ";
print(*i);
}
cout << endl;
}
template <class T>
void print(const deque<T> &a) {
if (a.empty()) return;
print(a[0]);
for (auto i = a.begin(); ++i != a.end();) {
cout << " ";
print(*i);
}
}
template <class T, size_t size>
void print(const array<T, size> &a) {
print(a[0]);
for (auto i = a.begin(); ++i != a.end();) {
cout << " ";
print(*i);
}
}
template <class T, class L>
void print(const pair<T, L> &p) {
cout << '(';
print(p.first);
cout << ",";
print(p.second);
cout << ')';
}
template <class T>
void print(set<T> &x) {
for (auto e : x) print(e), cout << " ";
cout << endl;
}
template <class T>
void print(multiset<T> &x) {
for (auto e : x) print(e), cout << " ";
cout << endl;
}
template <class T, size_t size>
void print(const T (&a)[size]) {
print(a[0]);
for (auto i = a; ++i != end(a);) {
cout << " ";
print(*i);
}
}
template <class T>
void print(const T &a) {
cout << a;
}
int out() {
putchar('\n');
return 0;
}
template <class T>
int out(const T &t) {
print(t);
putchar('\n');
return 0;
}
template <class Head, class... Tail>
int out(const Head &head, const Tail &...tail) {
print(head);
putchar(' ');
out(tail...);
return 0;
}
long long gcd(long long a, long long b) {
while (b) {
long long c = b;
b = a % b;
a = c;
}
return a;
}
long long lcm(long long a, long long b) {
if (!a || !b) return 0;
return a * b / gcd(a, b);
}
vector<pair<long long, long long>> factor(long long x) {
vector<pair<long long, long long>> ans;
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) {
ans.push_back({i, 1});
while ((x /= i) % i == 0) ans.back().second++;
}
if (x != 1) ans.push_back({x, 1});
return ans;
}
template <class T>
vector<T> divisor(T x) {
vector<T> ans;
for (T i = 1; i * i <= x; i++)
if (x % i == 0) {
ans.push_back(i);
if (i * i != x) ans.push_back(x / i);
}
return ans;
}
template <typename T>
void zip(vector<T> &x) {
vector<T> y = x;
sort(begin(y), end(y));
for (int i = 0; i < x.size(); ++i) {
x[i] = distance((y).begin(), lower_bound(begin(y), end(y), (x[i])));
}
}
int popcount(long long x) { return __builtin_popcountll(x); }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int n) { return uniform_int_distribution<int>(0, n - 1)(rng); }
long long rndll(long long n) {
return uniform_int_distribution<long long>(0, n - 1)(rng);
}
template <typename T>
void shuffle(vector<T> &v) {
for (long long i = v.size() - 1; i >= 1; --i) {
swap(v[i], v[rnd(i)]);
}
}
vector<string> YES{"NO", "YES"};
vector<string> Yes{"No", "Yes"};
vector<string> yes{"no", "yes"};
template <class... T>
void err(const T &...) {}
template <typename T>
struct edge {
int from, to;
T cost;
int id;
edge(int to, T cost) : from(-1), to(to), cost(cost) {}
edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
edge(int from, int to, T cost, int id)
: from(from), to(to), cost(cost), id(id) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T>
using Edges = vector<edge<T>>;
struct Graph : vector<vector<int>> {
using vector<vector<int>>::vector;
Graph(int n, int m) : vector(n) { read(m); }
inline void add(int a, int b, bool directed = false) {
(*this)[a].emplace_back(b);
if (!directed) (*this)[b].emplace_back(a);
}
void read(int n = -1, int offset = 1, bool directed = false) {
if (n == -1) n = this->size() - 1;
int a, b;
while (n--) {
cin >> a >> b;
Graph::add(a - offset, b - offset, directed);
}
}
};
template <typename T>
struct WeightedGraph : vector<Edges<T>> {
using vector<Edges<T>>::vector;
inline void add(int a, int b, T c, bool directed = false) {
(*this)[a].emplace_back(b, c);
if (!directed) (*this)[b].emplace_back(a, c);
}
void read(int n = -1, int offset = 1) {
if (n == -1) n = this->size() - 1;
int a, b;
T c;
while (n--) {
cin >> a >> b >> c;
WeightedGraph::add(a - offset, b - offset, c);
}
}
};
struct Setup_io {
Setup_io() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
}
} setup_io;
template <typename Monoid>
struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f;
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n) sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) L = f(L, seg[a++]);
if (b & 1) R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
template <typename C>
int find_subtree(int a, const C &check, Monoid &M, bool type) {
while (a < sz) {
Monoid nxt = type ? f(seg[2 * a + type], M) : f(M, seg[2 * a + type]);
if (check(nxt))
a = 2 * a + type;
else
M = nxt, a = 2 * a + 1 - type;
}
return a - sz;
}
template <typename C>
int find_first(int a, const C &check) {
Monoid L = M1;
if (a <= 0) {
if (check(f(L, seg[1]))) return find_subtree(1, check, L, false);
return -1;
}
int b = sz;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
Monoid nxt = f(L, seg[a]);
if (check(nxt)) return find_subtree(a, check, L, false);
L = nxt;
++a;
}
}
return -1;
}
template <typename C>
int find_last(int b, const C &check) {
Monoid R = M1;
if (b >= sz) {
if (check(f(seg[1], R))) return find_subtree(1, check, R, true);
return -1;
}
int a = sz;
for (b += sz; a < b; a >>= 1, b >>= 1) {
if (b & 1) {
Monoid nxt = f(seg[--b], R);
if (check(nxt)) return find_subtree(b, check, R, true);
R = nxt;
}
}
return -1;
}
void print(int n) {
for (int i = 0; i < n; i++) {
cerr << seg[i + sz] << " ";
}
cerr << '\n';
}
};
struct Data {
int x, y, id;
Data(int x, int y, int id) : x(x), y(y), id(id) {}
Data() = default;
bool operator<(const Data r) const { return y < r.y; }
};
int main() {
int n;
IN(n);
vector<int> xs, a(n), b(n), c(n), d(n);
for (long long i = 0; i < n; ++i)
cin >> a[i] >> b[i] >> c[i] >> d[i], xs.emplace_back(a[i]),
xs.emplace_back(c[i]);
UNIQUE(xs);
int m = (int)(xs).size();
SegmentTree<Data> seg(
m, [](Data x, Data y) { return min(x, y); }, Data(0, INT_MAX, 0));
for (long long i = 0; i < n; ++i)
a[i] = distance((xs).begin(), lower_bound(begin(xs), end(xs), (a[i]))),
c[i] = distance((xs).begin(), lower_bound(begin(xs), end(xs), (c[i])));
vector<vector<Data>> mp(m, vector<Data>());
for (long long i = 0; i < n; ++i) mp[a[i]].emplace_back(a[i], b[i], i);
for (long long i = 0; i < m; ++i)
mp[i].emplace_back(0, INT_MAX, 0), sort(begin(mp[i]), end(mp[i])),
reverse(begin(mp[i]), end(mp[i]));
for (long long i = 0; i < m; ++i) seg.set(i, mp[i].back());
seg.build();
vector<int> pre(n, -1);
queue<Data> q;
q.emplace(0, 0, -2);
while (!q.empty()) {
auto [x, y, from] = q.front();
q.pop();
auto [xx, yy, to] = seg.query(0, x + 1);
while (yy <= y) {
pre[to] = from;
q.emplace(c[to], d[to], to);
mp[xx].pop_back();
seg.update(xx, mp[xx].back());
auto [X, Y, TO] = seg.query(0, x + 1);
xx = X, yy = Y, to = TO;
}
}
if (pre[n - 1] == -1) {
cout << -1 << '\n';
} else {
int now = n - 1;
vector<int> ans{now + 1};
while (pre[now] != -2) {
now = pre[now];
ans.emplace_back(now + 1);
}
cout << (int)(ans).size() << '\n';
reverse(begin(ans), end(ans));
print(ans);
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, n, a, b, c, d, e, f;
char s[100005];
cin >> n >> a >> b;
cin >> s;
if (s[a - 1] == s[b - 1])
cout << "0";
else {
cout << "1";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, t = 0, l, r, a[N], v[N], L[N], R[N];
char s[N];
struct cmp {
bool operator()(pair<int, int> &r, pair<int, int> &q) const {
if (abs(a[r.first] - a[r.second]) == abs(a[q.first] - a[q.second]))
return r.first > q.first;
return abs(a[r.first] - a[r.second]) > abs(a[q.first] - a[q.second]);
}
};
priority_queue<pair<int, int>, vector<pair<int, int> >, cmp> pq;
int main() {
cin >> n;
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i), L[i] = i - 1, R[i] = i + 1;
if (i != 1 && s[i] != s[i - 1]) pq.push({i - 1, i});
if (s[i] == 'G') t++;
}
t = min(t, n - t);
cout << t << endl;
while (t) {
pair<int, int> c = pq.top();
pq.pop();
if (v[c.first] || v[c.second]) continue;
cout << c.first << " " << c.second << endl;
l = L[c.first], r = R[c.second];
if (l > 0 && r <= n && s[l] != s[r]) pq.push({l, r});
L[r] = l, R[l] = r;
v[c.first] = 1, v[c.second] = 1;
t--;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int m, n;
int p[30];
int ask(int y) {
printf("%d\n", y);
fflush(stdout);
int ans;
scanf("%d", &ans);
return ans;
}
int it = 0;
void bs(int lo, int hi) {
int mid = (lo + hi) / 2;
int t = ask(mid);
if (p[it] == 0) t *= -1;
it = (it + 1) % n;
if (t == 0) return;
if (t == -1) bs(lo, mid - 1);
if (t == 1) bs(mid + 1, hi);
}
int main() {
scanf("%d %d", &m, &n);
for (int i = 0; (i) < int(n); (i)++) {
int t = ask(m);
if (t == 0) return 0;
if (t == -1) p[i] = 1;
if (t == 1) p[i] = 0;
}
bs(1, m - 1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
void binarysearch() {
long long l = 2, r = k, m, sum;
while (l <= r) {
m = (l + r) / 2;
sum = ((m + k) * (k - m + 1) / 2 - (k - m));
if (sum < n && (sum + m - 2) > n)
break;
else if (sum < n)
r = m - 1;
else if (sum > n)
l = m + 1;
else {
cout << k - m + 1;
return;
}
}
if (l > r)
cout << -1;
else
cout << k - m + 2;
}
int main() {
cin >> n >> k;
if (n > ((k + 2) * (k - 1) / 2))
cout << -1;
else if (n == 1)
cout << 0;
else if (n <= k)
cout << 1;
else
binarysearch();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e6 + 10;
const int p = 1009;
int raw[maxn], cnt[maxn];
struct node {
double x, y;
node(double xx = 0, double yy = 0) { x = xx, y = yy; }
};
node operator*(node J, node Q) {
return node(J.x * Q.x - J.y * Q.y, J.x * Q.y + J.y * Q.x);
}
node operator+(node J, node Q) { return node(J.x + Q.x, J.y + Q.y); }
node operator-(node J, node Q) { return node(J.x - Q.x, J.y - Q.y); }
node F1[maxn], F2[maxn];
const double PI = acos(-1.0);
int rev[maxn];
void init(vector<int>& A, int n) {
A.clear();
A.shrink_to_fit();
int size = 1;
while (size <= n) size *= 2;
A.assign(size * 2, 0);
}
void FFT(node* A, int siz, int type) {
int n = siz;
int S = log2(n);
for (int i = 0; i < n; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (S - 1));
for (int i = 0; i < n; i++)
if (i < rev[i]) swap(A[i], A[rev[i]]);
for (int i = 1; i < n; i *= 2) {
node Wn(cos(PI / i), type * sin(PI / i));
for (int j = 0; j < n; j += i * 2) {
node W(1, 0);
for (int k = 0; k < i; k++) {
node facx = A[j + k], facy = W * A[j + k + i];
A[j + k] = facx + facy;
A[j + k + i] = facx - facy;
W = W * Wn;
}
}
}
if (type == -1)
for (int i = 0; i < n; i++) A[i].x = ((A[i].x / n + 0.5));
}
vector<int> mul(vector<int> A, vector<int> B) {
int n = A.size(), m = B.size();
int siz = n + m - 1;
vector<int> C(siz);
if (siz < 64) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) C[i + j] = (C[i + j] + 1LL * A[i] * B[j]) % p;
}
return C;
}
int fsiz = 1;
while (fsiz <= siz) fsiz *= 2;
fsiz *= 2;
for (int i = 0; i < fsiz; i++) F1[i] = F2[i] = 0;
for (int i = 0; i < n; i++) F1[i] = A[i];
for (int i = 0; i < m; i++) F2[i] = B[i];
FFT(F1, fsiz, 1);
FFT(F2, fsiz, 1);
for (int i = 0; i < fsiz; i++) F1[i] = F1[i] * F2[i];
FFT(F1, fsiz, -1);
for (int i = 0; i < siz; i++) {
C[i] = ((long long)F1[i].x) % p;
}
return C;
}
vector<int> solve(int l, int r) {
if (l == r) {
return vector<int>(cnt[l] + 1, 1);
}
int m = (l + r) / 2;
return mul(solve(l, m), solve(m + 1, r));
}
struct Node {
int w;
vector<int> P;
Node(int w = 0, vector<int> P = {}) : w(w), P(P) {}
bool operator<(const Node& X) const { return w > X.w; }
};
priority_queue<Node> pq;
vector<int> ans;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
cnt[x]++;
}
vector<int> ans = solve(1, m);
cout << ans[k] << '\n';
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
double pi = 3.14159265358979;
struct pt {
double x;
double y;
};
struct line {
double a;
double b;
double c;
};
line to(pt a, pt b) {
line l;
l.a = (b.y - a.y);
l.b = (a.x - b.x);
l.c = (-a.x * l.a - a.y * l.b);
return l;
}
pt perec(line l1, line l2) {
pt o;
o.y = (l2.c * l1.a - l1.c * l2.a) / (l2.a * l1.b - l1.a * l2.b);
o.x = (l2.c * l1.b - l1.c * l2.b) / (l2.b * l1.a - l1.b * l2.a);
return o;
}
double dist(pt a, pt b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15) << "";
long long n;
cin >> n;
if (n <= 4) {
cout << "No solution";
return 0;
}
vector<pt> u;
for (long long i = 0; i < n; ++i) {
double f = (2.0 * pi * i / (n + 0.0));
pt z;
z.x = sin(f);
z.y = cos(f);
u.push_back(z);
}
vector<line> z;
for (long long i = 0; i < n; ++i) {
z.push_back(to(u[i], u[(i + 1) % n]));
}
if (n >= 10) {
for (long long i = 0; i < n; ++i) {
z[i].c *= 1000;
z[i].c += (i / (1000.0));
}
} else {
for (long long i = 0; i < n; ++i) {
z[i].c *= 500;
z[i].c += (i / (1.0));
}
}
vector<pt> ans(n);
for (long long i = 0; i < n; ++i) {
ans[i] = perec(z[i], z[(i + 1) % n]);
}
reverse(ans.begin(), ans.end());
for (long long i = 0; i < n; ++i) {
cout << ans[i].x << ' ' << ans[i].y << endl;
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long int max = 0;
int ans = -1;
if (a[0] != 0)
ans = 1;
else {
for (int i = 1; i < n; i++) {
if (a[i - 1] > max) max = a[i - 1];
if (a[i] - max > 1) {
ans = i + 1;
break;
}
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, sum = 0;
cin >> n >> k;
int i;
for (i = 0; i < n; i++) {
int x;
cin >> x;
sum += x;
}
int ans = 2 * (k * n - sum) - n;
cout << ((ans > 0) ? ans : 0) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 3e5;
int a[maxn];
set<int> sr[maxn];
set<pair<int, int>> all_a;
set<pair<int, int>> all_sz;
int pr[maxn];
vector<pair<int, int>> edges;
int n;
int x;
void make_set() {
for (int i = 0; i < maxn; ++i) {
pr[i] = i;
}
}
int find_set(int aa) {
if (pr[aa] == aa)return aa;
return pr[aa] = find_set(pr[aa]);
}
int get(int v, pair<int, int> aa) {
if (find_set(aa.first) == find_set(v))return aa.second;
else return aa.first;
}
void unic(int a1, int b1) {
a1 = find_set(a1);
b1 = find_set(b1);
if (sr[a1].size() > sr[b1].size())swap(a1, b1);
all_a.erase({a[b1], b1});
a[b1] += a[a1];
a[b1] -= x;
all_a.insert({a[b1], b1});
all_a.erase({a[a1], a1});
a[a1] = 0;
all_sz.erase({sr[b1].size(), b1});
for (auto x: sr[a1]) {
int to = find_set(get(a1, edges[x]));
if (to == b1) {
sr[b1].erase(x);
continue;
}
sr[b1].insert(x);
}
all_sz.insert({sr[b1].size(), b1});
all_sz.erase({sr[a1].size(), a1});
sr[a1].clear();
pr[a1] = b1;
}
vector<int> ans;
void rec(int i) {
if (i == n - 1)return;
auto it = all_a.end();
it--;
int id_a = it->second;
int id_sz = all_sz.begin()->second;
if (a[id_a] >= x) {
int f = *sr[id_a].begin();
int to = get(id_a, edges[f]);
unic(id_a, to);
ans.push_back(f);
rec(i + 1);
} else {
int f = *sr[id_sz].begin();
all_a.erase({a[id_sz], id_sz});
all_sz.erase({sr[id_sz].size(), id_sz});
for (auto x: sr[id_sz]) {
int t = find_set(get(id_sz, edges[x]));
all_sz.erase({sr[t].size(), t});
sr[t].erase(x);
all_sz.insert({sr[t].size(), t});
}
sr[id_sz].clear();
rec(i + 1);
ans.push_back(f);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
#ifdef foo
freopen("input.txt", "r", stdin);
#endif
int m;
cin >> n >> m >> x;
for (int l = 0; l < n; ++l) {
cin >> a[l];
}
for (int i = 0; i < m; ++i) {
int a1, b1;
cin >> a1 >> b1;
a1--;
b1--;
edges.push_back({a1, b1});
sr[a1].insert(i);
sr[b1].insert(i);
}
int sum = 0;
for (int j = 0; j < n; ++j) {
all_a.insert({a[j], j});
all_sz.insert({sr[j].size(), j});
sum += a[j];
}
if (sum < (n - 1) * x) {
cout << "NO";
exit(0);
}
make_set();
cout << "YES" << "\n";
rec(0);
for (int k = 0; k < n - 1; ++k) {
cout << ans[k] + 1 << "\n";
}
} | 18 |
#include <bits/stdc++.h>
using namespace std;
int primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53};
int DP[101][(1 << 16) + 5];
int ch[101][(1 << 16) + 5];
int arr[105], sum[105], sol[105];
int masks[61];
vector<int> cans[(1 << 16) + 5];
int n;
int solve(int ind, int mask) {
if (ind == n) return 0;
int &temp = DP[ind][mask];
if (temp != -1) return temp;
temp = solve(ind + 1, mask) + arr[ind] - 1;
ch[ind][mask] = 1;
for (int i = 0; i < cans[mask].size(); i++) {
int x = solve(ind + 1, (masks[cans[mask][i]] | mask));
if (x + abs(arr[ind] - cans[mask][i]) < temp)
ch[ind][mask] = cans[mask][i], temp = x + abs(arr[ind] - cans[mask][i]);
}
return temp;
}
void get(int ind, int mask) {
if (ind == n) return;
sol[ind] = ch[ind][mask];
get(ind + 1, masks[ch[ind][mask]] | mask);
}
int main() {
ios_base::sync_with_stdio(0);
memset(DP, -1, sizeof(DP));
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = n - 1; i >= 0; i--) sum[i] = sum[i - 1] + arr[i] - 1;
for (int i = 2; i < 59; i++) {
int temp = i, res = 0;
for (int j = 0; j < 16 && temp != 1; j++) {
while (temp % primes[j] == 0) temp /= primes[j], res |= (1 << j);
}
masks[i] = res;
}
for (int i = 0; i < (1 << 16); i++) {
for (int j = 2; j < 59; j++) {
if ((masks[j] & i) == 0) cans[i].push_back(j);
}
}
solve(0, 0);
get(0, 0);
for (int i = 0; i < n; i++) cout << sol[i] << " ";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, x, a, c, ans;
vector<long long> v;
int main() {
cin >> n >> k >> x;
for (long long i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
ans += a;
}
c = v.size() - 1;
for (long long i = 0; i < k; i++) {
if (x < v[c]) {
ans -= v[c] - x;
} else {
break;
}
c--;
}
cout << ans;
cout << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int x, y, a, b;
int t1, t2;
scanf("%d %d %d %d", &a, &b, &x, &y);
int c;
t1 = a;
t2 = b;
while (a % b) {
c = a % b;
a = b;
b = c;
}
c = (t1 * t2) / b;
printf("%d\n", (y / c) - (x - 1) / c);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = INT_MAX;
const long long N = 2e5 + 5;
int n, mn = INF, ans;
string s, a = "ACTG";
int main() {
ios_base::sync_with_stdio(false), cin.tie(), cout.tie();
cin >> n >> s;
for (int i = 0; i < n - 3; i++) {
for (int j = 0; j < 4; j++) {
int x = (int)a[j];
int y = (int)s[i + j];
int a = abs(y - x);
int b = 90 - y + (x - 65 + 1);
int c = (y - 65) + (90 - x) + 1;
ans += min(a, min(b, c));
}
mn = min(mn, ans);
ans = 0;
}
cout << mn;
}
| 2 |
#include <bits/stdc++.h>
const int SIZE = 1e2 + 5;
using namespace std;
int Inc[SIZE];
int Dec[SIZE];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
int n, m;
cin >> n >> m;
while (m-- > 0) {
int x, y, z;
cin >> x >> y >> z;
Inc[x] += z;
Dec[y] += z;
}
int Ans = 0;
for (int i = 1; i < n + 1; i++)
if (Dec[i] > Inc[i]) Ans += (Dec[i] - Inc[i]);
cout << Ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e4 + 10;
const long long ZERO = 0;
const long long SADAT = 7.84e-17;
const long long INF = 1e9;
const long long mod = 1e9 + 7;
int q[300];
char r[300];
long double dp[300][300];
int main() {
int n, m;
long long t;
cin >> n >> m >> t;
memset(q, 63, sizeof(q));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int p;
cin >> p;
q[i + j] = min(q[i + j], p);
}
int l = n + m - 1;
vector<pair<int, int> > v;
for (int i = 0; i < l; i++) {
v.push_back(make_pair(q[i], i));
}
sort(v.begin(), v.end());
--t;
for (int i = 0; i < l; i++) {
r[v[i].second] = '(';
for (int j = 0; j <= l; j++)
for (int k = 0; k <= l; k++) dp[j][k] = 0;
dp[0][0] = 1;
for (int j = 0; j < l; j++) {
for (int k = 0; k < l; k++) {
if (r[j] != ')') dp[j + 1][k + 1] += dp[j][k];
if (r[j] != '(' && k > 0) dp[j + 1][k - 1] += dp[j][k];
}
}
if (dp[l][0] <= t) {
t -= (long long)dp[l][0];
r[v[i].second] = ')';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << r[i + j];
cout << '\n';
}
return (0);
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
string s;
cin >> s;
for (int i = 0; i < t; i++) {
for (int j = n - 2; j >= 0; j--) {
if (s[j] == 'B' && s[j + 1] == 'G') {
swap(s[j], s[j + 1]);
j--;
}
}
}
cout << s;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int prime(int x) {
if (x == 2) return 1;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
return 0;
}
}
return 1;
}
int main() {
int n;
cin >> n;
if (prime(n)) {
cout << 1 << endl << n << endl;
return 0;
}
if (prime(n - 2)) {
cout << 2 << endl << 2 << " " << n - 2 << endl;
return 0;
}
if (prime(n - 4)) {
cout << 3 << endl << 2 << " " << 2 << " " << n - 4 << endl;
return 0;
}
cout << 3 << endl;
cout << 3 << " ";
for (int i = 3; i <= n - 6; i++) {
int p1 = i, p2 = n - i - 3;
if (prime(p1) && prime(p2)) {
cout << p1 << " " << p2;
return 0;
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4000;
long long vis[maxn], cnt[maxn], sum[maxn];
struct Node {
int v, rt, p;
} aa[maxn];
bool cmp(Node a, Node b) {
if (a.v != b.v) return a.v < b.v;
return a.p < b.p;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> aa[i].p >> aa[i].v;
aa[i].rt = i;
}
sort(aa + 1, aa + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
sum[aa[i].p]++;
}
long long mi_ans = -1;
for (int i = 1; i <= n; i++) {
long long ns = 0;
long long ans = 0;
memset(cnt, 0, sizeof(cnt));
memset(vis, 0, sizeof(vis));
for (int j = 1; j <= n; ++j) {
if (aa[j].p == 1)
ns++, vis[aa[j].rt] = 1;
else {
if (sum[aa[j].p] - cnt[aa[j].p] >= i) {
cnt[aa[j].p]++;
ans += aa[j].v;
vis[aa[j].rt] = 1;
ns++;
}
}
}
for (int j = 1; j <= n; ++j) {
if (ns >= i) break;
if (vis[aa[j].rt] == 1) continue;
ns++;
ans += aa[j].v;
}
if (mi_ans == -1)
mi_ans = ans;
else
mi_ans = min(ans, mi_ans);
}
cout << mi_ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[150], b[150], c[300];
int flag, len, i;
while (gets(a)) {
gets(b);
memset(c, 0, sizeof(c));
flag = 0;
len = strlen(a);
for (i = 0; i < len; i++) {
if (a[i] == b[i])
c[i] = a[i];
else if (a[i] < b[i]) {
flag = 1;
break;
} else
c[i] = b[i];
}
if (flag == 1)
printf("-1\n");
else
puts(c);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int prime[maxn];
bool is_prime[maxn];
int pp[maxn];
int sieve(int n) {
int p = 0;
for (int i = 0; i <= n; ++i) is_prime[i] = true;
is_prime[0] = is_prime[1] = false;
for (int i = 2; i <= n; ++i) {
if (is_prime[i]) {
prime[p++] = i;
for (int j = i + i; j <= n; j += i) is_prime[j] = false;
}
}
return p;
}
int a[maxn];
vector<int> ve[maxn];
bool vis[maxn];
int ans = 0;
int dfs(int x, int p) {
if (a[x] % p != 0) return 0;
int res = 1;
while (a[x] % p == 0) a[x] /= p;
vector<int> temp;
for (auto m : ve[x]) {
if (a[m] % p) continue;
temp.push_back(dfs(m, p));
}
sort(temp.rbegin(), temp.rend());
if (temp.size()) res = res + temp[0];
if (temp.size() > 1)
ans = max(ans, res + temp[1]);
else
ans = max(ans, res);
return res;
}
int main() {
int la = sieve(ceil(sqrt(200000.0)));
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
ve[u].push_back(v);
ve[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < la; j++) {
if (a[i] > 1) {
dfs(i, prime[j]);
}
}
if (a[i] > 1) {
dfs(i, a[i]);
}
}
printf("%d\n", ans);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n;
string cards[105];
map<char, int> m;
bool is_distinguishable(string a, string b, int mask) {
if (a == b) return true;
if (a[0] == b[0])
return (((1 << (a[1] - '0' - 1)) & mask) != 0) ||
(((1 << (b[1] - '0' - 1)) & mask) != 0);
if (a[1] == b[1])
return (((1 << m[a[0]]) & mask) != 0) || (((1 << m[b[0]]) & mask) != 0);
return (((1 << (a[1] - '0' - 1)) & mask) != 0) ||
(((1 << (b[1] - '0' - 1)) & mask) != 0) ||
(((1 << m[a[0]]) & mask) != 0) || (((1 << m[b[0]]) & mask) != 0);
}
bool is_valid_hint(int mask) {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (!is_distinguishable(cards[i], cards[j], mask)) return false;
}
}
return true;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> cards[i];
}
m['R'] = 5;
m['G'] = 6;
m['B'] = 7;
m['Y'] = 8;
m['W'] = 9;
int y = 1 << 10;
int ans = 10;
for (int mask = 0; mask < y; mask++) {
if (is_valid_hint(mask)) ans = min(ans, __builtin_popcount(mask));
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x, y;
cin >> x >> y;
vector<char> pn(n);
vector<int> px(n), py(n);
vector<int> mind(8, ((int)2e9 + 1));
vector<int> minp(8, -1);
for (int i = 0; i < n; i++) cin >> pn[i] >> px[i] >> py[i];
int d = 2e9;
for (int i = 0; i < n; i++) {
if (py[i] == y) {
if (px[i] > x) {
d = px[i] - x;
if (d < mind[0]) {
mind[0] = d;
minp[0] = i;
};
} else {
d = x - px[i];
if (d < mind[1]) {
mind[1] = d;
minp[1] = i;
};
}
} else if (px[i] == x) {
if (py[i] > y) {
d = py[i] - y;
if (d < mind[2]) {
mind[2] = d;
minp[2] = i;
};
} else {
d = y - py[i];
if (d < mind[3]) {
mind[3] = d;
minp[3] = i;
};
}
} else if (px[i] - x == py[i] - y) {
if (px[i] > x) {
d = px[i] - x;
if (d < mind[4]) {
mind[4] = d;
minp[4] = i;
};
} else {
d = x - px[i];
if (d < mind[5]) {
mind[5] = d;
minp[5] = i;
};
}
} else if (px[i] - x == y - py[i]) {
if (px[i] > x) {
d = px[i] - x;
if (d < mind[6]) {
mind[6] = d;
minp[6] = i;
};
} else {
d = x - px[i];
if (d < mind[7]) {
mind[7] = d;
minp[7] = i;
};
}
}
}
bool res = false;
for (int i = 0; i < 4; i++) {
if (minp[i] != -1) {
char piece = pn[minp[i]];
if (piece == 'R' || piece == 'Q') {
res = true;
}
}
}
for (int i = 4; i < 8; i++) {
if (minp[i] != -1) {
char piece = pn[minp[i]];
if (piece == 'B' || piece == 'Q') {
res = true;
}
}
}
if (res) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long n, k, mn = -1, mx = 0;
cin >> n >> k;
map<int, int> x;
for (int j = 0; j < n; j++) {
int t;
cin >> t;
t = t % k;
x[t]++;
if (mx <= x[t] && t != 0) {
if (mx == x[t])
mn = max(mn, k - t);
else
mn = k - t;
mx = x[t];
}
}
if (mx)
cout << k * (mx - 1) + mn + 1 << endl;
else
cout << 0 << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
vector<pair<long long int, pair<long long int, long long int> > > ans;
for (long long int i = 0; i < ((long long int)(300)); ++i)
for (long long int j = 0; j < ((long long int)(12)); ++j)
ans.push_back(make_pair(abs(n - (i * 36 + j * 3)), make_pair(i, j)));
sort((ans).begin(), (ans).end());
cout << ans[0].second.first << " " << ans[0].second.second << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, d[15][15], res = -1;
int main(int argc, char* argv[]) {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &d[i][j]);
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
d[i][j] =
((d[i][j]) > (d[i][k] + d[k][j]) ? (d[i][k] + d[k][j]) : (d[i][j]));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) res = ((res) > (d[i][j]) ? (res) : (d[i][j]));
printf("%d\n", res);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long x, y, z;
if (a < b) {
x = a;
y = b;
} else {
x = b;
y = a;
}
while (x > 0) {
z = x;
x = y % x;
y = z;
}
return y;
}
int main() {
long long a[100005], num, g, i, n;
scanf("%I64d", &n);
num = a[0] = 0;
for (i = 1; i <= n; i++) scanf("%I64d", &a[i]);
sort(a, a + n + 1);
for (i = 0; i < n; i++) {
num += (a[i + 1] - a[i]) * ((2 * n + 1) * i - 2 * (1 + i) * i + n);
}
g = gcd(num, n);
printf("%I64d %I64d\n", num / g, n / g);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2000000000000000;
int main() {
char str[100010];
int b[100010];
int rol = 100010;
int minIndex[200100];
for (int i = 0; i < 200100; ++i) minIndex[i] = -2;
int len;
scanf("%i", &len);
scanf("%s", str);
b[0] = -1 + 2 * (*str - '0');
for (int i = 1; i < len; ++i) b[i] = b[i - 1] - 1 + 2 * (str[i] - '0');
minIndex[rol] = -1;
for (int i = 0; i < len; ++i)
if (minIndex[b[i] + rol] == -2) minIndex[b[i] + rol] = i;
int res = 0;
for (int i = 0; i < len; ++i) {
int cur = i - minIndex[b[i] + rol];
if (res < cur) res = cur;
}
printf("%i", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int reader_pt = 1048576, reader_last;
char reader_buf[1048576];
int writer_pt = 0;
char writer_buf[1048576];
void reader(int *x) {
int k, m = 0;
*x = 0;
for (;;) {
{
if (reader_pt == 1048576)
reader_pt = 0,
reader_last = fread(reader_buf, sizeof(char), 1048576, stdin);
(k) = reader_buf[reader_pt++];
};
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
{
if (reader_pt == 1048576)
reader_pt = 0,
reader_last = fread(reader_buf, sizeof(char), 1048576, stdin);
(k) = reader_buf[reader_pt++];
};
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
void reader(long long *x) {
int k, m = 0;
*x = 0;
for (;;) {
{
if (reader_pt == 1048576)
reader_pt = 0,
reader_last = fread(reader_buf, sizeof(char), 1048576, stdin);
(k) = reader_buf[reader_pt++];
};
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
{
if (reader_pt == 1048576)
reader_pt = 0,
reader_last = fread(reader_buf, sizeof(char), 1048576, stdin);
(k) = reader_buf[reader_pt++];
};
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
int reader(char c[]) {
int i, s = 0;
for (;;) {
{
if (reader_pt == 1048576)
reader_pt = 0,
reader_last = fread(reader_buf, sizeof(char), 1048576, stdin);
(i) = reader_buf[reader_pt++];
};
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF) break;
}
c[s++] = i;
for (;;) {
{
if (reader_pt == 1048576)
reader_pt = 0,
reader_last = fread(reader_buf, sizeof(char), 1048576, stdin);
(i) = reader_buf[reader_pt++];
};
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) break;
c[s++] = i;
}
c[s] = '\0';
return s;
}
template <class T, class S>
void reader(T *x, S *y) {
reader(x);
reader(y);
}
template <class T, class S, class U>
void reader(T *x, S *y, U *z) {
reader(x);
reader(y);
reader(z);
}
template <class T, class S, class U, class V>
void reader(T *x, S *y, U *z, V *w) {
reader(x);
reader(y);
reader(z);
reader(w);
}
void writer(int x, char c) {
int s = 0, m = 0;
char f[10];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) {
if (writer_pt == 1048576)
writer_pt = 0, fwrite(writer_buf, sizeof(char), 1048576, stdout);
writer_buf[writer_pt++] = ('-');
};
while (s--) {
if (writer_pt == 1048576)
writer_pt = 0, fwrite(writer_buf, sizeof(char), 1048576, stdout);
writer_buf[writer_pt++] = (f[s] + '0');
};
{
if (writer_pt == 1048576)
writer_pt = 0, fwrite(writer_buf, sizeof(char), 1048576, stdout);
writer_buf[writer_pt++] = (c);
};
}
void writer(long long x, char c) {
int s = 0, m = 0;
char f[20];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) {
if (writer_pt == 1048576)
writer_pt = 0, fwrite(writer_buf, sizeof(char), 1048576, stdout);
writer_buf[writer_pt++] = ('-');
};
while (s--) {
if (writer_pt == 1048576)
writer_pt = 0, fwrite(writer_buf, sizeof(char), 1048576, stdout);
writer_buf[writer_pt++] = (f[s] + '0');
};
{
if (writer_pt == 1048576)
writer_pt = 0, fwrite(writer_buf, sizeof(char), 1048576, stdout);
writer_buf[writer_pt++] = (c);
};
}
void writer(const char c[]) {
int i;
for (i = 0; c[i] != '\0'; i++) {
if (writer_pt == 1048576)
writer_pt = 0, fwrite(writer_buf, sizeof(char), 1048576, stdout);
writer_buf[writer_pt++] = (c[i]);
};
}
void writer(const char x[], char c) {
int i;
for (i = 0; x[i] != '\0'; i++) {
if (writer_pt == 1048576)
writer_pt = 0, fwrite(writer_buf, sizeof(char), 1048576, stdout);
writer_buf[writer_pt++] = (x[i]);
};
{
if (writer_pt == 1048576)
writer_pt = 0, fwrite(writer_buf, sizeof(char), 1048576, stdout);
writer_buf[writer_pt++] = (c);
};
}
template <class T>
void writerLn(T x) {
writer(x, '\n');
}
template <class T, class S>
void writerLn(T x, S y) {
writer(x, ' ');
writer(y, '\n');
}
template <class T, class S, class U>
void writerLn(T x, S y, U z) {
writer(x, ' ');
writer(y, ' ');
writer(z, '\n');
}
template <class T>
void writerArr(T x[], int n) {
int i;
if (!n) {
{
if (writer_pt == 1048576)
writer_pt = 0, fwrite(writer_buf, sizeof(char), 1048576, stdout);
writer_buf[writer_pt++] = ('\n');
};
return;
}
for (i = 0; i < n - 1; i++) writer(x[i], ' ');
writer(x[n - 1], '\n');
}
template <class T>
void sort(int N, T a[], void *mem = NULL) {
sort(a, a + N);
}
template <class T1, class T2>
void sort(int N, T1 a[], T2 b[], void *mem) {
int i;
pair<T1, T2> *r = (pair<T1, T2> *)mem;
for (i = 0; i < N; i++) r[i].first = a[i], r[i].second = b[i];
sort(r, r + N);
for (i = 0; i < N; i++) a[i] = r[i].first, b[i] = r[i].second;
}
template <class T1, class T2, class T3>
void sort(int N, T1 a[], T2 b[], T3 c[], void *mem) {
int i;
pair<T1, pair<T2, T3> > *r = (pair<T1, pair<T2, T3> > *)mem;
for (i = 0; i < N; i++)
r[i].first = a[i], r[i].second.first = b[i], r[i].second.second = c[i];
sort(r, r + N);
for (i = 0; i < N; i++)
a[i] = r[i].first, b[i] = r[i].second.first, c[i] = r[i].second.second;
}
template <class T1, class T2, class T3, class T4>
void sort(int N, T1 a[], T2 b[], T3 c[], T4 d[], void *mem) {
int i;
pair<pair<T1, T2>, pair<T3, T4> > *r =
(pair<pair<T1, T2>, pair<T3, T4> > *)mem;
for (i = 0; i < N; i++)
r[i].first.first = a[i], r[i].first.second = b[i], r[i].second.first = c[i],
r[i].second.second = d[i];
sort(r, r + N);
for (i = 0; i < N; i++)
a[i] = r[i].first.first, b[i] = r[i].first.second, c[i] = r[i].second.first,
d[i] = r[i].second.second;
}
int N;
long long H[111111], A[111111];
int M, K;
long long P;
int rem[5100], nx[5100];
int get_nx(int a) {
if (a >= M) return M;
if (rem[a]) return a;
return nx[a] = get_nx(nx[a]);
}
int main() {
int i, j, ng;
long long L, R, C, dec, tm, sm, x;
void *mem = malloc(77000000);
reader(&N, &M, &K, &P);
for (i = 0; i < N; i++) reader(H + i, A + i);
sort(N, A, H, mem);
L = 0;
R = 100000000000000LL;
for (i = 0; i < N; i++) L = max(L, A[i]);
while (L < R) {
C = (L + R) / 2;
for (i = 0; i < M; i++) rem[i] = K, nx[i] = i + 1;
ng = 0;
for (i = 0; i < N; i++) {
dec = (H[i] + A[i] * M) - C;
if (dec <= 0) continue;
tm = dec / P;
sm = dec % P;
if (sm) {
x = (sm - H[i] + A[i] - 1) / A[i];
x = max(0LL, x);
x = get_nx(x);
if (x >= M) {
ng = 1;
break;
}
rem[x]--;
}
for (j = 0; j < tm; j++) {
x = (sm + (j + 1) * P - H[i] + A[i] - 1) / A[i];
x = max(0LL, x);
x = get_nx(x);
if (x >= M) {
ng = 1;
break;
}
rem[x]--;
}
}
if (ng)
L = C + 1;
else
R = C;
}
writerLn(L);
{
fwrite(writer_buf, sizeof(char), writer_pt, stdout);
writer_pt = 0;
};
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 5;
const long long linf = 1e18;
const long double eps = 1e-8;
inline void swap(int &a, int &b) {
int t = a;
a = b;
b = t;
}
inline long double Fabs(long double x) { return x < 0 ? -x : x; }
inline bool eq(long double x, long double y) { return Fabs(x - y) <= eps; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
inline int Abs(int x) { return x < 0 ? -x : x; }
inline bool in(int l, int r, long long x) {
return (l <= x && x <= r) || (r <= x && x <= l);
}
struct Point {
int x, y;
inline void read(void) { scanf("%d%d", &x, &y); }
inline friend bool operator<(const Point &p, const Point &q) {
return p.x == q.x ? p.y < q.y : p.x < q.x;
}
inline friend bool operator==(const Point &p, const Point &q) {
return p.x == q.x && p.y == q.y;
}
};
struct Seg {
Point p, q;
long double k, b;
inline void calc(void) {
if (p.x == q.x) {
k = linf;
b = -linf;
return;
}
k = (long double)(p.y - q.y) / (p.x - q.x);
b = p.y - k * p.x;
}
inline void read(void) {
p.read();
q.read();
if (p.x > q.x) swap(p, q);
calc();
}
inline bool inx(long long x) { return in(p.x, q.x, x); }
inline bool iny(long long y) { return in(p.y, q.y, y); }
} a[MAXN];
Point crs[MAXN];
int cnt = 0;
void chk(Seg a, Seg b) {
if (eq(a.k, b.k)) return;
if (eq(b.k, linf)) swap(a, b);
long double k1 = a.k, b1 = a.b;
long double k2 = b.k, b2 = b.b;
if (eq(k1, linf)) {
int x = a.p.x;
if (!b.inx(x)) return;
long double yy = k2 * x + b2;
long long y = roundl(yy);
if (!eq(y, yy) || !a.iny(y)) return;
crs[++cnt] = (Point){x, (int)y};
return;
}
long double xx = (b2 - b1) / (k1 - k2), yy = k1 * xx + b1;
long long x = roundl(xx), y = roundl(yy);
if (eq(x, xx) && eq(y, yy))
if (a.inx(x) && a.iny(y) && b.inx(x) && b.iny(y))
crs[++cnt] = (Point){(int)x, (int)y};
}
int main(void) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) a[i].read();
long long ans = 0;
for (int i = 1; i <= n; ++i) {
cnt = 0;
for (int j = i + 1; j <= n; ++j) chk(a[i], a[j]);
sort(crs + 1, crs + cnt + 1);
cnt = unique(crs + 1, crs + cnt + 1) - crs - 1;
int dx = Abs(a[i].p.x - a[i].q.x);
int dy = Abs(a[i].p.y - a[i].q.y);
ans += gcd(dx, dy) + 1 - cnt;
}
printf("%lld", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
const int N = 200005;
using namespace std;
set<int> col[N];
int seg[N * 3];
int mnv[N * 3];
int mxt[N * 3];
int tag[N * 3];
int lcon[N * 3];
int rcon[N * 3];
inline void _down(int rt) {
if (tag[rt]) {
mnv[(rt << 1)] += tag[rt];
mnv[(rt << 1 | 1)] += tag[rt];
tag[(rt << 1)] += tag[rt];
tag[(rt << 1 | 1)] += tag[rt];
tag[rt] = 0;
}
}
inline void _up(int rt) {
int ls = rt << 1;
int rs = rt << 1 | 1;
mxt[rt] = max(mxt[ls], mxt[rs]);
mnv[rt] = min(mnv[ls], mnv[rs]);
if (mnv[ls] < mnv[rs]) {
seg[rt] = seg[ls];
lcon[rt] = lcon[ls];
rcon[rt] = max(mxt[rs], rcon[ls]);
} else if (mnv[ls] > mnv[rs]) {
seg[rt] = seg[rs];
rcon[rt] = rcon[rs];
lcon[rt] = max(mxt[ls], lcon[rs]);
} else {
lcon[rt] = lcon[ls];
rcon[rt] = rcon[rs];
seg[rt] = seg[ls] + seg[rs] + max(lcon[rs], rcon[ls]);
}
}
void upd(int rt, int l, int r, int ul, int ur, int v) {
if (ul > ur) return;
if (ul <= l && r <= ur) return mnv[rt] += v, void(tag[rt] += v);
int mid = (l + r) >> 1;
_down(rt);
if (ul <= mid) upd((rt << 1), l, mid, ul, ur, v);
if (ur > mid) upd((rt << 1 | 1), mid + 1, r, ul, ur, v);
_up(rt);
}
void cov(int rt, int l, int r, int p, int v) {
if (l == r) return void(mxt[rt] = lcon[rt] = v);
int mid = (l + r) >> 1;
_down(rt);
if (p <= mid)
cov((rt << 1), l, mid, p, v);
else
cov((rt << 1 | 1), mid + 1, r, p, v);
_up(rt);
}
int n, q;
int base[N];
void mdf(int c, int mk) {
int w;
if (!(w = col[c].size())) return;
cov(1, 1, n, *col[c].begin(), mk > 0 ? w : 0);
upd(1, 1, n, *col[c].begin(), *col[c].rbegin() - 1, mk);
}
int val_it() { return n - seg[1] - lcon[1] - rcon[1]; }
int main() {
int x, y, z;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) scanf("%d", &base[i]), col[base[i]].insert(i);
for (int i = 1; i < N; ++i) mdf(i, 1);
printf("%d\n", val_it());
while (q--) {
scanf("%d%d", &x, &y);
z = base[x];
mdf(z, -1);
col[z].erase(x);
mdf(z, 1);
mdf(y, -1);
col[y].insert(x);
mdf(y, 1);
printf("%d\n", val_it());
base[x] = y;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, ans = 0, k = INT_MAX;
const int MAXN = 1000;
char s[MAXN];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n - 2; i++) {
if (s[i] == '1' && s[i + 1] == '0' && s[i + 2] == '1' && k - i != -2) {
ans++;
k = i;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int p[N], n, k, m, r[N];
int find(int x) {
if (x != p[x]) p[x] = find(p[x]);
return p[x];
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= k; i++) {
int a, b;
scanf("%d %d", &a, &b);
p[find(a)] = find(b);
}
unordered_set<int> S;
cin >> m;
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (find(a) == find(b)) S.insert(find(a));
}
for (int i = 1; i <= n; i++) {
if (!S.count(find(i))) r[find(i)]++;
}
int res = 0;
for (int i = 1; i <= n; i++) {
res = max(res, r[i]);
}
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long min(unsigned long long x, unsigned long long y) {
if (x < y) return x;
return y;
}
unsigned long long max(unsigned long long x, unsigned long long y) {
if (x < y) return y;
return x;
}
long long min(long long x, long long y) {
if (x < y) return x;
return y;
}
long long max(long long x, long long y) {
if (x < y) return y;
return x;
}
double min(double x, double y) {
if (x < y) return x;
return y;
}
double max(double x, double y) {
if (x < y) return y;
return x;
}
unsigned long long gcd(unsigned long long x, unsigned long long y) {
if (!x) return y;
if (!y) return x;
if (x > y) swap(x, y);
return gcd(x, y % x);
}
unsigned long long inv(unsigned long long a, unsigned long long c) {
if (a == 1) {
return 1;
}
return ((c - (c / a)) * inv(c % a, c)) % c;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, t, sum = 0, ans = 0, pos = 0;
cin >> n >> t;
vector<long long> a(n, 0);
multiset<long long> s;
for (int i = 0; i < n; i++) {
cin >> a[i];
s.insert(a[i]);
sum += a[i];
}
while (!s.empty()) {
if (sum <= t) {
ans += (t / sum) * ((long long)s.size());
t %= sum;
} else {
multiset<long long>::iterator it = s.end();
--it;
if ((*it) <= t) {
if ((s.find(a[pos]) != s.end()) && (a[pos] <= t)) {
ans++;
t -= a[pos];
pos++;
if (pos == n) pos = 0;
} else {
pos++;
if (pos == n) pos = 0;
}
continue;
}
sum -= (*it);
s.erase(it);
}
}
cout << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define mii map<int, int>
#define pb push_back
#define mk make_pair
const int inf = 0x3f3f3f3f;
const ll mod = 1000000007;
const ll linf = 0x3f3f3f3f3f3f3f3f;
#define deb(k) cerr << #k << ": " << k << "\n";
#define fastcin cin.tie(0)->sync_with_stdio(0);
#define st first
#define nd second
#define MAXN 1000100
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll cnt[32];
ll count(ll l, ll x, ll k, ll small){
if(l == x+1){
if(small >= k) return min(k, (k+1)/2);
return (k+1)/2;
}
if( ( 1ll<<(l-x) ) == k ) return (1ll<<(l-x)) - 1;
if( ( 1ll<<(l-x) ) < k ){
k -= (1ll<<(l-x));
small += (1ll<<l) - (1ll<<(l-x));
if(small >= k) return min( (1ll<<(l-x)) -1 + 1 + count(l-1, x, k, small) , (1ll<<(l-x)) - 1 + k);
return (1ll<<(l-x)) - 1 + 1 + count(l-1, x, k, small);
}
if(small >= k) return min(1 + count(l-1, x, k, small), k);
return 1 + count(l-1, x, k, small);
}
void solve(){
int n,q;
cin>>n>>q;
for(int i=0;i<n;i++) cin>>cnt[i];
while(q--){
ll p, x, k;
cin>>p>>x>>k;
if(p == 1) cnt[x] = k;
else{
ll small = 0;
ll ans = 0;
for(int i=0;i<=x;i++){
k -= cnt[i];
small += (cnt[i]<<i) - cnt[i];
}
if(k < 0){
cout<<"0\n";
continue;
}
ll ind = -1;
//cout<<-1<<" "<<ans<<" "<<k<<" "<<" "<<small<<"\n";
for(int i=x+1;i<n;i++){
ll aux = k / (1ll<<(i-x));
if(aux >= cnt[i]){
k -= (cnt[i]<<(i-x));
ans += (cnt[i]<<(i-x)) - cnt[i];
small += (cnt[i]<<i) - (cnt[i]<<(i-x));
continue;
}
ind = i;
k -= (aux<<(i-x));
ans += (aux<<(i-x)) - aux;
small += (aux<<i) - (aux<<(i-x));
break;
}
if(ind == -1){
if(small >= k) cout<<ans + k<<"\n";
else cout<<"-1\n";
continue;
}
//cout<<ind<<" "<<ans<<" "<<k<<" "<<small<<"\n";
ans += count(ind, x, k, small) ;
cout<<ans<<"\n";
}
}
// Have you read the problem again?
// Maybe you understood the wrong problem
}
int main(){
fastcin;
solve();
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
long long i, p[100005], j, n, k, flag, ctr, a[100005];
vector<long long> fac;
int main() {
cin >> n;
for (i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
fac.push_back(i);
fac.push_back(n / i);
}
}
flag = 1;
for (i = 0; i < n; i++) {
cin >> a[i];
if (!a[i]) flag = 0;
}
if (flag) {
cout << "YES";
return 0;
}
for (i = 0; i < fac.size(); i++) {
for (j = 0; j < fac[i]; j++) {
flag = 1;
k = j;
ctr = 0;
while (k < n + j) {
if (!a[k % n]) {
flag = 0;
break;
}
k += fac[i];
ctr++;
}
if (ctr < 3) flag = 0;
if (flag) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
return 0;
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int N = 2e5 + 10;
int arr[N], arr2[N];
int main(int argc, char const *argv[]) {
int n, k, q;
scanf("%d%d%d", &n, &k, &q);
for (int i = 0; i < n; i++) {
int l, r;
scanf("%d%d", &l, &r);
arr[l] += 1;
arr[r + 1] -= 1;
}
for (int i = 1; i < N; i++) {
arr[i] += arr[i - 1];
arr2[i] = arr2[i - 1] + (arr[i] >= k ? 1 : 0);
}
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", arr2[r] - arr2[l - 1]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ara[2005][2005];
int sum[2005];
char str[2005][2005];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", str[i] + 1);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (str[i][j] == '1') sum[j]++;
}
}
for (int i = 1; i <= n; i++) {
int ok = 0;
for (int j = 1; j <= m; j++) {
int MINUS = 0;
if (str[i][j] == '1') MINUS = 1;
if (sum[j] - MINUS > 0) ok++;
}
if (ok == m) {
cout << "YES\n";
return 0;
}
}
cout << "NO\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double dp[205][205][205];
struct y {
double p;
int num;
} haha[205];
bool compare(y a, y b) {
if (a.num != b.num)
return a.num > b.num;
else
return a.p >= b.p;
}
int main() {
int n, l, k, q;
memset(haha, 0, sizeof(haha));
memset(dp, 0, sizeof(dp));
cin >> n >> l >> k;
for (int i = 0; i < n; i++) {
cin >> q;
haha[i].p = q / 100.0;
}
for (int i = 0; i < n; i++) {
cin >> haha[i].num;
}
sort(haha, haha + n, compare);
dp[0][0][k] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
for (int z = 0; z <= 200; z++) {
if (haha[i - 1].num == -1) {
if (z > 0) dp[i][j + 1][z - 1] += dp[i - 1][j][z] * haha[i - 1].p;
} else {
int now = min(200, z + haha[i - 1].num);
if (now > 0) {
dp[i][j + 1][now] += dp[i - 1][j][z] * haha[i - 1].p;
}
}
dp[i][j][z] += dp[i - 1][j][z] * (1 - haha[i - 1].p);
}
}
}
double ans = 0;
for (int i = l; i <= 200; i++) {
for (int j = 0; j <= 200; j++) {
ans = ans + dp[n][i][j];
}
}
printf("%.12lf\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int N = 103;
using namespace std;
int n, m, a[N][N], sum, ans, now, c[N];
pair<int, int> b[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
for (int j = 1; j <= n; j++) scanf("%d", a[i] + j);
}
ans = m;
for (int i = 1; i < n; i++) {
sum = 0;
for (int j = 0; j < m; j++)
b[j] = make_pair(a[j][i] - a[j][n], j), sum += b[j].first;
sort(b, b + m);
for (now = 0; sum < 0 && now < m; now++) sum -= b[now].first;
if (now <= ans) {
ans = now;
for (int j = 0; j < now; j++) c[j] = b[j].second;
}
}
printf("%d\n", ans);
for (int j = 0; j < ans; j++) printf("%d ", c[j] + 1);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int size_n, size_m, size_q;
int result[105][105];
void solve(int curIterate);
int main() {
int ii, jj;
cin >> size_n >> size_m >> size_q;
solve(size_q);
for (ii = 0; ii < size_n; ii++) {
for (jj = 0; jj < size_m; jj++) cout << result[ii][jj] << " ";
cout << endl;
}
return 0;
}
void solve(int curIterate) {
int ii;
int inputType, inputValue1 = 0, inputValue2 = 0, inputValue3 = 0, last;
if (curIterate == 0) return;
cin >> inputType;
if (inputType == 3)
cin >> inputValue1 >> inputValue2 >> inputValue3;
else
cin >> inputValue1;
solve(curIterate - 1);
inputValue1--;
inputValue2--;
if (inputType == 3)
result[inputValue1][inputValue2] = inputValue3;
else if (inputType == 1) {
last = result[inputValue1][size_m - 1];
for (ii = (size_m - 2); ii > -1; ii--)
result[inputValue1][ii + 1] = result[inputValue1][ii];
result[inputValue1][0] = last;
} else {
last = result[size_n - 1][inputValue1];
for (ii = (size_n - 2); ii > -1; ii--)
result[ii + 1][inputValue1] = result[ii][inputValue1];
result[0][inputValue1] = last;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (!(n & 1)) {
cout << "white" << endl << 1 << " " << 2 << endl;
} else {
cout << "black" << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, Q, w[400010], cnt, dfn[400010], low[400010], tot, blo[400010];
int fa[400010], top[400010], pos[400010], po[400010], dep[400010], size[400010],
nxt[400010];
int k, la[400010], ff[400010], tp, q[400010], flag[400010];
struct node {
int a, b;
} e[400010];
struct info {
int x, y;
bool operator<(const info &p) const { return y > p.y; }
};
struct data {
int minn;
} t[400010 * 4];
vector<int> s[400010];
priority_queue<info> h[400010];
void add(int a, int b) {
e[++k] = (node){a, b};
ff[k] = la[a];
la[a] = k;
e[++k] = (node){b, a};
ff[k] = la[b];
la[b] = k;
}
void insert(int x, int p) {
if (blo[x] == p) return;
s[p].push_back(x);
blo[x] = p;
}
void dfs(int x, int pre) {
dfn[x] = ++cnt;
low[x] = cnt;
for (int a = la[x]; a; a = ff[a]) {
if (!dfn[e[a].b]) {
q[++tp] = a;
dfs(e[a].b, x);
low[x] = min(low[x], low[e[a].b]);
if (low[e[a].b] >= dfn[x]) {
tot++;
for (; tp; tp--) {
insert(e[q[tp]].a, tot);
insert(e[q[tp]].b, tot);
if (q[tp] == a) {
tp--;
break;
}
}
}
} else if (dfn[e[a].b] < dfn[x] && e[a].b != pre) {
q[++tp] = a;
low[x] = min(low[x], dfn[e[a].b]);
}
}
}
void solve() {
k = 0;
memset(la, 0, sizeof(la));
for (int i = 1; i <= tot; i++)
for (int j = 0; j < s[i].size(); j++) add(n + i, s[i][j]);
}
void bfs() {
int l = 1, r = 2;
q[1] = 1;
dep[1] = 1;
cnt = 0;
while (l < r) {
int x = q[l++];
size[x] = 1;
for (int a = la[x]; a; a = ff[a]) {
if (dep[e[a].b]) continue;
q[r] = e[a].b;
fa[q[r]] = x;
dep[q[r]] = dep[x] + 1;
r++;
}
}
for (int i = 1; i <= n; i++)
if (fa[i]) h[fa[i]].push((info){i, w[i]});
for (int i = r - 1; i; i--) {
int x = q[i];
if (!fa[x]) continue;
size[fa[x]] += size[x];
if (size[nxt[fa[x]]] < size[x]) nxt[fa[x]] = x;
}
for (int i = 1; i < r; i++) {
int x = q[i];
if (top[x]) continue;
for (int j = x; j; j = nxt[j]) top[j] = x, po[pos[j] = ++cnt] = j;
}
}
int get(int x) {
if (x <= n) return w[x];
while (1) {
info p = h[x].top();
if (w[p.x] == p.y) return p.y;
h[x].pop();
}
}
class seg_tree {
public:
void build(int x, int l, int r) {
if (l == r) {
t[x].minn = get(po[l]);
return;
}
int mid = l + r >> 1, lc = x << 1, rc = lc + 1;
build(lc, l, mid);
build(rc, mid + 1, r);
t[x].minn = min(t[lc].minn, t[rc].minn);
}
int qry(int x, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return t[x].minn;
int mid = l + r >> 1, lc = x << 1, rc = lc + 1, res = 2100000000;
if (ql <= mid) res = min(res, qry(lc, l, mid, ql, qr));
if (qr > mid) res = min(res, qry(rc, mid + 1, r, ql, qr));
return res;
}
void modify(int x, int l, int r, int pos, int a, int b) {
if (l == r) {
if (po[l] > n) h[po[l]].push((info){a, b});
t[x].minn = get(po[l]);
return;
}
int mid = l + r >> 1, lc = x << 1, rc = lc + 1;
if (pos <= mid)
modify(lc, l, mid, pos, a, b);
else
modify(rc, mid + 1, r, pos, a, b);
t[x].minn = min(t[lc].minn, t[rc].minn);
}
} T;
int qry(int x, int y) {
int res = 2100000000;
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
res = min(res, T.qry(1, 1, cnt, pos[top[x]], pos[x]));
x = fa[top[x]];
}
if (pos[x] > pos[y]) swap(x, y);
res = min(res, T.qry(1, 1, cnt, pos[x], pos[y]));
if (x > n) res = min(res, w[fa[x]]);
return res;
}
int main() {
int a, b;
char ch;
scanf("%d%d%d", &n, &m, &Q);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 1; i <= m; i++) scanf("%d%d", &a, &b), add(a, b);
dfs(1, 0);
solve();
bfs();
T.build(1, 1, cnt);
while (Q--) {
scanf(" %c%d%d", &ch, &a, &b);
if (ch == 'A')
printf("%d\n", qry(a, b));
else {
if (w[a] == b) continue;
w[a] = b;
T.modify(1, 1, cnt, pos[a], a, b);
T.modify(1, 1, cnt, pos[fa[a]], a, b);
}
}
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
template <class AT, class UT>
struct SegmentTree {
AT I;
UT NU, v;
int N, l, r;
vector<AT> A;
vector<UT> U;
vector<int> L, R;
virtual AT op(const AT& i, const AT& j) = 0;
virtual AT us(int p, const UT& v) = 0;
SegmentTree(int N, AT I = 0, UT NU = INT_MIN)
: I(I), NU(NU), N(N), A(4 * N, I), U(4 * N, NU), L(4 * N), R(4 * N) {
build(1, 0, N - 1);
}
void build(int p, int i, int j) {
L[p] = i;
R[p] = j;
if (i != j) {
build(2 * p, i, (i + j) / 2);
build(2 * p + 1, (i + j) / 2 + 1, j);
}
}
SegmentTree(const vector<AT>& data, AT I = 0, UT NU = INT_MIN)
: I(I),
NU(NU),
N(data.size()),
A(4 * N),
U(4 * N, NU),
L(4 * N),
R(4 * N) {}
AT& build(int p, int i, int j, const vector<AT>& data) {
L[p] = i;
R[p] = j;
if (i == j) return A[p] = data[i];
return A[p] = op(build(2 * p, i, (i + j) / 2, data),
build(2 * p + 1, (i + j) / 2 + 1, j, data));
}
AT update(int p) {
if (l <= L[p] && R[p] <= r) return us(p, v);
if (R[p] < l || r < L[p] || L[p] == R[p]) return v == NU ? I : A[p];
us(2 * p, U[p]);
us(2 * p + 1, U[p]);
U[p] = NU;
AT r = op(update(2 * p), update(2 * p + 1));
if (v != NU) A[p] = r;
return r;
}
AT update(int i, int j, UT k) {
l = i;
r = j;
v = k;
return j < i ? I : update(1);
}
AT query(int i, int j) { return update(i, j, NU); }
};
struct ARR : SegmentTree<char, char> {
ARR(const vector<char>& data) : SegmentTree(data, 10, 10) {
if (N) build(1, 0, N - 1, data);
}
char op(const char& i, const char& j) { return i == I ? j : i; }
char us(int p, const char& v) {
if (v != NU) {
A[p] = v;
U[p] = v;
}
return A[p];
}
};
int n, m, k;
string s;
struct CTS : SegmentTree<array<int, 100>, array<int, 5> > {
CTS(const vector<array<int, 100> >& data)
: SegmentTree(data, array<int, 100>(), {INT_MIN, 0, 0, 0, 0}) {
if (N) build(1, 0, N - 1, data);
}
array<int, 100> op(const array<int, 100>& i, const array<int, 100>& j) {
array<int, 100> r = i;
for (int c = 0; c < 100; c++) r[c] += j[c];
return r;
}
array<int, 100> us(int p, const array<int, 5>& v) {
if (v != NU) {
array<int, 5> t = v;
if (L[p] != t[3]) t[0] = t[1];
if (R[p] != t[4]) t[2] = t[1];
A[p].fill(0);
int w = R[p] - L[p] + 1;
if (w == 1) {
A[p][k * t[0] + t[2]] = 1;
} else {
A[p][k * t[0] + t[1]]++;
A[p][k * t[1] + t[2]]++;
A[p][t[1] * (1 + k)] += w - 2;
}
U[p] = v;
}
return A[p];
}
};
int main() {
int i;
char cc;
ios::sync_with_stdio(false);
cin >> n >> m >> k >> s;
for (int c = 0; c < n; c++) s[c] -= 'a';
array<int, 100> t;
vector<array<int, 100> > data(n - 1);
for (int c = 0; c < n - 1; c++) data[c][k * s[c] + s[c + 1]] = 1;
ARR chars(vector<char>(s.begin(), s.end()));
CTS cts(data);
int x, y;
for (int c = 0; c < m; c++) {
cin >> i;
if (i == 1) {
cin >> x >> y >> cc;
x--;
y--;
cc -= 'a';
chars.update(x, y, cc);
x--;
if (x < 0) x++;
if (y == n - 1) y--;
cts.update(x, y,
{chars.query(x, x), cc, chars.query(y + 1, y + 1), x, y});
} else {
cin >> s;
int r = 1;
t = cts.query(0, n - 2);
for (int i = 0; i < s.size(); i++)
for (int j = i; j < s.size(); j++)
r += t[(s[j] - 'a') * k + s[i] - 'a'];
cout << r << endl;
}
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long mod = 1000000007;
const int MAXN = 150;
const int MAXL = 2000100;
int l, n;
char s1[MAXL], s2[MAXL], ans[MAXN];
struct edge {
int from, to, cap, flow, cost;
};
inline int ID(char c) {
if (c >= 'A' && c <= 'Z')
return c - 'A' + 26;
else
return c - 'a';
}
inline char idtoc(int id) {
if (id < 26) return 'a' + id;
return 'A' + id - 26;
}
struct MCMF {
int n, m, s, t;
vector<edge> edges;
vector<int> G[MAXN];
int inq[MAXN], d[MAXN], p[MAXN], a[MAXN];
void init(int n) {
this->n = n;
for (int i = 0; i < n; ++i) G[i].clear();
edges.clear();
}
void add(int from, int to, int cap, int cost) {
edges.push_back(edge{from, to, cap, 0, cost});
edges.push_back(edge{to, from, 0, 0, -cost});
m = edges.size();
G[from].push_back(m - 2);
G[to].push_back(m - 1);
}
bool BellmanFord(int s, int t, int &flow, int &cost) {
memset(d, INF, sizeof(d));
memset(inq, 0, sizeof(inq));
d[s] = 0, inq[s] = 1, p[s] = 0, a[s] = INF;
queue<int> q;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
inq[u] = 0;
for (int i = 0; i < G[u].size(); ++i) {
edge &e = edges[G[u][i]];
if (e.cap > e.flow && d[e.to] > d[u] + e.cost) {
d[e.to] = d[u] + e.cost;
p[e.to] = G[u][i];
a[e.to] = min(a[u], e.cap - e.flow);
if (!inq[e.to]) {
q.push(e.to);
inq[e.to] = 1;
}
}
}
}
if (d[t] == INF) return false;
flow += a[t];
cost += d[t] * a[t];
for (int u = t; u != s; u = edges[p[u]].from) {
edges[p[u]].flow += a[t];
edges[p[u] ^ 1].flow -= a[t];
}
return true;
}
int MincostMaxflow(int s, int t, int &cost) {
int flow = 0;
cost = 0;
while (BellmanFord(s, t, flow, cost))
;
return flow;
}
void out() {
m = edges.size();
int k = (n - 2) >> 1;
for (int i = 0; i < m; ++i) {
edge &e = edges[i];
if (e.flow == 1 && e.from != 0 && e.to != 2 * k + 1)
ans[e.from - 1] = idtoc(e.to - k - 1);
}
printf("%s\n", ans);
}
};
int g[MAXN][MAXN];
int main() {
scanf("%d%d%s%s", &l, &n, s1, s2);
MCMF G;
G.init(n * 2 + 2);
for (int i = 0; i < l; ++i) g[ID(s1[i])][ID(s2[i])]++;
for (int i = 0; i < n; ++i) {
G.add(0, i + 1, 1, 0);
G.add(i + 1 + n, 2 * n + 1, 1, 0);
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) G.add(i + 1, j + n + 1, 1, -g[i][j]);
int cost;
G.MincostMaxflow(0, 2 * n + 1, cost);
printf("%d\n", -cost);
G.out();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
using std::string;
long long power(long long b, long long p) {
if (p == 0) return 1;
long long ans = 1;
while (p > 1) {
if (p % 2 == 0) {
b *= b;
b %= 1000000007;
p /= 2;
} else {
ans *= b;
ans %= 1000000007;
p -= 1;
}
}
ans *= b;
ans %= 1000000007;
return ans;
}
int main() {
long long k, b, n, t, T;
double m;
cin >> k >> b >> n >> t;
if (k != 1) {
m = (double)(t * (k - 1) + b) / (double)((k - 1) + b);
T = n - (long long)((double)log(m) / (double)log(k));
} else
T = (1 - t) / b + n;
if (power(k, n - T + 1) <= m) T -= 1;
cout << max((long long)0, T);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e12;
const int MAXN = 1e6 + 1, MODM = 1e9 + 7, P = 1e6 + 3, MULT1 = 30, MULT2 = 239,
LUCKY = 13, ELEVEN = 11, MAXM = 101;
vector<int> g[MAXN];
vector<pair<int, int> > t[MAXN];
int f[MAXN << 2];
int n, m;
void update(int v, int tl, int tr, int ind) {
if (tl == tr)
f[v]++;
else {
int tm = (tl + tr) / 2;
if (ind <= tm)
update(v * 2, tl, tm, ind);
else
update(v * 2 + 1, tm + 1, tr, ind);
f[v] = f[v * 2] + f[v * 2 + 1];
}
}
int sum(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r) return f[v];
int tm = (tl + tr) / 2;
return sum(v * 2, tl, tm, l, min(r, tm)) +
sum(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
g[y].push_back(x);
}
for (int i = 0; i < m; i++) {
int k;
cin >> k;
int x = -1;
for (int o = 0; o < k; o++) {
int y = x + 1;
cin >> x;
t[x - 1].push_back(make_pair(y, i));
}
t[MAXN - 1].push_back(make_pair(x + 1, i));
}
vector<int> ans(m, 0);
for (int i = 1; i < MAXN; i++) {
for (int j = 0; j < g[i].size(); j++) update(1, 0, MAXN, g[i][j]);
for (int j = 0; j < t[i].size(); j++)
ans[t[i][j].second] += sum(1, 0, MAXN, t[i][j].first, i);
}
for (int i = 0; i < m; i++) cout << n - ans[i] << " ";
return 0;
}
| 14 |
#include <bits/stdc++.h>
long long read() {
long long x = 0, f = 1;
char c;
while ((c = getchar()) < '0' || c > '9') {
if (c == '-') f = -1;
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
long long T, n, m, l, r, a[40], b[40], dp[40][1 << 4];
long long dfs(long long x, long long s) {
if (!x) return 1;
if (dp[x][s] != -1) return dp[x][s];
long long ans = 0;
for (long long i = 0; i <= 1; i++)
for (long long j = 0; j <= 1; j++) {
if (i == 1 && j == 1) continue;
if (i > b[x] && s & 1) continue;
if (i < a[x] && s & 2) continue;
if (j > b[x] && s & 4) continue;
if (j < a[x] && s & 8) continue;
long long t = ((i == b[x]) * 1) | ((i == a[x]) * 2) | ((j == b[x]) * 4) |
((j == a[x]) * 8);
ans += dfs(x - 1, s & t);
}
dp[x][s] = ans;
return ans;
}
long long cal(long long l, long long r) {
n = 0;
m = 0;
memset(a, 0, sizeof a);
memset(b, 0, sizeof b);
while (l) a[++n] = l % 2, l /= 2;
while (r) b[++m] = r % 2, r /= 2;
return dfs(m, 15);
}
signed main() {
T = read();
while (T--) {
l = read();
r = read();
memset(dp, -1, sizeof dp);
printf("%lld\n", cal(l, r));
}
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
string str[3];
vector<int> adj1[4], adj2[4];
pair<int, int> sz[4];
int ted = 0;
int main() {
cin >> str[0] >> str[1] >> str[2];
for (int i = 0; i < 3; i++) {
if (str[i][1] == '>') {
adj1[str[i][0] - 'A'].push_back(str[i][2] - 'A');
adj2[str[i][2] - 'A'].push_back(str[i][0] - 'A');
}
if (str[i][1] == '<') {
adj2[str[i][0] - 'A'].push_back(str[i][2] - 'A');
adj1[str[i][2] - 'A'].push_back(str[i][0] - 'A');
}
}
for (int i = 0; i < 3; i++) {
sz[i] = make_pair(adj1[i].size(), i);
if (adj1[i].size() != 0 && adj2[i].size() != 0) ted++;
}
if (ted == 3) {
cout << "Impossible" << endl;
return 0;
}
sort(sz, sz + 3);
for (int i = 0; i < 3; i++) {
cout << (char)(sz[i].second + 'A');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int a[N], sum[N];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sum[0] = a[0];
for (int i = 1; i < n; i++) {
sum[i] = sum[i - 1] + a[i];
}
if (sum[n - 1] % k) {
return cout << "No", 0;
}
int tt = sum[n - 1] / k;
vector<int> ans;
int cnt = 0;
int tmp = 0;
for (int i = 0; i < n; i++) {
tmp += a[i];
cnt++;
if (tmp == tt) {
ans.push_back(cnt);
cnt = 0;
tmp = 0;
}
if (tmp > tt) {
return cout << "No", 0;
}
}
cout << "Yes" << endl;
cout << ans[0] << " ";
for (int i = 1; i < ans.size(); i++) {
cout << ans[i] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 50 + 10;
long long n, m, l, a, sum[maxN], maxx[maxN], dpl[maxN];
long long first[maxN], ans = -1e6, last, zero, mn;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> l;
mn = 0;
first[i] = ans;
maxx[i] = ans;
for (int j = 0; j < l; j++) {
cin >> a;
sum[i] += a;
maxx[i] = max(maxx[i], sum[i] - mn);
first[i] = max(first[i], sum[i]);
mn = min(mn, sum[i]);
}
dpl[i] = sum[i] - mn;
}
for (int k = 1; k <= m; k++) {
cin >> a;
ans = max(ans, max(maxx[a], first[a] + last));
last = max(zero, max(dpl[a], sum[a] + last));
}
cout << ans;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[100005], b[100005];
bool check(int x, int y) { return a[x] > b[y]; }
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long mn = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
b[i] = mn;
mn = min(mn, a[i]);
}
for (int i = 0; i < n; i++) {
long long r = n - 1, l = i, mid;
while (l < r - 1) {
mid = (l + r) / 2;
if (check(i, mid))
l = mid;
else
r = mid;
}
if (r >= n || b[l] >= a[i])
cout << -1 << ' ';
else
cout << r - i - 1 << ' ';
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long Maxn = 100010;
const long long Mod = 1e9 + 7;
long long b[Maxn << 2], bl;
long long f1[Maxn], f2[Maxn], f[Maxn << 2];
struct lnode {
long long l, r;
bool operator<(const lnode &A) const { return l == A.l ? r > A.r : l < A.l; }
} l1[Maxn], l2[Maxn];
long long n, m, K;
long long qpow(long long x, long long k) {
long long ret = 1;
while (k) {
if (k & 1) ret = ret * x % Mod;
x = x * x % Mod;
k >>= 1;
}
return ret;
}
void up(long long &x, long long y) { x = (x + y) % Mod; }
int main() {
long long i, j, k;
scanf("%I64d%I64d%I64d", &K, &n, &m);
for (i = 1; i <= n; i++) scanf("%I64d%I64d", &l1[i].l, &l1[i].r);
sort(l1 + 1, l1 + n + 1);
long long tmp = 0;
for (i = 1; i <= n; i++) {
while (tmp > 0 && l1[i].r <= l1[tmp].r) tmp--;
l1[++tmp] = l1[i];
}
n = tmp;
for (i = 1; i <= m; i++) scanf("%I64d%I64d", &l2[i].l, &l2[i].r);
sort(l2 + 1, l2 + m + 1);
tmp = 0;
for (i = 1; i <= m; i++) {
while (tmp > 0 && l2[i].r <= l2[tmp].r) tmp--;
l2[++tmp] = l2[i];
}
m = tmp;
for (i = 1; i <= n; i++) b[++bl] = l1[i].l - 1, b[++bl] = l1[i].r;
for (i = 1; i <= m; i++) b[++bl] = l2[i].l - 1, b[++bl] = l2[i].r;
b[++bl] = K;
sort(b + 1, b + bl + 1);
bl = unique(b + 1, b + bl + 1) - (b + 1);
long long j1 = 1, k1 = 1, s1 = 0, j2 = 1, k2 = 1, s2 = 0;
f[0] = 1;
for (i = 1; i <= bl; i++) {
if (k1 <= n && l1[k1].r == b[i]) {
while (j1 < k1 && l1[j1].r < l1[k1].l) s1 = (s1 - f1[j1++] + Mod) % Mod;
tmp = (s1 + f[lower_bound(b + 1, b + bl + 1, l1[k1].l) - b - 1]) % Mod;
up(f1[k1], Mod - tmp);
up(f[i], Mod - tmp);
up(s1, Mod - tmp);
k1++;
}
if (k2 <= m && l2[k2].r == b[i]) {
while (j2 < k2 && l2[j2].r < l2[k2].l) s2 = (s2 - f2[j2++] + Mod) % Mod;
tmp = (s2 + f[lower_bound(b + 1, b + bl + 1, l2[k2].l) - b - 1]) % Mod;
up(f2[k2], Mod - tmp);
up(f[i], Mod - tmp);
up(s2, Mod - tmp);
k2++;
}
up(f[i], f[i - 1] * qpow(2, b[i] - b[i - 1]));
}
printf("%I64d\n", f[bl]);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
vector<int> diff, sim;
int F(string s1, string s2) {
int i;
for (i = 0; i < s1.length(); i++) {
if (s1[i] - s2[i]) {
diff.push_back(i);
} else
sim.push_back(i);
}
return diff.size();
}
char some(char a, char b) {
char p = 'a';
for (int i = 0; i < 26; i++) {
if (p + i != a && p + i != b) return p + i;
}
}
int main() {
std::ios::sync_with_stdio(0);
int n, t;
cin >> n >> t;
char Ans[n];
int i;
string s1, s2;
cin >> s1 >> s2;
int l1 = F(s1, s2), l;
l = l1;
if (l % 2 == 0)
l /= 2;
else {
l++;
l /= 2;
}
if (t < l) {
cout << "-1" << endl;
} else {
if (t >= l1) {
vector<int>::iterator x = diff.begin();
t -= l1;
while (x != diff.end()) {
Ans[*x] = some(s1[*x], s2[*x]);
x++;
}
x = sim.begin();
while (t) {
Ans[*x] = some(s1[*x], s2[*x]);
x++;
t--;
}
while (x != sim.end()) {
Ans[*x] = s1[*x];
x++;
}
for (int j = 0; j < n; j++) cout << Ans[j];
cout << endl;
} else {
int cnt = l1 - t;
vector<int>::iterator x = diff.begin();
while (cnt) {
Ans[*x] = s1[*x];
x++;
cnt--;
}
cnt = l1 - t;
while (cnt) {
Ans[*x] = s2[*x];
x++;
cnt--;
}
while (x != diff.end()) {
Ans[*x] = some(s1[*x], s2[*x]);
x++;
}
x = sim.begin();
while (x != sim.end()) {
Ans[*x] = s1[*x];
x++;
}
for (int j = 0; j < n; j++) cout << Ans[j];
cout << endl;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MOD = 998244353;
template <typename S, typename T>
inline bool Min(S &a, const T &b) {
return a > b ? a = b, true : false;
}
template <typename S, typename T>
inline bool Max(S &a, const T &b) {
return a < b ? a = b, true : false;
}
template <typename S, typename T>
inline void Adm(S &a, const T &b) {
a = (a + b) % MOD;
if (a < 0) a += MOD;
}
template <typename S, typename T>
inline void Mum(S &a, const T &b) {
a = 1LL * a * b % MOD;
}
template <typename T>
inline bool IsPri(T x) {
if (x < 2) return false;
for (T i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
template <typename T>
inline T Gcd(T a, T b) {
while (b) {
T t = b;
b = a % b;
a = t;
}
return a;
}
template <typename T>
inline int BitCnt(T x) {
int cnt = 0;
while (x) ++cnt, x &= x - 1;
return cnt;
}
template <typename T>
inline T MDis(T x1, T y1, T x2, T y2) {
return abs(x1 - x2) + abs(y1 - y2);
}
template <typename T>
inline T MDis(T x1, T y1, T z1, T x2, T y2, T z2) {
return abs(x1 - x2) + abs(y1 - y2) + abs(z1 - z2);
}
inline double EDis(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
inline double EDis(double x1, double y1, double z1, double x2, double y2,
double z2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) +
(z1 - z2) * (z1 - z2));
}
inline long long Pow(long long a, long long n) {
long long t = 1;
while (n) {
if (n & 1) t = t * a % MOD;
a = a * a % MOD, n >>= 1;
}
return t;
}
inline int read() {
static char buf[1000000], *p1 = buf, *p2 = buf;
register int x = false;
register char ch =
p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
register bool sgn = false;
while (ch != '-' && (ch < '0' || ch > '9'))
ch = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
if (ch == '-')
sgn = true,
ch = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48),
ch = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
;
return sgn ? -x : x;
}
const int N = 4e3 + 100;
bool vx[N], vy[N];
long long f[N][N], g[N][N];
long long fac[N], inv[N];
long long C(long long n, long long m) {
if (n < m || m < 0) return 0;
return fac[n] * inv[n - m] % MOD * inv[m] % MOD;
}
int main() {
fac[0] = inv[0] = 1;
for (int i = 1; i < N; ++i)
fac[i] = fac[i - 1] * i % MOD, inv[i] = Pow(fac[i], MOD - 2);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < k; ++i) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
vx[x1] = vx[x2] = vy[y1] = vy[y2] = 1;
}
int X = 0, Y = 0;
for (int i = 0; i <= n; ++i) f[i][0] = 1, X += !vx[i];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= i; ++j) {
f[i][j] = f[i - 1][j];
if (i >= 2 && !vx[i] && !vx[i - 1]) Adm(f[i][j], f[i - 2][j - 1]);
}
for (int i = 0; i <= m; ++i) g[i][0] = 1, Y += !vy[i];
for (int i = 1; i <= m; ++i)
for (int j = 1; j <= i; ++j) {
g[i][j] = g[i - 1][j];
if (i >= 2 && !vy[i] && !vy[i - 1]) Adm(g[i][j], g[i - 2][j - 1]);
}
--X, --Y;
long long ans = 0;
for (int i = 0; i * 2 <= X; ++i)
for (int j = 0; j * 2 <= Y; ++j)
if (i * 2 + j <= X && i + j * 2 <= Y) {
long long res = f[n][i] * g[m][j] % MOD;
res = res * C(X - i * 2, j) % MOD * C(Y - j * 2, i) % MOD;
res = res * fac[i] % MOD * fac[j] % MOD;
Adm(ans, res);
}
cout << ans << endl;
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int find_father(vector<int>& f, int p) {
if (f[p] == p) {
return p;
}
return f[p] = find_father(f, f[p]);
}
int mark(vector<int>& f, vector<int>& ns, int p, int idx) {
int cnt = 0;
while (f[p] == -1) {
f[p] = idx;
p = ns[p];
cnt++;
}
return cnt;
}
vector<int> solve(int n, vector<int>& ns, int m) {
vector<int> f(n, -1);
int idx = 0;
int move = 0;
for (int i = 0; i < n; i++) {
if (f[i] == -1) {
move += mark(f, ns, i, i) - 1;
}
}
vector<int> res;
while (move > m) {
for (int i = 0; i < n; i++) {
if (ns[i] == i) {
continue;
}
vector<int> ps;
int j = ns[i];
while (j != i) {
ps.push_back(j);
j = ns[j];
}
sort(ps.begin(), ps.end());
for (auto p : ps) {
res.push_back(i);
res.push_back(p);
move--;
swap(ns[i], ns[p]);
break;
}
break;
}
}
while (move < m) {
for (int i = 1; i < n; i++) {
if (find_father(f, 0) == find_father(f, i)) {
continue;
}
res.push_back(0);
res.push_back(i);
move++;
swap(ns[0], ns[i]);
f[find_father(f, i)] = 0;
break;
}
}
return res;
}
int main() {
int n;
cin >> n;
vector<int> ns(n);
for (int i = 0; i < n; i++) {
scanf("%d", &ns[i]);
ns[i] -= 1;
}
int m;
cin >> m;
auto res = solve(n, ns, m);
int k = res.size();
printf("%d\n", k / 2);
for (int i = 0; i < k; i += 2) {
printf("%d %d ", res[i] + 1, res[i + 1] + 1);
}
puts("");
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
vector<int> start[1000000 + 5], finish[1000000 + 5];
pair<int, int> cp[200005];
long long ans;
long long cores[1000000 + 5], cost[1000000 + 5];
void update(int c, int p, int i) {
for (; i <= 1000000; i += i & -i) {
cores[i] += c;
cost[i] += (long long)p * c;
}
}
long long queryCores(int i) {
long long res = 0;
for (; i > 0; i -= i & -i) res += cores[i];
return res;
}
long long queryCost(int i) {
long long res = 0;
for (; i > 0; i -= i & -i) res += cost[i];
return res;
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 0; i < m; i++) {
int l, r, c, p;
scanf("%d%d%d%d", &l, &r, &c, &p);
start[l].push_back(i);
finish[r].push_back(i);
cp[i] = pair<int, int>(c, p);
}
for (int i = 1; i <= n; i++) {
for (int j : start[i]) {
int c, p;
tie(c, p) = cp[j];
update(c, p, p);
}
if (queryCores(1000000) <= k) {
ans += queryCost(1000000);
} else {
int maxp = -1;
int lo = 1, hi = 1000000, mid;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (queryCores(mid) >= k) {
hi = mid - 1;
maxp = mid;
} else {
lo = mid + 1;
}
}
long long curcost = queryCost(maxp);
int extra = queryCores(maxp) - k;
curcost -= (long long)extra * maxp;
ans += curcost;
}
for (int j : finish[i]) {
int c, p;
tie(c, p) = cp[j];
update(-c, p, p);
}
}
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct P {
int x, y;
bool operator<(const P &a) const {
if (x != a.x) return x < a.x;
return y < a.y;
};
};
int a, b, c, d, i, n, m, e, k, dx[10] = {1, 0, -1, 0, 1, 1, -1, -1},
dy[10] = {0, 1, 0, -1, 1, -1, 1, -1};
int o[333331];
int l[333331];
int ss[1];
long long x, y, z, mod = 1000000007, hf = (mod + 1) / 2;
char r[1];
vector<int> v[333333];
P u[1];
queue<int> q;
set<int> s;
map<int, int> p;
bool as(P a, P b) { return a.x < b.x; }
int main() {
int ttt;
scanf("%d", &ttt);
for (int tt = 1; tt <= ttt; tt++) {
scanf("%d", &a);
for (int t = 1; t <= a; o[t] = l[t] = 0, t++) v[t].clear();
for (int t = 1; t <= a; t++) {
scanf("%d", &n);
l[n] = max(l[n], t - o[n]);
o[n] = t;
}
for (int t = 1; t <= a; t++) {
l[t] = max(l[t], a + 1 - o[t]);
v[l[t]].push_back(t);
}
k = mod;
for (int t = 1; t <= a; t++) {
for (int h = 0; h < v[t].size(); h++) {
k = min(k, v[t][h]);
}
if (k == mod)
printf("-1 ");
else
printf("%d ", k);
}
puts("");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long k1, k2, k3, t1, t2, t3, n;
cin >> k1 >> k2 >> k3 >> t1 >> t2 >> t3 >> n;
vector<unsigned long long> c(n);
for (int i = 0; i < n; i++) cin >> c[i];
vector<unsigned long long> a1, a2, a3;
a1.push_back(c[0] + t1);
a2.push_back(c[0] + t1 + t2);
a3.push_back(c[0] + t1 + t2 + t3);
for (long long i = 1; i < n; i++) {
long long t = c[i];
if (a1.size() < k1)
a1.push_back(t + t1);
else
a1.push_back(max(a1[a1.size() - k1] + t1, t + t1));
t = a1[a1.size() - 1];
if (a2.size() < k2)
a2.push_back(t + t2);
else
a2.push_back(max(a2[a2.size() - k2] + t2, t + t2));
t = a2[a2.size() - 1];
if (a3.size() < k3)
a3.push_back(t + t3);
else
a3.push_back(max(a3[a3.size() - k3] + t3, t + t3));
}
vector<unsigned long long> q(n);
for (int i = 0; i < n; i++) q[i] = a3[i] - c[i];
cout << *max_element(q.begin(), q.end());
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 1e5 + 9;
const long double pi = acos(-1);
bool cmp(int a, int b) { return a > b; }
int a[MX];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
long double ans = 0, c = 0;
for (int i = n; i > 0; i -= 2) {
ans += pi * a[i] * a[i] - (pi * a[i - 1] * a[i - 1]);
}
cout << fixed << setprecision(10) << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int IN() {
int x = 0, f = 0, ch;
for (; (ch = getchar()) < '0' || ch > '9';) f = (ch == '-');
for (; ch >= '0' && ch <= '9'; (ch = getchar())) x = x * 10 + ch - '0';
return f ? -x : x;
}
int N, M, Ans, fa[200005];
long long Sum[200005], Bas[65];
vector<long long> Cyc[200005];
vector<int> Bel[200005];
int Pow(int a, int b) {
int ret = 1;
for (; b; b >>= 1, a = 1ll * a * a % 1000000007)
if (b & 1) ret = 1ll * ret * a % 1000000007;
return ret;
}
int Get(int u) {
if (fa[u] == u) return u;
int t = Get(fa[u]);
Sum[u] ^= Sum[fa[u]];
return fa[u] = t;
}
void Work(vector<int>& Bel) {
int tot = 0;
for (int i = 0, lim = 60; i <= lim; i++) Bas[i] = 0;
for (int k = 1, lim = Bel.size(); k <= lim; k++) {
int i = Bel[k - 1];
for (int g = 1, lim = Cyc[i].size(); g <= lim; g++) {
long long t = Cyc[i][g - 1];
for (int j = 60, lim = 0; j >= lim; j--)
if ((1ll << j) & t) {
if (!Bas[j]) {
Bas[j] = t;
break;
} else
t ^= Bas[j];
}
}
}
for (int i = 0, lim = 60; i <= lim; i++)
if (Bas[i])
for (int j = i + 1, lim = 60; j <= lim; j++)
if ((1ll << i) & Bas[j]) Bas[j] ^= Bas[i];
for (int i = 0, lim = 60; i <= lim; i++)
if (Bas[i]) tot++;
for (int d = 0, lim = 60; d <= lim; d++) {
int a = 0, b = 0, t = 0;
for (int i = 1, lim = Bel.size(); i <= lim; i++)
if ((1ll << d) & Sum[Bel[i - 1]])
b++;
else
a++;
for (int i = 0, lim = 60; i <= lim; i++)
if ((1ll << d) & Bas[i]) t++;
int x = 0, y = 0;
if (t == 0)
x = Pow(2, tot);
else
x = Pow(2, tot - 1), y = Pow(2, tot - 1);
int ret = (1ll * a * (a - 1) / 2 % 1000000007 * y % 1000000007 +
1ll * b * (b - 1) / 2 % 1000000007 * y % 1000000007 +
1ll * a * b % 1000000007 * x % 1000000007) %
1000000007;
Ans = (Ans + 1ll * Pow(2, d) * ret) % 1000000007;
}
}
int main(int argc, char* argv[]) {
N = IN();
M = IN();
for (int i = 1, lim = N; i <= lim; i++) fa[i] = i;
for (int i = 1, lim = M; i <= lim; i++) {
int u = IN(), v = IN(), fx = Get(u), fy = Get(v);
long long t;
scanf("%lld", &t);
if (fx != fy)
fa[fx] = fy, Sum[fx] = t ^ Sum[u] ^ Sum[v];
else {
t = t ^ Sum[u] ^ Sum[v];
Cyc[fx].push_back(t);
}
}
for (int i = 1, lim = N; i <= lim; i++) Bel[Get(i)].push_back(i);
for (int i = 1, lim = N; i <= lim; i++) Work(Bel[i]);
printf("%d\n", Ans);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int n, p, cds, i, j;
bool t, ans;
string s;
int main() {
cin >> n >> p >> s;
cds = s.size();
while (1) {
j = n;
s[j - 1]++;
while (j > 1 && s[j - 1] >= 'a' + p) {
s[j - 1] -= p;
s[--j - 1]++;
}
if (j == 1 && s[j - 1] >= 'a' + p) break;
t = 0;
for (i = j; i <= n; i++) {
if (i > 2 && s[i - 1] == s[i - 3]) {
t = 1;
break;
}
if (i > 1 && s[i - 1] == s[i - 2]) {
t = 1;
break;
}
}
if (t == 1)
for (j = i + 1; j <= n; j++) s[j - 1] = 'a' + p - 1;
else {
ans = 1;
break;
}
}
if (ans == 1)
cout << s << endl;
else
cout << "NO" << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
Node *l = 0, *r = 0;
int lo, hi;
long long val = 0, forb = 0, baseval;
Node(int lo, int hi, int odd) : lo(lo), hi(hi) {
if (lo + 1 < hi) {
int mid = lo + (hi - lo) / 2;
l = new Node(lo, mid, odd);
r = new Node(mid, hi, odd);
val = l->val + r->val;
} else {
if (odd == 2)
baseval = 1;
else
baseval = lo * 2 + odd;
val = baseval;
}
}
long long query(int L, int R) {
if (R <= lo || hi <= L || forb) return 0;
if (L <= lo && hi <= R) return val;
return l->query(L, R) + r->query(L, R);
}
void add(int L, int R, int x) {
if (R <= lo || hi <= L) return;
if (L <= lo && hi <= R) {
forb += x;
val = forb ? 0 : (lo + 1 == hi ? baseval : l->val + r->val);
} else {
l->add(L, R, x), r->add(L, R, x);
val = forb ? 0 : l->val + r->val;
}
}
};
struct Tr {
int odd;
Node *tr, *tr2;
Tr(int odd) : odd(odd) {
tr = new Node(0, 100010, 2);
tr2 = new Node(0, 100010, odd);
}
int toi(int x) {
if (odd != (x % 2)) x++;
return x / 2;
}
long long query(int from, int to, int start) {
from = toi(from);
to = toi(to);
long long count = tr->query(from, to);
long long sum = tr2->query(from, to);
return sum - (start - 1) * count;
}
void forbid(int from, int to) {
from = toi(from);
to = toi(to);
tr->add(from, to, 1);
tr2->add(from, to, 1);
}
void unforbid(int from, int to) {
from = toi(from);
to = toi(to);
tr->add(from, to, -1);
tr2->add(from, to, -1);
}
};
int main() {
cin.sync_with_stdio(false);
cin.exceptions(cin.failbit);
int N, M;
cin >> N >> M;
vector<pair<int, int>> seg;
vector<pair<int, pair<int, int>>> ev;
Tr eventree(0), oddtree(1);
set<int> starts;
starts.insert(M);
for (int i = 0; i < (N); ++i) {
int L, R;
cin >> L >> R;
--L;
seg.emplace_back(L, R);
ev.emplace_back(L, pair<int, int>(i, 0));
ev.emplace_back(R, pair<int, int>(i, 1));
starts.insert(L);
if (L % 2 == 0)
oddtree.forbid(L, R);
else
eventree.forbid(L, R);
if (L % 2 == R % 2) eventree.forbid(R, M), oddtree.forbid(R, M);
}
sort(ev.begin(), ev.end());
int eid = 0;
multiset<int> active[2];
long long res = 0;
for (int i = 0; i < (M); ++i) {
while (eid < (int)(ev).size() && ev[eid].first == i) {
int id = ev[eid].second.first;
int type = ev[eid].second.second;
int to = seg[id].second;
if (type == 0) {
active[to % 2].insert(to);
if (i % 2 == 0)
oddtree.unforbid(i, to);
else
eventree.unforbid(i, to);
if (to % 2 == i % 2) eventree.unforbid(to, M), oddtree.unforbid(to, M);
} else {
auto it = active[to % 2].find(to);
active[to % 2].erase(it);
}
eid++;
}
int canuntil = M;
int mustdoodduntil = i;
if (!active[i % 2].empty()) {
canuntil = *active[i % 2].begin();
mustdoodduntil = max(mustdoodduntil, *active[i % 2].rbegin());
}
if (!active[(i + 1) % 2].empty()) {
mustdoodduntil = max(mustdoodduntil, *active[(i + 1) % 2].rbegin());
}
int ji = i;
if (active[i % 2].empty() && active[(i + 1) % 2].empty()) {
int j = *starts.lower_bound(i);
mustdoodduntil = max(mustdoodduntil, j);
ji = max(ji, j);
}
long long subres = 0;
if (i % 2 == 0) {
subres += eventree.query(ji, canuntil, i);
subres += oddtree.query(mustdoodduntil, canuntil, i);
} else {
subres += eventree.query(mustdoodduntil, canuntil, i);
subres += oddtree.query(ji, canuntil, i);
}
res += subres;
}
cout << res << endl;
exit(0);
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
long long gcd(long long a, long long b) {
if (a < b) {
return gcd(b, a);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
long long n, m, x, y, a, b;
bool test(long long x1, long long y1, long long x2, long long y2) {}
int main() {
cin >> n >> m >> x >> y >> a >> b;
long long d = gcd(a, b);
a /= d;
b /= d;
long long k = min(n / a, m / b);
long long dx = k * a;
long long dy = k * b;
long long x1 = x - (dx + 1) / 2;
long long x2 = x1 + dx;
long long y1 = y - (dy + 1) / 2;
long long y2 = y1 + dy;
long long shiftX = 0;
if (x2 > n) {
shiftX = -(x2 - n);
}
if (x1 < 0) {
shiftX = -x1;
}
long long shiftY = 0;
if (y2 > m) {
shiftY = -(y2 - m);
}
if (y1 < 0) {
shiftY = -y1;
}
x1 += shiftX;
x2 += shiftX;
y1 += shiftY;
y2 += shiftY;
cout << x1 << " " << y1 << " " << x2 << " " << y2 << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1280000000")
using namespace std;
void solve();
void precalc();
clock_t start;
int testNumber = 1;
bool todo = true;
int main() {
start = clock();
int t = 1;
cout.sync_with_stdio(0);
cin.tie(0);
precalc();
cout.precision(10);
cout << fixed;
int testNum = 1;
while (t--) {
solve();
++testNumber;
}
return 0;
}
int binpow(int q, int w, int mod) {
if (!w) return 1 % mod;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
void precalc() {}
int gcd(int q, int w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
long long dpLeft[2][150][150 * 150];
long long dpRight[2][150][150 * 150];
void relaxMax(long long& dest, long long val) {
if (val == -1) {
return;
}
if (dest == -1) {
dest = val;
} else {
dest = max(dest, val);
}
}
void relaxMin(long long& dest, long long val) {
if (val == -1) {
return;
}
if (dest == -1) {
dest = val;
} else {
dest = min(dest, val);
}
}
void solve() {
long long n, k, s;
cin >> n >> k >> s;
vector<long long> q(n);
long long sum_first = 0;
for (long long i = 0; i < n; ++i) {
cin >> q[i];
if (i < k) {
sum_first += q[i];
}
}
long long w = 0;
memset(dpLeft[w], -1, sizeof dpLeft[w]);
dpLeft[w][0][0] = 0;
for (long long pos = k - 1; pos >= 0; --pos) {
memset(dpLeft[w ^ 1], -1, sizeof dpLeft[w ^ 1]);
long long dist = k - 1 - pos;
for (long long take = 0; take <= dist; ++take) {
for (long long inv = 0; inv <= dist * take; ++inv) {
if (dpLeft[w][take][inv] == -1) {
continue;
}
relaxMax(dpLeft[w ^ 1][take][inv], dpLeft[w][take][inv]);
relaxMax(dpLeft[w ^ 1][take + 1][inv + dist],
dpLeft[w][take][inv] + q[pos]);
}
}
w ^= 1;
}
for (long long take = 0; take <= k; ++take) {
for (long long inv = 0; inv < k * take; ++inv) {
relaxMax(dpLeft[w][take][inv + 1], dpLeft[w][take][inv]);
}
}
long long par = 0;
memset(dpRight[par], -1, sizeof dpRight[par]);
dpRight[par][0][0] = 0;
for (long long pos = k; pos < n; ++pos) {
memset(dpRight[par ^ 1], -1, sizeof dpRight[par ^ 1]);
long long dist = pos - k;
for (long long take = 0; take <= dist; ++take) {
for (long long inv = 0; inv <= dist * take; ++inv) {
if (dpRight[par][take][inv] == -1) {
continue;
}
relaxMin(dpRight[par ^ 1][take][inv], dpRight[par][take][inv]);
relaxMin(dpRight[par ^ 1][take + 1][inv + dist],
dpRight[par][take][inv] + q[pos]);
}
}
par ^= 1;
}
for (long long take = 0; take <= n - k; ++take) {
for (long long inv = 0; inv < (n - k) * take; ++inv) {
relaxMin(dpRight[par][take][inv + 1], dpRight[par][take][inv]);
}
}
long long ans = 0;
for (long long take = 0; take <= k; ++take) {
for (long long inv = 0; inv <= k * take; ++inv) {
long long inv1 = min(s - take - inv, (n - k) * take);
if (inv1 >= 0 && dpLeft[w][take][inv] != -1 &&
dpRight[par][take][inv1] != -1) {
ans = min(ans, -dpLeft[w][take][inv] + dpRight[par][take][inv1]);
}
}
}
ans += sum_first;
cout << ans << "\n";
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<long long> a(n), b(n);
for (int i = 0; i < n; ++i) cin >> a[i] >> b[i];
long long ans = 0;
for (int i = 0; i < n; ++i) {
ans ^= a[i];
a[i] ^= b[i];
}
int rk = 0;
for (rk = 0; rk < n; ++rk) {
int pos = max_element(a.begin() + rk, a.end()) - a.begin();
swap(a[pos], a[rk]);
if (a[rk] == 0) break;
for (int i = rk + 1; i < n; ++i)
if ((a[i] ^ a[rk]) < a[i]) a[i] ^= a[rk];
}
for (int i = 0; i < rk; ++i)
if ((ans ^ a[i]) < ans) ans ^= a[i];
if (ans != 0)
cout << "1/1\n";
else {
long long v = 1;
for (int i = 0; i < rk; ++i) v *= 2;
cout << v - 1 << '/' << v << "\n";
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int x, y, z;
cin >> x >> y >> z;
int ans = -1;
if (x > y + z) ans = 1;
if (y > x + z) {
if (ans == -1)
ans = 2;
else {
cout << '?' << endl;
return 0;
}
}
if (z == 0 && x == y && ans == -1) {
cout << 0 << endl;
return 0;
}
if (ans == 1)
cout << '+' << endl;
else if (ans == 2)
cout << '-' << endl;
else
cout << '?' << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T _sq(T a) {
return a * a;
}
template <class T>
inline T _sqrt(T a) {
return (T)sqrt((double)a);
}
template <class T, class X>
inline T _pow(T a, X y) {
T z = 1;
for (int i = 1; i <= y; i++) {
z *= a;
}
return z;
}
template <class T>
inline T _gcd(T a, T b) {
a = abs(a);
b = abs(b);
if (!b) return a;
return _gcd(b, a % b);
}
template <class T>
inline T _lcm(T a, T b) {
a = abs(a);
b = abs(b);
return (a / _gcd(a, b)) * b;
}
template <class T>
inline T _extended(T a, T b, T &x, T &y) {
a = abs(a);
b = abs(b);
T g, x1, y1;
if (!b) {
x = 1;
y = 0;
g = a;
return g;
}
g = _extended(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return g;
}
template <class T, class X>
inline bool getbit(T a, X i) {
T t = 1;
return ((a & (t << i)) > 0);
}
template <class T, class X>
inline T setbit(T a, X i) {
T t = 1;
return (a | (t << i));
}
template <class T, class X>
inline T resetbit(T a, X i) {
T t = 1;
return (a & (~(t << i)));
}
template <class T, class X>
inline T togglebit(T a, X i) {
T t = 1;
return (a ^ (t << i));
}
template <class T>
void pv(T v) {
for (int i = 0; i < ((int)v.size()); i++) cout << v[i] << " ";
cout << endl;
}
template <class T, class X>
inline T _bigmod(T n, X m) {
unsigned long long ret = 1, a = n % 1000000007;
while (m) {
if (m & 1) ret = (ret * a) % 1000000007;
m >>= 1;
a = (a * a) % 1000000007;
}
ret %= 1000000007;
return (T)ret;
}
template <class T>
inline T _modinv(T n) {
return _bigmod(n, 1000000007 - 2);
}
int col[(100000 + 3)];
vector<int> adj[(100000 + 3)];
long long dp[(100000 + 3)][2];
long long go(int n, int p, int b) {
if (p >= ((int)adj[n].size())) return !b;
long long &ret = dp[adj[n][p]][b];
if (ret != -1) return ret;
ret = 0;
if (!col[adj[n][p]] && b) {
ret = (ret + go(n, p + 1, 1) * go(adj[n][p], 0, 0)) % 1000000007;
ret = (ret + go(n, p + 1, 0) * go(adj[n][p], 0, 1)) % 1000000007;
} else if (col[adj[n][p]] == b) {
ret = (ret + go(n, p + 1, 0) * go(adj[n][p], 0, 0)) % 1000000007;
}
ret =
(ret + go(n, p + 1, b) * go(adj[n][p], 0, !col[adj[n][p]])) % 1000000007;
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i <= n - 2; i++) {
int x;
cin >> x;
adj[x + 1].push_back(i + 2);
}
for (int i = 1; i <= n; i++) {
cin >> col[i];
}
adj[0].push_back(1);
memset(dp, -1, sizeof dp);
cout << go(0, 0, 1) % 1000000007 << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
const int maxn = 3e5 + 10;
using namespace std;
int n;
char s1[3], s2[3];
int a[3], b[3];
int ans[maxn];
int cnt[4], p[4];
void doo() {
for (int i = 1; i <= 3 * n; i++) cout << ans[i];
cout << endl << endl;
}
bool ok() {
for (int i = 1; i <= min(3 * n - 1, 36); i++) {
if (ans[i] == a[1] && ans[i + 1] == a[2]) return false;
if (ans[i] == b[1] && ans[i + 1] == b[2]) return false;
}
return true;
}
bool okk() {
if (n <= 12) {
for (int i = 1; i <= 3 * n - 1; i++) {
if (ans[i] == a[1] && ans[i + 1] == a[2]) return false;
if (ans[i] == b[1] && ans[i + 1] == b[2]) return false;
}
return true;
}
if (a[1] == a[2]) return false;
if (b[1] == b[2]) return false;
if (p[1] == a[1] && p[2] == a[2]) return false;
if (p[2] == a[1] && p[3] == a[2]) return false;
if (p[1] == b[1] && p[2] == b[2]) return false;
if (p[2] == b[1] && p[3] == b[2]) return false;
return true;
}
void print() {
puts("YES");
for (int i = 1; i <= 3 * n; i++) {
if (ans[i] == 1) printf("a");
if (ans[i] == 2) printf("b");
if (ans[i] == 3) printf("c");
}
puts("");
return;
}
int main() {
scanf("%d", &n);
scanf("%s%s", s1 + 1, s2 + 1);
a[1] = s1[1] - 'a' + 1;
a[2] = s1[2] - 'a' + 1;
b[1] = s2[1] - 'a' + 1;
b[2] = s2[2] - 'a' + 1;
p[1] = 1;
p[2] = 2;
p[3] = 3;
do {
for (int i = 1; i <= n; i++) ans[i] = p[1];
for (int i = 1; i <= n; i++) ans[i + n] = p[2];
for (int i = 1; i <= n; i++) ans[i + 2 * n] = p[3];
if (okk()) {
print();
return 0;
}
for (int i = 0; i <= n - 1; i++)
ans[1 + 3 * i] = p[1], ans[2 + 3 * i] = p[2], ans[3 + 3 * i] = p[3];
if (ok()) {
print();
return 0;
}
} while (next_permutation(p + 1, p + 3 + 1));
puts("NO");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int>> xys(n);
for (auto& xy : xys) cin >> xy.first >> xy.second;
sort(xys.begin(), xys.end());
map<pair<int, int>, int> ma;
for (int i = 0; i < xys.size(); ++i) {
for (int j = i + 1; j < xys.size(); ++j) {
++ma[make_pair(xys[j].first - xys[i].first,
xys[j].second - xys[i].second)];
}
}
int ans = 0;
for (auto& pa : ma) {
ans += pa.second * (pa.second - 1) / 2;
}
ans /= 2;
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5e4 + 5;
int n, q;
int w[N];
vector<int> g[N];
int W(char c) {
if (c == '?') return 26;
return c - 'a';
}
set<int> st;
int dep[N], cnt = 0, H = 0, p[N], id[N], fa[N];
vector<int> V[N];
void dfs(int u, int p) {
fa[u] = p;
dep[u] = dep[p] + 1;
id[u] = u;
H = max(H, dep[u]);
if ((int)g[u].size() == 0) st.insert(dep[u]);
for (auto v : g[u]) dfs(v, u);
if ((int)g[u].size() == 1) id[u] = id[g[u][0]], fa[id[g[u][0]]] = fa[u];
}
int bad = 0;
int mx[N][28], sum[N], num[N][28];
bool b[N];
inline void upd(int u, int d, int _w) {
num[u][_w] += d;
for (; fa[u] != -1; u = fa[u]) {
bad -= b[fa[u]];
int pre = mx[fa[u]][_w];
mx[fa[u]][_w] = 0;
for (auto v : g[fa[u]])
mx[fa[u]][_w] = max(mx[fa[u]][_w], mx[id[v]][_w] + num[id[v]][_w]);
sum[fa[u]] += mx[fa[u]][_w] - pre;
if (sum[fa[u]] <= H - dep[fa[u]])
b[fa[u]] = 0;
else
b[fa[u]] = 1;
bad += b[fa[u]];
}
}
int main() {
scanf("%d%d", &n, &q);
char op[2];
for (int i = (2); i < (n + 1); i++) {
scanf("%d%s", &p[i], op);
g[p[i]].push_back(i);
w[i] = W(op[0]);
}
dep[0] = -1;
fa[0] = -1;
g[0].push_back(1);
dfs(1, 0);
w[1] = 0;
for (int i = (1); i < (n + 1); i++)
if (w[i] <= 25) upd(id[i], 1, w[i]);
if ((int)st.size() != 1) {
for (int i = (1); i < (q + 1); i++) printf("Fou\n");
return 0;
}
int v, ct;
for (int i = (1); i < (q + 1); i++) {
scanf("%d%s", &v, op);
if (w[v] <= 25) upd(id[v], -1, w[v]);
w[v] = W(op[0]);
if (w[v] <= 25) upd(id[v], 1, w[v]);
if (bad == 0) {
printf("Shi ");
int ss = 0;
mx[0][0]--;
for (int i = (0); i < (26); i++) ss += mx[id[0]][i];
int mark = H - ss;
long long ans = 0;
for (int i = (0); i < (26); i++) {
ans += (long long)(mx[id[0]][i] + mark) * (i + 1);
}
printf("%lld\n", ans);
mx[0][0]++;
} else
printf("Fou\n");
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int p, y, i, flag = 0;
cin >> p >> y;
if (y % 2 == 0) y--;
for (i = y; i > p; i -= 2) {
long long int fl = 0;
long long int temp = sqrt(y);
long long int lo = min(temp, p);
for (long long int j = 3; j <= lo; j += 2) {
if (i % j == 0) {
fl = 1;
break;
}
}
if (fl != 1) {
cout << i << endl;
flag = 1;
break;
}
}
if (flag == 0) cout << -1 << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, ans = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int i = n - 1;
while (a[i] <= a[i - 1] && i > 0) i--;
while (a[i] >= a[i - 1] && i > 0) i--;
cout << i << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void Emsawy() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
const double PI = acos(-1.0);
const double eps = 1e-10;
const int mod = 1e9 + 7, oo = 1e9;
int dx[]{1, -1, 0, 0, 1, -1, 1, -1};
int dy[]{0, 0, 1, -1, 1, -1, -1, 1};
int n, m, k, t, c;
vector<vector<int> > adj, tree;
const int N = 1500 + 5;
char g[N][N];
int vst[N][N];
pair<int, int> vs[N][N];
int gx(int x) { return ((x % n) + n) % n; }
int gy(int y) { return ((y % m) + m) % m; }
bool go(int i, int j) {
if (vs[gx(i)][gy(j)] != make_pair(-oo, -oo) &&
vs[gx(i)][gy(j)] != make_pair(i, j))
return 1;
if (vs[gx(i)][gy(j)] != make_pair(-oo, -oo)) return 0;
vs[gx(i)][gy(j)] = make_pair(i, j);
for (int k = 0; k < 4; k++) {
int x = i + dx[k], y = dy[k] + j;
if (g[gx(x)][gy(y)] == '#') continue;
if (go(x, y)) return 1;
}
return 0;
}
void fil(int i, int j) {
if (vst[i][j]) return;
vst[i][j] = 1;
for (int k = 0; k < 4; k++) {
int x = (i + dx[k] + n) % n, y = (dy[k] + j + m) % m;
if (g[x][y] == '#') continue;
fil(x, y);
}
}
int main() {
Emsawy();
while (cin >> n >> m) {
pair<int, int> s;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> g[i][j];
if (g[i][j] == 'S') s = {i, j};
}
}
fill(vs[0], vs[0] + N * N, make_pair(-oo, -oo));
fil(s.first, s.second);
bool ret = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (vst[i][j]) {
if (vs[i][j] != make_pair(-oo, -oo)) continue;
ret |= go(i, j);
}
}
}
if (ret)
cout << "Yes" << endl;
else
cout << "No" << endl;
memset(vst, 0, sizeof(vst));
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int dp[320][320];
int a[4];
string s[] = {"BitLGM", "BitAryo"};
int n;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
if (n == 1)
cout << s[(a[0] == 0 ? 1 : 0)] << endl;
else if (n == 3)
cout << s[min(1, a[0] ^ a[1] ^ a[2]) ^ 1] << endl;
else {
for (int i = 0; i <= 300; ++i)
for (int j = 0; j <= 300; ++j) {
if (i == 0 && j == 0)
dp[i][j] = 1;
else if (i == 0)
dp[i][j] = 0;
else if (j == 0)
dp[i][j] = 0;
else {
for (int k = 1; k <= i; ++k) dp[i][j] |= dp[i - k][j];
for (int k = 1; k <= j; ++k) dp[i][j] |= dp[i][j - k];
for (int k = 1; k <= min(i, j); ++k) dp[i][j] |= dp[i - k][j - k];
dp[i][j] ^= 1;
}
}
cout << s[dp[a[0]][a[1]]] << endl;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500001;
struct Edge {
int y, next;
} adj[MAXN * 2];
struct State {
int size;
long long f;
} state[MAXN];
int fch[MAXN], size[MAXN];
long long f[MAXN], ans;
int que[MAXN];
int n, m;
void add(int u, int v) {
adj[++m] = (Edge){v, fch[u]};
fch[u] = m;
}
long long square(int x) { return x * 1LL * x; }
long long check(State a, State b) {
return a.f + b.f + square(n - a.size - b.size);
}
bool cross(State a, State b, State c) {
double y0 = a.f + square(a.size);
double x1 = b.size - a.size, y1 = b.f + square(b.size) - y0;
double x2 = c.size - a.size, y2 = c.f + square(c.size) - y0;
return x1 * y2 < x2 * y1;
}
bool cmp(State a, State b) { return a.size > b.size; }
void dfs(int t, int parent) {
f[t] = 1LL << 60;
size[t] = 1;
for (int i = fch[t]; i != 0; i = adj[i].next) {
int v = adj[i].y;
if (v != parent) {
dfs(v, t);
size[t] += size[v];
}
}
if (size[t] == 1) {
f[t] = 1;
return;
}
int m = 0;
for (int i = fch[t]; i != 0; i = adj[i].next) {
int v = adj[i].y;
if (v != parent) {
long long c = f[v] + square(size[t] - size[v]);
if (c < f[t]) f[t] = c;
if (parent == 0) {
c = f[v] + square(n - size[v]);
if (c < ans) ans = c;
}
state[m++] = (State){size[v], f[v]};
}
}
if (m == 1) return;
sort(state, state + m, cmp);
int head = 0, tail = 0;
que[0] = 0;
for (int i = 1; i < m; i++) {
while (head < tail && check(state[i], state[que[head]]) >=
check(state[i], state[que[head + 1]]))
head++;
long long c = check(state[i], state[que[head]]);
if (c < ans) ans = c;
que[++tail] = i;
while (head + 1 < tail &&
cross(state[que[tail - 2]], state[que[tail - 1]], state[que[tail]]))
que[--tail] = i;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
ans = square(n);
dfs(1, 0);
cout << (square(n) - ans) / 2 + (n * 1LL * (n - 1) / 2) << endl;
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
class TSegmentTree {
public:
virtual T combine(const T& a, const T& b) = 0;
virtual T neutral() = 0;
virtual void push_value(T& dst, const T& src, int len) {}
vector<T> t;
int n;
T neutral_;
void init(int n_) {
n = n_;
t.resize(4 * n);
neutral_ = neutral();
}
void build(const vector<T>& a) { build(a, 1, 0, n - 1); }
T query(int l, int r) {
assert(0 <= l && l < n);
assert(0 <= r && r < n);
return get(1, 0, n - 1, l, r);
}
void update(int l, int r, const T& val) {
assert(0 <= l && l < n);
assert(0 <= r && r < n);
update(1, 0, n - 1, l, r, val);
}
void dump() { dump(1, 0, n - 1); }
void dump(int v, int tl, int tr) {
printf("[%d, %d] -> ", tl, tr);
t[v].show();
if (tl == tr) return;
int tm = (tl + tr) / 2;
dump(v * 2, tl, tm);
dump(v * 2 + 1, tm + 1, tr);
}
private:
void build(const vector<T>& a, int v, int tl, int tr) {
if (tl == tr) {
t[v] = a[tl];
} else {
int tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
}
T get(int v, int tl, int tr, int l, int r) {
if (l > r) {
return neutral_;
}
if (l == tl && r == tr) {
return t[v];
}
int tm = (tl + tr) / 2;
push_value(t[v * 2], t[v], tm - tl + 1);
push_value(t[v * 2 + 1], t[v], tr - tm);
T left = get(v * 2, tl, tm, l, min(r, tm));
T right = get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
t[v] = combine(t[v * 2 + 1], t[v * 2]);
return combine(left, right);
}
void update(int v, int tl, int tr, int l, int r, const T& val) {
if (l > r) {
return;
}
if (l == tl && tr == r) {
push_value(t[v], val, tr - tl + 1);
return;
}
int tm = (tl + tr) / 2;
push_value(t[v * 2], t[v], tm - tl + 1);
push_value(t[v * 2 + 1], t[v], tr - tm);
update(v * 2, tl, tm, l, min(r, tm), val);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, val);
t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
};
struct TNode {
long long value;
long long add;
TNode(long long value_, long long add_) : value(value_), add(add_) {}
TNode() : value(0), add(0) {}
};
const long long INF = 1e18;
class TMyTree : public TSegmentTree<TNode> {
TNode neutral() { return TNode(INF, 0); }
TNode combine(const TNode& a, const TNode& b) {
TNode node;
node.add = 0;
node.value = min(a.value, b.value);
return node;
}
void push_value(TNode& dst, const TNode& src, int len) {
dst.add += src.add;
dst.value += src.add;
}
};
int main() {
int n;
cin >> n;
vector<TNode> a;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
a.push_back(TNode(x, 0));
}
TMyTree tree;
tree.init(n);
tree.build(a);
int m;
cin >> m;
string t;
getline(cin, t);
for (int i = 0; i < m; ++i) {
string s;
getline(cin, s);
stringstream ss;
ss << s;
int x, y;
ss >> x >> y;
int v;
if (ss >> v) {
TNode val(0, v);
if (x > y) {
tree.update(x, n - 1, val);
tree.update(0, y, val);
} else {
tree.update(x, y, val);
}
} else {
long long res;
if (x > y) {
TNode v1 = tree.query(x, n - 1);
TNode v2 = tree.query(0, y);
res = min(v1.value, v2.value);
} else {
TNode v = tree.query(x, y);
res = v.value;
}
cout << res << endl;
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long cnt = 0;
if (n < k) {
cnt = n;
cout << cnt << endl;
} else {
while (n != 0) {
long long d;
if (n % k == 0) {
n = n / k;
cnt++;
} else {
d = (n % k);
n = n - d;
cnt = cnt + d;
}
}
cout << cnt << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (cin >> n >> m) {
if (n == 1 || m == 1) {
printf("%d\n", m + n - 1);
continue;
}
if (n == 2 || m == 2) {
int k = 0;
if ((m + n - 2) % 4 == 1) k = 2;
int ct = (m + n - 2) / 2;
ct = ((ct + 1) / 2) * 4;
printf("%d\n", ct + k);
continue;
}
printf("%d\n", ((n + 1) / 2) * ((m + 1) / 2) + (n / 2) * (m / 2));
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
bool used[350][350][8][35], a[350][350];
int t[35], n;
void dfs(int x, int y, int dir, int rec) {
if (used[x][y][dir][rec]) return;
used[x][y][dir][rec] = true;
for (int j = 0; j < t[rec]; j++) {
x += dx[dir], y += dy[dir];
a[x][y] = true;
}
if (rec != n - 1) {
dfs(x, y, (dir + 1) % 8, rec + 1);
dfs(x, y, (dir + 7) % 8, rec + 1);
}
}
int main() {
cin >> n;
int x = 175, y = 175, dir = 0, rec = 0;
for (int i = 0; i < n; i++) {
cin >> t[i];
}
t[0]--;
a[x][y] = true;
dfs(x, y, dir, rec);
int ans = 0;
for (int i = 0; i < 350; i++) {
for (int j = 0; j < 350; j++) {
if (a[i][j]) ans++;
}
}
cout << ans << endl;
return 0;
}
| 11 |
Subsets and Splits