solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
vector<long long> val;
long long type1 = 0, type2 = 0, type3 = 0;
long long ch1 = 0, ch2 = 0;
if (s.size() == 1) {
cout << -1 << endl;
return 0;
}
for (long long i = 0; i < s.size(); ++i) {
if (s[i] == '(') {
type1++;
ch1++;
} else if (s[i] == ')') {
type2++;
ch2++;
if (type1 != 0) {
type1--;
}
} else if (s[i] == '#') {
type3++;
type1 = 0;
}
if (ch1 < ch2 + type3) {
cout << -1 << endl;
return 0;
}
}
if (type1 > 0) {
cout << -1 << endl;
return 0;
}
for (long long i = 0; i < type3 - 1; ++i) {
cout << 1 << endl;
ch2++;
}
cout << ch1 - ch2 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 10;
const int INF = 0x3f3f3f3f;
const int mod = 20050321;
int t, a;
unordered_map<int, int> mp;
vector<int> res;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &a);
mp.clear();
res.clear();
int sq = sqrt(a);
res.push_back(0);
res.push_back(1);
mp[0] = 1;
mp[1] = 1;
for (int i = sq; i >= 1; i--) {
int tmp = a / i;
if (!mp[tmp]) {
res.push_back(tmp);
mp[tmp] = true;
}
if (!mp[i]) {
res.push_back(i);
mp[i] = true;
}
}
sort(res.begin(), res.end());
printf("%d\n", res.size());
for (auto to : res) printf("%d ", to);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const int maxn = (int)1e5 + 17;
const int mod = (int)1e9 + 7;
int n, m, t, kase;
int a[maxn], cnt[maxn];
vector<int> v[maxn];
void dfs(int x) {
if (v[x].size() == 0) cnt[x] = 1;
for (auto i : v[x]) {
dfs(i);
cnt[x] += cnt[i];
}
}
int main() {
kase = 1;
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; ++i) {
v[i].clear();
cnt[i] = 0;
}
for (int i = 2; i <= n; ++i) {
scanf("%d", &m);
v[m].push_back(i);
}
dfs(1);
sort(cnt + 1, cnt + n + 1);
for (int i = 1; i <= n; ++i) {
printf("%d ", cnt[i]);
}
putchar('\n');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int t[1000111];
int N;
void inc(int x) {
while (x <= N) {
t[x]++;
x += x & -x;
}
}
int sum(int x) {
int res = 0;
while (x) {
res += t[x];
x -= x & -x;
}
return res;
}
int a[200222];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
N = max(N, a[i]);
}
sort(a, a + n);
int kol = 0;
for (int i = 0; i < n; i++) {
int S = sum(a[i]) - sum(max(0, a[i] - m));
if (S + 1 < k) {
inc(a[i]);
kol++;
}
}
cout << n - kol;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct query {
int x1, y1, x2, y2, i;
bool operator<(const query q) const { return x2 < q.x2; }
};
const int MAXK = 200005;
const int SZ = 1 << 18;
int N, M, K, Q, A[2 * SZ], res[MAXK];
pair<int, int> R[MAXK];
query queries[MAXK];
void update(int p, int v) {
p += SZ - 1;
A[p] = v;
for (p /= 2; p; p /= 2) {
A[p] = min(A[2 * p], A[2 * p + 1]);
}
}
int rmq(int l, int r) {
l += SZ - 1, r += SZ;
int res = MAXK;
for (; l < r; l /= 2, r /= 2) {
if (l & 1) res = min(res, A[l++]);
if (r & 1) res = min(res, A[--r]);
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M >> K >> Q;
for (int i = 0; i < K; i++) {
int x, y;
cin >> x >> y;
R[i] = pair<int, int>(x, y);
}
for (int i = 0; i < Q; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
queries[i] = {x1, y1, x2, y2, i};
}
sort(R, R + K);
sort(queries, queries + Q);
for (int i = 0, j = 0; i < Q; i++) {
for (; j < K && R[j].first <= queries[i].x2; j++) {
update(R[j].second, R[j].first);
}
int r = rmq(queries[i].y1, queries[i].y2);
if (r >= queries[i].x1) res[queries[i].i] = 1;
}
for (int i = 0; i < K; i++) {
swap(R[i].first, R[i].second);
}
for (int i = 0; i < Q; i++) {
swap(queries[i].x1, queries[i].y1);
swap(queries[i].x2, queries[i].y2);
}
memset(A, 0, sizeof(A));
sort(R, R + K);
sort(queries, queries + Q);
for (int i = 0, j = 0; i < Q; i++) {
for (; j < K && R[j].first <= queries[i].x2; j++) {
update(R[j].second, R[j].first);
}
int r = rmq(queries[i].y1, queries[i].y2);
if (r >= queries[i].x1) res[queries[i].i] = 1;
}
for (int i = 0; i < Q; i++) {
cout << (res[i] ? "YES\n" : "NO\n");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
int rd(int l, int r) {
printf("? %d %d\n", l, r);
fflush(stdout);
int t;
scanf("%d", &t);
if (t == -1) exit(0);
return t;
}
void fmain(int tid) {
int t;
scanf("%d%d", &n, &t);
vector<int> a(n + 5, 0);
a[n] = t;
int pre = 0;
for (int(i) = 1; (i) <= (int)(n - 1); (i)++) {
int pt = t, st = t;
for (int(zz) = 0; (zz) < (int)(16); (zz)++) {
rd(i + 1, n);
t = rd(i + 1, n);
if (t != pt) {
st = t;
}
}
st -= pt;
a[i] = (i - st) / 2 - pre;
pre += a[i] + t - pt;
a[n] -= a[i];
}
printf("! ");
for (int(i) = 1; (i) <= (int)(n); (i)++) printf("%d", a[i]);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 9 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define For(i,a,b,c) for(ll i=a;i<b;i+=c)
#define For2(i,a,b,c) for(ll i=a;i>=b;i-=c)
#define vec_ll vector<vector<ll>>
#define vec_pr vector<pair<ll,ll>>
#define pr pair<ll,ll>
#define pbk push_back
#define mkpr make_pair
#define fst first
#define snd second
void print(ll *arr, ll n){
For(i,0,n,1)cout<<arr[i]<<" ";
cout<<endl;
}
bool s_sec(const pair<ll,ll> &a, const pair<ll,ll> &b) {
return (a.second < b.second);
}
ll fast_expo(ll a, ll p){
//cout<<a<<" ";
ll x=p-2;
ll curr=a;
ll ans=1;
while(x!=0){
if(x%2==1){
ans=(ans*curr)%p;
}
x/=2;
curr=(curr*curr)%p;
}
return ans;
}
bool solve(vec_ll &mat_xor, ll n){
bool horiz=true, vert=true;
For(i,0,n,1){
ll sum=0, sum2=0;
For(j,0,n,1){
sum+=mat_xor[i][j];
sum2+=mat_xor[j][i];
}
if(n>sum && sum>0){
horiz=false;
}
if(n>sum2 && sum2>0){
vert=false;
}
}
if(horiz==true || vert==true){
return true;
}
else{
ll arr1[n][n];
bool poss=true;
For(i,0,n,1){
arr1[0][i]=mat_xor[0][i];
}
///First check whether arr1 can be made equal to mat_xor
For(i,1,n,1){
arr1[i][0]=mat_xor[i][0];
ll temp=(arr1[i][0]+mat_xor[0][0])%2;
For(j,1,n,1){
arr1[i][j]=(arr1[0][j] xor temp);
}
}
For(i,0,n,1){
For(j,0,n,1){
poss = poss && (arr1[i][j] == mat_xor[i][j]);
}
}
return poss;
}
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
/*ll T,p=1000000007;
cin>>T;
ll fact[1001],inverse[1001];
fact[0]=fact[1]=inverse[0]=inverse[1]=1;
For(i,2,1001,1){
fact[i]=(fact[i-1]*i)%p;
inverse[i]=fast_expo(fact[i],p);
}*/
ll T;
cin>>T;
while(T--){
ll n;
cin>>n;
string a[n],b[n];
///
For(i,0,n,1){
cin>>a[i];
}
///
For(i,0,n,1){
cin>>b[i];
}
vec_ll mat_xor;
For(i,0,n,1){
vector<ll> temp;
For(j,0,n,1){
temp.pbk((a[i][j]-'0' + b[i][j]-'0')%2);
}
mat_xor.pbk(temp);
}
bool poss=solve(mat_xor,n);
if(poss==true){
cout<<"YES\n";
}
else{
cout<<"NO\n";
}
}
}
| 5 |
#include <bits/stdc++.h>
int dp[2010][2010];
int n, k;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < k; i++) {
for (int j = 1; j <= n; j++) {
dp[i + 1][j] = 0;
}
for (int j = 1; j <= n; j++) {
if (i == 0) {
dp[i + 1][j] = 1;
} else {
for (int p = j; p <= n; p += j) {
dp[i + 1][p] = (dp[i + 1][p] + dp[i][j]) % 1000000007;
}
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = (ans + dp[k][i]) % 1000000007;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, ans;
cin >> n;
ans = n / 2;
if (n % 2) ans -= n;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int c[n + 2];
for (int i = 0; i < n; i++) {
c[i] = a[i];
}
int b[n + 2];
for (int i = 0; i < n; i++) {
b[i] = i;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < i; j++) {
if (a[j] < a[j + 1]) {
b[j] = b[j + 1] + b[j];
b[j + 1] = b[j] - b[j + 1];
b[j] = b[j] - b[j + 1];
a[j] = a[j] + a[j + 1];
a[j + 1] = a[j] - a[j + 1];
a[j] = a[j] - a[j + 1];
}
}
}
int d[n + 2];
for (int i = 0; i < n; i++) {
d[b[i]] = i;
}
for (int i = 0; i < n; i++) {
cout << c[b[((d[i] + 1) % n)]] << " ";
}
}
| 6 |
#include <bits/stdc++.h>
template <typename T>
T GCD(T a, T b) {
return a ? GCD(b % a, a) : b;
}
template <typename T>
T LCM(T a, T b) {
return (a * b) / GCD(a, b);
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
for (auto ob : v) os << ob << " ";
return os;
}
template <typename T, typename S>
std::ostream &operator<<(std::ostream &os, const std::map<T, S> &v) {
for (auto ob : v) os << ob.first << " : " << ob.second << std::endl;
return os;
}
using ld = double;
using ll = long long int;
using ul = unsigned long long int;
using namespace std;
class DSalaryChanging {
bool Possible(vector<pair<int, int>> money, ll s, int mid, int n) {
ll sum = 0;
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (money[i].second < mid) {
sum += money[i].first;
} else if (money[i].first >= mid) {
cnt++;
sum += money[i].first;
} else if (money[i].first < mid && money[i].second >= mid) {
if (cnt > n / 2) {
sum += money[i].first;
} else {
cnt++;
sum += mid;
}
}
}
return cnt > n / 2 && sum <= s;
}
public:
void solve(std::istream &in, std::ostream &out) {
ll n, s;
in >> n >> s;
vector<pair<int, int>> money;
for (int i = 0; i < n; ++i) {
int l, r;
in >> l >> r;
money.push_back(make_pair(l, r));
}
sort(money.begin(), money.end());
reverse(money.begin(), money.end());
int low = 0, high = 1e9 + 17, ans = 0;
while (low <= high) {
int mid = low + (high - low) / 2;
bool isPossible = Possible(money, s, mid, n);
if (isPossible) {
ans = mid;
low = mid + 1;
} else {
high = mid - 1;
}
}
out << ans << endl;
}
};
int main() {
std::ios_base::sync_with_stdio(0);
std::cin.tie(nullptr);
DSalaryChanging solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
int n;
in >> n;
for (int i = 0; i < n; ++i) {
solver.solve(in, out);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
const int mod = 998244353;
bool hor[4444], ver[4444];
int h, w, n;
long long f[4444];
long long invf[4444];
long long qp(long long c, long long st) {
long long r = 1;
while (st) {
if (st & 1) r *= c, r %= mod;
c *= c;
c %= mod;
st >>= 1;
}
return r;
}
long long solve(int n2, int n1, int totaln, long long* n2counts) {
if (n2 * 2 + n1 > totaln) return 0;
return n2counts[n2] * f[totaln - 2 * n2] % mod * invf[n1] % mod *
invf[totaln - 2 * n2 - n1] % mod;
}
long long horcounts2[4444];
long long vercounts2[4444];
void addstuff(long long* cnt, int n) {
vector<long long> c;
for (int i = (0); i < (n / 2 + 1); i++)
c.push_back(f[n - i] * invf[n - i - i] % mod * invf[i] % mod);
for (int i = 4000; i >= 0; i--)
if (cnt[i]) {
long long t = cnt[i];
cnt[i] = 0;
for (int j = (0); j < (c.size()); j++) {
cnt[i + j] = (cnt[i + j] + t * c[j]) % mod;
}
}
}
int main() {
f[0] = 1;
for (int i = (1); i < (4444); i++) f[i] = f[i - 1] * i % mod;
for (int i = (0); i < (4444); i++) invf[i] = qp(f[i], mod - 2);
cin >> h >> w >> n;
for (int i = (0); i < (n); i++) {
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
r1--, r2--, c1--, c2--;
hor[r1] = 1;
hor[r2] = 1;
ver[c1] = 1;
ver[c2] = 1;
}
int nh = 0, nv = 0;
for (int i = (0); i < (h); i++)
if (hor[i] == 0) nh++;
for (int i = (0); i < (w); i++)
if (ver[i] == 0) nv++;
horcounts2[0] = 1;
vercounts2[0] = 1;
for (int i = 0; i < h; i++) {
if (hor[i] == 0) {
int num = 0;
while (i < h && hor[i] == 0) {
num++;
i++;
}
addstuff(horcounts2, num);
}
}
for (int i = 0; i < w; i++) {
if (ver[i] == 0) {
int num = 0;
while (i < w && ver[i] == 0) {
num++;
i++;
}
addstuff(vercounts2, num);
}
}
long long res = 0;
for (int numhor = (0); numhor < (nh / 2 + 1); numhor++)
for (int numver = (0); numver < (nv / 2 + 1); numver++) {
res = (res + solve(numhor, numver, nh, horcounts2) *
solve(numver, numhor, nv, vercounts2) % mod * f[numhor] %
mod * f[numver] % mod) %
mod;
}
cout << res << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct proba {
string a;
long long bull, cow;
};
vector<proba> v;
pair<long long, long long> schet(string a, string b) {
multiset<char> s;
for (long long i = 0; i < b.size(); i++) {
s.insert(b[i]);
}
long long bull = 0;
long long cow = 0;
for (long long i = 0; i < a.size(); i++) {
if (a[i] == b[i]) {
bull++;
s.erase(s.find(a[i]));
}
}
for (long long i = 0; i < a.size(); i++) {
if (s.count(a[i]) != 0) {
cow++;
s.erase(s.find(a[i]));
}
}
return {bull, cow};
}
bool check(string ans) {
for (long long i = 0; i < v.size(); i++) {
pair<long long, long long> bob = schet(v[i].a, ans);
if (bob.first != v[i].bull || bob.second != v[i].cow) {
return false;
}
}
return true;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
long long b, c;
string a;
cin >> a >> b >> c;
v.push_back({a, b, c});
}
string kol;
for (long long i = 100; i < 10000; i++) {
set<long long> se;
string go;
long long x = i;
while (x > 0) {
go += ((char)((long long)(x % 10) + (long long)'0'));
se.insert(x % 10);
x /= 10;
}
if (i < 1000) {
se.insert(0);
go += '0';
}
reverse(go.begin(), go.end());
if (se.size() == 4 && check(go)) {
if (kol.size() != 0) {
cout << "Need more data" << endl;
return 0;
}
kol = go;
}
}
if (kol.size() == 0) {
cout << "Incorrect data" << endl;
} else {
cout << kol << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using i2 = pair<int, int>;
using ll2 = pair<ll, ll>;
const int N = 3e5 + 9;
const ll inf = 1e18;
ll A[N], dp[N][2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; ++i) cin >> A[i];
dp[1][0] = -inf;
dp[1][1] = A[1];
ll m0 = -inf, m1 = A[1];
for (int i = 2; i <= n; ++i) {
dp[i][1] = max(m0, 0LL) + A[i];
dp[i][0] = m1 - A[i];
m0 = max(m0, dp[i][0]);
m1 = max(m1, dp[i][1]);
}
cout << max(m0, m1) << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
struct node {
int x, k, op;
} a[105];
long long f[1050000] = {};
bool cmp(node a, node b) { return a.k < b.k; }
int main() {
int n, m, mi, x;
long long b;
long long ans = (1ll << 60);
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &a[i].x, &a[i].k, &mi);
for (int j = 0; j < mi; j++) {
scanf("%d", &x);
a[i].op |= (1 << (x - 1));
}
}
sort(a, a + n, cmp);
for (int i = 1; i < 1 << m; i++) f[i] = (1ll << 60);
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++) {
long long v = a[i].x + f[j];
f[j | a[i].op] = min(f[j | a[i].op], v);
}
ans = min(ans, a[i].k * b + f[(1 << m) - 1]);
}
cout << (ans == (1ll << 60) ? -1 : ans) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
inline int read() {
int f = 1, k = 0;
char c = getchar();
while (c < '0' || c > '9') c == '-' && (f = -1), c = getchar();
while (c >= '0' && c <= '9') k = k * 10 + c - '0', c = getchar();
return k * f;
}
using namespace std;
const int maxn = 2e5 + 100;
char s[maxn], inv[maxn];
int cnt[26], c[maxn], n;
vector<int> store[26];
inline int query(int x) {
int ans = 0;
for (; x <= n; x += x & -x) ans += c[x];
return ans;
}
inline void upd(int x) {
for (; x; x -= x & -x) c[x]++;
}
signed main() {
n = read();
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) inv[i] = s[n - i + 1];
for (int i = 1; i <= n; i++)
store[inv[i] - 'a'].push_back(n - i + 1), cnt[inv[i] - 'a']++;
long long ans = 0;
for (int i = 1; i <= n; i++) {
int ch = inv[i] - 'a';
int val = store[ch][--cnt[ch]];
ans += query(val + 1);
upd(val);
}
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,avx2,fma,tune=native")
using namespace std;
const int maxn = 5e4 + 5, S = 200, inf = 912881939;
namespace SgT {
int A[maxn << 2], B[maxn << 2];
int mx[maxn << 2], mn[maxn << 2], sc[maxn << 2], sa[maxn << 2], sb[maxn << 2],
ta[maxn << 2], tb[maxn << 2];
void clear() {
memcpy(sa, A, sizeof A), memcpy(sb, B, sizeof B);
for (int i = 1; i < (maxn << 2); i++) sc[i] = inf;
memset(mx, 0, sizeof mx), memset(mn, 0, sizeof mn), memset(ta, 0, sizeof ta),
memset(tb, 0, sizeof tb);
}
void Insert(int u, int l, int r, int ps, int k, int kk) {
A[u] += k, B[u] += kk;
if (l == r) return;
int mid = l + r >> 1;
ps <= mid ? Insert(u << 1, l, mid, ps, k, kk)
: Insert(u << 1 | 1, mid + 1, r, ps, k, kk);
}
void Pushup(int u) {
mx[u] = max(mx[u << 1], mx[u << 1 | 1]),
mn[u] = min(mn[u << 1], mn[u << 1 | 1]);
sa[u] = (mn[u << 1] == mn[u] ? sa[u << 1] : 0) +
(mn[u << 1 | 1] == mn[u] ? sa[u << 1 | 1] : 0);
sb[u] = (mn[u << 1] == mn[u] ? sb[u << 1] : 0) +
(mn[u << 1 | 1] == mn[u] ? sb[u << 1 | 1] : 0);
sc[u] = (mn[u << 1] == mn[u << 1 | 1] ? min(sc[u << 1], sc[u << 1 | 1])
: max(mn[u << 1], mn[u << 1 | 1]));
}
void calc(int u) { sa[u] = A[u], sb[u] = B[u]; }
void Spread(int u) {
if (tb[u]) {
mn[u << 1] = mn[u << 1 | 1] = mx[u << 1] = mx[u << 1 | 1] = tb[u << 1] =
tb[u << 1 | 1] = tb[u],
sc[u << 1] = sc[u << 1 | 1] = inf;
ta[u << 1] = ta[u << 1 | 1] = tb[u] = 0, calc(u << 1), calc(u << 1 | 1);
}
if (ta[u]) {
if (mn[u << 1] < ta[u]) mn[u << 1] = ta[u << 1] = ta[u];
if (mn[u << 1 | 1] < ta[u]) mn[u << 1 | 1] = ta[u << 1 | 1] = ta[u];
ta[u] = 0;
}
}
pair<int, int> plus(pair<int, int> a, pair<int, int> b) {
return {a.first + b.first, a.second + b.second};
}
pair<int, int> Modify(int u, int l, int r, int ul, int ur, int x, int y) {
if (mn[u] > x) return {0, 0};
int mid = l + r >> 1;
pair<int, int> res = {0, 0};
if (ul <= l && r <= ur) {
if (l != r) Spread(u);
if (mx[u] <= x) {
mn[u] = mx[u] = tb[u] = y, ta[u] = 0, sc[u] = inf, calc(u);
return {A[u], B[u]};
}
if (y < sc[u]) {
if (mx[u] == mn[u]) mx[u] = y;
mn[u] = ta[u] = y;
return {sa[u], sb[u]};
}
res = plus(res, Modify(u << 1, l, mid, ul, ur, x, y));
res = plus(res, Modify(u << 1 | 1, mid + 1, r, ul, ur, x, y)), Pushup(u);
return res;
}
Spread(u);
if (ul <= mid) res = plus(res, Modify(u << 1, l, mid, ul, ur, x, y));
if (ur > mid) res = plus(res, Modify(u << 1 | 1, mid + 1, r, ul, ur, x, y));
Pushup(u);
return res;
}
} // namespace SgT
vector<int> T[maxn];
int N, Q, A[maxn], P[maxn], X[maxn], dp[maxn], a1[maxn], a2[maxn];
namespace Solve1 {
set<int> ss;
vector<int> nq[maxn];
void preWork() {
for (int i = 1; i <= Q; i++) nq[X[i]].push_back(i);
}
void Solve(int u) {
int nt = 0;
for (int v : nq[u]) ss.insert(v);
if (A[u] > S)
while (233) {
set<int>::iterator it = ss.lower_bound(nt);
if (it == ss.end()) break;
a1[*it]++, a2[*it] += dp[u];
nt = *it + A[u];
}
for (int v : T[u]) Solve(v);
for (int v : nq[u]) ss.erase(v);
}
} // namespace Solve1
namespace Solve2 {
int dfn[maxn], sz[maxn], dfc;
void DFS(int u) {
dfn[u] = ++dfc, dp[u] = dp[P[u]] + (sz[u] = 1);
for (int v : T[u]) DFS(v), sz[u] += sz[v];
}
void preWork() {
for (int i = 2; i <= N; i++) T[P[i]].push_back(i);
DFS(1);
}
void Solve(int vl) {
int ct = 0;
for (int i = 1; i <= N; i++)
if (A[i] == vl) SgT::Insert(1, 1, N, dfn[i], 1, dp[i]), ct++;
if (!ct) return;
SgT::clear();
for (int i = 1; i <= Q; i++) {
pair<int, int> tp =
SgT::Modify(1, 1, N, dfn[X[i]], dfn[X[i]] + sz[X[i]] - 1, i, i + vl);
a1[i] += tp.first, a2[i] += tp.second;
}
for (int i = 1; i <= N; i++)
if (A[i] == vl) SgT::Insert(1, 1, N, dfn[i], -1, -dp[i]);
}
} // namespace Solve2
int main() {
scanf("%d%d", &N, &Q);
for (int i = 1; i <= N; i++) scanf("%d", A + i);
for (int i = 2; i <= N; i++) scanf("%d", P + i);
for (int i = 1; i <= Q; i++) scanf("%d", X + i);
Solve1::preWork(), Solve2::preWork(), Solve1::Solve(1);
for (int i = 1; i <= S; i++) Solve2::Solve(i);
for (int i = 1; i <= Q; i++)
printf("%d %d\n", a2[i] - a1[i] * dp[X[i]], a1[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
return os << "(" << v.first << ", " << v.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (int i = int(0); i <= int((sz(v)) - 1); ++i) {
if (i) os << ", ";
os << v[i];
}
return os << "]";
}
template <class T>
bool setmax(T& _a, T _b) {
if (_a < _b) {
_a = _b;
return true;
}
return false;
}
template <class T>
bool setmin(T& _a, T _b) {
if (_b < _a) {
_a = _b;
return true;
}
return false;
}
template <class T>
T gcd(T _a, T _b) {
return _b == 0 ? _a : gcd(_b, _a % _b);
}
int read_int() {
int x;
scanf("%d", &x);
return x;
}
long long read_ll() {
long long x;
scanf("%lld", &x);
return x;
}
string read_string() {
string s;
cin >> s;
return s;
}
vector<int> read_vi(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<int> a(n);
for (int i = int(0); i <= int((n)-1); ++i) scanf("%d", &a[i]);
return a;
}
vector<long long> read_vl(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<long long> a(n);
for (int i = int(0); i <= int((n)-1); ++i) scanf("%lld", &a[i]);
return a;
}
vector<double> read_vd(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<double> a(n);
for (int i = int(0); i <= int((n)-1); ++i) scanf("%lf", &a[i]);
return a;
}
vector<pair<int, int> > read_vpi(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<pair<int, int> > a(n);
for (int i = int(0); i <= int((n)-1); ++i)
scanf("%d%d", &a[i].first, &a[i].second);
return a;
}
vector<pair<long long, long long> > read_vpl(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<pair<long long, long long> > a(n);
for (int i = int(0); i <= int((n)-1); ++i)
scanf("%lld%lld", &a[i].first, &a[i].second);
return a;
}
vector<pair<double, double> > read_vpd(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<pair<double, double> > a(n);
for (int i = int(0); i <= int((n)-1); ++i)
scanf("%lf%lf", &a[i].first, &a[i].second);
return a;
}
inline long long powmod(long long a, long long b, long long m) {
long long r = 1;
for (; b > 0; b >>= 1, a = a * a % m) {
if (b & 1) r = r * a % m;
}
return r;
}
bool in_cycle(const vector<vector<int> >& es, int start) {
const int n = static_cast<int>((es).size());
vector<int> dfn(n), low(n), vis(n);
vector<bool> in(n, false);
int cur = 0;
const function<void(int)> dfs = [&](int x) {
vis[x] = -1;
low[x] = dfn[x] = cur++;
for (int y : es[x]) {
if (vis[y] == 0) {
dfs(y);
setmin(low[x], low[y]);
} else if (vis[y] < 0) {
setmin(low[x], dfn[y]);
}
if (in[y]) in[x] = true;
}
vis[x] = 1;
if (low[x] < dfn[x]) in[x] = true;
};
dfs(start);
return in[start];
}
int main() {
const int n = read_int();
(void)read_int();
vector<vector<int> > es(n), res(n);
for (int x = int(0); x <= int((n)-1); ++x) {
for (int y0 : read_vi()) {
const int y = y0 - 1;
es[x].push_back(y), res[y].push_back(x);
}
}
const int start = read_int() - 1;
vector<vector<int> > pre(n, vector<int>(2, -1));
queue<pair<int, int> > que;
for (int x = int(0); x <= int((n)-1); ++x) {
if (es[x].empty()) {
pre[x][0] = -2;
que.push(make_pair(x, 0));
}
}
while (!que.empty()) {
const int x = que.front().first, s = que.front().second;
que.pop();
for (int y : res[x]) {
if (pre[y][s ^ 1] == -1) {
pre[y][s ^ 1] = x;
que.push(make_pair(y, s ^ 1));
}
}
}
if (pre[start][1] >= 0) {
printf("Win\n");
for (int x = start, s = 1; x >= 0; x = pre[x][s], s ^= 1) {
printf("%d ", x + 1);
}
printf("\n");
} else {
if (in_cycle(es, start)) {
printf("Draw\n");
} else {
printf("Lose\n");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
struct Wrapper {
char s[20];
int n = 0;
Wrapper(char *buf) {
strcpy(s, buf);
int len = strlen(buf);
for (int i = 0; i < len; ++i) {
buf[i] = ((buf[i] - '0') % 2 ? '1' : '0');
n += (buf[i] - '0') * (int)pow(2, len - 1 - i);
}
}
bool operator<(const Wrapper &r) const { return strcmp(s, r.s) < 0; }
};
std::map<Wrapper, int> mp;
std::map<int, int> cnt;
int main() {
int T;
scanf("%d", &T);
while (T--) {
char op[3], num[20];
scanf("%s%s", op, num);
if (op[0] == '+') {
Wrapper w(num);
++mp[w];
++cnt[w.n];
} else if (op[0] == '-') {
Wrapper w(num);
--mp[w];
--cnt[w.n];
} else if (op[0] == '?') {
int len = strlen(num), n = 0;
for (int i = 0; i < len; ++i) {
num[i] = ((num[i] - '0') % 2 ? '1' : '0');
n += (num[i] - '0') * (int)pow(2, len - 1 - i);
}
printf("%d\n", cnt[n]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 30;
long long a, b, res1, res2, last, tmp;
int32_t main() {
cout << "?"
<< " " << 0 << " " << 0 << endl;
cin >> last;
for (long long i = N - 1; i >= 0; i--) {
long long ans1, pw = (1LL << i);
cout << "?"
<< " " << res1 + pw << " " << res2 + pw << endl;
cin >> tmp;
ans1 = tmp;
if (!tmp) {
cout << "?"
<< " " << res1 + pw << " " << res2 << endl;
cin >> tmp;
if (tmp == -1) {
res1 += pw;
res2 += pw;
}
last = 0;
} else if (tmp == last) {
cout << "?"
<< " " << res1 + pw << " " << res2 << endl;
cin >> tmp;
if (tmp == 1)
;
else if (tmp == 0)
return -1;
else {
res1 += pw;
res2 += pw;
}
last = ans1;
} else {
tmp = last;
if (tmp == 1) {
res1 += pw;
} else if (!tmp) {
return -1;
} else {
res2 += pw;
}
cout << "?"
<< " " << res1 << " " << res2 << endl;
cin >> last;
}
}
cout << '!' << " " << res1 << " " << res2 << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<string> token(string a) {
vector<string> w;
a.push_back(' ');
while (!a.empty()) {
w.push_back(a.substr(0, a.find(" ")));
a = a.substr(a.find(" ") + 1, a.size() - 1);
}
return w;
}
map<string, int> mapik;
vector<string> amapik;
int dodaj(string a) {
if (mapik.count(a) == 0) {
mapik[a] = mapik.size() - 1;
amapik.push_back(a);
}
return mapik[a];
}
char tmp_str[1000];
string scanf_string() {
scanf("%s", tmp_str);
return tmp_str;
}
const int N = 1000;
int n, m;
int k;
vector<pair<string, int> > skills;
int main() {
scanf("%d%d 0.%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
char name[30];
int val;
scanf("%s %d", name, &val);
val = (val * k) / 100;
if (val >= 100) {
skills.push_back(make_pair(name, val));
}
}
for (int i = 0; i < m; i++) {
char name[30];
scanf("%s", name);
int jest = 0;
for (int i2 = 0; i2 < skills.size(); i2++) {
if (skills[i2].first == name) {
jest = 1;
break;
}
}
if (!jest) {
skills.push_back(make_pair(name, 0));
}
}
sort((skills).begin(), (skills).end());
printf("%d\n", skills.size());
for (int i = 0; i < skills.size(); i++) {
printf("%s %d\n", skills[i].first.c_str(), skills[i].second);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
int t, cnt[MAXN], ansx, ansy, maxDis, n, m, cnt2[MAXN];
bool can;
bool pdAns(int n, int m) {
memset(cnt2, 0, sizeof(cnt2));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cnt2[abs(i - ansx) + abs(j - ansy)]++;
}
}
for (int i = 0; i <= maxDis; ++i) {
if (cnt[i] != cnt2[i]) {
return false;
}
}
return true;
}
int main() {
scanf("%d", &t);
for (int i = 1; i <= t; ++i) {
int num;
scanf("%d", &num);
cnt[num]++;
maxDis = max(maxDis, num);
}
for (int i = 1; i <= maxDis + 1; ++i) {
if (cnt[i] < i * 4) {
ansx = i;
break;
}
}
can = false;
for (n = 1; n <= sqrt(t); ++n) {
if (t % n == 0) {
m = t / n;
ansy = n + m - maxDis - ansx;
if (ansx <= n && ansy >= 1 && ansy <= m) {
can = pdAns(n, m);
}
if (can) {
break;
}
if (ansx <= m && ansy >= 1 && ansy <= n) {
can = pdAns(m, n);
}
if (can) {
swap(m, n);
break;
}
}
}
if (!can) {
printf("-1\n");
} else {
printf("%d %d\n%d %d", n, m, ansx, ansy);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long row, col, move, level, rem;
cin >> row >> col >> move;
if (move < row) {
cout << move + 1 << " " << 1 << endl;
return 0;
}
move -= (row - 1);
move--;
level = move / (col - 1);
rem = move % (col - 1);
cout << row - level << " ";
if (level & 1) {
cout << col - rem << endl;
} else {
cout << 2 + rem << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s[22], t[22];
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < m; i++) cin >> t[i];
int q;
cin >> q;
while (q--) {
int y;
cin >> y;
y--;
cout << s[y % n] << t[y % m] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2100000;
const long long MOD = 998244353;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) x = (x * 10) + (ch ^ 48);
return x * f;
}
inline long long qpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1LL) res = res * a % MOD;
b >>= 1, a = a * a % MOD;
}
return res;
}
int n, m, r[MAXN], d;
long long w[2][MAXN], invn;
inline void NTT_init() {
int i;
for (n = 1; n <= 2 * m; n <<= 1) d++;
for (i = 0; i < n; i++) r[i] = (r[i >> 1] >> 1) | ((i & 1) << (d - 1));
invn = qpow(n, MOD - 2);
long long G = qpow(3, (MOD - 1) >> d);
w[0][0] = w[0][n] = 1;
for (i = 1; i < n; i++) w[0][i] = w[0][i - 1] * G % MOD;
for (i = 0; i <= n; i++) w[1][i] = w[0][n - i];
}
inline void NTT(long long a[], int t) {
int i, j, k;
for (i = 0; i < n; i++)
if (i < r[i]) swap(a[i], a[r[i]]);
for (i = 2; i <= n; i <<= 1)
for (j = 0; j < n; j += i)
for (k = 0; k < (i >> 1); k++) {
long long val = a[j + k + (i >> 1)] * w[t][(n / i) * k] % MOD;
a[j + k + (i >> 1)] = (a[j + k] - val + MOD) % MOD;
a[j + k] = (a[j + k] + val) % MOD;
}
}
long long a[MAXN], b[MAXN];
vector<int> p;
int main() {
int i;
n = read(), m = read();
for (i = 1; i <= n; i++) a[read()] = 1;
memcpy(b, a, sizeof(a));
NTT_init();
NTT(b, 0);
for (i = 0; i < n; i++) b[i] = b[i] * b[i] % MOD;
NTT(b, 1);
for (i = 0; i < n; i++) b[i] = b[i] * invn % MOD;
for (i = 1; i <= m; i++) {
if (a[i] && b[i] == 0)
p.push_back(i);
else if (a[i] == 0 && b[i]) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
printf("%d\n", (int)p.size());
for (i = 0; i < (int)p.size(); i++) printf("%d ", p[i]);
printf("\n");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int cases(1), t;
template <typename T>
void binary(T n) {
stack<int> st;
while (n > 0) {
st.push(n % 2);
n /= 2;
}
while (!st.empty()) {
cout << st.top();
st.pop();
}
cout << '\n';
}
vector<long long> factorize(long long x) {
vector<long long> res;
if (x % 2 == 0) {
res.push_back(2);
}
while (x % 2 == 0) {
x /= 2;
}
for (long long i = 3; i * i <= x; i += 2) {
if (x % i == 0) {
res.push_back(i);
while (x % i == 0) {
x /= i;
}
}
}
if (x > 2) res.push_back(x);
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
for (cin >> t; cases <= t; ++cases) {
long long first, second;
cin >> first >> second;
long long ans = 0;
if (first % second) {
cout << first << '\n';
continue;
}
vector<long long> fac = factorize(second);
for (long long i = 0; i < fac.size(); i++) {
long long res = first;
while (res % second == 0) {
res /= fac[i];
}
ans = max(res, ans);
}
cout << ans << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100, M = 200200;
int i, j, k, t, n, m, q, ch, l, r, ll, rr, S = 80;
int a[N], rk[N], lg2[N], ans[N];
char s1[N], s2[N];
struct dd {
int l, r, k, x, y, q;
} Q[N];
int min(const int &x, const int &y) {
if (x < y) return x;
return y;
}
void R(int &x) {
x = 0;
ch = getchar();
while (ch < '0' || '9' < ch) ch = getchar();
while ('0' <= ch && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
}
void W(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) W(x / 10);
putchar(x % 10 + '0');
}
struct SA {
int i, j, k, n, m, nn;
int s[M], nm[M], x[M], y[M], sa[M], rk[M], ht[M], ST[M][22];
void work() {
m = 26;
for (i = 1; i <= m; i++) nm[i] = 0;
for (i = 1; i <= n; i++) x[i] = s[i], nm[s[i]]++;
for (i = 1; i <= m; i++) nm[i] += nm[i - 1];
for (i = n; i; i--) sa[nm[x[i]]--] = i;
for (k = 1; k <= n; k <<= 1) {
nn = 0;
for (i = n - k + 1; i <= n; i++) y[++nn] = i;
for (i = 1; i <= n; i++)
if (sa[i] > k) y[++nn] = sa[i] - k;
for (i = 1; i <= m; i++) nm[i] = 0;
for (i = 1; i <= n; i++) nm[x[i]]++;
for (i = 1; i <= m; i++) nm[i] += nm[i - 1];
for (i = n; i; i--) sa[nm[x[y[i]]]--] = y[i];
m = 1;
y[sa[1]] = 1;
for (i = 2; i <= n; i++) {
if (x[sa[i - 1]] == x[sa[i]] && sa[i - 1] + k <= n && sa[i] + k <= n &&
x[sa[i - 1] + k] == x[sa[i] + k])
y[sa[i]] = m;
else
y[sa[i]] = ++m;
}
if (m >= n) break;
for (i = 1; i <= n; i++) x[i] = y[i];
}
for (i = 1; i <= n; i++) rk[sa[i]] = i;
k = 0;
for (i = 1; i <= n; i++) {
if (k) k--;
if (rk[i] == 1) continue;
j = sa[rk[i] - 1];
while (i + k <= n && j + k <= n && s[i + k] == s[j + k]) k++;
ht[i] = k;
ST[rk[i]][0] = k;
}
nn = 0;
while ((1 << nn) < n) nn++;
for (j = 1; j <= nn; j++)
for (i = 1; i <= n; i++)
if (i + (1 << j) - 1 <= n)
ST[i][j] = min(ST[i][j - 1], ST[i + (1 << j - 1)][j - 1]);
}
int lcp(int a, int b) {
if (a == b) return n - a + 1;
int t;
a = rk[a];
b = rk[b];
if (a > b) {
t = a;
a = b;
b = t;
}
a++;
t = lg2[b - a + 1];
return min(ST[a][t], ST[b - (1 << t) + 1][t]);
}
} A;
struct cc {
int i, j, k, n, nn;
int a[N], ST[N][22];
void work() {
nn = 0;
while ((1 << nn) < n) nn++;
for (i = 0; i <= n; i++) ST[i][0] = a[i];
for (j = 1; j <= nn; j++)
for (i = 0; i <= n; i++)
if (i + (1 << j) - 1 <= n) {
if (rk[ST[i][j - 1]] < rk[ST[i + (1 << j - 1)][j - 1]])
ST[i][j] = ST[i][j - 1];
else
ST[i][j] = ST[i + (1 << j - 1)][j - 1];
}
}
int get_min(int l, int r) {
int t = lg2[r - l + 1];
if (rk[ST[l][t]] < rk[ST[r - (1 << t) + 1][t]]) return ST[l][t];
return ST[r - (1 << t) + 1][t];
}
} B;
bool cmp(const int &a, const int &b) {
int t;
if (a < b) {
if (b - a >= m) {
t = A.lcp(n + 1, a + 1);
if (t < m) return A.s[n + t + 1] < A.s[a + t + 1];
t = A.lcp(a + 1, a + m + 1);
if (t < b - a - m) return A.s[a + t + 1] < A.s[a + m + t + 1];
t = A.lcp(b - m + 1, n + 1);
if (t < m) return A.s[b - m + t + 1] < A.s[n + t + 1];
return a < b;
}
t = A.lcp(n + 1, a + 1);
if (t < b - a) return A.s[n + t + 1] < A.s[a + t + 1];
t = A.lcp(n + b - a + 1, n + 1);
if (t < m - (b - a)) return A.s[n + b - a + t + 1] < A.s[n + t + 1];
t = A.lcp(a + 1, n + m - (b - a) + 1);
if (t < b - a) return A.s[a + t + 1] < A.s[n + m - (b - a) + t + 1];
return a < b;
}
if (a - b >= m) {
t = A.lcp(b + 1, n + 1);
if (t < m) return A.s[b + t + 1] < A.s[n + t + 1];
t = A.lcp(b + m + 1, b + 1);
if (t < a - b - m) return A.s[b + m + t + 1] < A.s[b + t + 1];
t = A.lcp(n + 1, a - m + 1);
if (t < m) return A.s[n + t + 1] < A.s[a - m + t + 1];
return a < b;
}
t = A.lcp(b + 1, n + 1);
if (t < a - b) return A.s[b + t + 1] < A.s[n + t + 1];
t = A.lcp(n + 1, n + a - b + 1);
if (t < m - (a - b)) return A.s[n + t + 1] < A.s[n + a - b + t + 1];
t = A.lcp(n + m - (a - b) + 1, b + 1);
if (t < a - b) return A.s[n + m - (a - b) + t + 1] < A.s[b + t + 1];
return a < b;
}
bool cmp1(const dd &a, const dd &b) { return a.k < b.k; }
int main() {
scanf("%s%s", s1 + 1, s2 + 1);
n = strlen(s1 + 1);
m = strlen(s2 + 1);
for (i = 0; (1 << i) <= n + m; i++) lg2[1 << i] = i;
for (i = 3; i <= n + m; i++)
if (!lg2[i]) lg2[i] = lg2[i - 1];
for (i = 1; i <= n; i++) A.s[i] = s1[i] - 'a' + 1;
for (i = 1; i <= m; i++) A.s[n + i] = s2[i] - 'a' + 1;
A.n = n + m;
A.work();
for (i = 0; i <= n; i++) a[i] = i;
sort(a, a + n + 1, cmp);
for (i = 0; i <= n; i++) rk[a[i]] = i;
while (S * S > n) S--;
R(q);
for (i = 1; i <= q; i++) {
R(Q[i].l);
R(Q[i].r);
R(Q[i].k);
R(Q[i].x);
R(Q[i].y);
Q[i].q = i;
ans[i] = -1;
}
sort(Q + 1, Q + q + 1, cmp1);
l = 1;
r = 0;
for (i = 1; i <= S; i++) {
while (l <= q && Q[l].k < i) l++;
if (Q[l].k != i) continue;
r = l;
while (Q[r + 1].k == i) r++;
for (j = 0; j < i; j++) {
for (k = l; k <= r; k++)
if (Q[k].x <= j && j <= Q[k].y) break;
if (k > r) continue;
B.n = -1;
for (k = j; k <= n; k += i) B.a[++B.n] = k;
B.work();
for (k = l; k <= r; k++)
if (Q[k].x <= j && j <= Q[k].y) {
if (Q[k].l % i <= j)
ll = Q[k].l / i;
else
ll = Q[k].l / i + 1;
if (Q[k].r % i >= j)
rr = Q[k].r / i;
else
rr = Q[k].r / i - 1;
if (ll > rr) continue;
t = B.get_min(ll, rr);
if (ans[Q[k].q] == -1 || rk[t] < rk[ans[Q[k].q]]) ans[Q[k].q] = t;
}
}
}
B.n = n;
for (i = 0; i <= n; i++) B.a[i] = i;
B.work();
for (i = r + 1; i <= q; i++) {
for (j = 0; j <= n; j += Q[i].k) {
ll = j + Q[i].x;
rr = j + Q[i].y;
rr = min(rr, Q[i].r);
ll = max(ll, Q[i].l);
if (ll > rr) continue;
t = B.get_min(ll, rr);
if (ans[Q[i].q] == -1 || rk[t] < rk[ans[Q[i].q]]) ans[Q[i].q] = t;
}
}
for (i = 1; i <= q; i++) W(ans[i]), putchar(' ');
puts("");
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int tc;
int N, M, A, B, C;
int odd_sz[5005], even_sz[5005];
vector<int> odd[5005], even[5005];
vector<int> adj[5005];
int dist[5005];
int cnt[5], p = 1;
void BFS(int u) {
cnt[0] = 0, cnt[1] = 0;
queue<int> q;
q.push(u);
dist[u] = 0;
cnt[0]++;
even[p].push_back(u);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : adj[u]) {
if (dist[v] > dist[u] + 1) {
dist[v] = dist[u] + 1;
cnt[dist[v] & 1]++;
if (dist[v] & 1)
odd[p].push_back(v);
else
even[p].push_back(v);
q.push(v);
}
if ((dist[v] & 1) == (dist[u] & 1)) {
cout << "NO\n";
exit(0);
}
}
}
odd_sz[p] = cnt[1], even_sz[p] = cnt[0];
p++;
}
int memo[5005][5005];
int dp(int now, int left) {
if (now >= p) return (left == B);
if (memo[now][left] != -1) return memo[now][left];
return memo[now][left] =
dp(now + 1, left + even_sz[now]) | dp(now + 1, left + odd_sz[now]);
}
int ans[5005];
vector<int> bebas;
void trace(int now, int left) {
if (now >= p) return;
if (dp(now + 1, left + even_sz[now])) {
for (int tp : even[now]) {
ans[tp] = 2;
}
for (int tp : odd[now]) {
bebas.push_back(tp);
}
trace(now + 1, left + even_sz[now]);
} else if (dp(now + 1, left + odd_sz[now])) {
for (int tp : odd[now]) {
ans[tp] = 2;
}
for (int tp : even[now]) {
bebas.push_back(tp);
}
trace(now + 1, left + odd_sz[now]);
}
}
int main() {
memset(dist, 0x3f3f3f3f, sizeof(dist));
memset(memo, -1, sizeof(memo));
ios_base::sync_with_stdio(0);
cin >> N >> M >> A >> B >> C;
int u, v;
for (int i = 1; i <= M; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= N; i++) {
if (dist[i] == 0x3f3f3f3f) BFS(i);
}
int res = dp(1, 0);
if (res == 0) {
cout << "NO\n";
return 0;
} else {
trace(1, 0);
for (int i : bebas) {
if (A > 0) {
ans[i] = 1;
A--;
} else
ans[i] = 3;
}
}
cout << "YES\n";
for (int i = 1; i <= N; i++) {
cout << ans[i];
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int N = 305;
int n;
struct vec {
double x, y;
vec operator+(const vec &k) const { return (vec){x + k.x, y + k.y}; }
vec operator-(const vec &k) const { return (vec){x - k.x, y - k.y}; }
vec operator/(double k) const { return (vec){x / k, y / k}; }
vec operator*(double k) const { return (vec){x * k, y * k}; }
double ang() const { return atan2(y, x); }
double len() const { return sqrt(x * x + y * y); }
void out() const { ((void)0); }
} a[N], p1, p2;
double cross(const vec &k1, const vec &k2) { return k1.x * k2.y - k1.y * k2.x; }
int sgn(double x) { return x < -eps ? -1 : x > eps ? 1 : 0; }
struct line {
vec a, b;
double ang;
void init(vec s, vec t) {
a = s, b = t - s;
ang = b.ang();
}
bool operator<(const line &k) const {
int t;
return sgn(ang - k.ang) ? ang < k.ang
: (t = sgn(cross(b, k.b))) != 0 ? t > 0
: cross(k.a - a, b) < 0;
}
line move(double r) {
line res = *this;
vec tem = b;
tem = (vec){-tem.y, tem.x} / tem.len() * r;
res.a = res.a + tem;
res.b = res.b * (-1);
res.ang = res.b.ang();
return res;
}
void out() const {
((void)0);
a.out();
((void)0);
b.out();
((void)0);
((void)0);
}
} b[N * 2];
vec intersection(const line &a, const line &b) {
return a.a + a.b * cross(b.b, a.a - b.a) / cross(a.b, b.b);
}
deque<line> bk;
bool sol(deque<line> cur, vec &p) {
sort(cur.begin(), cur.end());
deque<vec> v;
deque<line> l;
for (const auto &t : cur) {
while (((int)(v).size()) && cross(v.back() - t.a, t.b) > 0)
v.pop_back(), l.pop_back();
while (((int)(v).size()) && cross(v.front() - t.a, t.b) > 0)
v.pop_front(), l.pop_front();
if (((int)(l).size()) && sgn(cross(t.b, l.back().b)) == 0) {
if (sgn(t.ang - l.back().ang) != 0) return 0;
l.pop_back();
if (((int)(v).size())) v.pop_back();
}
if (((int)(l).size())) v.push_back(intersection(l.back(), t));
l.push_back(t);
}
while (((int)(v).size()) && cross(v.back() - l.front().a, l.front().b) > 0)
v.pop_back(), l.pop_back();
if (((int)(l).size()) <= 2) return 0;
p = intersection(l.front(), l.back());
return 1;
}
bool OK(int l, int r, vec &p) {
deque<line> cur = bk;
for (int i = (l); i <= (r); ++i) cur.push_back(b[(i - 1) % n + 1 + n]);
return sol(cur, p);
}
bool chk(double mid) {
for (int i = (1); i <= (n); ++i) b[i].init(a[i], a[i % n + 1]);
for (int i = (n + 1); i <= (n + n); ++i) {
b[i] = b[i - n].move(mid);
}
bk.clear();
for (int i = (1); i <= (n); ++i) bk.push_back(b[i]);
for (int i = 1, j = 1; i <= n; ++i) {
while (j < i + n - 2 && OK(i, j, p1)) ++j;
if (OK(j, i + n - 1, p2)) return 1;
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) scanf("%lf%lf", &a[i].x, &a[i].y);
double l = 0, r = 1e6;
while (r - l > 1e-9) {
double mid = (l + r) / 2.;
if (chk(mid))
r = mid;
else
l = mid;
}
chk(r);
printf("%.20f\n", l);
printf("%.20f %.20f\n", p1.x, p1.y);
printf("%.20f %.20f\n", p2.x, p2.y);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0) return b;
if (b == 0) return a;
if (a % b == 0) return b;
return gcd(b, a % b);
}
int main() {
int a, b, n, cnt = 0;
cin >> a >> b >> n;
while (n) {
if (cnt % 2 != 0)
n = n - gcd(b, n);
else
n = n - gcd(a, n);
cnt++;
}
if (cnt % 2 != 0)
cout << 0;
else
cout << 1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
long long MOD = (long long)1000000007;
long long sm, dp[1005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &p);
for (int j = p; j < i; ++j) dp[i] = (dp[i] + dp[j] + 1) % MOD;
dp[i] = (dp[i] + 1) % MOD;
}
sm = 0;
for (int i = 1; i <= n; ++i) sm = (sm + 1 + dp[i]) % MOD;
printf("%I64d\n", sm);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const int MOD = 1e9 + 7;
const int N = 510;
int n, k;
int a[N], b[N];
vector<pair<int, char>> ans;
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
cin >> k;
for (int i = 1; i <= k; i++) cin >> b[i];
int le = 1;
int ri = 1;
for (int i = 1; i <= k; i++) {
ri = le;
long long sum = 0;
while (ri <= n && sum < b[i]) {
sum += a[ri];
ri++;
}
ri--;
if (sum != b[i]) {
cout << "NO";
return 0;
}
if (ri - le + 1 == 1) {
le = ri + 1;
continue;
}
vector<int> v;
for (int j = le; j <= ri; j++) v.push_back(a[j]);
int ind = 0;
for (int j = 0; j < (int)v.size(); j++)
if (v[ind] < v[j]) ind = j;
char dir = '?';
int pos = ind;
for (int j = 0; j < (int)v.size(); j++)
if (v[ind] == v[j]) {
if (j - 1 >= 0 && v[j - 1] < v[j]) {
dir = 'L';
pos = j;
break;
} else if (j + 1 < (int)v.size() && v[j + 1] < v[j]) {
dir = 'R';
pos = j;
break;
}
}
if (dir == '?') {
cout << "NO";
return 0;
}
if (dir == 'R') {
for (int j = 1; j <= (int)v.size() - pos - 1; j++)
ans.push_back(make_pair(i + pos, 'R'));
for (int j = pos; j >= 1; j--) ans.push_back(make_pair(i + j, 'L'));
} else {
for (int j = pos; j >= 1; j--) ans.push_back(make_pair(i + j, 'L'));
for (int j = pos + 1; j <= (int)v.size() - 1; j++)
ans.push_back(make_pair(i, 'R'));
}
le = ri + 1;
}
if ((int)ans.size() == n - k) {
cout << "YES\n";
for (int j = 0; j < (int)ans.size(); j++)
cout << ans[j].first << " " << ans[j].second << "\n";
} else
cout << "NO";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char a[120000], b[120000], w1, w2, w3, w4;
int n, m;
int main() {
cin >> n >> m;
scanf("%s", a + 1);
scanf("%s", b + 1);
w1 = a[1];
w2 = a[n];
w3 = b[1];
w4 = b[m];
if (w1 == '<' && w2 == '>' && w3 == 'v' && w4 == '^')
puts("YES");
else if (w1 == '>' && w2 == '<' && w3 == '^' && w4 == 'v')
puts("YES");
else
puts("NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int book[15][15];
struct sair {
string str[105];
int co;
int x, y;
};
int dir[8][2] = {0, 1, 1, 0, 0, -1, -1, 0, 1, 1, -1, -1, 1, -1, -1, 1};
string D[8] = {"R", "D", "L", "U", "RD", "LU", "LD", "RU"};
sair bfs(sair s) {
queue<sair> Q;
Q.push(s);
sair e;
while (!Q.empty()) {
s = Q.front();
Q.pop();
for (int i = 0; i < 8; i++) {
e = s;
e.x = s.x + dir[i][0];
e.y = s.y + dir[i][1];
if (e.x >= 0 && e.x < 8 && e.y >= 0 && e.y < 8 && book[e.x][e.y] != 1) {
e.str[e.co] = D[i];
e.co++;
Q.push(e);
if (book[e.x][e.y] == 2) {
return e;
}
book[e.x][e.y] = 1;
}
}
}
}
int main() {
string str, str1;
cin >> str;
sair s;
book[7 - (str[1] - '1')][str[0] - 'a'] = 1;
s.y = str[0] - 'a', s.x = 7 - (str[1] - '1'), s.co = 0;
cin >> str1;
book[7 - (str1[1] - '1')][str1[0] - 'a'] = 2;
if (str == str1) {
cout << 0 << endl;
return 0;
}
s = bfs(s);
cout << s.co << endl;
for (int i = 0; i < s.co; i++) {
cout << s.str[i] << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a = 0, b = 0, c = 0;
cin >> a >> b >> c;
cout << (a + b) / c << ' ';
if ((a % c) + (b % c) >= c)
cout << min(c - a % c, c - b % c) << '\n';
else
cout << 0 << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int N = 1000005, M = 5005;
int n, m, P, mx, a[N], f[M][M], A[M], fac[M], g[2][M];
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cin >> n >> m >> P;
for (int i = 1; i <= n; ++i) {
std::cin >> a[i];
mx = std::max(mx, a[i]);
}
A[0] = fac[0] = 1;
for (int i = 1; i <= mx && i <= m; ++i) {
A[i] = 1ll * A[i - 1] * (m - i + 1) % P;
fac[i] = 1ll * fac[i - 1] * i % P;
}
f[0][0] = 1;
for (int i = 1; i <= mx; ++i) {
for (int j = 1; j <= i; ++j) {
f[i][j] = (f[i - 1][j - 1] + 1ll * f[i - 1][j] * (j - 1)) % P;
}
}
int u = 0;
g[0][0] = 1;
for (int i = 1; i <= n; ++i) {
u ^= 1;
int sum = 0;
for (int j = 0; j <= m && j <= a[i - 1]; ++j) {
sum = (sum + g[u ^ 1][j]) % P;
}
for (int j = 0; j <= m && j <= a[i]; ++j) {
g[u][j] = 1ll * (sum + P - g[u ^ 1][j]) * f[a[i]][j] % P * A[j] % P;
g[u][j] =
(g[u][j] + 1ll * (A[j] + P - fac[j]) * f[a[i]][j] % P * g[u ^ 1][j]) %
P;
}
for (int j = 0; j <= m && j <= a[i - 1]; ++j) {
g[u ^ 1][j] = 0;
}
}
int ans = 0;
for (int i = 0; i <= mx && i <= m; ++i) {
ans = (ans + g[u][i]) % P;
}
std::cout << ans << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void show(const T& v) {
cerr << v << ' ';
}
template <typename T1, typename... T2>
void show(const T1& first, const T2&... rest) {
show(first);
show(rest...);
}
template <typename F, typename S>
ostream& operator<<(ostream& os, const pair<F, S>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
typename vector<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[";
typename set<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream& operator<<(ostream& os, const map<F, S>& v) {
os << "[";
typename map<F, S>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
const double eps = 1e-9;
void solve() {
long long sum = 0;
int n, k, p;
cin >> n >> k >> p;
vector<int> even, odd;
for (int i = 0; i < n; i++) {
int val;
cin >> val;
if (val & 1)
odd.push_back(val);
else
even.push_back(val);
sum += (long long)val;
}
long long temp = (even.size() + (odd.size() - k + p) / 2);
if ((sum & 1) != ((k - p) & 1) || (odd.size() < (k - p)) || temp < p) {
cout << "NO" << endl;
return;
}
int j = 0;
vector<int> ans[k];
for (int i = even.size() - 1; i >= 0 && j < p; i--, j++) {
ans[j].push_back(even[i]);
even.pop_back();
}
for (int i = odd.size() - 1; i - 1 >= 0 && j < p; i -= 2, j++) {
ans[j].push_back(odd[i]);
ans[j].push_back(odd[i - 1]);
odd.pop_back();
odd.pop_back();
}
for (int i = odd.size() - 1; i >= 0 && j < k; i--, j++) {
ans[j].push_back(odd[i]);
odd.pop_back();
}
for (int i = 0; i < even.size(); i++) ans[k - 1].push_back(even[i]);
for (int i = 0; i < odd.size(); i++) ans[k - 1].push_back(odd[i]);
cout << "YES" << endl;
for (int i = 0; i < k; i++) {
cout << ans[i].size() << " ";
for (auto& val : ans[i]) cout << val << " ";
cout << endl;
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int t = 1, cs = 0;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<int, vector<int>, greater<int> > pq;
int n;
int a[1000006], b[1000006], l[1000006], deep[1000006], cnt[1000006];
vector<int> edge[1000006];
void dfs(int ch, int fa) {
cnt[ch] = 1;
deep[ch] = deep[fa] + 1;
int u;
for (int i = 0; i < edge[ch].size(); i++) {
u = edge[ch][i];
if (u == fa) continue;
dfs(u, ch);
cnt[ch] += cnt[u];
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
cin >> a[i] >> b[i] >> l[i];
edge[a[i]].push_back(b[i]);
edge[b[i]].push_back(a[i]);
}
dfs(1, 0);
double ans = 0;
for (int i = 1; i <= n; i++) {
if (deep[a[i]] < deep[b[i]]) swap(a[i], b[i]);
ans += 6.0 * l[i] * cnt[a[i]] / (n - 1) * (n - cnt[a[i]]) / n;
}
int q;
cin >> q;
int r, w;
for (int i = 0; i < q; i++) {
int r, w;
scanf("%d%d", &r, &w);
ans -= 6.0 * l[r] * cnt[a[r]] / (n - 1) * (n - cnt[a[r]]) / n;
l[r] = w;
ans += 6.0 * l[r] * cnt[a[r]] / (n - 1) * (n - cnt[a[r]]) / n;
printf("%.10f\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T, class U>
inline void print(T first, U second) {
printsp(first);
println(second);
}
template <class T, class U, class V>
inline void print(T first, U second, V z) {
printsp(first);
printsp(second);
println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
long long l[202020], r[202020];
pair<long long, long long> p[202020];
int ans[202020], I[202020];
int main() {
int n, m;
gn(n, m);
for (int i = 1; i <= n; i++) {
gn(l[i], r[i]);
if (i > 1)
p[i - 1] = pair<long long, long long>(l[i] - r[i - 1], r[i] - l[i - 1]);
}
set<pair<long long, long long> > st;
for (int i = 1; i <= m; i++) {
long long u;
gn(u);
st.insert(pair<long long, long long>(u, i));
}
iota(I, I + n - 1, 1);
sort(I, I + n - 1, [](int u, int v) { return p[u] < p[v]; });
for (int i = n - 2; i >= 0; i--) {
if (st.empty()) return puts("No");
auto it =
st.upper_bound(pair<long long, long long>(p[I[i]].second, 0x3f3f3f3f));
if (it == st.begin()) return puts("No");
it--;
if (it->first < p[I[i]].first) return puts("No");
ans[I[i]] = it->second;
st.erase(it);
}
puts("Yes");
for (int i = 1; i <= n - 1; i++) printsp(ans[i]);
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read(void) {
register int x = 0, f = 1, ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -f;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 300005;
struct node {
long long sum;
int tag;
node *left, *right;
} seg[maxn << 1], *root = seg;
int tot_seg, a[maxn];
int Log[maxn];
void build(int l, int r, node *p = root) {
p->tag = 0;
if (l == r) {
p->sum = a[l];
return;
}
register int mid = (l + r) >> 1;
p->left = seg + ++tot_seg;
build(l, mid, p->left);
p->right = seg + ++tot_seg;
build(mid + 1, r, p->right);
p->sum = p->left->sum + p->right->sum;
}
inline void pushdown(int l, int r, node *p) {
if (p->tag) {
p->left->tag ^= p->tag;
p->right->tag ^= p->tag;
p->tag = 0;
}
}
inline void renew(int l, int r, node *p) {
if (l == r) return;
register int c = Log[r - l + 1] - 1;
if (p->tag & (1 << c)) {
swap(p->left, p->right);
p->tag ^= (1 << c);
p->tag ^= (1 << (c - 1));
}
}
void modify(int l, int r, int c, int d, node *p = root) {
renew(l, r, p);
if (l == r) {
p->sum = d;
return;
}
pushdown(l, r, p);
register int mid = (l + r) >> 1;
if (c <= mid)
modify(l, mid, c, d, p->left);
else
modify(mid + 1, r, c, d, p->right);
p->sum = p->left->sum + p->right->sum;
}
long long query(int l, int r, int ql, int qr, node *p = root) {
renew(l, r, p);
if (ql <= l && r <= qr) return p->sum;
pushdown(l, r, p);
register int mid = (l + r) >> 1;
register long long res = 0;
if (ql <= mid) res += query(l, mid, ql, qr, p->left);
if (mid < qr) res += query(mid + 1, r, ql, qr, p->right);
return res;
}
int main(void) {
int n = read(), m = read();
for (register int i = 0; i <= n; ++i) Log[1 << i] = i;
n = 1 << n;
for (register int i = 1; i <= n; ++i) a[i] = read();
build(1, n);
while (m--) {
int opt = read();
if (opt == 1) {
int x = read(), y = read();
modify(1, n, x, y);
} else if (opt == 2) {
int x = read();
if (x > 0) root->tag ^= (1 << (x - 1));
} else if (opt == 3) {
int x = read();
root->tag ^= (1 << x);
if (x > 0) root->tag ^= (1 << (x - 1));
} else if (opt == 4) {
int x = read(), y = read();
printf("%lld\n", query(1, n, x, y));
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
char a = 'z';
int k = 0;
int len = s.length();
string ans;
while (k < len - 1 || a >= 'a') {
for (int i = k; i < len; i++)
if (s[i] == a) {
ans += s[i];
k = i;
}
a--;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 2e5 + 10;
long long ans = 0;
void mergeSort(vector<long long> &v, int st, int end) {
if (st == end) {
return;
}
int mid = (st + end) / 2;
mergeSort(v, st, mid);
mergeSort(v, mid + 1, end);
vector<int> a, b;
for (int i = st; i <= mid; i++) {
a.push_back(v[i]);
}
for (int i = mid + 1; i <= end; i++) {
b.push_back(v[i]);
}
int i = 0, j = 0, curr = st;
int aa = a.size(), bb = b.size();
while (i < aa or j < bb) {
if (i < aa and j < bb and a[i] <= b[j]) {
v[curr++] = a[i++];
} else if (i < aa and j < bb and a[i] > b[j]) {
v[curr++] = b[j++];
ans += aa - i;
} else if (i < aa) {
v[curr++] = a[i++];
} else {
v[curr++] = b[j++];
}
}
}
long long countInversions(vector<long long> &v, int n) {
mergeSort(v, 0, n - 1);
return ans;
}
void test_case() {
long long n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
ans = 0;
countInversions(v, n);
set<long long> st(v.begin(), v.end());
if (st.size() < n or ans % 2 == 0) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tc = 1;
cin >> tc;
while (tc--) {
test_case();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char ara[100];
vector<int> num2;
scanf("%d", &n);
scanf("%s", ara);
int cnt = 1;
for (int i = 0, _b = (n - 1); i <= _b; i++) {
if (ara[i] == '0') {
if (ara[i + 1] != '1') num2.push_back(0);
}
if (ara[i] == '1' && ara[i] == ara[i + 1])
cnt++;
else {
if (ara[i] == '1') {
num2.push_back(cnt);
cnt = 1;
if (ara[i + 2] == '1') i++;
}
}
}
for (vector<int>::iterator it = num2.begin(); it != num2.end(); it++)
cout << *it;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> s;
int count = 0, check = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1') {
check = 1;
}
if (check == 1 && s[i] == '0') count++;
}
if (count >= 6)
cout << "yes";
else {
cout << "no";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int x[200005], y[200005];
int sgn[200005];
int par[200005];
vector<int> g[200005];
bool check(int a, int b, long long th) {
int icap = x[a] + x[b];
int jcap = y[a] + y[b];
long long z = 1LL * icap * icap + 1LL * jcap * jcap;
return (z <= th);
}
bool checkR(int a, int b, long long th) {
int icap = x[a] - x[b];
int jcap = y[a] - y[b];
long long z = 1LL * icap * icap + 1LL * jcap * jcap;
return (z <= th);
}
void dfs(int x, int p) {
sgn[x] *= sgn[p];
for (auto i : g[x]) {
if (i != p) dfs(i, x);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
for (int i = 1; i < n + 1; i++) {
cin >> x[i] >> y[i];
}
vector<int> v;
for (int i = 1; i < n + 1; i++) {
v.push_back(i);
}
for (int i = 0; i < 200005; i++) {
sgn[i] = 1;
}
int id = n;
while (v.size() > 2) {
int u[3];
u[0] = v.back();
v.pop_back();
u[1] = v.back();
v.pop_back();
u[2] = v.back();
v.pop_back();
bool flag = 0;
for (int i = 0; i < 3; i++) {
for (int j = i + 1; j < 3; j++) {
if (check(u[i], u[j], 1e12)) {
par[u[i]] = par[u[j]] = ++id;
g[id].push_back(u[i]);
g[id].push_back(u[j]);
x[id] = x[u[i]] + x[u[j]];
y[id] = y[u[i]] + y[u[j]];
v.push_back(id);
for (int k = 0; k < 3; k++) {
if (k != i && k != j) v.push_back(u[k]);
}
flag = 1;
} else if (checkR(u[i], u[j], 1e12)) {
par[u[i]] = par[u[j]] = ++id;
g[id].push_back(u[i]);
g[id].push_back(u[j]);
x[id] = x[u[i]] - x[u[j]];
y[id] = y[u[i]] - y[u[j]];
sgn[u[j]] = -1;
v.push_back(id);
for (int k = 0; k < 3; k++) {
if (k != i && k != j) v.push_back(u[k]);
}
flag = 1;
}
if (flag == 1) break;
}
if (flag) break;
}
assert(flag);
}
++id;
g[id].push_back(v[0]);
g[id].push_back(v[1]);
if (check(v[0], v[1], 2.27 * 1e12) == 0) {
sgn[v[1]] = -1;
}
dfs(id, 0);
int ansx = 0, ansy = 0;
for (int i = 1; i < n + 1; i++) {
ansx += x[i] * sgn[i];
ansy += y[i] * sgn[i];
cout << sgn[i] << " ";
}
}
| 7 |
#include <bits/stdc++.h>
bool isprime(long long n);
long long fibonacci(long long x);
long long factorial(long long x);
long long permutations(long long x, long long y);
long double combinations(long double x, long double y);
using namespace std;
void SieveOfEratosthenes(int n, bool prime[], bool primesquare[], int a[]) {
for (int i = 2; i <= n; i++) prime[i] = true;
for (int i = 0; i <= (n * n + 1); i++) primesquare[i] = false;
prime[1] = false;
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * 2; i <= n; i += p) prime[i] = false;
}
}
int j = 0;
for (int p = 2; p <= n; p++) {
if (prime[p]) {
a[j] = p;
primesquare[p * p] = true;
j++;
}
}
}
int countDivisors(int n) {
if (n == 1) return 1;
bool prime[n + 1], primesquare[n * n + 1];
int a[n];
SieveOfEratosthenes(n, prime, primesquare, a);
int ans = 1;
for (int i = 0;; i++) {
if (a[i] * a[i] * a[i] > n) break;
int cnt = 1;
while (n % a[i] == 0) {
n = n / a[i];
cnt = cnt + 1;
}
ans = ans * cnt;
}
if (prime[n])
ans = ans * 2;
else if (primesquare[n])
ans = ans * 3;
else if (n != 1)
ans = ans * 4;
return ans;
}
long long Divisors(long long x) {
long long c = 0;
for (long long i = 1; i <= x; i++) {
if (x % i == 0) {
c++;
}
}
return c;
}
long long division(long long x) {
int c = 0, i;
for (i = 1; i * i < x; i++)
if (x % i == 0) c += 2;
if (i * i == x) c++;
return c;
}
int countDivisors2(int n) {
int cnt = 0;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
cnt++;
else
cnt = cnt + 2;
}
}
return cnt;
}
unsigned long long div(unsigned long long x) {
unsigned long long counter = 0, i;
for (i = 1; i * i < x; i++) {
if (x % i == 0) {
counter += 2;
}
}
if (i * i == x) counter++;
return counter;
}
unsigned GCD(unsigned u, unsigned v) {
while (v != 0) {
unsigned r = u % v;
u = v;
v = r;
}
return u;
}
long long lcm(long long a, long long b) { return (a * b) / GCD(a, b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
vector<int> v;
int n, bitcoins, odd = 0, even = 0, answer = 0;
cin >> n >> bitcoins;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
if (arr[i] % 2)
odd++;
else
even++;
if (even == odd) v.push_back(abs(arr[i] - arr[i + 1]));
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
if (v[i] <= bitcoins) {
bitcoins -= v[i];
answer++;
} else {
break;
}
}
cout << answer;
return 0;
}
long long factorial(long long x) {
long long fact = 1;
for (long long i = 1; i <= x; i++) {
fact *= i;
}
return fact;
}
long long permutations(long long x, long long y) {
long long fact1 = 1;
for (long long i = 1; i <= max(x, y); i++) {
fact1 *= i;
}
long long fact2 = 1;
for (long long i = 1; i <= abs(x - y); i++) {
fact2 *= i;
}
return fact1 / fact2;
}
long double combinations(long double x, long double y) {
long long ans = 1;
for (long double i = 0, w = min(y, abs(x - y)); i < w; i++) {
ans *= (x - i) / (i + 1);
}
return ans;
}
long long fibonacci(long long x) {
if (x == 1) return 1;
if (x == 0) return 0;
return fibonacci(x - 1) + fibonacci(x - 2);
}
bool isprime(long long n) {
if (n == 1)
return false;
else if (n == 2)
return true;
for (long long i = 2; i < n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int large(long long int a, long long int b) { return a > b ? a : b; }
void solve() {
int n;
cin >> n;
long long int ans = 0;
vector<long long int> a(n, 0);
vector<long long int> b(n, 0);
long long int sa = INT_MAX;
long long int sb = INT_MAX;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] < sa) sa = a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
if (b[i] < sb) sb = b[i];
}
for (int i = 0; i < n; i++) {
if (b[i] > sb && a[i] > sa) {
ans += large(b[i] - sb, a[i] - sa);
} else if (b[i] > sb) {
ans += b[i] - sb;
} else if (a[i] > sa) {
ans += a[i] - sa;
}
}
cout << ans << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
int arr[n];
int one = 0;
int ind = -1;
for (int j = 0; j < n; j++) {
cin >> arr[j];
if (arr[j] % 2 == 0) {
one = 1;
ind = j + 1;
}
}
if (one == 1) {
cout << 1 << endl;
cout << ind << endl;
} else {
if (n >= 2) {
cout << 2 << endl;
cout << 1 << " " << 2 << endl;
} else {
cout << -1 << endl;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, ans = 0;
cin >> n >> x;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int mark[100000] = {0};
for (int i = 0; i < n; i++) mark[a[i]]++;
for (int i = 0; i < x; i++)
if (!mark[i]) ans++;
if (mark[x])
cout << ans + mark[x];
else
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int sum, n;
int a[N], h[N];
struct BIT {
int b[N];
void add(int x, int v) {
while (x <= sum) {
b[x] += v;
x += x & -x;
}
}
int get(int x) {
int ans = 0;
while (x) {
ans += b[x];
x -= x & -x;
}
return ans;
}
int findfre(int pos) {
int val = get(pos);
if (!val) return pos + 1;
int cur = 0;
for (int i = 19; i >= 0; i--) {
int cpos = cur + (1 << i);
if (cpos > pos) continue;
if (val > b[cpos]) {
cur = cpos;
val -= b[cpos];
}
}
return cur + 1;
}
} mbit;
vector<pair<int, int> > ret;
bool check(int use) {
ret.clear();
h[use]++;
mbit.add(use, 1);
int cur = sum;
while (cur) {
int idx = mbit.findfre(cur);
if (idx > cur) return 1;
int take = min(cur / idx, h[idx]);
cur -= take * idx;
h[idx] -= take;
ret.push_back(pair<int, int>(idx, take));
mbit.add(idx, -take);
}
for (auto i : ret) {
h[i.first] += i.second;
mbit.add(i.first, i.second);
}
h[use]--;
mbit.add(use, -1);
return 0;
}
int main() {
scanf("%d%d", &sum, &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) {
mbit.add(a[i], 1);
h[a[i]]++;
}
for (int use = 1; use <= sum; use++)
if (check(use)) {
cout << use;
return 0;
}
cout << "Greed is good";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x;
cin >> n >> x;
char c;
long long ans1 = 0;
long long ans2 = 0;
for (int i = 0; i < n; i++) {
cin >> c;
long long d;
cin >> d;
if (c == '+')
x += d;
else {
if (x < d) {
ans2++;
} else {
x -= d;
}
}
}
cout << x << " " << ans2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e15;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<vector<long long>> adj(n + 1, vector<long long>(n + 1));
for (int q = 1; q <= n; q++) {
for (int w = 1; w <= n; w++) {
cin >> adj[q][w];
}
}
vector<int> order(n);
for (int q = 0; q < n; q++) {
cin >> order[q];
}
vector<long long> ans(n);
ans[n - 1] = 0;
vector<vector<long long>> dist(n + 1, vector<long long>(n + 1, inf));
vector<int> curnodes;
curnodes.push_back(order[n - 1]);
dist[order[n - 1]][order[n - 1]] = 0;
for (int q = n - 2; q >= 0; q--) {
int v = order[q];
for (int w : curnodes) {
for (int e : curnodes) {
dist[w][v] = min(dist[w][v], dist[w][e] + adj[e][v]);
dist[v][w] = min(dist[v][w], adj[v][e] + dist[e][w]);
}
}
for (int w : curnodes) {
for (int e : curnodes) {
dist[w][e] = min(dist[w][e], dist[w][v] + dist[v][e]);
}
}
long long tot = 0;
for (int w = 1; w <= n; w++) {
for (int e = 1; e <= n; e++) {
if (dist[w][e] != inf) {
tot += dist[w][e];
}
}
}
dist[v][v] = 0;
ans[q] = tot;
curnodes.push_back(v);
}
for (int q = 0; q < n; q++) {
cout << ans[q] << " ";
}
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const int MOD = (int)1e9 + 7;
const int MAX = 205;
int n, a[MAX];
bool cmp(int x, int y) { return abs(x) < abs(y); }
int main() {
scanf("%d", &n);
int sum = 0, sn = 0;
for (size_t(i) = 0; (i) < (size_t)(2 * n - 1); (i)++) {
scanf("%d", a + i);
sum += abs(a[i]);
if (a[i] < 0) sn++;
}
sort(a, a + 2 * n - 1, cmp);
if (((sn & 1) == (n & 1)) || (sn % 2 == 0))
printf("%d\n", sum);
else
printf("%d\n", sum - 2 * abs(a[0]));
return 0;
}
| 5 |
#include <bits/stdc++.h>
int d[5] = {0};
int n, sum = 0;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
d[t]++;
sum += t;
}
if ((sum <= 2) || (sum == 5)) {
printf("-1");
return 0;
}
int move = 0;
if (d[1] >= d[2]) {
move += d[2];
d[1] -= d[2];
d[3] += d[2];
d[2] = 0;
move += d[1] / 3 * 2;
d[3] += d[1] / 3;
d[1] %= 3;
if (d[3] == 0) {
if (d[1] == 1) move += 2;
if (d[1] == 2) move += 2;
} else {
move += d[1];
d[3] -= d[1];
d[4] += d[1];
d[1] = 0;
}
} else {
move += d[1];
d[2] -= d[1];
d[3] += d[1];
d[1] = 0;
move += d[2] / 3 * 2;
d[3] += d[2] / 3 * 2;
d[2] %= 3;
if (d[2] == 1) {
if (d[4] > 0)
move++;
else
move += 2;
} else if (d[2] == 2)
move += 2;
}
printf("%d", move);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int findGreatest(int currentAmt, int amt, int value, int goal) {
int maximumAmt = (goal - currentAmt) / value;
if (maximumAmt > amt) return amt;
return maximumAmt;
}
void solve() {
int a, b, n, s;
cin >> a >> b >> n >> s;
int amtA = findGreatest(0, a, n, s);
int amtB = findGreatest(amtA * n, b, 1, s);
if (amtB + amtA * n == s)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int main() {
int q;
cin >> q;
while (q--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool T[107];
int main() {
ios_base::sync_with_stdio(0);
int n;
int a;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> a;
if (a == 1) {
T[i] = 1;
}
if (a == 2) {
T[j] = 1;
}
if (a == 3) {
T[i] = 1;
T[j] = 1;
}
}
}
int wynik = 0;
for (int i = 1; i <= n; i++) {
if (T[i] == 0) {
wynik++;
}
}
cout << wynik << "\n";
for (int i = 1; i <= n; i++) {
if (T[i] == 0) {
cout << i << " ";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N;
long long a[500000], b[500000], s[500000];
map<long long, int> last;
int pos;
long long best = -1000000000000;
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a[i];
b[i] = max(a[i], 0LL);
last[a[i]] = i;
}
partial_sum(b, b + N, s);
for (int i = 0; i < N; i++) {
if (last[a[i]] != i) {
long long b = s[last[a[i]] - 1] - s[i] + 2 * a[i];
if (b > best) {
best = b;
pos = i;
}
}
}
vector<int> cut;
for (int i = 0; i < pos; i++) cut.push_back(i + 1);
for (int i = pos + 1; i < last[a[pos]]; i++)
if (a[i] < 0) cut.push_back(i + 1);
for (int i = last[a[pos]] + 1; i < N; i++) cut.push_back(i + 1);
cout << best << " " << cut.size() << "\n";
if (cut.size() > 0) {
cout << cut[0];
for (int i = 1; i < cut.size(); i++) cout << " " << cut[i];
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
qp, qm;
int n = 0;
scanf("%d", &(n));
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d", &(a));
scanf("%d", &(b));
if (a > 0) qp.push(pair<int, int>(a, b));
if (a < 0) qm.push(pair<int, int>(-a, b));
}
int count = min(qp.size(), qm.size());
int sum = 0;
for (int i = 0; i < count; i++) {
sum += qp.top().second;
qp.pop();
sum += qm.top().second;
qm.pop();
}
int p = (qp.size() > 0 ? qp.top().second : 0);
int m = (qm.size() > 0 ? qm.top().second : 0);
sum += max(p, m);
printf("%d", (sum));
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, hav[(1 << 20)], x[(1 << 20)];
int q[(1 << 20)];
int xx[(1 << 20)], yy[(1 << 20)], tp;
int main() {
n = read();
for (int i = 0; i <= n - 1; i++) {
hav[i] = read();
x[i] = read();
}
tp = 0;
int h = 0, t = -1;
for (int i = 0; i <= n - 1; i++)
if (hav[i] == 1) q[++t] = i;
while (h <= t) {
int u = q[h++];
if (hav[u] == 0) continue;
x[x[u]] ^= u;
hav[x[u]]--;
tp++;
xx[tp] = u;
yy[tp] = x[u];
if (hav[x[u]] == 1) q[++t] = x[u];
}
cout << tp << endl;
for (int i = 1; i <= tp; i++) printf("%d %d\n", xx[i], yy[i]);
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
vector<int> solve(vector<int>& nums) {
int N = 201000;
vector<int> cnts(N + 1, 0);
for (auto num : nums) {
++cnts[num];
}
int res = 1;
pair<int, int> ranges{nums[0], nums[0]};
for (int i = 0; i + 1 <= N; ++i) {
if (cnts[i] > 0 && cnts[i + 1] > 0) {
if (res < cnts[i] + cnts[i + 1]) {
res = cnts[i] + cnts[i + 1];
ranges = make_pair(i, i + 1);
}
}
}
for (int i = 0; i <= N; ++i) {
if (cnts[i] > 1) {
int l = i;
int cnt = cnts[i];
while (i + 1 < N && cnts[i + 1] > 1) {
cnt += cnts[i + 1];
++i;
}
int r = i;
if (l - 1 >= 0 && cnts[l - 1] > 0) {
cnt += cnts[l - 1];
--l;
}
if (r + 1 <= N && cnts[r + 1] > 0) {
cnt += cnts[r + 1];
++r;
}
if (cnt > res) {
res = cnt;
ranges = make_pair(l, r);
}
}
}
vector<int> ans;
ans.reserve(res);
int l = ranges.first, r = ranges.second;
for (int i = l; i <= r; ++i) {
ans.push_back(i);
--cnts[i];
}
for (int i = r; i >= l; --i) {
while (cnts[i]-- > 0) {
ans.push_back(i);
}
}
return ans;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
Solution sol;
int n;
cin >> n;
vector<int> nums(n);
for (int i = 0; i < n; ++i) {
cin >> nums[i];
}
auto res = sol.solve(nums);
cout << res.size() << "\n";
for (auto r : res) {
cout << r << " ";
}
cout << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 5;
int vis[maxn], mk[maxn], p[maxn], a[maxn];
int ans = 0;
double ti = 0.5;
int main() {
int n, k, m;
scanf("%d%d", &n, &k);
m = 0;
int tmp;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
k = min(n, k);
for (int i = 1; i <= k; i++) vis[i] = 1;
for (;; ti += 1) {
for (int i = 1; i <= n; i++) {
if (vis[i] == 1) p[i]++;
}
int d = round(100.0 * m / n);
for (int i = 1; i <= n; i++) {
if (vis[i] == 1 && p[i] == d && !mk[i]) {
ans++;
mk[i] = 1;
}
}
for (int i = 1; i <= n; i++) {
if (p[i] == a[i] && vis[i] == 1) {
m++;
vis[i] = -1;
for (int j = i + 1; j <= n; j++) {
if (!vis[j]) {
vis[j] = 1;
break;
}
}
}
}
if (m == n) break;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000 + 10;
int n;
int a[MAX], b[MAX], top;
int cmp(int l, int r) { return a[l] < a[r]; }
int ansx[MAX * MAX], ansy[MAX * MAX], tot;
void work(int c, int d) {
a[c] -= a[d];
a[d] *= 2;
ansx[++tot] = c;
ansy[tot] = d;
}
int main() {
int i, j;
scanf("%d", &n);
int num = 0;
for ((i) = (1); (i) <= (n); ++(i)) {
scanf("%d", &a[i]);
if (a[i]) ++num;
}
if (num < 2) {
printf("-1\n");
return 0;
}
while (1) {
top = 0;
for ((j) = (1); (j) <= (n); ++(j))
if (a[j]) b[++top] = j;
if (top == 2) break;
sort(b + 1, b + 4, cmp);
int& A = b[1];
int& B = b[2];
int& C = b[3];
while (a[A]) {
int q = a[B] / a[A];
for (; q; q /= 2)
if (q % 2 == 1)
work(B, A);
else
work(C, A);
sort(b + 1, b + 4, cmp);
}
}
cout << tot << endl;
for ((i) = (1); (i) <= (tot); ++(i))
cout << ansy[i] << " " << ansx[i] << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
double a[100005], b[100005], p, q, l, r, m1, m2;
int n;
double f(double x) {
double y = 1e130;
for (int i = 1; i <= n; i++) {
y = min(y, (1.0 - a[i] * x) / b[i]);
}
return p * x + q * y;
}
int main() {
scanf("%d%lf%lf", &n, &p, &q);
for (int i = 1; i <= n; i++) {
scanf("%lf%lf", &a[i], &b[i]);
}
l = 0.0;
r = 1e130;
for (int i = 1; i <= n; i++) {
r = min(r, 1.0 / a[i]);
}
while (r - l > 1e-16) {
m1 = l + (r - l) / 3.0;
m2 = r - (r - l) / 3.0;
if (f(m1) < f(m2)) {
l = m1;
} else {
r = m2;
}
}
printf("%.15f\n", f((l + r) / 2));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct P {
int x, y;
void read() { cin >> x >> y; }
};
const int inf = 1000000000;
int main() {
int n;
int x0 = inf;
int x1 = -inf;
int y0 = inf;
int y1 = -inf;
cin >> n;
long long sum = 0;
for (int i = 0; i < (int)(n); ++i) {
P a;
a.read();
P b;
b.read();
x0 = min(x0, min(a.x, b.x));
x1 = max(x1, max(a.x, b.x));
y0 = min(y0, min(a.y, b.y));
y1 = max(y1, max(a.y, b.y));
sum += (b.y - a.y) * (long long)(b.x - a.x);
}
if (y1 - y0 == x1 - x0 && sum == (y1 - y0) * (long long)(y1 - y0))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int maxn = 45, maxd = 1 << 7;
int n, m, maxs, dp[maxn][maxd][maxd], cnt[maxd];
inline int iread() {
int f = 1, x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar()) f = ch == '-' ? -1 : 1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return f * x;
}
bool check(int s1, int s2, int s3) {
int s = s1 | s2 | s3 | (s2 << 1) | (s2 >> 1);
return (s & maxs) == maxs;
}
int main() {
n = iread();
m = iread();
if (n < m) std::swap(n, m);
maxs = (1 << m) - 1;
for (int i = 0; i <= 42; i++)
for (int j = 0; j <= maxs; j++)
for (int k = 0; k <= maxs; k++) dp[i][j][k] = -1;
for (int i = 0; i <= maxs; i++) dp[0][0][i] = 0;
for (int i = 0; i <= maxs; i++)
for (int x = (maxs ^ i); x; x -= x & -x) ++cnt[i];
for (int i = 1; i <= n; i++)
for (int j = 0; j <= maxs; j++)
for (int k = 0; k <= maxs; k++)
if (dp[i - 1][j][k] >= 0)
for (int l = 0; l <= maxs; l++)
if (check(j, k, l))
dp[i][k][l] = std::max(dp[i][k][l], dp[i - 1][j][k] + cnt[k]);
int ans = 0;
for (int i = 0; i <= maxs; i++) ans = std::max(ans, dp[n][i][0]);
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int max, min;
while (scanf("%d%d", &n, &m) != EOF) {
if (n == 0 && m)
puts("Impossible");
else if (n == 0 && m == 0)
puts("0 0");
else if (n && m == 0)
printf("%d %d", n, n);
else {
max = n + m - 1;
if (n >= m)
min = n;
else
min = m;
printf("%d %d\n", min, max);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
struct node {
long long pos, index;
};
bool cmp(node l, node r) { return (l.pos < r.pos); }
long long n, k;
node station[1000000];
long long sum[1000000], f[1000000];
bool selected[1000000];
long long getsum(int l, int r) {
if (r <= 0)
return 0;
else if (l <= 0)
return sum[r];
else
return sum[r] - sum[l - 1];
}
int main() {
scanf("%I64d", &n);
for (int i = 0; i < n; i++) station[i].index = i;
for (int i = 0; i < n; i++) scanf("%I64d", &station[i].pos);
std::stable_sort(station, station + n, cmp);
scanf("%I64d", &k);
sum[0] = station[0].pos;
for (int i = 1; i < n; i++) sum[i] = sum[i - 1] + station[i].pos;
f[0] = 0;
for (int i = 0; i < k; i++)
f[0] = f[0] + station[i].pos * i - getsum(0, i - 1);
for (int i = 0; i < n - 1; i++)
f[i + 1] = f[i] - getsum(i + 1, i + k - 1) + station[i].pos * (k - 1) +
station[i + k].pos * (k - 1) - getsum(i + 1, i + k - 1);
long long mini = LONG_LONG_MAX, index = -1;
for (int i = 0; i < n - k + 1; i++)
if (f[i] < mini) {
mini = f[i];
index = i;
}
for (int i = index; i < index + k; i++) selected[station[i].index] = true;
for (int i = 0; i < n; i++)
if (selected[i]) printf("%d ", i + 1);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int MAXN = 1e5 + 5;
const int MAXM = 5e5 + 5;
const int MAXL = 16;
struct Node {
int mx, ps;
Node(int mx = 0, int ps = -1) : mx(mx), ps(ps) {}
inline Node operator+(const Node &t) const {
return mx >= t.mx ? (*this) : t;
}
} sm[MAXN << 5];
int lc[MAXN << 5], rc[MAXN << 5], rt[MAXN], cnt;
inline void update(int &x, int l, int r, int p) {
if (!x) x = ++cnt;
if (l == r) {
++sm[x].mx;
sm[x].ps = l;
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
update(lc[x], l, mid, p);
else
update(rc[x], mid + 1, r, p);
sm[x] = sm[lc[x]] + sm[rc[x]];
}
inline int merge(int x, int y, int l, int r) {
if (!x || !y) return x | y;
int v = ++cnt, mid = (l + r) >> 1;
if (l == r) {
sm[v] = Node(sm[x].mx + sm[y].mx, l);
return v;
}
lc[v] = merge(lc[x], lc[y], l, mid);
rc[v] = merge(rc[x], rc[y], mid + 1, r);
sm[v] = sm[lc[v]] + sm[rc[v]];
return v;
}
inline Node query(int x, int l, int r, int L, int R) {
if (!x) return Node(-1, -1);
if (l == L && r == R) return sm[x];
int mid = (l + r) >> 1;
if (R <= mid)
return query(lc[x], l, mid, L, R);
else if (L > mid)
return query(rc[x], mid + 1, r, L, R);
else
return query(lc[x], l, mid, L, mid) + query(rc[x], mid + 1, r, mid + 1, R);
}
char s[MAXM], str[MAXN];
int n;
int ch[MAXN][26], fail[MAXN], len[MAXN], tot = 1;
inline int work(int p, int c) {
int q = ch[p][c], nq = ++tot;
for (int i = 0; i <= 25; ++i) ch[nq][i] = ch[q][i];
fail[nq] = fail[q];
len[nq] = len[p] + 1;
fail[q] = nq;
for (; p && ch[p][c] == q; p = fail[p]) ch[p][c] = nq;
return nq;
}
inline int insert(int p, int c) {
int q = ch[p][c];
if (q) {
if (len[q] == len[p] + 1) return q;
return work(p, c);
}
int np = ++tot;
len[np] = len[p] + 1;
for (; p && !ch[p][c]; p = fail[p]) ch[p][c] = np;
if (!p)
fail[np] = 1;
else {
q = ch[p][c];
if (len[q] == len[p] + 1)
fail[np] = q;
else
fail[np] = work(p, c);
}
return np;
}
int t[MAXN], sa[MAXN];
int f[MAXN][MAXL + 1];
int ps[MAXM], l[MAXM];
int main() {
scanf("%s", s + 1);
scanf("%d", &n);
for (int c = 1; c <= n; ++c) {
scanf("%s", str + 1);
int len = strlen(str + 1);
int p = 1;
for (int i = 1; i <= len; ++i) {
p = insert(p, str[i] - 'a');
update(rt[p], 1, n, c);
}
}
for (int i = 1; i <= tot; ++i) ++t[len[i]];
for (int i = 1; i <= tot; ++i) t[i] += t[i - 1];
for (int i = 1; i <= tot; ++i) sa[t[len[i]]--] = i;
for (int c = 1; c <= tot; ++c) {
int v = sa[c];
f[v][0] = fail[v];
for (int i = 1; i <= MAXL; ++i) f[v][i] = f[f[v][i - 1]][i - 1];
}
for (int i = tot; i >= 1; --i)
rt[fail[sa[i]]] = merge(rt[fail[sa[i]]], rt[sa[i]], 1, n);
int m = strlen(s + 1);
int v = 1, len = 0;
for (int i = 1; i <= m; ++i) {
int o = s[i] - 'a';
if (ch[v][o])
v = ch[v][o], ++len;
else {
while (v && !ch[v][o]) v = fail[v];
if (!v)
v = 1, len = 0;
else
len = ::len[v] + 1, v = ch[v][o];
}
ps[i] = v;
l[i] = len;
}
int q;
scanf("%d", &q);
for (int c = 1; c <= q; ++c) {
int l, r, pl, pr;
scanf("%d%d%d%d", &l, &r, &pl, &pr);
if (::l[pr] < pr - pl + 1) {
printf("%d 0\n", l);
continue;
}
int v = ps[pr];
for (int i = MAXL; i >= 0; --i) {
if (::len[f[v][i]] >= pr - pl + 1) v = f[v][i];
}
Node res = query(rt[v], 1, n, l, r);
if (res.ps == -1) res = Node(0, l);
printf("%d %d\n", res.ps, res.mx);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T gi() {
T f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return f * x;
}
const int INF = 0x3f3f3f3f, N = 100003, M = N << 1;
int n;
struct Node {
int l, d;
} a[N];
long long tr[N << 2], sum[N << 2];
int t[N];
long long suf[N], pre[N], ans;
inline bool cmp(Node x, Node y) { return x.l < y.l; }
inline int ls(int p) { return p << 1; }
inline int rs(int p) { return p << 1 | 1; }
inline void pushup(int p) {
tr[p] = tr[ls(p)] + tr[rs(p)], sum[p] = sum[ls(p)] + sum[rs(p)];
}
void modify(int x, int l, int r, int p) {
if (l == r) {
++tr[p];
sum[p] += x;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
modify(x, l, mid, ls(p));
else
modify(x, mid + 1, r, rs(p));
pushup(p);
}
long long getans(int x, int k, int l, int r, int p) {
if (k >= tr[p]) return sum[p];
if (l == r) return (long long)l * min(1ll * k, tr[p]);
int mid = (l + r) >> 1;
if (k >= tr[rs(p)])
return sum[rs(p)] + getans(x, k - tr[rs(p)], l, mid, ls(p));
else
return getans(x, k, mid + 1, r, rs(p));
}
int main() {
n = gi<int>();
for (int i = 1; i <= n; i += 1) a[i].l = gi<int>(), ++t[a[i].l];
for (int i = 1; i <= n; i += 1) a[i].d = gi<int>();
sort(a + 1, a + 1 + n, cmp);
for (int i = n; i >= 1; i -= 1) suf[i] = suf[i + 1] + a[i].d;
for (int i = 1; i <= n; i += 1) pre[i] = pre[i - 1] + a[i].d;
ans = suf[1];
for (int i = 1; i <= n; i += 1) {
if (a[i].l == a[i - 1].l) continue;
int now = a[i].l, x = t[now];
int tmp = x - 1;
ans = min(ans, suf[i + x] + pre[i - 1] - getans(100000, tmp, 1, 100000, 1));
for (int j = i; j <= i + x - 1; j += 1) modify(a[j].d, 1, 100000, 1);
i = i + x - 1;
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const double PI = acos(-1.0);
using namespace std;
const int MAXN = 200117;
int n, m, p[MAXN], dp[MAXN], ps1[MAXN], ps2[MAXN], prv[MAXN];
char s[MAXN], t[MAXN];
int main() {
scanf("%s", t);
scanf("%s", s);
n = strlen(s);
m = strlen(t);
s[n] = '$';
memcpy(s + n + 1, t, m * sizeof(char));
m += n + 1;
p[0] = 0;
prv[0] = -1;
for (int i = 1; i < m; i++) {
for (p[i] = p[i - 1]; p[i] > 0 && s[i] != s[p[i]]; p[i] = p[p[i] - 1])
;
if (s[i] == s[p[i]]) p[i]++;
prv[i] = (p[i] == n ? i : prv[i - 1]);
}
dp[n] = 1;
ps1[n] = 1;
ps2[n] = 1;
for (int i = n + 1; i < m; i++) {
if (prv[i] == -1)
dp[i] = 0;
else
dp[i] = ps2[prv[i] - n];
ps1[i] = (ps1[i - 1] + dp[i]) % (1000000007);
ps2[i] = (ps2[i - 1] + ps1[i]) % (1000000007);
}
int ans = 0;
for (int i = n + 1; i < m; i++) ans = (ans + dp[i]) % (1000000007);
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int offset = 200010;
int N;
pair<int, int> P[100010];
vector<pair<int, int> > Q, R;
vector<int> upd[400010];
set<pair<int, int> > st1, st2;
long long ans;
void solve(int t, vector<pair<int, int> > &P) {
int n = P.size();
for (int i = 0; i < 400010; i++) upd[i].clear();
for (int i = 0; i < n; i++) {
upd[P[i].first + P[i].second + offset].push_back(i);
}
st1.clear();
st2.clear();
for (int i = 0; i < n; i++) {
st1.insert(pair<int, int>(P[i].first - P[i].second, i));
}
for (int i = 0; i < 400010; i++) {
for (int j = 0; j < upd[i].size(); j++) {
int idx = upd[i][j];
st1.erase(st1.find(pair<int, int>(P[idx].first - P[idx].second, idx)));
st2.insert(pair<int, int>(P[idx].first - P[idx].second, idx));
}
if (i % 2 == t && st1.size() > 1 && st2.size() > 1) {
int mn = max(st1.begin()->first, st2.begin()->first);
int mx = min(st1.rbegin()->first, st2.rbegin()->first);
if (mn < mx) ans += (mx - mn) / 2;
}
}
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d %d", &P[i].first, &P[i].second);
}
for (int i = 0; i < N; i++) {
if ((P[i].first + P[i].second) % 2)
Q.push_back(P[i]);
else
R.push_back(P[i]);
}
solve(0, Q);
solve(1, R);
printf("%lld", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, dg[401], dp[401][401][401], sq[401], zs = 0;
pair<int, int> ed[401];
vector<int> al[401], cd[401];
bitset<401> vtd, spc;
pair<int, int> mne = {1e9, -1};
void rtd(int x) {
int i, sz = al[x].size(), l;
vtd[x] = 1;
for (i = 0; i < sz; i++) {
l = al[x][i];
if (!vtd[l]) {
cd[x].push_back(l);
dg[x]++;
rtd(l);
}
}
}
void dfs(int x) {
int i, j, r, l;
for (i = 2; i <= m; i++) {
dp[x][0][i] = 1e9;
}
dp[x][0][1] = 0;
for (i = 0; i < dg[x]; i++) {
l = cd[x][i];
dfs(l);
for (j = 1; j <= m; j++) {
dp[x][i + 1][j] = 1e9;
for (r = 1; r <= j; r++) {
dp[x][i + 1][j] =
min(dp[x][i + 1][j], dp[x][i][r] + dp[l][dg[l]][j - r]);
}
}
}
dp[x][dg[x]][0] = 1;
mne = min(mne, {dp[x][dg[x]][m] + (x != 1), x});
}
void bt(int x, int w) {
int i, j, l;
spc[x] = 1;
for (i = dg[x] - 1; i + 1; i--) {
l = cd[x][i];
for (j = 1; j <= w; j++) {
if (dp[x][i + 1][w] == dp[x][i][j] + dp[l][dg[l]][w - j]) {
break;
}
}
if (w - j) {
bt(l, w - j);
}
w = j;
}
}
int main() {
int i, k, l;
scanf("%d%d", &n, &m);
for (i = 1; i <= n - 1; i++) {
scanf("%d%d", &k, &l);
ed[i] = {k, l};
al[k].push_back(l);
al[l].push_back(k);
}
rtd(1);
dfs(1);
bt(mne.second, m);
for (i = 1; i <= n - 1; i++) {
k = ed[i].first;
l = ed[i].second;
if (spc[k] ^ spc[l]) {
zs++;
sq[zs] = i;
}
}
printf("%d\n", zs);
for (i = 1; i <= zs; i++) {
printf("%d%c", sq[i], " \n"[i == zs]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
inline int tc() {
int c = fetch();
while (c <= 32 && c != EOF) c = fetch();
return c;
}
} // namespace ae86
using ae86::tc;
using ae86::ty;
const int _ = 100007;
int n, m, val[_] = {0};
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
n = ty(), m = ty();
for (int i = 1; i <= n; i++) val[i] = tc();
long long ans = n * (m - 1);
for (int i = 2, now = 0; i <= n; i++) {
if (val[i] == val[i - 2])
now++;
else
now = 0;
if (val[i] != val[i - 1]) ans += n * (m - 1) - now - 1;
}
cout << ans << lf;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
pair<int, int> msg[n + 1];
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> msg[i].first;
msg[i].second = i + 1;
sum += msg[i].first;
}
sort(msg + 1, msg + n);
msg[n] = msg[0];
if (sum >= n - 1 && msg[n].first) {
int num = n - 1;
cout << n - 1 << endl;
for (int i = n; i > 0 && num; i--) {
for (; msg[i].first > 0 && num; msg[i].first--)
cout << msg[i].second << " " << msg[num--].second << endl;
}
} else {
cout << -1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7;
using namespace std;
void solve() {
long long p, q, Ans = 1;
cin >> p >> q;
if (p % q) {
cout << p << "\n";
;
return;
}
long long x = p;
while (x % q == 0) x /= q;
Ans = x;
for (long long i = 2; i * i <= q; i++) {
if (q % i) continue;
long long x = p, j = q / i;
while (x % q == 0) x /= i;
Ans = max(Ans, x);
x = p;
while (x % q == 0) x /= j;
Ans = max(Ans, x);
}
cout << Ans << "\n";
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using namespace std;
const int MAXN = 200001;
string s, t;
int c[26];
int n;
void shift(int x) {
cout << x << " ";
string lst = s.substr(n - x);
s = string(lst.rbegin(), lst.rend()) + s.substr(0, n - x);
}
int main() {
ios_base::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(20);
cout.tie(nullptr);
cin.tie(nullptr);
cin >> n;
cin >> s >> t;
for (char ch : s) {
++c[ch - 'a'];
}
for (char ch : t) {
if (--c[ch - 'a'] < 0) {
cout << -1 << "\n";
return 0;
}
}
cout << 3 * n << "\n";
for (int i = n - 1; i >= 0; --i) {
int p = n - 1;
while (s[p] != t[i]) {
--p;
}
shift(n);
shift(p);
shift(1);
}
assert(s == t);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int B[1000 * 1001];
const int base = 1000 * 1000 + 3;
int main() {
int n, m;
int r = 1;
bool ok = true;
cin >> n >> m;
string A[n];
for (int i = 0; i < n; i++) cin >> A[i];
for (int i = 0; i < n; i++) {
bool empty = true;
for (int j = 0; j < m; j++) empty &= A[i][j] == '.';
if (empty) {
r = (r * 2) % base;
continue;
}
B[0] = 0;
B[m + 1] = 0;
for (int j = 0; j < m; j++) {
if (A[i][j] == '.') B[j + 1] = 0;
if (A[i][j] == '1' || A[i][j] == '2') B[j + 1] = 1;
if (A[i][j] == '3' || A[i][j] == '4') B[j + 1] = -1;
}
for (int j = 1; j < m; j++)
if (B[j] == -1 && B[j + 1] == 1) B[j] = B[j + 1] = 2;
for (int j = 1; j <= m; j++)
if (B[j] == 1 && B[j - 1] == 0) B[j] = B[j - 1] = 2;
for (int j = 1; j <= m; j++)
if (B[j] == -1 && B[j + 1] == 0) B[j] = B[j + 1] = 2;
int c = -1000 * 1000;
B[m + 1] = 2;
for (int j = 1; j <= m; j++) {
if (B[j] != 0 && B[j] != 2) ok = false;
if (B[j] == 0) c++;
if (B[j] == 2) {
if (c > 0 && c % 2) ok = false;
c = 0;
}
}
}
for (int i = 0; i < m; i++) {
bool empty = true;
for (int j = 0; j < n; j++) empty &= A[j][i] == '.';
if (empty) {
r = (r * 2) % base;
continue;
}
B[0] = 0;
B[n + 1] = 0;
for (int j = 0; j < n; j++) {
if (A[j][i] == '.') B[j + 1] = 0;
if (A[j][i] == '1' || A[j][i] == '4') B[j + 1] = 1;
if (A[j][i] == '3' || A[j][i] == '2') B[j + 1] = -1;
}
for (int j = 1; j < n; j++)
if (B[j] == -1 && B[j + 1] == 1) B[j] = B[j + 1] = 2;
for (int j = 1; j <= n; j++)
if (B[j] == 1 && B[j - 1] == 0) B[j] = B[j - 1] = 2;
for (int j = 1; j <= n; j++)
if (B[j] == -1 && B[j + 1] == 0) B[j] = B[j + 1] = 2;
int c = -1000 * 1000;
B[n + 1] = 2;
for (int j = 1; j <= n; j++) {
if (B[j] != 0 && B[j] != 2) ok = false;
if (B[j] == 0) c++;
if (B[j] == 2) {
if (c > 0 && c % 2) ok = false;
c = 0;
}
}
}
cout << (ok ? r : 0) << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, dist, totalFuel;
vector<long long> canTravel;
vector<long long> canCarry;
pair<long long, long long> ans;
int main() {
cin >> n >> dist >> totalFuel;
long long carry = 0;
for (long long i = 0; i < n; i++) {
long long c, f, l;
cin >> c >> f >> l;
carry += c;
if (l >= dist) {
canTravel.push_back(f);
if (c > 0) canCarry.push_back(f);
}
}
sort(canTravel.begin(), canTravel.end());
sort(canCarry.begin(), canCarry.end());
ans = make_pair(0, 0);
long long fuel = 0;
pair<long long, long long> t;
if (canCarry.size() && canCarry[0] <= totalFuel) {
long long k = canCarry[0];
fuel += k;
for (long long i = 0; i < canTravel.size(); i++) {
if (canTravel[i] == k) {
canTravel.erase(canTravel.begin() + i);
break;
}
}
carry++;
t = make_pair(min(carry, n), -fuel);
ans = max(ans, t);
for (long long i = 0; i < canTravel.size(); i++) {
fuel += canTravel[i];
if (fuel > totalFuel) break;
carry++;
t = make_pair(min(carry, n), -fuel);
ans = max(ans, t);
}
}
carry = 0, fuel = 0;
for (long long i = 0; i < canTravel.size(); i++) {
fuel += canTravel[i];
if (fuel > totalFuel) break;
carry++;
t = make_pair(min(carry, n), -fuel);
ans = max(ans, t);
}
cout << ans.first << " " << -ans.second << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1000005], A = 1, m;
bool in[5005][1 << 13], s[1 << 13];
vector<int> g[5005];
int main() {
scanf("%d", &n);
s[0] = 1;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), m = max(a[i], m);
for (int i = 0; i <= m; i++) g[i].push_back(0), in[i][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = (int)g[a[i]].size() - 1; ~j; j--) {
int v = a[i] ^ g[a[i]][j];
if (!s[v]) s[v] = 1, A++;
for (int k = a[i] + 1; k <= m; k++) {
if (in[k][v]) break;
in[k][v] = 1;
g[k].push_back(v);
}
g[a[i]].pop_back();
}
}
printf("%d\n", A);
for (int i = 0; i < (1 << 13); i++)
if (s[i]) printf("%d ", i);
puts("");
return 0;
}
| 8 |
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
int gcd(int a,int b)
{
return b?gcd(b,a%b):a;
}
int main()
{
int t,k,g,c;
cin>>t;
while(t--)
{
c=100;
cin>>k;
g=gcd(c,k);
c/=g;
k/=g;
cout<<c<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
long long T;
cin >> T;
while (T--) {
long long n, sum = 1;
cin >> n;
for (int i = 1; i < 2 * n; i++) {
sum = (sum * i) % mod;
}
cout << (sum * n) % mod << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
double p[maxn][maxn];
int n;
double dp[1 << 18][maxn];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%lf", &p[i][j]);
}
}
dp[1][0] = 1.0;
for (int i = 2; i <= (1 << n) - 1; i++) {
for (int j = 0; j < n; j++) {
int x = 1 << j;
if (i & (1 << j) == 0) continue;
for (int k = 0; k < n; k++) {
int y = (1 << k);
if (i & (1 << k) == 0) continue;
double tmp = p[j][k] * dp[i ^ y][j] + p[k][j] * dp[i ^ x][k];
dp[i][j] = max(dp[i][j], tmp);
}
}
}
double res = 0;
for (int i = 0; i < n; i++) {
res = max(res, dp[(1 << n) - 1][i]);
}
printf("%.10f\n", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long x, n, m;
cin >> x >> n >> m;
while (x > 20 && n > 0) {
x = x / 2 + 10;
n--;
}
if (x - m * 10 <= 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int INF = 0x3f3f3f3f;
const int N = 105;
int dp[N][N][26];
vector<pair<int, int> > G[N];
int DP(int x, int y, int ch) {
if (dp[x][y][ch] != -1) return dp[x][y][ch];
int &ans = dp[x][y][ch];
ans = 0;
for (int k = 0; k < (int((G[x]).size())); k++) {
if (G[x][k].second < ch) continue;
bool flag = 0;
for (int i = 0; i < (int((G[y]).size())) && !flag; i++) {
if (G[y][i].second < G[x][k].second) continue;
int vy = G[y][i].first;
int vx = G[x][k].first;
if (DP(vx, vy, G[y][i].second) == 0) flag = true;
}
if (flag == 0) {
dp[x][y][ch] = 1;
break;
}
}
return ans;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
char ch;
scanf("%d %d %c", &u, &v, &ch);
G[u].push_back(pair<int, int>(v, ch - 'a'));
}
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++, puts(""))
for (int j = 1; j <= n; j++)
if (DP(i, j, 0))
putchar('A');
else
putchar('B');
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x;
cin >> x;
if (x % 2 == 0)
cout << x / 2 << endl;
else {
long long c = (x + 1) / 2;
cout << "-" << c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g, who;
int d[100005], mn[100005], mx[100005];
int used[100005], finish[100005];
vector<vector<int> > in;
int deg[100005];
pair<int, int> go(int v) {
if (used[v] == 2) return make_pair(mn[v], mx[v]);
if (used[v] == 1) {
if (finish[v])
return make_pair(-2, -2);
else
return make_pair(-1, -1);
}
used[v] = 1;
mx[v] = 0;
for (int i = 0; i < who[v].size(); ++i) {
int t = who[v][i];
int minv = d[t], maxv = d[t];
bool ok = true;
for (int j = 0; j < g[t].size(); ++j) {
pair<int, int> p = go(g[t][j]);
if (!finish[g[t][j]]) {
ok = false;
break;
}
if (maxv != -2) {
if (p.second == -2)
maxv = -2;
else if (p.second == -3)
maxv = -3;
else {
maxv += p.second;
maxv = min(maxv, 314000000);
}
}
}
if (!ok) continue;
if (maxv == -2)
mx[v] = -2;
else if (maxv == -3) {
if (mx[v] != -2) mx[v] = -3;
} else {
if (mx[v] != -2 && mx[v] != -3) mx[v] = max(mx[v], maxv);
}
}
used[v] = 2;
return make_pair(mn[v], mx[v]);
}
int type[100005], addm[100005];
struct cmp {
bool operator()(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
return a.first.first > b.first.first ||
a.first.first == b.first.first && a.first.second > b.first.second;
}
};
priority_queue<pair<pair<int, int>, int>, vector<pair<pair<int, int>, int> >,
cmp>
q;
int main() {
int m, n;
scanf("%d%d", &m, &n);
g.resize(m);
who.resize(n);
in.resize(n);
for (int i = 0; i < m; ++i) {
int t, l, a;
scanf("%d%d", &t, &l);
--t;
who[t].push_back(i);
type[i] = t;
for (int j = 0; j < l; ++j) {
scanf("%d", &a);
if (a == -1)
d[i]++;
else {
g[i].push_back(a - 1);
in[a - 1].push_back(i);
deg[i]++;
}
}
}
for (int i = 0; i < n; ++i) mn[i] = -2;
memcpy(addm, d, sizeof(addm));
for (int i = 0; i < m; ++i) q.push(make_pair(make_pair(deg[i], addm[i]), i));
while (q.size()) {
pair<pair<int, int>, int> p = q.top();
q.pop();
if (make_pair(deg[p.second], addm[p.second]) != p.first) continue;
if (p.first.first == 0 && !finish[type[p.second]]) {
finish[type[p.second]] = true;
if (addm[p.second] != -2) mn[type[p.second]] = addm[p.second];
for (int j = 0; j < in[type[p.second]].size(); ++j) {
deg[in[type[p.second]][j]]--;
if (mn[type[p.second]] == -2)
addm[in[type[p.second]][j]] = -2;
else if (addm[in[type[p.second]][j]] != -2)
addm[in[type[p.second]][j]] =
min(314000000, addm[in[type[p.second]][j]] + mn[type[p.second]]);
q.push(make_pair(
make_pair(deg[in[type[p.second]][j]], addm[in[type[p.second]][j]]),
in[type[p.second]][j]));
}
}
}
for (int i = 0; i < n; ++i)
if (!used[i]) go(i);
for (int i = 0; i < n; ++i)
printf("%d %d\n", finish[i] ? mn[i] : -1, finish[i] ? mx[i] : -1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
int n, t;
double p;
bool check[2020][2020];
double dp[2020][2020];
double solve(int idx, int time) {
if (idx == 0 || time == 0) return 0.;
if (check[idx][time]) return dp[idx][time];
double part1 = p * (1 + solve(idx - 1, time - 1));
double part2 = (1 - p) * (solve(idx, time - 1));
dp[idx][time] = part1 + part2;
check[idx][time] = true;
return dp[idx][time];
}
int main() {
scanf("%d %lf %d", &n, &p, &t);
for (int i = 0; i < 2020; i++) {
for (int j = 0; j < 2020; j++) {
check[i][j] = false;
}
}
double result = solve(n, t);
printf("%lf", result);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
struct Edge {
int go, next;
} e[80010];
int head[8010], tot, col[8010];
long long pw[4010];
void add(int x, int y) {
e[++tot].go = y;
e[tot].next = head[x];
head[x] = tot;
}
void da(int x, int y) {
add(x, y);
add(y, x);
}
void init() {
memset(head, 0, sizeof(head));
memset(col, 0, sizeof(col));
tot = 0;
}
char a[1010];
bool dfs(int x, int t) {
col[x] = t;
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].go;
if (col[v] == 0) {
bool f = dfs(v, -t);
if (!f) return false;
} else if (col[v] == t)
return false;
}
return true;
}
int one = 8001;
int main() {
scanf("%s", a + 1);
int n = strlen(a + 1);
pw[0] = 1;
for (int i = 1; i <= 4000; i++) pw[i] = pw[i - 1] * 2 % mod;
long long ans = 0;
for (int i = 1; i < n; i++) {
init();
int cnt = n + i;
for (int j = 1; j <= n; j++) {
da(j, ++cnt);
da(cnt, n + 1 - j);
if (j <= i) {
da(n + j, ++cnt);
da(cnt, n + (i + 1 - j));
if (a[n + 1 - j] == '0') {
da(j, ++cnt);
da(cnt, n + j);
}
if (a[n + 1 - j] == '1') {
da(j, n + j);
}
} else {
if (a[n + 1 - j] == '0') da(j, one);
if (a[n + 1 - j] == '1') da(j, 0);
}
}
da(n + 1, 0);
da(0, one);
int c = 0;
bool fl = 1;
fl &= dfs(one, 1);
for (int j = 1; j <= n + i; j++) {
if (col[j]) continue;
fl &= dfs(j, 1);
if (!fl) break;
c++;
}
if (fl) ans = (ans + pw[c]) % mod;
}
printf("%lld", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char str[1005][1005];
int main(int argc, char const* argv[]) {
int s1 = 0, s2 = 0;
for (int i = 0; gets(str[i]); i++) {
for (int j = 0; str[i][j]; j++) {
if (!isalpha(str[i][j])) continue;
bool up = isupper(str[i][j]);
char ch = tolower(str[i][j]);
int k = 0;
if (ch == 'q') k = 9;
if (ch == 'r') k = 5;
if (ch == 'b') k = 3;
if (ch == 'n') k = 3;
if (ch == 'p') k = 1;
if (up)
s1 += k;
else
s2 += k;
}
}
if (s1 == s2)
printf("Draw\n");
else if (s1 > s2)
printf("White\n");
else
printf("Black\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
;
long long t1, t2, x1, x2, t0;
cin >> t1 >> t2 >> x1 >> x2 >> t0;
long long y1 = x1;
long double ans = 1e8;
long long y11 = 0, y22 = 0;
if (t1 == t0 && t2 == t0) {
cout << x1 << " " << x2 << '\n';
return 0;
} else if (t1 == t0) {
cout << x1 << " " << 0 << '\n';
return 0;
} else if (t2 == t0) {
cout << 0 << " " << x2 << '\n';
return 0;
}
while (y1 > 0) {
long long y2 = ceil(((t1 - t0) * y1) / ((t0 - t2) * 1.0));
if (y2 > x2) {
y1--;
continue;
}
long double val = (t1 * y1 + t2 * y2) / ((y1 + y2) * 1.0);
if (abs(val - ans) <= 1e-6) {
ans = val;
if (y1 + y2 > y11 + y22) {
y11 = y1;
y22 = y2;
}
} else if (val - t0 < ans - t0) {
ans = val;
y11 = y1;
y22 = y2;
}
y1--;
}
if (y11 == 0 && y22 == 0)
cout << 0 << " " << x2 << '\n';
else
cout << y11 << " " << y22 << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int D[8][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1},
{1, -1}, {-1, 1}, {-1, -1}, {1, 1}};
int N, M, K, f[600005], F[3005][6005];
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
bool can(int& x, int& y) {
if (!y) y = 2 * M;
if (y > 2 * M) y = 1;
return 1 <= x && x <= N && F[x][y];
}
bool check(int x, int y) {
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) {
int x1 = x + D[i][0], y1 = y + D[i][1], x2 = x + D[j][0],
y2 = y + M + D[j][1];
if (can(x1, y1) && can(x2, y2) && find(F[x1][y1]) == find(F[x2][y2]))
return 0;
}
return 1;
}
void add(int x, int y, int z) {
F[x][y] = z;
for (int i = 0; i < 8; i++) {
int xx = x + D[i][0], yy = y + D[i][1];
if (can(xx, yy)) f[find(F[xx][yy])] = find(z);
}
}
void doit() {
int ans = 0;
scanf("%d%d%d", &N, &M, &K);
if (M == 1) {
puts("0");
return;
}
for (int i = 1; i <= 2 * K; i++) f[i] = i;
for (int i = 1, x, y; i <= K; i++) {
scanf("%d%d", &x, &y);
if (check(x, y)) add(x, y, i), add(x, y + M, i + K), ans++;
}
printf("%d\n", ans);
}
int main() {
doit();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a[200010];
long long area = 2000000000000000000ll;
void input() {
scanf("%I64d", &n);
for (long long i = 1; i <= 2 * n; i++) scanf("%I64d", a + i);
sort(a + 1, a + 2 * n + 1);
for (long long i = 2; i <= n; i++) {
area = min(area, (a[i + n - 1] - a[i]) * (a[2 * n] - a[1]));
}
area = min(area, (a[n] - a[1]) * (a[2 * n] - a[n + 1]));
printf("%I64d", area);
}
signed main() {
input();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, pair<int, int> >, int> M;
int n, m, rans,
mo[5][5][5] = {{{1, 1, 1}, {0, 1, 0}, {0, 1, 0}},
{{0, 0, 1}, {1, 1, 1}, {0, 0, 1}},
{{0, 1, 0}, {0, 1, 0}, {1, 1, 1}},
{{1, 0, 0}, {1, 1, 1}, {1, 0, 0}}};
char ab[12][12];
int dfs(int x, int y, int mask) {
if (x >= n - 1) return 0;
if (y >= m - 1) return dfs(x + 1, 1, mask >> 2);
pair<int, pair<int, int> > cur = make_pair(mask, make_pair(x, y));
if (M.find(cur) != M.end()) return M[cur];
int &ans = M[cur];
int nmask = mask;
for (int i = 0; i < 4; i++) {
nmask = mask;
bool flag = 1;
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++)
if (mo[i][j][k] && (mask & (1 << (j * m + k)))) flag = 0;
if (!flag) continue;
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++)
if (mo[i][j][k]) nmask |= 1 << (j * m + k);
ans = max(dfs(x, y + 1, nmask >> 1) + 1, ans);
}
ans = max(dfs(x, y + 1, mask >> 1), ans);
return ans;
}
void rec(int x, int y, int now, int mask) {
if (x >= n - 1) return;
if (y >= m - 1) {
rec(x + 1, 1, now, mask >> 2);
return;
}
int nmask = mask;
for (int i = 0; i < 4; i++) {
nmask = mask;
bool flag = 1;
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++)
if (mo[i][j][k] && (mask & (1 << (j * m + k)))) flag = 0;
if (!flag) continue;
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++)
if (mo[i][j][k]) nmask |= 1 << (j * m + k);
if (dfs(x, y + 1, nmask >> 1) + 1 + now == rans) {
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++)
if (mo[i][j][k]) ab[x + j][y + k] = 65 + now;
rec(x, y + 1, now + 1, nmask >> 1);
return;
}
}
rec(x, y + 1, now, mask >> 1);
}
int main() {
scanf("%d%d", &n, &m);
printf("%d\n", rans = dfs(1, 1, 0));
rec(1, 1, 0, 0);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
putchar(ab[i][j] == 0 ? '.' : ab[i][j]);
if (j == m) putchar('\n');
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, prev = 0, sum = 0, res = 0;
cin >> n >> k;
vector<int> v(n, 0);
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < k; i++) prev += v[i];
int mi = prev;
for (int i = 1; i < n - k + 1; i++) {
sum = prev - v[i - 1] + v[i + k - 1];
if (sum < mi) {
mi = sum;
res = i;
}
prev = sum;
}
cout << (res + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int MN = 200 + 5;
using namespace std;
template <typename T>
inline T& IN(T& in) {
in = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) in = in * 10 + c - '0', c = getchar();
return in *= f;
}
int n, m;
long long k;
string suf[MN], pre[MN], ans;
void input() {
IN(n), IN(k), IN(m);
pre[0] = suf[0] = "0", pre[1] = suf[1] = "1";
for (int i = 2; i <= n; ++i) {
pre[i] = pre[i - 2];
suf[i] = suf[i - 1];
if (pre[i].length() < m) pre[i] += pre[i - 1];
if (pre[i].length() > m) pre[i].resize(m);
if (suf[i].length() < m) suf[i] = suf[i - 2] + suf[i - 1];
if (suf[i].length() > m) suf[i] = suf[i].substr(suf[i].length() - m, m);
}
for (int i = 1; i <= m && k > 0; ++i) {
long long f0 = i == 1, f1 = 0, f2 = 0;
for (int j = 2; j <= n; ++j) {
f2 = f1 + f0;
string t1 = suf[j - 2] + pre[j - 1], t2 = ans + '0';
int l = max(0, (int)suf[j - 2].length() - i + 1),
r = min(t1.length() - i, suf[j - 2].length() - 1);
for (int k = l; k <= r; ++k)
if (t1.substr(k, i) == t2) f2++;
f0 = f1, f1 = f2;
if (f1 >= k) break;
}
if (f1 >= k)
ans += '0';
else
ans += '1', k -= f1;
if (suf[n].substr(suf[n].length() - i, i) == ans) k--;
}
printf("%s\n", ans.c_str());
}
int main() {
input();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool try_line(vector<vector<char> > &a) {
int b[5] = {0, 0, 0, 0, 0};
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int x = a[i][j] - '0';
if (x && b[x] && b[x] != 2 - (i % 2))
return false;
else
b[x] = 2 - (i % 2);
}
int kol[3] = {0, 0, 0};
for (int i = 1; i <= 4; i++) ++kol[b[i]];
if (kol[2] > 2 || kol[1] > 2) return false;
for (int i = 1; i <= 4; i++) {
if (!b[i]) {
if (kol[2] < 2) {
b[i] = 2;
++kol[2];
} else {
b[i] = 1;
++kol[1];
}
}
}
vector<vector<char> > ans(n + 1, vector<char>(m + 1));
for (int i = 1; i <= n; i++) {
char c1 = '0', c2 = '0';
for (int j = 1; j <= 4; j++)
if (b[j] == 2 - (i % 2)) {
if (c1 == '0')
c1 = (char)(j + '0');
else
c2 = (char)(j + '0');
}
bool ok = true;
for (int j = 1; j <= m; j++) {
if (j % 2 && a[i][j] != '0' && a[i][j] != c1) ok = false;
if (!(j % 2) && a[i][j] != '0' && a[i][j] != c2) ok = false;
}
if (ok) {
for (int j = 1; j <= m; j++) {
if (j % 2)
ans[i][j] = c1;
else
ans[i][j] = c2;
}
} else {
ok = true;
for (int j = 1; j <= m; j++) {
if (j % 2 && a[i][j] != '0' && a[i][j] != c2) ok = false;
if (!(j % 2) && a[i][j] != '0' && a[i][j] != c1) ok = false;
}
if (ok) {
for (int j = 1; j <= m; j++) {
if (j % 2)
ans[i][j] = c2;
else
ans[i][j] = c1;
}
} else
return false;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%c", ans[i][j]);
printf("\n");
}
return true;
}
bool try_col(vector<vector<char> > &a) {
int b[5] = {0, 0, 0, 0, 0};
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int x = a[i][j] - '0';
if (x && b[x] && b[x] != 2 - (j % 2))
return false;
else
b[x] = 2 - (j % 2);
}
int kol[3] = {0, 0, 0};
for (int i = 1; i <= 4; i++) ++kol[b[i]];
if (kol[2] > 2 || kol[1] > 2) return false;
for (int i = 1; i <= 4; i++) {
if (!b[i]) {
if (kol[2] < 2) {
b[i] = 2;
++kol[2];
} else {
b[i] = 1;
++kol[1];
}
}
}
vector<vector<char> > ans(n + 1, vector<char>(m + 1));
for (int j = 1; j <= m; j++) {
char c1 = '0', c2 = '0';
for (int i = 1; i <= 4; i++)
if (b[i] == 2 - (j % 2)) {
if (c1 == '0')
c1 = (char)(i + '0');
else
c2 = (char)(i + '0');
}
bool ok = true;
for (int i = 1; i <= n; i++) {
if (i % 2 && a[i][j] != '0' && a[i][j] != c1) ok = false;
if (!(i % 2) && a[i][j] != '0' && a[i][j] != c2) ok = false;
}
if (ok) {
for (int i = 1; i <= n; i++) {
if (i % 2)
ans[i][j] = c1;
else
ans[i][j] = c2;
}
} else {
ok = true;
for (int i = 1; i <= n; i++) {
if (i % 2 && a[i][j] != '0' && a[i][j] != c2) ok = false;
if (!(i % 2) && a[i][j] != '0' && a[i][j] != c1) ok = false;
}
if (ok) {
for (int i = 1; i <= n; i++) {
if (i % 2)
ans[i][j] = c2;
else
ans[i][j] = c1;
}
} else
return false;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%c", ans[i][j]);
printf("\n");
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
scanf("\n");
vector<vector<char> > a(n + 2, vector<char>(m + 2));
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= m + 1; j++) a[i][j] = '0';
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) scanf("%c", &a[i][j]);
if (i != n) scanf("\n");
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] != '0') {
if (a[i][j] == a[i - 1][j] || a[i][j] == a[i + 1][j] ||
a[i][j] == a[i][j - 1] || a[i][j] == a[i][j + 1]) {
printf("0");
return 0;
}
}
if (try_line(a)) return 0;
if (try_col(a)) return 0;
printf("0");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, even = 0, odd = 0, x;
cin >> n;
while (n--) {
cin >> x;
sum = sum + x;
if (x % 2 == 0)
even++;
else
odd++;
}
if (odd % 2 != 0)
cout << odd;
else
cout << even;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> seq;
vector<int> edge[100010];
void solve() {
bool ok, haveans = 0;
for (int i = 0; i < 500; ++i) {
ok = true;
random_shuffle(seq.begin(), seq.end());
for (int j = 0; j < m; ++j) {
int p = seq[j];
int q = seq[(j + 1) % n];
for (int k = 0; k < edge[p].size(); ++k)
if (edge[p][k] == q) ok = false;
}
if (ok) {
for (int j = 0; j < m; ++j)
printf("%d %d\n", seq[j] + 1, seq[(j + 1) % n] + 1);
haveans = 1;
break;
}
}
if (!haveans) printf("-1\n");
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
edge[i].clear();
seq.push_back(i);
}
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
edge[x].push_back(y);
edge[y].push_back(x);
}
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000000000;
string s;
int n, m, k, ans = MAX, f[505][505], d[505][505], len[505];
void calc(int x) {
vector<int> a;
a.clear();
for (int i = 0; i < m; ++i) {
if (s[i] == '1') a.push_back(i);
}
len[x] = a.size();
int l = 0, r = a.size() - 1;
for (int i = 0; i < len[x]; ++i) {
f[x][i] = MAX;
for (int j = 0; j <= i; ++j) {
f[x][i] = min(f[x][i], a[len[x] - 1 - j] - a[i - j] + 1);
}
}
}
int main() {
scanf("%d%d%d\n", &n, &m, &k);
for (int i = 1; i <= n; ++i) {
getline(cin, s);
calc(i);
}
int sum = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= k; ++j) d[i][j] = MAX;
sum += len[i];
for (int j = 0; j <= min(sum, k); ++j) {
for (int u = 0; u <= min(j, len[i]); ++u) {
d[i][j] = min(d[i][j], d[i - 1][j - u] + f[i][u]);
}
}
}
for (int i = 0; i <= k; ++i) ans = min(ans, d[n][i]);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int d1, m1;
int y2;
int mon[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool check(int d, int m, int y) {
if (m > 12) return 0;
if (y % 4 == 0) {
if (m == 2) {
if (d <= 29) return 1;
} else
return (d <= mon[m]);
}
return (d <= mon[m]);
}
bool f(int d, int m, int y) {
int q = y + 18;
if (q != y2) {
return (y2 > q);
};
if (m != m1) {
return (m1 > m);
}
return (d1 >= d);
}
int main() {
int d, m, y;
scanf("%d.%d.%d", &d1, &m1, &y2);
scanf("%d.%d.%d", &d, &m, &y);
if (check(d, m, y)) {
if (f(d, m, y)) {
cout << "YES";
return 0;
}
}
if (check(d, y, m)) {
if (f(d, y, m)) {
cout << "YES";
return 0;
}
}
if (check(m, d, y)) {
if (f(m, d, y)) {
cout << "YES";
return 0;
}
}
if (check(m, y, d)) {
if (f(m, y, d)) {
cout << "YES";
return 0;
}
}
if (check(y, m, d)) {
if (f(y, m, d)) {
cout << "YES";
return 0;
}
}
if (check(y, d, m)) {
if (f(y, d, m)) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.