solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
#define ll long long
#define R return
#define pb push_back
#define F first
#define S second
#define C continue
#define B break
#define SI size()
using namespace std;
ll a[105];
int main()
{
ll t;
cin>>t;
while(t--)
{
ll n,k,h=1;
cin>>n>>k;
for(ll i=1; i<=n; i++)
cin>>a[i];
ll x=1;
if(n==1){cout<<-1<<endl;C;}
for(ll i=1; i<=k; i++){
for(ll j=1; j<n; j++){
if(a[j]<a[j+1]){
a[j]++;
x=j;
B;
}
else if(j==n-1){
h=0;
B;
}
}
if(h==0)B;
}
if(h==0)cout<<-1<<endl;
else cout<<x<<endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<int> ve[N];
int c[N], du[N][2], n;
unordered_set<int> sd[3];
void add(int u, int v) {
ve[u].push_back(v);
ve[v].push_back(u);
du[u][0]++;
du[v][0]++;
}
int tik(int cc) {
int s = 0;
for (int i = 0; i < 3; i++) sd[i].clear();
for (int i = 1; i <= n; i++) {
du[i][1] = du[i][0];
if (du[i][1] == 1) sd[c[i]].insert(i);
}
while (1) {
while (sd[cc].size() || sd[0].size()) {
int k = 0;
if (sd[cc].size()) {
k = *sd[cc].begin();
sd[cc].erase(sd[cc].begin());
} else if (sd[0].size()) {
k = *sd[0].begin();
sd[0].erase(sd[0].begin());
}
for (int t : ve[k]) {
du[t][1]--;
if (du[t][1] == 1) {
sd[c[t]].insert(t);
}
}
}
cc = 3 - cc;
s++;
if (sd[cc].empty() && sd[0].empty()) break;
}
return s;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
du[i][0] = du[i][1] = 0;
ve[i].clear();
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
}
int ans = min(tik(1), tik(2));
printf("%d\n", ans);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long arr[111111];
for (__typeof(n) i = 0; i < n; i++) {
cin >> arr[i];
}
set<pair<long long, long long> > finder;
vector<long long> ans(n, -2);
for (__typeof(n - 1) i = n - 1; i >= 0; i--) {
if (finder.size() == 0) {
finder.insert(make_pair(arr[i], i));
ans[i] = -1;
} else {
if (finder.begin()->first > arr[i]) {
finder.insert(make_pair(arr[i], i));
ans[i] = -1;
} else {
set<pair<long long, long long> >::iterator it =
finder.lower_bound(make_pair(arr[i], -1));
if (it == finder.begin())
ans[i] = -1;
else {
it--;
ans[i] = it->second - 1 - i;
}
}
}
}
for (__typeof(n) i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
unsigned long long a, b;
int data[2][maxn], ans[2][maxn];
void getbin(unsigned long long x, int flag) {
while (x) {
data[flag][++data[flag][0]] = x % 2;
x /= 2;
}
}
unsigned long long getnum(int flag, int len) {
unsigned long long ret = 0;
for (int i = len; i > 0; i--) ret = ret * 2 + ans[flag][i];
return ret;
}
int main() {
cin >> a >> b;
getbin(a, 0);
getbin(b, 1);
int len = max(data[0][0], data[1][0]), flag = 0;
for (int i = 1; i <= len && !flag; i++) {
int x = data[0][i], y = data[1][i];
if (x == y) {
if (!x)
ans[0][i] = ans[1][i] = 0;
else {
ans[0][i] = 0;
ans[1][i] = 1;
}
} else if (!x) {
if (i == 1) flag = 1;
if (ans[0][i - 1] == ans[1][i - 1] && !ans[0][i - 1]) {
ans[0][i] = 0;
ans[1][i] = 1;
ans[0][i - 1] = ans[1][i - 1] = 1;
data[0][i + 1]--;
int j = i + 1;
while (data[0][j] < 0 && j <= len) {
data[0][j] += 2;
data[0][++j]--;
}
if (j > len) flag = 1;
}
} else {
if (i == 1) flag = 1;
if (ans[0][i - 1] == ans[1][i - 1] && !ans[0][i - 1]) {
ans[0][i - 1] = ans[1][i - 1] = 1;
ans[0][i] = ans[1][i] = 0;
} else
flag = 1;
}
}
if (flag)
printf("-1\n");
else {
cout << getnum(0, len) << " " << getnum(1, len) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
#pragma GCC target("avx")
using namespace std;
inline char gc() {
static char buf[1 << 16], *p1 = buf, *p2 = buf;
if (p1 == p2) {
p2 = (p1 = buf) + fread(buf, 1, 1 << 16, stdin);
if (p2 == p1) return EOF;
}
return *p1++;
}
template <class t>
inline t read(t &x) {
char c = gc();
bool f = 0;
x = 0;
while (!isdigit(c)) f |= c == '-', c = gc();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = gc();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 205, M = 3e5 + 5;
int en = 1, h[N], cur[N], d[N], n, m, a[N];
vector<vector<int> > ans;
vector<int> vec, odd, even;
bool v[N];
struct edge {
int n, v, w;
} e[M << 1];
void add(int x, int y, int z) {
e[++en] = (edge){h[x], y, z};
h[x] = en;
}
bool bfs(int s, int aim) {
memset(d, 0, sizeof d);
memcpy(cur, h, sizeof cur);
queue<int> q;
q.push(s);
d[s] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = h[x]; i; i = e[i].n) {
int y = e[i].v;
if (!d[y] && e[i].w) {
d[y] = d[x] + 1;
if (y == aim) return 1;
q.push(y);
}
}
}
return 0;
}
int dfs(int x, int flow, int aim) {
if (x == aim) return flow;
int rest = flow;
for (int &i = cur[x]; i && rest; i = e[i].n) {
int y = e[i].v;
if (d[y] == d[x] + 1 && e[i].w) {
int tp = dfs(y, min(rest, e[i].w), aim);
rest -= tp;
e[i].w -= tp;
e[i ^ 1].w += tp;
}
}
return flow - rest;
}
int dinic(int s, int t) {
int res = 0;
while (bfs(s, t)) res += dfs(s, INT_MAX, t);
return res;
}
void exadd(int x, int y, int f) {
add(x, y, f);
add(y, x, 0);
}
bool isprime(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return 0;
return 1;
}
void go(int x) {
v[x] = 1;
vec.push_back(x);
for (int i = h[x]; i; i = e[i].n) {
int y = e[i].v;
if (v[y]) continue;
if (!e[i ^ (a[x] & 1)].w) continue;
go(y);
break;
}
}
signed main() {
read(n);
for (int i = 1; i <= n; i++) {
read(a[i]);
if (a[i] & 1)
odd.push_back(i), exadd(0, i, 2);
else
even.push_back(i), exadd(i, n + 1, 2);
}
if (odd.size() != even.size()) {
puts("Impossible");
return 0;
}
for (int x : odd)
for (int y : even)
if (isprime(a[x] + a[y])) exadd(x, y, 1);
if (dinic(0, n + 1) != n) {
puts("Impossible");
return 0;
}
v[0] = v[n + 1] = 1;
for (int x : odd)
if (!v[x]) {
vec.clear();
go(x);
ans.push_back(vec);
}
write(ans.size());
puts("");
for (auto a : ans) {
write(a.size());
putchar(' ');
for (int x : a) write(x), putchar(' ');
puts("");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int Mod = 100000000;
map<pair<long long int, long long int>, int> hmp;
queue<pair<long long int, long long int> > Q;
map<pair<long long int, long long int>, long long int> visited;
int main() {
long long int i, j, k, l, m, n, x, y, z, a, b, r, t, x0, y0, x1, y1,
a1 = 0, a2 = 0, a3 = 0;
scanf("%lld", &x0);
scanf("%lld", &y0);
scanf("%lld", &x1);
scanf("%lld", &y1);
scanf("%lld", &n);
for (i = 0; i < n; i++) {
scanf("%lld", &r);
scanf("%lld", &a);
scanf("%lld", &b);
for (j = a; j <= b; j++) {
hmp[make_pair(r, j)] = 1;
}
}
Q.push(make_pair(x0, y0));
visited[make_pair(x0, y0)] = 1;
long long int ans = 0;
while (!Q.empty()) {
pair<long long int, long long int> p = Q.front();
Q.pop();
a3 = 0;
for (i = -1; i < 2; i++) {
for (j = -1; j < 2; j++) {
x = p.first + i;
y = p.second + j;
if (hmp[make_pair(x, y)] == 1) {
if (!visited[make_pair(x, y)]) {
visited[make_pair(x, y)] = visited[p] + 1;
Q.push(make_pair(x, y));
}
}
if (hmp[make_pair(x, y)] != 1) {
continue;
}
}
}
}
if (!visited[make_pair(x1, y1)]) {
printf("-1\n");
return 0;
}
printf("%lld\n", visited[make_pair(x1, y1)] - 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, f, i;
cin >> n;
if (n % 3 == 0)
i = n / 3;
else {
if (n % 3 == 1)
i = n / 3;
else
i = n / 3 + 1;
}
f = i / 12;
i = i % 12;
cout << f << " " << i;
return (0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 5;
const int mod = 1000000000;
int a[N], f[N];
int main() {
int n, m, type, x, v, l, r, d, sum;
scanf("%d%d", &n, &m);
f[0] = f[1] = 1;
for (int i = 2; i < n; ++i) f[i] = (f[i - 1] + f[i - 2]) % mod;
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < m; ++i) {
scanf("%d", &type);
if (type == 1) {
scanf("%d%d", &x, &v);
x--;
a[x] = v;
} else if (type == 2) {
scanf("%d%d", &l, &r);
sum = 0;
r--;
l--;
for (int j = 0; j <= r - l; ++j) {
sum = (sum + (long long)(f[j]) * (long long)(a[l + j])) % mod;
}
cout << sum << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int dr[] = {1, 0, -1, 0};
int dc[] = {0, 1, 0, -1};
int drow[] = {1, 1, 1, 0, -1, -1, -1, 0};
int dcol[] = {1, 0, -1, -1, -1, 0, 1, 1};
int main() {
int n, k;
int f[100010];
for (int i = 0; i < 100001; i++) f[i] = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
f[i % k] += x;
}
int ans = INT_MAX;
int pos = 0;
for (int i = k - 1; i >= 0; i--) {
if (ans >= f[i]) {
ans = f[i];
pos = i;
}
}
cout << pos + 1 << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 3;
struct node {
int sum;
node *izq, *der;
node() {
sum = 0;
izq = der = NULL;
}
};
typedef node *pnode;
int clsright[maxn];
int lastap[maxn];
int v[maxn];
int n, ini, fin, cnt, mid;
pnode tree[maxn];
pnode build(int l, int r) {
pnode nodo = new node();
if (l == r) {
nodo->sum = (lastap[v[l]] == l);
return nodo;
}
int md = (l + r) / 2;
nodo->izq = build(l, md);
nodo->der = build(md + 1, r);
nodo->sum = nodo->izq->sum + nodo->der->sum;
return nodo;
}
pnode upd(const pnode ori, int l, int r, int p) {
if (l > p || r < p) return ori;
pnode nodo = new node();
if (l == r) {
nodo->sum = 1;
return nodo;
}
int md = (l + r) / 2;
nodo->izq = upd(ori->izq, l, md, p);
nodo->der = upd(ori->der, md + 1, r, p);
nodo->sum = nodo->izq->sum + nodo->der->sum;
return nodo;
}
pair<int, int> get(const pnode ori, int l, int r, int wantsum, int p) {
int md = (l + r) / 2;
if (r < p) {
return {0, 0};
}
if (l == r) {
return {l, ori->sum};
}
if (l >= p) {
if (ori->sum <= wantsum) return {r, ori->sum};
if (ori->izq->sum <= wantsum) {
auto rchild = get(ori->der, md + 1, r, wantsum - ori->izq->sum, p);
return {rchild.first, ori->izq->sum + rchild.second};
}
}
auto lchild = get(ori->izq, l, md, wantsum, p);
if (lchild.second > wantsum) {
return lchild;
}
auto rchild = get(ori->der, md + 1, r, wantsum - lchild.second, p);
return {rchild.first, rchild.second + lchild.second};
}
int lastopt[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &v[i]);
lastap[v[i]] = n + 1;
}
for (int i = n; i >= 1; i--) {
clsright[i] = lastap[v[i]];
lastap[v[i]] = i;
}
tree[0] = build(1, n);
for (int i = 1; i <= n; i++) {
if (i == 1 || clsright[i - 1] == n + 1)
tree[i] = tree[i - 1];
else
tree[i] = upd(tree[i - 1], 1, n, clsright[i - 1]);
}
for (int k = 1; k <= n; k++) {
cnt = 0;
for (int i = 1; i <= n;) {
cnt++;
auto x = get(tree[i], 1, n, k, i);
if (x.second <= k) break;
i = x.first;
}
printf("%d ", cnt);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 550;
const long long mod = 1e9 + 7;
int n, a[maxn], sz;
long long dp[305][305], cnt[305], vis[305];
bool check(long long x) {
long long l = 1, r = 1e9;
while (l <= r) {
long long mid = (l + r) / 2;
if (mid * mid == x)
return true;
else if (mid * mid < x)
l = mid + 1;
else
r = mid - 1;
}
return false;
}
inline long long quick_pow(long long x, int p) {
long long res = 1;
while (p) {
if (p & 1) res = (res * x) % mod;
x = (x * x) % mod, p >>= 1;
}
return res;
}
inline long long inv(long long a) {
long long inv_a = quick_pow(a, mod - 2);
return inv_a;
}
long long F[maxn], Finv[maxn];
void init() {
F[0] = Finv[0] = 1ll;
for (int i = 1; i <= maxn - 500; i++) {
F[i] = F[i - 1] * 1ll * (long long)i % mod;
Finv[i] = Finv[i - 1] * 1ll * inv(i) % mod;
}
}
long long C(long long n, long long m) {
if (m < 0 || m > n) return 0;
return F[n] * 1ll * Finv[n - m] % mod * Finv[m] % mod;
}
int main() {
cin >> n;
init();
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
++sz, cnt[sz] = 1, vis[i] = true;
for (int j = 1; j <= n; j++) {
if (vis[j]) continue;
if (!check(1ll * a[i] * a[j])) continue;
cnt[sz]++;
vis[j] = true;
}
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
int m = 0;
for (int i = 1; i <= sz; i++) {
for (int j = 0; j <= m; j++) {
for (int q = 1; q <= cnt[i]; q++) {
for (int p = 0; p <= j; p++) {
int k = j - p + cnt[i] - q;
dp[i][k] += dp[i - 1][j] * C(cnt[i] - 1, q - 1) % mod * C(j, p) %
mod * C(m + 1 - j, q - p) % mod * F[cnt[i]] % mod;
dp[i][k] %= mod;
}
}
}
m += cnt[i];
}
cout << dp[sz][0] << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
unordered_set<int> dp[N];
int main() {
int n, k;
scanf("%d%d", &n, &k);
dp[0].insert(0);
for (int i = 0; i < n; ++i) {
int c;
scanf("%d", &c);
for (int j = k; j >= c; --j) {
for (int l : dp[j - c]) dp[j].insert(l);
for (int l : dp[j - c]) dp[j].insert(l + c);
if (dp[j].size() > 0) dp[j].insert(j);
}
}
printf("%d\n", dp[k].size());
vector<int> res;
for (int l : dp[k]) res.push_back(l);
sort(res.begin(), res.end());
for (int l : res) printf("%d ", l);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m;
char a[2002][2002];
vector<pair<int, int>> pos[30];
int main() {
cin >> t;
while (t--) {
bool ans = 1;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf(" %c", a[i] + j);
for (int i = 0; i < 26; i++) pos[i].clear();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] != '.') pos[a[i][j] - 'a'].push_back(make_pair(i, j));
int cnt = 0;
for (int i = 0; i < 26 && ans; i++) {
if (pos[i].size() == 0) continue;
cnt = i + 1;
sort(pos[i].begin(), pos[i].end());
if (min(abs(pos[i][0].first - pos[i].back().first),
abs(pos[i][0].second - pos[i].back().second)) != 0)
ans = 0;
for (int j = 1; j < pos[i].size() - 1; j++)
if (pos[i][j].second < pos[i][0].second ||
pos[i][j].second > pos[i].back().second)
ans = 0;
for (int y = pos[i][0].first; y <= pos[i].back().first; y++)
for (int x = pos[i][0].second; x <= pos[i].back().second; x++)
if (a[y][x] == '.') ans = 0;
for (int j = 0; j < pos[i].size(); j++)
a[pos[i][j].first][pos[i][j].second] = '.';
}
if (ans) {
for (int i = cnt - 2; i >= 0; i--)
if (pos[i].empty()) pos[i] = pos[i + 1];
printf("YES\n");
printf("%d\n", cnt);
for (int i = 0; i < cnt; i++) {
printf("%d %d %d %d\n", pos[i][0].first, pos[i][0].second,
pos[i].back().first, pos[i].back().second);
}
} else
printf("NO\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, r;
cin >> n >> r;
if (n > r) {
cout << (r * (r + 1)) / 2 << endl;
} else {
cout << (n * (n - 1)) / 2 + 1 << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
getline(cin, s);
int n = 0;
char x = '1';
for (int i = 0; i < s.length(); i++) {
if (isalpha(s[i])) {
n++;
for (int j = i + 1; j < s.length(); j++) {
if (s[i] == s[j]) {
s[j] = x;
}
}
}
}
cout << n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int get_int() {
int x = 0;
char c;
for (c = getchar(); c != '-' && (c < '0' || c > '9'); c = getchar())
;
int t = 0;
if (c == '-') {
t = 1;
c = getchar();
}
for (; c >= '0' && c <= '9'; c = getchar()) {
x *= 10;
x += c - 48;
}
if (t) x = -x;
return x;
}
int n, tot;
long long k;
long long sum[100050], sum_[100050];
int s[100050];
void init() {
n = get_int();
scanf("%I64d", &k);
for (int i = 1; i <= n; i++) sum_[i] = sum[i] = sum[i - 1] + get_int();
}
void bd() {
sort(sum_, sum_ + n + 1);
tot = 0;
for (int i = 1; i <= n; i++)
if (sum_[i] != sum_[i - 1]) {
tot++;
sum_[tot] = sum_[i];
}
for (int i = 0; i <= n; i++) {
int left = 0, right = tot, mid;
while (1) {
mid = (left + right) / 2;
if (sum[i] == sum_[mid]) {
sum[i] = mid + 1;
break;
}
if (sum[i] > sum_[mid])
left = mid + 1;
else
right = mid - 1;
}
}
}
int get(long long v) {
int left = 0, right = tot, mid;
for (int _ = 1; _ <= 20; _++) {
mid = (left + right) / 2;
if (v > sum_[mid])
left = mid;
else
right = mid;
}
for (int _ = min(tot, mid + 2); _ >= max(0, mid - 2); _--)
if (v >= sum_[_]) return _ + 1;
return 0;
}
int tree[400050];
void put(int v, int s, int t, int x) {
if (s == t) {
tree[v]++;
return;
}
int mid = (s + t) / 2;
if (x <= mid) put(v * 2, s, mid, x);
if (x >= mid + 1) put(v * 2 + 1, mid + 1, t, x);
tree[v] = tree[v * 2] + tree[v * 2 + 1];
}
long long ask(int v, int s, int t, int l, int r) {
if (s >= l && t <= r) return tree[v];
int mid = (s + t) / 2;
long long ans = 0;
if (mid >= l) ans += ask(v * 2, s, mid, l, r);
if (mid + 1 <= r) ans += ask(v * 2 + 1, mid + 1, t, l, r);
return ans;
}
long long check(long long v) {
long long ans = 0;
memset(tree, 0, sizeof(tree));
put(1, 1, tot + 1, sum[0]);
for (int j = 1; j <= n; j++) {
long long gt = sum_[sum[j] - 1] - v;
int g_t = get(gt);
if (g_t != 0) ans += ask(1, 1, tot + 1, 1, g_t);
put(1, 1, tot + 1, sum[j]);
}
return ans;
}
long long inf = (1 << 30);
void work() {
inf = inf * inf;
long long left = -inf, right = inf, mid;
for (int _ = 1; _ <= 61; _++) {
mid = (left + right) / 2;
if (check(mid) >= k)
left = mid;
else
right = mid;
}
for (long long _ = mid - 5; _ <= mid + 5; _++)
if (check(_ + 1) < k && check(_) >= k) {
printf("%I64d\n", _);
return;
}
printf("%I64d", mid);
}
int main() {
init();
bd();
work();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, q;
long long x[(long long)3e5 + 7], y[(long long)3e5 + 7];
long long b[(long long)3e5 + 7];
long long l[(long long)3e5 + 7], r[(long long)3e5 + 7];
long long safel[(long long)3e5 + 7], safer[(long long)3e5 + 7];
bool safe[(long long)3e5 + 7];
long long dp[(long long)3e5 + 7][5];
long long pos[(long long)3e5 + 7][5];
int main() {
scanf("%lld%lld%lld%lld", &n, &m, &k, &q);
for (long long i = 1; i <= n; i++) {
l[i] = LONG_LONG_MAX;
r[i] = 0;
}
for (long long i = 1; i <= k; i++) {
scanf("%lld%lld", &x[i], &y[i]);
r[x[i]] = max(y[i], r[x[i]]);
l[x[i]] = min(y[i], l[x[i]]);
}
for (long long i = 1; i <= q; i++) {
scanf("%lld", &b[i]);
safe[b[i]] = true;
}
for (long long i = 1; i <= m; i++) {
if (safe[i] == true) {
safel[i] = i;
} else {
safel[i] = safel[i - 1];
}
}
for (long long i = m; i >= 1; i--) {
if (safe[i] == true) {
safer[i] = i;
} else {
safer[i] = safer[i + 1];
}
}
if (r[1] == 0 && l[1] == LONG_LONG_MAX) {
l[1] = 1;
r[1] = 1;
} else {
dp[1][1] = (r[1] - l[1]) + r[1] - 1;
dp[1][2] = r[1] - 1;
}
bool flag[(long long)3e5 + 7];
for (long long i = 2; i <= n; i++) {
flag[i] = false;
dp[i][1] = LONG_LONG_MAX;
dp[i][2] = LONG_LONG_MAX;
if (l[i] == LONG_LONG_MAX && r[i] == 0) {
if (dp[i - 1][1] != LONG_LONG_MAX) {
dp[i][1] = dp[i - 1][1] + 1;
}
if (dp[i - 1][2] != LONG_LONG_MAX) {
dp[i][2] = dp[i - 1][2] + 1;
}
l[i] = l[i - 1];
r[i] = r[i - 1];
flag[i] = true;
continue;
}
if (l[i - 1] != LONG_LONG_MAX) {
if (safel[l[i]] - safel[l[i - 1] - 1] != 0) {
dp[i][2] = min(dp[i][2],
dp[i - 1][1] + abs(l[i] - l[i - 1]) + (r[i] - l[i]) + 1);
}
if (safel[min(l[i], l[i - 1])] != 0) {
dp[i][2] =
min(dp[i][2],
dp[i - 1][1] + abs(l[i] - l[i - 1]) +
abs(min(l[i], l[i - 1]) - safel[min(l[i], l[i - 1])]) * 2 +
(r[i] - l[i]) + 1);
}
if (safer[max(l[i], l[i - 1])] != 0) {
dp[i][2] = min(
dp[i][2],
dp[i - 1][1] + abs(l[i] - l[i - 1]) + (r[i] - l[i]) +
abs(max(l[i], l[i - 1]) - safer[max(l[i], l[i - 1])]) * 2 + 1);
}
}
if (r[i - 1] != 0) {
if (safel[r[i]] - safel[r[i - 1] - 1] != 0) {
dp[i][1] = min(dp[i][1],
dp[i - 1][2] + abs(r[i] - r[i - 1]) + (r[i] - l[i]) + 1);
}
if (safel[min(r[i], r[i - 1])] != 0) {
dp[i][1] =
min(dp[i][1],
dp[i - 1][2] + abs(r[i] - r[i - 1]) +
abs(min(r[i], r[i - 1]) - safel[min(r[i], r[i - 1])]) * 2 +
(r[i] - l[i]) + 1);
}
if (safer[max(r[i], r[i - 1])] != 0) {
dp[i][1] = min(
dp[i][1],
dp[i - 1][2] + abs(r[i] - r[i - 1]) + (r[i] - l[i]) +
abs(max(r[i], r[i - 1]) - safer[max(r[i], r[i - 1])]) * 2 + 1);
}
}
if (l[i - 1] != LONG_LONG_MAX) {
if (safel[r[i]] - safel[l[i - 1] - 1] != 0) {
dp[i][1] = min(dp[i][1],
dp[i - 1][1] + abs(r[i] - l[i - 1]) + (r[i] - l[i]) + 1);
}
if (safel[min(r[i], l[i - 1])] != 0) {
dp[i][1] =
min(dp[i][1],
dp[i - 1][1] + abs(r[i] - l[i - 1]) +
abs(min(r[i], l[i - 1]) - safel[min(r[i], l[i - 1])]) * 2 +
(r[i] - l[i]) + 1);
}
if (safer[max(r[i], l[i - 1])] != 0) {
dp[i][1] = min(
dp[i][1],
dp[i - 1][1] + abs(r[i] - l[i - 1]) + (r[i] - l[i]) +
abs(max(r[i], l[i - 1]) - safer[max(r[i], l[i - 1])]) * 2 + 1);
}
}
if (r[i - 1] != 0) {
if (safel[l[i]] - safel[r[i - 1] - 1] != 0) {
dp[i][2] = min(dp[i][2],
dp[i - 1][2] + abs(l[i] - r[i - 1]) + (r[i] - l[i]) + 1);
}
if (safel[min(l[i], r[i - 1])] != 0) {
dp[i][2] =
min(dp[i][2],
dp[i - 1][2] + abs(l[i] - r[i - 1]) +
abs(min(l[i], r[i - 1]) - safel[min(l[i], r[i - 1])]) * 2 +
(r[i] - l[i]) + 1);
}
if (safer[max(l[i], l[i - 1])] != 0) {
dp[i][2] = min(
dp[i][2],
dp[i - 1][2] + abs(l[i] - r[i - 1]) + (r[i] - l[i]) +
abs(max(l[i], r[i - 1]) - safer[max(l[i], r[i - 1])]) * 2 + 1);
}
}
}
while (flag[n] == true) {
n -= 1;
}
printf("%lld", min(dp[n][1], dp[n][2]));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dp[2][23000][152];
int n, s, m;
int a[151];
int main() {
scanf("%d%d%d", &n, &m, &s);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
s = min(s, n * n);
memset(dp, 0x3f, sizeof(dp));
int h = 1;
dp[h][0][0] = 0;
for (int i = n; i >= 1; i--, h ^= 1) {
for (int j = s; j >= 0; j--) {
for (int k = 0; k <= m; k++) {
dp[h ^ 1][j][k] = dp[h][j][k];
if (k - 1 < 0 || j - (i - m + k - 1) < 0) continue;
dp[h ^ 1][j][k] =
min(dp[h ^ 1][j][k], dp[h][j - (i - m + k - 1)][k - 1] + a[i]);
}
}
memset(dp[h], 0x3f, sizeof(dp[h]));
}
int ans = 999999999;
for (int i = 0; i <= s; i++) {
ans = min(ans, dp[h][i][m]);
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a1, b1, a2, b2, a3, b3;
int max(int a, int b) {
if (a > b)
return a;
else
return b;
}
int main() {
int u, v, x, y;
cin >> a1 >> b1 >> a2 >> b2 >> a3 >> b3;
x = a2 + a3;
y = max(b2, b3);
if (x <= a1 && y <= b1 || x <= b1 && y <= a1) {
cout << "YES";
return 0;
}
x = b2 + b3;
y = max(a2, a3);
if (x <= a1 && y <= b1 || x <= b1 && y <= a1) {
cout << "YES";
return 0;
}
x = a2 + b3;
y = max(b2, a3);
if (x <= a1 && y <= b1 || x <= b1 && y <= a1) {
cout << "YES";
return 0;
}
x = b2 + a3;
y = max(b3, a2);
if (x <= a1 && y <= b1 || x <= b1 && y <= a1) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string ch, ch1 = "";
cin >> ch;
for (int i = 0; i < ch.length(); i++) {
if (ch1.find(ch[i]) == std::string::npos) ch1 = ch1 + ch[i];
}
if (ch1.length() % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << n / 2 << endl;
} else {
cout << n / 2 + 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
unsigned int n;
scanf("%u", &n);
unsigned short a[n];
unsigned register int c1 = 0, c2 = 0;
for (unsigned register int i = 0; i < n; i++) {
scanf("%hu", &a[i]);
c1 += a[i] == 1;
c2 += a[i] == 0;
}
for (unsigned register int i = 0; i < n; i++) {
c1 -= a[i] == 1;
c2 -= a[i] == 0;
if (!c1 + !c2) {
printf("%u\n", i + 1);
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
template <class T>
void chmax(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
a = min(a, b);
}
int N, num[30], cnt;
string s;
int main() {
cin >> s >> N;
for (int i = 0; i < (s.size()); i++) {
int c = s[i] - 'a';
if (!num[c]) ++cnt;
++num[c];
}
if (cnt > N) {
cout << -1 << endl;
return 0;
}
int be = 1, en = s.size(), res = s.size();
while (be <= en) {
int m = (be + en) / 2;
cnt = 0;
for (int i = 0; i < (30); i++) cnt += (num[i] + m - 1) / m;
if (cnt <= N) {
res = m;
en = m - 1;
} else
be = m + 1;
}
cout << res << endl;
string s2;
for (int i = 0; i < (30); i++) {
char c = 'a' + i;
cnt = (num[i] + res - 1) / res;
while (cnt--) s2 += c;
}
while (s2.size() < N) s2 += 'x';
cout << s2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int D[5002][5002];
int SumMod(int x, int y) {
int rez = x + y;
while (rez >= 1000000007) rez -= 1000000007;
while (rez < 0) rez += 1000000007;
return rez;
}
int main() {
int N, A, B, K;
scanf("%d%d%d%d", &N, &A, &B, &K);
A--;
B--;
D[0][A] = 1;
for (int i = 0; i < K; ++i) {
for (int j = 0; j < N; ++j) {
int dif = abs(j - B);
D[i + 1][max(j - dif + 1, 0)] =
SumMod(D[i + 1][max(j - dif + 1, 0)], D[i][j]);
D[i + 1][min(j + dif, 5002 - 1)] =
SumMod(D[i + 1][min(j + dif, 5002 - 1)], -D[i][j]);
}
for (int j = 1; j < N; ++j)
D[i + 1][j] = SumMod(D[i + 1][j], D[i + 1][j - 1]);
for (int j = 0; j < N; ++j) D[i + 1][j] = SumMod(D[i + 1][j], -D[i][j]);
}
int sol = 0;
for (int j = 0; j < N; ++j) sol = SumMod(sol, D[K][j]);
printf("%d", sol);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
int mx = -1;
vector<int> a((n << 1)), tm;
vector<bool> point(n << 1);
for (int i = 0; i < (n << 1); ++i) {
cin >> a[i];
if (a[i] > mx) point[i] = 1, mx = a[i];
}
int tmp_cnt = 0;
for (int i = (n << 1) - 1; i >= 0; --i) {
++tmp_cnt;
if (point[i]) {
tm.emplace_back(tmp_cnt);
tmp_cnt = 0;
}
}
vector<bool> f((n << 1) + 1);
f[0] = 1;
for (int i = 0; i < (int)tm.size(); ++i) {
for (int j = (n << 1) - tm[i]; j >= 0; --j) {
if (f[j]) f[j + tm[i]] = 1;
}
}
if (f[n])
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int bsf(int x) { return __builtin_ctz(x); }
int bsr(int x) { return 31 - __builtin_clz(x); }
using namespace std;
const double pi = 3.14159265358979323846;
const int inf = (int)2e+9 + 2;
const int mod = (int)1e+9 + 7;
const double eps = 1e-8;
const int N = 200000;
int n, m, k;
vector<vector<int>> a;
int s[N];
void solve() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; ++i) {
cin >> k;
a[i].resize(k);
for (int j = 0; j < k; ++j) {
cin >> a[i][j];
s[i] += a[i][j];
}
}
map<int, int> mp;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < static_cast<int>(a[i].size()); ++j) {
int val = s[i] - a[i][j];
if (auto it = mp.find(val); it != mp.end() && it->second != i) {
cout << "YES\n";
cout << i + 1 << ' ' << j + 1 << '\n';
for (int q = 0; q < static_cast<int>(a[it->second].size()); ++q) {
if (s[it->second] - a[it->second][q] == val) {
cout << it->second + 1 << ' ' << q + 1;
break;
}
}
return;
} else {
mp.emplace(val, i);
}
}
}
cout << "NO";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int test = 1;
for (; test; --test) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T>
void ndarray(vector<T> &vec, int len) {
vec.resize(len);
}
template <typename T, typename... Args>
void ndarray(vector<T> &vec, int len, Args... args) {
vec.resize(len);
for (auto &v : vec) ndarray(v, args...);
}
template <typename T>
bool mmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T>
bool mmin(T &m, const T q) {
if (m > q) {
m = q;
return true;
} else
return false;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec) os << v << ",";
os << "]";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "deq[";
for (auto v : vec) os << v << ",";
os << "]";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &vec) {
os << "{";
for (auto v : vec) os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &vec) {
os << "{";
for (auto v : vec) os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &vec) {
os << "{";
for (auto v : vec) os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) {
os << "{";
for (auto v : vec) os << v << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << "(" << pa.first << "," << pa.second << ")";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
os << "{";
for (auto v : mp) os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) {
os << "{";
for (auto v : mp) os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename T>
struct SegTree {
int N;
int head;
vector<T> x;
T defaultT;
using func = function<T(const T &, const T &)>;
func merger;
T _get(int begin, int end, int pos, int l, int r) const {
if (r <= begin or l >= end) return defaultT;
if (l >= begin and r <= end) return x[pos];
return merger(_get(begin, end, 2 * pos + 1, l, (l + r) / 2),
_get(begin, end, 2 * pos + 2, (l + r) / 2, r));
}
SegTree(int N, T defaultT, func merger)
: N(N), defaultT(defaultT), merger(merger) {
int N_tmp = 1;
while (N_tmp < N) N_tmp <<= 1;
x = vector<T>(N_tmp * 2, defaultT), head = N_tmp - 1;
}
SegTree() : SegTree(0, T(), [](T, T) { return T(); }) {}
void build(const vector<T> &vals) {
for (int i = (0), i_end_ = (vals.size()); i < i_end_; i++)
x[head + i] = vals[i];
for (int i = (head)-1, i_begin_ = (0); i >= i_begin_; i--)
x[i] = merger(x[i * 2 + 1], x[i * 2 + 2]);
}
void update(int pos, T val) {
pos += head, x[pos] = val;
while (pos)
pos = (pos - 1) / 2, x[pos] = merger(x[pos * 2 + 1], x[pos * 2 + 2]);
}
T get(int begin, int end) const {
return _get(begin, end, 0, 0, (int)x.size() / 2);
}
};
struct Mn {
int hi, lo2, hilo2, lo2hi, df, c;
Mn() : hi(0), lo2(0), hilo2(0), lo2hi(0), df(0), c(0) {}
Mn(int sgn) {
if (sgn > 0)
hi = 1, lo2 = 0, hilo2 = 0, lo2hi = 1, df = 1, c = 1;
else
hi = 0, lo2 = 2, hilo2 = 2, lo2hi = 0, df = -1, c = 0;
}
};
int main() {
int N, Q;
cin >> N >> Q;
SegTree<Mn> st((N - 1) * 2, Mn(), [](const Mn &L, const Mn &R) {
Mn ret;
ret.hi = max(L.hi, L.df + R.hi);
ret.lo2 = max(L.lo2, -L.df * 2 + R.lo2);
ret.hilo2 = max(max(L.hilo2, -L.df + R.hilo2), L.hi - L.df * 2 + R.lo2);
ret.lo2hi = max(max(L.lo2hi, -L.df + R.lo2hi), L.lo2 + L.df + R.hi);
ret.df = L.df + R.df;
ret.c =
max(max(L.c, R.c), max(L.hi - L.df + R.lo2hi, L.hilo2 + L.df + R.hi));
return ret;
});
string s;
cin >> s;
vector<Mn> vec(s.length());
for (int i = (0), i_end_ = (s.length()); i < i_end_; i++)
vec[i] = Mn(s[i] == '(');
st.build(vec);
Mn v = st.get(0, s.length());
printf("%d\n", v.c);
for (int _ = (0), __end_ = (Q); _ < __end_; _++) {
int x, y;
cin >> x >> y;
x--;
y--;
swap(vec[x], vec[y]);
st.update(x, vec[x]);
st.update(y, vec[y]);
Mn v = st.get(0, s.length());
printf("%d\n", v.c);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)3e17;
vector<long long> v(200050, 0);
long long val[200050][2] = {-1};
long long vis[200050][2] = {0};
long long n;
long long dfs(long long i, long long cnt) {
if (vis[i][cnt]) return val[i][cnt];
vis[i][cnt] = 1;
long long idx = (cnt == 0) ? (i - v[i]) : (i + v[i]);
if (idx <= 0 || idx > n) return val[i][cnt] = v[i];
if (dfs(idx, 1 - cnt) == -1)
return val[i][cnt] = -1;
else
return val[i][cnt] = v[i] + dfs(idx, 1 - cnt);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
memset(val, -1, sizeof(val));
memset(vis, 0, sizeof(vis));
for (long long i = 2; i <= n; i++) {
cin >> v[i];
}
for (long long i = 2; i <= n; i++) {
for (long long j = 0; j <= 1; j++) {
long long ans = dfs(i, j);
}
}
for (long long i = 1; i <= (n - 1); i++) {
long long j = 1 + i;
long long ans = val[j][0];
if (ans == -1) {
cout << -1 << "\n";
continue;
}
cout << val[j][0] + i << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> as(n, 0);
for (int i = 0; i < n; i++) cin >> as[i];
if (n == 1) {
cout << "1 1\n" << -as[0] << "\n";
cout << "1 1\n0\n1 1\n0\n";
return 0;
}
int len = n - 1;
cout << "1 " << len << "\n";
for (int i = 0; i < len; i++) {
cout << (long long)(as[i] % n) * len;
if (i < len - 1) cout << " ";
as[i] += (as[i] % n) * len;
}
cout << "\n" << n << " " << n << "\n" << -as[len] + n << "\n";
as[len] -= as[len] - n;
cout << "1 " << n << "\n";
for (int i = 0; i < n; i++) {
cout << -as[i];
if (i < n - 1) cout << " ";
}
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
long long int i, length, cnt = 0, res = 0;
length = a.size();
for (i = 0; i < length; i++) {
if (a[i] == 'h' && a[i + 1] == 'e' && a[i + 2] == 'a' && a[i + 3] == 'v' &&
a[i + 4] == 'y')
cnt++;
else if (a[i] == 'm' && a[i + 1] == 'e' && a[i + 2] == 't' &&
a[i + 3] == 'a' && a[i + 4] == 'l')
res += cnt;
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int p[1005];
void Init(int n) {
for (int i = 1; i <= n; i++) p[i] = i;
}
int Find(int x) { return x == p[x] ? x : p[x] = Find(p[x]); }
void Union(int x, int y) {
x = Find(x);
y = Find(y);
if (x < y) swap(x, y);
p[x] = y;
}
char s[1005];
bool is_prime(int x) {
for (int i = 2; i <= (int)sqrt(x); i++) {
if (x % i == 0) return 0;
}
return 1;
}
int n, loc, cnt[30];
struct alpha {
int cnt, id;
bool operator<(const alpha &t) const { return cnt > t.cnt; }
} k[1005];
int ch[1005];
bool isok;
void dfs(int now) {
if (now == loc + 1) {
isok = 1;
return;
}
for (int i = 0; i < 26; i++) {
if (cnt[i] >= k[now].cnt) {
cnt[i] -= k[now].cnt;
ch[k[now].id] = i;
dfs(now + 1);
cnt[i] += k[now].cnt;
if (isok) return;
}
}
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) {
cnt[s[i] - 'a']++;
}
Init(n);
for (int i = 2; i <= n; i++) {
if (is_prime(i)) {
for (int j = 2 * i; j <= n; j += i) {
Union(i, j);
}
}
}
for (int i = 1; i <= n; i++) k[i].id = i;
for (int i = 1; i <= n; i++) k[Find(i)].cnt++;
sort(k + 1, k + n + 1);
for (int i = 1; i <= n; i++) {
if (k[i].cnt == 0) {
loc = i;
break;
}
if (i == n) loc = n;
}
dfs(1);
if (isok) {
printf("YES\n");
for (int i = 1; i <= n; i++) {
printf("%c", ch[Find(i)] + 'a');
}
printf("\n");
} else
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 100;
const long long inf = (1LL << 30 - 1);
pair<int, int> A[maxn];
int fa[maxn], X[maxn], Y[maxn], Hx[maxn], Hy[maxn], ans[maxn];
int FindSet(int x) { return fa[x] == x ? x : fa[x] = FindSet(fa[x]); }
void UnionSet(int u, int v) {
u = FindSet(u);
v = FindSet(v);
if (u != v) fa[u] = v;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n * m; i++) {
fa[i] = i;
scanf("%d", &A[i].first);
A[i].second = i;
}
sort(A, A + n * m);
int j = -1;
memset(X, 0, sizeof(X));
memset(Y, 0, sizeof(Y));
for (int i = 0; i < n * m; i++) {
if (i != n * m - 1 && A[i].first == A[i + 1].first) continue;
for (int k = j + 1; k <= i; k++) {
int p = A[k].second;
int x = A[k].second / m, y = A[k].second % m;
Hx[x] = p;
Hy[y] = p;
}
for (int k = j + 1; k <= i; k++) {
int p = A[k].second;
int x = A[k].second / m, y = A[k].second % m;
UnionSet(Hx[x], p);
UnionSet(Hy[y], p);
}
for (int k = j + 1; k <= i; k++) {
int p = A[k].second;
int x = A[k].second / m, y = A[k].second % m;
int pa = FindSet(p);
ans[pa] = max(ans[pa], max(X[x], Y[y]) + 1);
}
for (int k = j + 1; k <= i; k++) {
int p = A[k].second;
int x = A[k].second / m, y = A[k].second % m;
int pa = FindSet(p);
X[x] = max(X[x], ans[pa]);
Y[y] = max(Y[y], ans[pa]);
}
j = i;
}
for (int i = 0; i < n * m; i++) {
printf("%d", ans[FindSet(i)]);
if ((i + 1) % m == 0)
printf("\n");
else
printf(" ");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void myassert(bool expr) {
if (!expr) abort();
}
const int64_t posinf = 9223372036854775807LL;
const int64_t neginf = 9223372036854775808LL;
const int64_t bigprime = (1LL << 61) - 1LL;
const int64_t mult = 199;
const int64_t mult2 = 3571;
const int64_t mod = 1000000007LL;
const int64_t mod2 = 1000000009LL;
const long double pi = 3.1415926535897932384626433832795L;
template <typename T>
T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, int> > pos, neg;
for (int i = 0; i < n; i++) {
int x, a;
cin >> x >> a;
if (x < 0)
neg.emplace_back(-x, a);
else
pos.emplace_back(x, a);
}
sort(pos.begin(), pos.end());
sort(neg.begin(), neg.end());
int ans = 0;
auto sz = min(pos.size(), neg.size());
for (size_t i = 0; i < min(sz + 1, pos.size()); i++) ans += pos[i].second;
for (size_t i = 0; i < min(sz + 1, neg.size()); i++) ans += neg[i].second;
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O2,no-stack-protector,unroll-loops,fast-math")
const long long maxn = 1e5 + 10, maxm = 1e7 + 10, lg = 16, mod = 1e9 + 7,
inf = 1e18;
long long n, q, ww[maxn], root = 1;
vector<long long> g[maxn];
long long st[maxn], ft[maxn], tt, h[maxn], par[maxn][lg + 1];
void pfs(long long v = 1, long long p = 0) {
st[v] = tt++;
h[v] = h[p] + 1;
par[v][0] = p;
for (int i = 1; i <= lg; i++) par[v][i] = par[par[v][i - 1]][i - 1];
for (auto u : g[v])
if (u != p) pfs(u, v);
ft[v] = tt;
}
long long gup(long long v, long long x) {
for (int i = 0; i <= lg; i++)
if (x >> i & 1) v = par[v][i];
return v;
}
long long lca(long long v, long long u) {
if (h[v] > h[u]) swap(v, u);
u = gup(u, h[u] - h[v]);
if (v == u) return v;
for (int i = lg; i >= 0; i--)
if (par[v][i] != par[u][i]) v = par[v][i], u = par[u][i];
return par[v][0];
}
bool ispar(long long v, long long u) {
return st[v] <= st[u] && ft[v] >= ft[u];
}
long long sum[maxn << 2], laz[maxn << 2];
void app(long long s, long long t, long long v, long long x) {
sum[v] += (t - s) * x;
laz[v] += x;
}
void shift(long long s, long long t, long long v) {
if (laz[v] == 0) return;
app(s, ((s + t) >> 1), (v << 1), laz[v]);
app(((s + t) >> 1), t, ((v << 1) ^ 1), laz[v]);
laz[v] = 0;
}
void add(long long l, long long r, long long x, long long s = 0,
long long t = tt, long long v = 1) {
if (l >= t || r <= s) return;
if (l <= s && r >= t) return app(s, t, v, x);
shift(s, t, v);
add(l, r, x, s, ((s + t) >> 1), (v << 1));
add(l, r, x, ((s + t) >> 1), t, ((v << 1) ^ 1));
sum[v] = sum[(v << 1)] + sum[((v << 1) ^ 1)];
}
long long get(long long l, long long r, long long s = 0, long long t = tt,
long long v = 1) {
if (l >= t || r <= s) return 0;
if (l <= s && r >= t) return sum[v];
shift(s, t, v);
return get(l, r, s, ((s + t) >> 1), (v << 1)) +
get(l, r, ((s + t) >> 1), t, ((v << 1) ^ 1));
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> ww[i];
for (int i = 1; i < n; i++) {
long long v, u;
cin >> v >> u;
g[v].push_back(u), g[u].push_back(v);
}
pfs();
for (int i = 1; i <= n; i++) add(st[i], st[i] + 1, ww[i]);
while (q--) {
long long ty;
cin >> ty;
if (ty == 1) cin >> root;
if (ty == 2) {
long long v, u, x;
cin >> v >> u >> x;
long long w = lca(v, u), w1 = lca(v, root), w2 = lca(u, root);
if (ispar(w, root)) {
w = (h[w1] > h[w2] ? w1 : w2);
long long br = gup(root, h[root] - h[w] - 1);
add(st[1], ft[1], x);
add(st[br], ft[br], -x);
} else
add(st[w], ft[w], x);
}
if (ty == 3) {
long long v;
cin >> v;
if (v == root)
cout << get(st[1], ft[1]) << '\n';
else if (ispar(v, root)) {
long long br = gup(root, h[root] - h[v] - 1);
cout << get(st[1], ft[1]) - get(st[br], ft[br]) << '\n';
} else
cout << get(st[v], ft[v]) << '\n';
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
const double oo = 1e30;
const int maxn = 200000;
using namespace std;
struct point {
double x, y;
int i;
} a[maxn];
bool operator<(point a, point b) { return a.x < b.x; }
double s[maxn], t[maxn], d[maxn], ans, sum;
int n, k, i;
double dist(point a, point b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
int main() {
scanf("%d%d\n", &n, &k);
for (i = 1; i <= n + 1; i++) scanf("%lf", &a[i].x), a[i].i = i;
scanf("%lf\n", &a[n + 1].y);
a[n + 1].i = n + 1;
if (a[n + 1].y) {
sort(a + 1, a + n + 1);
for (i = 2; i <= n; i++) s[i] = s[i - 1] + dist(a[i - 1], a[i]);
for (i = n - 1; i >= 1; i--) t[i] = t[i + 1] + dist(a[i], a[i + 1]);
for (i = 1; i <= n; i++) d[i] = dist(a[i], a[n + 1]);
for (i = 1; i <= n; i++)
if (a[i].i == k) {
k = i;
break;
}
if (n + 1 == k) {
ans = min(d[1] + s[n], d[n] + t[1]);
for (i = 2; i <= n - 1; i++) {
ans = min(ans, d[i] + t[1] - t[i] + d[1] + d[n] + t[i + 1]);
ans = min(ans, d[i] + s[n] - s[i] + d[n] + d[1] + s[i - 1]);
}
printf("%.7lf\n", ans);
return 0;
}
ans = min(d[1] + d[n] + s[k] + t[k + 1], d[1] + d[n] + t[k] + s[k - 1]);
ans = min(ans, d[k] + d[n] + s[n]);
ans = min(ans, d[k] + d[1] + t[1]);
ans = min(ans, s[k] + d[1] + d[k + 1] + t[k + 1]);
ans = min(ans, t[k] + d[n] + d[k - 1] + s[k - 1]);
for (i = 1; i < k; i++) {
sum = min(s[k] - s[i + 1] + d[n], t[k] + d[i + 1]) + t[i + 1];
sum += min(d[1], d[i]) + s[i];
ans = min(ans, sum);
}
for (i = i + 1; i <= n; i++) {
sum = min(s[i - 1] - s[k] + d[1], s[k] + d[i - 1]) + s[i - 1];
sum += min(d[i], d[n]) + t[i];
ans = min(ans, sum);
}
sum = min(t[k] + d[1], s[k] + d[n]) + s[n];
ans = min(ans, sum);
} else {
sort(a + 1, a + n + 2);
n++;
for (i = 2; i <= n; i++) s[i] = s[i - 1] + dist(a[i - 1], a[i]);
for (i = n - 1; i >= 1; i--) t[i] = t[i + 1] + dist(a[i], a[i + 1]);
for (i = 1; i <= n; i++)
if (a[i].i == k) {
k = i;
break;
}
ans = s[n] + min(t[k], s[k]);
}
printf("%.7lf\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int ar[26] = {0};
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
ar[s[i] - 'a']++;
}
bool flag = 0;
int o = 0;
for (int i = 0; i < 26; i++) {
if (ar[i] & 1) {
o++;
}
}
if (o & 1 || o == 0) {
flag = 1;
}
if (flag) {
cout << "First\n";
} else {
cout << "Second\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int num;
cin >> num;
char names[5][20] = {"Sheldon", "Leonard", "Penny", "Rajesh", "Howard"};
if (num <= 5) {
cout << names[num - 1] << endl;
return 0;
}
int numbyfive = num / 5;
double logged = log(numbyfive + 1);
double y = logged / log(2);
int x = y;
int base = (pow(2, x) - 1) * 5;
int personcount = pow(2, x);
int rest = num - base;
if (rest == 0) {
cout << "Howard" << endl;
return 0;
} else {
int j = rest / personcount;
int k = rest % personcount;
if (k == 0) {
cout << names[j - 1] << endl;
} else {
cout << names[j] << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long n, k, ans = 0, a, b, sl = 1, jjj, pr, napr, mmm[100001];
vector<long long> sys[100001];
vector<long long> v;
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
if (n == 1 or k >= n * (n - 1) / 2 or (n == 2 and k > 0)) {
cout << "NO\n";
return 0;
}
for (int i = 0; i < k; i++) {
cin >> a >> b;
a--;
b--;
mmm[a]++;
mmm[b]++;
sys[a].push_back(b);
sys[b].push_back(a);
}
for (long long i = 0; i < n; i++) {
v.push_back(0);
}
bool bbbbbbb = true;
for (long long i = 0; i < n; i++) {
if (mmm[i] < (n - 1)) {
v[i] = 1;
pr = i;
long long g = 0;
for (long long r = 0; r < mmm[i]; r++) {
v[sys[i][r]] = (g + 3);
g++;
}
jjj = g;
break;
}
}
for (long long i = 0; i < n; i++) {
if (v[i] == 0) {
if (bbbbbbb) {
v[i] = 2;
bbbbbbb = false;
} else {
v[i] = jjj + 3;
jjj++;
}
}
}
cout << "YES\n";
for (int r = 0; r < n; r++) {
cout << v[r] << " ";
}
cout << "\n";
for (int r = 0; r < n; r++) {
if (r == pr) {
cout << 2 << " ";
} else {
cout << v[r] << " ";
}
}
return 0;
cout << "NO\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
cin >> n >> q;
vector<long long> v;
long long sum = 0;
long long st = 0;
for (int i = 0; i < n; i++) {
long long tem;
cin >> tem;
st += tem;
sum += tem;
v.push_back(sum);
}
sum = 0;
vector<long long> data;
for (int i = 0; i < q; i++) {
long long tem;
cin >> tem;
sum += tem;
data.push_back(sum);
if (sum >= st) {
sum = 0;
}
}
for (int i = 0; i < q; i++) {
auto find = lower_bound(v.begin(), v.end(), data[i]);
int de = find - v.begin();
if (find != v.end() && *find == data[i]) {
de++;
}
if (n - de == 0) {
cout << n << " ";
} else
cout << n - de << " ";
}
}
| 3 |
#include <bits/stdc++.h>
const double eps = 1e-8;
struct point {
double x;
double y;
};
struct line {
double a;
double b;
};
struct triangle {
point p1;
point p2;
point p3;
};
double max(double a, double b) {
if (a > b)
return a;
else
return b;
}
double distance(point p1, point p2) {
double d =
sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
return d;
}
line giveLine(point p1, point p2) {
line L;
L.a = (p2.y - p1.y) / (p2.x - p1.x);
L.b = (p1.y - L.a * p1.x);
return L;
}
line giveBisector(point p1, point p2, point p3) {
line L;
point M;
if (p1.y == p2.y) p1 = p3;
M.x = (p1.x + p2.x) / 2;
M.y = (p1.y + p2.y) / 2;
L.a = -1 / giveLine(p1, p2).a;
L.b = M.y - L.a * M.x;
return L;
}
point cross(line L1, line L2) {
point C;
C.x = -(L1.b - L2.b) / (L1.a - L2.a);
C.y = L1.a * C.x + L1.b;
return C;
}
point circumcenter(triangle T) {
point M;
M = cross(giveBisector(T.p1, T.p2, T.p3), giveBisector(T.p1, T.p3, T.p2));
return M;
}
bool collinear(point p1, point p2, point p3) {
bool test;
if (p1.x == p2.x && p1.x == p3.x) return true;
line L = giveLine(p1, p2);
test = fabs((p3.y - L.a * p3.x - L.b)) < eps;
return test;
}
bool acute(triangle T) {
bool test;
double a = distance(T.p1, T.p2);
double b = distance(T.p2, T.p3);
double c = distance(T.p3, T.p1);
if (b > a) {
double tmp = a;
a = b;
b = tmp;
};
if (c > a) {
double tmp = a;
a = c;
c = tmp;
};
test = ((b * b + c * c - a * a) / (2 * b * c)) > eps;
return test;
}
bool right(triangle T) {
bool test;
double a = distance(T.p1, T.p2);
double b = distance(T.p2, T.p3);
double c = distance(T.p3, T.p1);
if (b > a) {
double tmp = a;
a = b;
b = tmp;
};
if (c > a) {
double tmp = a;
a = c;
c = tmp;
};
test = fabs((a * a - b * b - c * c)) < eps;
return test;
}
double radius(triangle T) {
double R;
R = distance(T.p1, circumcenter(T));
return R;
}
bool inside(triangle T, point p) {
point O = circumcenter(T);
double R = radius(T);
bool test = (R - distance(O, p)) > eps;
return test;
}
bool onCircle(triangle T, point p) {
point O = circumcenter(T);
double R = radius(T);
bool test = fabs((R - distance(O, p))) < eps;
return test;
}
int main() {
triangle T;
double time = 0;
double tmptime = 0;
double wrong = false;
double x, y;
int n;
point p1, p2, p3, p4;
scanf("%d", &n);
point points[n];
for (int i = 0; i < n; i++) {
scanf("%lf", &x);
scanf("%lf", &y);
points[i].x = x;
points[i].y = y;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
p1 = points[i];
p2 = points[j];
p3 = points[k];
if (collinear(p1, p2, p3)) break;
T.p1 = p1;
T.p2 = p2;
T.p3 = p3;
if (right(T)) {
tmptime = time;
for (int m = 0; m < n; m++) {
if (m != i && m != j && m != k) {
if (onCircle(T, points[m])) {
tmptime = max(tmptime, radius(T));
} else if (inside(T, points[m])) {
wrong = true;
break;
}
if (wrong) break;
}
}
if (!wrong) time = tmptime;
} else if (acute(T)) {
tmptime = time;
for (int m = 0; m < n; m++) {
if (m != i && m != j && m != k) {
if (inside(T, points[m])) wrong = true;
}
if (wrong) break;
tmptime = max(tmptime, radius(T));
}
if (!wrong) time = tmptime;
}
wrong = false;
}
}
}
if (time == 0) time = -1;
printf("%.6lf", time);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, q;
int a[N];
int b[N], len = 0;
bool read[N];
int cur = 0;
vector<int> ids[N];
int last = 1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
for (int i = 1; i <= q; ++i) {
int tp, x;
cin >> tp >> x;
if (tp == 1) {
++cur;
b[++len] = x;
ids[x].push_back(len);
} else if (tp == 2) {
for (int it = 0; it < ids[x].size(); ++it) {
int index = ids[x][it];
if (!read[index]) --cur;
read[index] = true;
}
ids[x].clear();
} else if (tp == 3) {
for (int it = last; it <= x; ++it) {
if (!read[it]) {
--cur;
read[it] = true;
}
}
}
if (tp == 3) last = max(x, last);
cout << cur << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int min(int a, int b) { return a < b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
long long max(long long a, long long b) { return a > b ? a : b; }
int maxi(int a, int b) { return a > b ? a : b; }
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool cmp(pair<int, int> a, pair<int, int> b) { return a.first < b.first; }
void solve() {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (abs(x1 - x2) == abs(y1 - y2)) {
cout << x2 << " " << y1 << " " << x1 << " " << y2;
return;
}
if (x1 == x2) {
cout << x1 + y1 - y2 << " " << y1 << " " << x1 + y1 - y2 << " " << y2;
return;
}
if (y1 == y2) {
cout << x1 << " " << y1 + x1 - x2 << " " << x2 << " " << y1 + x1 - x2;
return;
}
cout << -1;
}
int main() {
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long N, A, B;
cin >> N >> A >> B;
vector<long long> P(N, 0);
for (long long i = 0; i < N; i++) {
P[i] = i + 1;
}
long long n, m;
for (n = N / A; n >= 0; n--) {
long long l = 0, r = N;
bool found = false;
while (l != r) {
m = (l + r) / 2;
long long D = n * A + m * B;
if (D == N) {
found = true;
break;
} else if (D < N) {
if (l == m) {
break;
}
l = m;
} else {
if (r == m) {
break;
}
r = m;
}
}
if (found) {
break;
}
}
if (n * A + m * B == N) {
long long idx = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < A; j++, idx++) {
P[idx]++;
if (j == A - 1) {
P[idx] -= A;
}
}
}
for (long long i = 0; i < m; i++) {
for (long long j = 0; j < B; j++, idx++) {
P[idx]++;
if (j == B - 1) {
P[idx] -= B;
}
}
}
for (long long i = 0; i < N; i++) {
cout << P[i];
if (i == N - 1) {
cout << endl;
} else {
cout << " ";
}
}
return 0;
}
cout << -1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k;
int n, m;
int x, y;
map<int, int> mp;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
mp[x] = max(mp[x], y);
}
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
mp[x] = max(mp[x], y);
}
long long int sum = 0;
auto itr = mp.begin();
while (itr != mp.end()) {
sum += (long long int)itr->second;
itr++;
}
printf("%I64d ", sum);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define mod 1000000007
#define x first
#define y second
#define pii pair<int, int>
#define mii map<int, int>
#define pb push_back
#define ll long long
#define For(i, l, n) for (int i = l; i < n; i++)
#define clr(x) memset(x, 0, sizeof(x))
#define itmap(m) for (auto it = m.begin(); it != m.end(); it++)
#define vi vector<int>
using namespace std;
int mpow(ll x, ll y);
bool isPalindrone(string s);
void in_arr(int arr[], int n);
void findPrime();
ll _mod(ll a);
int prime[1];
int n,m;
void solve()
{
ll n;
cin>>n;
pair<ll,ll> arr[n];
For(i,0,n){
cin>>arr[i].second>>arr[i].first;
}
sort(arr,arr+n);
ll i=0,j=n-1;
ll count=0,collected=0;
while(i<=j)
{
if(collected>=arr[i].first){
collected+=arr[i].second;
count+=arr[i].second;
arr[i].second=0;
i++;
}else if(arr[i].first>=collected+arr[j].second){
collected+=arr[j].second;
count+=(arr[j].second*2);
arr[j].second=0;
j--;
}else{
ll x=(abs(arr[i].first-collected)*2);
arr[j].second-=(arr[i].first-collected);
collected+=(arr[i].first-collected);
count=count+x;
}
}
cout<<count;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
ll t;
t = 1;
// cin >> t;
while (t--)
{
solve();
}
return 0;
}
//calculating power in log(N)
int mpow(ll x, ll y)
{
ll res = 1;
while (y > 0)
{
if (y % 2 == 1)
{
res = (res * x) % mod;
}
y = y / 2;
x = (x * x) % mod;
}
return (int)res;
}
//input array
void in_arr(int arr[], int n)
{
For(i, 0, n)
{
cin >> arr[i];
}
}
// find Prime
void findPrime()
{
int n = 1000001;
prime[1] = -1;
For(i, 2, n)
{
if (prime[i] != 0)
{
continue;
}
for (int j = i + i; j < n; j += i)
{
prime[j] = -1;
}
}
}
// is Palindrone
bool isPalindrone(string s)
{
int j = s.length() - 1;
int i = 0;
while (i < j)
{
if (s[i] != s[j])
{
return false;
}
i++;
j--;
}
return true;
}
ll _mod(ll a)
{
return (mod + a % mod) % mod;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
vector<long long> sum(n);
sum[0] = s[0] - '0';
map<long long, long long> m;
m[1] = 1;
long long ans = 0;
for (int i = 0; i < n; i++) {
if (i > 0) sum[i] = sum[i - 1] + s[i] - '0';
ans += m[sum[i] - i];
m[sum[i] - i]++;
}
cout << ans << endl;
return;
}
int main() {
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
int n, x[5], y[5];
string st[105];
bool fillIt(int ind) {
int r = -1, c = -1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (st[i][j] == '*') {
r = i;
c = j;
i = n;
break;
}
if (c == -1 || x[ind] + r > n) return 0;
if (y[ind] + c > n) return 0;
for (int i = r; i - r < x[ind]; i++)
for (int j = c; j - c < y[ind]; j++) {
if (st[i][j] != '*') return 0;
st[i][j] = 'A' + ind;
}
return 1;
}
bool check() {
int a = 0, b = 0, c = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (st[i][j] == 'A')
a++;
else if (st[i][j] == 'B')
b++;
else if (st[i][j] == 'C')
c++;
else
return 0;
}
if (a != x[0] * y[0] || b != x[1] * y[1] || c != x[2] * y[2]) return 0;
return 1;
}
bool rec(int msk) {
if (msk == 7) {
return check();
}
string tmp[105];
for (int i = 0; i < n; i++) tmp[i] = st[i];
for (int i = 0; i < 3; i++)
if ((msk & (1 << i)) == 0) {
if (fillIt(i)) {
if (rec(msk | (1 << i))) return 1;
}
for (int i = 0; i < n; i++) st[i] = tmp[i];
swap(x[i], y[i]);
if (fillIt(i)) {
if (rec(msk | (1 << i))) return 1;
}
swap(x[i], y[i]);
}
return 0;
}
int main() {
for (int i = 0; i < 3; i++) cin >> x[i] >> y[i];
for (n = 1; n < 101; n++) {
for (int i = 0; i < n; i++) {
st[i].clear();
st[i].resize(n, '*');
}
bool ans = rec(0);
if (ans == 1) {
cout << n << endl;
for (int i = 0; i < n; i++) cout << st[i] << endl;
return 0;
}
}
cout << -1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
signed main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int k;
string s;
cin >> s >> k;
for (int i = 0; i < (int)((int)(s).size()); ++i)
if (k) {
int maxi = 0, id = -1;
for (int j = (int)(i + 1); j <= (int)((int)(s).size()); ++j)
if (s[j] - '0' > s[i] - '0' && j - i <= k && maxi < s[j] - '0')
maxi = s[j] - '0', id = j;
if (id != -1) {
for (int q = id; q >= i; q--) s[q] = s[q - 1];
s[i] = maxi + '0';
k -= id - i;
}
} else {
break;
}
cout << s << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
string s, res;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (res.back() != s[i] || res.size() % 2 == 0) res.push_back(s[i]);
}
if (res.size() % 2 != 0) res.pop_back();
cout << n - (res.size()) << '\n' << res << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m, k, a[300010], q, l;
string s;
map<int, int> h1, h2, h3;
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie();
cout.tie();
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
cin >> t;
for (; t; t--) {
cin >> s;
int c2 = 0, c1 = 0, c3 = 0;
int ln = 300000;
h1[0] = 0;
h2[0] = 0;
h3[0] = 0;
for (int i = 0; i < s.length(); i++) {
if ((s[i] - '0') == 3) {
c3++;
h3[c3] = i;
}
if ((s[i] - '0') == 2) {
c2++;
h2[c2] = i;
}
if ((s[i] - '0') == 1) {
c1++;
h1[c1] = i;
}
if (c2 == 0 || c1 == 0 || c3 == 0) {
continue;
}
ln = min(ln, max(max(i - h2[c2] + 1, i - h3[c3] + 1), i - h1[c1] + 1));
}
if (ln > 200000) {
cout << "0\n";
} else {
cout << ln << "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[1000020 << 1], t[1000020 << 1];
int c[2][2];
int main(void) {
int n;
int i;
int x, y;
scanf("%d", &n);
scanf("%s", s);
scanf("%s", t);
for (i = 0; i < (n << 1); i++) ++c[s[i] - '0'][t[i] - '0'];
for (i = x = y = 0; i < (n << 1); i++)
if (i & 1)
if (c[1][1]) {
--c[1][1];
++y;
} else if (c[0][1]) {
--c[0][1];
++y;
} else if (c[1][0])
--c[1][0];
else
--c[0][0];
else if (c[1][1]) {
--c[1][1];
++x;
} else if (c[1][0]) {
--c[1][0];
++x;
} else if (c[0][1])
--c[0][1];
else
--c[0][0];
puts(x < y ? "Second" : (x == y ? "Draw" : "First"));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[60], b[60];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
for (int i = 0; i < m; ++i) scanf("%lld", &b[i]);
long long _max = -1000000000000000001, max_ = -1000000000000000001, maxi = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i] * b[j] > _max) {
_max = a[i] * b[j];
maxi = i;
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (i == maxi) continue;
if (a[i] * b[j] > max_) max_ = a[i] * b[j];
}
}
printf("%lld\n", max_);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void c_p_c() {}
bool PowerTwo(long long x) { return x && (!(x & (x - 1))); }
void solve() {
long long n;
cin >> n;
if (PowerTwo(n)) {
cout << "-1\n";
return;
}
if (n == 3) {
cout << "2"
<< " "
<< "3"
<< " "
<< "1\n";
return;
}
long long a[n];
long long i;
a[0] = 2;
a[1] = 3;
a[2] = 1;
for (i = 4; i <= n - 1; i += 2) {
a[i - 1] = i + 1;
a[i] = i;
}
if (n % 2 == 0) {
a[n - 1] = n;
}
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
int32_t main() {
c_p_c();
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
long long x, y;
vector<long long> adj[51];
long long maxi = INT_MIN;
while (n--) {
cin >> x >> y;
adj[x].push_back(y);
maxi = max(maxi, x);
}
long long i;
for (i = 1; i <= maxi; i++) {
sort(adj[i].begin(), adj[i].end());
}
long long label[51];
long long j = 1;
vector<pair<long long, long long> > g[51];
for (i = maxi; i >= 1; i--) {
if (adj[i].size() != 0) {
long long start = j;
for (auto &it : adj[i]) {
label[j++] = it;
}
long long end = j;
g[i].push_back({start, end - 1});
}
}
long long k = label[m];
long long co = 0;
for (i = maxi; i >= 1; i--) {
if (adj[i].size() != 0) {
for (auto &it : g[i]) {
if (m >= it.first && m <= it.second) {
for (auto &it : adj[i]) {
if (it == k) co++;
}
}
}
}
}
cout << co;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 101000;
int N;
bool getv(int n) {
int a, b;
printf("? %d\n", 1 + n);
fflush(stdout);
scanf("%d", &a);
printf("? %d\n", 1 + n + (N / 2));
fflush(stdout);
scanf("%d", &b);
if (a == b) {
printf("! %d\n", 1 + n);
exit(0);
}
return a > b;
}
int main() {
scanf("%d", &N);
if (N % 4 > 0) {
printf("! -1\n");
return 0;
}
bool bvt = getv(0);
int low = 0, high = N / 2;
while (high > low + 1) {
int mid = low + (high - low) / 2;
if (getv(mid) == bvt)
low = mid;
else
high = mid;
}
getv(high);
printf("! -1\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int k;
int belong[1000002];
int cnt[1000002];
inline int root(int b) {
if (belong[b] == -1) {
return b;
}
belong[b] = root(belong[b]);
return belong[b];
}
void merge(int a, int b) {
a = root(a);
b = root(b);
if (a == b) {
return;
}
cnt[b] += cnt[a];
belong[a] = b;
}
map<int, int> mp;
int use[1000002];
int u_s;
bool dp[1000002];
bitset<1000002> b;
int main() {
b.set(0, true);
memset(belong, -1, sizeof(belong));
cin >> n >> k;
for (int i = 0; i < n; i++) {
cnt[i] = 1;
}
for (int i = 0; i < n; i++) {
int p;
scanf("%d", &p);
p--;
merge(i, p);
}
for (int i = 0; i < n; i++) {
if (root(i) == i) {
mp[cnt[i]]++;
}
}
for (auto it : mp) {
int offset = it.first;
int rem = it.second;
int p = 1;
while (rem) {
int cn = min(p, rem);
b |= (b << (offset * cn));
rem -= cn;
p *= 2;
}
}
if (b.test(k)) {
cout << k << " ";
} else {
cout << k + 1 << " ";
}
int odd = 0;
int ev = 0;
for (int i = 0; i < n; i++) {
if (root(i) == i) {
if (cnt[i] & 1) {
odd++;
}
ev += cnt[i] / 2;
}
}
cout << min(n, min(ev, k) * 2 + max(0, k - ev)) << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
double a, b;
int main() {
scanf("%lf%lf", &a, &b);
int n;
double ans = 1000000, i, j, t, v;
scanf("%d", &n);
while (n--) {
scanf("%lf%lf%lf", &i, &j, &v);
t = sqrt((i - a) * (i - a) + (j - b) * (j - b)) / v;
if (t < ans) ans = t;
}
printf("%.10lf\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 2e5 + 100;
const int md = 1000000007;
priority_queue<int, vector<int>, greater<int> > pq;
int main() {
ios::sync_with_stdio(0);
cin.tie();
int t, n, m, ans[30][5];
vector<string> arr(2010), ars(2010);
cin >> t;
pair<int, int> awal[30], akhir[30];
while (t--) {
bool can = true, hidup[30] = {};
int p = -1;
cin >> n >> m;
for (int i = 0; i < 27; i += 1) awal[i].first = -1;
for (int i = 0; i < n; i += 1) {
cin >> arr[i];
ars[i] = arr[i];
for (int j = 0; j < m; j += 1) {
ars[i][j] = '.';
if (arr[i][j] != '.') {
int z = arr[i][j] - 'a';
hidup[z] = 1;
if (awal[z].first == -1) awal[z] = make_pair(i, j);
akhir[z] = make_pair(i, j);
}
}
}
for (int i = 0; i < 26; i += 1) {
if (hidup[i]) p = i;
}
for (int i = 0; i < p + 1; i += 1) {
if (hidup[i] == 0) continue;
int a = awal[i].first, b = awal[i].second;
int c = akhir[i].first, d = akhir[i].second;
if (a == c) {
for (int j = b; j < d + 1; j += 1) ars[a][j] = char(i + 'a');
} else if (b == d) {
for (int j = a; j < c + 1; j += 1) ars[j][b] = char(i + 'a');
}
ans[i][0] = a + 1;
ans[i][1] = b + 1;
ans[i][2] = c + 1;
ans[i][3] = d + 1;
}
for (int i = 0; i < p + 1; i += 1) {
if (hidup[i]) continue;
ans[i][0] = ans[p][0];
ans[i][1] = ans[p][1];
ans[i][2] = ans[p][2];
ans[i][3] = ans[p][3];
}
for (int i = 0; i < n; i += 1) {
for (int j = 0; j < m; j += 1)
if (arr[i][j] != ars[i][j]) can = false;
}
if (can) {
printf("YES\n%d\n", p + 1);
for (int i = 0; i < p + 1; i += 1) {
for (int j = 0; j < 4; j += 1) printf("%d ", ans[i][j]);
printf("\n");
}
} else
printf("NO\n");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 310;
int n, m;
string s[8];
int main() {
int len;
string te;
s[0] = "vaporeon";
s[1] = "jolteon";
s[2] = "flareon";
s[3] = "espeon";
s[4] = "umbreon";
s[5] = "leafeon";
s[6] = "glaceon";
s[7] = "sylveon";
cin >> len >> te;
for (int i = 0; i <= 7; i++) {
if (s[i].length() == len) {
bool flag = false;
for (int j = 0; j < len; j++)
if (te[j] == s[i][j] || te[j] == '.')
continue;
else
flag = true;
if (!flag) {
cout << s[i] << endl;
return 0;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2020;
bitset<MAXN + MAXN> mat[MAXN];
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> g;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
mat[u][v] = 1;
g.push_back({u, v});
}
for (int i = 0; i < n; ++i) mat[i][n + i] = 1;
for (int i = 0; i < n - 1; ++i) {
int k = i;
for (; !mat[k][i]; ++k)
;
if (i != k) {
mat[i] ^= mat[k];
mat[k] ^= mat[i];
mat[i] ^= mat[k];
}
for (int j = i + 1; j < n; ++j) {
if (mat[j][i]) mat[j] ^= mat[i];
}
}
for (int i = n - 1; i >= 0; --i) {
for (int j = i - 1; j >= 0; --j)
if (mat[j][i]) mat[j] ^= mat[i];
}
for (int i = 0; i < m; ++i) {
if (mat[g[i].second][g[i].first + n])
cout << "NO\n";
else
cout << "YES\n";
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 0) {
cout << "O-|-OOOO" << endl;
return 0;
}
while (n > 0) {
int r = n % 10;
if (r < 5) {
cout << "O-|";
} else {
cout << "-O|";
r = r - 5;
}
for (int i = 1; i <= r; i++) cout << "O";
cout << "-";
for (int i = r + 1; i < 5; i++) cout << "O";
n = n / 10;
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
inline T lowbit(T x) {
return x & -x;
}
const int N = 2e5 + 10;
int n, m;
int q;
int res;
int les[N], more[N];
bool vis[N];
void solve() {
cin >> n >> m;
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
if (u > v)
les[u]++, more[v]++;
else
les[v]++, more[u]++;
}
for (int i = 1; i <= n; ++i) {
if (!more[i]) res++, vis[i] = 1;
}
cin >> q;
while (q--) {
int x;
scanf("%d", &x);
int a, b;
if (x == 1) {
scanf("%d%d", &a, &b);
if (a > b)
les[a]++, more[b]++;
else
les[b]++, more[a]++;
if (vis[a] && more[a]) vis[a] = 0, res--;
if (vis[b] && more[b]) vis[b] = 0, res--;
}
if (x == 2) {
scanf("%d%d", &a, &b);
if (a > b)
les[a]--, more[b]--;
else
les[b]--, more[a]--;
if (!vis[a] && !more[a]) res++, vis[a] = 1;
if (!vis[b] && !more[b]) res++, vis[b] = 1;
}
if (x == 3) {
cout << res << endl;
}
}
}
signed main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void code() {
long long n;
cin >> n;
long long yr = 0;
long long yl = 0;
while (n--) {
long long x, y;
cin >> x >> y;
if ((x < 0 and y <= 0) or (x < 0 and y >= 0)) {
yl++;
} else {
yr++;
}
}
if (yl <= 1 or yr <= 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
signed main() { code(); }
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, i;
cin >> t;
map<int, int> freq;
while (t--) {
cin >> n;
int a[n];
freq.clear();
int cnt = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
freq[a[i]]++;
if (freq[a[i]] == 1) cnt++;
}
cout << cnt << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<long long> v[N];
long long vis[N];
long long col[N];
set<long long> che;
void dfs(long long x) {
vis[x] = 1;
che.insert(x);
for (auto it : v[x]) {
if (!vis[it]) {
dfs(it);
}
}
}
void solve() {
long long n;
cin >> n;
long long i, x, y;
vector<pair<long long, long long> > e, spe;
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
x--, y--;
e.push_back(make_pair(x, y));
}
for (i = 0; i < n; i++) {
cin >> col[i];
}
for (auto it : e) {
if (col[it.first] != col[it.second]) {
spe.push_back(make_pair(it.first, it.second));
}
}
long long m = spe.size();
long long f = 0, ind = 0;
long long cnt[n];
memset(cnt, 0, sizeof(cnt));
if (m == 0) {
cout << "YES\n1";
return;
}
for (auto it : spe) {
cnt[it.first]++;
cnt[it.second]++;
}
for (i = 0; i < n; i++) {
if (cnt[i] == m) {
cout << "YES\n" << i + 1;
return;
}
}
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
string str;
cin >> str;
string temp = str;
sort(str.begin(), str.end());
int count = 0;
for (int i = 0; i < n; i++) {
if (str[i] != temp[i]) count++;
}
cout << count << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int test;
cin >> test;
while (test--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[114514];
int main() {
long long n, ans = 0;
scanf("%I64d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (int i = 1; i <= n; i++) ans += a[i] + (a[i] - 1) * (i - 1);
printf("%I64d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int rd() {
char c = getchar();
int t = 0, f = 1;
while (!isdigit(c)) f = (c == '-') ? -1 : 1, c = getchar();
while (isdigit(c)) t = t * 10 + c - 48, c = getchar();
return t * f;
}
void wt(int x) {
if (x < 0)
putchar('-'), wt(-x);
else {
if (x > 9) wt(x / 10);
putchar(x % 10 + 48);
}
}
const int N = 15005;
const int mxf = 1e9;
int head[N], cnt = 1;
struct Edge {
int to, nxt, fl;
} E[2000005];
void Link(int u, int v, int w) {
E[++cnt] = (Edge){v, head[u], w}, head[u] = cnt;
E[++cnt] = (Edge){u, head[v], 0}, head[v] = cnt;
}
int inf;
int pos[55][2000];
int d[N], n, m, a[N], b[N], c[N], l[N], r[N], S, T = N - 1, id, ans;
bool bfs() {
static int h, t, x, Q[N];
memset(d, -1, sizeof d);
h = 0, Q[t = 1] = S, d[S] = 0;
while (h < t) {
x = Q[++h];
for (int y, i = head[x]; i; i = E[i].nxt)
if (d[y = E[i].to] == -1 && E[i].fl) {
d[y] = d[x] + 1;
if (y == T)
return 1;
else
Q[++t] = y;
}
}
return 0;
}
int dfs(int x, int fl) {
int w = 0, Ret;
if (x == T || !fl) return fl;
for (int y, i = head[x]; i; i = E[i].nxt)
if (d[y = E[i].to] == d[x] + 1 && (Ret = dfs(y, min(fl - w, E[i].fl))))
E[i].fl -= Ret, E[i ^ 1].fl += Ret, w += Ret;
if (!w) d[x] = -1;
return w;
}
int main() {
n = rd(), m = rd(), inf = -1 << 30;
for (int i = ((int)1); i <= ((int)n); i++)
a[i] = rd(), b[i] = rd(), c[i] = rd();
for (int i = ((int)1); i <= ((int)n); i++) {
l[i] = rd(), r[i] = rd();
for (int j = ((int)l[i]); j <= ((int)r[i]); j++)
inf = max(inf, a[i] * j * j + b[i] * j + c[i]);
}
for (int i = ((int)1); i <= ((int)n); i++) {
for (int j = ((int)l[i] - 1); j <= ((int)r[i]); j++) pos[i][j] = ++id;
Link(S, pos[i][l[i] - 1], mxf);
Link(pos[i][r[i]], T, mxf);
for (int j = ((int)l[i]); j <= ((int)r[i]); j++)
Link(pos[i][j - 1], pos[i][j], inf - a[i] * j * j - b[i] * j - c[i]);
}
while (m--) {
int u = rd(), v = rd(), d = rd();
for (int i = ((int)l[u] - 1); i <= ((int)r[u] - 1); i++)
if (i - d >= l[v] && i - d <= r[v]) Link(pos[u][i], pos[v][i - d], mxf);
}
ans = inf * n;
while (bfs()) ans -= dfs(S, mxf);
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int s[200005], t[200005];
int val[200005], sum[200005];
struct data {
int ss, tt;
};
data p[200005];
bool operator<(const data &fir, const data &sec) { return (fir.tt < sec.tt); }
int main() {
int T;
int i, k;
int n, m, l;
int idx;
int selst, selen;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &s[i], &t[i]);
p[i].ss = s[i], p[i].tt = t[i];
}
t[m] = 0, t[m + 1] = n;
sort(t, t + m + 2);
l = unique(t, t + m + 2) - t;
sort(p, p + m);
idx = 0;
val[0] = 1;
sum[0] = 1;
for (i = 1; i < l; i++) {
while (1) {
if (p[idx].tt != t[i])
break;
else {
selst = lower_bound(t, t + l, p[idx].ss) - t;
selen = lower_bound(t, t + l, p[idx].tt) - t;
if (selst)
val[i] = (val[i] + sum[selen - 1] - sum[selst - 1]) % 1000000007;
else
val[i] = (val[i] + sum[selen - 1]) % 1000000007;
if (val[i] < 0) val[i] += 1000000007;
sum[i] = (sum[i - 1] + val[i]) % 1000000007;
idx++;
}
}
}
if (l)
printf("%d\n", val[l - 1]);
else
printf("0\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int nn = 55;
int main() {
int n, m, a, b;
set<pair<int, int> > data;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
if (a > b) swap(a, b);
data.insert(make_pair(a, b));
}
bool ans = 0;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
set<pair<int, int> > done;
int k = i;
bool cek = 1;
for (set<pair<int, int> >::iterator j = data.begin(); j != data.end();
++j) {
if (done.count(*j) == 0) {
pair<int, int> tmp = *j;
int x = tmp.first;
int y = tmp.second;
while (done.count(make_pair(x, y)) == 0 &&
data.count(make_pair(x, y)) == 1) {
done.insert(make_pair(x, y));
x += k;
y += k;
if (x > n) x -= n;
if (y > n) y -= n;
if (x > y) swap(x, y);
}
if (x != tmp.first || y != tmp.second) {
cek = 0;
break;
}
}
}
if (cek) ans = 1;
done.clear();
k = n / i;
if (k == n) continue;
cek = 1;
for (set<pair<int, int> >::iterator j = data.begin(); j != data.end();
++j) {
if (done.count(*j) == 0) {
pair<int, int> tmp = *j;
int x = tmp.first;
int y = tmp.second;
while (done.count(make_pair(x, y)) == 0 &&
data.count(make_pair(x, y)) == 1) {
done.insert(make_pair(x, y));
x += k;
y += k;
if (x > n) x -= n;
if (y > n) y -= n;
if (x > y) swap(x, y);
}
if (x != tmp.first || y != tmp.second) {
cek = 0;
break;
}
}
}
if (cek) ans = 1;
}
}
if (ans)
printf("Yes\n");
else
printf("No\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<string, int> cnt;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<string> store;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
int m = s.size();
map<string, bool> done;
for (int j = 0; j < m; ++j) {
for (int len = 1; len <= m - j; ++len) {
string curr = s.substr(j, len);
if (done[curr] == 0) {
cnt[s.substr(j, len)] += 1;
done[curr] = 1;
}
}
}
store.push_back(s);
}
for (int i = 0; i < n; ++i) {
string poss = "1243567891011";
bool found = false;
string chek = store[i];
int m = chek.size();
for (int j = 0; j < m; ++j) {
for (int len = 1; len <= m - j; ++len) {
string curr = chek.substr(j, len);
if (cnt[curr] == 1) {
if (poss.size() > curr.size()) {
poss = curr;
}
}
}
}
cout << poss << endl;
}
return 0;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 100000 + 5;
const long long mod = 1000000000000000 + 7;
const long long LMT = 1000000;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long f[MAX], in[MAX], iff[MAX];
void fact() {
f[0] = f[1] = 1;
for (long long i = 2; i < MAX; i++) f[i] = (f[i - 1] * i) % mod;
in[0] = 1, in[1] = 1;
for (long long i = 2; i < MAX; i++)
in[i] = mod - (mod / i) * in[mod % i] % mod;
iff[0] = 1;
for (long long i = 1; i < MAX; i++) iff[i] = (in[i] * iff[i - 1]) % mod;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, ans = 0, i, j, k = 0, l, m;
string s;
cin >> n >> s;
vector<long long> trans, extras;
for (i = 0; i < n; i++) {
long long cr = 0;
char ch = s[i];
while (i < n) {
if (s[i] != ch) {
i--;
break;
}
cr++;
i++;
}
trans.push_back(cr);
}
n = trans.size();
i = k = j = 0;
while (i < n) {
if (trans[i] > 1) {
j++;
k++;
trans[i]--;
} else
i++;
if (i < j) i = j;
}
k += (n - j + 1) / 2;
cout << k << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long int advceil(long long int num, long long int den) {
return (num % den == 0 ? num / den : num / den + 1);
}
long long int lstbt(long long int val) {
long long int msk = val & (val - 1);
return log2(val ^ msk);
}
long long int modmul(long long int a, long long int b) {
if (a < 1e9 and b < 1e9) return (a * b) % 1000000007;
a %= 1000000007;
b %= 1000000007;
long long int res = 0;
while (b > 0) {
if (b & 1) res = (res + a) % 1000000007;
a = (a * 2) % 1000000007;
b /= 2;
}
return res;
}
long long int modexpo(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = modmul(res, a);
a = modmul(a, a);
b /= 2;
}
return res;
}
long long int gcd(long long int a, long long int b) {
return a == 0 ? b : gcd(b % a, a);
}
vector<long long int> CALCfactor(long long int n) {
vector<long long int> factor(n + 2, 0);
for (long long int i = 4; i <= n; i += 2) factor[i] = 2;
for (long long int j = 3; j <= n; j += 2) {
if (factor[j]) continue;
for (long long int i = 2 * j; i <= n; i += j) factor[i] = j;
}
return factor;
}
vector<long long int> CALCprimeNUM(long long int n) {
vector<long long int> factor = CALCfactor(n);
vector<long long int> primeNUM;
primeNUM.reserve(n + 2);
for (long long int i = 2; i <= n; i++)
if (!factor[i]) primeNUM.push_back(i);
return primeNUM;
}
vector<long long int> CALCprimeFACTOR(long long int n) {
vector<long long int> factor = CALCfactor(n);
vector<long long int> ans;
while (factor[n] != 0) {
ans.push_back(factor[n]);
n /= factor[n];
}
if (n > 1) ans.push_back(n);
return ans;
}
vector<long long int> unique(vector<long long int> x) {
sort(x.begin(), x.end());
set<long long int> s;
vector<long long int> ans;
ans.reserve(x.size());
for (auto elem : x) s.insert(elem);
for (auto elem : s) ans.push_back(elem);
return ans;
}
pair<vector<long long int>, vector<long long int> > getFact(long long int n) {
vector<long long int> fact(n + 1, 1), invfact(n + 1, 1);
for (long long int i = 1; i <= n; i++)
fact[i] = (i * (fact[i - 1])) % 1000000007;
for (long long int i = 1; i <= n; i++)
invfact[i] = (modexpo(i, 1000000007 - 2) * invfact[i - 1]) % 1000000007;
return {fact, invfact};
}
void compress(vector<long long int>& arr, long long int n) {
map<long long int, vector<long long int> > pos;
for (long long int i = 1; i <= n; i++) pos[arr[i]].push_back(i);
long long int cnt = 1;
for (auto itr : pos) {
for (auto elem : itr.second) arr[elem] = cnt;
cnt++;
}
}
bool rcomp(long long int a, long long int b) { return a > b; }
void solve() {
long long int n, k;
cin >> n >> k;
vector<long long int> arr(n + 2, 0);
for (long long int i = 1; i <= n; i++) cin >> arr[i];
vector<long long int> pref(n + 2, 0), suff(n + 2, -1e12);
for (long long int i = 1; i <= n; i++) {
pref[i] = pref[i - 1] + arr[i];
if (pref[i] > k) {
cout << "-1"
<< "\n";
return;
}
}
for (long long int i = n + 1 - 1; i >= 1; i--)
suff[i] = max(suff[i + 1], pref[i]);
vector<long long int> zeropos;
for (long long int i = 1; i <= n; i++)
if (arr[i] == 0) zeropos.push_back(i);
long long int ans = 0, profit = 0;
vector<long long int> set;
for (auto elem : zeropos) {
if (pref[elem] + profit >= 0) continue;
ans++;
long long int profithere = abs(pref[elem] + profit);
long long int maxval = max(0ll, k - suff[elem] - profit);
if (maxval >= profithere)
profit += maxval;
else {
cout << "-1"
<< "\n";
return;
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
auto start1 = high_resolution_clock::now();
solve();
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Rea = 1e5 + 3;
struct Rin {
char c;
inline char gc() {
static char rea[Rea];
static char *head, *tail;
return head == tail && (tail = (head = rea) + fread(rea, 1, Rea, stdin),
head == tail)
? EOF
: *head++;
}
inline Rin &operator>>(int &x) {
bool tag = false;
x = 0;
for (c = gc(); c > '9' || c < '0'; c = gc())
if (c == '-') {
c = gc();
tag = true;
break;
}
for (; c >= '0' && c <= '9'; c = gc()) x = (x << 1) + (x << 3) + (c ^ '0');
if (tag) x = -x;
return *this;
}
inline Rin &operator>>(long long &x) {
bool tag = false;
x = 0;
for (c = gc(); c > '9' || c < '0'; c = gc())
if (c == '-') {
c = gc();
tag = true;
break;
}
for (; c >= '0' && c <= '9'; c = gc()) x = (x << 1) + (x << 3) + (c ^ '0');
if (tag) x = -x;
return *this;
}
} rin;
inline void jh(int &x, int &y) {
if (x ^ y) x ^= y ^= x ^= y;
return;
}
inline void jh(long long &x, long long &y) {
if (x ^ y) x ^= y ^= x ^= y;
return;
}
inline int min(int x, int y) { return x < y ? x : y; }
inline int max(int x, int y) { return x > y ? x : y; }
inline long long min(long long x, long long y) { return x < y ? x : y; }
inline long long max(long long x, long long y) { return x > y ? x : y; }
const int N = 1e5 + 3;
const int S = 1e6;
int n, m;
struct gyq {
int x, y;
gyq(int x_ = 0, int y_ = 0) {
x = x_;
y = y_;
}
};
vector<gyq> U;
vector<gyq> D;
vector<gyq> L;
vector<gyq> R;
vector<int> X;
vector<int> Y;
long long ans;
inline bool myru_y(gyq x, gyq y) { return x.y < y.y; }
inline bool myru_x(gyq x, gyq y) { return x.x < y.x; }
int f[S + 3];
inline int lowbit(int x) { return x & (-x); }
inline void add(int x, int y) {
for (; x <= S; x += lowbit(x)) f[x] += y;
return;
}
inline int check(int x) {
int y = 0;
for (; x; x -= lowbit(x)) y += f[x];
return y;
}
int main() {
rin >> n >> m;
for (int i = 1, y, l, r; i <= n; i++) {
rin >> y >> l >> r;
if (l == 0 && r == S) {
Y.push_back(y);
continue;
}
if (l == 0) R.push_back(gyq(r, y));
if (r == S) L.push_back(gyq(l, y));
}
for (int i = 1, x, l, r; i <= m; i++) {
rin >> x >> l >> r;
if (l == 0 && r == S) {
X.push_back(x);
continue;
}
if (l == 0) U.push_back(gyq(x, r));
if (r == S) D.push_back(gyq(x, l));
}
ans = 1LL * (X.size() + 1) * (Y.size() + 1);
sort(X.begin(), X.end());
sort(Y.begin(), Y.end());
sort(L.begin(), L.end(), myru_x);
sort(R.begin(), R.end(), myru_x);
sort(U.begin(), U.end(), myru_x);
sort(D.begin(), D.end(), myru_x);
vector<gyq>::iterator i = R.begin(), u = U.begin(), d = D.begin();
for (; i != R.end(); i++) {
for (; u != U.end() && u->x <= i->x; u++) add(1, 1), add(u->y + 1, -1);
for (; d != D.end() && d->x <= i->x; d++) add(d->y, 1);
ans += check(i->y) +
(X.size() - (X.end() - upper_bound(X.begin(), X.end(), i->x)));
}
for (; u != U.end(); u++) add(1, 1), add(u->y + 1, -1);
for (; d != D.end(); d++) add(d->y, 1);
i = L.begin();
u = U.begin();
d = D.begin();
for (; i != L.end(); i++) {
for (; u != U.end() && u->x < i->x; u++) add(1, -1), add(u->y + 1, 1);
for (; d != D.end() && d->x < i->x; d++) add(d->y, -1);
ans += check(i->y) + (X.end() - lower_bound(X.begin(), X.end(), i->x));
}
for (i = U.begin(); i != U.end(); i++)
ans += (Y.size() - (Y.end() - upper_bound(Y.begin(), Y.end(), i->y)));
for (i = D.begin(); i != D.end(); i++)
ans += (Y.end() - lower_bound(Y.begin(), Y.end(), i->y));
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
long long int w;
cin >> n;
cin >> w;
int flag = 0;
int q = 0;
long long int a[n];
long long int s = 0;
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> v;
for (int i = 0; i < n; i++) {
if (a[i] <= w) {
if (s + a[i] > w && a[i] * 2 < w)
continue;
else {
if (a[i] * 2 >= w) {
q = i + 1;
flag = 1;
break;
}
v.push_back(i + 1);
s = s + a[i];
}
}
}
if (flag == 0) {
if (v.size() != 0 && s * 2 >= w && s <= w) {
cout << v.size() << endl;
for (auto x : v) cout << x << " ";
cout << endl;
} else
cout << -1 << endl;
continue;
} else if (flag == 1) {
cout << 1 << endl;
cout << q << endl;
continue;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long mx_error = 15 * 1e5;
struct delta {
int idx;
long long dx, dy;
bool operator<(const delta& other) const {
return dx * dx + dy * dy < other.dx * other.dx + other.dy + other.dy;
}
};
long long sgn(long long x) {
if (x >= 0) return 1;
return -1;
}
int get_q(long long x, long long y) {
int dir_x = 0;
int dir_y = 0;
if (sgn(x) == -1) dir_x = 1;
if (sgn(y) == -1) dir_y = 1;
int res = 0;
res |= (dir_x);
res |= (dir_y << 1);
return res;
}
long long not_good_error(long long x, long long y) {
if (x > mx_error || y > mx_error) return true;
return x * x + y * y > mx_error * mx_error;
}
bool cmp_x(delta a, delta b) { return a.dx > b.dx; }
bool cmp_y(delta a, delta b) { return a.dy > b.dy; }
int ans[100009];
int main() {
long long px = 0, py = 0;
int n;
scanf("%d", &n);
vector<delta> vx_pos;
vector<delta> vx_neg;
vector<delta> vy_pos;
vector<delta> vy_neg;
for (int i = 0; i < n; i++) {
int dx, dy;
scanf("%d %d", &dx, &dy);
px += dx;
py += dy;
ans[i] = 1;
if (dx >= 0)
vx_pos.push_back({i, dx, dy});
else
vx_neg.push_back({i, dx, dy});
if (dy >= 0)
vy_pos.push_back({i, dx, dy});
else
vy_neg.push_back({i, dx, dy});
}
sort(vx_pos.begin(), vx_pos.end(), cmp_x);
sort(vx_neg.begin(), vx_neg.end(), cmp_x);
sort(vy_pos.begin(), vy_pos.end(), cmp_y);
sort(vy_pos.begin(), vy_pos.end(), cmp_y);
int i_pos = 0;
int i_neg = (int)vx_neg.size() - 1;
int j_pos = 0;
int j_neg = (int)vy_neg.size() - 1;
while (not_good_error(px, py)) {
delta d;
if (abs(px) >= abs(py)) {
if (px >= 0) {
while (ans[vx_pos[i_pos].idx] == -1) i_pos++;
d = vx_pos[i_pos];
} else {
while (ans[vx_neg[i_neg].idx] == -1) i_neg--;
d = vx_neg[i_neg];
}
} else {
if (py >= 0) {
while (ans[vy_pos[j_pos].idx] == -1) j_pos++;
d = vy_pos[j_pos];
} else {
while (ans[vy_neg[j_neg].idx] == -1) j_neg--;
d = vy_neg[j_neg];
}
}
px -= 2 * d.dx;
py -= 2 * d.dy;
ans[d.idx] = -1;
}
for (int i = 0; i < n; i++) printf("%d%c", ans[i], " \n"[i == n - 1]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, a, b, c, d, l, m, p, q;
scanf("%d", &n);
a = n / 100;
p = n % 100;
b = p / 20;
q = p % 20;
d = q / 10;
m = q % 10;
c = m / 5;
l = m % 5;
printf("%d\n", (a + b + c + d + l));
return 0;
}
| 0 |
#include <bits/stdc++.h>
template <class T>
inline T read(const T sample) {
T x = 0;
int f = 1;
char s;
while ((s = getchar()) > '9' || s < '0')
if (s == '-') f = -1;
while (s >= '0' && s <= '9')
x = (x << 1) + (x << 3) + (s ^ 48), s = getchar();
return x * f;
}
template <class T>
inline void write(const T x) {
if (x < 0) return (void)(putchar('-'), write(-x));
if (x > 9) write(x / 10);
putchar(x % 10 ^ 48);
}
template <class T>
inline T Max(const T x, const T y) {
return x > y ? x : y;
}
template <class T>
inline T Min(const T x, const T y) {
return x < y ? x : y;
}
template <class T>
inline T fab(const T x) {
return x > 0 ? x : -x;
}
template <class T>
inline T Gcd(const T x, const T y) {
return y ? Gcd(y, x % y) : x;
}
const int N = 1e6 + 5;
int n, k, q[N], l, r, p, f[2][N];
int main() {
int L, R;
n = read(9), k = read(9);
memset(f, 0x3f, sizeof f);
f[0][0] = 0;
while (k--) {
L = read(9), R = read(9);
l = 1, r = 0;
for (register signed i = (0), _end = (N - 5); i <= _end; ++i)
f[p ^ 1][i] = f[p][i];
for (register signed i = (0), _end = (Min(n, R)); i <= _end; ++i) {
while (l <= r && f[p][q[r]] >= f[p][i]) --r;
q[++r] = i;
while (l <= r && q[l] < i - (R - L)) ++l;
f[p ^ 1][i] = Min(f[p ^ 1][i], f[p][q[l]] + 2);
}
l = 1, r = 0;
for (register signed i = (R), _end = (0); i >= _end; --i) {
while (l <= r && f[p][q[r]] >= f[p][R - i]) --r;
while (l <= r && q[l] < L - i) ++l;
q[++r] = R - i;
f[p ^ 1][i] = Min(f[p ^ 1][i], f[p][q[l]] + 1);
}
p ^= 1;
}
if (f[p][n] >= 0x3f3f3f3f)
puts("Hungry");
else
printf("Full\n%d\n", f[p][n]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int N_SIZE = 200010;
const int M_SIZE = 3010;
int n, m;
int a[N_SIZE];
int np[2];
long long dp[M_SIZE][M_SIZE];
long long w[N_SIZE];
long long inv[2 * M_SIZE];
long long mypow(long long x, long long y) {
x %= MOD;
long long res = 1 % MOD;
while (y) {
if (y & 1) res = res * x % MOD;
y >>= 1;
x = x * x % MOD;
}
return res;
}
long long dp_pos[M_SIZE], dp_neg[M_SIZE];
int main() {
MOD = 998244353;
R(n, m);
for (int i = (1); i <= (n); ++i) R(a[i]);
for (int i = (1); i <= (n); ++i) {
R(w[i]);
if (a[i])
np[1] += w[i];
else
np[0] += w[i];
}
for (int i = (-M_SIZE); i <= (M_SIZE); ++i) {
if (np[1] + np[0] + i >= 0) {
inv[i + M_SIZE] = mypow(np[0] + np[1] + i, MOD - 2);
}
}
dp[0][0] = 1;
for (int i = 0; i < (m); ++i) {
for (int pos_cnt = (0); pos_cnt <= (i); ++pos_cnt) {
int neg_cnt = i - pos_cnt;
if (neg_cnt > np[0]) continue;
ADD(dp[i + 1][pos_cnt + 1], dp[i][pos_cnt] * (np[1] + pos_cnt) % MOD *
inv[pos_cnt - neg_cnt + M_SIZE]);
if (np[0] > neg_cnt)
ADD(dp[i + 1][pos_cnt], dp[i][pos_cnt] * (np[0] - neg_cnt) % MOD *
inv[pos_cnt - neg_cnt + M_SIZE]);
}
}
long long pos_cc = 0, neg_cc = 0;
dp_pos[0] = 1;
for (int i = 0; i < (m); ++i) {
dp_pos[i + 1] = (dp_pos[i] + dp_pos[i] * mypow(np[1] + i, MOD - 2)) % MOD;
}
for (int pos_cnt = (0); pos_cnt <= (m); ++pos_cnt) {
ADD(pos_cc, dp_pos[pos_cnt] * dp[m][pos_cnt]);
}
dp_neg[0] = 1;
for (int i = 0; i < (min(np[0], m)); ++i) {
dp_neg[i + 1] = (dp_neg[i] - dp_neg[i] * mypow(np[0] - i, MOD - 2)) % MOD;
if (dp_neg[i + 1] < 0) dp_neg[i + 1] += MOD;
}
for (int neg_cnt = (0); neg_cnt <= (min(np[0], m)); ++neg_cnt) {
ADD(neg_cc, dp_neg[neg_cnt] * dp[m][m - neg_cnt]);
}
for (int i = (1); i <= (n); ++i) {
if (a[i])
W(pos_cc * w[i] % MOD);
else
W(neg_cc * w[i] % MOD);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long n, m, a[100100];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
map<int, int> temp;
for (int i = 0; i < n; i++) {
if (a[i])
temp[a[i]] = 1;
else
temp[a[i]] = 0;
}
string ans = "";
int count = 0;
for (int i = 1; i <= m; i++) {
if (temp[i]) continue;
count++;
ans += to_string(i);
ans += " ";
m -= i;
}
printf("%d\n", count);
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long memo[107][2];
const long long MOD = 1000000007;
int n, k, d;
long long dp(int sum, bool in) {
if (sum == 0) {
return in;
}
long long &ret = memo[sum][in];
if (ret + 1) return ret;
ret = 0;
for (int i = 1; i <= k; ++i) {
if (i > sum) break;
ret += dp(sum - i, (in || i >= d));
if (ret >= MOD) ret -= MOD;
}
return ret;
}
int main() {
memset(memo, -1, sizeof memo);
scanf("%d %d %d", &n, &k, &d);
cout << dp(n, 0) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, o = 0;
int s[100000], c = 0;
cin >> k;
if (k == 0) {
cout << 1;
return 0;
}
while (k > 0) {
s[o] = k % 16;
o++;
k /= 16;
}
for (int i = o - 1; i >= 0; i--) {
if (s[i] == 0 || s[i] == 4 || s[i] == 6 || s[i] == 9 || s[i] == 10 ||
s[i] == 13) {
c++;
}
if (s[i] == 8 || s[i] == 11) {
c += 2;
}
}
cout << c;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 26;
const int inf = 0x3f3f3f3f;
int n;
int a[3][maxn];
char s[3][4] = {"MW", "LW", "LM"};
struct node {
int id, x, d1, d2;
node() {}
node(int id, int x, int d1, int d2) : id(id), x(x), d1(d1), d2(d2) {}
bool operator<(const node &rhs) const {
if (d1 != rhs.d1) return d1 < rhs.d1;
return d2 < rhs.d2;
}
} s1[2222222], s2[2222222];
node cal(int beg, int end, int st) {
int sum[3] = {0, 0, 0};
int ss = st;
for (int i = beg; i < end; i++) {
int x = st % 3;
st /= 3;
for (int j = 0; j < 3; j++) {
if (j == x) continue;
sum[j] += a[j][i];
}
}
return node(ss, sum[0], sum[1] - sum[0], sum[2] - sum[0]);
}
void print(int beg, int end, int st) {
for (int i = beg; i < end; i++) {
int x = st % 3;
puts(s[x]);
st /= 3;
}
}
int pow3[15];
int main() {
pow3[0] = 1;
for (int i = 1; i <= 13; i++) pow3[i] = pow3[i - 1] * 3;
while (cin >> n) {
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++) scanf("%d", &a[j][i]);
if (n == 1) {
bool flag = 0;
for (int i = 0; i < 3; i++) {
int cnt = 0;
for (int j = 0; j < 3; j++) {
if (j == i) continue;
if (a[j][0] == 0) cnt++;
}
if (cnt == 2) {
flag = 1;
puts(s[i]);
break;
}
}
if (!flag) puts("Impossible");
continue;
}
bool flag = 0;
int mx = -inf;
int m = n >> 1;
int c1 = pow3[m], c2 = pow3[n - m];
int st1, st2;
for (int i = 0; i < c1; i++) {
s1[i] = cal(0, m, i);
}
for (int i = 0; i < c2; i++) {
s2[i] = cal(m, n, i);
}
sort(s2, s2 + c2);
for (int i = 0; i < c1; i++) {
int beg = lower_bound(s2, s2 + c2, node(0, 0, -s1[i].d1, -s1[i].d2)) - s2;
int end = upper_bound(s2, s2 + c2, node(0, 0, -s1[i].d1, -s1[i].d2)) - s2;
for (int j = beg; j < end; j++) {
if (s1[i].d1 + s2[j].d1 != 0 || s1[i].d2 + s2[j].d2 != 0) break;
int all = s1[i].x + s2[j].x;
flag = 1;
if (all > mx) {
mx = all;
st1 = i;
st2 = s2[j].id;
}
}
}
if (!flag)
puts("Impossible");
else {
print(0, m, st1);
print(m, n, st2);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int temp;
int sum = 0;
vector<int> current;
vector<int> after;
for (int i = 0; i < n; i++) {
cin >> temp;
current.push_back(temp);
}
for (int i = 0; i < n; i++) {
cin >> temp;
sum += temp;
after.push_back(current[i] - temp);
}
sort(after.begin(), after.end());
for (int i = 0; i < k || after[i] < 0; i++) {
sum += after[i];
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[1 << 10][1 << 10];
bool vx[1 << 10], vy[1 << 10];
int dis[1 << 10][1 << 10];
queue<pair<int, int> > q;
pair<int, int> p1, p2;
int main() {
int i, n, m, x, y, ans;
while (scanf("%d%d", &n, &m) != EOF) {
ans = 1 << 30;
for (i = 0; i < n; i++) scanf("%s", s[i]);
memset(dis, 0, sizeof(dis));
memset(vx, 0, sizeof(vx));
memset(vy, 0, sizeof(vy));
while (!q.empty()) q.pop();
vx[n - 1] = 1;
for (i = 0; i < m; i++) {
dis[n - 1][i] = 1;
if (s[n - 1][i] == '#') {
q.push(make_pair(n - 1, i));
}
}
while (!q.empty()) {
p1 = q.front();
q.pop();
x = p1.first;
y = p1.second;
if (x == 0) ans = min(ans, dis[x][y]);
if (!vx[x]) {
vx[x] = 1;
for (i = 0; i < m; i++) {
if (!dis[x][i]) {
dis[x][i] = dis[x][y] + 1;
if (s[x][i] == '#') q.push(make_pair(x, i));
}
}
}
if (!vy[y]) {
vy[y] = 1;
for (i = 0; i < n; i++) {
if (!dis[i][y]) {
dis[i][y] = dis[x][y] + 1;
if (s[i][y] == '#') {
q.push(make_pair(i, y));
}
}
}
}
}
if (ans > 1234560) ans = -1;
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, i, x;
int s[5], ct[3];
memset(ct, 0, 3 * sizeof(int));
memset(s, 0, 5 * sizeof(int));
cin >> n >> k;
s[2] = 2 * n;
s[4] = n;
for (i = 0; i < k; i++) {
cin >> x;
while (x >= 3)
if (s[4])
s[4]--, x -= 4;
else if (s[2])
s[2]--, x -= 2;
else
return cout << "NO", 0;
if (x > 0) ct[x]++;
}
while (ct[2])
if (s[2])
s[2]--, ct[2]--;
else if (s[4])
s[4]--, ct[2]--, s[1]++;
else
ct[1] += (2 * ct[2]), ct[2] = 0;
if (ct[1] > s[1] + s[2] + 2 * s[4]) return cout << "NO", 0;
cout << "YES";
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
char arr[4] = {'v', '<', '^', '>'};
char st, fin;
int n, i, idx = 0, cnt;
scanf("%c %c %d", &st, &fin, &n);
if (n % 2 == 0) {
printf("undefined");
return 0;
}
n = n % 4;
while (arr[idx] != st) idx++;
cnt = 0;
for (i = idx; cnt <= n; i++) {
cnt++;
if (i % 4 == 0) i = 0;
}
if (i - 1 < 0) i = 3;
if (arr[i - 1] == fin) {
printf("cw");
return 0;
}
cnt = 0;
for (i = idx; cnt <= n; i--) {
cnt++;
if (i < 0) i = 3;
}
if (i + 1 > 3) i = 0;
if (arr[i + 1] == fin) {
printf("ccw");
return 0;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
void funky() {
long long int i = 1;
long long int dif = 2;
while (i <= 1000000000) {
v.push_back(i);
i += dif;
dif++;
}
}
int main() {
funky();
long long int n;
while (cin >> n) {
bool flag = false;
int i = 0, j = v.size() - 1;
while (i <= j) {
if (v[i] + v[j] == n) {
flag = true;
break;
} else if (v[i] + v[j] > n)
j--;
else if (v[i] + v[j] < n)
i++;
}
puts(flag ? "YES" : "NO");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 1e5 + 5;
set<pair<int, int> > S;
set<pair<int, int> >::iterator it;
int n, m, d[Nmax];
vector<pair<int, int> > L[Nmax];
set<int> C[Nmax];
set<int>::iterator it1;
int main() {
int x, y, c;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y >> c;
L[x].push_back({y, c});
L[y].push_back({x, c});
}
for (int i = 1; i <= n; i++) {
cin >> x;
for (int j = 1; j <= x; j++) {
cin >> y;
C[i].insert(y);
}
}
for (int i = 1; i <= n; i++) d[i] = LONG_MAX;
d[1] = 0;
S.insert({d[1], 1});
while (!S.empty()) {
it = S.begin();
x = it->first;
y = it->second;
S.erase(it);
it1 = C[y].find(x);
while (it1 != C[y].end()) {
x++;
it1 = C[y].find(x);
}
for (auto p : L[y])
if (d[p.first] > x + p.second) {
d[p.first] = x + p.second;
S.insert({d[p.first], p.first});
}
}
if (d[n] == LONG_MAX)
cout << "-1\n";
else
cout << d[n] << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, d, v, g, r;
scanf("%d%d%d%d%d", &l, &d, &v, &g, &r);
double time = 0;
time += d * 1.0 / v;
double t = time;
while (t > g + r) t -= g + r;
if (t >= g) time += (g + r) - t;
time += (l - d) * 1.0 / v;
printf("%.8lf\n", time);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, i, j;
while (cin >> n >> k) {
int j = 1;
for (i = 1, j = k + 1; i <= j; i++, j--) {
cout << i << " ";
if (i != j) cout << j << ' ';
}
for (int i = k + 2; i <= n; i++) cout << i << " ";
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, long long> par[100010];
vector<int> adj[100010];
long long need[100010];
long long cur[100010];
long long bad(long long a, long long b) {
double x = (double)a * b;
if (x < -2e17) {
cout << "NO\n";
exit(0);
}
return a * b;
}
long long dfs(int v) {
for (int e : adj[v]) {
cur[v] += dfs(e);
bad(cur[v], 1);
}
long long diff = cur[v] - need[v];
if (diff >= 0) {
return bad(diff, 1);
} else {
return bad(diff, par[v].second);
}
}
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> cur[i];
}
for (int i = 0; i < n; i++) {
cin >> need[i];
}
for (int i = 1; i < n; i++) {
cin >> par[i].first >> par[i].second;
par[i].first--;
adj[par[i].first].push_back(i);
}
par[0].second = 1;
dfs(0);
if (need[0] > cur[0]) {
cout << "NO\n";
} else {
cout << "YES\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1111;
const int inf = 1e7 + 3;
const long long mod = 1e9 + 7;
int main() {
string str;
cin >> str;
for (int i = 0; i < str.size() / 2; ++i)
if (str[i] == 'p')
str[i] = 'q';
else if (str[i] == 'q')
str[i] = 'p';
else if (str[i] == 'b')
str[i] = 'd';
else if (str[i] == 'd')
str[i] = 'b';
else if (str[i] != 'H' && str[i] != 'I' && str[i] != 'A' && str[i] != 'M' &&
str[i] != 'O' && str[i] != 'o' && str[i] != 'T' && str[i] != 'W' &&
str[i] != 'w' && str[i] != 'U' && str[i] != 'V' && str[i] != 'v' &&
str[i] != 'X' && str[i] != 'x' && str[i] != 'Y')
str[i] = '@';
for (int i = 0; i < str.size() / 2; ++i)
if (str[i] != str[str.size() - 1 - i]) return puts("NIE");
int i = str.size() / 2;
if (str.size() % 2 == 0)
puts("TAK");
else if (str[i] != 'H' && str[i] != 'I' && str[i] != 'A' && str[i] != 'M' &&
str[i] != 'O' && str[i] != 'o' && str[i] != 'T' && str[i] != 'W' &&
str[i] != 'w' && str[i] != 'U' && str[i] != 'V' && str[i] != 'v' &&
str[i] != 'X' && str[i] != 'x' && str[i] != 'Y')
puts("NIE");
else
puts("TAK");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using vi = vector<int>;
using vll = vector<long long>;
using vd = vector<double>;
using vvi = vector<vi>;
int ctoi(char c) { return c - '0'; }
int slen(string s) { return s.length(); }
int vsize(vi a) { return (int)a.size(); }
int in() {
int x;
cin >> x;
return x;
}
void kmin(long long n, long long m) {
long long val = n / m;
n = n - (val * m);
long long val1 = (m - n) * (val - 1) * (val) / 2;
long long val2 = n * val * (val + 1) / 2;
long long val3 = val1 + val2;
cout << val3 << " ";
}
void kmax(long long n, long long m) {
n = n - (m - 1);
long long val = n * (n - 1) / 2;
cout << val;
cout << endl;
}
void solve() {
long long n, i, j, ans = 0;
cin >> n;
long long x, y, mx = 0, mn = 0;
char c;
for (i = 0; i < n; i++) {
cin >> c >> x >> y;
if (x < y) swap(x, y);
if (c == '+') {
if (mx < x) mx = x;
if (mn < y) mn = y;
} else {
if (x >= mx && y >= mn)
cout << "YES\n";
else
cout << "NO\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dx4[] = {0, 0, -1, 1};
int dy4[] = {-1, 1, 0, 0};
int dx8[] = {0, 0, -1, 1, -1, -1, 1, 1};
int dy8[] = {-1, 1, 0, 0, -1, 1, -1, 1};
int knightx[] = {-1, 1, -2, 2, -2, 2, -1, 1};
int knighty[] = {-2, -2, -1, -1, 1, 1, 2, 2};
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
if (ch < '0' || ch > '9') break;
n = n * 10 + (ch - '0');
ch = getchar();
}
return (ng ? -n : n);
}
template <typename T>
inline T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return (POW(B, P / 2) * POW(B, P / 2));
}
template <typename T>
inline T Gcd(T a, T b) {
if (a < 0) return Gcd(-a, b);
if (b < 0) return Gcd(a, -b);
return (b == 0) ? a : Gcd(b, a % b);
}
template <typename T>
inline T Lcm(T a, T b) {
if (a < 0) return Lcm(-a, b);
if (b < 0) return Lcm(a, -b);
return a * (b / Gcd(a, b));
}
template <typename T>
T Bigmod(T base, T power, T MOD) {
T ret = T(1) % MOD;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
template <typename T>
long long isLeft(T a, T b, T c) {
return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}
template <typename T>
T ModInverse(T number, T MOD) {
return Bigmod(number, MOD - T(2), MOD);
}
bool isConst(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
bool isPrime(long long val) {
if (val == 2) return true;
if (val % 2 == 0 || val == 1) return false;
long long sqrt_N = (long long)((double)sqrt(val));
for (long long i = 3; i <= sqrt_N; i += 2) {
if (val % i == 0) return false;
}
return true;
}
template <class T>
string convert(T _input) {
stringstream blah;
blah << _input;
return blah.str();
}
bool valid(int r, int c, int x, int y) {
if (x >= 1 && x <= r && y >= 1 && y <= c) return 1;
return 0;
}
map<string, long long> month;
void Month() {
month["January"] = 1, month["February"] = 2, month["March"] = 3,
month["April"] = 4, month["May"] = 5, month["June"] = 6;
month["July"] = 7, month["August"] = 8, month["September"] = 9,
month["October"] = 10, month["November"] = 11, month["December"] = 12;
}
bool Check(int val, int pos) { return bool(val & (1 << pos)); }
int Set(int val, int pos) { return val | (1 << pos); }
int Reset(int val, int pos) { return val & (~(1 << pos)); }
int Flip(int val, int pos) { return val ^ (1 << pos); }
long long n, m, caseno;
long long a[200005];
long long b[200005];
long long Fun() {
long long left = 0, right = n, mid, res = 0;
while (left <= right) {
mid = left + ((right - left) >> 1);
if ((mid * (mid - 1)) / 2 >= m) {
res = mid;
right = mid - 1;
} else
left = mid + 1;
}
return res;
}
int main() {
long long i, j, t;
n = in<long long>(), m = in<long long>();
long long Mn = LLONG_MAX;
for (i = 1; i <= n; i++) {
a[i] = in<long long>();
Mn = min(Mn, a[i]);
}
long long Mx = 0LL;
for (i = 1; i <= n; i++) {
a[i] -= Mn;
Mx = max(Mx, a[i]);
}
for (i = 1; i <= n; i++) {
if (a[i]) {
b[1]++;
b[a[i] + 1]--;
}
}
long long d = 0;
for (i = 1; i <= Mx; i++) {
d += b[i];
a[i] = d;
}
long long tot = 0;
long long res = 0;
for (i = Mx; i >= 1; i--) {
if (tot + a[i] > m) {
tot = a[i];
res++;
if (i == 1) res++;
} else {
tot += a[i];
if (i == 1) res++;
}
}
printf("%lld\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
h[-1] = 0;
int current_dollar = 0, energy = 0;
for (int i = 0; i < n; i++) {
energy += (h[i - 1] - h[i]);
if (energy < 0) {
current_dollar += -energy;
energy = 0;
}
}
cout << current_dollar << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int sx, sy, ex, ey, ans;
while (~scanf("%d %d %d %d", &sx, &sy, &ex, &ey)) {
int x3, y3;
x3 = fabs(sx - ex);
y3 = fabs(sy - ey);
int n = max(y3, x3);
printf("%d\n", n);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, val[1000005], head[1000005], E[1000005 << 1], V[1000005 << 1];
int cnt, root, last, ans = 0x3f3f3f3f;
inline void in(int &now) {
char Cget = getchar();
now = 0;
while (Cget > '9' || Cget < '0') Cget = getchar();
while (Cget >= '0' && Cget <= '9') {
now = now * 10 + Cget - '0';
Cget = getchar();
}
}
void dfs(int now, int fa, int Min) {
val[now] = min(now, Min), Min = min(now, Min);
for (int i = head[now]; i; i = E[i]) {
if (fa == V[i]) continue;
dfs(V[i], now, Min);
}
}
int main() {
in(n), in(m);
int u, v;
for (int i = 1; i < n; i++) {
in(u), in(v);
E[++cnt] = head[u], V[cnt] = v, head[u] = cnt;
E[++cnt] = head[v], V[cnt] = u, head[v] = cnt;
}
in(root), in(root), root = root % n + 1, dfs(root, 0, 0x3f3f3f3f);
for (int i = 1; i < m; i++) {
in(u), in(v);
v = (last + v) % n + 1;
if (u == 1) ans = min(val[v], ans);
if (u == 2) last = min(ans, val[v]), printf("%d\n", last);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, l, r;
cin >> n >> l >> r;
vector<long long> a, p;
for (long long i = 0; i < n; ++i) {
long long b;
cin >> b;
a.push_back(b);
}
for (long long i = 0; i < n; ++i) {
long long b;
cin >> b;
p.push_back(b);
}
vector<tuple<long long, long long, long long>> wow;
for (long long i = 0; i < n; ++i) {
wow.push_back(make_tuple(p[i], a[i], i));
}
sort(wow.begin(), wow.end());
vector<pair<long long, long long>> ans;
ans.push_back(make_pair(get<2>(wow[0]), l - get<1>(wow[0])));
for (long long i = 1; i < n; ++i) {
if (r - get<1>(wow[i]) <= ans[i - 1].second) {
cout << -1 << endl;
return 0;
} else if (l - get<1>(wow[i]) > ans[i - 1].second) {
ans.push_back(make_pair(get<2>(wow[i]), l - get<1>(wow[i])));
} else {
ans.push_back(make_pair(get<2>(wow[i]), ans[i - 1].second + 1));
}
}
sort(ans.begin(), ans.end());
vector<long long> checker;
for (long long i = 0; i < n; ++i) {
long long true_value = ans[i].second + a[i];
if (true_value - ans[i].second < l || true_value - ans[i].second > r) {
cout << -1 << endl;
return 0;
} else
checker.push_back(true_value);
}
for (long long i = 0; i < n; ++i) {
cout << checker[i] << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse3", "sse2", "sse")
#pragma GCC target("avx", "sse4", "sse4.1", "sse4.2", "ssse3")
#pragma GCC target("f16c")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", \
"no-stack-protector")
using namespace std;
template <typename Iter>
ostream& _out(ostream& s, Iter b, Iter e) {
s << "[";
for (auto it = b; it != e; it++) s << (it == b ? "" : " ") << *it;
s << "]";
return s;
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
return out << '(' << p.first << ", " << p.second << ')';
}
template <class T1, class T2>
istream& operator>>(istream& in, pair<T1, T2>& p) {
return in >> p.first >> p.second;
}
template <typename T>
ostream& operator<<(ostream& s, const vector<T>& c) {
return _out(s, c.begin(), c.end());
}
template <typename T, size_t N>
ostream& operator<<(ostream& s, const array<T, N>& c) {
return _out(s, c.begin(), c.end());
}
inline char readchar() {
const int S = 1 << 20;
static char buf[S], *p = buf, *q = buf;
if (p == q && (q = (p = buf) + fread(buf, 1, S, stdin)) == buf) return EOF;
return *p++;
}
inline void input(int& _x) {
_x = 0;
int _tmp = 1;
char _tc = readchar();
while (_tc < '0' || _tc > '9') _tc = readchar();
while (_tc >= '0' && _tc <= '9')
_x = (_x << 1) + (_x << 3) + (_tc - 48), _tc = readchar();
}
inline void output(int _x) {
char _buff[20];
int _f = 0;
if (_x == 0) putchar('0');
while (_x > 0) {
_buff[_f++] = _x % 10 + '0';
_x /= 10;
}
for (_f -= 1; _f >= 0; _f--) putchar(_buff[_f]);
putchar('\n');
}
vector<int> u, v, uu, vv;
signed main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
;
string s, t;
cin >> s >> t;
u.push_back(0), v.push_back(0);
uu.push_back(0);
vv.push_back(0);
for (auto c : s) u.push_back(c != 'A');
for (auto c : t) v.push_back(c != 'A');
for (auto c : s) uu.push_back(c == 'A' ? 1 + uu.back() : 0);
for (auto c : t) vv.push_back(c == 'A' ? 1 + vv.back() : 0);
for (int i = 1; i < u.size(); i++) u[i] += u[i - 1];
for (int i = 1; i < v.size(); i++) v[i] += v[i - 1];
int q;
cin >> q;
while (q--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
if ((v[d] - v[c - 1]) < (u[b] - u[a - 1]))
putchar('0');
else if (((v[d] - v[c - 1]) - (u[b] - u[a - 1])) & 1)
putchar('0');
else if (min(uu[b], b - a + 1) < min(vv[d], d - c + 1))
putchar('0');
else if (u[b] - u[a - 1] == 0 && (v[d] - v[c - 1]) > 0 &&
min(uu[b], b - a + 1) == min(vv[d], d - c + 1))
putchar('0');
else if ((v[d] - v[c - 1]) > (u[b] - u[a - 1]) &&
min(uu[b], b - a + 1) > min(vv[d], d - c + 1))
putchar('1');
else if ((min(uu[b], b - a + 1) - min(vv[d], d - c + 1)) % 3 != 0)
putchar('0');
else
putchar('1');
}
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.