solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int flag = 0;
scanf("%d", &flag);
switch (flag) {
case 1:
printf("14");
break;
case 2:
printf("12");
break;
case 3:
printf("13");
break;
case 4:
printf("8");
break;
case 5:
printf("9");
break;
case 6:
printf("10");
break;
case 7:
printf("11");
break;
case 8:
printf("0");
break;
case 9:
printf("1");
break;
case 10:
printf("2");
break;
case 11:
printf("3");
break;
case 12:
printf("4");
break;
case 13:
printf("5");
break;
case 14:
printf("6");
break;
case 15:
printf("7");
break;
default:
printf("15");
break;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
const long long Mod = 1000000007LL;
long long AB(long long b, long long n) {
if (n < 0) return 0;
long long ans = 1;
while (n) {
if (n & 1) ans = (ans * b) % Mod;
n >>= 1;
b = (b * b) % Mod;
}
return ans;
}
int main() {
bool suc = true;
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; ++i) {
int s, t;
scanf("%d%d", &s, &t);
if (s + 1 != t && s + k + 1 != t) suc = false;
if (s + k + 1 == t) v.push_back(make_pair(s, t));
}
if (suc == false) {
puts("0");
return 0;
}
long long ans = 0;
if (v.size() == 0) {
for (int i = 1; i + k + 1 <= n; ++i) {
ans += AB(2, min(i + k, n - k - 1) - i);
ans %= Mod;
}
ans = (ans + 1) % Mod;
} else {
int t = v[0].second;
int s = v[v.size() - 1].first;
if (t <= s) {
puts("0");
return 0;
}
ans += AB(2, min(n - k, t) - s - 1);
for (int i = 1; i <= n; ++i) {
int j = i + k + 1;
if (j <= s || j >= t) continue;
long long r1 = AB(2, t - j - 1);
long long r2 = AB(2, min(n - k, j) - s - 1);
ans += (r1 * r2) % Mod;
ans %= Mod;
}
int ct = s - v[0].first + 1 - v.size();
ans = (ans * AB(2, ct)) % Mod;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void Max(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void Min(T &a, T b) {
if (a > b) a = b;
}
inline void add(int &a, int b) {
a += b;
while (a >= 1000000007) a -= 1000000007;
}
int pow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = 1LL * ans * a % 1000000007;
a = 1LL * a * a % 1000000007;
b >>= 1;
}
return ans;
}
int ne[100005], pr[100005], dead[100005], p[100005], a[100005], z[100005], m,
val[100005], p1[100005];
pair<int, int> b[100005];
priority_queue<pair<int, int> > q;
void check(int u, int v) {
int dist = p[v] - p[u];
if (dist < 0) dist += m;
if (dist <= a[u] && u < v)
val[u] = 1;
else if (a[u] <= a[v])
val[u] = 1000000007;
else if (u > v) {
int k = dist / (a[u] - a[v]);
if (dist % (a[u] - a[v])) k++;
val[u] = k;
} else {
int k = 1;
dist -= a[u];
k += dist / (a[u] - a[v]);
if (dist % (a[u] - a[v])) k++;
val[u] = k;
}
q.push(make_pair(-val[u], -u));
}
bool check2(int u, int v, int k) {
long long pos1 = z[u] * m + p[u] + 1LL * a[u] * k;
long long pos2 = z[v] * m + p[v] + 1LL * a[v] * (k - 1);
if (u > v) pos2 += a[v];
if (p1[u] > p1[v]) pos2 += m;
return pos1 >= pos2;
}
int main() {
int n, i, j, k;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d%d", &p[i], &a[i]);
p[i]--;
p1[i] = p[i];
b[i] = make_pair(p[i], i);
}
sort(b, b + n);
b[n] = b[0];
for (i = 0; i < n; i++) {
j = b[i].second, k = b[i + 1].second;
ne[j] = k;
pr[k] = j;
check(j, k);
}
int ans = n;
while (!q.empty()) {
int u = -q.top().second;
int t = -q.top().first;
q.pop();
if (dead[u]) continue;
if (t == 1000000007) break;
int v = ne[u];
bool ok = true;
while (check2(u, v, t)) {
ok = false;
dead[v] = true;
ans--;
if (ans == 1) break;
v = ne[v];
ne[u] = v, pr[v] = u;
if (a[u]) {
a[u]--;
p[u] += t;
z[u] += p[u] / m;
p[u] %= m;
}
}
if (ans == 1) break;
if (ok) continue;
check(u, ne[u]);
check(pr[u], u);
}
printf("%d\n", ans);
for (i = 0; i < n; i++)
if (!dead[i]) printf("%d ", i + 1);
puts("");
return 0;
}
| 5 |
#include<iostream>
#define x first
#define y second
using namespace std;
int main(){
pair<double,double>a1,a2,b1,b2;
while(cin>>a1.x>>a1.y>>a2.x>>a2.y>>b1.x>>b1.y>>b2.x>>b2.y){
bool f=0;
if(((a1.x<=b1.x&&b1.x<=a2.x)||(a1.x<=b2.x&&b2.x<=a2.x)||(b1.x<=a1.x&&a1.x<=b2.x)||(b1.x<=a2.x&&a2.x<=b2.x))
&&((a1.y<=b1.y&&b1.y<=a2.y)||(a1.y<=b2.y&&b2.y<=a2.y)||(b1.y<=a1.y&&a1.y<=b2.y)||(b1.y<=a2.y&&a2.y<=b2.y)))f=1;
if(f==1)cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int data[maxn], val[maxn], tol[maxn], tor[maxn], n;
int seg[maxn << 2];
void modify(int p, int v, int l, int r, int rt) {
if (l == r) {
seg[rt] = v;
return;
}
int m = (l + r) >> 1;
if (p <= m)
modify(p, v, l, m, rt << 1);
else
modify(p, v, m + 1, r, rt << 1 | 1);
seg[rt] = max(seg[rt << 1], seg[rt << 1 | 1]);
}
void modifymi(int p, int v, int l, int r, int rt) {
if (l == r) {
seg[rt] = v;
return;
}
int m = (l + r) >> 1;
if (p <= m)
modifymi(p, v, l, m, rt << 1);
else
modifymi(p, v, m + 1, r, rt << 1 | 1);
seg[rt] = min(seg[rt << 1], seg[rt << 1 | 1]);
}
int querymi(int ll, int rr, int l, int r, int rt) {
if (ll <= l && r <= rr) return seg[rt];
int m = (l + r) >> 1, res = n + 1;
if (ll <= m) res = min(res, querymi(ll, rr, l, m, rt << 1));
if (rr > m) res = min(res, querymi(ll, rr, m + 1, r, rt << 1 | 1));
return res;
}
int query(int ll, int rr, int l, int r, int rt) {
if (ll <= l && r <= rr) return seg[rt];
int m = (l + r) >> 1, res = 0;
if (ll <= m) res = max(res, query(ll, rr, l, m, rt << 1));
if (rr > m) res = max(res, query(ll, rr, m + 1, r, rt << 1 | 1));
return res;
}
void build(int l, int r, int rt) {
seg[rt] = n + 1;
if (l == r) return;
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
}
map<int, int> mp;
map<int, int>::iterator it;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", data + i);
mp[data[i]];
}
it = mp.begin();
for (int i = 1; i <= n; i++) {
it->second = i;
it++;
}
for (int i = 1; i <= n; i++) val[i] = mp[data[i]];
for (int i = 1; i <= n; i++) {
tol[i] = query(val[i], n, 1, n, 1);
modify(val[i], i, 1, n, 1);
}
build(1, n, 1);
for (int i = n; i >= 1; i--) {
tor[i] = querymi(val[i], n, 1, n, 1);
modifymi(val[i], i, 1, n, 1);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (tol[i]) ans = max(ans, data[i] ^ (data[tol[i]]));
if (tor[i] != n + 1) ans = max(ans, data[i] ^ (data[tor[i]]));
}
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
map<int, int> nxt[N];
int link[N], len[N], cnt = 1, las = 1, n, id[N], f[N][19];
int s[N];
void insert(int c) {
int cur = ++cnt, p = las;
len[cur] = len[las] + 1;
las = cur;
for (; p && !nxt[p][c]; p = link[p]) nxt[p][c] = cur;
if (!p)
link[cur] = 1;
else {
int q = nxt[p][c];
if (len[q] == len[p] + 1)
link[cur] = q;
else {
int clone = ++cnt;
len[clone] = len[p] + 1;
link[clone] = link[q];
link[q] = link[cur] = clone;
nxt[clone] = nxt[q];
for (; nxt[p][c] == q; p = link[p]) nxt[p][c] = clone;
}
}
}
struct segNode {
int l, r, v = 0;
} t[N * 30];
int root[N], sc;
vector<int> a[N];
void make_st() {
for (int i = 2; i <= cnt; i++) f[i][0] = link[i], a[link[i]].push_back(i);
for (int i = 1; i <= 18; i++)
for (int j = 2; j <= cnt; j++) f[j][i] = f[f[j][i - 1]][i - 1];
}
void update(int &now, int l, int r, int pos) {
if (!now) now = ++sc;
t[now].v++;
if (l == r) return;
if (pos <= (l + r) / 2)
update(t[now].l, l, (l + r) / 2, pos);
else
update(t[now].r, (l + r) / 2 + 1, r, pos);
}
int merge(int x, int y, int l, int r) {
if (x == 0 || y == 0) {
return x + y;
}
int now = ++sc;
t[now].v = t[x].v + t[y].v;
if (l == r) return now;
t[now].l = merge(t[x].l, t[y].l, l, (l + r) / 2);
t[now].r = merge(t[x].r, t[y].r, (l + r) / 2 + 1, r);
return now;
}
int query(int now, int l, int r, int x, int y) {
if (x <= l && r <= y) return t[now].v;
int ans = 0;
if (x <= (l + r) / 2) ans += query(t[now].l, l, (l + r) / 2, x, y);
if (y > (l + r) / 2) ans += query(t[now].r, (l + r) / 2 + 1, r, x, y);
return ans;
}
void dfs_for_merge(int now) {
for (auto to : a[now]) {
dfs_for_merge(to);
root[now] = merge(root[now], root[to], 1, n);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", s + i);
for (int i = 1; i < n; i++) {
int c = s[i + 1] - s[i];
insert(c);
id[i + 1] = las;
}
insert(2e9);
for (int i = 1; i < n; i++) {
int c = s[i] - s[i + 1];
insert(c);
update(root[las], 1, n, i + 1);
}
make_st();
dfs_for_merge(1);
t[root[1]].v = 0;
int q;
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
int l = y - x + 1;
if (l == 1)
printf("%d\n", n - 1);
else {
int p = id[y];
for (int i = 18; i >= 0; i--) {
if (len[f[p][i]] >= l - 1) p = f[p][i];
}
int ans = 0;
if (l <= x - 1) ans += query(root[p], 1, n, l, x - 1);
if (y + l <= n) ans += query(root[p], 1, n, y + l, n);
printf("%d\n", ans);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[])
{
int n;
cin>>n;
int a[n],f=1;
for (int i = 0; i < n; ++i)
{
cin>>a[i];
if (a[i]%2==1)
{
f=0;
}
}
if (f)
{
cout<<"second\n";
}
else
{
cout<<"first\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 3e5 + 10;
map<int, int> to[sz];
int ar[sz], q[sz], pr[sz], prsy[sz];
long long an;
void dfs(int l, int r) {
if (l != r) {
int mid = (l + r) >> 1, s = 0, qnt = 1;
prsy[0] = -1;
for (int a = mid; a >= l; a--) {
int sy = ar[a];
if (prsy[s] == sy)
s = pr[s];
else {
if (to[s].find(sy) == to[s].end()) {
pr[qnt] = s, prsy[qnt] = sy, to[s][sy] = qnt, s = qnt++;
} else
s = to[s][sy];
}
q[s]++;
}
s = 0;
for (int a = mid + 1; a <= r; a++) {
int sy = ar[a];
if (prsy[s] == sy)
s = pr[s];
else {
if (to[s].find(sy) == to[s].end()) {
pr[qnt] = s, prsy[qnt] = sy, to[s][sy] = qnt, s = qnt++;
} else
s = to[s][sy];
}
an += q[s];
}
for (int a = 0; a < qnt; a++) q[a] = 0, to[a].clear();
dfs(l, mid);
dfs(mid + 1, r);
}
}
int main() {
int q;
cin >> q;
while (q) {
q--;
int n;
scanf("%d", &n);
for (int a = 0; a < n; a++) scanf("%d", &ar[a]);
an = 0;
dfs(0, n - 1);
printf("%lld\n", an);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e2 + 10;
using ll = long long;
int a[N];
ll f[N][N];
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i)
cin >> a[i];
memset(f, 0x3f, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n + 1; ++i)
{
for (int j = 0; j < i; ++j)
for (int k = 0; k <= j; ++k)
f[i][j] = min(f[i][j], f[i - k - 1][j - k] + max(a[i] - a[i - k - 1], 0));
}
cout << f[n + 1][m];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void init() {
long long n, x;
cin >> n >> x;
vector<long long> a(n);
for (long long &i : a) cin >> i;
long long s = n - 1;
for (auto &x : a) s += x;
if (s == x)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int32_t main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
init();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
int N, a[169], c[169], K;
long long int M = -10000000000000LL;
int ned, prv[169], first[169];
long long int cap[20009], cost[20009], to[20009], nxt[20009], dist[169],
pot[169];
void init() {
memset(first, -1, sizeof first);
ned = 0;
}
void add(int u, int v, long long int f, long long int c) {
to[ned] = v, cap[ned] = f;
cost[ned] = c, nxt[ned] = first[u];
first[u] = ned++;
to[ned] = u, cap[ned] = 0;
cost[ned] = -c, nxt[ned] = first[v];
first[v] = ned++;
}
bool dijkstra(int s, int t) {
memset(prv, -1, sizeof prv);
for (int i = 0; i < N; i++) dist[i] = 1000000000000000000LL;
set<pair<long long int, int> > q;
q.insert(make_pair(0LL, s));
dist[s] = prv[s] = 0;
int u, v;
while (!q.empty()) {
u = q.begin()->second;
q.erase(q.begin());
for (int e = first[u]; e != -1; e = nxt[e]) {
if (cap[e] <= 0) continue;
v = to[e];
long long int new_dist = dist[u] + cost[e] + pot[u] - pot[v];
if (new_dist < dist[v]) {
q.erase(make_pair(dist[v], v));
dist[v] = new_dist;
prv[v] = e;
q.insert(make_pair(new_dist, v));
}
}
}
return prv[t] != -1;
}
inline long long int augment(int s, int t) {
for (int i = t; i != s; i = to[prv[i] ^ 1]) {
cap[prv[i]]--;
cap[prv[i] ^ 1]++;
}
--K;
long long int flowCost = dist[t] - pot[s] + pot[t];
for (int i = 0; i < N; i++)
if (prv[i] != -1) pot[i] += dist[i];
return flowCost;
}
long long int mincostmaxflow(int s, int t) {
long long int flowCost = 0;
memset(pot, 0, sizeof(pot));
while (K > 0 && dijkstra(s, t)) {
flowCost += augment(s, t);
}
return flowCost;
}
int main() {
set<int> v;
scanf("%d%d", &N, &K);
for (int i = 0; i < N; ++i) {
scanf("%d", &a[i]);
v.insert(a[i]);
}
for (int i = 1; i < N + 1; ++i) scanf("%d", &c[i]);
init();
K = min(K, (int)v.size());
for (int i = 0; i < N; ++i) {
add(0, 2 * i + 1, 1, c[a[i]]);
add(2 * i + 1, 2 * i + 2, 1, M);
add(2 * i + 2, 2 * N + 1, 1, 0);
for (int j = i + 1; j < N; ++j) {
if (a[i] != a[j])
add(2 * i + 2, 2 * j + 1, 1, c[a[j]]);
else
add(2 * i + 2, 2 * j + 1, 1, 0);
}
}
long long int n = N;
N = 2 * N + 2;
printf("%lld\n", mincostmaxflow(0, N - 1) - M * n);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int test(string s) {
int f = s.size() - 1;
for (int i = 0; i < s.size(); i++, f--) {
if (s.at(i) != s.at(f)) {
return 0;
}
}
return 1;
}
int main() {
string s, m = " ", s1;
cin >> s;
s1 = s;
for (char c = 'a'; c <= 'z'; c++) {
for (int i = 0; i < s1.length(); i++) {
s1 = s;
m[0] = c;
s1.insert(i, m);
if (test(s1) == 1) {
cout << s1;
return 0;
} else {
}
}
}
cout << "NA";
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define fread_siz 1024
inline int get_c(void)
{
static char buf[fread_siz];
static char *head = buf + fread_siz;
static char *tail = buf + fread_siz;
if (head == tail)
fread(head = buf, 1, fread_siz, stdin);
return *head++;
}
inline int get_i(void)
{
register int ret = 0;
register int neg = false;
register int bit = get_c();
for (; bit < 48; bit = get_c())
if (bit == '-')neg ^= true;
for (; bit > 47; bit = get_c())
ret = ret * 10 + bit - 48;
return neg ? -ret : ret;
}
template <class T>
inline T min(T a, T b)
{
return a < b ? a : b;
}
const int inf = 2e9;
const int maxn = 2005;
int n, m;
int s, t;
int flow;
int edges;
int hd[maxn];
int nt[maxn];
int to[maxn];
int vl[maxn];
int fl[maxn];
inline void add(int u, int v, int f, int w)
{
nt[edges] = hd[u]; to[edges] = v; fl[edges] = f; vl[edges] = +w; hd[u] = edges++;
nt[edges] = hd[v]; to[edges] = u; fl[edges] = 0; vl[edges] = -w; hd[v] = edges++;
}
int dis[maxn];
int pre[maxn];
inline bool spfa(void)
{
static int que[maxn];
static int inq[maxn];
static int head, tail;
memset(dis, 0x3f, sizeof(dis));
head = 0, tail = 0;
que[tail++] = s;
pre[s] = -1;
inq[s] = 1;
dis[s] = 0;
while (head != tail)
{
int u = que[head++], v; inq[u] = 0;
for (int i = hd[u]; ~i; i = nt[i])
if (dis[v = to[i]] > dis[u] + vl[i] && fl[i])
{
dis[v] = dis[u] + vl[i];
pre[v] = i ^ 1;
if (!inq[v])
inq[v] = 1, que[tail++] = v;
}
}
return dis[t] < 0x3f3f3f3f;
}
inline int expend(void)
{
int newFlow = inf;
for (int i = pre[t]; ~i; i = pre[to[i]])
newFlow = min(newFlow, fl[i ^ 1]);
for (int i = pre[t]; ~i; i = pre[to[i]])
fl[i] += newFlow, fl[i^1] -= newFlow;
return flow -= newFlow, newFlow * dis[t];
}
inline int mcmf(void)
{
int ret = 0;
while (spfa())
ret += expend();
return flow ? -1 : ret;
}
signed main(void)
{
n = get_i();
m = get_i();
flow = get_i();
memset(hd, -1, sizeof(hd));
for (int i = 1; i <= m; ++i)
{
int u = get_i();
int v = get_i();
int f = get_i();
int w = get_i();
add(u, v, f, w);
}
s = n, t = n - 1;
add(s, 0, flow, 0);
printf("%d\n", mcmf());
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
double s, b, l, r;
} d[525525];
int N, n, m, c, x, y, i, a[200200], b[200200], p[200200];
double cur[200200], r;
Node merge(Node l, Node r) {
Node b;
b.s = l.s + r.s;
b.b = max(l.r + r.l, max(l.b, r.b));
b.l = max(l.l, l.s + r.l);
b.r = max(r.r, r.s + l.r);
return b;
}
void init(int i, int L, int R) {
if (L < R) {
int h = (L + R) / 2;
init(i * 2, L, h);
init(i * 2 + 1, h + 1, R);
d[i] = merge(d[i * 2], d[i * 2 + 1]);
} else {
d[i].s = cur[L];
d[i].b = d[i].l = d[i].r = max(0.0, d[i].s);
}
}
Node best(int i, int L, int R, int l, int r) {
if (L == l && R == r) return d[i];
int h = (L + R) / 2;
if (r <= h) return best(i * 2, L, h, l, r);
if (l > h) return best(i * 2 + 1, h + 1, R, l, r);
return merge(best(i * 2, L, h, l, h), best(i * 2 + 1, h + 1, R, h + 1, r));
}
int main() {
scanf("%d%d%d", &n, &m, &c);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 1; i < n; i++) scanf("%d", &p[i]);
for (i = 1; i < n; i++) cur[i] = 0.5 * (a[i] - a[i - 1]) - 0.01 * p[i] * c;
for (N = 1; N < n; N *= 2)
;
init(1, 1, N);
for (i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
double o = r;
r += best(1, 1, N, x, y - 1).b;
}
printf("%.8lf\n", r);
return 0;
}
| 3 |
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
using namespace std;
#define N 100050
int n,a[N];
int gcd(int x,int y) {return y?gcd(y,x%y):x;}
void print(int x) {
puts((x&1)?"First":"Second");
exit(0);
}
int main() {
scanf("%d",&n);
int i;
for(i=1;i<=n;i++) scanf("%d",&a[i]);
int cas=0;
for(;;cas++) {
int i,flg=0,s=0,odd=0;
for(i=1;i<=n;i++) {
if(a[i]==1) flg=1;
s+=(a[i]-1);
if(a[i]&1) odd++;
}
if(flg==1) print(cas+s);
if(s&1) print(cas+1);
if(odd>1) print(cas);
for(i=1;i<=n;i++) if(a[i]&1) a[i]--;
int t=0;
for(i=1;i<=n;i++) t=gcd(a[i],t);
for(i=1;i<=n;i++) a[i]/=t;
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int a;
string s;
int main() {
cin>>a;
cin>>s;
if(a>=3200) cout<<s;
else cout<<"red";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
long double x, y;
pt() {}
pt(long double _x, long double _y) : x(_x), y(_y) {}
pt operator+(const pt &p) const { return pt(x + p.x, y + p.y); }
pt operator-(const pt &p) const { return pt(x - p.x, y - p.y); }
pt operator*(long double c) const { return pt(x * c, y * c); }
pt operator/(long double c) const { return pt(x / c, y / c); }
void operator+=(const pt &p) {
x += p.x;
y += p.y;
};
void operator-=(const pt &p) {
x -= p.x;
y -= p.y;
};
void operator*=(long double c) {
x *= c;
y *= c;
};
void operator/=(long double c) {
x /= c;
y /= c;
};
long double operator/(const pt &p) const { return (x * p.y - y * p.x); }
long double operator*(const pt &p) const { return (x * p.x + y * p.y); }
long double length() { return sqrtl(x * x + y * y); }
long double angle() { return atan2(y, x); }
};
struct treap {
int key, p, cnt;
treap *l, *r;
treap(int _key)
: key(_key),
p(((RAND_MAX < 1000000000) ? (rand() * rand()) : (rand()))),
cnt(1),
l(NULL),
r(NULL) {}
};
int getcnt(treap *t) {
if (t) return t->cnt;
return 0;
}
treap *upd(treap *t) {
if (!t) return t;
t->cnt = 1 + getcnt(t->l) + getcnt(t->r);
}
void split(treap *t, int key, treap *&l, treap *&r) {
if (!t) return void(l = r = NULL);
if (t->key < key)
split(t->l, key, l, t->l), r = t;
else
split(t->r, key, t->r, r), l = t;
upd(t);
}
treap *merge(treap *l, treap *r) {
if (!l || !r) return max(l, r);
if (l->p > r->p) {
l->r = merge(l->r, r);
return upd(l);
} else {
r->l = merge(l, r->l);
return upd(r);
}
}
struct rmq {
int l, r, MaxInd;
int Max, Add;
rmq *L, *R;
rmq(int b, int e) {
l = b;
r = e;
MaxInd = l;
Max = Add = 0;
if (b != e) {
L = new rmq(b, (b + e) / 2);
R = new rmq((b + e) / 2 + 1, e);
}
}
void SET(int i, int x) {
if (l == r)
Max = x;
else {
if (i <= L->r)
L->SET(i, x);
else
R->SET(i, x);
Max = max(L->Max + L->Add, R->Max + R->Add);
if (Max == L->Max + L->Add)
MaxInd = L->MaxInd;
else
MaxInd = R->MaxInd;
}
}
void ADD(int b, int e, int x) {
if (b > r || e < l) return;
if (b <= l && e >= r)
Add += x;
else {
L->ADD(b, e, x);
R->ADD(b, e, x);
Max = max(L->Max + L->Add, R->Max + R->Add);
if (Max == L->Max + L->Add)
MaxInd = L->MaxInd;
else
MaxInd = R->MaxInd;
}
}
int MAX(int b, int e) {
if (b > r || e < l) return -1000000000;
if (b <= l && e >= r)
return Max + Add;
else {
return max(L->MAX(b, e), R->MAX(b, e)) + Add;
}
}
pair<int, int> MAX_IND(int b, int e) {
if (b > r || e < l) return make_pair(-1000000000, -1000000000);
if (b <= l && e >= r)
return make_pair(Max + Add, MaxInd);
else {
pair<int, int> ans = max(L->MAX_IND(b, e), R->MAX_IND(b, e));
ans.first += Add;
return ans;
}
}
};
const int MAXN = 100 * 1000;
int n, m, k;
int a[MAXN], b[MAXN], c[MAXN];
int main() {
cin >> n >> m >> k;
for (int i = 0; i < m; ++i) cin >> a[i] >> b[i] >> c[i];
long long res = 0;
for (int i = 0; i < k; ++i) {
int x;
long long summ = 0;
cin >> x;
for (int j = 0; j < m; ++j) {
if (a[j] <= x && b[j] >= x) {
summ += c[j] + (x - a[j]);
}
}
res += summ;
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, a[1010], x, y, ans;
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < m; i++) {
cin >> x >> y;
ans += min(a[x - 1], a[y - 1]);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, z = 0;
cin >> n >> a >> b;
int chores[n];
for (int i = 0; i < n; i++) cin >> chores[i];
sort(chores, chores + n);
z = chores[b] - chores[b - 1];
cout << z << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<long long int> arr;
long long int temp, dist, diff1, diff2;
for (int i = 0; i < 3; i++) {
cin >> temp;
arr.push_back(temp);
}
cin >> dist;
sort(arr.begin(), arr.end());
diff1 = arr[0] + dist - arr[1];
diff2 = arr[0] + 2 * dist - arr[2];
if (diff1 > 0 && diff1 > diff2)
cout << diff1;
else if (diff2 > 0)
cout << diff2;
else if (diff1 <= 0 && diff2 <= 0)
cout << 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int a[100010];
int b[100010];
int c[100010];
int main(int argc, char* argv[]) {
int i, j, n;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; ++i) {
scanf("%d", &b[i]);
}
for (i = 1; i <= n; ++i) {
c[a[i]] = b[i];
}
for (i = 1; i <= n; ++i) {
printf("%d ", c[i]);
}
return 0;
}
| 6 |
#include "bits/stdc++.h"
using namespace std;
const int N = 1e5 + 5;
int n;
int a[N] , b[N];
int c[N] , d[N];
map < int , int > edges[N];
queue < pair < int , int > > q;
int comp[N];
int find(int node){
if(comp[node] == node){
return node;
}
return comp[node] = find(comp[node]);
}
void insert(int a , int b){
a = find(a);
b = find(b);
if(a != b){
++edges[a][b];
++edges[b][a];
if(edges[a][b] >= 2){
q.push({a , b});
}
}
}
void merge(){
int a = - 1 , b = -1;
while(!q.empty()){
a = find(q.front().first);
b = find(q.front().second);
q.pop();
if(a != b){
break;
}
}
if(a == b){
printf("NO\n");
exit(0);
}
if(edges[a].size() > edges[b].size()){
swap(a , b);
}
for(auto it : edges[a]){
edges[it.first].erase(edges[it.first].find(a));
}
comp[a] = b;
for(auto it : edges[a]){
if(it.first == b){
continue;
}
if(it.first == a){
continue;
}
while(it.second--){
insert(b , find(it.first));
}
}
edges[a].clear();
}
int main(){
scanf("%d" , &n);
for(int i = 1 ; i < n ; ++i){
scanf("%d %d" , a + i , b + i);
}
for(int i = 1 ; i < n ; ++i){
scanf("%d %d" , c + i , d + i);
}
for(int i = 1 ; i <= n ; ++i){
comp[i] = i;
}
for(int i = 1 ; i < n ; ++i){
insert(a[i] , b[i]);
insert(c[i] , d[i]);
}
for(int i = 1 ; i < n ; ++i){
merge();
}
printf("YES\n");
} | 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n, m;
cin >> n >> m;
vector<string> a(n), b(m);
rep(i, n) cin >> a[i];
rep(i, m) cin >> b[i];
rep(i, n - m + 1) {
rep(j, n - m + 1) {
bool flag = true;
rep(k, m) rep(l, m) flag &= (a[i + k][j + l] == b[k][l]);
if (flag) {
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
return 0;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
struct Edge {
int v, nxt;
int id;
Edge() {}
Edge(int vv, int next) {
v = vv;
nxt = next;
}
} edge[N << 1];
int idx;
int head[N];
void addEdge(int u, int v, int id) {
edge[++idx] = Edge(v, head[u]);
edge[idx].id = id;
head[u] = idx;
}
vector<int> ret[N];
int mx = 0;
void dfs(int u, int f, int fob) {
int cnt = 1;
for (int k = head[u]; k; k = edge[k].nxt) {
int v = edge[k].v;
if (v == f) continue;
int id = edge[k].id;
while (cnt == fob) cnt++;
mx = max(mx, cnt);
dfs(v, u, cnt);
ret[cnt++].push_back(id);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
addEdge(u, v, i);
addEdge(v, u, i);
}
dfs(1, -1, 0);
printf("%d\n", mx);
for (int i = 1; i <= mx; i++) {
printf("%d", ret[i].size());
for (int j = 0; j < ret[i].size(); j++) printf(" %d", ret[i][j]);
puts("");
}
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int main() {
int n;
while (cin >> n && n != 0) {
int A=0, B=0, a, b;
for (int i=0; i<n; i++) {
cin >> a >> b;
if (a > b) {
A += a+b;
} else if (a < b) {
B += a+b;
} else {
A += a;
B += b;
}
}
cout << A << " " << B << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int cnt[100005], vis[100005], steps[100005];
int main() {
int n, res = 2000000000, x, y;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
queue<pair<int, int> > q;
q.push(make_pair(x, 0));
while (!q.empty()) {
x = q.front().first;
y = q.front().second;
q.pop();
if (x > 100003) continue;
if (vis[x] == i) continue;
vis[x] = i;
steps[x] += y;
cnt[x]++;
q.push(make_pair(x * 2, y + 1));
q.push(make_pair(x / 2, y + 1));
}
}
for (int i = 0; i <= 100000; i++)
if (cnt[i] == n)
if (res > steps[i]) res = steps[i];
printf("%d", res);
return 0;
}
| 3 |
// 6/2
// 2-6-4. 素数のこすう
// エラトステネスの篩
#include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1e9;
// Sieve of Eratosthenes
// https://youtu.be/UTVg7wzMWQc?t=2774
struct Sieve {
int n;
vector<int> f, primes;
Sieve(int n=1):n(n), f(n+1) {
f[0] = f[1] = -1;
for (ll i = 2; i <= n; ++i) {
if (f[i]) continue;
primes.push_back(i);
f[i] = i;
for (ll j = i*i; j <= n; j += i) {
if (!f[j]) f[j] = i;
}
}
}
bool isPrime(int x) { return f[x] == x;}
vector<int> factorList(int x) {
vector<int> res;
while (x != 1) {
res.push_back(f[x]);
x /= f[x];
}
return res;
}
vector<P> factor(int x) {
vector<int> fl = factorList(x);
if (fl.size() == 0) return {};
vector<P> res(1, P(fl[0], 0));
for (int p : fl) {
if (res.back().first == p) {
res.back().second++;
} else {
res.emplace_back(p, 1);
}
}
return res;
}
};
int main() {
// vector<vector<bool>> is_unique(1e6 + 1, vector<bool>(1e6 + 1, true)); // is_unique[i][j] = j / iがユニークかどうか
// for (int i = 1; i < 1e6; i++) {
// for (int j = 1; j < )
// }
// Sieve sieve(1e6);
// vector<int> f(1e6 + 1); // f[i] = 分母がiの時の項目数
// f[0] = 0;
// f[1] = 2; // 0/1, 1/1
// for(int i = 2; i <= 1e6; i++) {
// vector<P> fact = sieve.factor(i);
// ll yakusu = 1;
// for (auto f : fact) {
// yakusu *= f.second + 1;
// }
// f[i] = i - yakusu;
// }
// vector<int> unique(1e6 + 1); // unique[i] = 分母がiで約分できない数。ただし0は覗く。
// rep(i, 1e6 + 1) unique[i] = i;
// for (int i = 1; i <= 1e6; i++) {
// for (int j = i * 2; j <= 1e6; j += i) {
// unique[j]--;
// }
// }
// unique[1] += 1; // 1の時は0/1があるので特殊。
// vector<int> ans(1e6 + 1);
// ans[0] = 0;
// for(int i = 1; i <= 1e6; i++) {
// printf("unique[%d] = %d\n", i, unique[i]);
// ans[i] = ans[i - 1] + unique[i];
// };
Sieve sieve(1e6);
vector<ll> F(1e6 + 1);
F[0] = 0;
F[1] = 2;
for (int i = 2; i <= 1e6; i++) {
vector<P> primes = sieve.factor(i);
F[i] = i;
for (auto p : primes) {
F[i] *= (1.0 - 1.0 / (double)p.first);
}
}
// rep(i, 10) {
// printf("F[%d] = %d\n", i, F[i]);
// }
vector<ll> ans(1e6 + 1);
ans[0] = 0;
for (int i = 1; i <= 1e6; i++) {
ans[i] = ans[i - 1] + F[i];
}
int t;
cin >> t;
vector<int> n(t);
rep(i, t) cin >> n[i];
rep(i, t) cout << ans[n[i]] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
int n, m, k;
int main() {
n = in();
m = in();
k = in();
int lane = k / (2 * m);
int rem = k % (2 * m);
if (rem == 0) {
cout << lane << ' ' << m << ' ' << 'R' << endl;
} else {
int row = rem / 2;
if (rem % 2) row++;
cout << lane + 1 << ' ' << row << ' ';
if (k & 1)
cout << 'L' << endl;
else
cout << 'R' << endl;
}
return 0;
}
| 1 |
#define _USE_MATH_DEFINES
#define INF 100000000
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
static const double EPS = 1e-8;
int main(){
int N,K;
int tank[100];
while(~scanf("%d %d",&N,&K)){
if(N==K && K==0) break;
for(int i=0;i<K;i++){
scanf("%d",tank+i);
}
bool isok = true;
for(int i=0;i<N;i++){
for(int j=0;j<K;j++){
int B;
scanf("%d",&B);
tank[j]-=B;
if(tank[j]<0) isok = false;
}
}
printf("%s\n",isok ? "Yes" : "No");
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, L, s, t;
long long Calc(long long a, long long b, long long c, long long L) {
long long tmp = 0;
if (b + c > a) tmp = b + c - a;
if (tmp > L) return 0;
a += tmp;
L -= tmp;
long long Res = 0;
for (long long i = 0; i <= L; i++) {
tmp = min(a + i - b - c, L - i);
Res += (tmp + 1) * (tmp + 2) / 2;
}
return Res;
}
int main() {
cin >> a >> b >> c >> L;
t = (L + 1) * (L + 2) * (L + 3) / 6;
s = Calc(a, b, c, L);
s += Calc(b, a, c, L);
s += Calc(c, a, b, L);
cout << t - s << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void read(int &x) { scanf("%d", &x); }
void read(long long int &x) { scanf("%I64d", &x); }
void read(long long int &a, long long int &b) { scanf("%I64d %I64d", &a, &b); }
void read(long long int &a, long long int &b, long long int &c) {
scanf("%I64d %I64d %I64d", &a, &b, &c);
}
void read(long long int &a, long long int &b, long long int &c,
long long int &d) {
scanf("%I64d %I64d %I64d %I64d", &a, &b, &c, &d);
}
void read(double &x) { scanf("%lf", &x); }
void read(char &x) { scanf("%c", &x); }
void read(string &x) {
char y[1000006];
scanf("%s", &y);
x = y;
}
void print(long long int x, bool flag = false) {
if (flag)
printf("%I64d ", x);
else
printf("%I64d\n", x);
}
void print(int x, bool flag = false) {
if (flag)
printf("%d ", x);
else
printf("%d\n", x);
}
void print(double x, bool flag = false) {
if (flag)
printf("%0.14lf ", x);
else
printf("%0.14lf\n", x);
}
void print(char x) { printf("%c\n", x); }
void print(string x) {
for (long long int i = 0; i < x.size(); i++) {
printf("%c", x[i]);
}
printf("\n");
}
void solve() {
long long int n;
read(n);
set<long long int> numbers;
map<long long int, long long int> left;
map<long long int, long long int> right;
long long int node;
read(node);
numbers.insert(node);
for (long long int i = 0; i < n - 1; i++) {
read(node);
long long int res;
auto it = numbers.upper_bound(node);
if (it != numbers.end() && left.count(*it) == 0) {
left[*it] = node;
res = *it;
} else {
it--;
right[*it] = node;
res = *it;
}
numbers.insert(node);
print(res, true);
}
printf("\n");
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <iostream>
using namespace std;
int main(){
int H,W,i,j;
cin >> H >> W;
string s[H];
for (i=0;i<H;++i) {
cin >> s[i];
}
for (i=0;i<H;++i) {
for (j=0;j<W;++j) {
if (s[i][j]=='#') {
if ((i==0 || s[i-1][j]=='.') && (i==H-1 || s[i+1][j]=='.') && (j==0 || s[i][j-1]=='.') && (j==W-1 || s[i][j+1]=='.')) {
cout << "No" << endl;
return 0;
}
}
}
}
cout << "Yes" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool q;
char c[10];
string s[6];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c[i];
}
s[0] = "jolteon";
s[1] = "flareon";
s[2] = "umbreon";
s[3] = "leafeon";
s[4] = "glaceon";
s[5] = "sylveon";
if (n == 6) {
cout << "espeon";
} else {
if (n == 8) {
cout << "vaporeon";
} else {
for (int i = 0; i < 6; i++) {
q = true;
for (int j = 0; j < n; j++) {
if (c[j] != s[i][j]) {
if (c[j] != '.') {
q = false;
break;
}
}
}
if (q) {
cout << s[i];
break;
}
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char input[1000001];
int main() {
cin >> input;
stack<char> s;
s.push(input[strlen(input) - 1]);
for (int i = strlen(input) - 2; i >= 0; i--) {
if (input[i] >= s.top()) {
s.push(input[i]);
}
}
while (!s.empty()) {
cout << s.top();
s.pop();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
multiset<long long> Inc[MAXN], Max, Min;
long long T[MAXN], Cmin[MAXN], Cmax[MAXN], G[MAXN], Self[MAXN], Els[MAXN];
int C[MAXN], Fa[MAXN], N, Q;
long long Smin(int x) { return (*Inc[x].begin()) + G[x]; }
long long Smax(int x) { return (*Inc[x].rbegin()) + G[x]; }
void Push(int p) {
if (!Inc[p].empty())
Max.insert(Cmax[p] = Smax(p)), Min.insert(Cmin[p] = Smin(p));
else
Cmax[p] = Cmin[p] = -1;
}
void DelInfo(int x, int y, int z) {
static int A[MAXN];
int c = 0;
A[++c] = x, A[++c] = y, A[++c] = z;
for (int i = 1; i <= 6; i++) A[++c] = Fa[A[i]];
sort(A + 1, A + c + 1);
int t = 1;
for (int j = 2; j <= c; j++)
if (A[j] != A[t]) A[++t] = A[j];
for (int i = 1; i <= t; i++) {
int p = A[i];
if (Cmax[p] != -1)
Max.erase(Max.find(Cmax[p])), Min.erase(Min.find(Cmin[p]));
Inc[Fa[p]].erase(Inc[Fa[p]].find(Els[p] + Self[p]));
}
for (int i = 1; i <= t; i++) {
int p = A[i];
Els[Fa[p]] -= G[p];
}
}
void InsInfo(int x, int y, int z) {
static int A[MAXN];
int c = 0;
A[++c] = x, A[++c] = y, A[++c] = z;
for (int i = 1; i <= 6; i++) A[++c] = Fa[A[i]];
sort(A + 1, A + c + 1);
int t = 1;
for (int j = 2; j <= c; j++)
if (A[j] != A[t]) A[++t] = A[j];
for (int i = 1; i <= t; i++) {
int p = A[i];
G[p] = T[p] / (C[p] + 2), Els[Fa[p]] += G[p],
Self[p] = T[p] - (C[p] + 1) * G[p];
}
for (int i = 1; i <= t; i++) {
int p = A[i];
Inc[Fa[p]].insert(Els[p] + Self[p]);
}
for (int i = 1; i <= t; i++) Push(A[i]);
}
void Modify(int u, int v) {
int fr = Fa[u];
DelInfo(fr, u, v);
C[fr]--, C[v]++, Fa[u] = v;
InsInfo(fr, u, v);
}
int main() {
scanf("%d%d", &N, &Q);
for (int i = 1; i <= N; i++) scanf("%I64d", &T[i]);
for (int i = 1; i <= N; i++) scanf("%d", &Fa[i]), C[Fa[i]]++;
for (int i = 1; i <= N; i++)
G[i] = T[i] / (C[i] + 2), Els[Fa[i]] += G[i],
Self[i] = T[i] - (C[i] + 1) * G[i];
for (int i = 1; i <= N; i++)
Inc[Fa[i]].insert(Self[i] + Els[i]), Cmax[i] = Cmin[i] = -1;
for (int i = 1; i <= N; i++)
if (!Inc[i].empty())
Min.insert(Cmin[i] = Smin(i)), Max.insert(Cmax[i] = Smax(i));
for (int i = 1; i <= Q; i++) {
int type, u, v;
scanf("%d", &type);
if (type == 1) {
scanf("%d%d", &u, &v);
Modify(u, v);
}
if (type == 2) {
scanf("%d", &u);
printf("%I64d\n", Els[u] + Self[u] + G[Fa[u]]);
}
if (type == 3) printf("%I64d %I64d\n", *Min.begin(), *Max.rbegin());
}
return 0;
}
| 4 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
using namespace std;
int n,r;
void shuffle(vector<int> &v,int c){
stack<int> A;
stack<int> B;
for(int i = v.size()-1; i >= 0; i--){
if(i<v.size()/2){
B.push(v[i]);
}
else
A.push(v[i]);
}
v.clear();
while(1){
for(int i = 0; i < c&&!A.empty(); i++){
v.push_back(A.top());
A.pop();
}
for(int i = 0; i < c&&!B.empty(); i++){
v.push_back(B.top());
B.pop();
}
if(A.size()==0&&B.size()==0)
break;
}
}
int main(){
while(cin>>n>>r){
vector<int> cs;
for(int i = 0; i < r; i++){
int c;
cin>>c;
cs.push_back(c);
}
vector<int> v;
for(int i = 0; i < n; i++){
v.push_back(i);
}
for(int i = 0; i < r; i++){
shuffle(v,cs[i]);
}
cout<<v[v.size()-1]<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 554400;
char ss[maxn];
long long a, n;
long long x[maxn], s[maxn];
long long h[maxn];
int main() {
cin >> a;
cin >> ss;
n = (long long)strlen(ss);
for (int i = 0; i < n; i++)
x[i + 1] = ss[i] - '0', s[i + 1] = s[i] + x[i + 1];
long long i, j;
for (i = 1; i <= n; i++)
for (j = 0; j < i; j++) h[s[i] - s[j]]++;
long long ans = 0;
if (a == 0) {
for (i = 0; i <= s[n]; i++) ans += h[0] * h[i];
}
for (i = 1; i <= s[n]; i++) {
if ((a % i == 0) && (a / i <= s[n])) ans += h[i] * h[a / i];
}
cout << ans << endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll dp[60][60][3000];
int main(){
int n,a;cin>>n>>a;
int x[60];
for(int i=0;i<n;i++){
cin>>x[i];
}
dp[0][0][0]=1;
for(int i=0;i<n;i++){
for(int j=0;j<=i;j++){
for(int k=0;k<=2600;k++){
dp[i+1][j][k]+=dp[i][j][k];
dp[i+1][j+1][k+x[i]]+=dp[i][j][k];
}
}
}
ll ans=0;
for(int i=1;i<=n;i++){
ans+=dp[n][i][i*a];
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include<iostream>
using namespace std;
int main()
{
int x;
cin >> x;
if((x/100)*5>=x%100) cout <<"1";
else cout << "0";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
bool f[100001];
int c[100002];
int main() {
for (int i=2; i<=100000; i++) {
if (!f[i]) {
for (int j=i+i; j<=100000; j+=i)
f[j] = true;
}
}
for (int i=3; i<=100000; i+=2) {
if (!f[i] && !f[(i+1)/2])
c[i]++;
}
for (int i=3; i<=100000; i++)
c[i] += c[i-1];
int q;
scanf("%d", &q);
for (int i=0; i<q; i++) {
int l, r;
scanf("%d %d", &l, &r);
printf("%d\n", c[r]-c[l-1]);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace ::std;
uint64_t to_dec(vector<int> &v) {
uint64_t ans = 0;
for (int i = 0; i < v.size(); i++) {
ans <<= 1;
if (v[i]) ans |= 1;
}
return ans;
}
int main() {
vector<uint64_t> P;
P.reserve(3000);
for (int len = 2; len <= 60; len++) {
vector<int> v(len, 1);
for (int i = 1; i < len; i++) {
v[i] = 0;
P.push_back(to_dec(v));
v[i] = 1;
}
}
uint64_t a, b;
cin >> a >> b;
uint64_t ans = 0;
for (int i = 0; i < P.size(); i++)
if ((P[i] >= a) && (P[i] <= b)) ans++;
std::cout << ans << std::endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
string s;
cin >> s;
int pos = 0;
int t;
for (int i = 0; i < s.size(); i++) {
t = s[i] - 'a';
if (t > pos) {
if (t - pos > 13) {
n += 13 - (t - pos) % 13;
} else {
n += t - pos;
}
} else {
if (pos - t > 13) {
n += 13 - (pos - t) % 13;
} else {
n += pos - t;
}
}
pos = t;
}
cout << n << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[5], sum = 0, minn = 1000;
for (int i = 0; i < 5; ++i) {
cin >> a[i];
sum += a[i];
}
sort(a, a + 5);
minn = sum;
for (int i = 4; i >= 1; --i) {
if (a[i] == a[i - 1] && a[i - 1] == a[i - 2] && i >= 2) {
if (sum - a[i] * 3 < minn) minn = sum - a[i] * 3;
}
if (a[i] == a[i - 1]) {
if (sum - a[i] * 2 < minn) minn = sum - a[i] * 2;
}
}
cout << minn;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, q;
cin >> n >> m >> q;
int a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
int c = 0, mx;
vector<int> v(n, 0);
for (int i = 0; i < n; i++) {
mx = INT_MIN;
c = 0;
for (int j = 0; j < m; j++) {
if (a[i][j] == 1) {
c++;
} else {
mx = max(c, mx);
c = 0;
}
}
mx = max(c, mx);
v[i] = mx;
}
while (q--) {
int x, y;
cin >> x >> y;
x--;
y--;
if (a[x][y] == 1) {
a[x][y] = 0;
} else {
a[x][y] = 1;
}
mx = INT_MIN;
c = 0;
for (int i = 0; i < m; i++) {
if (a[x][i] == 1) {
c++;
} else {
mx = max(c, mx);
c = 0;
}
}
mx = max(c, mx);
v[x] = mx;
mx = 0;
for (int i = 0; i < v.size(); i++) {
mx = max(mx, v[i]);
}
cout << mx << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int Get() {
int res = 0, q = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') q = -1, ch = getchar();
while (ch >= '0' && ch <= '9') res = res * 10 + ch - '0', ch = getchar();
return res * q;
}
const double eps = 1e-12, pi = M_PI;
const int oo = (int)2e9, mod = (int)1e9 + 7;
const long long INF = (long long)1e17;
const int N = (int)1e6;
int n, m, K, d;
char s[2][N + 10];
int f[N + 10][22];
int main() {
scanf("%s", s[0]), n = strlen(s[0]);
int cur = 0;
scanf(
"%d"
"\n",
&m);
for (; m--;) {
scanf(
"%d"
"%d"
"\n",
&K, &d);
cur ^= 1;
if (K == 1 && d == 1) {
for (int i = (0), end = (n - 1); i <= end; ++i) s[cur][i] = s[cur ^ 1][i];
for (int i = (0), end = (n - 1); i <= end; ++i) printf("%c", s[cur][i]);
printf("\n");
continue;
}
int tot = 0;
for (int i = (0), end = (d - 1); i <= end; ++i) {
f[i][0] = tot++;
for (int j = i + d; j < K; j += d) f[j][0] = f[j - d][0] + 1, ++tot;
}
for (int i = (1), end = (20); i <= end; ++i) {
int to = 1 << (i - 1);
if (to > n) break;
for (int j = (0), end = (K - 1); j <= end; ++j) {
int k = f[j][i - 1];
if (k <= to)
f[j][i] = k;
else
f[j][i] = f[k - to][i - 1] + to;
}
}
int u = K - 1;
for (int i = (0), end = (n - 1); i <= end; ++i) {
int tot = 0, now = min(i, u), ed = min(n - i, n - K + 1);
for (int j = (20), end = (0); j >= end; --j)
if (tot + (1 << j) <= ed) {
if (now <= tot) break;
now = tot + f[now - tot][j], tot += (1 << j);
}
now += max(0, i - u);
s[cur][now] = s[cur ^ 1][i];
}
for (int i = (0), end = (n - 1); i <= end; ++i) printf("%c", s[cur][i]);
printf("\n");
}
return 0;
}
| 3 |
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int n;
int m[40];
int s[40];
int p[21],d[21];
int f,tmp;
while(1){
cin >> n;
if(!n)break;
for(int i=0;i<n;i++){
cin >> m[i];
s[i] = 0;
for(int j=0;j<21;j++)p[j] = 0;
for(int j=0;j<21;j++)d[j] = 1;
f = 0;
while(1){
cin >> tmp;
if(f<18){
if(!(f%2) && tmp==10){
p[f] = 10;
f+=2;
}else{
p[f] = tmp;
f++;
}
}else{
if(f==18){
p[f] = tmp;
f++;
}else if(f==19){
p[f] = tmp;
if(p[f-1]+p[f] > 9){
cin >> tmp;
p[f+1] = tmp;
}
break;
}
}
}
for(int j=0;j<18;j++){
if(!(j%2) && p[j]==10){
d[j+2]++;
if(p[j+2]==10 && j+2 != 18)d[j+4]++;
else d[j+3]++;
}else if(p[j] && j%2 && p[j-1]+p[j]==10){
d[j+1]++;
}
}
for(int j=0;j<21;j++){
s[i]+=d[j]*p[j];
}
}
for(int i=0;i<n-1;i++){
for(int j=i+1;j<n;j++){
if(s[i]<s[j]){
swap(s[i],s[j]);
swap(m[i],m[j]);
}else if(s[i]==s[j] && m[i]>m[j]){
swap(s[i],s[j]);
swap(m[i],m[j]);
}
}
}
for(int i=0;i<n;i++){
cout << m[i] << " " << s[i] << endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, numbit[60], dp[110][(1 << 17) + 10], ara[110], dir[110][(1 << 17) + 10];
int prms[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59};
void print(int pos, int mask) {
if (pos == 0) return;
print(pos - 1, (mask & ~(numbit[dir[pos][mask]])));
cout << dir[pos][mask] << " ";
}
int main() {
for (int i = 2; i <= 59; i++) {
for (int j = 0; j < 17; j++) {
if (i % prms[j] == 0) numbit[i] |= (1 << j);
}
}
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &ara[i]);
memset(dp, 0x3f, sizeof dp);
dp[0][0] = 0;
int ans = INT_MAX, last;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 59; j++) {
int x = ((1 << 17) - 1) & (~numbit[j]);
for (int mask = x;; mask = (mask - 1) & x) {
if (dp[i - 1][mask] + abs(ara[i] - j) < dp[i][mask | numbit[j]]) {
dp[i][mask | numbit[j]] = dp[i - 1][mask] + abs(ara[i] - j);
dir[i][mask | numbit[j]] = j;
}
if (i == n) {
if (dp[i][mask | numbit[j]] < ans) {
ans = dp[i][mask | numbit[j]];
last = mask | numbit[j];
}
}
if (mask == 0) break;
}
}
}
print(n, last);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
string s, t;
cin >> s >> t;
vector<int> ans;
for (int i = 0; i < n; i++) {
if (s[i] == t[i]) continue;
for (int j = i + 1; j < n; j++) {
if (s[j] == t[i]) {
for (int w = j - 1; w >= i; w--) {
char temp = s[w];
s[w] = s[w + 1];
s[w + 1] = temp;
ans.push_back(w + 1);
}
break;
}
}
if (s[i] != t[i]) {
cout << -1;
return;
}
}
cout << ans.size() << endl;
for (int i : ans) {
cout << i << " ";
}
}
int main() { solve(); }
| 2 |
#include <bits/stdc++.h>
//#include <sys/resource.h>
#define initrand mt19937 mt_rand(time(0));
#define rand mt_rand()
#define int long long
#define MOD 1000000007
#define INF 1000000000
#define mid(l, u) ((l+u)/2)
#define rchild(i) (i*2 + 2)
#define lchild(i) (i*2 + 1)
#define mp(a, b) make_pair(a, b)
#define lz lazup(l, u, i);
using namespace std;
const int N = 55;
signed dp[N][N*N], p[N][N*N], nCr[N][N];
int fac[N];
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, mod;
cin>>n>>mod;
dp[0][0] = 1;
dp[0][0] %= mod;
for(int i = 1;i<=n;i++){ //dp[i][k] + dp[k-1] + ... + dp[k-(i-1)] + dp[k-i]
int sum = 0;
int maxi = i*(i-1)/2;
for(int j = 0;j<=maxi;j++){
sum += dp[i-1][j];
sum %= mod;
if((j - i)>=0) sum -= dp[i-1][j-i];
sum += mod;
sum %= mod;
dp[i][j] = sum;
}
p[i][maxi] = dp[i][maxi];
for(int j = maxi-1;j>=0;j--){
p[i][j] = dp[i][j] + p[i][j+1];
p[i][j] %= mod;
}
}
fac[0] = 1;
for(int i = 1;i<N;i++){
fac[i] = i*fac[i-1];
fac[i] %= mod;
}
nCr[0][0] = 1;
nCr[0][0] %= mod;
for(int i = 1;i<N;i++){
nCr[i][0] = nCr[i][i] = 1;
nCr[i][i] %= mod;
for(int j = 1;j<i;j++){
nCr[i][j] = nCr[i-1][j] + nCr[i-1][j-1];
nCr[i][j] %= mod;
}
}
int ans = 0;
for(int i = 1;i<=(n-1);i++){
int b = nCr[n][i+1];
b *= fac[n-i-1];
b %= mod;
int maxi = (i*(i-1))/2;
int bb = 0;
int ww = 0;
for(int k = maxi;k>=0;k--){
ww -= bb;
if((k+2) <= maxi) ww += p[i][k+2]*i;
ww %= mod;
ww += mod;
ww %= mod;
if((k+i+1)<=maxi) bb -= p[i][k+i+2];
if((k+2) <= maxi) bb += p[i][k+2];
bb %= mod;
bb += mod;
bb %= mod;
int toAdd = b;
toAdd *= dp[i][k];
toAdd %= mod;
toAdd *= ww;
ans += toAdd;
ans %= mod;
}
}
cout<<ans<<endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010, M = 12;
int n, m, u, v, dp[N][N][M + 1], dp2[N][(1 << M)], dp3[N][(1 << M)];
vector<int> arr, g[N], t[M + 1];
int fres = 1;
int solve() {
int idx = 0, all = 0, sz, mask, res = 0;
for (int i = 0; i < (int)arr.size(); i++) {
for (int node = 1; node <= n; node++) {
if ((int)t[arr[i]].size() == 0) {
if (i == (int)arr.size() - 1) {
res++;
if (res >= 1000000007) res -= 1000000007;
}
for (int j = 0; j < (int)g[node].size(); j++) {
dp[g[node][j]][node][arr[i]] = 1;
}
continue;
}
sz = (int)t[arr[i]].size();
all = (1 << sz);
for (mask = 0; mask < all; mask++) dp2[(int)g[node].size()][mask] = 0;
dp2[(int)g[node].size()][0] = 1;
for (mask = 0; mask < all; mask++) {
for (int j = (int)g[node].size() - 1; j >= 0; j--) {
dp2[j][mask] = dp2[j + 1][mask];
for (int k = 0; k < sz; k++) {
if (((mask >> k) & 1) == 0) continue;
dp2[j][mask] += (long long)dp2[j + 1][(mask ^ (1 << k))] *
dp[node][g[node][j]][t[arr[i]][k]] % 1000000007;
if (dp2[j][mask] >= 1000000007) dp2[j][mask] -= 1000000007;
}
}
for (int j = 0; j < (int)g[node].size(); j++) {
if (j == 0)
dp3[j][mask] = (mask == 0 ? 1 : 0);
else
dp3[j][mask] = dp3[j - 1][mask];
for (int k = 0; k < sz; k++) {
if (((mask >> k) & 1) == 0) continue;
if (j == 0) {
if ((mask ^ (1 << k)) != 0) continue;
dp3[j][mask] = dp[node][g[node][j]][t[arr[i]][k]];
continue;
}
dp3[j][mask] += (long long)dp3[j - 1][(mask ^ (1 << k))] *
dp[node][g[node][j]][t[arr[i]][k]] % 1000000007;
if (dp3[j][mask] >= 1000000007) dp3[j][mask] -= 1000000007;
}
}
}
if (i == (int)arr.size() - 1) {
res += dp2[0][all - 1];
if (res >= 1000000007) res -= 1000000007;
continue;
}
for (int j = 0; j < (int)g[node].size(); j++) {
if (j == 0) {
dp[g[node][j]][node][arr[i]] = dp2[1][all - 1];
continue;
}
if (j == (int)g[node].size() - 1) {
dp[g[node][j]][node][arr[i]] = dp3[j - 1][all - 1];
continue;
}
for (int k = 0; k < all; k++) {
dp[g[node][j]][node][arr[i]] += (long long)dp3[j - 1][k] *
dp2[j + 1][(k ^ (all - 1))] %
1000000007;
if (dp[g[node][j]][node][arr[i]] >= 1000000007)
dp[g[node][j]][node][arr[i]] -= 1000000007;
}
}
}
}
return res;
}
inline int fastpower(int num, int po) {
fres = 1;
while (po > 0) {
if (po & 1) fres = (long long)fres * num % 1000000007;
po >>= 1;
num = (long long)num * num % 1000000007;
}
return fres;
}
void fix(int node, int prnt) {
arr.push_back(node);
for (int i = 0; i < (int)t[node].size(); i++) {
if (t[node][i] == prnt) {
t[node].erase(t[node].begin() + i);
i--;
continue;
}
fix(t[node][i], node);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
scanf("%d", &m);
for (int i = 0; i < m - 1; i++) {
scanf("%d%d", &u, &v);
t[u].push_back(v);
t[v].push_back(u);
}
fix(1, -1);
reverse(arr.begin(), arr.end());
int ans = solve();
for (int i = 1; i <= n; i++) g[i].clear();
for (int i = 1; i <= m; i++) {
for (int j = 0; j < (int)t[i].size(); j++) {
g[i].push_back(t[i][j]);
g[t[i][j]].push_back(i);
}
}
n = m;
ans = (long long)ans * fastpower(solve(), 1000000007 - 2) % 1000000007;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
char s[(1 << 17)];
int ds = (1 << 17);
char ma[5200][5200];
inline char readch() {
if (ds == (1 << 17)) {
fread(s, (1 << 17), 1, stdin);
ds = 0;
}
ds++;
return s[ds - 1];
}
inline int cmmmc(int a, int b) {
int r;
while (b > 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
int main() {
int n, rez = 0, cur, i, j, k;
char ch;
scanf("%d ", &n);
for (i = 0; i < n; i++) {
for (j = 0; j < (n >> 2); j++) {
ch = readch();
if (ch >= 'A' && ch <= 'F')
ch = ch - 'A' + 10;
else
ch = ch - '0';
for (k = 0; k < 4; k++) {
ma[i][4 * j + 3 - k] = ((ch & (1 << k)) > 0);
}
}
readch();
}
for (i = 0; i < n; i++) {
cur = 1;
for (j = 1; j < n; j++) {
if (ma[i][j] == ma[i][j - 1])
cur++;
else {
rez = cmmmc(rez, cur);
cur = 1;
}
}
rez = cmmmc(rez, cur);
}
for (i = 0; i < n; i++) {
cur = 1;
for (j = 1; j < n; j++) {
if (ma[j][i] == ma[j - 1][i])
cur++;
else {
rez = cmmmc(rez, cur);
cur = 1;
}
}
rez = cmmmc(rez, cur);
}
printf("%d\n", rez);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
inline void getint(int &first) {
char c;
while (c = getchar(), c > '9' || c < '0')
;
for (first = 0; c >= '0' && c <= '9'; c = getchar())
first = (first << 1) + (first << 3) + c - '0';
}
inline void print(int first) {
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int a[111][111], dis[6666], pre[6666], C;
short int cost[6666][6666], flow[6666][6666];
vector<int> adj[6666];
queue<int> q;
int maxflow(int s, int t) {
int ans = 0, u, v, bot;
while (1) {
q = queue<int>();
q.push(s);
memset(dis, 0x3f3f3f3f, sizeof(dis));
dis[s] = 0;
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = 0; i < adj[u].size(); i++) {
v = adj[u][i];
if (flow[u][v] == 0) continue;
if (dis[v] > dis[u] + cost[u][v]) {
dis[v] = dis[u] + cost[u][v];
q.push(v);
pre[v] = u;
}
}
}
if (dis[t] == 0x3f3f3f3f) return ans;
bot = 0x3f3f3f3f;
for (u = t; u != s; u = pre[u]) smin(bot, flow[pre[u]][u]);
for (u = t; u != s; u = pre[u]) {
flow[pre[u]][u] -= bot;
flow[u][pre[u]] += bot;
}
C += dis[t];
ans += bot;
}
return ans;
}
void add(int u, int v, int f, int c) {
adj[u].push_back(v);
adj[v].push_back(u);
flow[u][v] = f;
flow[v][u] = 0;
cost[u][v] = c;
cost[v][u] = -c;
}
int dx[] = {0, -1, 0, 1};
int dy[] = {1, 0, -1, 0};
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", a[i] + j);
}
}
int src = n * m, tar = src + 1;
for (int i = 0; i < n; i++) {
for (int j = i & 1; j < m; j += 2) {
add(src, i * m + j, 1, 0);
for (int d = 0; d < 4; d++) {
int u = i + dx[d];
int v = j + dy[d];
if ((u < 0 || v < 0 || u >= n || v >= m)) continue;
add(i * m + j, u * m + v, 1, a[i][j] != a[u][v]);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = ~i & 1; j < m; j += 2) {
add(i * m + j, tar, 1, 0);
}
}
maxflow(src, tar);
cout << C << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, b, k, n;
int c[100005], cn;
bool isp[100005];
long long ans;
void dfs(int g, int cc, long long s) {
if (s > n) return;
if (g == cn) {
if (cc & 1)
ans -= n / s;
else
ans += n / s;
return;
}
dfs(g + 1, cc, s);
dfs(g + 1, cc + 1, s * c[g]);
}
int f(int _n) {
n = _n;
cn = 0;
for (int i = 2; i < k && (long long)i * k <= n; ++i)
if (isp[i]) c[cn++] = i;
ans = 0;
dfs(0, 0, k);
return (int)ans;
}
int main() {
memset(isp, 1, sizeof(isp));
for (int i = 2; i < 100005; ++i)
if (isp[i])
for (int j = i + i; j < 100005; j += i) isp[j] = 0;
scanf("%d %d %d", &a, &b, &k);
bool p = 1;
for (int i = 2; i < 100005 && (long long)i * i <= k; ++i)
if (k % i == 0) {
p = 0;
break;
}
if (!p) {
puts("0");
return 0;
}
printf("%d\n", f(b) - f(a - 1));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, c;
cin >> n >> c;
vector<long long int> a(n - 1), b(n - 1);
for (int i = 0; i < n - 1; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
cin >> b[i];
}
cout << 0 << " ";
long long int s = 0, e = c, snew, enew;
for (int i = 0; i < n - 1; i++) {
snew = a[i] + min(s, e);
enew = b[i] + min(s + c, e);
cout << min(snew, enew) << " ";
s = snew;
e = enew;
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int cnt = 0, cntq = 0, ans = 0;
int forw[5001][5001], back[5001][5001];
string str;
int main() {
cin >> str;
int len = str.length();
for (int i = 0; i < len; i++) {
cnt = cntq = 0;
if (str[i] == ')') {
continue;
}
if (str[i] == '(') {
cnt = 1;
} else {
cnt = 1;
}
for (int j = i + 1; j < len; j++) {
if (str[j] == ')') {
cnt--;
} else if (str[j] == '(') {
cnt++;
} else {
cnt++, cntq++;
}
if (cnt < 0) {
break;
}
if (((cnt % 2) == 0) && (cnt / 2 <= cntq)) {
forw[i][j] = 1;
}
}
}
for (int i = len - 1; i >= 0; i--) {
cnt = cntq = 0;
if (str[i] == '(') {
continue;
}
if (str[i] == ')') {
cnt = 1;
} else {
cnt = 1;
}
for (int j = i - 1; j >= 0; j--) {
if (str[j] == '(') {
cnt--;
} else if (str[j] == ')') {
cnt++;
} else {
cnt++, cntq++;
}
if (cnt < 0) {
break;
}
if (((cnt % 2) == 0) && (cnt / 2 <= cntq)) {
back[j][i] = 1;
}
}
}
for (int i = 0; i < len; i++) {
for (int j = i + 1; j < len; j++) {
if (forw[i][j] && back[i][j]) {
ans++;
}
}
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[4];
void input() {
scanf("%d%d%d%d", &a[0], &a[1], &a[2], &a[3]);
sort(a, a + 4);
if (a[0] + a[3] == a[1] + a[2] || a[0] + a[1] + a[2] == a[3])
printf("YES\n");
else
printf("NO\n");
}
int main() { input(); }
| 1 |
#include <bits/stdc++.h>
using namespace std;
int C[26];
int main()
{string S; cin >> S; for (auto c : S) ++C[c - 'a'];
for (int c : C) if (c > 1) puts("no"), exit(0);
puts("yes");} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
unsigned int countBits(unsigned int n) {
unsigned int count = 0;
while (n) {
count++;
n >>= 1;
}
return count;
}
bool isPerfectSquare(long double x) {
long double sr = sqrt(x);
return ((sr - floor(sr)) == 0);
}
int subArraySum(int arr[], int n) {
int curr_sum = arr[0], start = 0, i, count = 0, len;
len = 0;
for (i = 1; i <= n; i++) {
len++;
while (curr_sum > len && start < i - 1) {
curr_sum = curr_sum - arr[start];
start++;
len++;
}
if (curr_sum == len) {
count++;
}
if (i < n && i > 0) {
curr_sum = curr_sum + arr[i];
}
}
return count;
}
void printDigit(int N, vector<long long int>& arr) {
int i = 0;
int j, r;
while (N != 0) {
r = N % 10;
arr.push_back(r);
i++;
N = N / 10;
}
}
void solver(vector<long long int> arr, long long int start,
long long int& count, long long int a1) {
long long int sum = 0;
for (long long int i = start + 1; i < arr.size() - 1; i++) {
sum += arr[i];
if (sum == a1) count++;
}
}
bool checkDivisibility(long long int n, int digit) {
if (digit == 0) return true;
return (digit != 0 && n % digit == 0);
}
bool allDigitsDivide(long long int n) {
long long int temp = n;
while (temp > 0) {
int digit = temp % 10;
if (!(checkDivisibility(n, digit))) return false;
temp /= 10;
}
return true;
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool isPowerOfTwo(unsigned long long x) { return x && (!(x & (x - 1))); }
int nextPrime(int N) {
if (N <= 1) return 2;
int prime = N;
bool found = false;
while (!found) {
prime++;
if (isPrime(prime)) found = true;
}
return prime;
}
bool sortcol(const vector<long long int>& v1, const vector<long long int>& v2) {
return v1[0] < v2[0];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long int b = 0, q, c, x, y, start = 0, end = 0, count = 0, neg = 0,
pos = 0, count1 = 0, a1 = 0, b1 = 0, c1 = 0, x1, y1, n1, m,
ans = 0, sum = 0, k;
long long int n;
string s1, s2(""), s3("");
bool check2 = false, check3 = false;
long long int x3, x2, y3, y2;
int curr1 = 0, curr = 0;
vector<int> arr(130, 0);
vector<int> arr1;
stack<char> s;
long long int vb;
bool check1 = false, check4 = false;
vector<double> arrv;
unordered_map<long long int, long long int> map1;
unordered_map<long long int, long long int> map2;
long long int a, l = 0, d = 0, u = 0, v, g, sub;
cin >> s1;
n = s1.length();
for (int i = 0; i < n; i++) {
arr[s1[i]]++;
}
for (int i = 0; i < arr.size(); i++) {
if (arr[i] % 2 != 0) count++;
}
if (count == 0 || count == 1)
cout << "First";
else if (count % 2 != 0)
cout << "First";
else
cout << "Second";
return 0;
}
| 2 |
#include<iostream>
#include<vector>
#include<list>
#include<string>
#include<algorithm>
#include<map>
#include<cmath>
#include<set>
using namespace std;
int main() {
int n;
while (cin >> n&&n != 0) {
string u,h;
string a[50];
int k = 1000;
for (int i = 0; i < n; i++) {
cin >> u;
h = "";
for (int i = 0; i < u.length(); i++) {
if (i == 0) h += u[0];
else if (u[i - 1] == 'a' || u[i - 1] == 'i' || u[i - 1] == 'u' || u[i - 1] == 'e' || u[i - 1] == 'o') {
h += u[i];
}
}
a[i] = h;
k = max(k, (int)h.length());
}
int m = -1;
for (int i = 1; i <= k; i++) {
string b[50];
bool l = true;
for (int j = 0; j < n; j++) {
if (a[j].length() < i) b[j] = a[j];
else b[j] = a[j].substr(0, i);
for (int z = 0; z < j; z++) {
if (b[z] == b[j]) {
l = false;
break;
}
}
}
if (l) {
m = i;
break;
}
}
cout << m << endl;
}
} | 0 |
#include <bits/stdc++.h>
const int N = 4e5 + 5;
using namespace std;
int gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
int lcm(int a, int b) { return (a * b) / gcd(a, b); }
int n, a[N], I, sum, fro[N], bak[N], res = INT_MAX, cnt, t;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> I;
set<int> st;
map<int, int> mp;
int m = I * 8 / n;
m = m >= 30 ? 1 << 30 : 1 << m;
for (int i = 0; i < n; ++i) {
cin >> t;
if (mp[t] == 0) sum++;
mp[t]++;
st.insert(t);
}
m = sum - m;
if (m <= 0) goto RES;
for (set<int>::iterator it = st.begin(); it != st.end(); it++)
a[++cnt] = mp[*it];
for (int i = 1, j = cnt; i <= cnt; ++i, --j) {
fro[i] = fro[i - 1] + a[i];
bak[j] = bak[j + 1] + a[j];
}
for (int i = m, j = cnt + 1; i >= 0; --i, --j) {
res = min(res, fro[i] + bak[j]);
}
cout << res;
return 0;
RES:
cout << 0;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int inf = INT_MAX;
const int N = 100004;
const long long mod1 = 1000000007;
const long long mod2 = 1000000009;
const long long mod3 = inf;
long long x1[N], x2[N], x3[N], k;
int n;
int main() {
cin >> n >> k;
x1[0] = x2[0] = x3[0] = 1;
for (int i = 1; i <= n; i++) {
x1[i] = (x1[i - 1] * k) % mod1;
x2[i] = (x2[i - 1] * k) % mod2;
x3[i] = (x3[i - 1] * k) % mod3;
}
char buf[17];
bool full = true;
bool a0 = false;
int jog = 0;
long long ans1 = 0, ans2 = 0, ans3 = 0;
long long val;
for (int i = 0; i < n + 1; i++) {
scanf(" %s", buf);
if (buf[0] == '?') {
full = false;
if (!i) a0 = true;
} else {
jog++;
long long tmp = atoll(buf);
if (!i) val = tmp;
ans1 = (ans1 + tmp * x1[i]) % mod1;
ans2 = (ans2 + tmp * x2[i]) % mod2;
ans3 = (ans3 + tmp * x3[i]) % mod3;
}
}
if (!k) {
if (a0) {
if (jog & 1)
puts("Yes");
else
puts("No");
} else {
if (!val)
puts("Yes");
else
puts("No");
}
} else {
if (full) {
if (ans1 == 0 && ans2 == 0 && ans3 == 0)
puts("Yes");
else
puts("No");
} else {
if (n & 1)
puts("Yes");
else
puts("No");
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e4 + 5;
int l;
long long n, d[MAX];
map<int, bool> dp;
bool F(long long n) {
if (dp.count(n)) return dp[n];
bool ans = 0;
for (int i = 1; i <= l && d[i] < n; i++)
if (n % d[i] == 0) ans |= !F(n / d[i]);
return dp[n] = ans;
}
int main() {
scanf("%I64d", &n);
if (n == 1) {
printf("1\n0\n");
return 0;
}
for (long long i = 2; i * i <= n; i++) {
if (n % i) continue;
d[++l] = i;
if (i == n / i) continue;
d[++l] = n / i;
}
if (l == 0) {
printf("1\n0\n");
return 0;
}
sort(d + 1, d + l + 1);
for (int i = 1; i <= l; i++) {
if (F(d[i]) == 1) {
printf("1\n%I64d\n", d[i]);
return 0;
}
}
printf("2\n");
return 0;
}
| 1 |
//
// Created by maze on 2019/11/03.
//
#include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)le18
#define INF (int32)le9
#define REP(i, n) for(int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for(int64 i = (a); i < (b); i++)
#define all(x) x.begin(), x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using int64 = int_fast64_t;
using uint32 = uint_fast32_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
int comp(const string& lhs, const string& rhs) {
if (isdigit(lhs[0]) && isdigit(rhs[0])) {
if (lhs.size() != rhs.size()) return lhs.size() < rhs.size() ? -1 : 1;
else return lhs < rhs ? -1 : (lhs == rhs ? 0 : 1);
} else if (isdigit(lhs[0]) || isdigit(rhs[0])) {
return isdigit(lhs[0]) ? -1 : 1;
} else {
return lhs < rhs ? -1 : (lhs == rhs ? 0 : 1);
}
}
int comp(const vector<string>& lhs, const vector<string>& rhs) {
REP(i, min(lhs.size(), rhs.size())) {
int ret = comp(lhs[i], rhs[i]);
if (ret == -1) return -1;
else if (ret == 1) return 1;
}
return (lhs.size() < rhs.size() ? -1 : (lhs.size() == rhs.size() ? 0 : 1));
}
int main(void) {
int64 n;
cin >> n;
vector<vector<string>> s(n+1);
REP(i, n+1) {
string t;
cin >> t;
string now = "";
REP(j, t.size()) {
if (now == "" || isdigit(t[j]) == isdigit(now[0])) {
now += t[j];
} else {
s[i].push_back(now);
now = t[j];
}
}
if (now != "") {
s[i].push_back(now);
}
}
FOR(i, 1, n+1) {
int ret = comp(s[i], s[0]);
if (ret == -1) {
cout << '-' << endl;
} else {
cout << '+' << endl;
}
}
}
| 0 |
#include <iostream>
#include <cstdio>
using namespace std;
int n,m;
int trip[100000];
int fare_r[100000];
int ic[100000];
int fare_i[100000];
long long mycount[100000]={};
long long rui[100000]={};
void countcreate(void){
int prev,next;
prev=trip[0]-1;
for(int lp=1;lp<m;lp++){
next=trip[lp]-1;
if(prev<next){
rui[prev]++;
rui[next]--;
}else{
rui[next]++;
rui[prev]--;
}
prev=next;
}
mycount[0]=rui[0];
for(int lp=1;lp<n-1;lp++){
mycount[lp]=mycount[lp-1]+rui[lp];
}
}
long long solve(void){
long long answer=0;
long long sum_r,sum_i;
for(int lp=0;lp<n-1;lp++){
sum_r=fare_r[lp]*mycount[lp];
sum_i=fare_i[lp]*mycount[lp]+ic[lp];
//printf("rail %d count:%d real:%d, ic:%d\n",lp,mycount[lp],sum_r,sum_i);
if(sum_r>sum_i){
answer+=sum_i;
}else{
answer+=sum_r;
}
}
return answer;
}
int main(void){
scanf("%d %d",&n,&m);
for(int lp=0;lp<m;lp++){
scanf("%d",&trip[lp]);
}
for(int lp=0;lp<n-1;lp++){
scanf("%d %d %d",&fare_r[lp],&fare_i[lp],&ic[lp]);
}
countcreate();
printf("%lld\n",solve());
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
using namespace std;
string s;
int ans,l,r,n,k,cnt;
int main()
{
cin>>n>>k>>s;
for(;r < s.size();r++){
if(s[r]=='0'){
if(r==0 || s[r-1]=='1')
cnt++;
}
if(cnt > k){
while(l < s.size() && s[l]=='1')
l++;
while(l < s.size() && s[l]=='0')
l++;
cnt--;
}
ans=max(ans,r-l+1);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, q;
cin >> n >> q;
vector<int> src(n);
for (int i = 0; i < n; ++i) cin >> src[i];
const int MAX = (int)1e5;
int ts = 1;
while (ts < MAX) ts *= 2;
enum TYPE { FLIP, SET, NOTHING };
const pair<TYPE, uint8_t> EMPTY = make_pair(NOTHING, 0);
vector<uint8_t> st(2 * ts);
vector<pair<TYPE, uint8_t>> psh(2 * ts, EMPTY);
const int SON_COUNT = 2;
auto push = [&](int v) {
if (psh[v].first != NOTHING) {
if (psh[v].first == FLIP) {
st[v] ^= psh[v].second;
} else {
st[v] = psh[v].second;
}
if (v < ts) {
for (int i = 0; i < SON_COUNT; ++i) {
if (psh[v].first == SET) {
psh[2 * v + i] = psh[v];
} else {
psh[2 * v + i].second ^= psh[v].second;
if (psh[2 * v + i].first != SET) psh[2 * v + i].first = FLIP;
}
}
}
psh[v] = EMPTY;
}
};
function<void(int, pair<TYPE, uint32_t>, int, int, int, int)> set =
[&](int v, pair<TYPE, uint32_t> val, int l, int r, int L, int R) {
push(v);
if (l > R || L > r) return;
if (l <= L && R <= r) {
psh[v] = val;
push(v);
return;
}
set(2 * v, val, l, r, L, (L + R) / 2);
set(2 * v + 1, val, l, r, (L + R) / 2 + 1, R);
};
const int root = 1;
const int L = 1;
const int R = ts;
while (q--) {
char s;
int x, y;
cin >> s >> y;
x = abs(y);
if (s == '<') {
if (y > 0) {
set(root, make_pair(FLIP, 1), 1, x - 1, L, R);
set(root, make_pair(SET, 2), x, MAX, L, R);
} else {
set(root, make_pair(SET, 2), x + 1, MAX, L, R);
}
} else {
if (y > 0) {
set(root, make_pair(SET, 3), x + 1, MAX, L, R);
} else {
set(root, make_pair(FLIP, 1), 1, x - 1, L, R);
set(root, make_pair(SET, 3), x, MAX, L, R);
}
}
}
for (int i = 1; i < 2 * ts; ++i) push(i);
for (int i = 0; i < n; ++i) {
if (!src[i])
cout << 0 << ' ';
else {
int f = st[abs(src[i]) + ts - 1];
switch (f) {
case 0:
cout << src[i] << ' ';
break;
case 1:
cout << -src[i] << ' ';
break;
case 2:
cout << abs(src[i]) << ' ';
break;
case 3:
cout << -abs(src[i]) << ' ';
break;
default:
break;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long logN = 20;
const long long M = 1000000007;
const long long INF = 1e12;
int pow1(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = res * a;
}
a = a * a;
b >>= 1;
}
return res;
}
int main() {
long long t = 1;
while (t--) {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
vector<vector<long long> > vec(n);
for (long long i = 0; i < n; i++) {
long long num = v[i];
long long tmp = sqrt(num);
for (long long j = 1; j <= tmp; j++) {
if (num % j == 0) {
if (j * j == num) {
if (j <= n) vec[i].push_back(j);
} else {
if (j <= n) vec[i].push_back(j);
if ((num / j) <= n) vec[i].push_back(num / j);
}
}
}
sort(vec[i].begin(), vec[i].end(), greater<long long>());
}
long long dp[n + 1];
dp[0] = 1;
for (long long i = 1; i < n + 1; i++) dp[i] = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < (long long)vec[i].size(); j++) {
dp[vec[i][j]] = (dp[vec[i][j]] + dp[vec[i][j] - 1]) % M;
}
}
long long ans = 0;
for (long long i = 1; i < n + 1; i++) {
ans = (ans + dp[i]) % M;
}
cout << ans;
}
}
| 3 |
//hail to jwalaji
#include<bits/stdc++.h>
using namespace std;
typedef long long int lli;
lli h,w,a,b,f,t,e;
set<pair<lli,lli>> st;
multiset<lli> ms;
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
cin>>h>>w;
for(lli i=0;i<w;i++){
st.insert({i,i});
ms.insert(0);
}
for(lli i=0;i<h;i++){
cin>>a>>b;
auto tl=st.lower_bound({a-1,0}),el=st.lower_bound({b,0});
e=tl!=el;
for(;tl!=el;tl=st.erase(tl)){
tie(t,f)=*tl;
ms.erase(ms.find(t-f));
}
if(e&&b!=w){
st.insert({b,f});
ms.insert(b-f);
}
if(ms.empty()){cout<<-1<<endl;}
else{
cout<<*ms.begin()+i+1<<endl;
}
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define LL long long
LL a,b,c;
LL calu(LL x)
{
LL cnt=0;
while(x) ++cnt,x/=10;
return cnt;
}
int main()
{
LL t;
cin>>t;
while(t--)
{
cin>>a>>b>>c;
LL x,y,z;
x=1;
while(calu(x)<c)
{
x<<=1;
}
y=x,z=x;
while(calu(y)<a) y<<=1;
while(calu(z)<b) z*=3;
cout<<y<<' '<<z<<endl;
// cout<<__gcd(y,z)<<endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200000];
bool st[200000][2];
long long memo[200000][2];
long long solve(int node, int rev) {
if (node < 0 || node >= n) return 0;
if (st[node][rev]) return 0x3f3f3f3f3f3f3f3fll;
if (node == 0) return 0;
long long& val = memo[node][rev];
if (val != 0xc0c0c0c0c0c0c0c0ll) return val;
st[node][rev] = true;
val = solve(node + a[node] * (1 - 2 * rev), 1 - rev);
if (val != 0x3f3f3f3f3f3f3f3fll) val += a[node];
st[node][rev] = false;
return val;
}
int main() {
ios::sync_with_stdio(0);
memset(st, false, sizeof st);
memset(memo, 0xc0c0c0c0c0c0c0c0ll, sizeof memo);
cin >> n;
for (int i = 1; i < n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
st[0][0] = true;
long long ans = solve(i, 1);
if (ans == 0x3f3f3f3f3f3f3f3fll)
ans = -1;
else
ans += i;
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
using namespace std;
const int MAXN = 2e5 + 51;
struct Query {
int x, y, id;
inline bool operator<(const Query &rhs) const { return y < rhs.y; }
};
Query qry[MAXN];
int n, m, x, y, tp, ptr, l, r, mid, rr;
int c[MAXN], pr[MAXN], st[MAXN], res[MAXN];
inline int read() {
register int num = 0, neg = 1;
register char ch = getchar();
while (!isdigit(ch) && ch != '-') {
ch = getchar();
}
if (ch == '-') {
neg = -1;
ch = getchar();
}
while (isdigit(ch)) {
num = (num << 3) + (num << 1) + (ch - '0');
ch = getchar();
}
return num * neg;
}
inline long double slope(int u, int v) {
return 1.0L * (pr[u] - pr[v] - 1.0L * c[u] * u + 1.0L * c[v] * v) /
(c[u] - c[v]);
}
inline int calc(int x) {
int l = 1, r = tp, mid;
while (l < r) {
mid = (l + r) >> 1;
st[mid] < x ? l = mid + 1 : r = mid;
}
return l;
}
int main() {
n = read();
for (register int i = 1; i <= n; i++) {
pr[i] = pr[i - 1] + (c[i] = read());
}
m = read();
for (register int i = 1; i <= m; i++) {
x = read(), y = read(), qry[i] = (Query){x, y, i};
}
sort(qry + 1, qry + m + 1), ptr = 1;
for (register int i = 1; i <= n; i++) {
while (tp && c[st[tp]] >= c[i]) {
tp--;
}
while (tp > 1 && slope(st[tp], i) >= slope(st[tp - 1], i)) {
tp--;
}
st[++tp] = i;
while (qry[ptr].y == i && ptr <= m) {
x = qry[ptr].x, y = qry[ptr].y, l = calc(y - x), r = tp;
while (l < r) {
mid = (l + r) >> 1;
slope(st[mid], st[mid + 1]) < x - y ? r = mid : l = mid + 1;
}
l = st[l], r = qry[ptr].y,
res[qry[ptr++].id] = pr[r] - pr[l] + (x - r + l) * c[l];
}
}
for (register int i = 1; i <= m; i++) {
printf("%d\n", res[i]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int N = 100005;
const double PI = 4 * atan(1);
const long long MAX = 9223372036854775807;
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, 1, -1, -1};
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
bool issquare(long long w) { return trunc(sqrt(w)) * trunc(sqrt(w)) == w; }
bool isprime(long long u) {
for (long long i = 2; i <= (int)sqrt(u); i++) {
if (u % i == 0) return 0;
}
return 1;
}
long long mod(long long to_mod, long long MOD) {
to_mod %= MOD;
while (to_mod < 0) to_mod += MOD;
return to_mod % MOD;
}
long long moduloMultiplication(long long a, long long b) {
long long res = 0;
while (b) {
if (b & 1) res = (res + a);
a = (2 * a);
b >>= 1;
}
return res;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long n, m, q, y, k, z, w, t, l, r, res, ans, x, a, b;
long long xx, yy, xxx, yyy, xx1, yy1;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> q;
while (q--) {
cin >> n >> k;
res = 0;
a = 0;
while (a < n && res < k && res >= 0) {
res += (1ll << a) * (1ll << a);
a++;
}
if (res < k && res >= 0) {
cout << "NO\n";
continue;
}
b = n;
a = 1;
vector<pair<long long, long long> > v;
while (k >= (1ll << a) - 1 && b > 0) {
k -= (1ll << a) - 1;
b--;
if (a == 1) {
v.push_back(make_pair(n - a, 1));
} else {
v.push_back(make_pair(n - a, 4 * v[a - 2].second + 1));
}
a++;
}
res = 0;
for (auto t : v) {
if (res > k || res < 0) break;
a = 1;
long long u = t.second;
while (res >= 0 && a <= t.first) {
if (res > k) break;
res += u * (1ll << (a - 1)) * (1ll << (a - 1));
a++;
}
}
if (res >= k || res <= 0) {
cout << "YES " << b << "\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void Digvijay() {
long long x1, y1, z1, x2, y2, z2;
cin >> x1 >> y1 >> z1 >> x2 >> y2 >> z2;
long long n = x1 + y1 + z1;
long long ans = 0;
long long v1 = min(z1, y2);
ans += 2 * v1;
if (z1 >= y2) {
z1 -= y2;
y2 = 0;
} else {
z1 = 0;
}
long long v2 = x1 + z1;
if (v2 >= z2) {
z2 = 0;
} else {
z2 -= v2;
}
ans += z2 * -2;
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long _ = 1;
cin >> _;
for (long long __ = 1; __ <= _; __++) {
Digvijay();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = ((int)2e5) + 5;
set<int> numbers;
long long int dp[501][501];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
dp[0][0] = 1;
int n, m, k;
cin >> n >> m >> k;
int f[3] = {0};
string str[m];
for (int i = 0; i < m; i++) {
cin >> str[i];
}
for (int j = 0; j < n; j++) {
int fr = 0;
for (int i = 0; i < m; i++) {
if (str[i][j] == '1') {
fr++;
}
}
f[(2 - fr)]++;
}
for (int needTwo = 0; needTwo < 500 + 1; needTwo++) {
for (int needOne = 0; needOne < 500 + 1; needOne++) {
if (needOne + needTwo > n) break;
long long int &res = dp[needTwo][needOne];
if (needOne >= 2) {
res = (res + ((needOne * 1ll * (needOne - 1)) / 2) *
dp[needTwo][needOne - 2] % k) %
k;
}
if (needTwo >= 2) {
res = (res + ((needTwo * 1ll * (needTwo - 1)) / 2) *
dp[needTwo - 2][needOne + 2] % k) %
k;
}
if (needOne >= 1 && needTwo >= 1) {
res = (res +
(needTwo * 1ll * (needOne) % k) * dp[needTwo - 1][needOne] % k) %
k;
}
}
}
cout << dp[f[2]][f[1]] % k;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double sumx[29], sumy[29];
double chu, ans;
char sz1[200006], sz2[200006];
int main() {
int n, a, b, i;
scanf("%d", &n);
scanf("%s%s", sz1 + 1, sz2 + 1);
for (i = 1; i <= n; i++) chu += i * i;
for (i = 1; sz1[i]; i++) {
a = sz1[i] - 'A';
sumx[a] += i;
b = sz2[i] - 'A';
ans += (n - i + 1) * 1.0 * (sumx[b] + sumy[a]);
sumy[b] += i;
}
printf("%0.8f\n", ((double)ans) / n / (n + 1) / ((n << 1) | 1) * 6);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int ans = 0;
int cur = 0;
int pr = -1;
while (n--) {
int x;
scanf("%d", &x);
if (pr == -1 || x <= 2 * pr) {
++cur;
} else {
cur = 1;
}
if (cur > ans) {
ans = cur;
}
pr = x;
}
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, l = 0, r = 0, ans = 0, sum = 0, x, y, a, b, k, pos = 0;
string s;
cin >> n >> k;
cin >> s;
while (pos < n - 1) {
for (int i = pos; i <= pos + k; i++) {
if (s[i] == '1') l = i;
}
if (pos == l) {
cout << -1;
return 0;
}
pos = l;
ans++;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
char buf[1000];
string nextLine(int length = 100) {
cin.getline(buf, length);
string s(buf);
return s;
}
string next(int length = 100) {
string tmp;
cin >> tmp;
return tmp;
}
int nextInt() {
int tmp;
scanf("%d", &tmp);
return tmp;
}
long long mod = 1E9 + 7;
long long add(long long a, long long b) { return (a + b) % mod; }
const int MAXN = 5010;
string s1, s2;
int m, n;
long long dp[MAXN][MAXN];
long long get(int starta, int startb) {
if (starta == m) return 0;
if (startb == n) return 0;
long long &ret = dp[starta][startb];
if (ret != -1) return ret;
ret = 0;
if (s2[startb] == s1[starta]) {
ret++;
ret = add(ret, get(starta + 1, startb + 1));
}
ret = add(ret, get(starta, startb + 1));
return ret;
}
int main() {
s1 = next();
s2 = next();
m = ((int)(s1).size());
n = ((int)(s2).size());
long long sum = 0;
for (int i = 0, _i = (MAXN); i < _i; ++i)
for (int j = 0, _j = (MAXN); j < _j; ++j) dp[i][j] = -1;
for (int i = 0, _i = (m); i < _i; ++i) {
sum = add(sum, get(i, 0));
}
cout << sum << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[300005], b[300005], dp[300005][3];
void Solve() {
cin >> n;
for (long long i = 1, _b = n; i <= _b; i++) cin >> a[i] >> b[i];
dp[1][0] = 0;
dp[1][1] = b[1];
dp[1][2] = b[1] * 2;
for (long long i = 2, _b = n; i <= _b; i++) {
if (a[i] == a[i - 1]) {
dp[i][2] = min(dp[i - 1][0], dp[i - 1][1]) + b[i] * 2;
dp[i][1] = min(dp[i - 1][0], dp[i - 1][2]) + b[i];
dp[i][0] = min(dp[i - 1][1], dp[i - 1][2]);
} else if (a[i] + 1 == a[i - 1]) {
dp[i][2] = min(dp[i - 1][0], dp[i - 1][2]) + b[i] * 2;
dp[i][1] = min(dp[i - 1][1], dp[i - 1][2]) + b[i];
dp[i][0] = min(dp[i - 1][0], min(dp[i - 1][1], dp[i - 1][2]));
} else if (a[i] == a[i - 1] + 1) {
dp[i][2] = min(dp[i - 1][0], min(dp[i - 1][1], dp[i - 1][2])) + b[i] * 2;
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + b[i];
dp[i][0] = min(dp[i - 1][0], dp[i - 1][2]);
} else if (a[i] + 2 == a[i - 1]) {
dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]) + b[i] * 2;
dp[i][1] = min(dp[i - 1][0], min(dp[i - 1][1], dp[i - 1][2])) + b[i];
dp[i][0] = min(dp[i - 1][0], min(dp[i - 1][1], dp[i - 1][2]));
} else if (a[i] == a[i - 1] + 2) {
dp[i][2] = min(dp[i - 1][0], min(dp[i - 1][1], dp[i - 1][2])) + b[i] * 2;
dp[i][1] = min(dp[i - 1][0], min(dp[i - 1][1], dp[i - 1][2])) + b[i];
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]);
} else {
dp[i][2] = min(dp[i - 1][0], min(dp[i - 1][1], dp[i - 1][2])) + b[i] * 2;
dp[i][1] = min(dp[i - 1][0], min(dp[i - 1][1], dp[i - 1][2])) + b[i];
dp[i][0] = min(dp[i - 1][0], min(dp[i - 1][1], dp[i - 1][2]));
}
}
cout << min(dp[n][0], min(dp[n][1], dp[n][2])) << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int Test_numbers = 1;
cin >> Test_numbers;
while (Test_numbers--) Solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int main()
{
int n, md = 0; cin >> n;
for (int i = 0; i < n; i ++){
int d; cin >> d; a[d] ++;
md = max(d, md);
}
int r = (md + 1) / 2;
for (int i = 0; i < r; i ++){
if (a[i] >= 1) return cout << "Impossible", 0;
}
if (md % 2 == 0) if (a[r] != 1) return cout << "Impossible", 0;
if (md % 2 != 0) if (a[r] != 2) return cout << "Impossible", 0;
for (int i = r + 1; i <= md; i ++){
if (a[i] <= 1) return cout << "Impossible", 0;
}
cout << "Possible";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace Fast {
inline char getc() {
static char buf[1 << 21], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++;
}
inline void read() {}
template <typename T1, typename... T2>
inline void read(T1 &x, T2 &...oth) {
bool f = false;
x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = true;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch - 48);
ch = getchar();
}
x = f ? -x : x;
read(oth...);
}
template <typename T>
inline void print(T x) {
if (x < 0) {
putchar('-');
x = ~(x - 1);
}
char f[100];
int top = 0;
while (x) f[++top] = x % 10 + '0', x /= 10;
if (!top) f[++top] = '0';
while (top) putchar(f[top--]);
}
template <typename T>
inline void print(T x, char c) {
print(x);
putchar(c);
}
} // namespace Fast
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using Fast::read;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const ll LLF = 0x3f3f3f3f3f3f3f3f;
const int M = 1e5 + 10;
template <typename T>
T gcd(T a, T b, T m = 0) {
while (b) m = a % b, a = b, b = m;
return a;
}
template <typename T>
inline void input_arr(T *a, int l, int r) {
while (l < r) read(a[l++]);
}
int a[M], sum[M];
void solve() {
int n, k, z;
read(n, k, z);
for (int i = 1; i <= n; ++i) {
read(a[i]);
sum[i] = sum[i - 1] + a[i];
}
int ans = sum[k + 1];
for (int i = 2; i <= k + 1; ++i) {
int re = k - i + 1;
int cnt = min(z * 2, re);
int tot = sum[k - cnt + 1] + cnt / 2 * (a[i] + a[i - 1]);
if (cnt & 1) tot += a[i - 1];
ans = max(ans, tot);
}
printf("%d\n", ans);
}
clock_t ___;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int _ = 1;
read(_);
___ = clock();
while (_--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) {
long long z = y;
while (x % y != 0) {
z = x % y;
x = y;
y = z;
}
return z;
}
long long a[2], t[2], p[2];
long long ans = (1LL << 60);
long long f, T, t0;
char s[1000005];
int tt, ps;
void pp(int ss, int gg) {
printf("%d %d\n", ss, gg);
exit(0);
}
int dp[1000005];
int vps[1000005], sx[1000005];
bool ne(int l, int r) { return r < l || sx[min(r, n)] == sx[max(0, l - 1)]; }
bool ck(int T) {
memset(dp, 0, sizeof dp);
for (int(i) = 1; (i) <= (int)(ps); (i)++) {
if (ne(dp[i - 1] + 1, vps[i] - T - 1)) dp[i] = max(dp[i], vps[i]);
if (ne(dp[i - 1] + 1, vps[i] - 1)) dp[i] = max(dp[i], vps[i] + T);
if (i > 1) {
if (ne(dp[i - 2] + 1, vps[i] - T - 1)) dp[i] = max(dp[i], vps[i - 1] + T);
}
}
return sx[min(dp[ps], n)] == sx[n];
}
void fmain(int ID) {
scanf("%d%s", &n, s + 1);
for (int(i) = 1; (i) <= (int)(n); (i)++)
if (s[i] == '*') {
tt++;
sx[i] = 1;
} else if (s[i] == 'P') {
vps[++ps] = i;
}
if (ps == 1) {
int sl = 0, tar;
for (int(i) = 1; (i) <= (int)(n); (i)++)
if (s[i] == '*')
sl++;
else if (s[i] == 'P') {
tar = i;
break;
}
int L = tar, R = tar, sr = tt - sl;
for (int i = tar - 1; i; i--)
if (s[i] == '*') L = i;
for (int i = tar + 1; i <= n; i++)
if (s[i] == '*') R = i;
if (sl < sr)
pp(sr, R - tar);
else if (sr < sl)
pp(sl, tar - L);
else
pp(sl, min(R - tar, tar - L));
}
for (int(i) = 1; (i) <= (int)(n); (i)++) sx[i] += sx[i - 1];
int l = 1, r = 1e7;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (ck(mid))
r = mid;
else
l = mid + 1;
}
int ans = ck(l) ? l : r;
pp(tt, ans);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &t) {
t = 0;
char ch = getchar();
int f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
t *= f;
}
template <typename T>
void write(T t) {
if (t < 0) {
putchar('-');
write(-t);
return;
}
if (t > 9) write(t / 10);
putchar('0' + t % 10);
}
template <typename T>
void writeln(T t) {
write(t);
puts("");
}
const int mod = (1e9) + 7;
int n, k, t1, t2, jc[100010];
map<int, int> dx, dy;
struct node {
int x, y, z;
} now[60];
vector<node> H;
vector<pair<int, int> > g[120];
int dep[120];
void add_edge(int x, int y, int z) {
g[x].push_back(make_pair(y, z));
g[y].push_back(make_pair(x, z));
}
bool vis[120];
vector<int> L, R;
vector<pair<int, int> > tr[120];
int V, E;
void dfs(int u) {
if (vis[u]) return;
vis[u] = 1;
if (u <= t1)
L.push_back(u);
else
R.push_back(u);
V++;
E += (int)g[u].size();
for (pair<int, int> A : g[u]) {
if (vis[A.first]) continue;
dep[A.first] = dep[u] + 1;
tr[u].push_back(A);
dfs(A.first);
}
}
vector<int> res, all;
void update(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
vector<int> operator*(vector<int> t1, vector<int> t2) {
vector<int> res;
int n = (int)t1.size() - 1, m = (int)t2.size() - 1;
res.resize(n + m + 1, 0);
for (int i = 0; i <= n; i++)
if (t1[i])
for (int j = 0; j <= m; j++)
if (t2[j]) update(res[i + j], (long long)t1[i] * t2[j] % mod);
return res;
}
vector<int> operator+(vector<int> t1, vector<int> t2) {
while ((int)t1.size() < (int)t2.size()) t1.push_back(0);
for (int i = 0; i < t2.size(); i++) update(t1[i], t2[i]);
return t1;
}
vector<int> operator-(vector<int> t1, vector<int> t2) {
for (int i = 0; i < t2.size(); i++) update(t1[i], mod - t2[i]);
return t1;
}
vector<int> operator*(vector<int> t1, int t2) {
for (int i = 0; i < t1.size(); i++) t1[i] = (long long)t1[i] * t2 % mod;
return t1;
}
int bit[1 << 20], dp[1 << 20], Dy[120];
int sz;
vector<int> f[120][2];
bool ban[120];
vector<int> T[120];
void dfs_dp(int rt) {
f[rt][0] = {1};
for (pair<int, int> A : tr[rt]) {
int v = A.first;
dfs_dp(v);
T[v] = f[v][0] + f[v][1];
f[rt][0] = f[rt][0] * T[v];
}
if (ban[rt]) {
f[rt][1] = {0};
return;
}
f[rt][1] = {0};
vector<int> pre[120], suf[120];
for (int i = 0; i < tr[rt].size(); i++) {
if (i)
pre[i] = pre[i - 1] * T[tr[rt][i].first];
else
pre[i] = T[tr[rt][i].first];
}
for (int i = (int)tr[rt].size() - 1; i >= 0; i--) {
if (i != (int)tr[rt].size() - 1)
suf[i] = suf[i + 1] * T[tr[rt][i].first];
else
suf[i] = T[tr[rt][i].first];
}
int i = 0;
for (pair<int, int> A : tr[rt]) {
int v = A.first;
if (ban[v]) {
i++;
continue;
}
vector<int> tmp = (f[v][0] * A.second);
if (i) tmp = tmp * pre[i - 1];
if (i != (int)tr[rt].size() - 1) tmp = tmp * suf[i + 1];
f[rt][1] = f[rt][1] + tmp;
i++;
}
f[rt][1] = f[rt][1] * (vector<int>){0, 1};
return;
f[rt][1].push_back(0);
for (int i = (int)f[rt][1].size() - 2; i >= 0; i--)
f[rt][1][i + 1] = f[rt][1][i];
f[rt][1][0] = 0;
}
void solve1(int rt) {
H.clear();
for (int x : L)
for (pair<int, int> A : g[x]) {
int y = A.first;
if (dep[x] > dep[y] + 1) H.push_back((node){x, y, A.second});
}
for (int x : R)
for (pair<int, int> A : g[x]) {
int y = A.first;
if (dep[x] > dep[y] + 1) H.push_back((node){x, y, A.second});
}
int SZ = (int)H.size(), bit = 0;
for (int t = 0; t < (1 << SZ); t++) {
for (int x : L) ban[x] = 0;
for (int x : R) ban[x] = 0;
int flag = 1, x, y, tmp = 1;
bit = 0;
for (int i = 0; i < SZ; i++)
if (t & (1 << i)) {
x = H[i].x, y = H[i].y;
bit++;
if (ban[x] || ban[y]) {
flag = 0;
break;
}
ban[x] = ban[y] = 1;
tmp = (long long)tmp * H[i].z % mod;
}
if (!flag) continue;
dfs_dp(rt);
for (int i = 0; i < f[rt][0].size(); i++)
if (f[rt][0][i]) update(res[i + bit], (long long)tmp * f[rt][0][i] % mod);
for (int i = 0; i < f[rt][1].size(); i++)
if (f[rt][1][i]) update(res[i + bit], (long long)tmp * f[rt][1][i] % mod);
}
}
void solve2() {
for (int t = 0; t < (1 << sz); t++) {
dp[t] = 0;
if (t) bit[t] = bit[t - (t & (-t))] + 1;
}
dp[0] = 1;
for (int i = 0; i < L.size(); i++) Dy[L[i]] = i;
for (int x : R) {
for (int t = (1 << sz) - 1; t >= 0; t--)
if (dp[t]) {
for (pair<int, int> A : g[x]) {
int y = Dy[A.first];
if (t & (1 << y)) continue;
update(dp[t | (1 << y)], (long long)A.second * dp[t] % mod);
}
}
}
for (int t = 0; t < (1 << sz); t++) update(res[bit[t]], dp[t]);
}
int main() {
read(n), read(k);
int x, y, z;
for (int i = 1; i <= k; i++) {
read(x), read(y), read(z);
z--;
if (!dx[x]) dx[x] = ++t1;
x = dx[x];
if (!dy[y]) dy[y] = ++t2;
y = dy[y];
now[i] = (node){x, y, z};
}
for (int i = 1; i <= k; i++) {
add_edge(now[i].x, now[i].y + t1, now[i].z);
}
jc[0] = jc[1] = 1;
for (int i = 2; i <= n; i++) jc[i] = (long long)jc[i - 1] * i % mod;
all = {1};
for (int i = 1; i <= t1; i++)
if (!vis[i]) {
V = E = 0;
L.clear(), R.clear();
dfs(i);
E /= 2;
if ((int)L.size() > (int)R.size()) swap(L, R);
sz = (int)L.size();
res = vector<int>(sz + 1, 0);
if (E <= V * 3 / 2)
solve1(i);
else
solve2();
all = all * res;
}
int ans = 0;
for (int i = 0; i < all.size(); i++)
update(ans, (long long)all[i] * jc[n - i] % mod);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void chkmax(int &x, int y) { x = x > y ? x : y; }
int dp[10005];
int n, m, c0, d0;
int main() {
scanf("%d%d%d%d", &n, &m, &c0, &d0);
memset(dp, 0, sizeof(dp));
for (int i = c0; i <= n; i++) dp[i] = i / c0 * d0;
for (int i = 0; i < m; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
for (int j = 1; j <= a / b; j++) {
for (int k = n; k >= c; k--) {
chkmax(dp[k], dp[k - c] + d);
}
}
}
printf("%d\n", dp[n]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 0x3F3F3F3F;
const int maxn = 2e5 + 555;
const int MOD = 1e9 + 7;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
string a;
cin >> a;
vector<int> V;
for (int i = 0; i < (int)a.size(); i++) V.push_back(int(a[i] - 'A'));
for (int j = 2; j < (int)a.size(); j++) {
if ((V[j]) == (V[j - 1] + V[j - 2]) % 26) {
continue;
} else {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n = 2 * 1e5 + 1;
long long root = 0;
vector<vector<long long>> adj(n);
vector<long long> c, vi(n);
vector<bool> visited(n);
void dfs(long long s, long long anc) {
if (visited[s]) return;
visited[s] = true;
for (auto u : adj[s]) {
if (visited[u] == true && u != anc && u != s && vi[s] == 0) {
c.push_back(u);
vi[u] = 1;
}
dfs(u, s);
}
}
int main() {
long long m;
cin >> m;
long long res = -1;
vector<long long> a(m);
for (long long i = 0; i < m; i++) {
cin >> a[i];
adj[a[i]].push_back(i + 1);
adj[i + 1].push_back(a[i]);
if (a[i] == i + 1 && root == 0) root = a[i];
}
for (long long i = 1; i < m + 1; i++) {
if (visited[i] == false) {
dfs(i, -1);
res++;
}
}
if (res == 0 && root == 0) {
res++;
a[c[0] - 1] = c[0];
} else if (res > 0 && root == 0) {
res++;
root = c[0];
for (long long i = 0; i < c.size(); i++) a[c[i] - 1] = root;
} else if (res > 0 && root > 0) {
for (long long i = 0; i < m; i++) {
if (a[i] == i + 1 && a[i] != root) a[i] = root;
}
for (long long i = 0; i < c.size(); i++) a[c[i] - 1] = root;
}
cout << res << endl;
for (auto i = a.begin(); i != a.end(); i++) {
cout << *i << " ";
}
cout << "\n";
;
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define F first
#define S second
#define int long long
#define double long double
using namespace std;
typedef pair<int,int> P;
typedef pair<int,P> iP;
typedef pair<P,int> Pi;
typedef pair<P,P> PP;
double eps=1e-8;
int mod=1e9+7;
int inf=1LL<<55;
priority_queue<P,vector<P>,greater<P> > pq;
int n,p[100000];
string ans;
signed main(){
cin>>n;
for(int i=0;i<n;i++)cin>>p[i];
stack<int> st;
int x=1;
string ans;
for(int i=0;i<n;i++){
while(x<=p[i])st.push(x++),ans+='(';
int y=st.top();
if(y!=p[i]){cout<<":("<<endl;return 0;}
ans+=')';
st.pop();
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
bool debug = 0;
const long long MOD = 1000000007;
const double PI = acos(-1.0);
const double eps = 1e-9;
using namespace std;
vector<int> v[5100];
int n, m;
int t[5100];
int dist(int a, int b) {
if (b >= a) return b - a;
return n - a + b;
}
int main() {
cin >> n >> m;
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
v[a].push_back(b);
}
for (int i = 1; i <= n; i++) {
if (v[i].size() == 0) {
t[i] = 0;
continue;
}
sort(v[i].begin(), v[i].end());
t[i] += (v[i].size() - 1) * n;
if ((*v[i].rbegin()) > i) {
int pos = lower_bound(v[i].begin(), v[i].end(), i) - v[i].begin();
t[i] += v[i][pos] - i;
} else {
t[i] += n - i + v[i][0];
}
if (debug)
cout << "i"
<< " = " << (i) << endl;
if (debug)
cout << "t[i]"
<< " = " << (t[i]) << endl;
if (debug) cout << endl;
}
for (int i = 1; i <= n; i++) {
int res = 0;
for (int j = 1; j <= n; j++) {
res = max(res, t[j] == 0 ? 0 : t[j] + dist(i, j));
}
printf("%d ", res);
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define all(v) begin(v),end(v)
using ll = long long;
int main() {
int h,w;cin>>h>>w;
vector<vector<string>> s(h,vector<string>(w));
rep(i,h)rep(j,w)cin>>s[i][j];
rep(i,h)rep(j,w){
if(s[i][j]=="snuke")cout<<char('A'+j)<<i+1<<endl;
}
} | 0 |
#include<iostream>
using namespace std;
int main()
{
int n, m;
cin >> n; //数列a
int a[n];
for( int i = 0; i < n; i++ )
cin >> a[i];
cin >> m; //数列b
int b[m];
for( int i = 0; i < m; i++ )
cin >> b[i];
int i = 0, j = 0; //値が小さいほうのindexを増やしていく
int judge = 2; //aの方が小さいなら1、bの方が小さいなら0
while( i != n && j != m ) //while文を抜けたときに、i==n or j==mとなるので、大小が判明する。
{
if( a[i] < b[j] )
{
judge = 1;
break;
}
else if( a[i] > b[j] )
{
judge = 0;
break;
}
else
{
i++;
j++;
}
}
if( judge == 0 )
cout << 0 << endl;
else if ( judge == 1 )
cout << 1 << endl;
else //比べた数がすべて同じ
{
if( i == n && j == m ) //i,j同時に出てきたら、bの方が大きいとは言えないので0
cout << 0 << endl;
else if( i == n ) //iが先に出てきたら、bの方が大きいので1
cout << 1 << endl;
else //jが先に出てきたら、aの方が大きいので0
cout << 0 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, k;
int dp[1005][3005];
int ans[1000][3005];
int32_t main() {
cin >> n >> k;
memset(dp, 0, sizeof dp);
cin >> s;
dp[0][k] = 1;
for (int i = 1; i <= n; i++) {
if (s[i - 1] == 'W') {
for (int j = 1; j < 2 * k; j++) {
if (dp[i - 1][j]) {
dp[i][j + 1] = 1;
ans[i][j + 1] = 1;
}
}
} else if (s[i - 1] == 'L') {
for (int j = 1; j < 2 * k; j++) {
if (dp[i - 1][j]) {
dp[i][j - 1] = 1;
ans[i][j - 1] = 2;
}
}
} else if (s[i - 1] == 'D') {
for (int j = 1; j < 2 * k; j++) {
if (dp[i - 1][j]) {
dp[i][j] = 1;
ans[i][j] = 3;
}
}
} else {
for (int j = 1; j < 2 * k; j++) {
if (dp[i - 1][j]) {
if (j + 1 <= 2 * k) {
dp[i][j + 1] = 1;
ans[i][j + 1] = 1;
}
}
if (dp[i - 1][j]) {
if (j - 1 >= 0) {
dp[i][j - 1] = 1;
ans[i][j - 1] = 2;
}
}
if (dp[i - 1][j]) {
dp[i][j] = 1;
ans[i][j] = 3;
}
}
}
}
if (!dp[n][0] && !dp[n][2 * k]) {
cout << "NO";
return 0;
} else {
map<int, char> m;
m[1] = 'W';
m[2] = 'L';
m[3] = 'D';
string res = "";
if (dp[n][0]) {
int temp = 0;
for (int i = n; i > 0; i--) {
if (s[i - 1] == 'W') {
res += 'W';
temp--;
} else if (s[i - 1] == 'L') {
res += 'L';
temp++;
} else if (s[i - 1] == 'D') {
res += 'D';
} else {
int w = ans[i][temp];
if (w == 1)
temp--;
else if (w == 2)
temp++;
res += m[w];
}
}
reverse(res.begin(), res.end());
cout << res << endl;
return 0;
} else {
int temp = 2 * k;
for (int i = n; i > 0; i--) {
if (s[i - 1] == 'W') {
res += 'W';
temp--;
} else if (s[i - 1] == 'L') {
res += 'L';
temp++;
} else {
int w = ans[i][temp];
if (w == 1)
temp--;
else if (w == 2)
temp++;
res += m[w];
}
}
reverse(res.begin(), res.end());
cout << res << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
char c = 'a';
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] >= c) {
c = s[i];
continue;
} else {
s.erase(i, 1);
};
};
cout << s;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long N = 1234567891, M = 251, N2 = 1234567891;
long long i, j;
long long x, y, z, n, m, k, l, r, t, ma = 0, ans, x2, y2, x3, y3, x4, y4, f,
kol, mi, a[410010], b[410000], p[410000],
dp[11100][110], d[410000];
string s, s2, s3;
vector<long long> v, v2, v3;
long long vo(long long x, long long y) {
if (y == 0) return 1ll;
long long t = vo(x, y / 2);
if (y % 2) return t * t % N * x % N;
return t * t % N;
}
long long C(long long n, long long k) {
return d[n] * vo(d[n - k] * d[k] % N, N - 2) % N;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
int su = 0;
for (i = 1; i <= n; i++) {
cin >> x;
a[x]++;
su += x;
}
k = 0;
for (i = 1; i <= 100; i++)
if (a[i]) k++;
if (k <= 2) {
cout << n;
return 0;
}
d[0] = 1;
for (i = 1; i <= n; i++) d[i] = (d[i - 1] * i) % N;
dp[0][0] = 1;
for (i = 1; i <= 100; i++) {
for (j = 1; j <= a[i]; j++) {
for (x = su; x >= i; x--) {
for (y = 1; y <= n; y++) {
if (!dp[x - i][y - 1]) continue;
dp[x][y] += dp[x - i][y - 1];
if (dp[x][y] >= N) dp[x][y] -= N;
}
}
}
}
ma = 0;
for (i = 1; i <= 100; i++) {
for (j = 1; j <= a[i]; j++) {
if (C(a[i], j) == dp[j * i][j])
ma = max(ma, j);
else
break;
}
}
cout << ma;
}
| 5 |
#include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int straight(int[]);
int main() {
int ans, h[5];
while(scanf("%d,%d,%d,%d,%d", &h[0], &h[1], &h[2], &h[3], &h[4])!=EOF) {
ans=0;
for(int i=0; i<4; i++) {
for(int j=i+1; j<5; j++) {
if(h[i]==h[j])
ans++;
}
}
switch(ans) {
case 1:
cout << "one pair" << endl;
break;
case 2:
cout << "two pair" << endl;
break;
case 3:
cout << "three card" << endl;
break;
case 4:
cout << "full house" << endl;
break;
case 6:
cout << "four card" << endl;
break;
default:
if(straight(h))
cout << "straight" << endl;
else
cout << "null" << endl;
}
}
return 0;
}
int straight(int h[5]) {
sort(h, h+5);
for(int i=0; i<9; i++) {
if(h[0]==i&&h[1]==i+1&&h[2]==i+2&&h[3]==i+3&&h[4]==i+4||h[0]==1&&h[1]==10&&h[2]==11&&h[3]==12&&h[4]==13)
return 1;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a, b, k, t;
int dp[2][210010], sum[210010];
int main() {
scanf("%d%d%d%d", &a, &b, &k, &t);
dp[0][0] = 1;
for (int i = 1; i <= t; i++) {
for (int j = 0; j < 210010; j++)
sum[j] = ((j > 0 ? sum[j - 1] : 0) + dp[(i - 1) % 2][j]) % 1000000007;
for (int j = 0; j < 210010; j++)
dp[i % 2][j] = (sum[j] - (j - 2 * k - 1 >= 0 ? sum[j - 2 * k - 1] : 0) +
1000000007) %
1000000007;
}
for (int i = 0; i < 210010; i++)
sum[i] = ((i > 0 ? sum[i - 1] : 0) + dp[t % 2][i]) % 1000000007;
long long ans = 0;
for (int i = 0; i <= 2 * k * t; i++)
(ans += (long long)dp[t % 2][i] *
(i + a - b - 1 < 0 ? 0 : (long long)sum[i + a - b - 1]) %
1000000007) %= 1000000007;
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char a[105][105];
int n, m;
int pan(int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m)
return 1;
else
return 0;
}
int judge(int k, int x, int y) {
int ans = 0;
if (x - 1 >= 0)
if (a[x - 1][y] == '*') ans++;
if (y - 1 >= 0)
if (a[x][y - 1] == '*') ans++;
if (x + 1 < n)
if (a[x + 1][y] == '*') ans++;
if (y + 1 < m)
if (a[x][y + 1] == '*') ans++;
if (pan(x - 1, y - 1))
if (a[x - 1][y - 1] == '*') ans++;
if (pan(x - 1, y + 1))
if (a[x - 1][y + 1] == '*') ans++;
if (pan(x + 1, y - 1))
if (a[x + 1][y - 1] == '*') ans++;
if (pan(x + 1, y + 1))
if (a[x + 1][y + 1] == '*') ans++;
if (ans == k)
return 0;
else
return 1;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; i++) scanf("%s", a[i]);
int flag = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] >= '0' && a[i][j] <= '9')
flag = judge(a[i][j] - '0', i, j);
else if (a[i][j] == '.')
flag = judge(0, i, j);
if (flag) break;
}
if (flag) break;
}
if (!flag)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
int n, A, B, r[200000];
pair<int, int> a[200000];
int main() {
cin >> n >> A >> B;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i].first);
a[i].second = i;
if (A < B) a[i].first *= (-1);
}
if (A != B) sort(a, a + n);
for (int i = 0; i < A; ++i) r[a[i].second] = 1;
for (int i = A; i < n; ++i) r[a[i].second] = 2;
for (int i = 0; i < n; ++i) cout << r[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long cols[1000001] = {0};
long long rows[1000001] = {0};
int mat[1010][1010] = {{0}};
class cmp {
public:
bool operator()(long long &p1, long long &p2) { return p2 > p1; }
};
int main() {
ios_base::sync_with_stdio(false);
rows[0] = cols[0] = 0;
int n, m, k, p;
cin >> n >> m >> k >> p;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> mat[i][j];
priority_queue<long long, vector<long long>, cmp> pq;
for (int i = 0; i < n; i++) {
long long sum = 0;
for (int j = 0; j < m; j++) sum += mat[i][j];
pq.push(sum);
}
for (int i = 1; i <= k; i++) {
rows[i] = rows[i - 1];
long long ele = pq.top();
pq.pop();
rows[i] += ele;
ele -= (m * p);
pq.push(ele);
}
while (!pq.empty()) pq.pop();
for (int i = 0; i < m; i++) {
long long sum = 0;
for (int j = 0; j < n; j++) sum += mat[j][i];
pq.push(sum);
}
for (int i = 1; i <= k; i++) {
cols[i] = cols[i - 1];
long long ele = pq.top();
pq.pop();
cols[i] += ele;
ele -= (n * p);
pq.push(ele);
}
long long ans = -1E18;
for (int i = 0; i <= k; i++) {
int r = i;
int c = k - i;
long long rem = 1LL * r * c;
rem = rem * p;
long long temp = rows[r] + cols[c] - rem;
ans = max(ans, temp);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<string> ans;
int aa;
cin >> aa;
string a[aa];
for (int z = 0; z < aa; z++) {
cin >> a[z];
ans.insert(a[z]);
}
for (int y = aa - 1; y > -1; y--) {
if (ans.find(a[y]) != ans.end()) {
cout << a[y] << endl;
ans.erase(a[y]);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long int n, m;
cin >> n >> m;
long double ans = numeric_limits<long double>::min();
for (int i = 0; i < m; i++) {
long double x, d;
cin >> x >> d;
if (d < 0) {
long double val;
if (n % 2 == 1) {
long long int s = n / 2;
val = x * n + d * s * ((s + 1));
} else {
long long int s = (n - 1) / 2;
val = x * n + d * ((s + 1) * (s + 1));
}
ans += val;
} else {
long double val = x + (d * (n - 1)) / 2;
ans += val * n;
}
}
printf("%.15Lf\n", ans / n);
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.