solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (k == n) {
string r = "";
for (int i = 0; i < n; i++) r += char(i + 'a');
cout << r << endl;
} else if (k > n || (k == 1 && n > 1)) {
cout << "-1" << endl;
} else {
int i = 0;
string r = "";
while (n > k) {
if (i == 0 || i == 1) k--;
if (i % 2 == 0)
r += 'a';
else
r += 'b';
n--;
i++;
}
for (int j = 0; j < n; j++) {
r += char(j + 'c');
}
cout << r << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200005];
long long s[200005], dp[200005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
s[i] = a[i] + s[i - 1];
}
for (int i = 1; i <= n; i++) {
dp[i] = dp[max(0, i - m)] + s[i];
}
for (int i = 1; i <= n; i++) {
printf("%lld ", dp[i]);
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
string buf;
while(getline(cin,buf),buf!=""){
string s=buf;
while(getline(cin,buf),buf!="") s+=buf;
string a;
getline(cin,a);
//cout<<s<<endl<<a<<endl;
int n=a.size();
vector<int> pos[n];
for(int i=0;i<(int)s.size();i++)
for(int j=0;j<n;j++)
if(s[i]==a[j]) pos[j].push_back(i);
bool f=1;
for(int i=0;i<n;i++) f&=!!(pos[i].size());
if(!f){
cout<<0<<endl<<endl;
getline(cin,buf);
continue;
}
int idx[n];
memset(idx,0,sizeof(idx));
int ans=0,len=s.size()+1,head=0;
for(int i=0;i<(int)s.size();i++){
int nxt=i;
for(int j=0;j<n;j++)
nxt=max(nxt,pos[j][idx[j]]);
if(nxt-i+1<len) ans=0,len=nxt-i+1,head=i;
if(nxt-i+1==len) ans++;
for(int j=0;j<n;j++){
if(s[i]==a[j]) idx[j]++;
if(idx[j]>=(int)pos[j].size()) goto LAB;
}
}
LAB:
string str=s.substr(head,len);
cout<<ans<<endl;
for(int i=0;i<(int)str.size();i++){
if(i%72==0) cout<<endl;
cout<<str[i];
}
cout<<endl<<endl;;
//ready for next;
getline(cin,buf);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int b[50], a[1010];
bool work() {
int i, j, pre = -1, t, k;
a[0] = -1;
for (i = 0; i < n; i++) {
t = -1;
for (j = 0; j < m; j++)
if (j != pre && (b[j] > t || j == a[0] && b[j] == t)) t = b[j], k = j;
if (t <= 0) return false;
pre = a[i] = k;
b[k]--;
}
if (a[n - 1] == a[0]) {
for (j = 0; j < m; j++)
if (j != a[n - 2] && j != a[0] && b[j]) break;
if (j >= m) return false;
a[n - 1] = j;
}
return true;
}
int main() {
int i, j;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) scanf("%d", &b[i]);
if (work())
for (i = 0; i < n; i++) printf("%d%c", a[i] + 1, i == n - 1 ? '\n' : ' ');
else
printf("-1\n");
cin >> i;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double EPS = 1e-6;
const int MOD = (int)1e9 + 7;
bool Reverse(long long a, long long b) { return a > b; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
cout << ((n + 1) / 2) - 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int T, N, R;
int main() {
scanf("%d", &T);
for (int(_z) = (0); (_z) < (T); ++(_z)) {
scanf("%d %d", &N, &R);
R %= N;
int cum = 0;
for (int(i) = (0); (i) < (N - 1); ++(i)) {
int _a;
scanf("%d", &_a);
cum += _a;
cum %= N;
}
int ans = (R - cum + N) % N;
if (ans == 0) ans = N;
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n, j = 0;
cin >> n;
int a[n], b[n];
pair<int, int> s[n];
for (auto &i : s) cin >> i.first, i.second = j++;
sort(s, s + n);
map<int, int> mp;
for (int i = 0; i < n; i++) mp[s[i].second] = i;
for (int i = 0; i < (n + 2) / 3; i++) a[i] = i;
for (int i = (n + 2) / 3; i < (2 * n + 2) / 3; i++) b[i] = i;
for (int i = n - 1; i >= (2 * n + 2) / 3; i--) b[i] = n - 1 - i;
for (int i = (n + 2) / 3; i < n; i++) a[i] = s[i].first - b[i];
for (int i = 0; i < (n + 2) / 3; i++) b[i] = s[i].first - a[i];
cout << "YES" << '\n';
for (int i = 0; i < n; i++) cout << a[mp[i]] << " ";
cout << '\n';
for (int i = 0; i < n; i++) cout << b[mp[i]] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
int m, c_matches = 0, c_boxes = 0;
cin >> n >> m;
int arr[m][m];
for (int i = 0; i < m; i++) {
cin >> arr[i][0] >> arr[i][1];
c_boxes += arr[i][0];
c_matches += arr[i][0] * arr[i][1];
}
if (n >= c_boxes) {
cout << c_matches;
return 0;
}
int matches = 0;
while (n) {
int maxx = 0;
for (int i = 0; i < m; i++) {
if (arr[i][1] > arr[maxx][1]) {
maxx = i;
}
}
if (n <= arr[maxx][0]) {
matches += arr[maxx][1] * n;
cout << matches << endl;
return 0;
} else {
matches += arr[maxx][0] * arr[maxx][1];
n -= arr[maxx][0];
arr[maxx][1] = 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
template <typename T1, typename T2>
ostream& operator<<(ostream& os, pair<T1, T2> p) {
cout << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T>& vec) {
os << "{";
for (int i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
os << "}";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, set<T>& st) {
cout << "{";
for (auto itr = st.begin(); itr != st.end(); itr++)
cout << *itr << (next(itr) != st.end() ? ", " : "");
cout << "}";
return os;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, map<T1, T2> mp) {
cout << "{";
for (auto itr = mp.begin(); itr != mp.end(); itr++)
cout << "(" << (itr->first) << ", " << (itr->second) << ")"
<< (next(itr) != mp.end() ? "," : "");
cout << "}";
return os;
}
void dump_func() { cout << endl; }
template <class Head, class... Tail>
void dump_func(Head&& head, Tail&&... tail) {
cout << head;
if (sizeof...(Tail) == 0) {
cout << " ";
} else {
cout << ", ";
}
dump_func(std::move(tail)...);
}
template <class T>
inline bool chmax(T& a, T const& b) {
if (a >= b) return false;
a = b;
return true;
}
template <class T>
inline bool chmin(T& a, T const& b) {
if (a <= b) return false;
a = b;
return true;
}
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
return 0;
}
using ll = long long;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
const int mod = 1e9 + 7, INF = 1 << 29;
const double EPS = 1e-5, PI = 3.1415926535897932384626;
const ll lmod = 1e9 + 7, LINF = 1LL << 59;
template <int MOD>
struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
ModInt(signed long long sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
int get() const { return (int)x; }
ModInt& operator+=(ModInt that) {
if ((x += that.x) >= MOD) x -= MOD;
return *this;
}
ModInt& operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD) x -= MOD;
return *this;
}
ModInt& operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt& operator/=(ModInt that) { return *this *= that.inverse(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt inverse() const {
long long a = x, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return ModInt(u);
}
bool operator==(ModInt that) const { return x == that.x; }
bool operator!=(ModInt that) const { return x != that.x; }
ModInt operator-() const {
ModInt t;
t.x = x == 0 ? 0 : Mod - x;
return t;
}
};
template <int MOD>
ostream& operator<<(ostream& st, const ModInt<MOD> a) {
st << a.get();
return st;
};
template <int MOD>
ModInt<MOD> operator^(ModInt<MOD> a, unsigned long long k) {
ModInt<MOD> r = 1;
while (k) {
if (k & 1) r *= a;
a *= a;
k >>= 1;
}
return r;
}
template <typename T, int FAC_MAX>
struct Comb {
vector<T> fac, ifac;
Comb() {
fac.resize(FAC_MAX, 1);
ifac.resize(FAC_MAX, 1);
for (int i = 1; i < FAC_MAX; i++) fac[i] = fac[i - 1] * i;
ifac[FAC_MAX - 1] = T(1) / fac[FAC_MAX - 1];
for (int i = FAC_MAX - 2; i >= 1; i--) ifac[i] = ifac[i + 1] * T(i + 1);
}
T aPb(int a, int b) {
if (b < 0 || a < b) return T(0);
return fac[a] * ifac[a - b];
}
T aCb(int a, int b) {
if (b < 0 || a < b) return T(0);
return fac[a] * ifac[a - b] * ifac[b];
}
T nHk(int n, int k) {
if (n == 0 && k == 0) return T(1);
if (n <= 0 || k < 0) return 0;
return aCb(n + k - 1, k);
}
};
using mint = ModInt<998244353>;
using vm = vector<mint>;
void _main() {
int N;
cin >> N;
int M;
cin >> M;
vvl g(N);
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
}
vl dist(N, LINF);
for (int i = 0; i < N; i++) {
for (auto u : g[i]) chmin(dist[i], (u - i + N) % N);
if (g[i].size() != 0) dist[i] += ll(g[i].size() - 1) * ll(N);
if (dist[i] == LINF) dist[i] = 0;
}
for (int i = 0; i < N; i++) {
ll ans = 0;
for (int j = 0; j < N; j++)
if (g[j].size() != 0) chmax(ans, dist[j] + ll((j - i + N) % N));
cout << ans << (i == N - 1 ? "\n" : " ");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> v;
set<int> s;
for (int i = 0; i < n; i = i + 1) {
int x;
int sx = s.size();
cin >> x;
s.insert(x);
if (s.size() == sx + 1) {
if (s.size() <= k)
v.push_back(x);
else {
s.erase(*v.begin());
v.erase(v.begin());
v.push_back(x);
}
}
}
cout << v.size() << endl;
for (int i = v.size() - 1; i >= 0; i--) {
cout << v[i] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a;
int main() {
while (scanf(" %d", &n) == 1) {
int sum = 0, cnt = 0, minn = 1003;
m = 2 * n - 1;
while (m--) {
scanf(" %d", &a);
if (a < 0) {
cnt++;
a = -a;
}
sum += a;
minn = min(minn, a);
}
if (n & 1 || !(cnt & 1))
printf("%d\n", sum);
else
printf("%d\n", sum - 2 * minn);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
std::vector<pair<pair<long long, long long>, long long> > dis;
std::vector<pair<long long, long long> > bridge;
long long l[200100], r[200100];
long long t;
long long ans[200100];
bool cmp(pair<pair<long long, long long>, long long> A,
pair<pair<long long, long long>, long long> B) {
if (A.first.second != B.first.second) return A.first.second < B.first.second;
if (A.first.first != B.first.first) return A.first.first < B.first.first;
return A.second < B.second;
}
int main() {
cin >> n >> m;
for (long long i = 0; i < n; i++) cin >> l[i] >> r[i];
for (long long i = 0; i < m; i++) {
cin >> t;
bridge.push_back(make_pair(t, i));
}
for (long long i = 0; i < n - 1; i++) {
dis.push_back(make_pair(make_pair(l[i + 1] - r[i], r[i + 1] - l[i]), i));
}
sort(dis.begin(), dis.end(), cmp);
sort(bridge.begin(), bridge.end());
set<pair<long long, long long> > s;
long long idx = 0;
for (long long i = 0; i <= n - 2; i++) {
pair<pair<long long, long long>, long long> q = dis[i];
while (idx < m && q.first.second >= bridge[idx].first) {
s.insert(bridge[idx]);
idx++;
}
set<pair<long long, long long> >::iterator it =
s.lower_bound(pair<long long, long long>(dis[i].first.first, -10LL));
if (it == s.end()) {
cout << "No" << endl;
return 0;
}
ans[dis[i].second] = (*it).second;
s.erase(it);
}
cout << "Yes" << endl;
for (long long i = 0; i < n - 1; i++) cout << ans[i] + 1 << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> gcd(int a, int b) {
if (b == 0) return make_pair(1, 0);
auto ret = gcd(b, a % b);
return make_pair(ret.second, ret.first - a / b * ret.second);
}
struct Modint {
int val;
Modint(int nval = 0) { val = nval; }
Modint& operator+=(Modint r) {
val = (val + r.val) % 1000000007;
return *this;
}
Modint& operator-=(Modint r) {
val = (val + 1000000007 - r.val) % 1000000007;
return *this;
}
Modint& operator*=(Modint r) {
val = 1LL * val * r.val % 1000000007;
return *this;
}
Modint operator+(Modint r) { return Modint(*this) += r; }
Modint operator-(Modint r) { return Modint(*this) -= r; }
Modint operator*(Modint r) { return Modint(*this) *= r; }
Modint invert() {
int ret = gcd(val, 1000000007).first;
while (ret < 0) ret += 1000000007;
return ret;
}
Modint& operator/=(Modint r) { return operator*=(r.invert()); }
Modint operator/(Modint r) { return Modint(*this) /= r; }
};
Modint power[300000 + 1], inversePower[300000 + 1];
struct Ftree {
vector<Modint> val;
Ftree() { val.resize(300000 + 1); }
void add(int pos, Modint toAdd) {
if (pos > 300000) return;
val[pos] += toAdd;
add(pos + (pos & -pos), toAdd);
}
Modint get(int pos) {
if (pos == 0) return 0;
return val[pos] + get(pos - (pos & -pos));
}
Modint segment(int l, int r) {
Modint ret = get(r - 1) - get(l - 1);
return ret * inversePower[l - 1];
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
power[0] = 1;
inversePower[0] = 1;
power[1] = 10;
inversePower[1] = power[1].invert();
for (int i = 2; i <= 300000; i++) {
power[i] = power[i - 1] * power[1];
inversePower[i] = inversePower[i - 1] * inversePower[1];
}
Ftree left[3], revleft[3];
Modint mult[3] = {2, 5, 7};
int n, p;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p;
p--;
{
int sz = min(p, n - p - 1);
for (int m = 0; m < 3; m++) {
Modint lcmp = left[m].segment(p + 2, p + 2 + sz);
Modint rcmp = revleft[m].segment(300000 - p + 1, 300000 - p + 1 + sz);
if (lcmp.val != rcmp.val) {
cout << "YES\n";
return 0;
}
}
}
for (int m = 0; m < 3; m++) {
left[m].add(p + 1, mult[m] * power[p]);
revleft[m].add(300000 - p, mult[m] * power[300000 - p - 1]);
}
}
cout << "NO\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n1, n2, n3, t1, t2, t3;
scanf("%d %d %d %d %d %d %d", &k, &n1, &n2, &n3, &t1, &t2, &t3);
vector<int> f1(n1, 0);
vector<int> f2(n2, 0);
vector<int> f3(n3, 0);
int ans = 0;
for (int i = 0; i < k; i++) {
int p1 = f1[i % n1] + t1 + t2 + t3;
int p2 = f2[i % n2] + t2 + t3;
int p3 = f3[i % n3] + t3;
int p = max(max(p1, p2), p3);
f1[i % n1] = p - t2 - t3;
f2[i % n2] = p - t3;
f3[i % n3] = p;
ans = p;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <stdio.h>
#include <iostream>
#include <vector>
#include <list>
#include <cmath>
#include <fstream>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <complex>
#include <iterator>
#include <cstdlib>
#include <cstring>
#include <sstream>
using namespace std;
#define EPS (1e-10)
#define EQ(a,b) (abs((a) - (b)) < EPS)
#define EQV(a,b) (EQ((a).real(),(b).real()) && EQ((a).imag(),(b).imag()))
typedef complex<double> P;
typedef long long ll;
const int MAX_SIZE = 10000;
// àÏ
double dot(P a, P b) {
return (a.real() * b.real() + a.imag() * b.imag());
}
// OÏ
double cross(P a, P b) {
return (a.real() * b.imag() - a.imag() * b.real());
}
// _cª¼üabãÉ é©È¢©
int is_point_on_line(P a, P b, P c) {
return EQ( cross(b-a, c-a), 0.0 );
}
// 2¼ü̼s»è
int is_orthogonal(P a1, P a2, P b1, P b2) {
return EQ( dot(a1-a2, b1-b2), 0.0 );
}
// 2¼ü̽s»è
int is_parallel(P a1, P a2, P b1, P b2) {
return EQ( cross(a1-a2, b1-b2), 0.0 );
}
// _a,bðÊé¼üÆ_cÌÔÌ£
double distance_l_p(P a, P b, P c) {
return abs(cross(b-a, c-a)) / abs(b-a);
}
// _a,bð[_Æ·éüªÆ_cÆÌ£
double distance_ls_p(P a, P b, P c) {
if ( dot(b-a, c-a) < EPS ) return abs(c-a);
if ( dot(a-b, c-b) < EPS ) return abs(c-b);
return abs(cross(b-a, c-a)) / abs(b-a);
}
// a1,a2ð[_Æ·éüªÆb1,b2ð[_Æ·éüªÌð·»è
int is_intersected_ls(P a1, P a2, P b1, P b2) {
return ( cross(a2-a1, b1-a1) * cross(a2-a1, b2-a1) < EPS ) &&
( cross(b2-b1, a1-b1) * cross(b2-b1, a2-b1) < EPS );
}
// a1,a2ð[_Æ·éüªÆb1,b2ð[_Æ·éüªÌð_vZ
P intersection_ls(P a1, P a2, P b1, P b2) {
P b = b2-b1;
double d1 = abs(cross(b, a1-b1));
double d2 = abs(cross(b, a2-b1));
double t = d1 / (d1 + d2);
return a1 + (a2-a1) * t;
}
// a1,a2ðÊé¼üÆb1,b2ðÊé¼üÌð·»è
int is_intersected_l(P a1, P a2, P b1, P b2) {
return !EQ( cross(a1-a2, b1-b2), 0.0 );
}
// a1,a2ðÊé¼üÆb1,b2ðÊé¼üÌð_vZ
P intersection_l(P a1, P a2, P b1, P b2) {
P a = a2 - a1; P b = b2 - b1;
return a1 + a * cross(b, b1-a1) / cross(b, a);
}
/*
~üÆüªÌð·»è
*/
bool isCircleCrossLine(P a,P b,P c,double r){
double d1 = abs(a-c);
double d2 = abs(b-c);
if(d1<r&&d2<r){
return false;
}
double d = distance_ls_p(a,b,c);
if(EQ(d,r)||d<r){
return true;
}
else
return false;
}
// Op`ÌàÉ_ª é©Ç¤©
// OÏ̳ª·×į¶ÈçàÉ_ è
bool isInTriangle(P p1,P p2,P p3,P s){
P a=p1-s;
P b=p2-s;
P c=p3-s;
return ((cross(a,b)>0&&cross(b,c)>0&&cross(c,a)>0)||(cross(a,b)<0&&cross(b,c)<0&&cross(c,a)<0));
}
int main(){
int n,m;
while(cin>>n&&n!=0){
double S=0;
int angle=0;
int sumAngle=0;
for(int i = 0; i < n-1; i++){
cin>>angle;
S+=0.5*sin(((double)angle/180)*acos(-1.0));
sumAngle+=angle;
}
S+=0.5*sin(((double)(360-sumAngle)/180)*acos(-1.0));
cin>>m;
double S2=0;
sumAngle=0;
for(int i = 0; i < m-1; i++){
cin>>angle;
S2+=0.5*sin(((double)angle/180)*acos(-1.0));
sumAngle+=angle;
}
S2+=0.5*sin(((double)(360-sumAngle)/180)*acos(-1.0));
if(EQ(S,S2)){
cout<<0<<endl;
}
else if(S<S2){
cout<<2<<endl;
}
else{
cout<<1<<endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int i = 0;
int j = 1;
while (i < n) {
if (a[i] >= j) {
i++;
j++;
} else {
i++;
}
}
cout << j - 1 << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s0 =
"What are you doing at the end of the world? Are you busy? Will you save "
"us?";
string s1 = "What are you doing while sending \"";
string s2 = "\"? Are you busy? Will you send \"";
string s3 = "\"?";
int t0 = (int)s0.size(), t1 = (int)s1.size(), t2 = (int)s2.size(), t3 = 2;
long long maxN = 1000000000000000000;
vector<long long> lens(60);
long long len(long long n) {
if (n < 60) {
if (lens[n]) return lens[n];
long long p2 = 1LL << n;
int t = t1 + t2 + t3;
int t_t0 = t + t0;
if (p2 <= 1 + (maxN + t - 1) / t_t0) {
return lens[n] = t_t0 * p2 - t;
}
return lens[n] = maxN;
}
return maxN;
}
void step(long long n, long long k) {
if (n == 0) {
cout << (k < t0 ? s0[k] : '.');
return;
}
if (k < t1) {
cout << s1[k];
return;
}
long long x = len(n - 1);
long long y = t1;
if (k < y + x) {
step(n - 1, k - y);
return;
}
y += x;
if (k < y + t2) {
cout << s2[k - y];
return;
}
y += t2;
if (k < y + x) {
step(n - 1, k - y);
return;
}
y += x;
if (k < y + t3) {
cout << s3[k - y];
return;
}
cout << ".";
}
void solve() {
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
long long n, k;
cin >> n >> k;
--k;
step(n, k);
}
}
int main(int argc, char**) {
if (argc > 1) {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
ios::sync_with_stdio(false);
cin.tie(0);
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, N) for (int i = 0; i < (int)N; i++)
#define V_MAX 15
int d[V_MAX][V_MAX];
int INF = 10000;
int dp[1<<V_MAX][V_MAX];
int V, E;
int solve(int T, int u) {
if(dp[T][u] != -1) return dp[T][u];
int res = INF;
for(int v = 1; v < V; v++) {
if((T & (1 << v)) && u != v) res = min(res, solve(T & ~(1 << u), v) + d[v][u]);
}
dp[T][u] = res;
return res;
}
int main () {
REP(i, 1<<V_MAX)REP(j,V_MAX) dp[i][j] = -1;
REP(i,V_MAX)REP(j,V_MAX) d[i][j] = INF;
int s, t, w, res;
cin >> V >> E;
REP(i, E) {
cin >> s >> t >> w;
d[s][t] = w;
}
dp[1][0] = 0;
for(int i = 1; i < V; i++) dp[1 | (1<<i)][i] = d[0][i];
res = INF;
for(int v = 1; v < V; v++) {
res = min(res, solve((1<<V) - 1, v) + d[v][0]);
}
if(res == INF) res = -1;
cout << res << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
cin >> tc;
while (tc--) {
long long int n, k;
cin >> n >> k;
vector<int> a(n), b(n);
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
ans += a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
for (int i = 0; i < k; i++) {
if (a[i] >= b[n - i - 1]) {
break;
}
ans -= a[i];
ans += b[n - i - 1];
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool smaller = 1, bigger = 1;
short int small_index = 0, big_index = 0;
string choices[4];
cin >> choices[0];
choices[0].erase(0, 2);
int biggest = choices[0].size(), smallest = choices[0].size();
for (int i = 1; i < 4; i++) {
cin >> choices[i];
choices[i].erase(0, 2);
if (choices[i].size() < smallest) {
smallest = choices[i].size();
small_index = i;
}
if (choices[i].size() > biggest) {
biggest = choices[i].size();
big_index = i;
}
}
for (int i = 0; i < 4; i++) {
if (i == small_index) continue;
if (smallest > choices[i].size() / 2) {
smaller = 0;
break;
}
}
for (int i = 0; i < 4; i++) {
if (i == big_index) continue;
if (biggest < choices[i].size() * 2) {
bigger = 0;
break;
}
}
if (smaller == 1 && bigger == 0)
cout << (char)('A' + small_index) << endl;
else if (smaller == 0 && bigger == 1)
cout << (char)('A' + big_index) << endl;
else
cout << (char)('A' + 2) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 100005, mod = 1e9 + 7, inf = 1e9;
int n, q, a;
int t[500005];
int j = (1 << 17);
int lazy[500005];
int tab[nax];
char d;
void init(int x) {
for (int i = 1; x >= i; ++i) {
lazy[i] = -1;
t[i] = 2;
}
}
void go(int node, int co) {
if (co <= 1) {
t[node] = lazy[node] = co;
return;
}
if (co == 3) {
if (t[node] <= 1) {
t[node] = lazy[node] = !t[node];
return;
}
if (t[node] == 2) {
t[node] = lazy[node] = 3;
return;
}
if (t[node] == 3) {
t[node] = 2;
lazy[node] = -1;
return;
}
}
return;
}
void push(int node) {
if (lazy[node] == -1) return;
go(2 * node, lazy[node]);
go(2 * node + 1, lazy[node]);
lazy[node] = -1;
t[node] = 2;
return;
}
void ustaw(int node, int lewo, int prawo, int x, int y, int co) {
if (y >= prawo && lewo >= x) {
go(node, co);
return;
}
int mid = (lewo + prawo) / 2;
push(node);
if (x <= mid) ustaw(2 * node, lewo, mid, x, y, co);
if (y > mid) ustaw(2 * node + 1, mid + 1, prawo, x, y, co);
}
int val(int node, int lewo, int prawo, int x, int y) {
if (y >= prawo && lewo >= x) return t[node];
push(node);
int mid = (lewo + prawo) / 2;
if (x <= mid)
return val(2 * node, lewo, mid, x, y);
else
return val(2 * node + 1, mid + 1, prawo, x, y);
}
int main() {
init(2 * j - 1);
scanf("%d %d", &n, &q);
for (int i = 1; n >= i; ++i) {
scanf("%d", &tab[i]);
}
for (int i = 1; q >= i; ++i) {
scanf(" %c %d", &d, &a);
if (d == '>') {
if (a >= 0) {
ustaw(1, 0, j - 1, a + 1, j - 1, 0);
} else {
ustaw(1, 0, j - 1, -a, j - 1, 0);
ustaw(1, 0, j - 1, 0, -a - 1, 3);
}
} else {
if (a > 0) {
ustaw(1, 0, j - 1, a, j - 1, 1);
ustaw(1, 0, j - 1, 0, a - 1, 3);
} else {
ustaw(1, 0, j - 1, -a + 1, j - 1, 1);
}
}
}
for (int i = 1; n >= i; ++i) {
int b = val(1, 0, j - 1, abs(tab[i]), abs(tab[i]));
int x = tab[i];
int y = -tab[i];
if (b == 0) printf("%d ", min(x, y));
if (b == 1) printf("%d ", max(x, y));
if (b == 2) printf("%d ", tab[i]);
if (b == 3) printf("%d ", -tab[i]);
}
return 0;
}
| 5 |
#include <iostream>
using namespace std;
int main(void){
string s;
while(cin>>s,s!="0"){
for(int i=0;i<3;++i){
if(i)cin>>s;
int a=0,b=0;
for(int j=1;j<s.size();++j){
if(s[j]=='A') ++a;else ++b;
}
if(a>b) ++a;else ++b;
cout<<a<<" "<<b<<endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, w, k;
cin >> n >> w;
vector<int> b;
for (int i = 0; i < 2 * n; i++) {
cin >> k;
b.push_back(k);
}
sort(b.begin(), b.end());
int mig = b[0], mib = b[n];
double a, f, d;
a = (double)(2 * min(mib * 0.5, (double)mig) * n +
n * min(mib * 0.5, (double)mig));
f = (double)(min(mig * 2, mib) * n / 2.0 + (double)n * min(mig * 2, mib));
d = (double)w;
double res = min(a, min(f, d));
cout << fixed << setprecision(6) << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long llo;
#define mp make_pair
#define pb push_back
#define a first
#define b second
#define endl '\n'
int n;
int aa[200001];
int bb[200001];
pair<int,int> cc[200001];
int ans[200001];
int par[200001];
int ss[200001];
int mi[200001];
int find(int no){
if(par[no]==no){
return no;
}
par[no]=find(par[no]);
return par[no];
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin>>n;
for(int i=0;i<n;i++){
cin>>aa[i]>>bb[i];
aa[i]--;
bb[i]--;
cc[aa[i]]={bb[i],i};
}
for(int i=0;i<n;i++){
par[i]=i;
ss[i]=1;
mi[i]=cc[i].a;
}
set<pair<int,int>> cur;
for(int i=0;i<n;i++){
vector<pair<int,int>> kk;
for(auto j:cur){
if(j.a>cc[i].a){
break;
}
int x=find(j.b);
int y=find(i);
par[x]=y;
ss[y]+=ss[x];
mi[y]=min(mi[y],mi[x]);
kk.pb(j);
}
cur.insert({mi[i],i});
for(auto j:kk){
cur.erase(j);
}
}
for(int i=0;i<n;i++){
ans[cc[i].b]=ss[find(i)];
}
for(int i=0;i<n;i++){
cout<<ans[i]<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
const int MAX = 11;
const double PI = acos(-1);
const double eps = 1e-5;
void FFT(std::complex<double> *a, int length, int type) {
for (int i = 1, j = 0; i < length - 1; ++i) {
for (int s = length; j ^= s >>= 1, ~j & s;)
;
if (i < j) {
std::swap(a[i], a[j]);
}
}
int len = -1;
for (int x = length; x; ++len, x >>= 1)
;
for (int i = 1; i <= len; ++i) {
std::complex<double> unit(cos(PI / (1 << i - 1)),
type * sin(PI / (1 << i - 1)));
for (int j = 0; j < length; j += 1 << i) {
std::complex<double> w(1, 0);
for (int k = j, szk = 1 << i - 1; k < j + szk; ++k) {
std::complex<double> s = a[k], t = w * a[k + szk];
a[k] = s + t, a[k + szk] = s - t;
w *= unit;
}
}
}
if (type == 1) {
return;
}
for (int i = 0; i < length; ++i) {
a[i] /= (std::complex<double>)length;
}
}
void mult(std::complex<double> (*compa)[1 << MAX], std::vector<int> lengtha,
std::complex<double> (*compb)[1 << MAX], std::vector<int> lengthb) {
std::vector<int> length = {1, 1};
std::vector<int> n = {lengtha[1] + lengthb[1] - 1,
lengtha[0] + lengthb[0] - 1};
for (int i = 0; i < 2; ++i) {
for (; length[i] < n[i]; length[i] <<= 1)
;
}
for (int i = 0; i < lengtha[0]; ++i) {
FFT(compa[i], length[0], 1);
}
for (int i = 0; i < lengthb[0]; ++i) {
FFT(compb[i], length[0], 1);
}
for (int i = 0, sz = std::max(length[0], lengtha[0]); i < sz; ++i) {
for (int j = 0; j < i; ++j) {
std::swap(compa[i][j], compa[j][i]);
}
}
for (int i = 0, sz = std::max(length[0], lengthb[0]); i < sz; ++i) {
for (int j = 0; j < i; ++j) {
std::swap(compb[i][j], compb[j][i]);
}
}
for (int i = 0; i < length[0]; ++i) {
FFT(compa[i], length[1], 1);
FFT(compb[i], length[1], 1);
}
for (int i = 0; i < length[0]; ++i) {
for (int j = 0; j < length[1]; ++j) {
compa[i][j] *= compb[i][j];
}
}
for (int i = 0; i < length[0]; ++i) {
FFT(compa[i], length[1], -1);
}
for (int i = 0, sz = std::max(length[0], length[1]); i < sz; ++i) {
for (int j = 0; j < i; ++j) {
std::swap(compa[i][j], compa[j][i]);
}
}
for (int i = 0; i < n[1]; ++i) {
FFT(compa[i], length[0], -1);
}
}
std::complex<double> a[1 << MAX][1 << MAX], b[1 << MAX][1 << MAX];
int n, m, r, c;
char s[1 << MAX][1 << MAX];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
a[i][j] = std::complex<double>{sin(2 * PI * s[i][j] / 26),
cos(2 * PI * s[i][j] / 26)};
}
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) {
scanf("%s", s[i]);
}
int cnt = 0;
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
b[r - i - 1][c - j - 1] = s[i][j] == '?' ? ++cnt, 0
: std::complex<double>{sin(2 * PI * s[i][j] / 26),
-cos(2 * PI * s[i][j] / 26)};
}
}
for (int i = 0; i < 1 << MAX - 1; ++i) {
for (int j = 0; j < 1 << MAX - 1; ++j) {
a[i][j] = a[i % n][j % m];
}
}
mult(a, {1 << MAX - 1, 1 << MAX - 1}, b, {r, c});
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
putchar(std::abs(r * c - cnt - a[i + r - 1][j + c - 1].real()) < eps
? '1'
: '0');
}
putchar('\n');
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e6 + 10;
const int mod = 998244353;
const int G = 3;
const int iG = (mod + 1) / 3;
int n, m, a[maxn], b[maxn], tr[maxn];
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
inline int ksm(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = 1ll * res * x % mod;
x = 1ll * x * x % mod;
y >>= 1;
}
return res;
}
inline void ntt(int *f, int len, int flag) {
for (int i = 0; i < len; i++)
if (i < tr[i]) swap(f[i], f[tr[i]]);
for (int i = 2; i <= len; i <<= 1) {
int w = ksm(flag ? G : iG, (mod - 1) / i);
for (int j = 0, p = i >> 1; j < len; j += i) {
int wi = 1;
for (int k = j; k < j + p; k++) {
int tt = 1ll * wi * f[k + p] % mod;
f[k + p] = (f[k] - tt + mod) % mod;
f[k] = (f[k] + tt) % mod;
wi = 1ll * wi * w % mod;
}
}
}
if (flag == 0) {
int iv = ksm(len, mod - 2);
for (int i = 0; i < len; i++) f[i] = 1ll * f[i] * iv % mod;
}
}
int main() {
n = read(), m = read();
for (int i = 1, x; i <= n; i++) x = read(), a[x] = b[x] = 1;
int len = 1;
for (; len <= m + m; len <<= 1)
;
for (int i = 0; i < len; i++)
tr[i] = (tr[i >> 1] >> 1) | ((i & 1) ? len >> 1 : 0);
ntt(b, len, 1);
for (int i = 0; i < len; i++) b[i] = 1ll * b[i] * b[i] % mod;
ntt(b, len, 0);
for (int i = 1; i <= m; i++)
if (b[i] && !a[i]) return puts("NO"), 0;
puts("YES");
int tot = 0;
for (int i = 1; i <= m; i++)
if (a[i] && !b[i]) tot++;
printf("%d\n", tot);
for (int i = 1; i <= m; i++)
if (a[i] && !b[i]) printf("%d ", i);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int other;
int other_idx;
bool used;
int id;
edge(int other, int other_idx, int id)
: id(id), other(other), other_idx(other_idx), used(false) {}
};
void dfs_eulerian(vector<vector<edge>>& g, vector<int>& indices,
vector<pair<int, bool>>& ans, int node) {
while (indices[node] < g[node].size()) {
edge& e = g[node][indices[node]];
if (!e.used) {
e.used = true;
g[e.other][e.other_idx].used = true;
++indices[node];
dfs_eulerian(g, indices, ans, e.other);
ans.push_back(make_pair(e.id, node < e.other));
} else {
++indices[node];
}
}
}
int find_idx(map<int, int>& m, int x) {
if (m.find(x) == m.end()) {
int next = m.size();
return m[x] = next;
}
return m[x];
}
vector<vector<edge>> constructGraph(int& N) {
int x, y;
int a_x, a_y, b_x, b_y, m_x, m_y;
cin >> N;
vector<vector<edge>> g(N * 2);
map<int, int> unique_x, unique_y;
for (int i = 0; i < N; ++i) {
cin >> x >> y;
int u_x = find_idx(unique_x, x);
int u_y = find_idx(unique_y, y) + N;
g[u_x].push_back(edge(u_y, g[u_y].size(), i));
g[u_y].push_back(edge(u_x, g[u_x].size() - 1, i));
}
return g;
}
int getStartingNode(vector<vector<edge>>& g) {
for (int i = 0; i < g.size(); ++i) {
if (g[i].size() % 2 == 1) {
return i;
}
}
return 0;
}
int main() {
int T;
int N;
vector<vector<edge>> g = constructGraph(N);
int dummy = 2 * N;
g.push_back(vector<edge>());
for (int i = 0; i < g.size(); ++i) {
if (g[i].size() % 2 == 1) {
g[i].push_back(edge(dummy, g[dummy].size(), -1));
g[dummy].push_back(edge(i, g[i].size() - 1, -1));
}
}
vector<int> indices(g.size(), 0);
vector<pair<int, bool>> ans;
for (int i = 0; i < g.size(); ++i) {
if (indices[i] != g[i].size()) {
dfs_eulerian(g, indices, ans, i);
}
}
vector<bool> label(N);
for (int i = 0; i < ans.size(); ++i) {
if (ans[i].first == -1) continue;
label[ans[i].first] = ans[i].second;
}
for (int i = 0; i < N; ++i) {
cout << (label[i] ? 'r' : 'b');
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, f = 0;
string d, e;
cin >> a >> d >> e;
b = int(d[0] - '0') * 10;
b += int(d[1] - '0');
c = int(e[0] - '0') * 10;
c += int(e[1] - '0');
for (int i = 0;; i++) {
if (c < 0) {
c = 60 - (0 - c);
b--;
}
if (c % 10 == 7) {
cout << f;
return 0;
}
if (b < 0) {
b = 23;
}
if (b % 10 == 7) {
cout << f;
return 0;
}
c -= a;
f++;
}
}
| 1 |
#include<cstdio>
#include<complex>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
typedef complex<double> Point;
const double EPS=1e-9;
int n;
Point p[300];
int f(const Point &c){
int res=0;
rep(i,n) if(abs(p[i]-c)<1+EPS) res++;
return res;
}
int main(){
for(;scanf("%d",&n),n;){
rep(i,n){ double x,y; scanf("%lf%lf",&x,&y); p[i]=Point(x,y); }
int ans=1;
rep(j,n) rep(i,j) {
double d=abs(p[j]-p[i])/2;
Point v=(p[j]-p[i])/(2*d);
if(d<1){
ans=max(ans,f(p[i]+d*v+sqrt(1-d*d)*v*Point(0,+1)));
ans=max(ans,f(p[i]+d*v+sqrt(1-d*d)*v*Point(0,-1)));
}
}
printf("%d\n",ans);
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define N 111116
int n,q;
vector<long long> a;
long long t[N],ans[N];
long long read(){
long long x=0,f=1;char ch=getchar();
for (;!isdigit(ch);ch=getchar()) if (ch=='-') f=-f;
for (;isdigit(ch);ch=getchar()) x=x*10+ch-'0';
return x*f;
}
int main(){
n=read();q=read();a.push_back(n);
for (int i=1;i<=q;i++){
long long x=read();
while (a.size()&&a.back()>=x) a.pop_back();
a.push_back(x);
}
q=a.size();t[q-1]=1;
for (int i=q-1;i>=0;i--){
long long x=a[i],y=i-1;
while (y>=0){
t[y]+=x/a[y]*t[i];x%=a[y];
for (int k=1<<16;k;k/=2)
if (y-k+1>=0&&a[y-k+1]>=x) y-=k;
}
ans[1]+=t[i];ans[x+1]-=t[i];
}
for (int i=1;i<=n;i++)
printf("%lld\n",ans[i]+=ans[i-1]);
return 0;
} | 0 |
#include "bits/stdc++.h"
#include "math.h"
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vin;
typedef pair<ll,ll> P;
typedef vector<P> vp;
#define rep(i,a,b) for(ll i=(a);i<(b);++i)
#define drep(i,a,b) for(ll i=(a);i>=(b);--i)
#define SIZE(a) int((a).size())
#define out(a) cout<<(a)<<endl;
const int MAX = 510000;
const ll MOD = 10000000007;
ll fac[MAX], finv[MAX], inv[MAX];
int main(){
ll v,e,r,cnt=0;cin>>v>>e>>r;
vvll g(e,vll(3));vll dis(v,MOD);
rep(i,0,e){
ll s,t,d;cin>>s>>t>>d;
g[i][0]=s; g[i][1]=t; g[i][2]=d;
}
dis[r]=0;
while(cnt<v){
bool end=true;
for(vll u:g){
if(dis[u[0]]!=MOD&&dis[u[0]]+u[2]<dis[u[1]]){
dis[u[1]]=dis[u[0]]+u[2];
end=false;
}
}
if(end)break;
cnt++;
}
if(cnt==v){out("NEGATIVE CYCLE");}
else{
rep(i,0,v){
if(dis[i]!=MOD){out(dis[i]);}
else{out("INF");}
}
}
return 0;
}
| 0 |
#include <iostream>
#include <map>
#include <string>
using namespace std;
int main() {
map<char,string> t;
map<string,char> s;
string inp,res,code;
t[65]="00000"; t[66]="00001"; t[67]="00010"; t[68]="00011";
t[69]="00100"; t[70]="00101"; t[71]="00110"; t[72]="00111";
t[73]="01000"; t[74]="01001"; t[75]="01010"; t[76]="01011";
t[77]="01100"; t[78]="01101"; t[79]="01110"; t[80]="01111";
t[81]="10000"; t[82]="10001"; t[83]="10010"; t[84]="10011";
t[85]="10100"; t[86]="10101"; t[87]="10110"; t[88]="10111";
t[89]="11000"; t[90]="11001"; t[32]="11010"; t[46]="11011";
t[44]="11100"; t[45]="11101"; t[39]="11110"; t[63]="11111";
s["101"]=' '; s["000000"]='\''; s["000011"]=','; s["10010001"]='-';
s["010001"]='.'; s["000001"]='?'; s["100101"]='A'; s["10011010"]='B';
s["0101"]='C'; s["0001"]='D'; s["110"]='E'; s["01001"]='F';
s["10011011"]='G'; s["010000"]='H'; s["0111"]='I'; s["10011000"]='J';
s["0110"]='K'; s["00100"]='L'; s["10011001"]='M'; s["10011110"]='N';
s["00101"]='O'; s["111"]='P'; s["10011111"]='Q'; s["1000"]='R';
s["00110"]='S'; s["00111"]='T'; s["10011100"]='U'; s["10011101"]='V';
s["000010"]='W'; s["10010010"]='X'; s["10010011"]='Y'; s["10010000"]='Z';
while(getline(cin,inp)){
string temp;
int i,j;
res="";
code="";
for(i=0;i<inp.length();++i){
code += t[inp[i]];
}
for(i=0;i<code.length();++i){
for(j=3;j<=8;++j){
temp = code.substr(i,j);
if(s.find(temp) == s.end())continue;
res += s[temp];
i+=j-1;
break;
}
}
cout<<res<<endl;
}
return 0;
} | 0 |
/**
* author: tourist
* created: 30.12.2020 17:45:47
**/
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a; swap(a, m);
u -= t * v; swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod()) v = static_cast<Type>(x);
else v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const { return static_cast<U>(value); }
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) { if ((value += other.value) >= mod()) value -= mod(); return *this; }
Modular& operator-=(const Modular& other) { if ((value -= other.value) < 0) value += mod(); return *this; }
template <typename U> Modular& operator+=(const U& other) { return *this += Modular(other); }
template <typename U> Modular& operator-=(const U& other) { return *this -= Modular(other); }
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) { Modular result(*this); *this += 1; return result; }
Modular operator--(int) { Modular result(*this); *this -= 1; return result; }
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value, Modular>::type & operator*=(const Modular& rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x), d, m;
asm(
"divl %4; \n\t"
: "=a" (d), "=d" (m)
: "d" (xh), "a" (xl), "r" (mod())
);
value = m;
#else
value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, long long>::value, Modular>::type & operator*=(const Modular& rhs) {
long long q = static_cast<long long>(static_cast<long double>(value) * rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if < !is_integral<typename Modular<U>::Type>::value, Modular >::type & operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) { return *this *= Modular(inverse(other.value, mod())); }
friend const Type& abs(const Modular& x) { return x.value; }
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename V, typename U>
friend V& operator>>(V& stream, Modular<U>& number);
private:
Type value;
};
template <typename T> bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value == rhs.value; }
template <typename T, typename U> bool operator==(const Modular<T>& lhs, U rhs) { return lhs == Modular<T>(rhs); }
template <typename T, typename U> bool operator==(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) == rhs; }
template <typename T> bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(const Modular<T>& lhs, U rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(U lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T> bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value < rhs.value; }
template <typename T> Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T> Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T> Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T> Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template<typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
bool IsZero(const Modular<T>& number) {
return number() == 0;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
// U == std::ostream? but done this way because of fastoutput
template <typename U, typename T>
U& operator<<(U& stream, const Modular<T>& number) {
return stream << number();
}
// U == std::istream? but done this way because of fastinput
template <typename U, typename T>
U& operator>>(U& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, long long>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
/*
using ModType = int;
struct VarMod { static ModType value; };
ModType VarMod::value;
ModType& md = VarMod::value;
using Mint = Modular<VarMod>;
*/
constexpr int md = (int) 1e9 + 7;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
/*vector<Mint> fact(1, 1);
vector<Mint> inv_fact(1, 1);
Mint C(int n, int k) {
if (k < 0 || k > n) {
return 0;
}
while ((int) fact.size() < n + 1) {
fact.push_back(fact.back() * (int) fact.size());
inv_fact.push_back(1 / fact.back());
}
return fact[n] * inv_fact[k] * inv_fact[n - k];
}*/
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
vector<long long> x(n);
for (int i = 0; i < n; i++) {
cin >> x[i];
}
vector<int> cnt(60);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 60; j++) {
if (x[i] & (1LL << j)) {
cnt[j] += 1;
}
}
}
Mint ans = 0;
for (int i = 0; i < n; i++) {
Mint sum_and = 0;
Mint sum_or = 0;
for (int j = 0; j < 60; j++) {
if (x[i] & (1LL << j)) {
sum_and += Mint(1LL << j) * cnt[j];
sum_or += Mint(1LL << j) * n;
} else {
sum_or += Mint(1LL << j) * cnt[j];
}
}
ans += sum_and * sum_or;
}
cout << ans << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
long long dp[200005];
void solve() {
long long n, mod, sum = 0;
cin >> n >> mod;
dp[1] = 1, sum = 1;
for (long long i = 2; i <= n; i++) {
dp[i] = sum;
long long val = 0;
for (long long l = 1, r; l <= i; l = r + 1) {
r = i / (i / l);
val = (val + (r - l + 1) * dp[i / l] % mod) % mod;
}
dp[i] = val;
sum = (sum + dp[i]) % mod;
}
cout << dp[n];
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i;
string s;
int main() {
scanf("%d%d", &n, &m);
cin >> s;
int x = s.find('G');
int y = s.find('T');
if (x > y) swap(x, y);
for (i = x; i < y; i = i + m) {
if (s[i] == '#') {
break;
}
}
printf("%s", i == y ? "YES" : "NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> aa, aa2;
long long int ans, p;
long long int i, j, k, n, m, A, N, B, C, arr[1000000], flag[1000000],
maxx[1000000], l, r, x, y, a, b, q;
string s, s2;
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> arr[i];
aa[arr[i]] = i;
}
cin >> m;
for (i = 0; i < m; i++) {
ans = 0;
A = 0;
cin >> k;
for (j = 0; j < n; j++) flag[j] = 0;
if (k == 2) {
cin >> a >> b;
aa[arr[b - 1]] = a - 1;
aa[arr[a - 1]] = b - 1;
swap(arr[a - 1], arr[b - 1]);
} else {
cin >> x >> y;
ans = 1;
for (j = x; j < y; j++)
if (aa[j] > aa[j + 1]) {
ans++;
}
cout << ans << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, k, m;
int a[maxn], hsh[maxn], t[maxn];
struct Num {
int id, w;
bool operator<(const Num b) const { return w < b.w; }
};
struct Heap {
Num a[maxn];
int len;
Heap() {
memset(a, 0, sizeof a);
len = 0;
}
void push(Num x) {
a[++len] = x;
int son = len;
while (son > 1) {
if (a[son / 2] < a[son])
swap(a[son], a[son / 2]);
else
break;
son >>= 1;
}
}
Num get() {
Num now = a[1];
a[1] = a[len--];
int fa = 1, son;
while (fa * 2 <= len) {
if (a[fa * 2 + 1] < a[fa * 2] || fa * 2 + 1 > len)
son = fa * 2;
else
son = fa * 2 + 1;
if (a[fa] < a[son])
swap(a[son], a[fa]);
else
break;
fa = son;
}
return now;
}
} hep;
inline int read() {
int ret = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch >= 48 && ch <= 57) {
ret = ret * 10 + ch - 48;
ch = getchar();
}
return ret * f;
}
int main() {
n = read();
k = read();
for (int i = 1; i <= n; i++) a[i] = read(), m = max(m, a[i]), hsh[a[i]]++;
for (int i = 1; i <= m; i++) {
if (!hsh[i]) continue;
t[i]++;
hep.push((Num){i, hsh[i]});
}
for (int i = 1; i <= k; i++) {
Num now = hep.get();
printf("%d ", now.id);
t[now.id]++;
hep.push((Num){now.id, hsh[now.id] / t[now.id]});
}
return 0;
}
| 4 |
#include <iostream>
#include <cstdio>
using namespace std;
int main(void)
{
int y, m, d;
int a;
while (scanf("%d%d%d", &y, &m, &d) != EOF){
a = (y * 10000 +m * 100 + d);
if (a < 18680908) {
cout << "pre-meiji" << endl;
continue;
}
if (a < 19120730){
cout << "meiji " << y-1867 << " " << m << " " << d << endl;
continue;
}
if (a < 19261225){
cout << "taisho " << y-1911 << " " << m << " " << d << endl;
continue;
}
if (a < 19890108){
cout << "showa " << y-1925 << " " << m << " " << d << endl;
continue;
}
cout << "heisei " << y-1988 << " " << m << " " << d << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int x, y, z;
pair<int, int> ans;
string a, b, c;
void calc(int x, int y, int z) {
if (x == 0 && z == 0) {
ans.first = 2, ans.second = y;
return ;
}
if (x == 0 && y == 0) {
ans.first = 3, ans.second = z;
return ;
}
if (y == 0 && z == 0) {
ans.first = 1, ans.second = x;
return ;
}
if (x <= z) {
for (auto it : c) a.push_back(it);
calc(x, y, z - x);
}
else {
string tmp = c;
c = b;
b.clear();
for (auto it : a) b.push_back(it);
for (auto it : tmp) b.push_back(it);
calc(x - z, z, y);
}
}
int main() {
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> x >> y >> z;
if (x == 0) {
x = y, y = z, z = 0;
a.push_back('b'); b.push_back('c'); c.push_back('a');
}
else a.push_back('a'), b.push_back('b'), c.push_back('c');
calc(x, y, z);
for (int i = 0; i < ans.second; i++) {
if (ans.first == 1) cout << a;
else if (ans.first == 2) cout << b;
else cout << c;
}
cout << '\n';
return 0;
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long double EPS = 1e-9L;
const long double MAX_SQR_LEN = 2250000000000.0L;
bool eq(long double x, long double y) { return abs(x - y) < EPS; }
bool ls(long double x, long double y) { return x < y && !eq(x, y); }
bool lsEq(long double x, long double y) { return x < y || eq(x, y); }
struct Point {
long double x, y;
Point() : x(), y() {}
Point(long double _x, long double _y) : x(_x), y(_y) {}
Point operator+(const Point& a) const { return Point(x + a.x, y + a.y); }
Point operator-(const Point& a) const { return Point(x - a.x, y - a.y); }
Point operator*(const long double& k) const { return Point(x * k, y * k); }
Point operator/(const long double& k) const { return Point(x / k, y / k); }
long double operator%(const Point& a) const { return x * a.x + y * a.y; }
long double operator*(const Point& a) const { return x * a.y - y * a.x; }
long double sqrLen() const { return x * x + y * y; }
long double len() const { return sqrt(sqrLen()); }
Point norm() const { return (*this) / len(); }
Point ort() const { return Point(-y, x); }
Point rot(const long double& cosA, const long double& sinA) const {
return (*this) * cosA + ort() * sinA;
}
Point rot(const long double& ang) const { return rot(cos(ang), sin(ang)); }
bool operator==(const Point& a) const { return eq(x, a.x) && eq(y, a.y); }
bool operator<(const Point& a) const {
if (!eq(x, a.x)) return x < a.x;
return ls(y, a.y);
}
};
int main() {
srand(time(NULL));
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<pair<Point, int>> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i].first.x >> p[i].first.y;
p[i].second = i;
}
mt19937 randGen(time(0));
vector<int> c;
while (true) {
shuffle(p.begin(), p.end(), randGen);
c.assign(n, 0);
Point pos(0, 0);
for (int i = 0; i < n; i++) {
long double distPlus = (pos + p[i].first).sqrLen();
long double distMinus = (pos - p[i].first).sqrLen();
if (lsEq(distPlus, distMinus)) {
c[p[i].second] = 1;
pos = pos + p[i].first;
} else {
c[p[i].second] = -1;
pos = pos - p[i].first;
}
}
if (lsEq(pos.sqrLen(), MAX_SQR_LEN)) break;
}
for (int i = 0; i < n; i++) cout << c[i] << " ";
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 3;
int n;
void input() { cin >> n; }
void solve() {
cout << (n / 2 + (n % 2)) * (n / 2) << endl;
for (int i = 1; i <= n / 2; i++)
for (int j = n / 2 + 1; j <= n; j++) cout << i << ' ' << j << endl;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
input(), solve();
return 0;
}
| 5 |
#include<iostream>
#include<string>
using namespace std;
struct NODE { int key; NODE *pa, *ri, *le; };
NODE *NIL, *root;
void insert(int k)
{
NODE *z, *x = root, *y = NIL;
z = new NODE;
z->key = k;
z->le = NIL;
z->ri = NIL;
while (x != NIL)
{
y = x;
if (z->key < x->key)
x = x->le;
else
x = x->ri;
}
z->pa = y;
if (y == NIL)
root = z;
else
{
if (z->key < y->key)
y->le = z;
else
y->ri = z;
}
}
void preorder(NODE *u)
{
if (u == NIL)return;
cout << " " << u->key;
preorder(u->le);
preorder(u->ri);
}
void inorder(NODE *u)
{
if (u == NIL)return;
inorder(u->le);
cout << " " << u->key;
inorder(u->ri);
}
int main()
{
string str;
int i, n, k;
cin >> n;
for (i = 0; i < n; i++)
{
cin >> str;
if (str[0] == 'i')
{
cin >> k;
insert(k);
}
else if (str[0] == 'p')
{
inorder(root);
cout << endl;
preorder(root);
cout << endl;
}
}
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#include <map>
using namespace std;
int N, M;
vector<vector<int> > G;
vector<bool> seen;
bool rec(int v, int p, int s, int t) {
if (v == s && p != -1) return true; // 一周回ってきて s に戻って来たら OK
if (v != s) seen[v] = true;
for (auto nv : G[v]) {
if (nv == p || nv == t || seen[nv]) continue;
if (rec(nv, v, s, t)) return true;
}
return false;
}
bool solve() {
cin >> N >> M;
G.assign(N, vector<int>());
for (int i = 0; i < M; ++i) {
int a, b; cin >> a >> b; --a, --b;
G[a].push_back(b);
G[b].push_back(a);
}
map<int,int> degs;
for (int v = 0; v < N; ++v) degs[(int)G[v].size()]++;
for (auto it : degs) if (it.first % 2 != 0) return false;
if (degs[6] > 0) return true;
if (degs[4] > 2) return true;
if (degs[4] <= 1) return false;
vector<int> four;
for (int v = 0; v < N; ++v) if (G[v].size() == 4) four.push_back(v);
int s = four[0], t = four[1];
seen.assign(N, 0);
return rec(s, -1, s, t);
}
int main() {
if (solve()) cout << "Yes" << endl;
else cout << "No" << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int llINF = 0x3f3f3f3f3f3f3f;
const int N = 212345;
int n;
long long int dp[N];
int par[N];
pair<int, int> a[N];
int id[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
dp[i + 1] = llINF;
int c;
scanf("%d", &c);
a[i] = make_pair(c, i);
par[i] = -1;
}
par[n] = -1;
sort(a, a + n);
for (int i = 0; i <= n - 3; i++) {
if (dp[i] == llINF) continue;
for (int j = 0; j < 3; j++) {
int val = i + 3 + j;
if (val > n) continue;
int plc = dp[val];
dp[val] = min(dp[val], dp[i] + (long long int)(a[val - 1].first) -
(long long int)(a[i].first));
if (dp[val] < plc) {
par[val] = i;
}
}
}
printf("%lld ", dp[n]);
stack<int> s;
int x = n;
s.push(n);
while (x != -1) {
s.push(x);
x = par[x];
}
int vaca = s.size() - 2;
printf("%d\n", vaca);
int l = s.top(), r;
s.pop();
r = s.top();
for (int i = 1; i <= vaca; i++) {
for (int k = l; k < r; k++) {
id[a[k].second] = i;
}
l = r;
if (!s.empty()) {
s.pop();
r = s.top();
}
}
for (int i = 0; i < n; i++) {
if (i > 0) printf(" ");
printf("%d", id[i]);
}
printf("\n");
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
const int MX = 105;
#define rep(i,n) for(int i=0; i<(n); i++)
int n, m, a, pr[MX], w, b[MX][MX];
set<int> st[MX];
bool used[MX];
bool dfs(int v){
used[v] = true;
for(int it: st[v]) if((w = pr[it/m]) < 0 || (!used[w] && dfs(w))){
pr[it/m] = v;
return true;
}
return false;
}
int main(){
scanf("%d%d", &n, &m);
rep(i,n) rep(j,m){
scanf("%d", &a);
st[i].insert(a-1);
}
rep(i,m){
fill(pr, pr+n, -1);
rep(j,n){
fill(used,used+n,0);
dfs(j);
}
rep(j,n){
w = pr[j];
auto it = st[w].lower_bound(j*m);
b[i][w] = *it;
st[w].erase(it);
}
}
rep(i,n) rep(j,m) printf("%d%c", b[j][i]+1, j<m-1?' ':'\n');
rep(i,m) sort(b[i],b[i]+n);
rep(i,n) rep(j,m) printf("%d%c", b[j][i]+1, j<m-1?' ':'\n');
}
| 0 |
#include <bits/stdc++.h>
int main(int argc, char *argv[]) {
int N, d, f;
scanf("%d", &N);
d = N / 3;
if (N % 3 > 1) {
d++;
}
f = d / 12;
d = d - f * 12;
printf("%d %d\n", f, d);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[104];
int main() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
int n, k;
long long ans = 0;
cin >> n >> k;
for (int j = 1; j <= n; j++) {
cin >> a[j];
}
sort(a + 1, a + n + 1);
int r = n;
int l = n - k;
for (int j = 1; j <= k; j++) {
ans += a[l] / a[r];
l--;
r--;
}
for (int j = 1; j <= n - 2 * k; j++) {
ans += a[j];
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
int main() {
char a[1000002];
int i, x = 0, y = 0, d;
scanf("%s", a);
for (i = 0; i < strlen(a); i++)
if (a[i] == 'x')
x++;
else
y++;
d = x - y;
if (d > 0)
while (d--) printf("x");
else
while (d++) printf("y");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int t;
cin >> t;
while (t--) {
int result = 0, cntr = 0;
vector<int> v;
cin >> s;
for (int j = 0; j < s.length(); j++) {
if (s[j] == '1') {
cntr++;
} else {
if (cntr) v.push_back(cntr);
cntr = 0;
}
}
v.push_back(cntr);
sort(v.rbegin(), v.rend());
for (int i = 0; i < v.size(); i++) {
if (i % 2 == 0) {
result += v[i];
}
}
cout << result << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool check(string s, int i) {
for (int j = 0; j < i / 2 + 1; j++) {
if (s[j] != s[j + i / 2 + 1]) return false;
}
return true;
}
int main() {
string s;
int n;
cin >> n;
cin >> s;
int cnt = 0;
for (int i = s.size() - 1; i >= 0; i--) {
if (i % 2 == 0)
cnt++;
else {
if (check(s, i)) {
cnt += 2 + i / 2;
break;
} else
cnt++;
}
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main()
{
int a,b,c;
while(cin>>a>>b)
{
c=a+b;
int k=0;
while(c>0)
{
c/=10;
k++;
}
cout<<k<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define MAXN (200010)
int n;
int q[MAXN], t[MAXN], f[MAXN];
int main(){
scanf("%d", &n);
for(int i = 1; i <= n; ++ i){
int pi;
scanf("%d", &pi);
q[pi] = i;
}
for(int i = n - 1; i; -- i){
if(!t[i + 1]){
if(q[i] > q[i + 1]){
t[i] = 1;
f[i] = i + 1;
}
else{
continue;
}
}
else{
if(q[f[i + 1]] < q[i] && q[i] < q[i + 1] ||
q[i] < q[i + 1] && q[i + 1] < q[f[i + 1]] ||
q[i + 1] < q[f[i + 1]] && q[f[i + 1]] < q[i]){
t[i] = t[i + 1];
f[i] = f[i + 1];
}
else{
t[i] = t[i + 1] + 1;
f[i] = i + 1;
}
}
}
printf("%d\n", t[1]);
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
int N, M, b, Exit, mask;
int v[1 << 15];
int ret;
void rec(int digit, int cnt){
if(cnt >= ret) return;
if(digit == Exit || digit == ((~Exit) & mask)){
ret = min( ret, cnt);
return;
} else if(v[digit & mask] <= cnt){
return;
} else {
v[digit] = cnt;
const int prev = digit;
for(int i = 0; i < N - 1; ++i){
digit &= ~(3 << i);
digit |= ((prev >> i) & 1) << (i + 1);
digit |= ((prev >> (i + 1)) & 1) << i;
rec( digit, cnt + 1);
digit = prev;
}
}
}
int main(){
fill_n( v, 1 << 15, INF);
ret = INF;
cin >> N >> M;
mask = (1 << N) - 1;
for(int i = 0; i < N; ++i){
bool d;
cin >> d;
b |= d << (N - i - 1);
}
int cnt = 0;
bool flip = false;
for(int i = 0; i < M; ++i){
int p;
cin >> p;
while(p--){
Exit |= (int)flip << (N - cnt - 1);
++cnt;
}
flip ^= 1;
}
rec(b, 0);
cout << ret << endl;
} | 0 |
#include <bits/stdc++.h>
int dp[10001];
int main() {
int i, k, n1, n2, n3, t1, t2, t3;
scanf("%d%d%d%d%d%d%d", &k, &n1, &n2, &n3, &t1, &t2, &t3);
for (i = 1; i <= k; i++) {
dp[i] = t1 + t2 + t3;
if (i >= n1)
dp[i] = ((dp[i]) > (dp[i - n1] + t1) ? (dp[i]) : (dp[i - n1] + t1));
if (i >= n2)
dp[i] = ((dp[i]) > (dp[i - n2] + t2) ? (dp[i]) : (dp[i - n2] + t2));
if (i >= n3)
dp[i] = ((dp[i]) > (dp[i - n3] + t3) ? (dp[i]) : (dp[i - n3] + t3));
}
printf("%d", dp[k]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<char> animals(n);
int tigers = 0;
for (int i = 0; i < n; i++) {
cin >> animals[i];
if (animals[i] == 'T') tigers++;
}
int l = 0;
int r = tigers;
int max = 0;
for (l = 0; l < n; l++) {
int inzone = 0;
for (int i = l; i < r; i++) {
if (animals[i % n] == 'T') inzone++;
}
if (inzone > max) max = inzone;
r++;
}
cout << tigers - max << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<int> a(n + 1), dp(n + 1, 1);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = n; i >= 1; i--) {
int mx = 0;
for (int j = 2; i * j <= n; j++) {
if (a[i] < a[i * j]) mx = max(mx, dp[i * j]);
}
dp[i] += mx;
}
cout << *max_element(dp.begin(), dp.end()) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10000000;
int tmp[30], cnt;
bool check(int x) {
cnt = 0;
int y = x;
while (y) tmp[cnt++] = y % 10, y /= 10;
if (cnt == 1) return 1;
if (tmp[0] == tmp[1]) return 0;
if (tmp[0] > tmp[1]) {
for (int i = 0; i < cnt - 1; i += 2)
if (tmp[i + 1] >= tmp[i]) return 0;
for (int i = 1; i < cnt - 1; i += 2)
if (tmp[i + 1] <= tmp[i]) return 0;
} else {
for (int i = 0; i < cnt - 1; i += 2)
if (tmp[i + 1] <= tmp[i]) return 0;
for (int i = 1; i < cnt - 1; i += 2)
if (tmp[i + 1] >= tmp[i]) return 0;
}
return 1;
}
int v[830169], vcnt;
unordered_map<int, vector<int> > mp[10][2];
int main() {
long long n, k;
cin >> n >> k;
for (int i = 0; i < maxn; i++)
if (check(i)) {
v[vcnt++] = i;
if (i % n == 0 && !(--k)) {
cout << i;
;
return 0;
}
if (i < 100000) continue;
if (i < 1000000) {
if (tmp[cnt - 1] < tmp[cnt - 2]) continue;
tmp[cnt++] = 0;
}
int d = (tmp[cnt - 1] > tmp[cnt - 2]);
mp[tmp[cnt - 1]][d][i % n].push_back(i);
}
long long mul = 10000000;
for (auto i : v) {
int x = i % 10, y = (i / 10) % 10;
long long val = (-mul * i) % n;
if (val < 0) val += n;
if (val >= maxn) continue;
if (i < 10 || y < x)
for (int j = 0; j < x; j++) {
auto it = mp[j][0].find(val);
if (it == mp[j][0].end()) continue;
if (k > it->second.size())
k -= it->second.size();
else {
cout << i * mul + it->second[k - 1];
return 0;
}
}
if (i < 10 || x < y)
for (int j = x + 1; j < 10; j++) {
auto it = mp[j][1].find(val);
if (it == mp[j][1].end()) continue;
if (k > it->second.size())
k -= it->second.size();
else {
cout << i * mul + it->second[k - 1];
return 0;
}
}
}
printf("-1\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dp[501][501];
long long ar[501][2];
int n, k;
int rek(int cur, int leftRed) {
if (cur == -1) return leftRed == 0;
if (dp[cur][leftRed] == -1) {
dp[cur][leftRed] = rek(cur - 1, ((leftRed - ar[cur][0]) % k + k) % k);
for (int ctr1 = 0; ctr1 <= k; ++ctr1) {
if (ar[cur][0] < ctr1 || ar[cur][1] < k - ctr1) continue;
dp[cur][leftRed] |=
rek(cur - 1, ((leftRed - ar[cur][0] + ctr1) % k + k) % k);
if (dp[cur][leftRed]) break;
}
}
return dp[cur][leftRed];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
memset(dp, -1, sizeof(dp));
cin >> n >> k;
long long tot[2] = {0};
for (int ctr1 = 0; ctr1 < n; ++ctr1)
for (int ctr2 = 0; ctr2 < 2; ++ctr2)
cin >> ar[ctr1][ctr2], tot[ctr2] += ar[ctr1][ctr2];
long long rez = 0;
for (int ctr1 = 0; ctr1 < k; ++ctr1)
if (rek(n - 1, ctr1)) rez = max(rez, (tot[0] + tot[1] - ctr1) / k);
cout << rez;
return 0;
}
| 5 |
#include <iostream>
using namespace std;
#define N 16
int ans[N];
int cur[N];
int anspos[N];
int movepos[4] = {-4, 1, 4, -1};
int checkAns() {
for (int i = 0; i < N; i++) {
if (ans[i] != cur[i]) return 0;
}
return 1;
}
int calcEst() {
int total = 0, t;
for (int i = 0; i < N; i++) {
if (cur[i]==0)continue;
t = (i % 4) - (anspos[cur[i]] %4);
if (t >= 0)
total += t;
else
total -= t;
t = (i / 4) - (anspos[cur[i]] / 4);
if (t >= 0)
total += t;
else
total -= t;
}
return total;
}
int dfs(int x, int px, int lim) {
int res = -1, minres = -1;
if (checkAns()) return 0;
if (lim == 0) return -1;
if (calcEst() > lim) return -1;
for (int i = 0; i < 4; i++) {
if (x + movepos[i] == px) continue;
if ((x % 4 == 0 && movepos[i] == -1) || (x % 4== 3 && movepos[i] == 1))
continue;
if (x + movepos[i] >= N || x + movepos[i] < 0) continue;
swap(cur[x], cur[x + movepos[i]]);
res = dfs(x + movepos[i], x, lim - 1);
if (res != -1) {
if (minres == -1) {
minres = res + 1;
} else {
minres = min(minres, res + 1);
}
break;
}
swap(cur[x], cur[x + movepos[i]]);
}
return minres;
}
int main() {
int x, lim = 0, res;
for (int i = 0; i < N; i++) ans[i] = i + 1;
ans[N - 1] = 0;
for (int i = 0; i < N; i++) anspos[i] = i - 1;
anspos[0] = N - 1;
for (int i = 0; i < N; i++) {
cin >> cur[i];
if (cur[i] == 0) x = i;
}
while (true) {
res = dfs(x, x, lim);
if (res >= 0) break;
lim++;
}
// cout << lim << endl;
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005], dir[100005], vec;
int vis1[100005], vis2[100005], vis3[100005], fl = 0;
void dfs1(int u) {
vis1[u] = 1;
vec.push_back(u);
for (int i = (int)0; i <= (int)adj[u].size() - 1; i++) {
if (!vis1[adj[u][i]]) dfs1(adj[u][i]);
}
}
void dfs2(int u) {
vis2[u] = 1;
vis3[u] = 1;
for (int i = (int)0; i <= (int)dir[u].size() - 1; i++) {
if (!vis2[dir[u][i]]) dfs2(dir[u][i]);
if (vis3[dir[u][i]]) fl = 1;
}
vis3[u] = 0;
}
int fun() {
int ret = 0;
for (int j = (int)0; j <= (int)vec.size() - 1; j++) {
if (!vis2[vec[j]]) {
fl = 0;
dfs2(vec[j]);
ret += fl;
}
}
return (ret == 0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = (int)1; i <= (int)m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
dir[u].push_back(v);
}
int ans = 0;
for (int i = (int)1; i <= (int)n; i++) {
if (!vis1[i]) {
vec.clear();
dfs1(i);
ans += vec.size() - fun();
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
int p = n / 2;
int t = 0;
for (int i = 1; i <= p; i++) {
if (t)
printf("aa");
else
printf("bb");
t = 1 - t;
}
if (n % 2) {
if (t)
printf("a");
else
printf("b");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6 + 10;
const long long INF = 1e18;
long long a, b, c, d, dp[maxn], sum[maxn], ans = 0;
long long f(long long z) {
if (z > (b + c)) return 0;
if ((a + b) > z) return 0;
return min(z - b, b) - max(z - c, a) + 1;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> a >> b >> c >> d;
long long len1 = b - a + 1, len2 = c - b + 1, len3 = d - c + 1;
ans = ((len1 * len2) * len3);
for (long long i = 1; i < c; i++) {
dp[i] = dp[i - 1] + f(i);
}
for (long long i = c; i <= d; i++) {
dp[i] = dp[i - 1] + f(i);
sum[i] = sum[i - 1] + dp[i];
}
ans -= sum[d];
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T lcm(T a, T b) {
return a / __gcd(a, b) * b;
}
template <class T>
T minimize(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
T maximize(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long mod = 1e9 + 7, oo = 1e12, N = 1005, K = 100005;
using namespace std;
long long n, m, k;
long long dx[] = {0, -1, 0, 1};
long long dy[] = {-1, 0, 1, 0};
long long mark[N][N], result[K];
char ch[N][N];
bool not_ok(long long u, long long v) {
if (u < 1 || u > m || v < 1 || v > n) return 1;
return 0;
}
void dfs(long long x, long long y, long long num_query, long long &sum) {
if (mark[x][y] || not_ok(x, y)) return;
if (ch[x][y] == '*') {
++sum;
return;
}
mark[x][y] = num_query;
for (__typeof(3) i = (0); i <= (3); ++i) {
long long new_x = x + dx[i];
long long new_y = y + dy[i];
dfs(new_x, new_y, num_query, sum);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> m >> n >> k;
for (__typeof(m) i = (1); i <= (m); ++i)
for (__typeof(n) j = (1); j <= (n); ++j) cin >> ch[i][j];
for (long long u, v; k; k--) {
cin >> u >> v;
long long sum = 0;
if (!mark[u][v])
dfs(u, v, k, sum);
else
sum = result[mark[u][v]];
result[k] = sum;
cout << result[k] << '\n';
}
return 0;
}
| 4 |
# include <bits/stdc++.h>
# define INF 1e9
using namespace std;
int main(){
long int N;
cin >> N;
for(int n=1; n<3501; n++){
for(int h=1; h<3501; h++){
long int num = N * h * n;
long int den = 4*h*n - N*(n+h);
if (den > 0 && num % den == 0){
cout << n <<" "<< h <<" " << num / den << endl;
exit(0);
}
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const long long int inf = -1e18;
const int MOD = 1e9 + 103;
int h[26];
int p[1505];
map<long long int, bool> mp;
long long int power(long long int x, long long int y) {
long long int ans = 1;
x %= MOD;
while (y) {
if (y & 1) ans = (ans * x) % MOD;
y >>= 1;
x = (x * x) % MOD;
}
return ans;
}
long long int addd(long long int x, long long int y) {
return (((x % MOD) + (y % MOD)) % MOD);
}
long long int sub(long long int x, long long int y) {
return (((x % MOD) - (y % MOD) + MOD) % MOD);
}
long long int mul(long long int x, long long int y) {
return (((x % MOD) * (y % MOD)) % MOD);
}
int main() {
string s;
char ch;
long long int k, len, sz, sum = 0, ans = 0;
cin >> s;
for (int i = 0; i < 26; i++) {
cin >> ch;
if (ch == '0') h[i] = 1;
}
cin >> k;
s = '@' + s;
for (int i = 1; i < (int)s.size(); i++) {
p[i] = p[i - 1];
if (h[s[i] - 'a']) p[i]++;
}
len = 1, sz = (int)s.size();
while (len < sz) {
mp.clear();
int i = 1, j = i + len - 1;
sum = 0;
for (int z = i; z <= j; z++) {
sum = addd(sum, mul((s[z] - 'a'), power(26, len - z)));
}
if (p[j] - p[i - 1] <= k) mp[sum] = 1;
i++, j++;
while (j < sz) {
sum = sub(sum, (s[i - 1] - 'a') * power(26, len - 1));
sum = mul(sum, 26);
sum = addd(sum, s[j] - 'a');
if (p[j] - p[i - 1] <= k) mp[sum] = 1;
i++, j++;
}
len++;
ans += (int)mp.size();
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long> v[200000];
int n, i, j, k, l, r, m;
long a;
int main() {
cin >> n;
cin >> a;
v[0].push_back(a);
k = 0;
for (i = 1; i < n; i++) {
cin >> a;
if (v[0][v[0].size() - 1] < a) {
v[0].push_back(a);
;
} else {
r = k;
l = 0;
while (r != l) {
m = (r + l) / 2;
if (v[m][v[m].size() - 1] < a)
r = m;
else
l = m + 1;
}
m = (r + l) / 2;
if ((l == k) && (v[m][v[m].size() - 1] >= a)) {
k++;
v[k].push_back(a);
} else
v[l].push_back(a);
}
}
for (i = 0; i <= k; i++) {
for (j = 0; j < v[i].size(); j++) cout << v[i][j] << " ";
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int to[2000000], h[2000000], nex[2000000];
int top, x, y, u, v, n, fu[500000][30], dep[2000000];
int num[2000000], lg[2000000], m;
void add(int p, int q) {
top++;
to[top] = q;
nex[top] = h[p];
h[p] = top;
}
void dfs(int x, int fa) {
dep[x] = dep[fa] + 1;
fu[x][0] = fa;
num[x] = 1;
for (int i = 1; (1 << i) <= dep[x]; i++) fu[x][i] = fu[fu[x][i - 1]][i - 1];
for (int i = h[x]; i; i = nex[i])
if (to[i] != fa) {
dfs(to[i], x);
num[x] += num[to[i]];
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
while (dep[x] > dep[y]) x = fu[x][lg[dep[x] - dep[y]] - 1];
if (x == y) return x;
for (int i = lg[dep[x]] - 1; i >= 0; i--)
if (fu[x][i] != fu[y][i]) {
x = fu[x][i];
y = fu[y][i];
}
return fu[x][0];
}
int calc(int u, int deep) {
for (int i = 25; i >= 0; i--)
if (dep[u] - (1 << i) >= deep) u = fu[u][i];
return u;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
lg[i] = lg[i - 1];
if (1 << lg[i - 1] == i) lg[i]++;
}
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
dfs(1, 0);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
if (dep[x] < dep[y]) swap(x, y);
if (x == y) {
printf("%d\n", n);
continue;
}
int t = lca(x, y);
int len = dep[x] + dep[y] - 2 * dep[t];
if (len & 1) {
printf("0\n");
continue;
}
if (dep[x] == dep[y]) {
int xa = calc(x, dep[t] + 1), xb = calc(y, dep[t] + 1);
printf("%d\n", n - num[xa] - num[xb]);
} else {
int mid = len / 2 - dep[y] + 2 * dep[t];
printf("%d\n", num[calc(x, mid)] - num[calc(x, mid + 1)]);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n = 8, YES = 0;
char a[10][10][10];
int was[10][10][10];
void dfs(int x, int y, int z) {
++was[x][y][z];
if (z == 8) {
++YES;
return;
}
if (z < n + 1) {
if (a[x][y][z + 1] == '.' && !was[x][y][z + 1]) dfs(x, y, z + 1);
if (y - 1 >= 0 && a[x][y - 1][z + 1] == '.' && a[x][y - 1][z] == '.' &&
!was[x][y - 1][z + 1])
dfs(x, y - 1, z + 1);
if (y + 1 < n && a[x][y + 1][z + 1] == '.' && a[x][y + 1][z] == '.' &&
!was[x][y + 1][z + 1])
dfs(x, y + 1, z + 1);
if (y - 1 >= 0 && x - 1 >= 0 && a[x - 1][y - 1][z + 1] == '.' &&
a[x - 1][y - 1][z] == '.' && !was[x - 1][y - 1][z + 1])
dfs(x - 1, y - 1, z + 1);
if (y + 1 < n && x - 1 >= 0 && a[x - 1][y + 1][z + 1] == '.' &&
a[x - 1][y + 1][z] == '.' && !was[x - 1][y + 1][z + 1])
dfs(x - 1, y + 1, z + 1);
if (y - 1 >= 0 && x + 1 < n && a[x + 1][y - 1][z + 1] == '.' &&
a[x + 1][y - 1][z] == '.' && !was[x + 1][y - 1][z + 1])
dfs(x + 1, y - 1, z + 1);
if (y + 1 < n && x + 1 < n && a[x + 1][y + 1][z + 1] == '.' &&
a[x + 1][y + 1][z] == '.' && !was[x + 1][y + 1][z + 1])
dfs(x + 1, y + 1, z + 1);
if (x - 1 >= 0 && a[x - 1][y][z + 1] == '.' && a[x - 1][y][z] == '.' &&
!was[x - 1][y][z + 1])
dfs(x - 1, y, z + 1);
if (x + 1 < n && a[x + 1][y][z + 1] == '.' && a[x + 1][y][z] == '.' &&
!was[x + 1][y][z + 1])
dfs(x + 1, y, z + 1);
}
}
int main() {
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) cin >> a[i][j][0];
a[0][n - 1][0] = '.';
a[n - 1][0][0] = '.';
for (int k = 1; k < n + 1; ++k) {
for (int i = 0; i < n - 1; ++i)
for (int j = 0; j < n; ++j) a[i + 1][j][k] = a[i][j][k - 1];
for (int j = 0; j < n; ++j) a[0][j][k] = '.';
}
memset(was, 0, sizeof was);
dfs(n - 1, 0, 0);
if (was[0][n - 1][n - 1] || YES)
cout << "WIN" << endl;
else
cout << "LOSE" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 555;
int n, d[N], a[N];
struct udsu {
private:
vector<unsigned> D;
void __init__(size_t n) {
D.resize(n + 1);
for (unsigned i = 0; i <= n; i++) D[i] = i;
}
int __find__(unsigned x) {
if (x >= D.size()) resize(x);
return D[x] = (D[x] == x ? x : __find__(D[x]));
}
public:
udsu() {}
udsu(size_t n) { __init__(n); }
void resize(size_t n) {
size_t lastsize = D.size();
D.resize(n + 1);
for (unsigned i = lastsize; i <= n; i++) D[i] = i;
}
void link(unsigned u, unsigned v) {
if (max(u, v) >= D.size()) resize(max(u, v));
D[__find__(u)] = __find__(v);
}
bool same(unsigned u, unsigned v) {
if (max(u, v) >= D.size()) resize(max(u, v));
return __find__(u) == __find__(v);
}
void clear() { D.clear(); }
size_t size() { return D.size(); }
};
struct dsu {
private:
map<int, int> fa;
bool exist(int x) { return fa.find(x) != fa.end(); }
int __find__(unsigned x) { return (!exist(x) ? x : fa[x] = __find__(fa[x])); }
public:
dsu() {}
void link(unsigned u, unsigned v) { fa[__find__(u)] = __find__(v); }
bool same(unsigned u, unsigned v) { return __find__(u) == __find__(v); }
void clear() { fa.clear(); }
};
udsu S;
int main() {
scanf("%d", &n);
S.resize(n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) {
scanf("%d", d + i);
if (i > d[i]) S.link(i, i - d[i]);
if (i + d[i] <= n) S.link(i, i + d[i]);
}
for (int i = 1; i <= n; i++)
if (!S.same(i, a[i])) {
puts("NO");
return 0;
}
puts("YES");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> g[2 * 100011];
bool p = 0;
bool mark[100011 * 2];
long long x = 0, y = 0;
void dfs(long long v) {
if (mark[v]) return;
mark[v] = 1;
y += g[v].size();
if (g[v].size() != 2) p = 1;
for (long long i = 0; i < g[v].size(); i++) {
long long u = g[v][i];
if (mark[u]) continue;
x++;
dfs(u);
}
}
int main() {
long long n, m, ans = 0;
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long u, v;
cin >> u >> v;
g[v].push_back(u);
g[u].push_back(v);
}
for (long long i = 1; i <= n; i++) {
if (mark[i]) continue;
x = 0;
y = 0;
p = 0;
dfs(i);
y /= 2;
x++;
if (x == y and !p) ans++;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int testnum;
vector<long long> nums;
int cnt;
void preprocess() {}
int a[3][3];
int getnumber(int i, int j) {
int r = a[i][j];
if (i - 1 >= 0) r += a[i - 1][j];
if (j - 1 >= 0) r += a[i][j - 1];
if (i + 1 < 3) r += a[i + 1][j];
if (j + 1 < 3) r += a[i][j + 1];
return r;
}
void solve() {
int i, j;
for (i = 0; i < 3; ++i)
for (j = 0; j < 3; ++j) cin >> a[i][j];
for (i = 0; i < 3; ++i) {
for (j = 0; j < 3; ++j) {
int x = getnumber(i, j);
if (x % 2 == 0)
cout << "1";
else
cout << "0";
}
cout << "\n";
}
}
bool input() { return true; }
int main() {
preprocess();
int T = 1;
for (testnum = 1; testnum <= T; testnum++) {
if (!input()) break;
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[400005], id[400005];
bool cmp(long long x, long long y) { return a[x] < a[y]; }
int main() {
long long n, i, x;
cin >> n;
for (i = 0; i < n; i++) {
id[i] = i;
cin >> a[i];
}
sort(id, id + n, cmp);
long long last = -1;
for (i = 0; i < n; i++) {
x = id[i];
if (last < a[x]) {
last = a[x];
a[x] = a[x];
} else {
a[x] = last + 1;
last++;
}
}
for (i = 0; i < n; i++) {
if (i != n - 1)
cout << a[i] << " ";
else
cout << a[i] << endl;
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
bool used[2000001];
int n,h,w,x;
int main(){
cin>>n>>h>>w;
for(int i=0;i<n;i++){
cin>>x;
if(i%2==0)for(int j=(w)*(i)+x;j<(w)*(i)+x+w;j++){
if(j>=0&&j<=w*n)used[j]=1;
}
else for(int j=w*(i)-x;j<w*(i)-x+w;j++){
if(j>=0&&j<=w*n)used[j]=1;
}
}
int sum=0;
for(int i=0;i<w*n;i++){
if(!used[i])sum+=h;
}
cout<<sum<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[150005], b[150005], c[150005], m = 0;
int snt[44722 + 1];
void sangnt() {
long i, j;
for (i = 1; i <= 44722; i++) snt[i] = 1;
snt[1] = 0;
i = 2;
while (i <= sqrt(44722)) {
while (snt[i] == 0) i++;
for (j = 2; j <= 44722 / i; j++) snt[i * j] = 0;
i++;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a[i], &b[i]);
}
int i;
for (i = 2; i <= a[1]; ++i) {
if (a[1] % i == 0) {
c[++m] = i;
}
while (a[1] % i == 0) {
a[1] /= i;
}
if (i * i > a[1] && a[1] > 1) {
c[++m] = a[1];
break;
}
}
for (i = 2; i <= b[1]; ++i) {
if (b[1] % i == 0) {
c[++m] = i;
}
while (b[1] % i == 0) {
b[1] /= i;
}
if (i * i > b[1] && b[1] > 1) {
c[++m] = b[1];
break;
}
}
bool ans;
for (i = 1; i <= m; ++i) {
ans = true;
for (int j = 2; j <= n; ++j) {
if (a[j] % c[i] != 0 && b[j] % c[i] != 0) {
ans = false;
break;
}
}
if (ans) {
printf("%d\n", c[i]);
break;
}
}
if (!ans) {
printf("-1\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long a[N];
int n;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0), cout.precision(15);
cin >> n;
for (int i = (0); i <= ((n)-1); i += (+1)) {
cin >> a[i];
}
a[n] = 2e9;
sort(a, a + n);
int ans = 0;
for (int i = (0); i <= ((n)-1); i += (+1)) {
int j = upper_bound(a, a + n + 1, a[i] + 5) - a;
while (a[j] - a[i] > 5) {
j--;
}
ans = max(ans, j - i + 1);
}
cout << ans << '\n';
return 0;
}
| 3 |
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
const int N=100005;
int n;
int a[N];
int gcd(int x,int y){
if (!y) return x;
else return gcd(y,x%y);
}
bool solve(){
int yi=0,er=0;
for (int i=1;i<=n;i++){
if (a[i]==1) yi++;
if (!(a[i]&1)) er++;
}
if (er&1) return 1;
if (er<n-1) return 0;
if (yi>0) return 0;
int g=0;
for (int i=1;i<=n;i++){
if (a[i]&1) a[i]--;
g=gcd(a[i],g);
}
for (int i=1;i<=n;i++) a[i]/=g;
return solve()^1;
}
int main(){
scanf("%d",&n);
for (int i=1;i<=n;i++) scanf("%d",&a[i]);
if (solve()) printf("First\n");
else printf("Second\n");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
vector<char> v;
int n, count = 0;
char cur;
cin >> n;
while (n--) {
cin >> cur;
v.push_back(cur);
}
for (int i = 0; i < v.size() - 1; i++) {
if (v[i] == v[i + 1]) {
v.erase(v.begin() + 1);
count++;
i--;
}
}
cout << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int> > gr;
int an[100010][20], tin[100010], tout[100010], t;
int dep[100010], sz[100010];
void dfs(int x, int par, int d) {
tin[x] = t++;
dep[x] = d;
sz[x] = 1;
an[x][0] = par;
for (int i = 1; i < 20; ++i) {
an[x][i] = an[an[x][i - 1]][i - 1];
}
for (auto i : gr[x]) {
if (i != par) {
dfs(i, x, d + 1);
sz[x] += sz[i];
}
}
tout[x] = t++;
}
bool isyananc(int x, int y) {
return (tin[y] <= tin[x] and tout[y] >= tout[x]);
}
int lca(int x, int y) {
if (isyananc(x, y)) {
return y;
}
if (isyananc(y, x)) {
return x;
}
for (int i = 20 - 1; i >= 0; --i) {
if (!isyananc(x, an[y][i])) {
y = an[y][i];
}
}
y = an[y][0];
return y;
}
int kthanc(int k, int x) {
int i = 0;
while (k) {
if (k & 1) {
x = an[x][i];
}
k >>= 1;
++i;
}
return x;
}
int sol(int x, int y) {
if (x == y) {
return n;
}
int l = lca(x, y);
int d = dep[x] - dep[l] + dep[y] - dep[l];
if (d & 1) {
return 0;
}
if (d == 2 * (dep[x] - dep[l])) {
for (int i = 20 - 1; i >= 0; --i) {
if (!isyananc(l, an[x][i])) {
x = an[x][i];
}
if (!isyananc(l, an[y][i])) {
y = an[y][i];
}
}
return n - sz[x] - sz[y];
}
if (dep[x] < dep[y]) {
swap(x, y);
}
return sz[kthanc(d / 2, x)] - sz[kthanc(d / 2 - 1, x)];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
vector<int> vi;
gr.resize(n + 1, vi);
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
gr[u].push_back(v);
gr[v].push_back(u);
}
cin >> m;
dfs(1, 1, 0);
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
cout << sol(x, y) << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x = 0, y = 0;
int n;
cin >> n;
string s;
cin >> s;
for (char c : s) {
if (c == 'U') y--;
if (c == 'D') y++;
if (c == 'L') x--;
if (c == 'R') x++;
}
cout << n - abs(x) - abs(y);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long prev = 0;
long long cur = 0;
for (int i = 1; i <= n; i++) {
long long a;
cin >> a;
if (i == 1) {
prev = a;
cur = 1;
continue;
}
if (a - prev > k) {
cur = 1;
} else {
cur++;
}
prev = a;
}
cout << cur;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int maxn = 1e5;
const int INF = 0x7fffffff;
const int mod = 1e9 + 7;
const double eps = 1e-7;
const double Pi = acos(-1.0);
inline int read_int() {
char c;
int ret = 0, sgn = 1;
do {
c = getchar();
} while ((c < '0' || c > '9') && c != '-');
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
return sgn * ret;
}
inline long long read_ll() {
char c;
long long ret = 0, sgn = 1;
do {
c = getchar();
} while ((c < '0' || c > '9') && c != '-');
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
return sgn * ret;
}
inline long long quick_pow(long long base, long long index) {
long long res = 1;
while (index) {
if (index & 1) res = res * base % mod;
base = base * base % mod;
index >>= 1;
}
return res;
}
int n, a, x, b, y;
bool res;
int main() {
cin >> n >> a >> x >> b >> y;
while (a != x && b != y) {
if (a == b) {
res = true;
break;
}
++a, --b;
if (a > n) a = 1;
if (b == 0) b = n;
}
if (a == b) res = true;
if (res)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
const int mod = 1e9 + 7;
int n, m, k, ans, x, y;
vector<pair<int, pair<int, int> > > all;
bool used[N][N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
all.push_back(make_pair(i + j, make_pair(i, j)));
sort(all.begin(), all.end());
for (int i = 0; i < k; i++) {
ans += (all[i].second.first + all[i].second.second - 1);
used[all[i].second.first][all[i].second.second] = 1;
}
cout << ans << endl;
while (k--) {
pair<int, int> last;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (used[i][j]) last = make_pair(i, j);
used[last.first][last.second] = 0;
for (int i = 1; i <= last.first; i++) cout << "(" << i << ",1) ";
for (int j = 2; j <= last.second; j++)
cout << "(" << last.first << "," << j << ") ";
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n -= 2;
cout << (n / 2 + (n % 2 > 0));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool se[105][105];
int main() {
ios_base::sync_with_stdio(0);
long long n, k, i, j, l, z, sum = 0, yl, yr, ise, min1;
cin >> n >> k;
while (n--) {
cin >> z;
yl = 69696;
ise = 69696;
yr = 69696;
min1 = 99999999;
for (i = 1; i <= k; i++) {
for (j = 1; j <= k - z + 1; j++) {
sum = 0;
bool ngon = 1;
for (l = j; l <= j + z - 1; l++) {
if (!se[i][l]) {
sum = sum + (abs(i - (k + 1) / 2) + abs(l - (k + 1) / 2));
} else {
j = l;
ngon = 0;
break;
}
}
if (ngon && sum < min1) {
ise = i;
yl = j;
yr = j + z - 1;
min1 = sum;
}
if (sum == min1 && ngon) {
if (ise > i) {
ise = i;
yl = j;
yr = j + z - 1;
}
if (ise == i && yl > j) {
ise = i;
yl = j;
yr = j + z - 1;
}
}
}
}
if (yl != 69696) {
cout << ise << " " << yl << " " << yr << endl;
for (j = yl; j <= yr; j++) {
se[ise][j] = 1;
}
} else {
cout << -1 << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, c, y, v, maxi;
scanf("%I64d", &x);
scanf("%I64d", &y);
scanf("%I64d", &c);
scanf("%I64d", &v);
maxi = max(abs(x - c), abs(y - v));
printf("%I64d", maxi);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double sum, pd;
int a, b, c, num;
int main() {
cin >> a >> b;
for (int i = 1; i <= a; i++) {
cin >> c;
sum += c;
}
pd = b - 0.5;
if (sum / a >= pd) {
cout << "0";
return 0;
}
while (1) {
num++;
if ((sum + b * num) / (a + num) >= pd) {
cout << num;
return 0;
}
}
return 0;
}
| 1 |
#include<iostream>
int main() {
int x, t;
std::cin >> x >> t;
std::cout << (x > t ? x - t : 0) << std::endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
constexpr long double PI = 3.14159265358979323846264338327950288L;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
constexpr ll mod17 = 1e9 + 7;
constexpr ll mod19 = 1e9 + 9;
constexpr ll mod9 = 998244353;
ll mod = mod17;
template <typename T>
T mod_pow(T a, ll x) {
T res = 1;
while (x > 0) {
if (x & 1) res *= a;
a *= a;
x >>= 1;
}
return res;
}
unordered_map<ll, ll> minvmap;
ll minv(ll a, ll m) {
auto k = a;
auto p = minvmap[a];
if (p != 0) return p;
ll b = m, u = 1, v = 0;
while (b) {
ll t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
p = (u % m + m) % m;
minvmap[k] = p;
return p;
}
struct mint {
ll x;
mint() : x(0) {}
mint(ll x) : x((x % mod + mod) % mod) {}
mint& fix() {
x = (x % mod + mod) % mod;
return *this;
}
mint operator-() const { return mint(0) - *this; }
mint& operator+=(const mint& a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint& a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint& a) {
(x *= a.x) %= mod;
return *this;
}
mint& operator/=(const mint& a) {
(x *= minv(a.x, mod)) %= mod;
return *this;
}
mint operator+(const mint& a) const { return mint(*this) += a; }
mint operator-(const mint& a) const { return mint(*this) -= a; }
mint operator*(const mint& a) const { return mint(*this) *= a; }
mint operator/(const mint& a) const { return mint(*this) /= a; }
bool operator<(const mint& a) const { return x < a.x; }
bool operator==(const mint& a) const { return x == a.x; }
};
struct mint64 {
ull x;
static ull mod, inv, r2;
mint64() : x(0) {}
mint64(ull x) : x(init(x)) {}
static ull init(ull x) { return reduce(__uint128_t(x) * r2); }
static void set_mod(ull m) {
mod = inv = m;
for (int i = 0; i < 5; i++) inv *= 2 - inv * m;
r2 = -__uint128_t(m) % m;
}
static ull reduce(__uint128_t x) {
ull y = ull(x >> 64) - ull((__uint128_t(ull(x) * inv) * mod) >> 64);
return ll(y) < 0 ? y + mod : y;
}
mint64& operator+=(mint64& a) {
x += a.x - mod;
if (ll(x) < 0) x += mod;
return *this;
}
mint64 operator+(mint64& a) const { return mint64(*this) += a; }
mint64& operator*=(mint64& a) {
x = reduce(__uint128_t(x) * a.x);
return *this;
}
mint64 operator*(mint64& a) const { return mint64(*this) *= a; }
};
ull mint64::mod, mint64::inv, mint64::r2;
struct Miller {
const vector<ull> v = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
bool suspect(ull a, ull s, ull d, ull n) {
if (mint64::mod != n) mint64::set_mod(n);
mint64 one = 1, minusone = n - 1, ma = a;
auto x = mod_pow(ma, d);
if (x.x == one.x) return true;
for (int r = 0; r < s; r++) {
if (x.x == minusone.x) return true;
x = x * x;
}
return false;
}
bool check(ull n) {
if (n < 2 || (n > 2 && n % 2 == 0)) return false;
ull d = n - 1;
ull s = 0;
while (!(d & 1)) {
d >>= 1;
s++;
}
for (auto a : v) {
if (a >= n) break;
if (!suspect(a, s, d, n)) return false;
}
return true;
}
};
class combination {
public:
std::vector<mint> fact;
public:
std::vector<mint> inv;
combination(int n) {
fact.resize(n + 1);
inv.resize(n + 1);
fact[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = fact[i - 1] * i;
}
inv[n] = mint(1) / fact[n];
for (int i = n - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1);
}
}
public:
mint get(int n, int r) {
if (n < r || n < 0 || r < 0) return 0;
return fact[n] * inv[r] * inv[n - r];
}
public:
mint p(int n, int r) {
if (n < r || n < 0) return 0;
return fact[n] * inv[n - r];
}
};
class AHilbertsHotel {
public:
void calc(istream& cin, ostream& cout) {
ll n;
cin >> n;
vector<ll> a(n);
for (int i = 0; i < (int)(n); i++) {
cin >> a[i];
a[i] += n * (mod);
a[i] %= n;
}
vector<bool> used(n);
for (int i = 0; i < (int)(n); i++) {
if (used[i]) continue;
int tmp = i;
if ((a[tmp] + tmp) % n == tmp) {
used[i] = true;
continue;
}
tmp = (tmp + a[tmp]) % n;
42;
while (tmp != i) {
42;
if (used[tmp]) {
cout << "NO" << '\n';
return;
}
used[tmp] = true;
tmp = (tmp + a[tmp]) % n;
if ((a[tmp] + tmp) % n == tmp) {
cout << "NO" << '\n';
return;
}
}
}
cout << "YES" << '\n';
}
void solve(istream& cin, ostream& cout) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
calc(cin, cout);
}
}
};
signed main() {
AHilbertsHotel solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int loga = 20;
const int off = 1 << loga;
int n, t;
int niz[maxn];
int tour[off * 2];
map<int, vector<int> > m;
vector<int> ac;
int gcd(int x, int y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
int query(int a, int b, int l, int r, int x) {
if (l > b || r < a) return 0;
if (l >= a && r <= b) return tour[x];
int mid = (l + r) / 2;
int as = query(a, b, l, mid, x * 2), bs = query(a, b, mid + 1, r, x * 2 + 1);
return gcd(as, bs);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", niz + i);
for (int i = 0; i < off * 2; i++) tour[i] = 1;
for (int i = 0; i < n; i++) tour[off + i] = niz[i];
for (int i = off - 1; i > 0; i--) tour[i] = gcd(tour[i * 2], tour[i * 2 + 1]);
for (int i = 0; i < n; i++) m[niz[i]].push_back(i);
scanf("%d", &t);
for (int i = 0; i < t; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
int wh = query(a, b, 0, off - 1, 1);
if (m[wh].empty())
printf("%d\n", b - a + 1);
else {
int index1 = lower_bound(m[wh].begin(), m[wh].end(), a) - m[wh].begin();
int index2 = upper_bound(m[wh].begin(), m[wh].end(), b) - m[wh].begin();
index2--;
printf("%d\n", b - a + 1 - (index2 - index1 + 1));
}
}
return 0;
}
| 6 |
#include<iostream>
#include<string>
#include<set>
#include<algorithm>
using namespace std;
int main() {
string s; cin >> s;
if (s.size() < 26) {
for (char c = 'a'; c <= 'z'; c++) {
if (s.find(c) == -1) {
cout << s << c << endl;
return 0;
}
}
}
else {
set<char>x;
while (!s.empty()) {
char c = s.back(); s.pop_back();
x.insert(c);
if (c != *x.rbegin()) {
cout << s << *x.upper_bound(c) << endl;
return 0;
}
}
cout << -1 << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
typedef long long LL;
#define SORT(c) sort((c).begin(),(c).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
using namespace std;
int main(void)
{
for(;;){
int n,pw;
cin >> n;
if(!n) return 0;
cin >> pw;
set<long double> wss;
wss.insert(0.0);
map<double,double>a;
double tmpanswer=0.0;
a[0.0]=pw;
int rnd;
REP(i,n){
int vw,pf,vf,th;
scanf("%d%d%d%d",&vw,&pf,&vf,&th);
if(th>0){
a[0.0]+=-1.0*pf*vw/vf;
tmpanswer+=1.0*th*pf/vf;
}
if(th==0&&vw<0){
a[0.0]+=-1.0*pf*vw/vf;
}
if(vw&&th*vw>0){
long double w=1.0*th/vw;
wss.insert(w);
a[w]+=1.0*pf*abs(vw)/vf;
}
}
vector<long double> ws(wss.begin(),wss.end());
double answer=tmpanswer;
REP(i,ws.size()-1){
tmpanswer+=a[ws[i]]*(ws[i+1]-ws[i]);
a[ws[i+1]]+=a[ws[i]];
answer=min(answer,tmpanswer);
}
cout << fixed << setprecision(10) << answer << endl;
}
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long s, x;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> s >> x;
if (x > s || (x % 2 != s % 2)) {
cout << 0;
return 0;
}
long long an = (s - x) / 2;
long long coef = 1;
for (int i = 0; i < 50; i++) {
int bit1 = (an >> i) % 2;
int bit2 = (x >> i) % 2;
if (bit1 == 1) {
if (bit2 != 0) {
cout << 0;
return 0;
}
} else {
if (bit2 == 1) {
coef *= 2;
}
}
}
if (an == 0) {
if (x == 0) {
cout << 0;
return 0;
} else {
coef -= 2;
}
}
cout << coef << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, X;
vector<int> R;
char S[105];
int main() {
scanf("%d", &N);
scanf("%s", S);
S[N++] = 'W';
for (int i = 0; i < N; i++) {
if (S[i] == 'B')
X++;
else if (X)
R.push_back(X), X = 0;
}
printf("%d\n", R.size());
for (int i = 0; i < R.size(); i++)
printf("%d%s", R[i], (i < R.size() - 1) ? " " : "\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
void search(int k, int n, int &x, int &y) {
int c, tmp;
if (k == 0) {
x = 0;
y = 0;
return;
}
c = 0;
for (int i = 0; i < k - 1; i++) c = 4 * c + 3;
tmp = (1 << k - 1) - 1;
if (n <= c) {
search(k - 1, n, x, y);
x ^= y, y ^= x, x ^= y;
} else if (n <= 2 * c + 1) {
search(k - 1, n - c - 1, x, y);
y += tmp + 1;
} else if (n <= 3 * c + 2) {
search(k - 1, n - c - 1 - c - 1, x, y);
x += tmp + 1;
y += tmp + 1;
} else {
search(k - 1, n - 3 * c - 3, x, y);
x = tmp - x;
y = tmp - y;
x ^= y, y ^= x, x ^= y;
x += tmp + 1;
}
}
int main() {
int a, b, x, y;
scanf("%d%d", &a, &b);
search(a, b, x, y);
printf("%d %d\n", x, y);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
struct Edge {
int y, ne;
};
int n, m, num, ans;
int x[N], y[N], dis[N];
Edge e[N];
int last[N];
pair<int, int> f[N][10], g[N][10];
pair<int, int> a1, a2;
queue<int> Q;
void add(int x, int y) {
e[++num] = (Edge){y, last[x]};
last[x] = num;
}
void bfs(int x) {
for (int i = 1; i <= n; i++) dis[i] = -1;
dis[x] = 0;
Q.push(x);
while (!Q.empty()) {
int now = Q.front();
Q.pop();
for (int j = last[now]; j; j = e[j].ne)
if (dis[e[j].y] == -1) {
dis[e[j].y] = dis[now] + 1;
Q.push(e[j].y);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x[i], &y[i]);
add(y[i], x[i]);
}
for (int i = 1; i <= n; i++) f[i][0].second = g[i][0].second = n + 10;
for (int i = 1; i <= n; i++) {
bfs(i);
for (int j = 1; j <= n; j++)
for (int k = 3; k >= 0; k--)
if (dis[j] < f[i][k].second) {
f[i][k + 1] = make_pair(j, dis[j]);
break;
} else
f[i][k + 1] = f[i][k];
}
num = 0;
for (int i = 1; i <= n; i++) last[i] = 0;
for (int i = 1; i <= m; i++) add(x[i], y[i]);
for (int i = 1; i <= n; i++) {
bfs(i);
for (int j = 1; j <= n; j++)
for (int k = 3; k >= 0; k--)
if (dis[j] < g[i][k].second) {
g[i][k + 1] = make_pair(j, dis[j]);
break;
} else
g[i][k + 1] = g[i][k];
}
for (int i = 1; i <= n; i++) {
bfs(i);
for (int j = 1; j <= n; j++)
if (j != i && dis[j] != -1)
for (int k1 = 1; k1 <= 3; k1++)
for (int k2 = 1; k2 <= 3; k2++) {
int p1 = f[i][k1].first, p2 = g[j][k2].first;
if (p1 == 0 || p2 == 0) continue;
if (p1 == i || p1 == j || p1 == p2) continue;
if (i == p2 || j == p2) continue;
if (ans < f[i][k1].second + dis[j] + g[j][k2].second) {
ans = f[i][k1].second + dis[j] + g[j][k2].second;
a1 = make_pair(p1, i);
a2 = make_pair(j, p2);
}
}
}
printf("%d %d %d %d\n", a1.first, a1.second, a2.first, a2.second);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod7 = 1000000007;
int n, m;
int sz;
string s[2];
vector<int> gr[200000];
int num[2][300002];
bool used[300002];
int dist[300002];
int lca[300002][30];
int l = 20;
int timer;
int tin[300002];
int tout[300002];
int cnt[300002];
int ccnt = 1;
void dfs(int v, int p, int depth) {
used[v] = true;
tin[v] = timer++;
lca[v][0] = p;
for (int i = 1; i < l; ++i) lca[v][i] = lca[lca[v][i - 1]][i - 1];
for (int i = 0; i < gr[v].size(); ++i) {
if (!used[gr[v][i]]) dfs(gr[v][i], v, depth + 1);
}
cnt[v] = ccnt;
dist[v] = depth;
tout[v] = timer++;
}
bool upper(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int find_lca(int a, int b) {
if (upper(a, b)) return a;
if (upper(b, a)) return b;
for (int i = l - 1; i >= 0; --i)
if (!upper(lca[a][i], b)) a = lca[a][i];
return lca[a][0];
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> s[0] >> s[1];
for (int j = 0; j < 2; ++j) {
for (int i = 0; i < s[j].length(); ++i) {
num[j][i] = -1;
if (s[j][i] == '.')
num[j][i] = sz;
else if (i && s[j][i - 1] == '.')
++sz;
}
++sz;
}
int j = 0;
for (int i = 0; i < s[j].length(); ++i) {
if (s[j][i] == '.' && s[1 - j][i] == '.') {
gr[num[j][i]].push_back(num[1 - j][i]);
gr[num[1 - j][i]].push_back(num[j][i]);
}
}
for (int i = 0; i < sz; ++i) {
if (!used[i]) {
dfs(i, i, 0);
++ccnt;
}
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
int temp = abs((a <= n ? a - 1 : a - n - 1) - (b <= n ? b - 1 : b - n - 1));
a = num[a <= n ? 0 : 1][a <= n ? a - 1 : a - n - 1];
b = num[b <= n ? 0 : 1][b <= n ? b - 1 : b - n - 1];
if (cnt[a] != cnt[b])
cout << -1 << endl;
else {
int z = find_lca(a, b);
cout << (dist[a] + dist[b] - 2 * dist[z] + temp) << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, k, l, n, m, x, z, s, d, t, ans, a[500007];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m >> k;
for (i = 0; i < 2 * k; i++) {
cin >> x >> z;
}
string s;
for (i = 0; i < n - 1; i++) {
s += 'U';
}
for (i = 0; i < m - 1; i++) {
s += 'L';
}
for (i = 0; i < n; i++) {
for (j = 0; j < m - 1; j++) {
if (i % 2 == 0)
s += 'R';
else
s += 'L';
}
if (i != n - 1) s += 'D';
}
cout << s.size() << "\n";
cout << s << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int arr[1005], val[1005];
long double dp[1005];
int par[1005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N, K;
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> arr[i] >> val[i];
}
long double l = 0, r = 1e9, ans = 0;
for (int t = 0; t < 60; t++) {
long double mid = (l + r) / 2;
for (int i = 1; i <= N; i++) {
long double ret = 1e12;
for (int j = 0; j < i; j++) {
ret = min(ret, sqrt(abs(K - arr[i] + arr[j])) + dp[j]);
}
dp[i] = ret - mid * val[i];
}
if (dp[N] >= 0) {
l = mid;
} else {
r = mid;
ans = mid;
}
}
for (int i = 1; i <= N; i++) {
long double ret = 1e12;
for (int j = 0; j < i; j++) {
if (ret > sqrt(abs(K - arr[i] + arr[j])) + dp[j]) {
par[i] = j;
}
ret = min(ret, sqrt(abs(K - arr[i] + arr[j])) + dp[j]);
}
dp[i] = ret - ans * val[i];
}
vector<int> out;
int c = N;
while (c) {
out.push_back(c);
c = par[c];
}
sort(out.begin(), out.end());
for (int n : out) {
cout << n << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long inline gcd(long long x, long long y) {
return !y ? (long long)abs(x) : gcd(y, x % y);
}
long long inline lcm(long long a, long long b) {
return ((long long)abs((a / gcd(a, b)) * b));
}
double inline cartesian_dist(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
long long bigmod(long long b, long long p, long long m) {
if (!p)
return 1 % m;
else if (p & 1)
return (((b % m) + m) % m * bigmod(b, p - 1, m)) % m;
else {
long long ret = bigmod(b, p / 2, m);
return (ret * ret) % m;
}
}
long long inverse(long long a, long long m) { return bigmod(a, m - 2, m); }
long long extended(long long a, long long m) {
long long oldr = a, r = m, oldans = 1, ans = 0, quotient;
while (r) {
quotient = oldr / r;
oldr = oldr - r * quotient;
swap(oldr, r);
oldans = oldans - ans * quotient;
swap(oldans, ans);
}
return ((oldans % m) + m) % m;
}
const double PI = acos(-1.0);
const double eps = 10E-12;
long long MOD = 101LL;
int d, n, m;
vector<pair<int, int> > vec;
long long getResult(int now) {
long long ans = 0;
priority_queue<pair<int, int> > pq;
for (int i = 0; i < vec.size(); i++) {
if (now >= vec[i].first)
pq.push(make_pair(-vec[i].second, vec[i].first));
else {
while (now < vec[i].first) {
if (pq.empty()) return -1;
while (!pq.empty() && pq.top().second + n <= now) pq.pop();
int canGo = n - (now - pq.top().second);
int nextPos = min(vec[i].first, now + canGo);
ans += (long long)(nextPos - now) * (long long)(-pq.top().first);
now = nextPos;
}
pq.push(make_pair(-vec[i].second, vec[i].first));
}
}
return ans;
}
int main() {
scanf("%d %d %d", &d, &n, &m);
int x, p;
while (m--) {
scanf("%d %d", &x, &p);
vec.push_back(make_pair(x, p));
}
vec.push_back(make_pair(d, 0));
sort(vec.begin(), vec.end());
printf("%lld", getResult(n));
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void findMin(int sum) {
int a = -1, b = 0;
for (b = sum / 7; b >= 0; b--) {
int rem = sum - b * 7;
if (rem % 4 == 0) {
a = rem / 4;
break;
}
}
if (a < 0) {
printf("-1\n");
return;
}
for (int i = 0; i < a; i++) printf("4");
for (int i = 0; i < b; i++) printf("7");
printf("\n");
}
int main() {
int n;
cin >> n;
findMin(n);
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.