solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, m;
char p;
cin >> h >> p >> m;
printf("%lf %lf", 30.0 * (h % 12) + 0.5 * m, 6.0 * m);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n];
long long sum = 0;
int count = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
}
for (int i = 1; i <= 5; ++i) {
if ((sum + i) % (n + 1) != 1) count++;
}
cout << count << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
vector<int> g[MAXN];
int val_at_v[MAXN];
int ans = 0;
pair<int, int> dfs(int v, int k, vector<int> &path) {
path.push_back(v);
int min_depth_subtr = MAXN;
int max_subtr = 0;
if (g[v].empty()) {
val_at_v[v] = 1;
min_depth_subtr = 0;
}
for (auto to : g[v]) {
auto subtr = dfs(to, k, path);
max_subtr = max(max_subtr, subtr.first);
min_depth_subtr = min(min_depth_subtr, subtr.second + 1);
}
if (min_depth_subtr < k) {
int cnt_up = min(k - min_depth_subtr, (int)path.size() - 1);
if (cnt_up) {
val_at_v[*(path.rbegin() + cnt_up)] += val_at_v[v];
val_at_v[v] = 0;
}
}
path.pop_back();
ans = max(ans, max_subtr + val_at_v[v]);
return {max_subtr + val_at_v[v], min_depth_subtr};
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; ++i) {
int p_i;
scanf("%d", &p_i);
g[p_i].push_back(i);
}
vector<int> path;
dfs(1, k, path);
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int t = 1;
while (t--) {
long long int x;
cin >> x;
long long int h, m;
cin >> h >> m;
if (h % 10 == 7 || m % 10 == 7) {
cout << "0\n";
return 0;
}
long long int cnt = 0;
while (true) {
if (h % 10 == 7 || m % 10 == 7) {
cout << cnt;
return 0;
}
if (m - x < 0) {
m = m + 60 - x;
if (h == 0)
h = 23;
else
h--;
} else {
m = m - x;
}
cnt++;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxh = 200 * 1000 + 5;
struct item {
int pos, hash;
item(int pos, int hash) : pos(pos), hash(hash) {}
};
bool operator<(item a, item b) { return a.pos < b.pos; }
int n, m, h;
set<item> S[maxh];
map<int, int> M;
int pos[maxh];
int Len[maxh];
int Base[maxh];
bool used[maxh];
long long add(int x, int hash) {
int base = Base[hash];
set<item>::iterator it = S[base].lower_bound(item(pos[hash], hash));
if (it == S[base].end()) {
it = S[base].begin();
}
int nhash = it->hash;
M[x] = nhash;
S[base].erase(it);
long long res = pos[nhash] - pos[hash];
if (res < 0) {
res += Len[base];
}
return res;
}
void del(int x) {
int base = Base[M[x]];
S[base].insert(item(pos[M[x]], M[x]));
}
int main() {
cin >> h >> m >> n;
for (int i = 0; i < h; ++i) {
if (used[i]) {
continue;
}
for (int j = i, p = 0; !used[j]; j += m, j %= h, ++p) {
S[i].insert(item(p, j));
pos[j] = p;
Base[j] = i;
used[j] = 1;
}
Len[i] = (int)S[i].size();
}
long long res = 0;
for (int i = 0; i < n; ++i) {
char op;
int id;
cin >> op >> id;
if (op == '+') {
int hash;
cin >> hash;
res += add(id, hash);
} else {
del(id);
}
}
cout << res << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string result = "";
for (int i = 1; i <= n; i++) {
if (i > 1) result += " that ";
if (i % 2 == 0) {
result += "I love";
} else {
result += "I hate";
}
if (i == n) result += " it\n";
}
cout << result;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, num = 0;
bool vis[305], iss[305][305], viss[305];
void init() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) iss[i][i] = 1;
for (int i = 1; i <= k; i++) {
scanf("%d", &x), vis[x] = 1;
}
num = n - k;
int maxx = (n - 1) * (n - 2) / 2 + num;
if (m > maxx || k == n) {
printf("-1");
return;
}
int t, tt = 1;
int calc = 0;
while (!vis[tt]) tt++;
viss[tt] = 1;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
t = i;
viss[t] = 1;
printf("%d %d\n", t, tt);
iss[t][tt] = iss[tt][t] = 1;
calc++;
}
}
for (int i = 1; i <= n; i++) {
if (viss[i]) continue;
printf("%d %d\n", i, t);
iss[i][t] = iss[t][i] = 1;
calc++;
if (calc == m) break;
}
for (int i = 1; i <= n; i++) {
if (calc == m) break;
if (i == tt) continue;
for (int j = 1; j <= n; j++) {
if (j == tt) continue;
if (iss[i][j]) continue;
printf("%d %d\n", i, j);
calc++;
iss[i][j] = iss[j][i] = 1;
if (calc == m) break;
}
}
}
int main() {
init();
return 0;
}
| 5 |
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
ll n, t[10000], dp[2][10010];
int main() {
scanf("%lld", &n);
for (ll i = 0; i < n-1; i++) scanf("%lld", &t[i]);
for (ll i = 0; i <= n; i++) dp[0][i] = INF;
dp[0][1] = 0;
for (ll i = 1; i < n; i++) {
ll now = i & 1, before = (i+1) & 1;
for (ll j = 1; j <= i; j++) dp[now][j+1] = dp[before][j];
dp[now][1] = INF;
for (ll j = 1; j <= i; j++) dp[now][j] = min(dp[now][j], dp[before][i+1-j] + t[i-1]);
//for (ll j = 1; j <= i+1; j++) printf("%lld ", dp[now][j]); printf("\n");
}
printf("%lld\n", dp[(n+1)&1][n/2]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 21;
int n;
ll a[maxn];
void read() {
int len;
cin >> len;
for (int i = 0; i < len; ++i) {
ll x;
cin >> x;
if (x != 0) {
a[n++] = x;
}
}
}
ll sum[1 << maxn];
int dp[1 << maxn];
bool can[1 << maxn];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
read();
if (n == 0) {
cout << 0 << '\n';
return 0;
}
for (int mask = 0; mask < (1 << n); ++mask) {
for (int i = 0; i < n; ++i) {
if (mask & (1 << i)) {
sum[mask] = sum[mask ^ (1 << i)] + a[i];
break;
}
}
}
for (int mask = 0; mask < (1 << n); ++mask) {
int len = __builtin_popcount(mask);
if (len <= 1) {
can[mask] = true;
continue;
}
if ((sum[mask] + len - 1) % 2 != 0) {
can[mask] = false;
continue;
}
int itermask = mask & (mask - 1);
for (int submask = itermask; submask > 0;
submask = (submask - 1) & itermask) {
if (abs(sum[submask] - sum[mask ^ submask]) < len) {
can[mask] = true;
break;
}
}
}
for (int mask = 0; mask < (1 << n); ++mask) {
if (can[mask]) {
int len = __builtin_popcount(mask);
if (len <= 1)
dp[mask] = len;
else
dp[mask] = len - 1;
} else {
dp[mask] = 100500;
}
int itermask = mask & (mask - 1);
for (int submask = itermask; submask > 0;
submask = (submask - 1) & itermask) {
dp[mask] = min(dp[mask], dp[submask] + dp[mask ^ submask]);
}
}
cout << dp[(1 << n) - 1] << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a = 0, b = 0;
long long ans = 0;
vector<vector<int> > v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
v = vector<vector<int> >(n, vector<int>(4, 0));
for (int i = 0; i < n; i++) {
string s;
cin >> s;
v[i][1] = s[0] - '0';
a += v[i][1];
v[i][2] = s[1] - '0';
b += v[i][2];
cin >> v[i][0];
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int cant = min(a, b);
int ca = 0, cb = 0;
for (int i = 0; i < n; i++) {
if (v[i][1] && v[i][2]) {
v[i][3] = 1;
ca++;
cb++;
}
}
for (int i = 0; i < n; i++) {
if (v[i][1] == 1 && ca < cant && !v[i][3]) {
v[i][3] = 1;
ca++;
}
if (v[i][2] == 1 && cb < cant && !v[i][3]) {
v[i][3] = 1;
cb++;
}
}
int temp = 0;
for (int i = 0; i < n; i++) {
if (v[i][3] == 1) {
ans += v[i][0];
temp++;
}
}
cant = (2 * cant) - temp;
temp = 0;
for (int i = 0; i < n; i++) {
if (v[i][3] == 0 && temp < cant) {
temp++;
ans += v[i][0];
}
}
cout << ans << endl;
;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
vector<int> g[N];
int main() {
int n;
scanf("%d", &n);
int mx = 0;
for (int i = 0; i < n; i++) {
int len;
scanf("%d", &len);
for (int j = 0; j < len; j++) {
int x;
scanf("%d", &x);
g[i].push_back(x);
mx = max(mx, x);
}
}
long long ans = 0LL;
for (int i = 0; i < n; i++) {
int big = 0;
for (auto x : g[i]) {
big = max(big, x);
}
int need = mx - big;
int cnt = (int)g[i].size();
ans += (1LL * need * cnt);
}
printf("%lld\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,sum=0;
cin>>N;
int L[203];
for(int i=0;i<2*N;i++){
cin>>L[i];
}
sort(L,L+2*N);
for(int i=0;i<2*N;i+=2){
sum+=L[i];
}
cout<<sum<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 65;
const int MAXS = 32768;
const int P = 1e9 + 7;
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
int n, m, bit[MAXN], a[MAXN], key[MAXN];
int f[MAXN], binom[MAXN][MAXN], dp[MAXS][MAXN];
int find(int x) {
if (f[x] == x)
return x;
else
return f[x] = find(f[x]);
}
int getcnt(int x) {
int ans = -1;
for (int i = 1; i <= n; i++)
if (f[i] == x) ans += key[i] == -1;
return max(ans, 0);
}
void update(int &x, int y) {
x += y;
if (x >= P) x -= P;
}
int getans(int x) {
int cnt = getcnt(x), m = 0;
if (cnt == 0) return 1;
cnt++;
static int ins[MAXS], type[MAXN];
for (int i = 1; i <= n; i++)
if (f[i] == x && key[i] != -1) key[i] = ++m;
for (int i = 0; i < (1 << m); i++) ins[i] = 0;
for (int i = 1; i <= n; i++)
if (f[i] == x && key[i] == -1) {
type[i] = 0;
for (int j = 1; j <= n; j++)
if (f[j] == x && key[j] != -1 && a[i] % a[j] == 0)
type[i] |= 1 << (key[j] - 1);
for (int j = 0; j < (1 << m); j++) ins[j] += (type[i] | j) == j;
}
static int dp[MAXN][MAXS];
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++)
if (f[i] == x && key[i] == -1) update(dp[1][type[i]], 1);
for (int i = 1; i <= cnt - 1; i++)
for (int j = 0; j < (1 << m); j++) {
int tmp = dp[i][j];
if (!tmp) continue;
update(dp[i + 1][j], 1ll * tmp * (ins[j] - i) % P);
for (int k = 1; k <= n; k++)
if (f[k] == x && key[k] == -1 && (type[k] & j) != 0 &&
(type[k] | j) != j)
update(dp[i + 1][j | type[k]], tmp);
}
return dp[cnt][(1 << m) - 1];
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]), f[i] = i;
for (int i = 0; i <= n; i++) {
binom[i][0] = 1;
for (int j = 1; j <= i; j++)
binom[i][j] = (binom[i - 1][j - 1] + binom[i - 1][j]) % P;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
if (key[i] == -1) continue;
bool vis = false;
for (int j = i + 1; j <= n; j++)
if (a[j] % a[i] == 0) {
vis = true;
key[j] = -1;
f[find(i)] = find(j);
}
if (vis)
key[i] = ++m;
else
key[i] = -1;
}
for (int i = 1; i <= n; i++) f[i] = find(i);
assert(m <= 15);
int ans = 1, cnt = 0;
for (int i = 1; i <= n; i++)
if (f[i] == i) {
ans = 1ll * ans * getans(i) % P * binom[cnt + getcnt(i)][cnt] % P;
cnt += getcnt(i);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int md = 1e9 + 7, inf = 1e9 + 7;
const long long hs = 199;
const long double eps = 1e-9, pi = acos(-1);
using namespace std;
int rnd() { return ((rand() % (1 << 15)) << 16) + (rand() % (1 << 15)); }
struct node {
node *l, *r;
int val, key;
int sz, tag;
node(int value) {
val = value;
key = rnd();
l = r = nullptr;
sz = 1, tag = 0;
}
void push() {
val += tag;
if (l) l->tag += tag;
if (r) r->tag += tag;
tag = 0;
}
void upd() {
sz = 1;
if (l) sz += l->sz;
if (r) sz += r->sz;
}
~node() {
delete l;
delete r;
}
};
struct treap {
node *root;
treap() {
srand(918273645);
root = new node(0);
}
int size() { return root ? root->sz : 0; }
void split(node *t, int val, node *&l, node *&r) {
if (t == nullptr) {
l = r = nullptr;
return;
}
t->push();
if (t->val < val) {
split(t->r, val, l, r);
t->r = l;
l = t;
} else {
split(t->l, val, l, r);
t->l = r;
r = t;
}
t->upd();
}
void size_split(node *t, int sz, node *&l, node *&r) {
if (t == nullptr) {
l = r = nullptr;
return;
}
t->push();
int lsz = (t->l ? t->l->sz : 0);
if (lsz < sz) {
size_split(t->r, sz - lsz - 1, l, r);
t->r = l;
l = t;
} else {
size_split(t->l, sz, l, r);
t->l = r;
r = t;
}
t->upd();
}
node *merge(node *l, node *r) {
if (!l || !r) return l ? l : r;
if (l->key < r->key) {
l->push();
l->r = merge(l->r, r);
l->upd();
return l;
}
r->push();
r->l = merge(l, r->l);
r->upd();
return r;
}
void upd(int st, int en) {
node *t[4];
split(root, st, t[0], t[1]);
split(t[1], en, t[1], t[3]);
if (t[3] != nullptr) {
size_split(t[3], 1, t[2], t[3]);
delete t[2];
}
if (t[1]) t[1]->tag++;
root = merge(merge(merge(t[0], new node(st)), t[1]), t[3]);
}
void print() {
print(root);
cout << '\n';
}
void print(node *t) {
if (t == nullptr) return;
t->push();
print(t->l);
cout << t->val << " ";
print(t->r);
}
};
int n;
treap T;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 0, l, r; i < n; i++) {
cin >> l >> r;
T.upd(l, r);
}
cout << T.size() - 1 << '\n';
}
| 4 |
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
void solve(){
ll a,b,n;
cin>>a>>b;
n = a+b;
string s;
cin>>s;
for(int i = 0; i < n; i++){
if(s[i] == '?'){
s[i] = s[n-i-1];
}
}
a -= count(s.begin(), s.end(), '0');
b -= count(s.begin(), s.end(), '1');
for(int i = 0; i <= n/2; i++){
if(i != n-i-1 && s[i] == '?'){
if(a > 1){
s[i] = '0';
s[n-i-1] = '0';
a -= 2;
}
else if(b > 1){
s[i] = '1';
s[n-i-1] = '1';
b -= 2;
}
}
else if(s[i] == '?'){
if(a){
s[i] = '0';
a--;
}
else{
s[i] = '1';
b--;
}
}
}
string v = s;
reverse(v.begin(), v.end());
if(s == v && a == 0 && b == 0){
cout<<s<<endl;
return;
}
cout<<-1<<endl;
}
int main()
{
ll t;
cin>>t;
while(t--){
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, k = 0, ans = 0, mx = 0;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'x') {
mx++;
} else {
ans += max(0, mx - 2);
mx = 0;
k = 0;
}
}
ans += max(0, mx - 2);
cout << ans;
exit(0);
}
| 2 |
#include<iostream>
int main(){
int a, b, c;
std::cin >> a >> b >> c;
std::cout << (a+b)*c/2;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[10][10];
int nn;
int num[10];
int d[10];
int row[10];
int col[10];
int dia[10];
long long tot;
int n;
bool rec(int r, int c) {
if (r == n - 1) {
long long rem = tot - col[c];
for (int i = 0; i < nn; i++) {
if (d[i] && num[i] == rem) {
if (c == 0 && dia[1] + rem != tot) return false;
if (c == n - 1) {
if (dia[0] + rem != tot)
return false;
else {
a[r][c] = rem;
return true;
}
}
d[i]--;
if (rec(r, c + 1)) {
a[r][c] = rem;
return true;
} else {
d[i]++;
return false;
}
}
}
return false;
}
if (c == n - 1) {
long long rem = tot - row[r];
for (int i = 0; i < nn; i++) {
if (d[i] && num[i] == rem) {
if (r == 0) dia[1] += num[i];
col[c] += num[i];
d[i]--;
if (rec(r + 1, 0)) {
a[r][c] = rem;
return true;
} else {
if (r == 0) dia[1] -= num[i];
col[c] -= num[i];
d[i]++;
return false;
}
}
}
return false;
}
for (int i = 0; i < nn; i++) {
if (d[i]) {
if (r == c) dia[0] += num[i];
if (r + c == n - 1) dia[1] += num[i];
row[r] += num[i];
col[c] += num[i];
d[i]--;
if (rec(r, c + 1)) {
a[r][c] = num[i];
return true;
} else {
d[i]++;
row[r] -= num[i];
col[c] -= num[i];
if (r == c) dia[0] -= num[i];
if (r + c == n - 1) dia[1] -= num[i];
}
}
}
return false;
}
int main() {
map<int, int> mp;
tot = 0;
int x;
cin >> n;
int k = n * n;
for (int i = 0; i < k; i++) {
cin >> x;
tot += x;
mp[x]++;
}
tot /= n;
nn = 0;
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); it++) {
num[nn] = it->first;
d[nn] = it->second;
nn++;
}
cout << tot << endl;
rec(0, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << a[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[10000], z, b[10000];
bool q;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
z = 0;
for (int j = 0; j < n; j++) {
b[j] = j + 1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
q = false;
if (a[i] == b[j]) {
b[j] = 5001;
q = true;
}
if (q == true) break;
}
if (q != true) {
z++;
}
}
cout << z;
}
| 2 |
#include <algorithm>
#include <iostream>
#include <cstdint>
int main() {
std::int64_t X, K, D;
std::cin >> X >> K >> D;
X = std::abs(X);
const auto n = std::min(K, X / D);
X -= n * D;
K -= n;
std::cout << std::abs(X - D * (K & 1)) << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 500005;
struct Node {
int mx;
int pa, pb;
int sa, sb;
int len;
} st1[4 * MX], st2[4 * MX];
int lz[4 * MX];
Node operator+(const Node &a, const Node &b) {
Node r = {0, 0, 0, 0, 0, a.len + b.len};
int cen = 0;
if (!a.sb && !b.pa)
cen = a.sa + b.pb;
else if (!a.sb)
cen = a.sa + b.pa + b.pb;
else if (!b.pa)
cen = a.sa + a.sb + b.pb;
r.mx = max({a.mx, b.mx, cen});
r.pa = a.pa;
r.pb = a.pb;
if (a.pa + a.pb == a.len) {
if (!b.pa)
r.pb += b.pb;
else if (!a.pb) {
r.pa += b.pa;
r.pb += b.pb;
}
}
r.sa = b.sa;
r.sb = b.sb;
if (b.sa + b.sb == b.len) {
if (!a.sb)
r.sa += a.sa;
else if (!b.sa) {
r.sa += a.sa;
r.sb += a.sb;
}
}
return r;
}
void build(int i, int j, int pos, char a[]) {
if (i == j) {
if (a[i] == '>') {
st1[pos] = {1, 1, 0, 1, 0, 1};
st2[pos] = {1, 0, 1, 0, 1, 1};
} else {
st1[pos] = {1, 0, 1, 0, 1, 1};
st2[pos] = {1, 1, 0, 1, 0, 1};
}
return;
}
int m = (i + j) / 2;
build(i, m, pos * 2, a);
build(m + 1, j, pos * 2 + 1, a);
st1[pos] = st1[pos * 2] + st1[pos * 2 + 1];
st2[pos] = st2[pos * 2] + st2[pos * 2 + 1];
}
void push(int i, int j, int pos) {
if (i < j) {
lz[pos * 2] ^= lz[pos];
lz[pos * 2 + 1] ^= lz[pos];
}
swap(st1[pos], st2[pos]);
lz[pos] = 0;
}
Node update(int i, int j, int pos, int a, int b) {
if (lz[pos]) push(i, j, pos);
if (b < i || j < a) return {0, 0, 0, 0, 0, 0};
if (a <= i && j <= b) {
lz[pos] = 1;
push(i, j, pos);
return st1[pos];
}
int m = (i + j) / 2;
Node r = update(i, m, pos * 2, a, b) + update(m + 1, j, pos * 2 + 1, a, b);
st1[pos] = st1[pos * 2] + st1[pos * 2 + 1];
st2[pos] = st2[pos * 2] + st2[pos * 2 + 1];
return r;
}
int n, q;
char a[MX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, n, 1, a);
while (q--) {
int l, r;
cin >> l >> r;
cout << update(1, n, 1, l, r).mx << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int i = 0, ans = 0, n, p, k;
cin >> n >> p >> k;
vector<int> prices(n), v(n);
for (i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
int prev = 0;
for (i = 0; i < k; i++) {
int sum = prev;
if (sum > p) break;
int count = i;
for (int j = i + k - 1; j < n; j += k) {
if (sum + v[j] <= p) {
count += k;
sum += v[j];
} else
break;
}
prev += v[i];
ans = max(ans, count);
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
string st;
cin >> st;
string ans;
char last = 'd';
int ct = 0;
for (auto c : st) {
if (c == '?')
ct += 1;
else {
int idx = last - 97 + 1;
while (ct != 0) {
idx %= 3;
if (idx == c - 97) idx++;
idx %= 3;
ans += char(97 + idx);
last = char(97 + idx);
idx += 1;
ct--;
}
if (c == last) break;
ans += c;
last = c;
}
}
char c = 'c';
int idx = last - 97 + 1;
while (ct--) {
idx %= 3;
if (idx == c - 97) idx++;
idx %= 3;
ans += char(97 + idx);
last = char(97 + idx);
idx += 1;
}
if (ans.size() != st.size())
cout << -1 << endl;
else
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
struct pt {
long double a, b, c, d, e;
pt() {}
};
pt operator+(pt x, pt y) {
pt z;
z.a = x.a + y.a;
z.b = x.b + y.b;
z.c = x.c + y.c;
z.d = x.d + y.d;
z.e = x.e + y.e;
return z;
}
pt operator-(pt x, pt y) {
pt z;
z.a = x.a - y.a;
z.b = x.b - y.b;
z.c = x.c - y.c;
z.d = x.d - y.d;
z.e = x.e - y.e;
return z;
}
void imp(pt x) {
cout << x.a << " " << x.b << " " << x.c << " " << x.d << " " << x.e << endl;
}
long double operator*(pt x, pt y) {
return x.a * y.a + x.b * y.b + x.c * y.c + x.d * y.d + x.e * y.e;
}
long double val(pt x) { return sqrtl(x * x); }
pt A[1010];
vector<int> R;
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++)
cin >> A[i].a >> A[i].b >> A[i].c >> A[i].d >> A[i].e;
if (n > 100) {
printf("%d\n", 0);
continue;
}
long double pd2 = pi / (long double)2.0;
R.clear();
for (int i = 0; i < n; i++) {
pt puta = A[i];
for (int j = 0; j < n; j++) {
A[j] = (A[j] - puta);
}
bool sw = 1;
for (int j = 0; j < n; j++) {
if (j == i) continue;
for (int k = j + 1; k < n; k++) {
if (k == i) continue;
if (acosl(A[j] * A[k] / (val(A[j]) * val(A[k]))) < pd2) sw = 0;
}
}
for (int j = 0; j < n; j++) A[j] = (A[j] + puta);
if (sw) R.push_back(i);
}
printf("%d\n", (int)R.size());
for (int i = 0; i < (int)R.size(); i++) printf("%d\n", R[i] + 1);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10010;
const int inf = 0x3fffffff;
int dp[1 << 20], w[20][20], d[maxn], x[20], a[100];
inline int rightZeroBit(int mask) {
for (int i = 0;; i++) {
if ((mask & (1 << i)) == 0) return i;
}
return -1;
}
int main() {
int n, k, l;
while (scanf("%d%d%d", &n, &k, &l) == 3) {
for (int i = 0; i < k; i++) scanf("%d", &x[i]);
for (int i = 0; i < l; i++) scanf("%d", &a[i]);
sort(a, a + l);
l = unique(a, a + l) - a;
set<int> iset;
for (int i = 0; i < k; i++) {
pair<set<int>::iterator, bool> p;
p = iset.insert(x[i] - 1);
if (!p.second) iset.erase(p.first);
p = iset.insert(x[i]);
if (!p.second) iset.erase(p.first);
}
k = copy(iset.begin(), iset.end(), x) - x;
for (int i = 0; i < k; i++) {
fill(d, d + n + 1, inf);
d[x[i]] = 0;
priority_queue<pair<int, int> > pq;
pq.push(make_pair(0, x[i]));
while (!pq.empty()) {
int s = pq.top().second;
int t = -pq.top().first;
pq.pop();
if (d[s] != t) continue;
for (int j = 0; j < l; j++) {
if (s - a[j] >= 0 && d[s - a[j]] > t + 1) {
d[s - a[j]] = t + 1;
pq.push(make_pair(-d[s - a[j]], s - a[j]));
}
if (s + a[j] <= n && d[s + a[j]] > t + 1) {
d[s + a[j]] = t + 1;
pq.push(make_pair(-d[s + a[j]], s + a[j]));
}
}
}
for (int j = 0; j < k; j++) w[i][j] = d[x[j]];
}
fill(dp, dp + (1 << k), inf);
dp[0] = 0;
for (int mask = 0; mask < (1 << k); mask++) {
int u;
for (u = 0; u < k; u++)
if ((mask & (1 << u)) == 0) break;
if (u >= k) continue;
for (int v = 0; v < k; v++)
if ((mask & (1 << v)) == 0) {
int _mask = mask ^ (1 << u) ^ (1 << v);
dp[_mask] = min(dp[_mask], dp[mask] + w[u][v]);
}
}
printf("%d\n", dp[(1 << k) - 1] == inf ? -1 : dp[(1 << k) - 1]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9, MOD = 1e9 + 7;
const int n_ = 210;
long long gcd(long long a, long long b) { return (a ? gcd(b % a, a) : b); }
long long power(long long a, long long n) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long power(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
int main() {
ios_base::sync_with_stdio(false);
int n, a[n_], m, x[n_], y[n_], first, second, sum, ans = -INF;
scanf("%d %d", &n, &m);
for (int(i) = 0; (i) < (n); (i)++) scanf("%d", a + i);
for (int(e) = 0; (e) < (n); (e)++) {
for (int(b) = 0; (b) < (e + 1); (b)++) {
first = second = sum = 0;
for (int(k) = 0; (k) < (n); (k)++) {
if (b <= k && k <= e) {
x[first++] = a[k];
sum += a[k];
} else {
y[second++] = a[k];
}
}
sort(x, x + first);
sort(y, y + second, greater<int>());
for (int(k) = 0; (k) < (m); (k)++) {
if (k < min(first, second) && x[k] < y[k]) {
sum += y[k] - x[k];
}
}
ans = max(ans, sum);
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd2(long long m, long long n) {
if (m < n) {
long long tmp = m;
m = n;
n = tmp;
}
if (n == 0) return m;
while (n > 0) {
long long tmp = m % n;
m = n;
n = tmp;
}
return m;
}
int f(int k) {
if (k == 1) return 0;
if (k % 2 == 0 || k % 3 == 0) {
if (k % 2 == 0) return f(k / 2);
if (k % 3 == 0) return f(k / 3);
} else
return 1;
}
int main() {
int n, flag = 1;
long long a, b;
long long k;
scanf("%d", &n);
scanf("%I64d", &a);
for (int i = 1; i <= n - 1; i++) {
scanf("%I64d", &b);
k = a * b / gcd2(a, b);
if (!(((f(k / a) == 0) && (f(k / b) == 0)))) {
flag = 0;
}
a = b;
}
if (flag == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int main(){
int n,k[112345],sum=0;
cin>>n;
for(int i=0;i<n;i++){
cin>>k[i];
sum+=k[i];
}
if(sum%2==0) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1.0);
const int day[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int digarr[10] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
const int dxo[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dyo[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int alf = 26;
const int dig = 10;
const int two = 2;
const int th = 3;
const long long prost = 239;
const long long btc = 30;
const long double eps = 1e-8;
const long long INF = (long long)(1e18 + 239);
const int BIG = (int)(1e9 + 239);
const int MOD = 1e9 + 7;
mt19937_64 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const int M = (int)(2e5 + 239);
const int N = (int)(2e3 + 239);
const int L = 18;
const int T = (1 << 18) + 239;
const int B = 500;
const int X = 1010;
const int S = 4 * X * X;
int n, m, q, dist[X][X];
string s[X];
pair<int, int> my_q[S];
int l, r;
bool check(int i, int j) { return (0 <= i && i < n && 0 <= j && j < m); }
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) dist[i][j] = BIG;
l = (S / 2);
r = (S / 2);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
bool ch = false;
for (int d = 0; d < 4; d++) {
int ni = i + dx[d];
int nj = j + dy[d];
if (check(ni, nj) && s[i][j] == s[ni][nj]) {
ch = true;
break;
}
}
if (ch) {
my_q[r++] = make_pair(i, j);
dist[i][j] = 0;
}
}
while (l < r) {
int i = my_q[l].first;
int j = my_q[l].second;
l++;
for (int d = 0; d < 4; d++) {
int ni = i + dx[d];
int nj = j + dy[d];
if (check(ni, nj)) {
if (s[ni][nj] == s[i][j]) {
if (dist[ni][nj] > dist[i][j]) {
dist[ni][nj] = dist[i][j];
l--;
my_q[l] = make_pair(ni, nj);
}
} else {
if (dist[ni][nj] > dist[i][j] + 1) {
dist[ni][nj] = dist[i][j] + 1;
my_q[r++] = make_pair(ni, nj);
}
}
}
}
}
for (int i = 0; i < q; i++) {
int x, y;
long long t;
cin >> x >> y >> t;
x--, y--;
if (dist[x][y] == BIG)
cout << s[x][y] << "\n";
else {
if (t <= dist[x][y])
cout << s[x][y] << "\n";
else {
int ev = (t - dist[x][y]) % 2LL;
if (ev == 0)
cout << s[x][y] << "\n";
else
cout << (char)('0' + '1' - s[x][y]) << "\n";
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct segtree {
int N;
vector<int> val, sum, add, flt;
segtree(int n) {
N = 1;
while (N < n) N *= 2;
sum.assign(2 * N, 0);
add.assign(2 * N, 0);
flt.assign(2 * N, 0);
init(0, n, 0, N, 0);
}
void init(int a, int b, int l, int r, int k) {
if (b <= l or r <= a) return;
if (a <= l and r <= b) flt[k] = 1;
sum[k] = min(r, b) - max(l, a);
if (r - l == 1) return;
init(a, b, l, (l + r) / 2, 2 * k + 1);
init(a, b, (l + r) / 2, r, 2 * k + 2);
}
int addi(int a, int b, int l, int r, int k, int x) {
if (b <= l or r <= a) return 0;
if (a <= l and r <= b) {
add[k] += x;
sum[k] += x * (r - l);
return x * (r - l);
}
flt[k] = 0;
int m = (l + r) / 2;
int s = addi(a, b, l, m, 2 * k + 1, x) + addi(a, b, m, r, 2 * k + 2, x);
sum[k] += s;
return s;
}
void update(int a, int b, int c, int d) { update(a, b, c, d, 0, N, 0); }
void update(int a, int b, int c, int d, int l, int r, int k) {
if (b <= l or r <= a) return;
if (a <= l and r <= b) {
if (flt[k]) {
addi(a + d - r, a + d - l, 0, N, 0, query(l, r) / (r - l));
return;
}
}
int m = (l + r) / 2;
update(a, b, c, d, l, m, 2 * k + 1);
update(a, b, c, d, m, r, 2 * k + 2);
}
int query(int a, int b) { return query(a, b, 0, N, 0); }
int query(int a, int b, int l, int r, int k) {
if (b <= l or r <= a) return 0;
if (a <= l and r <= b) return sum[k];
int m = (l + r) / 2, w = min(r, b) - max(l, a);
return query(a, b, l, m, 2 * k + 1) + query(a, b, m, r, 2 * k + 2) +
add[k] * w;
}
};
int n, q, bl, br, t, p, l, r, dir;
void solve() {
segtree st(n);
bl = 0;
br = n;
dir = 0;
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d", &p);
if ((br - bl) / 2 < p) {
p = (br - bl) - p;
dir ^= 1;
}
if (!dir) {
st.update(bl, bl + p, bl + p, bl + 2 * p);
bl += p;
} else {
st.update(br - p, br, br - 2 * p, br - p);
br -= p;
}
} else {
scanf("%d%d", &l, &r);
if (!dir)
printf("%d\n", st.query(l + bl, r + bl));
else
printf("%d\n", st.query(br - r, br - l));
}
}
}
void input() { scanf("%d%d", &n, &q); }
int main() {
input();
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, b;
cin >> r >> b;
cout << (r == b ? "Yes" : "No") << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
double x, y;
} a[1010];
int n;
double solve(int x, int y, int z) {
if (y == 1) x = n;
if (y == n) z = 1;
double A = a[z].y - a[x].y;
double B = a[x].x - a[z].x;
double C = a[z].x * a[x].y - a[x].x * a[z].y;
return fabs(A * a[y].x + B * a[y].y + C) / sqrt(A * A + B * B) / 2;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].x >> a[i].y;
}
double ans = 1e18;
for (int i = 1; i <= n; i++) {
ans = min(ans, solve(i - 1, i, i + 1));
}
printf("%.10lf\n", ans);
return 0;
}
| 4 |
#include<cstdio>
#include<iostream>
#include<bitset>
#include<deque>
#include<algorithm>
using namespace std;
struct Pox
{
int state,cost;
Pox(int state,int cost):state(state),cost(cost){}
};
int main()
{
while(1)
{
int n,U,k,r;
scanf("%d %d",&n,&U);
if(n+U == 0)
break;
int mincost[1<<n];
for(int i=0;i<(1<<n);i++)
mincost[i] = (1<<n);
deque<Pox> deq;
int G[n];
int c[n];
for(int i = 0;i<n;i++)
{
scanf("%d %d",&c[i],&k);
G[i] = 0;
for(int j=0;j<k;j++)
{
scanf("%d",&r);
G[i] |= (1<<r);
}
}
deq.push_back(Pox(0,0));
mincost[0] = 0;
int ans = (1<<n);
while(!deq.empty())
{
Pox pox = deq.front(); deq.pop_front();
int num = __builtin_popcount(pox.state);
if(num >= ans)
continue;
if(pox.cost >= U)
{
ans = min(ans,num);
continue;
}
for(int i=0;i<n;i++)
{
if((pox.state >> i) & 1)
continue;
int pre = G[i];
pre &= pox.state;
if(pre != G[i])
continue;
if(mincost[pox.state|(1<<i)] <= num+1)
continue;
mincost[pox.state|(1<<i)] = num+1;
if(pox.cost + c[i] < U)
deq.push_back(Pox(pox.state|(1<<i),pox.cost+c[i]));
else
ans = min(ans,num+1);
}
}
cout << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000007;
const int mod = 1000000007;
const int MOD = 998244353;
const int INF = 1e18 + 18;
vector<int> dx = {-1LL, 0LL, 1LL, 0LL}, dy = {0LL, 1LL, 0LL, -1LL};
void test_case() {
int q;
cin >> q;
int n = 710;
vector<vector<int>> dp(n + 1, vector<int>(n + 1, 0));
vector<int> arr(500000 + 1, 0);
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t == 1) {
int x, y;
cin >> x >> y;
for (int i = 1; i < n; i++) {
dp[i][x % i] += y;
}
arr[x] += y;
} else {
int x, y;
cin >> x >> y;
if (x < n) {
cout << dp[x][y % x] << "\n";
continue;
}
int suma = 0;
int k = y % x;
while (k <= 500000) {
suma += arr[k];
k += x;
}
cout << suma << "\n";
}
}
}
void intialize() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
void preprocess() {}
void codejam(int t) { cout << "Case #" << t << ": "; }
int main() {
intialize();
preprocess();
cout << fixed << setprecision(9);
test_case();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, dsize;
vector<long long> x,y,d;
string dir = "LUDR";
string solve(int now);
int main(){
cin >> n;
x.resize(n);
y.resize(n);
for(int i = 0;i < n;++i)cin >> x[i] >> y[i];
for(int i = 1;i < n;++i)
if(abs(x[i-1] + y[i-1]) % 2 != abs(x[i] + y[i]) % 2){
cout << -1 << endl;
return 0;
}
for(int i = 0;i < 31;++i)d.push_back((1LL << (30 - i)));
if(!(abs(x[0] + y[0]) % 2))d.push_back(1);
dsize = d.size();
cout << dsize << endl;
for(int i = 0;i < dsize;++i){
if(i != 0)cout << " ";
cout << d[i];
}
cout << endl;
for(int i = 0;i < n;++i)cout << solve(i) << endl;
return 0;
}
string solve(int now){
string ans;
long long uv[2] = {x[now]+y[now]+(1LL<<31) - 1,x[now]-y[now]+(1LL<<31) - 1};
if(abs(x[now]+y[now])%2 == 0)++uv[0],++uv[1];
for(int i = 0;i < dsize;++i){
int flag = 0;
for(int j = 0;j < 2;++j){
if(uv[j] >= 2 * d[i]){
flag += 1 <<j;
uv[j] -= 2 * d[i];
}
}
ans += dir[flag];
}
assert(uv[0] == 0 && uv[1] == 0);
return ans;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, m;
char a[N][N], c[N * N];
int b[N][N];
set<int> e[N * N];
int top;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
void dfs(int x, int y) {
b[x][y] = top;
for (int d = 0; d < 4; ++d) {
int nx = x + dx[d];
int ny = y + dy[d];
if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
if (a[nx][ny] == a[x][y] && !b[nx][ny]) dfs(nx, ny);
if (a[nx][ny] != a[x][y] && b[nx][ny]) {
e[top].insert(b[nx][ny]);
e[b[nx][ny]].insert(top);
}
}
}
}
int h[N * N];
int bfs(int s) {
h[s] = s;
int len = 0, op = 0, cl = 1;
vector<int> q;
q.push_back(s);
char last_color = c[q[op]];
while (op < q.size()) {
len += 1;
cl = q.size();
last_color = c[q[op]];
while (op < cl) {
int x = q[op];
for (int y : e[x])
if (h[y] != s) {
h[y] = s;
q.push_back(y);
}
++op;
}
}
return len - (last_color == 'W');
}
int main() {
scanf("%d%d \n", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", a[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (!b[i][j]) {
c[++top] = a[i][j];
dfs(i, j);
}
int ans = n + m;
for (int i = 1; i <= top; ++i) {
ans = min(ans, bfs(i));
}
cout << ans << endl;
}
| 5 |
#include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int g,a,b,c,m,mg;
while(cin >> g) {
if (g==0) break;
mg=9999999;
for (a=0;a<26;a++) for (b=0;b<17;b++) for (c=0;c<51;c++) {
if (a*200+b*300+c*500!=g) continue;
m=(a/5)*1520+(a%5)*380+(b/4)*1870+(b%4)*550+(c/3)*2244+(c%3)*850;
mg=(mg > m) ? m : mg;
}
cout << mg << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
long long a[200100], dp[200100], s[200100], ans;
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[n - i + 1]);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
for (int i = 1; i < n; i++)
dp[i] = ans + s[n],
ans = ((ans) > (-(s[i] + dp[i])) ? (ans) : (-(s[i] + dp[i])));
ans = -(1LL << 48);
for (int i = 0; i < n - 1; i++)
ans = ((ans) > (-dp[i] + s[n] - s[i]) ? (ans) : (-dp[i] + s[n] - s[i]));
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, ar[101000], dp[101000], dp2[101000], k, kk, ans;
int main() {
scanf("%I64d", &n);
for (i = 1; i <= n; i++) scanf("%I64d", &ar[i]);
dp[0] = 0;
for (i = 1; i <= n; i++) dp[i] = dp[i - 1] + ar[i];
if (dp[n] % 3 != 0) {
printf("0\n");
return 0;
}
ans = 0;
k = kk = dp[n] / 3;
k *= 2;
dp2[0] = 0;
for (i = 1; i <= n; i++) dp2[i] = dp2[i - 1] + ((dp[i] == k) ? 1 : 0);
for (i = 1; i <= n - 2; i++) {
if (dp[i] == kk) {
ans += dp2[n - 1] - dp2[i];
}
}
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
int p, q;
for (int i = 0; i < n; i++) {
cin >> p >> q;
if (p <= q - 2) {
ans++;
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 222;
int arr1[N], arr2[N];
int n, m;
bool solve(int x) {
for (int i = 1; i <= n; i++) {
bool sign = false;
for (int j = 1; j <= m; j++) {
if (((arr1[i] & arr2[j]) | x) == x) {
sign = true;
break;
}
}
if (!sign) return false;
}
return true;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr1[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d", &arr2[i]);
}
int ans = (1 << 9) - 1;
for (int k = 8; k >= 0; k--) {
if (solve(ans ^ (1 << k))) ans ^= (1 << k);
}
printf("%d\n", ans);
}
| 3 |
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstring>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <functional>
#include <sstream>
#include <complex>
#include <climits>
using namespace std;
#define REP(i,a,n) for(int i=(a);i<(int)(n);i++)
#define rep(i,n) REP(i,0,n)
#define pb push_back
#define mp make_pair
#define all(x) x.begin(),x.end()
#define EPS 1e-8
int main(){
const int dx[] = {0,1,0,-1};
const int dy[] = {1,0,-1,0};
int w,h,d,dir,x,y;
char commond[16];
while(scanf("%d%d",&w,&h),w|h){
dir = 0;
x = y = 1;
while(scanf("%s",commond)){
if( !strcmp(commond,"STOP") )break;
if( !strcmp(commond,"RIGHT") ){
dir = (dir+1)%4;
}else if( !strcmp(commond,"LEFT") ){
dir = (dir+3)%4;
}else{
scanf(" %d",&d);
if( !strcmp(commond,"FORWARD") ){
x += d*dx[dir];
y += d*dy[dir];
}else{
x -= d*dx[dir];
y -= d*dy[dir];
}
}
if( x<1 )x=1;
if( x>w )x=w;
if( y<1 )y=1;
if( y>h )y=h;
//printf("%s : dir:%d , %d,%d\n",commond,dir,x,y);
}
printf("%d %d\n",x,y);
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n; cin>>n;
if(n%2==0)
{
cout<<((n/2)+1)*((n/2)+1)<<endl;
}
else
{
int x = (n-1)/2;
cout<<(2+x)*(1+x)*2<<endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int c(int x) { return (x) * (x); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int a[6];
for (int i = 0; i < 6; ++i) cin >> a[i];
cout << c(a[0] + a[1] + a[2]) - c(a[0]) - c(a[2]) - c(a[4]);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, ar[1000005], sum, t, tut[1000005];
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cin >> t;
while (t--) {
sum = INT_MAX;
memset(tut, 0, sizeof(tut));
cin >> n;
for (long long int i = 1; i <= n; i++) cin >> ar[i];
for (long long int i = 1; i <= n; i++) {
if (tut[ar[i]]) sum = min(sum, i - tut[ar[i]]);
tut[ar[i]] = i;
}
if (sum == INT_MAX) sum = -2;
cout << sum + 1 << "\n";
}
}
| 3 |
#include<stdio.h>
int main(){
int a;scanf("%d",&a);
int L=a/100;
int R=a%100;
if(1<=L&&L<=12){
if(1<=R&&R<=12)printf("AMBIGUOUS\n");
else printf("MMYY\n");
}else{
if(1<=R&&R<=12)printf("YYMM\n");
else printf("NA\n");
}
}
| 0 |
#include <bits/stdc++.h>
const int N = 100010;
const int MAX = 1 << 17;
const int moder = 1e9 + 7;
const long long INF = 1e18;
int seg[MAX << 1], lazymult[MAX << 1], lazyadd[MAX << 1];
void addmod(int &a, int b) {
a += b;
a -= a >= moder ? moder : 0;
}
void submod(int &a, int b) {
a -= b;
a += a < 0 ? moder : 0;
}
void multmod(int &a, int b) { a = 1ll * a * b % moder; }
void multadd(int &a, int b, int c) { a = (a + 1ll * b * c) % moder; }
void push(int sit, int l, int r) {
for (int i = 0; i < 2; ++i) {
multmod(lazymult[sit << 1 | i], lazymult[sit]);
multmod(lazyadd[sit << 1 | i], lazymult[sit]);
multmod(seg[sit << 1 | i], lazymult[sit]);
addmod(lazyadd[sit << 1 | i], lazyadd[sit]);
multadd(seg[sit << 1 | i], r - l + 1 >> 1, lazyadd[sit]);
}
lazymult[sit] = 1;
lazyadd[sit] = 0;
}
void pull(int sit) {
seg[sit] = seg[sit << 1];
addmod(seg[sit], seg[sit << 1 | 1]);
}
void add(int sit, int l, int r, int ql, int qr, int value) {
if (ql <= l && qr >= r) {
multadd(seg[sit], r - l + 1, value);
addmod(lazyadd[sit], value);
return;
}
push(sit, l, r);
int mid = l + r >> 1;
if (ql <= mid) {
add(sit << 1, l, mid, ql, qr, value);
}
if (qr > mid) {
add(sit << 1 | 1, mid + 1, r, ql, qr, value);
}
pull(sit);
}
void add(int ql, int qr, int value) { add(1, 0, MAX - 1, ql, qr, value); }
void mult(int sit, int l, int r, int ql, int qr, int value) {
if (ql <= l && qr >= r) {
multmod(seg[sit], value);
multmod(lazyadd[sit], value);
multmod(lazymult[sit], value);
return;
}
push(sit, l, r);
int mid = l + r >> 1;
if (ql <= mid) {
mult(sit << 1, l, mid, ql, qr, value);
}
if (qr > mid) {
mult(sit << 1 | 1, mid + 1, r, ql, qr, value);
}
pull(sit);
}
void mult(int ql, int qr, int value) { mult(1, 0, MAX - 1, ql, qr, value); }
int query(int sit, int l, int r, int ql, int qr) {
if (ql <= l && qr >= r) {
return seg[sit];
}
push(sit, l, r);
int mid = l + r >> 1;
int ans = 0;
if (ql <= mid) {
addmod(ans, query(sit << 1, l, mid, ql, qr));
}
if (qr > mid) {
addmod(ans, query(sit << 1 | 1, mid + 1, r, ql, qr));
}
return ans;
}
int query(int ql, int qr) { return query(1, 0, MAX - 1, ql, qr); }
struct block {
long long real;
int mod;
int begin;
int end;
int sz;
block() : real(0), mod(0), begin(0), end(0), sz(0) {}
block(long long real, int begin, int sz)
: real(real), begin(begin), end(begin + sz - 1), sz(sz) {
mod = real % moder;
mod += mod < 0 ? moder : 0;
}
bool operator<(const block &b) const { return begin < b.begin; }
};
int a[N];
std::vector<std::pair<int, int> > vec[N];
int ans[N];
std::deque<block> queue;
int power[N], invpower[N];
int main() {
for (int i = 0; i < MAX << 1; ++i) {
lazymult[i] = 1;
}
power[0] = invpower[0] = 1;
for (int i = 1; i < N; ++i) {
power[i] = power[i - 1] << 1;
power[i] -= power[i] >= moder ? moder : 0;
invpower[i] = 1ll * invpower[i - 1] * (moder + 1 >> 1) % moder;
}
int n, q;
scanf("%d%d", &n, &q);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0, l, r; i < q; ++i) {
scanf("%d%d", &l, &r);
--l, --r;
vec[r].push_back({l, i});
}
for (int i = 0; i < n; ++i) {
queue.push_back(block(a[i], i, 1));
add(0, i, (a[i] % moder + moder) % moder);
while (queue.size() >= 2 && queue.back().real >= 0) {
block lastblock = queue.back();
queue.pop_back();
block preblock = queue.back();
queue.pop_back();
mult(lastblock.begin, lastblock.end, power[preblock.sz]);
add(0, preblock.end,
1ll * lastblock.mod * (power[preblock.sz] - 1 + moder) % moder);
multmod(lastblock.mod, power[preblock.sz]);
addmod(preblock.mod, lastblock.mod);
if (lastblock.real > 0) {
if (preblock.sz > 100) {
lastblock.real = INF;
} else if (1.0 * pow(2, preblock.sz) * lastblock.real > INF) {
lastblock.real = INF;
} else {
lastblock.real *= 1ll << preblock.sz;
}
}
preblock.sz += lastblock.sz;
preblock.end = preblock.begin + preblock.sz - 1;
preblock.real = std::min(INF, preblock.real + lastblock.real);
queue.push_back(preblock);
}
for (auto u : vec[i]) {
if (u.first == i) {
ans[u.second] = (a[i] % moder + moder) % moder;
continue;
}
int l = u.first + 1;
int sit = std::upper_bound(queue.begin(), queue.end(), block(0, l, 0)) -
queue.begin();
if (sit != queue.size()) {
ans[u.second] = query(queue[sit].begin, queue[sit].begin);
}
int sum = query(l, l);
submod(sum, ans[u.second]);
multadd(ans[u.second], sum, invpower[l - queue[sit - 1].begin]);
multmod(ans[u.second], 2);
addmod(ans[u.second], (a[u.first] % moder + moder) % moder);
}
}
for (int i = 0; i < q; ++i) {
printf("%d\n", ans[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, t, d;
cin >> n;
while (n--) {
cin >> x;
d = floor(x / 14);
t = x % 14;
if ((t <= 6 && t >= 1) && d >= 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
int main(int argc, char* argv[]) {
string s;
set<char> pos;
cin >> s;
for (char c : s) {
pos.insert(c);
}
if (pos.size() % 2 == 0) {
cout << "CHAT WITH HER!";
} else {
cout << "IGNORE HIM!";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(int x, int y) {
return !y ? (long long)x : (long long)gcd(y, x % y);
}
bool hts(vector<int> a, vector<int> b) { return a.size() < b.size(); }
int main() {
long long n, k, p, e = 0, o = 0, bit, len, idx = 0;
cin >> n >> k >> p, len = k, k -= p;
vector<int> array(n), resto, reste;
vector<vector<int> > ans(len);
for (long long i = 0; i < int(n); i++) {
scanf("%d", &array[i]), bit = (array[i] & 1);
if (bit && k && idx < len)
k--, ans[idx++].push_back(array[i]);
else if (!bit && p && idx < len)
p--, ans[idx++].push_back(array[i]);
else
bit ? resto.push_back(array[i]) : reste.push_back(array[i]), o += bit,
e += !bit;
}
if (k || (p && p > o / 2) || (o & 1)) {
cout << "NO" << endl;
return 0;
}
sort(ans.begin(), ans.end(), hts);
while (e || o)
for (long long i = 0; i < int(len); i++)
if (e)
ans[i].push_back(reste.back()), reste.pop_back(), e--;
else if (o)
ans[i].push_back(resto.back()), resto.pop_back(),
ans[i].push_back(resto.back()), resto.pop_back(), o -= 2;
else
goto hell;
hell:
cout << "YES" << endl;
for (long long i = 0; i < int(len); i++) {
cout << ans[i].size() << " ";
for (long long j = 0; j < int(ans[i].size()); j++) cout << ans[i][j] << " ";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
pair<int, int> h[maxn];
int p[maxn];
int ans[maxn];
int in[maxn];
int cal(int x) {
if (x == 1) {
return h[x].first;
}
return max(h[x].first, h[x].second + 1);
}
int main() {
p[1] = 0;
ans[1] = 1;
h[1] = make_pair(0, 0);
int n;
scanf("%d", &n);
for (int x = 2; x <= n + 1; ++x) {
scanf("%d", p + x);
++in[p[x]];
h[x] = make_pair(0, 0);
ans[x] = 0;
int cur = x;
for (; cur;) {
int tmp = cal(cur);
if (tmp > ans[cur]) {
if (h[p[cur]].first == ans[cur])
h[p[cur]].first = tmp;
else if (h[p[cur]].second == ans[cur])
h[p[cur]].second = tmp;
ans[cur] = tmp;
if (h[p[cur]].first < h[p[cur]].second)
swap(h[p[cur]].first, h[p[cur]].second);
cur = p[cur];
} else
break;
}
printf("%d%c", ans[1], x == n ? '\n' : ' ');
}
}
| 4 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef long long ll;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n,k;
while(cin >> n >> k){
if(!n && !k) break;
int card[n];
rep(i,n) cin >> card[i];
sort( card, card + n );
int ans = 0;
map<int,int> memo;
do{
int temp = 0;
rep(i,k){
temp *= 10;
if(card[i]>9) temp *= 10;
temp += card[i];
}
if(memo[temp] == 0) ans++;
memo[temp] = 1;
}while(next_permutation( card, card + n ));
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K;
long long dp[2005][2005];
void pri() {
for (int i = 1; i <= N; i++) {
for (int j = 0; j <= K; j++) cout << dp[i][j] << " ";
cout << endl;
}
return;
}
int main() {
cin >> N >> M >> K;
if (0 == K) {
cout << M;
return 0;
}
dp[1][0] = M;
for (int i = 2; i <= N; i++) {
dp[i][0] = dp[i - 1][0];
for (int j = 1; (j <= K && i > j); j++) {
dp[i][j] = (dp[i - 1][j - 1] * (M - 1) + dp[i - 1][j]) % 998244353;
}
}
cout << dp[N][K];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const int INF = 2e9 + 7;
const int mod = 1e9 + 7;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int a[30], b[30], v[30], flag, n, cnt;
bool cmp(int a, int b) { return a > b; }
bool ok(int x) {
int tot = 0;
for (int i = 0; i < x; i++) {
if (v[i] > 0) tot += v[i];
}
return tot == cnt;
}
void dfs(int x) {
if (flag) return;
if (a[x] == 1 || x == n) {
if (ok(x)) flag = 1;
return;
}
for (int i = 0; i < x; i++) {
if (flag) return;
if (v[i] >= a[x] && a[x] != b[i]) {
v[i] -= a[x];
v[x] = b[x] = a[x] - 1;
dfs(x + 1);
v[i] += a[x];
v[x] = -1;
b[x] = 0;
}
}
}
int main() {
int t, cas = 1, m;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1)
cnt++;
else if (a[i] == 2)
return 0 * puts("NO");
}
if (n == 1) return 0 * puts(a[0] == 1 ? "YES" : "NO");
sort(a, a + n, cmp);
memset(v, -1, sizeof v);
if (a[0] != n) return 0 * puts("NO");
b[0] = a[0] - 1;
v[0] = a[0] - 1;
dfs(1);
if (flag)
puts("YES");
else
puts("NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 10e-11;
class VagueDouble {
public:
double vd;
VagueDouble() { vd = nan(""); }
VagueDouble(const double d) { vd = d; }
inline VagueDouble operator+(const VagueDouble VD) const {
return VagueDouble(vd + VD.vd);
}
inline VagueDouble operator-(const VagueDouble VD) const {
return VagueDouble(vd - VD.vd);
}
inline VagueDouble operator*(const VagueDouble VD) const {
return VagueDouble(vd * VD.vd);
}
inline VagueDouble operator/(const VagueDouble VD) const {
return VagueDouble(vd / VD.vd);
}
inline VagueDouble operator+(const double d) const {
return VagueDouble(vd + d);
}
inline VagueDouble operator-(const double d) const {
return VagueDouble(vd - d);
}
inline VagueDouble operator*(const double d) const {
return VagueDouble(vd * d);
}
inline VagueDouble operator/(const double d) const {
return VagueDouble(vd / d);
}
inline bool operator<(const VagueDouble VD) const {
return vd + EPS < VD.vd && vd + EPS * abs(vd) < VD.vd;
}
inline bool operator>(const VagueDouble VD) const {
return vd - EPS > VD.vd && vd - EPS * abs(vd) > VD.vd;
}
inline bool operator==(const VagueDouble VD) const {
return !(*this < VD.vd) && !(*this > VD.vd);
}
inline bool operator<(const double d) const { return *this < VagueDouble(d); }
inline bool operator>(const double d) const { return *this > VagueDouble(d); }
inline bool operator==(const double d) const {
return *this == VagueDouble(d);
}
inline void operator+=(const VagueDouble VD) { *this = *this + VD; }
inline void operator-=(const VagueDouble VD) { *this = *this - VD; }
inline void operator*=(const VagueDouble VD) { *this = *this * VD; }
inline void operator/=(const VagueDouble VD) { *this = *this / VD; }
inline friend VagueDouble operator+(const double d, const VagueDouble &VD) {
return VagueDouble(d) + VD;
}
inline friend VagueDouble operator-(const double d, const VagueDouble &VD) {
return VagueDouble(d) - VD;
}
inline friend VagueDouble operator*(const double d, const VagueDouble &VD) {
return VagueDouble(d) * VD;
}
inline friend VagueDouble operator/(const double d, const VagueDouble &VD) {
return VagueDouble(d) / VD;
}
inline friend bool operator<(const double d, const VagueDouble &VD) {
return VagueDouble(d) < VD;
}
inline friend bool operator>(const double d, const VagueDouble &VD) {
return VagueDouble(d) > VD;
}
inline friend bool operator==(const double d, const VagueDouble &VD) {
return VagueDouble(d) == VD;
}
double to_double() { return vd; }
friend std::ostream &operator<<(std::ostream &os, const VagueDouble VD) {
os << VD.vd;
return os;
}
friend std::istream &operator>>(std::istream &is, VagueDouble &VD) {
double d;
is >> d;
VD = VagueDouble(d);
return is;
}
};
VagueDouble abs(VagueDouble VD) { return (VD.vd < 0) ? (-VD.vd) : VD.vd; }
VagueDouble sqr(VagueDouble VD) { return VD.vd * VD.vd; }
VagueDouble sqr(double d) { return d * d; }
VagueDouble sqrt(VagueDouble VD) { return VagueDouble(sqrt(VD.vd)); }
bool isnan(VagueDouble VD) { return isnan(VD.vd); }
class P {
private:
public:
VagueDouble x, y;
P() {
x = nan("");
y = nan("");
}
P(double _x, double _y) {
x = _x;
y = _y;
}
P(VagueDouble _x, VagueDouble _y) {
x = _x;
y = _y;
}
P operator+(const P p) const { return P(x + p.x, y + p.y); }
P operator-(const P p) const { return P(x - p.x, y - p.y); }
P operator*(const double d) const { return P(x * d, y * d); }
P operator/(const double d) const { return P(x / d, y / d); }
bool operator<(const P &p) const {
return (x == p.x) ? (y < p.y) : (x < p.x);
}
bool operator>(const P &p) const {
return (x == p.x) ? (y > p.y) : (x > p.x);
}
bool operator==(const P &p) const { return (x == p.x) && (y == p.y); }
void operator+=(const P &p) { *this = *this + p; }
void operator-=(const P &p) { *this = *this - p; }
void operator*=(const double &p) { *this = *this * p; }
void operator/=(const double &p) { *this = *this / p; }
friend std::ostream &operator<<(std::ostream &os, const P &p) {
os << p.x.vd << " " << p.y.vd;
return os;
}
friend std::istream &operator>>(std::istream &is, P &p) {
double _x, _y;
is >> _x >> _y;
p = P(_x, _y);
return is;
}
};
VagueDouble dist(P p0, P p1) {
return sqrt(sqr(p0.x - p1.x) + sqr(p0.y - p1.y));
}
VagueDouble area(P p0, P p1, P p2) {
return abs((p1.x - p0.x) * (p2.y - p0.y) - (p2.x - p0.x) * (p1.y - p0.y)) /
0.5;
}
VagueDouble distPL(P l0, P l1, P p) {
if (l0 == l1) return dist(l0, p);
VagueDouble dx = l0.x - l1.x;
VagueDouble dy = l0.y - l1.y;
return abs(dy * (l0.x - p.x) - dx * (l0.y - p.y)) / sqrt(dx * dx + dy * dy);
}
bool isnan(P p) { return isnan(p.x); }
bool onLine(P l0, P l1, P p) {
if (l0 == l1) return l0 == p;
if (p.x < min(l0.x, l1.x) || max(l0.x, l1.x) < p.x) return false;
if (p.y < min(l0.y, l1.y) || max(l0.y, l1.y) < p.y) return false;
return distPL(l0, l1, p) == 0;
}
P findCross(P a0, P a1, P b0, P b1) {
P a = a0 - a1, b = b0 - b1, res;
if (abs(a.x * b.y - a.y * b.x) == 0) return res;
res.x = (a.x * b.x * (a0.y - b0.y) + a.x * b.y * b0.x - a.y * b.x * a0.x) /
(a.x * b.y - a.y * b.x);
res.y = (a.y * b.y * (a0.x - b0.x) + a.y * b.x * b0.y - a.x * b.y * a0.y) /
(a.y * b.x - a.x * b.y);
if (res.x < min(a0.x, a1.x) || max(a0.x, a1.x) < res.x) return P();
if (res.x < min(b0.x, b1.x) || max(b0.x, b1.x) < res.x) return P();
if (res.y < min(a0.y, a1.y) || max(a0.y, a1.y) < res.y) return P();
if (res.y < min(b0.y, b1.y) || max(b0.y, b1.y) < res.y) return P();
return res;
}
class Polygon {
private:
public:
vector<P> points;
Polygon() {}
Polygon(vector<P> vec) { points = vec; }
Polygon(int num) { points.resize(num); }
int size() { return ((int)(points).size()); }
P &operator[](int pos) { return points[pos]; }
bool onPoly(P p) {
int n = ((int)(points).size());
for (int i = 0; i < ((int)(n)); ++i)
if (onLine(points[i], points[(i + 1) % n], p)) return true;
return false;
}
bool inPoly(P p) {
int n = ((int)(points).size());
if (n == 0) return false;
if (onPoly(p)) return true;
P right_point = p;
for (int i = 0; i < ((int)(n)); ++i)
right_point.x = max(right_point.x, points[i].x);
if (right_point == p) return false;
int cnt = 0;
for (int i = 0; i < ((int)(n)); ++i) {
P cross = findCross(points[i], points[(i + 1) % n], p, right_point);
if (!isnan(cross)) cnt++;
}
for (int i = 0; i < ((int)(((int)(points).size()))); ++i)
if (onLine(p, right_point, points[i])) {
VagueDouble dy0 = points[(i - 1 + n) % n].y - p.y;
VagueDouble dy1 = points[(i + 1 + n) % n].y - p.y;
if (dy0 * dy1 < 0) cnt++;
}
return cnt % 2 == 1;
}
friend std::ostream &operator<<(std::ostream &os, Polygon &poly) {
for (int i = 0; i < ((int)(((int)(poly).size()))); ++i)
os << poly[i] << " ";
return os;
}
friend std::istream &operator>>(std::istream &is, Polygon &poly) {
for (int i = 0; i < ((int)(((int)(poly).size()))); ++i) is >> poly[i];
return is;
}
};
int main() {
int n;
cin >> n;
vector<Polygon> base(n, Polygon(3));
for (int i = 0; i < ((int)(n)); ++i) cin >> base[i];
set<P> seg[10005];
for (int i = 0; i < ((int)(((int)(base).size()))); ++i)
for (int j = 0; j < ((int)(((int)(base[i]).size()))); ++j)
seg[i * 3 + j].insert(base[i][(j + 0) % 3]);
for (int i = 0; i < ((int)(((int)(base).size()))); ++i)
for (int j = 0; j < ((int)(((int)(base[i]).size()))); ++j)
seg[i * 3 + j].insert(base[i][(j + 1) % 3]);
for (int i = 0; i < ((int)(((int)(base).size()))); ++i)
for (int j = 0; j < ((int)(((int)(base[i]).size()))); ++j)
for (int k = 0; k < ((int)(((int)(base).size()))); ++k)
for (int l = 0; l < ((int)(((int)(base[k]).size()))); ++l) {
if (i == k) continue;
P cross = findCross(base[i][j], base[i][(j + 1) % 3], base[k][l],
base[k][(l + 1) % 3]);
if (isnan(cross)) continue;
seg[i * 3 + j].insert(cross);
}
VagueDouble res = 0.0;
vector<P> vec[10005];
for (int i = 0; i < ((int)(((int)(base).size()))); ++i)
for (int j = 0; j < ((int)(((int)(base[i]).size()))); ++j)
for (__typeof((seg[i * 3 + j]).begin()) it = (seg[i * 3 + j]).begin();
it != (seg[i * 3 + j]).end(); it++)
vec[i * 3 + j].push_back(*it);
for (int i = 0; i < ((int)(((int)(base).size()))); ++i)
for (int j = 0; j < ((int)(((int)(base[i]).size()))); ++j)
for (int k = 0; k < ((int)(((int)(vec[i * 3 + j]).size()) - 1)); ++k) {
P mid = (vec[i * 3 + j][k] + vec[i * 3 + j][k + 1]) / 2.0;
bool ok = true;
for (int l = 0; l < ((int)(((int)(base).size()))); ++l)
if (i != l && base[l].inPoly(mid)) {
ok = false;
break;
}
if (ok) res += dist(vec[i * 3 + j][k], vec[i * 3 + j][k + 1]);
}
printf("%0.20lf\n", res.to_double());
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, t;
long long dp[55][55];
long long solve(long long n, int p) {
if (p == 0) return 1;
for (int i = 50; i >= 0; --i) {
if ((1ll << i) & n) {
return dp[i][p] + solve(n - (1ll << i), p - 1);
}
}
return 0;
}
int main(void) {
dp[0][0] = 1;
for (int i = 0; i < 50; ++i) {
for (int j = 0; j < 50; ++j) {
dp[i + 1][j] = dp[i][j] + (j >= 1 ? dp[i][j - 1] : 0);
}
}
cin >> n >> t;
++n;
int p = 0;
while (1ll << p < t) ++p;
if (1ll << p != t) {
printf("0\n");
return 0;
}
++p;
cout << solve(n, p) - (t == 1 ? 1 : 0) << endl;
return 0;
}
| 5 |
#include <iostream>
using namespace std;
int main() {
int a[] = {1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
int n; cin >> n; cout << a[n-1] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
bool array[102][102], in = 1;
scanf("%d%d", &x, &y);
for (long long i = 1; i < x + 1; i++)
for (long long j = 1; j < y + 1; j++) cin >> array[i][j];
while (!(x % 2) && in) {
for (long long i = 1; i < x / 2 + 1; i++)
for (long long j = 1; j < y + 1; j++)
in &= (array[i][j] == array[x - i + 1][j]);
if (in) x /= 2;
}
cout << x << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long mod = 1e9 + 7;
long long l, r;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> l >> r;
vector<long long> v;
queue<string> q;
q.push("4");
q.push("7");
while (!q.empty()) {
string val = q.front();
q.pop();
if (stoll(val) > 2e10) {
break;
}
v.push_back(stoll(val));
q.push(val + "4");
q.push(val + "7");
}
sort(v.begin(), v.end());
long long ans = 0;
while (l <= r) {
vector<long long>::iterator it = lower_bound((v).begin(), (v).end(), l);
long long val = min(r, *it);
ans += (val - l + 1) * (*it);
l = val + 1;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p;
scanf("%d %d", &n, &p);
long long sum = 0;
long long ans = 0;
int a[100005];
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
long long temp = 0;
for (int j = 0; j < n - 1; j++) {
temp += a[j];
ans = max(ans, temp % p + (sum - temp) % p);
}
printf("%lld\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000005;
const int M = 1000000007;
int n, m;
int a, b;
int d[N];
int pa[N], ran[N];
int vis[N], cnt[N];
set<int> st;
void ini() {
memset(d, 0, sizeof(d));
memset(vis, 0, sizeof(vis));
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i <= n; i++) pa[i] = i, ran[i] = 1;
st.clear();
vis[1] = 2;
}
int find(int x) {
if (x == pa[x]) return x;
return pa[x] = find(pa[x]);
}
void uni(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (ran[x] < ran[y])
pa[x] = pa[y];
else {
pa[y] = pa[x];
if (ran[x] == ran[y]) ran[x]++;
}
}
int main() {
while (~scanf("%d%d", &n, &m)) {
ini();
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
vis[a] = vis[b] = 1;
if (a != b) {
d[a]++;
d[b]++;
}
uni(a, b);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) {
st.insert(find(i));
if (d[i] % 2) cnt[find(i)]++;
}
}
ans += st.size() == 1 ? 0 : st.size();
if (st.size() > 1) {
for (int i = 1; i <= n; i++) {
if (cnt[i] > 2) ans += (cnt[i] - 2) / 2;
}
} else {
for (int i = 1; i <= n; i++)
if (d[i] % 2) ans++;
ans /= 2;
if (vis[1] == 2) ans += 2;
}
if (m == 0) ans = 0;
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <iostream>
#include <cstdio>
#include <cstring>
#define max_n 200000
using namespace std;
int n,tr[max_n+1][2],tot=1;
long long l;
bool num[100];
char s[max_n+1],*ed;
void ins(int v,char*now){
int&x=tr[v][*now^'0'];
!x&&(x=++tot);
now<ed&&(ins(x,now+1),1);
}
void dfs(int v,int d){
#define k 0
tr[v][k]?dfs(tr[v][k],d+1),1:(l-d>0&&(num[__builtin_ctzll(l-d)]^=1));
#undef k
#define k 1
tr[v][k]?dfs(tr[v][k],d+1),1:(l-d>0&&(num[__builtin_ctzll(l-d)]^=1));
#undef k
}
int main(){
scanf("%d%lld",&n,&l),ed=s;
char*tmp;
for(int i=0; ++i<=n; ){
scanf("%s",tmp=ed+1);
ed+=strlen(tmp);
ins(1,tmp);
}
dfs(1,0);
for(int i=0;i<=60;i++) if(num[i]) {puts("Alice");return 0;}
puts("Bob");
return 0;
} | 0 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<math.h>
#include<stdlib.h>
#include<cstdlib>
using namespace std;
int main() {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
cout << (min(min(a, b), c) + min(d, e) - 50) << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long add(long long x, long long y, long long CMOD = MOD) {
return (x + y + CMOD + CMOD) % CMOD;
}
long long mult(long long x, long long y, long long CMOD = MOD) {
return add(x, 0) * add(y, 0) % CMOD;
}
long long fast_expo(long long x, long long y, long long CMOD = MOD) {
if (x == 0) return 0;
if (y == 0) return 1;
long long ans = fast_expo(x, y / 2, CMOD);
ans = mult(ans, ans, CMOD);
if (y & 1) ans = mult(ans, x, CMOD);
return ans;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long gen(long long x, long long y) {
if (x == y) return x;
return x + rng() % (y - x + 1);
}
const int TAM = 1e5 + 100;
const long long INF = LLONG_MAX / 4;
int n;
int main() {
priority_queue<long long, vector<long long>, greater<long long> > pq;
scanf("%d", &n);
if (n % 2 == 0) pq.push(0);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
pq.push(x);
}
long long ans = 0;
while (pq.size() > 1) {
long long x = 0;
for (int i = 0; i < 3; i++) {
x += pq.top();
pq.pop();
}
ans += x;
pq.push(x);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct _ {
_() { ios_base::sync_with_stdio(0); }
} _;
template <class A, class B>
ostream &operator<<(ostream &o, pair<A, B> t) {
o << "(" << t.first << ", " << t.second << ")";
return o;
}
template <class T>
string tostring(T first, int len = 0, char c = '0') {
stringstream ss;
ss << first;
string r = ss.str();
if (r.length() < len) r = string(len - r.length(), c) + r;
return r;
}
template <class T>
void PV(T a, T b, int n = 0, int w = 0, string s = " ") {
int c = 0;
while (a != b) {
cout << tostring(*a++, w, ' ');
if (a != b && (n == 0 || ++c % n))
cout << s;
else
cout << "\n";
cout.flush();
}
}
template <class T>
inline bool chmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
inline bool chmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
const long long linf = 0x3f3f3f3f3f3f3f3fLL;
const int inf = 0x3f3f3f3f;
const int mod = int(1e9) + 7;
const int N = 111111;
int main() {
long long l, r, k;
cin >> l >> r >> k;
if (r - l < 10) {
int n = r - l + 1;
long long minv = linf, pi = -1;
for (int i = 0; i < 1 << n; i++) {
int cnt = 0;
long long xr = 0;
for (int j = 0; j < n; j++) {
if (i >> j & 1) {
cnt++;
xr ^= l + j;
}
}
if (1 <= cnt && cnt <= k && chmin(minv, xr)) pi = i;
}
vector<long long> r;
for (int i = 0; i < n; i++)
if (pi >> i & 1) r.push_back(l + i);
cout << minv << endl;
cout << r.size() << endl;
PV((r).begin(), (r).end());
} else {
if (k == 1) {
cout << l << endl;
cout << 1 << endl;
cout << l << endl;
} else if (k == 2 || k == 3) {
long long pi = l, pj = l + 1;
if ((pi ^ pj) > 1) pi++, pj++;
int cl = 0, rl = 0;
while (l >> cl) cl++;
while (r >> rl) rl++;
if (k == 2 || cl == rl) {
cout << 1 << endl;
cout << 2 << endl;
cout << pi << " " << pj << endl;
} else {
long long R = r - (1LL << (rl - 1));
int Rl = 0;
while (R >> Rl) Rl++;
long long mx = (1LL << (Rl)) - 1;
if (mx < l) {
cout << 1 << endl;
cout << 2 << endl;
cout << pi << " " << pj << endl;
} else {
cout << 0 << endl;
cout << 3 << endl;
long long A = r;
long long B = mx ^ A;
long long C = A ^ B;
cout << A << " " << B << " " << C << endl;
}
}
} else if (k >= 4) {
for (long long i = l; i + 3 <= r; i++) {
if ((i ^ (i + 1) ^ (i + 2) ^ (i + 3)) == 0) {
cout << 0 << endl;
cout << 4 << endl;
cout << i << " " << i + 1 << " " << i + 2 << " " << i + 3 << endl;
break;
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int C[200006], A[200006], sp[200006], visit[200006], rev[200006];
vector<int> adj[200006];
int flag, pp;
void dfs(int node) {
if (visit[node]) return;
visit[node] = 1;
rev[node] = 1;
for (int i = 0; i < adj[node].size(); i++) {
if (rev[adj[node][i]]) {
flag = 1;
pp = adj[node][i];
}
dfs(adj[node][i]);
}
rev[node] = 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int N, i, j, k;
scanf("%d", &N);
for (i = 1; i <= N; i++) scanf("%d", &C[i]);
for (i = 1; i <= N; i++) {
scanf("%d", &A[i]);
adj[i].push_back(A[i]);
if (A[i] == i) sp[i] = 1;
}
for (i = 1; i <= N; i++) {
flag = 0;
pp = 0;
if (!visit[i]) {
dfs(i);
}
if (flag) {
int minn = 1e9;
int node = pp;
vector<int> lol;
int x = pp;
do {
if (x <= 0) break;
if (C[x] < minn) {
minn = C[x];
node = x;
}
x = A[x];
} while (x != pp && x > 0);
sp[node] = 1;
}
}
int ans = 0;
for (i = 1; i <= N; i++) {
if (sp[i]) ans += C[i];
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vb = vector<bool>;
using vd = vector<double>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvb = vector<vb>;
using vvd = vector<vd>;
using vvl = vector<vl>;
template <typename V, typename T>
inline void fill(V& x, const T& val) {
x = val;
}
template <typename V, typename T>
inline void fill(vector<V>& vec, const T& val) {
for (auto& v : vec) fill(v, val);
}
template <typename T>
inline vector<T> operator+(vector<T> lhs, const vector<T>& rhs) {
lhs.insert(lhs.end(), (rhs).begin(), (rhs).end());
return lhs;
}
template <typename T>
inline istream& operator>>(istream& is, vector<T>& vec) {
for (T& x : vec) is >> x;
return is;
}
template <typename T>
inline string join(const vector<T>& vec, string sep = " ") {
stringstream ss;
for (ll i = 0; i < (vec.size()); ++i)
ss << vec[i] << (i + 1 == vec.size() ? "" : sep);
return ss.str();
}
const ll MOD = ((ll)1e9) + 9;
const double EPS = 1e-10;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(30);
ll n;
cin >> n;
vl a(n);
vl b(n);
cin >> a >> b;
ll a_sum = 0, b_sum = 0;
for (ll i = 0; i < (n); ++i) a_sum |= a[i];
for (ll i = 0; i < (n); ++i) b_sum |= b[i];
cout << a_sum + b_sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans, mod=1e9+7;
long long p(long long x, long long y){
if(y==1) return (x+mod)%mod;
if(y%2) return (x*p(x, y-1)+mod)%mod;
long long res=p(x, y/2)%mod;
return (res*res+mod)%mod;
}
int main(){
cin>>n;
ans=p(10, n)-2*p(9, n);
ans%=mod;
ans+=p(8, n);
ans%=mod;
cout<<(ans+mod)%mod<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int maxn = 2e5 + 500;
int n;
string E[256], T[256], F[256];
bool flag = true;
void update(string &A, string B) {
if (A == "")
A = B, flag = 1;
else {
if (A.size() > B.size())
A = B, flag = 1;
else if (A.size() == B.size() && A > B)
A = B, flag = 1;
}
}
void slove() {
int x = 0, y = 0, z = 0;
for (int i = 0; i < 8; i++)
if (i / 4) x |= 1 << i;
F[x] = "x";
for (int i = 0; i < 8; i++)
if ((i / 2) % 2) y |= 1 << i;
F[y] = "y";
for (int i = 0; i < 8; i++)
if (i % 2) z |= 1 << i;
F[z] = "z";
while (flag) {
flag = 0;
for (int i = 0; i < 256; i++) {
for (int j = 0; j < 256; j++) {
if (E[i].size() && E[j].size()) update(E[i | j], E[i] + '|' + E[j]);
if (E[i].size() && T[j].size()) update(E[i | j], E[i] + '|' + T[j]);
if (T[i].size() && E[j].size()) update(E[i | j], T[i] + '|' + E[j]);
if (E[i].size() && F[j].size()) update(E[i | j], E[i] + '|' + F[j]);
if (F[i].size() && E[j].size()) update(E[i | j], F[i] + '|' + E[j]);
if (T[i].size() && T[j].size()) update(E[i | j], T[i] + '|' + T[j]);
if (F[i].size() && T[j].size()) update(E[i | j], F[i] + '|' + T[j]);
if (T[i].size() && F[j].size()) update(E[i | j], T[i] + '|' + F[j]);
if (F[i].size() && F[j].size()) update(E[i | j], F[i] + '|' + F[j]);
}
}
for (int i = 0; i < 256; i++) {
for (int j = 0; j < 256; j++) {
if (T[i].size() && T[j].size()) update(T[i & j], T[i] + '&' + T[j]);
if (F[i].size() && T[j].size()) update(T[i & j], F[i] + '&' + T[j]);
if (T[i].size() && F[j].size()) update(T[i & j], T[i] + '&' + F[j]);
if (F[i].size() && F[j].size()) update(T[i & j], F[i] + '&' + F[j]);
}
}
for (int i = 0; i < 256; i++)
if (E[i] != "") update(F[i], '(' + E[i] + ')');
for (int i = 0; i < 256; i++)
if (T[i] != "") update(F[i], '(' + T[i] + ')');
for (int i = 0; i < 256; i++)
if (F[i] != "") update(F[i ^ 255], '!' + F[i]);
if (!flag) break;
}
}
int main() {
slove();
cin >> n;
for (int i = 1; i <= n; i++) {
string st;
cin >> st;
int now = 0;
for (int j = 0; j < 8; j++) {
if (st[j] == '1') now |= 1 << j;
}
string str;
update(str, E[now]);
update(str, F[now]);
update(str, T[now]);
cout << str << endl;
}
}
| 5 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
double tkt[8];
double flg[256][30];
double path[30][30];
int main(){
for(int n, m, p, a, b; cin >> n >> m >> p >> a >> b;){
a--;
b--;
if(n == 0)break;
for(int i = 0; i < 256; i++){
for(int j = 0; j < 30; j++){
flg[i][j] = 1234;
}
}
for(int i = 0; i < 30; i++){
for(int j = 0; j < 30; j++){
path[i][j] = 1234;
}
}
for(int i = 0; i < n; i++)cin >> tkt[i];
for(int i = 0; i < p; i++){
int x, y, z;
cin >> x >> y >> z;
x--;
y--;
path[x][y] = z;
path[y][x] = z;
}
flg[0][a] = 0.0;
for(int bit = 0; bit < (1 << n); bit++){
for(int f = 0; f < m; f++){
double cs = flg[bit][f];
if(cs > 1000)continue;
for(int t = 0; t < m; t++){
if(path[f][t] > 1000)continue;
for(int b = 1, j = 0; j < n; b <<= 1, j++){
if(bit & b)continue;
flg[bit + b][t] = min(flg[bit + b][t], cs + path[f][t] / tkt[j]);
}
}
}
}
double ans = 1234;
for(int i = 0; i < (1 << n); i++){
ans = min(ans, flg[i][b]);
}
if(ans > 1000){
printf("Impossible\n");
}
else{
printf("%.9f\n", ans);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;
int n, k, sx;
char a[5][105];
bool bfs(int sx) {
queue<pair<int, int> > q;
q.push(pair<int, int>(sx, 1));
while (q.size()) {
int x = q.front().first, y = q.front().second;
q.pop();
if (isalpha(a[x][++y])) continue;
if (y >= n) return true;
for (int i = -1; i <= 1; ++i) {
int nx = x + i;
if (nx < 1 || nx > 3) continue;
if (isalpha(a[nx][y]) || isalpha(a[nx][y + 1]) || isalpha(a[nx][y + 2]) ||
a[nx][y + 2] == 1)
continue;
int ny = y + 2;
if (ny >= n) return true;
a[nx][ny] = 1;
q.push(pair<int, int>(nx, ny));
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
int t;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &k);
memset(a, 0, sizeof a);
for (int i = 1; i <= 3; ++i) {
scanf("%s", a[i] + 1);
if (a[i][1] == 's') sx = i;
}
puts(bfs(sx) ? "YES" : "NO");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int a[1000], n, c;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int val;
cin >> n;
long long int f = 1;
a[0] = 1000;
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
val = a[i];
if (f != -1) {
for (long long int j = a[i - 1]; j <= 2012; j++) {
c = 0;
if (j == 2012) {
f = -1;
break;
} else if (j < 2012) {
long long int t = j;
val = a[i];
while (val > 0) {
if (val % 10 == t % 10) c++;
val /= 10;
t /= 10;
}
if (c == 4 || c == 3) {
a[i] = j;
break;
} else
continue;
}
}
}
}
if (f == -1)
cout << "No solution";
else {
for (long long int i = 1; i <= n; i++) cout << a[i] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N(5011), A(26);
char a[N];
int c[N][N], dp[N][A], sum[N];
int modulo(1e9 + 7);
int main() {
int n;
cin >> n;
for (int i(0); i <= n; i++) {
for (int j(0); j <= i; j++) {
c[i][j] =
(i == 0 || j == 0) ? 1 : (c[i - 1][j - 1] + c[i - 1][j]) % modulo;
}
}
sum[0] = 1;
scanf("%s", a + 1);
for (int i(1); i <= n; i++) {
int c(a[i] - 'a');
for (int j(i); j >= 1; j--) {
int delta((0ll + sum[j - 1] - dp[j - 1][c] - dp[j][c] + 2 * modulo) %
modulo);
dp[j][c] = (dp[j][c] + delta) % modulo;
sum[j] = (sum[j] + delta) % modulo;
}
}
int ans(0);
for (int i(1); i <= n; i++) {
ans = (ans + (long long)sum[i] * c[n - 1][i - 1]) % modulo;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int T, n = 250, mx, si, a[252];
double X, V;
int main() {
scanf("%d", &T);
int i;
while (T--) {
mx = si = 0;
X = V = 0;
for (i = 1; i <= n; i++) scanf("%d", &a[i]), mx = max(mx, a[i]), X += a[i];
X /= n;
for (i = 1; i <= n; i++) si += (a[i] == mx), V += (a[i] - X) * (a[i] - X);
V /= n;
if (V > 2.0 * X) {
printf("uniform\n");
continue;
}
if ((mx >= 3) && (mx * 3 <= si)) {
printf("uniform\n");
continue;
}
printf("poisson\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T& num) {
char CH;
bool F = false;
for (CH = getchar(); CH < '0' || CH > '9'; F = CH == '-', CH = getchar())
;
for (num = 0; CH >= '0' && CH <= '9';
num = num * 10 + CH - '0', CH = getchar())
;
F && (num = -num);
}
int stk[70], tp;
template <class T>
inline void print(T p) {
if (!p) {
puts("0");
return;
}
while (p) stk[++tp] = p % 10, p /= 10;
while (tp) putchar(stk[tp--] + '0');
putchar('\n');
}
const long long mod = 1e9 + 7;
const double PI = acos(-1.0);
const int inf = 1e9;
const int N = 1e5 + 10;
const int maxn = 1e3 + 20;
const double eps = 1e-12;
int check(int x) {
int l = 1, r = 1000005;
if (x == 0) return 0;
while (l <= r) {
int mid = (l + r) >> 1;
if ((long long)mid * (mid - 1) < (long long)2 * x)
l = mid + 1;
else
r = mid - 1;
}
return l;
}
int main() {
int a, b, c, d;
read(a);
read(b);
read(c);
read(d);
int x = check(a), y = check(d);
if (x == 0 && (b || c)) x = 1;
if (y == 0 && (b || c)) y = 1;
if ((long long)x * (x - 1) != (long long)2 * a ||
(long long)y * (y - 1) != (long long)2 * d ||
(long long)x * y != (long long)b + c)
cout << "Impossible\n";
else {
if (x == 0 && y == 0)
printf("0");
else if (x == 0) {
for (int i = 1; i <= y; i++) printf("1");
} else if (y == 0) {
for (int i = 1; i <= x; i++) printf("0");
} else {
int t = b / y, f = y - b % y;
for (int i = 1; i <= t; i++) printf("0"), x--;
for (int i = 1; i <= f; i++) printf("1"), y--;
if (x > 0) {
printf("0");
x--;
}
for (int i = 1; i <= y; i++) printf("1");
for (int i = 1; i <= x; i++) printf("0");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) x.begin(),x.end()
typedef long long ll;
vector<ll> v(303030);
ll n,k,m,x,y;
string s,t;
int main() {
cin >> n;
ll sum=0;
rep(i,n){
cin >> v[i]; sum+=v[i];
}
ll l=0,ans=1e10;
rep(i,n) l+=v[i],ans=min(abs((sum-l)-l),ans);
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a, b, c, x, y;
cin >> a >> b >> c >> x >> y;
int ans = INT_MAX;
for (int i = 0; i <= 100000; i++)
{
ans = min(ans, i * 2 * c + max(0, x - i) * a + max(0, y - i) * b);
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 2e9;
const int maxn = 20;
pair<int, int> a[maxn], help[maxn];
int bin[maxn];
bool vis[maxn];
int ans = INF;
void pr() {
for (int i = 0; i < maxn; i++) {
help[i] = a[i];
bin[i] = 0;
vis[i] = false;
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
a[i].first++;
}
for (int i = 0; i < (1 << n); i++) {
pr();
int k = 0;
int l = i;
while (l) {
bin[k] = l % 2;
l = l / 2;
k++;
}
int need = 0, point = 0;
for (int j = 0; j < n; j++) {
if (bin[j]) {
need += help[j].second;
vis[j] = true;
help[j].first--;
point++;
}
}
int place = 1;
for (int j = 0; j < n; j++) {
if (help[j].first > point) place++;
if (help[j].first == point && !vis[j]) place++;
}
if (place <= m) ans = min(ans, need);
}
if (ans == INF)
cout << -1;
else
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct __s {
__s() {
if (1) {
ios_base::Init i;
cin.sync_with_stdio(0);
cin.tie(0);
}
}
~__s() {
if (!1)
fprintf(stderr, "Execution time: %.3lf s.\n",
(double)clock() / CLOCKS_PER_SEC);
long long n;
cin >> n;
}
} __S;
long long n, m;
double t, c;
double a[211111];
double sum, mean;
int main(void) {
cin >> n >> t >> c;
for (long long i = 0; i < (long long)(n); i++) {
cin >> a[i];
}
cin >> m;
long long b = 0;
for (long long i = 0; i < (long long)(t); i++) {
sum += a[i];
mean = (mean + a[i] / t) / c;
b++;
}
for (long long i = 0; i < (long long)(m); i++) {
long long tt;
cin >> tt;
while (b != tt) {
sum += a[b];
if (b - t >= 0) sum -= a[b - (long long)t];
mean = (mean + a[b] / t) / c;
b++;
}
double real = sum / t;
printf("%.6f %.6f %.6f\n", real, mean, fabs(real - mean) / real);
}
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main(void){
int a,b;
while(cin >> a >> b) cout << a+b << "\n";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char s[2000006];
char t[1000006];
int len[100005], pos[100005];
vector<pair<int, int>> e;
int main() {
int n;
scanf("%d", &n);
int tp = 0;
for (int i = 0; i < n; i++) {
scanf("%s", t + tp);
len[i] = strlen(t + tp);
pos[i] = tp;
tp += len[i];
int ki;
scanf("%d", &ki);
while (ki--) {
int xij;
scanf("%d", &xij);
e.push_back({xij - 1, i});
}
}
int p = 0;
sort(e.begin(), e.end());
int esz = (int)e.size();
tp = -1;
int te = -1, sp = 0;
while (p < esz) {
int f = e[p].first;
while (sp < f) {
if (tp != -1) {
s[sp++] = t[tp++];
if (tp >= te) tp = te = -1;
} else
s[sp++] = 'a';
}
if (tp == -1) {
tp = pos[e[p].second];
te = pos[e[p].second] + len[e[p].second];
} else if (len[e[p].second] > te - tp) {
tp = pos[e[p].second];
te = pos[e[p].second] + len[e[p].second];
}
while (p + 1 < esz && e[p + 1].first == e[p].first) {
p++;
if (len[e[p].second] > te - tp) {
tp = pos[e[p].second];
te = pos[e[p].second] + len[e[p].second];
}
}
p++;
}
while (tp < te) s[sp++] = t[tp++];
s[sp] = '\0';
printf("%s", s);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int N,i;scanf("%d",&N);
int a[N];
map<int,int> ml,mr;
for(i=0;i<N;i++) scanf("%d",&a[i]);
int ng = 0;vector<int> ans;
for(i=0;i<N;i++){
ml[a[i]]++;
if(ml[a[i]] == mr[a[i]]) ng--;
else if(ml[a[i]]-1 == mr[a[i]]) ng++;
mr[a[N-i-1]]++;
if(ml[a[N-i-1]] == mr[a[N-i-1]]) ng--;
else if(ml[a[N-i-1]] == mr[a[N-i-1]]-1) ng++;
if(ng == 0) ans.push_back(i+1);
}
for(i=0;i<ans.size()-1;i++) printf("%d ",ans[i]);
printf("%d\n",ans.back());
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 2e5 + 5;
vector<pair<pair<int, int>, int>> vp;
int ans[222];
bitset<10000005> bt;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vp.resize(n);
int i = 0;
for (auto& x : vp) cin >> x.first.second >> x.first.first, x.second = i++;
sort(vp.begin(), vp.end());
for (int i = 0; i < n; i++)
for (int j = vp[i].first.second;; j++)
if (!bt[j]) {
bt[j] = 1;
ans[vp[i].second] = j;
break;
}
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[1001];
int dist[1001][1001];
int marked[1001], inpath[1001];
void bfs(int u, int n) {
int s = u;
dist[u][u] = 0;
for (int i = 0; i < 1001; i++) {
marked[i] = 0;
}
marked[u] = true;
queue<int> Q;
Q.push(s);
while (((int)(Q.size()))) {
u = Q.front();
Q.pop();
for (int v : edge[u]) {
if (marked[v]) {
continue;
}
marked[v] = true;
Q.push(v);
dist[s][v] = dist[s][u] + 1;
}
}
}
void initializeDist(int n) {
for (int i = 1; i <= n; i++) {
bfs(i, n);
inpath[i] = false;
}
}
void handleQuery(vector<int> &nodeList, int &p, int &d) {
int m = ((int)(nodeList.size()));
cout << "? " << m;
for (int node : nodeList) {
cout << " " << node;
}
cout << endl;
cin >> p >> d;
}
void initialQuery(int n, int &p, int &d) {
vector<int> nodeList;
for (int i = 1; i <= n; i++) {
nodeList.push_back(i);
}
handleQuery(nodeList, p, d);
}
vector<int> nodeQueryList(int n, int u, int v, int curr, int act) {
int d = (act - curr + 1) / 2;
vector<int> nodeList;
for (int i = 1; i <= n; i++) {
if (inpath[i]) {
continue;
}
if (dist[i][u] == d or dist[i][v] == d) {
nodeList.push_back(i);
}
}
return nodeList;
}
void markPath(int u, int r) {
marked[u] = true;
if (u == r) {
inpath[u] = true;
return;
}
for (int v : edge[u]) {
if (marked[v] or inpath[v]) {
continue;
}
markPath(v, r);
if (inpath[v]) {
inpath[u] = true;
return;
}
}
}
void updatePath(int n, int &u, int &v, int curr, int act, int r) {
int d = (act - curr + 1) / 2;
for (int i = 1; i <= n; i++) {
marked[i] = false;
}
if (dist[r][u] == d) {
markPath(u, r);
u = r;
} else if (dist[r][v] == d) {
markPath(v, r);
v = r;
}
}
bool handleResult(int u, int v) {
string response;
cout << "! " << u << " " << v << endl;
cin >> response;
if (response != "Correct") {
return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, u, v, curr, act;
cin >> n;
for (int i = 1; i <= n; i++) {
edge[i].clear();
}
for (int i = 1; i < n; i++) {
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
initializeDist(n);
initialQuery(n, u, act);
inpath[u] = true;
v = u;
curr = 0;
while (curr < act) {
vector<int> nodeList = nodeQueryList(n, u, v, curr, act);
int r;
handleQuery(nodeList, r, act);
if (r == -1 or act == -1) {
return 0;
}
updatePath(n, u, v, curr, act, r);
curr = dist[u][v];
}
if (!handleResult(u, v)) {
return 0;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;++i)
#define all(x) (x).begin(),(x).end()
using namespace std;
const int INF=1145141919,MOD=1e9+7;
const int64_t LINF=8931145141919364364,LMOD=998244353;
// const int dy[]={0,-1,0,1,1,-1,-1,1};
// const int dx[]={1,0,-1,0,1,1,-1,-1};
int main() {
string keys; cin >> keys;
keys = keys.substr(1);
keys += ".";
vector<string> key;
string tmp;
for(char c : keys) {
if(c == '.') {
key.push_back(tmp);
tmp = "";
} else {
tmp += c;
}
}
// for(string s : key) cerr << s << endl;
int indent = -1;
int idx = 0;
string ans;
while(getline(cin, tmp)) {
if(idx >= (int)key.size()) continue;
try {
int ide = 0;
for(char c : tmp) {
if(c == ' ') {
ide++;
} else {
if(ide <= indent) {
throw "INDENT FALSE";
}
break;
}
}
string tag;
for(int i = ide; i < (int)tmp.size(); ++i) {
if(tmp[i] == ':') break;
tag += tmp[i];
}
if(key[idx] == tag and tag != "") {
indent = ide;
idx++;
}
}
catch(const char* s) {
// fprintf(stderr, "%s\n", s);
continue;
}
if(idx == (int)key.size()) {
bool flg = 0;
for(int i = 0; i < (int)tmp.size(); ++i) {
if(flg) {
ans += tmp[i];
}
if(tmp[i] == ':') {
i++;
flg = 1;
}
}
if(ans != "") {
cout << "string \"" << ans << "\"" << endl;
} else {
cout << "object" << endl;
ans = "!";
}
idx++;
}
}
if(ans == "") {
cout << "no such property" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 3e5 + 1, MOD = 1e9 + 7;
int arr[mxN], n, dp[2][mxN];
void solve() {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i + 2];
for (int i = 0; i < 2; i++)
for (int j = 0; j < n + 2; j++) dp[i][j] = 0;
arr[0] = 1e9;
arr[1] = 1e9;
dp[1][0] = 0;
dp[1][1] = 0;
dp[0][0] = 1e9;
dp[0][1] = 1e9;
for (int i = 2; i <= n + 1; i++) {
dp[1][i] = min(dp[0][i - 2], dp[0][i - 1]);
dp[0][i] = min(dp[1][i - 1] + arr[i], dp[1][i - 2] + arr[i - 1] + arr[i]);
}
cout << min(dp[1][n + 1], dp[0][n + 1]) << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, M, Two = 1, Res = 1;
int main() {
cin >> N >> M;
while (M--) Two = 2 * Two % 1000000009;
for (int i = 1; i <= N; i++) Res = (1LL) * Res * (Two - i) % 1000000009;
cout << Res;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s;cin>>s;int cnt1=0;
for(int i=0;i<s.length();i++)
{
if(s[i]=='x') cnt1++;
}
if(cnt1>=8) cout<<"NO"<<endl;
else cout<<"YES"<<endl;
} | 0 |
#include<cstdio>
#include<queue>
#include<tuple>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int main(){
int h, w; scanf("%d %d", &h, &w);
char s[50][51];
rep(i, h) scanf("%s", s[i]);
int b = 0;
rep(i, h) rep(j, w){
if(s[i][j] == '#') b++;
}
queue<tuple<int, int, int>> q;
q.push(make_tuple(0, 0, 0));
bool flag[50][50] = {};
flag[0][0] = 1;
int res = -1;
while(!q.empty()){
int x, y, t;
tie(y, x, t) = q.front(); q.pop();
if(y == h - 1 && x == w - 1){ res = t; break; }
rep(i, 4){
int ny = y + dy[i], nx = x + dx[i];
if(ny < 0 || ny >= h || nx < 0 || nx >= w || flag[ny][nx] || s[ny][nx] == '#') continue;
q.push(make_tuple(ny, nx, t + 1));
flag[ny][nx] = 1;
}
}
if(res == -1) puts("-1");
else printf("%d\n", h * w - b - res - 1);
return 0;
} | 0 |
#include <bits/stdc++.h>
char s[1000], s1[800];
int a[30];
int main() {
int l, sum, i;
while (gets(s)) {
sum = 0;
memset(a, 0, sizeof(a));
l = strlen(s);
for (i = 0; i < l; i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
a[s[i] - 'a']++;
}
}
for (i = 0; i < 26; i++) {
if (a[i] != 0) {
sum++;
}
}
printf("%d\n", sum);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD=1e9+7;
int n,a,b;
long long poww(long long b,long long p)
{
if(p==0) return 1;
if(p&1) return (b*poww(b,p-1))%MOD;
return poww((b*b)%MOD,p/2);
}
long long nck(int k)
{
long long ans=1;
for(int i=n;i>n-k;i--)
ans=(ans*i)%MOD;
for(int i=2;i<=k;i++)
ans=(ans*poww(i,MOD-2))%MOD;
return ans;
}
int main()
{
cin >> n >> a >> b;
long long ans=(poww(2,n)-1+MOD)%MOD;
ans-=nck(a);
ans-=nck(b);
ans%=MOD;
ans+=MOD;
ans%=MOD;
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd1(long long a, long long b) {
if (a == 0) return b;
return gcd1(b % a, a);
}
long long modx(long long base, long long ex) {
long long ans = 1LL, val = base;
while (ex > 0LL) {
if (ex & 1LL) ans = (ans * val) % 998244353LL;
val = (val * val) % 998244353LL;
ex = ex >> 1LL;
}
return ans;
}
const int maxn = 5e5 + 10;
int a[maxn], n, c;
int pre[maxn], suff[maxn];
int cnt[maxn], ans;
vector<int> v[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> c;
for (int i = 1; i <= n; i++) {
cin >> a[i];
v[a[i]].push_back(i);
if (a[i] == c)
cnt[i] = cnt[i - 1] + 1;
else
cnt[i] = cnt[i - 1];
}
ans = cnt[n];
for (int i = 1; i < maxn; i++) {
if (i == c) continue;
if (v[i].size() == 0) continue;
for (int j = 0; j < v[i].size(); j++) {
pre[j] = cnt[v[i][j]];
pre[j]++;
if (j > 0) pre[j] = max(pre[j], pre[j - 1] + 1);
}
for (int j = v[i].size() - 1; j >= 0; j--) {
suff[j] = cnt[n] - cnt[v[i][j]];
suff[j]++;
if (j + 1 < v[i].size()) suff[j] = max(suff[j], suff[j + 1] + 1);
}
for (int j = 0; j < v[i].size(); j++) {
ans = max(ans, pre[j] + suff[j] - 1);
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double esp = 1e-12;
const double PI = acos(-1.0);
const long long int INF = 0x3f3f3f3f3f3f3f3f;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
int POS;
struct treepo {
static const int MAXN = 100050;
struct SegTree {
int n;
struct Node {
int h[11];
} nd[MAXN << 2];
Node PushUp(Node u, Node v) {
int i = 0, j = 0;
Node w;
memset(w.h, 0, sizeof(w.h));
while (1) {
if (i + j == 11) return w;
if (u.h[i] == 0 && v.h[j] == 0) return w;
if (u.h[i] == 0) {
w.h[i + j] = v.h[j];
j++;
} else if (v.h[j] == 0) {
w.h[i + j] = u.h[i];
i++;
} else {
if (u.h[i] < v.h[j]) {
w.h[i + j] = u.h[i];
i++;
} else {
w.h[i + j] = v.h[j];
j++;
}
}
}
return w;
}
void PushUp(int rt) { nd[rt] = PushUp(nd[rt << 1], nd[rt << 1 | 1]); }
void build(int l, int r, int rt) {
memset(nd[rt].h, 0, sizeof(nd[rt].h));
if (l == r) {
memset(nd[rt].h, 0, sizeof(nd[rt].h));
return;
}
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
PushUp(rt);
}
void build(int n) {
this->n = n;
build(1, n, 1);
}
void update(int L, int c, int l, int r, int rt) {
if (L <= l && r <= L) {
int tem = c;
for (int x = 0; x <= 10; x++)
if (nd[rt].h[x]) {
if (nd[rt].h[x] > c) swap(tem, nd[rt].h[x]);
} else {
swap(tem, nd[rt].h[x]);
break;
}
return;
}
int m = (l + r) >> 1;
if (L <= m) update(L, c, l, m, rt << 1);
if (m < L) update(L, c, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
void update(int L, int c) { update(L, c, 1, n, 1); }
Node query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
return nd[rt];
}
int m = (l + r) >> 1;
Node mc;
memset(mc.h, 0, sizeof(mc.h));
if (L <= m) mc = PushUp(mc, query(L, R, l, m, rt << 1));
if (m < R) mc = PushUp(mc, query(L, R, m + 1, r, rt << 1 | 1));
return mc;
}
Node query(int L, int R) { return query(L, R, 1, n, 1); }
} tr;
struct Edge {
int to, next;
} edge[MAXN * 2];
int head[MAXN], tot;
int top[MAXN];
int fa[MAXN];
int deep[MAXN];
int num[MAXN];
int p[MAXN];
int fp[MAXN];
int son[MAXN];
void init(int n) {
tot = 0;
memset(head, -1, sizeof(head));
POS = 1;
memset(son, -1, sizeof(son));
tr.build(n);
}
void addedge(int u, int v) {
edge[tot].to = v;
edge[tot].next = head[u];
head[u] = tot++;
edge[tot].to = u;
edge[tot].next = head[v];
head[v] = tot++;
}
void dfs1(int u, int pre, int d) {
deep[u] = d;
fa[u] = pre;
num[u] = 1;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (v != pre) {
dfs1(v, u, d + 1);
num[u] += num[v];
if (son[u] == -1 || num[v] > num[son[u]]) son[u] = v;
}
}
}
void dfs1() { dfs1((tr.n + 1) / 2, -1, 0); }
void getPOS(int u, int sp) {
top[u] = sp;
p[u] = POS;
POS++;
fp[p[u]] = u;
if (son[u] == -1) return;
getPOS(son[u], sp);
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (v != son[u] && v != fa[u]) getPOS(v, v);
}
}
void getPOS() { getPOS((tr.n + 1) / 2, (tr.n + 1) / 2); }
SegTree::Node qu(int va, int vb) {
if (va == vb) return tr.query(p[va], p[va]);
SegTree::Node ans;
memset(ans.h, 0, sizeof(ans.h));
int f1 = top[va], f2 = top[vb];
while (f1 != f2) {
if (deep[f1] < deep[f2]) {
swap(f1, f2);
swap(va, vb);
}
ans = tr.PushUp(ans, tr.query(p[f1], p[va]));
va = fa[f1];
f1 = top[va];
}
if (va == vb) return tr.PushUp(ans, tr.query(p[va], p[va]));
if (deep[va] < deep[vb]) swap(va, vb);
return tr.PushUp(ans, tr.query(p[vb], p[va]));
}
} pt;
int main() {
int n, m, q, u, v, tem, a;
scanf("%d%d%d", &n, &m, &q);
pt.init(n);
for (int x = 1; x <= n - 1; x++) {
scanf("%d%d", &u, &v);
pt.addedge(u, v);
}
pt.dfs1();
pt.getPOS();
for (int x = 1; x <= m; x++) {
scanf("%d", &tem);
pt.tr.update(pt.p[tem], x);
}
treepo::SegTree::Node ans;
int len = 0;
for (int x = 1; x <= q; x++) {
len = 0;
scanf("%d%d%d", &u, &v, &a);
ans = pt.qu(u, v);
for (int y = 0; y < a; y++)
if (ans.h[y]) len++;
len = min(len, a);
printf("%d ", len);
for (int y = 0; y < len; y++) printf("%d ", ans.h[y]);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
while (t--) {
int n;
cin >> n;
vector<int> a(n), b(n);
set<int> myset;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
myset.insert(a[i]);
myset.insert(b[i]);
}
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int d = a[i] ^ b[j];
std::set<int>::iterator it;
it = myset.find(d);
if (it != myset.end()) count++;
}
}
if (count % 2 == 0)
cout << "Karen" << endl;
else
cout << "Koyomi" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int num, x, y;
} s[200005];
int n, q, a[200005], pos[200005], maxn, flag[200005], flag1[200005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d", &s[i].num);
if (s[i].num == 1) {
scanf("%d%d", &s[i].x, &s[i].y);
flag1[s[i].x] = 1;
}
if (s[i].num == 2) scanf("%d", &s[i].x);
}
for (int i = q; i >= 1; i--) {
if (s[i].num == 1) {
if (!flag[s[i].x]) {
flag[s[i].x] = 1;
a[s[i].x] = max(s[i].y, maxn);
}
} else
maxn = max(maxn, s[i].x);
}
for (int i = 1; i <= n; i++) {
if (!flag1[i]) a[i] = max(a[i], maxn);
}
for (int i = 1; i < n; i++) printf("%d ", a[i]);
printf("%d\n", a[n]);
}
| 2 |
#include<stdio.h>
int main(){
int x,y,s;
while(1){
scanf("%d%d%d",&x,&y,&s);if(x==0&&y==0&&s==0)break;
int max=0;
int ng=0,mg=0;int n=0,m=0;
int X=100+x,Y=100+y;
for(int i=1;i<s;i++){
ng=i*X/100;n=i*Y/100;
for(int j=1;j<=s-i;j++)
{
mg=j*X/100;m=j*Y/100;
if(ng+mg==s&&n+m>max)max=n+m;
}
}
printf("%d\n",max);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
void print(bool a[1005][1005]) {}
bool check1(bool a[1005][1005]) {
int k = 0;
bool res = 1;
for (int i = 1; i < n - 1 && res; ++i)
for (int j = 1; j < m - 1 && res; ++j)
if (a[i][j]) {
if (a[i + 1][j] && a[i][j + 1]) res = 0;
if (!a[i + 1][j] && !a[i][j + 1]) ++k;
res &= (k <= 1);
}
return res;
}
int reduce1(bool a[1005][1005], bool b[1005][1005]) {
int x[1005] = {};
int y[1005] = {};
for (int i = 1; i < n - 1; ++i)
for (int j = 1; j < m - 1; ++j)
if (a[i][j]) ++x[i];
int xmin = -1;
for (int i = 1; i < n - 1; ++i)
if (x[i] > 0) {
if (xmin == -1)
xmin = x[i];
else
xmin = min(xmin, x[i]);
}
for (int i = 0; i < n; ++i) {
int k = xmin - 1;
for (int j = m - 1; j >= 0; --j)
if (a[i][j])
b[i][j] = (--k < 0);
else
b[i][j] = 0;
}
print(b);
if (check1(b)) return xmin;
int last[1005] = {};
for (int i = 1; i < n - 1; ++i)
for (int j = 1; j < m - 1; ++j)
if (b[i][j]) {
++y[j];
last[j] = i;
}
int ymin = -1;
for (int j = 1; j < m - 1; ++j)
if (y[j] > 0) {
if (ymin == -1)
ymin = y[j];
else
ymin = min(ymin, y[j]);
}
for (int t = 2; t <= ymin; ++t) {
for (int j = 0; j < m; ++j)
if (b[last[j]][j]) b[last[j]--][j] = 0;
print(b);
if (check1(b)) return xmin * t;
}
return -1;
}
int reduce2(bool a[1005][1005], bool b[1005][1005]) {
int x[1005] = {};
int y[1005] = {};
for (int i = 1; i < n - 1; ++i)
for (int j = 1; j < m - 1; ++j)
if (a[i][j]) ++y[j];
int ymin = -1;
for (int j = 1; j < m - 1; ++j)
if (y[j] > 0) {
if (ymin == -1)
ymin = y[j];
else
ymin = min(ymin, y[j]);
}
for (int j = 0; j < m; ++j) {
int k = ymin - 1;
for (int i = n - 1; i >= 0; --i)
if (a[i][j])
b[i][j] = (--k < 0);
else
b[i][j] = 0;
}
print(b);
if (check1(b)) return ymin;
int last[1005] = {};
for (int i = 1; i < n - 1; ++i)
for (int j = 1; j < m - 1; ++j)
if (b[i][j]) {
++x[i];
last[i] = j;
}
int xmin = -1;
for (int i = 1; i < n - 1; ++i)
if (x[i] > 0) {
if (xmin == -1)
xmin = x[i];
else
xmin = min(xmin, x[i]);
}
for (int t = 2; t <= xmin; ++t) {
for (int i = 0; i < n; ++i)
if (b[i][last[i]]) b[i][last[i]--] = 0;
print(b);
if (check1(b)) return ymin * t;
}
return -1;
}
int main() {
cin >> n >> m;
char s[1005][1005];
for (int i = 0; i < n; ++i) cin >> s[i];
bool c[1005][1005];
n += 2;
m += 2;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (i == 0 || j == 0 || i == n - 1 || j == m - 1)
c[i][j] = 0;
else
c[i][j] = (s[i - 1][j - 1] == 'X');
int c1 = 0;
int c2 = 0;
for (int i = 1; i < n - 1; ++i)
for (int j = 1; j < m - 1; ++j) {
if (c[i][j] && !c[i - 1][j] && !c[i][j - 1]) ++c1;
if (c[i][j] && !c[i + 1][j] && !c[i][j + 1]) ++c2;
}
if (c1 > 1 || c2 > 1) {
cout << -1 << "\n";
return 0;
}
bool check = 1;
for (int i = 1; i < n - 1; ++i)
for (int j = 1; j < m - 1; ++j)
if (c[i][j] && c[i + 1][j] && c[i][j + 1]) check &= c[i + 1][j + 1];
if (!check) {
cout << -1 << "\n";
return 0;
}
print(c);
bool a[1005][1005];
bool b[1005][1005];
int r1 = reduce1(c, a);
print(c);
int r2 = reduce2(c, b);
if (check1(a) && check1(b))
cout << min(r1, r2) << "\n";
else if (check1(a))
cout << r1 << "\n";
else if (check1(b))
cout << r2 << "\n";
else
cout << "-1\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
template <typename T>
struct seg_tree {
int S;
T zero;
vector<T> value;
seg_tree<T>(int _S, T _zero = T()) {
S = _S, zero = _zero;
value.resize(2 * S + 1, zero);
}
void set_leaves(vector<T> &leaves) {
copy(leaves.begin(), leaves.end(), value.begin() + S);
for (int i = S - 1; i > 0; i--) value[i] = value[2 * i] + value[2 * i + 1];
}
void upd(int i, T v) {
i += S;
value[i] = v;
while (i > 1) {
i /= 2;
value[i] = value[2 * i] + value[2 * i + 1];
}
}
T query(int i, int j) {
T res_left = zero, res_right = zero;
for (i += S, j += S; i <= j; i /= 2, j /= 2) {
if ((i & 1) == 1) res_left = res_left + value[i++];
if ((j & 1) == 0) res_right = value[j--] + res_right;
}
return res_left + res_right;
}
};
struct seg_tree_vertex {
vector<int> people;
seg_tree_vertex() {}
seg_tree_vertex(vector<int> arg) {
sort(arg.begin(), arg.end());
if (arg.size() > 10) arg.resize(10);
people = arg;
}
seg_tree_vertex operator+(const seg_tree_vertex &v) {
vector<int> res(people.size() + v.people.size());
for (int i = 0; i < people.size(); i++) res[i] = people[i];
for (int j = 0; j < v.people.size(); j++)
res[j + people.size()] = v.people[j];
sort(res.begin(), res.end());
res.resize(unique(res.begin(), res.end()) - res.begin());
if (res.size() > 10) res.resize(10);
return {res};
}
};
int N;
vector<vector<int>> G;
vector<vector<int>> children;
vector<int> parent;
vector<int> time_in, time_out;
vector<vector<int>> paths;
vector<int> path_id, path_offset;
vector<seg_tree<seg_tree_vertex>> trees;
void load() {
G.clear();
G.resize(N);
for (int i = 0; i < N - 1; ++i) {
int x, y;
cin >> x >> y;
x--, y--;
G[x].push_back(y);
G[y].push_back(x);
}
}
vector<int> occupants[MAXN];
void dfs() {
parent.clear();
parent.resize(N);
children.clear();
children.resize(N);
time_in.clear();
time_in.resize(N);
time_out.clear();
time_out.resize(N);
paths.clear();
vector<bool> visited(N, false);
vector<int> walk;
vector<int> subtree_size(N, 0);
int time = 0;
stack<int> vertex, edge;
visited[0] = true;
time_in[0] = time;
parent[0] = 0;
vertex.push(0);
edge.push(0);
while (!vertex.empty()) {
++time;
int kde = vertex.top();
vertex.pop();
int e = edge.top();
edge.pop();
if (e == ((int)((G[kde]).size()))) {
walk.push_back(kde);
time_out[kde] = time;
subtree_size[kde] = 1;
for (int i = 0; i < ((int)((children[kde]).size())); ++i)
subtree_size[kde] += subtree_size[children[kde][i]];
} else {
vertex.push(kde);
edge.push(e + 1);
int kam = G[kde][e];
if (!visited[kam]) {
visited[kam] = true;
time_in[kam] = time;
parent[kam] = kde;
children[kde].push_back(kam);
vertex.push(kam);
edge.push(0);
}
}
}
vector<bool> parent_edge_processed(N, false);
parent_edge_processed[0] = true;
for (int i = 0; i < ((int)((walk).size())); ++i) {
int w = walk[i];
if (parent_edge_processed[w]) continue;
vector<int> this_path;
this_path.push_back(w);
while (1) {
bool is_parent_edge_heavy =
(2 * subtree_size[w] >= subtree_size[parent[w]]);
parent_edge_processed[w] = true;
w = parent[w];
this_path.push_back(w);
if (!is_parent_edge_heavy) break;
if (parent_edge_processed[w]) break;
}
paths.push_back(this_path);
}
path_id.clear();
path_id.resize(N);
path_id[0] = -1;
path_offset.clear();
path_offset.resize(N);
for (int i = 0; i < ((int)((paths).size())); ++i)
for (int j = 0; j < ((int)((paths[i]).size())) - 1; ++j) {
path_id[paths[i][j]] = i;
path_offset[paths[i][j]] = j;
}
trees.clear();
for (int i = 0; i < ((int)((paths).size())); ++i) {
int NV = ((int)((paths[i]).size()));
trees.push_back(seg_tree<seg_tree_vertex>(NV));
vector<seg_tree_vertex> leaves(NV);
for (int j = 0; j < NV; j++) {
leaves[j] = seg_tree_vertex(occupants[paths[i][j]]);
}
trees.back().set_leaves(leaves);
}
}
inline bool is_ancestor(int x, int y) {
return (time_in[y] >= time_in[x] && time_out[y] <= time_out[x]);
}
seg_tree_vertex query(int x, int y) {
if (x == y) return seg_tree_vertex(occupants[x]);
if (is_ancestor(x, y)) return query(y, x);
int p = path_id[x];
int lo = path_offset[x], hi = ((int)((paths[p]).size())) - 1;
if (is_ancestor(paths[p][hi], y)) {
while (hi - lo > 1) {
int med = (hi + lo) / 2;
if (is_ancestor(paths[p][med], y))
hi = med;
else
lo = med;
}
lo = path_offset[x];
}
seg_tree_vertex result = trees[p].query(lo, hi);
return result + query(paths[p][hi], y);
}
int M, Q;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N >> M >> Q;
load();
for (int i = 0; i < M; i++) {
int V;
cin >> V;
if (occupants[V - 1].size() < 10) occupants[V - 1].push_back(i + 1);
}
dfs();
while (Q--) {
int x, y, a;
cin >> x >> y >> a;
x--, y--;
seg_tree_vertex res = query(x, y);
int P = min(a, int(res.people.size()));
cout << P << " ";
for (int i = 0; i < P; i++) {
cout << res.people[i] << " ";
}
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, x, y, c;
cin >> t;
while (t--) {
cin >> x >> y;
if ((x == 1 && x < y) || (x <= 3 && y > 3)) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 5;
long long a[100005] = {0};
struct round {
long long o;
long long r;
long long ind;
long long flag = 0;
bool operator<(const round& b) const { return o < b.o; }
} r[MAXN];
struct point {
long long x;
long long y;
bool operator<(const point& b) const { return x < b.x; }
} p[MAXN];
long long ans[MAXN] = {0};
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a;
b >>= 1;
a = a * a;
}
return ans;
}
double distance(point p, long long o) {
long long x = p.x - o;
long long y = p.y;
return sqrt(x * x + y * y);
}
bool check(double len, long long rr) { return len <= rr; }
int main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> r[i].o >> r[i].r;
r[i].ind = i;
}
long long m;
sort(r + 1, r + n + 1);
cin >> m;
long long cnt = 0;
for (long long i = 1; i <= m; i++) {
cin >> p[i].x >> p[i].y;
long long L = 1;
long long R = n;
while (L <= R) {
long long mid = (L + R) >> 1;
if (r[mid].o > p[i].x)
R = mid - 1;
else
L = mid + 1;
}
if (check(distance(p[i], r[L - 1].o), r[L - 1].r) && !r[L - 1].flag) {
ans[r[L - 1].ind] = i;
r[L - 1].flag = 1;
cnt++;
}
if (check(distance(p[i], r[L].o), r[L].r) && !r[L].flag) {
ans[r[L].ind] = i;
r[L].flag = 1;
cnt++;
}
if (check(distance(p[i], r[L + 1].o), r[L + 1].r) && !r[L + 1].flag &&
L + 1 <= n) {
ans[r[L + 1].ind] = i;
r[L + 1].flag = 1;
cnt++;
}
}
cout << cnt << endl;
for (int i = 1; i <= n; i++) {
if (ans[i] != 0)
cout << ans[i] << " ";
else
cout << -1 << " ";
}
cout << endl;
return 0;
}
| 3 |
Subsets and Splits