solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
const int OFF = (1 << 20);
int n;
long long a[200005];
long long dp[200005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
dp[n - 1] = a[n];
for (int i = n - 2; i >= 1; i--) {
dp[i] = max(dp[i + 1], a[i + 1] - dp[i + 1]);
}
cout << dp[1];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x;
cin >> n >> x;
long long int l[100], r[100];
for (long long int j = 0; j < n; j++) {
cin >> l[j] >> r[j];
}
long long int ans = 0;
ans = (l[0] - 1) % x;
ans = ans + r[0] - l[0] + 1;
long long int v = r[0] + 1;
for (long long int i = 1; i < n; i++) {
ans = ans + (l[i] - v) % x;
ans = ans + r[i] - l[i] + 1;
v = r[i] + 1;
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
unsigned int A, B, C, D, ans, num;
bitset<100000010> check;
unsigned int cal(unsigned int x) {
return A * x * x * x + B * x * x + C * x + D;
}
int main() {
scanf("%d%u%u%u%u", &n, &A, &B, &C, &D);
num = cal(2);
for (int i = 2; i <= n; i *= 2) ans += n / i * num;
num = cal(3);
for (int i = 3; i <= n; i *= 3) ans += n / i * num;
for (int i = 4; i <= n; i++) {
if (check[i / 3] || i % 2 == 0 || i % 3 == 0) continue;
num = cal(i);
for (unsigned int j = i; j <= n; j += i)
if (j % 2 && j % 3) check[j / 3] = 1;
for (unsigned long long j = i; j <= n; j *= i) ans += n / j * num;
}
printf("%u\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[4200005];
int n, k, i, j, R, L, t, mxn, rt[4200005], c[4200005], pre[4200005], l[5005],
r[5005];
int lowbit(int x) { return x & -x; }
void add(int x, int d) {
for (int i = x; i <= mxn; i += lowbit(i)) c[i] += d;
}
int find(int x, int k) {
int t = x - (lowbit(x) >> 1);
while (k > c[t] && t < x) k -= c[t], t += max((lowbit(t) >> 1), 1);
if (k == 1 && t == x) return x;
return find(t, k);
}
int main() {
scanf("%s", s + 1);
scanf("%d%d", &k, &n);
mxn = 1;
while (mxn < k) mxn <<= 1;
for (i = 1; i <= n; i++) scanf("%d%d", &l[i], &r[i]);
memset(c, 0, sizeof(c));
for (i = 1; i <= k; i++) add(i, 1), pre[i] = i;
for (i = n; i; i--)
if (r[i] < k) {
L = r[i] + 1;
R = min(r[i] + r[i] - l[i] + 1, k);
for (j = 1; j <= R - L + 1; j++) {
if (L > c[mxn]) break;
t = find(mxn, L);
if (j <= (r[i] - l[i] + 1) / 2)
pre[t] = find(mxn, l[i] - 1 + 2 * j);
else
pre[t] = find(mxn, l[i] - 2 + 2 * (j - (r[i] - l[i] + 1) / 2));
add(t, -1);
}
}
int t;
memset(rt, 0, sizeof(rt));
for (i = 1; i <= c[mxn]; i++) pre[t = find(mxn, i)] = i, rt[t] = 1;
for (i = 1; i <= k; i++) {
if (!rt[i]) pre[i] = pre[pre[i]];
printf("%c", s[pre[i]]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, e, d;
cin >> n >> d >> e;
long long int a = d;
long long int b = 5 * e;
long long int mn = n % a;
for (long long int i = 1; i <= 1000000; i++) {
long long int x = n - (b * i);
if (x < 0) {
continue;
}
x = x % a;
mn = min(mn, x);
}
cout << mn << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int n, k;
cin >> n >> k;
k--;
long long int l = 0, r = (1 * 1ll << n) - 1;
long long int ans = n;
while (true) {
long long int m = (l + r) / 2;
if (k == m) {
cout << ans << endl;
return 0;
}
ans--;
if (k < m) {
r = m - 1;
} else {
l = m + 1;
}
}
}
| 2 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int n,m;
while(cin >> n >> m, n!=0 && m!=0){
int t[n],h[m];
int sumt = 0,sumh = 0,cht = 0,chh = 0,ch = 0;
for(int i=0;i< n; i++){
cin >> t[i];
sumt += t[i];
}
for(int i=0;i<m;i++){
cin >> h[i];
sumh += h[i];
}
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(sumt - sumh - 2*t[i] + 2*h[j] == 0){
if(ch == 0){
ch = t[i] + h[j];
cht = t[i];
chh = h[j];
}else if(ch > t[i] + h[j]){
ch = t[i] + h[j];
cht = t[i];
chh = h[j];
}
}
}
}
if(cht == 0){
cout << -1 << endl;
}else{
cout << cht << " " << chh << endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using Flow = int;
using Cost = long long;
namespace mcf {
struct edge {
int from, to;
Flow capacity;
Cost cost;
edge(int f, int t, Flow cap, Cost cst) {
from = f;
to = t;
capacity = cap;
cost = cst;
}
};
vector<edge> edges;
vector<vector<int>> adj;
const Cost INF_COST = 1e12;
void shortest_paths(int v0, vector<Cost> &d, vector<int> &p) {
const int n = adj.size();
d.assign(n, INF_COST);
d[v0] = 0;
vector<bool> inq(n, false);
queue<int> q;
q.push(v0);
p.assign(n, -1);
while (!q.empty()) {
int u = q.front();
q.pop();
inq[u] = false;
for (int id : adj[u]) {
const edge &e = edges[id];
int v = edges[id].to;
if (e.capacity > 0 && d[v] > d[u] + e.cost) {
d[v] = d[u] + e.cost;
p[v] = id;
if (!inq[v]) {
inq[v] = true;
q.push(v);
}
}
}
}
}
void init(int n) {
adj.assign(n, vector<int>());
edges.clear();
}
void add(int from, int to, Flow cap, Cost c) {
adj[from].push_back(edges.size());
edges.emplace_back(from, to, cap, c);
adj[to].push_back(edges.size());
edges.emplace_back(to, from, 0, -c);
}
Cost min_cost_flow(Flow K, int s, int t) {
Flow flow = 0;
Cost cost = 0;
vector<Cost> d;
vector<int> p;
while (flow < K) {
shortest_paths(s, d, p);
if (d[t] == INF_COST) {
break;
}
Flow f = K - flow;
int cur = t;
while (cur != s) {
f = min(f, edges[p[cur]].capacity);
cur = edges[p[cur]].from;
}
flow += f;
cost += f * d[t];
cur = t;
while (cur != s) {
edges[p[cur]].capacity -= f;
edges[p[cur] ^ 1].capacity += f;
cur = edges[p[cur]].from;
}
}
return cost;
}
}; // namespace mcf
template <typename T>
using pqueue = priority_queue<T, vector<T>, function<bool(T, T)>>;
void foo() {
int n, k;
cin >> n >> k;
const int V = 1 << n;
vector<int> a(V);
for (int i = 0; i < V; i++) {
cin >> a[i];
}
vector<pair<int, int>> edges;
auto comp = [&](const pair<int, int> &e1, const pair<int, int> &e2) {
return a[e1.first] + a[e1.second] > a[e2.first] + a[e2.second];
};
const int edges_count = (1 << (n - 1)) * n;
const int need = min((k - 1) * (n * 2 - 1) + 1, edges_count);
pqueue<pair<int, int>> pq(comp);
for (int i = 0; i < V; i++) {
for (int bit = 1; bit < V; bit <<= 1) {
if (i & bit) {
auto p = make_pair(i ^ bit, i);
if ((int)pq.size() < need) {
pq.push(p);
} else if (comp(p, pq.top())) {
pq.pop();
pq.push(p);
}
}
}
}
while (pq.size()) {
edges.push_back(pq.top());
pq.pop();
}
vector<int> vertices;
for (int i = 0; i < need; i++) {
vertices.push_back(edges[i].first);
vertices.push_back(edges[i].second);
}
sort(vertices.begin(), vertices.end());
vertices.erase(unique(vertices.begin(), vertices.end()), vertices.end());
vector<int> id(V);
for (int i = 0; i < (int)vertices.size(); i++) {
id[vertices[i]] = i;
}
mcf::init(vertices.size() + 2);
for (int i = 0; i < need; i++) {
int x = edges[i].first, y = edges[i].second;
if (__builtin_parity(x)) {
mcf::add(id[x], id[y], 1, -a[x] - a[y]);
} else {
mcf::add(id[y], id[x], 1, -a[x] - a[y]);
}
}
int source = vertices.size();
int sink = source + 1;
for (int v : vertices) {
if (__builtin_parity(v)) {
mcf::add(source, id[v], 1, 0);
} else {
mcf::add(id[v], sink, 1, 0);
}
}
int ans = -mcf::min_cost_flow(k, source, sink);
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
foo();
}
| 4 |
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <utility>
#define FR first
#define SE second
#define lowbit(x) (x&-x)
using namespace std;
int sumv[100005];
void add(int x,int num) {
for(;x;x-=lowbit(x)) sumv[x]+=num;
}
int sum(int x,int n) {
int s=0;
for(;x<=n;x+=lowbit(x)) s+=sumv[x];
return s;
}
typedef pair<int,int> pr;
pr a[300005];
bool cmp(pr x,pr y) {
return x.SE-x.FR>y.SE-y.FR;
}
int ans[100005];
int main() {
int n,m;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) {
int x,y;
scanf("%d%d",&x,&y);
a[i]=pr(x,y);
add(y,1);
add(x-1,-1);
}
sort(a+1,a+n+1,cmp);
int l=1;
for(int i=m;i>0;i--) {
while (l<=n&&a[l].SE-a[l].FR>=i) {
add(a[l].SE,-1);
add(a[l].FR-1,1);
l++;
}
ans[i]=l-1;
for(int j=i;j<=m;j+=i) ans[i]+=sum(j,m);
}
for(int i=1;i<=m;i++) printf("%d\n",ans[i]);
return 0;
} | 0 |
#include <iostream>
#include <string>
#include <utility>
#include <map>
#include <vector>
using namespace std;
int n, m, k;
string o;
vector<pair<string, vector<string> > > mix;
map<string, int> item;
int sum(vector<string> s) {
int p = 0;
for (int i = 0; i < s.size(); i++) {
p += item[s[i]];
}
return p;
}
void update() {
int p;
for (int i = 0; i < m; i++) {
p = sum(mix[i].second);
if (p < item[mix[i].first]) {
item[mix[i].first] = p;
}
}
}
int main(){
while (cin >> n && n != 0) {
item = map<string, int>();
for (int i = 0; i < n; i++) {
cin >> o >> k;
item[o] = k;
}
cin >> m;
mix = vector<pair<string, vector<string> > >(m);
for (int i = 0; i < m; i++) {
cin >> mix[i].first >> k;
for (int j = 0; j < k; j++) {
cin >> o;
mix[i].second.push_back(o);
}
}
for (int i = 0; i < 10000; i++) {
update();
}
cin >> o;
cout << item[o] << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
vector<int> v[60];
inline int ch(char c) { return (c - 'a' + 1); }
int dfs(int depth, int s) {
if (depth == n) return s == 1;
int res = 0;
for (int i = 1; i <= 6; ++i) {
int p = s * 6 + i;
if (v[p].size() == 0) continue;
res += dfs(depth + 1, v[p][0]);
}
return res;
}
int main() {
while (~scanf("%d %d", &n, &q)) {
for (int i = 0; i < 60; ++i) v[i].clear();
char c1[2], c2[2];
for (int i = 0; i < q; ++i) {
scanf("%s %s", c1, c2);
int a = ch(c1[0]) * 6 + ch(c1[1]), c = ch(c2[0]);
v[a].push_back(c);
}
int res = 0;
for (int i = 1; i <= 6; ++i) res += dfs(1, i);
printf("%d\n", res);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main(void) {
long long int m, i, l, count[100008] = {0}, e, swap;
char ch[200006];
scanf("%s\n", ch);
l = strlen(ch);
scanf("%I64d\n", &m);
while (m--) {
scanf("%I64d", &e);
count[e]++;
}
long long int s = 0;
for (i = 1; i <= l / 2; i++) {
s += count[i];
count[i] = s;
}
for (i = 1; i <= l / 2; i++) {
if (count[i] % 2 == 1) {
swap = ch[l - i];
ch[l - i] = ch[i - 1];
ch[i - 1] = swap;
}
}
printf("%s\n", ch);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void printAll(int n, ...) {
if (1) {
va_list ap;
va_start(ap, n);
for (int i = 1; i <= n; i++) cout << va_arg(ap, long long int) << " ";
cout << endl;
va_end(ap);
}
}
template <typename T>
string toString(T n) {
stringstream ss;
ss << n;
string s;
ss >> s;
return s;
}
void init() {
cout << fixed << setprecision(0);
ios_base::sync_with_stdio(false);
cin.tie(0);
}
bool isInteger(double n) {
if (n - (long long int)n == 0)
return true;
else
return false;
}
int main() {
init();
long long int i, j, k;
long long int t = 1;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> ara(n);
for (int i = 0; i < n; i++) cin >> ara[i];
bool inc = (ara[1] - ara[0] > 0 ? true : false);
vector<int> ans;
ans.push_back(ara[0]);
for (i = 2; i < n; i++) {
if ((inc && ara[i] - ara[i - 1] < 0) ||
(!inc && ara[i] - ara[i - 1] > 0)) {
inc = !inc;
ans.push_back(ara[i - 1]);
}
}
ans.push_back(ara[n - 1]);
cout << ans.size() << endl;
{
if (1) {
for (auto a : ans) cout << a << " ";
cout << endl;
}
};
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, cnt = 0;
cin >> t;
long long n;
for (int i = 1; i <= t; i++) {
cin >> n;
if (n == 1)
cout << 0 << "\n";
else {
while (n != 1) {
if (n % 2 == 0) {
n = n / 2;
cnt++;
} else if (n % 3 == 0) {
n = (2 * n) / 3;
cnt++;
} else if (n % 5 == 0) {
n = (4 * n) / 5;
cnt++;
} else
break;
}
if (n == 1)
cout << cnt << "\n";
else
cout << -1 << endl;
}
cnt = 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int read() {
char k = getchar();
int x = 0;
while (k < '0' || k > '9') k = getchar();
while (k >= '0' && k <= '9') x = x * 10 + k - '0', k = getchar();
return x;
}
const int MX = 2e5 + 23;
int n, m;
int ORG[MX], CAC[MX], tot = 1;
struct edge {
int node, next, w;
} h[MX * 6];
void addedge(int u, int v, int *head, int flg = 1) {
h[++tot] = (edge){v, head[u], 1}, head[u] = tot;
if (flg) addedge(v, u, head, 0);
}
int __[MX];
void init() {
for (int i = 1; i < MX; ++i) __[i] = i;
}
int find(int x) { return __[x] == x ? x : __[x] = find(__[x]); }
void link(int u, int v) { __[find(u)] = find(v); }
int DFN[MX], low[MX], stk[MX], stktop, cnt, jishu[MX];
int pcnt, oddcyc, color[MX];
void tarjan(int x, int c = 0, int *head = ORG) {
DFN[x] = low[x] = ++cnt, stk[++stktop] = x;
color[x] = c;
for (int i = head[x], d; i; i = h[i].next) {
int odd = oddcyc;
if (h[i].w) {
if (color[d = h[i].node] == c) ++oddcyc;
h[i].w = h[i ^ 1].w = 0;
}
if (!DFN[d = h[i].node]) {
int QWQ = odd;
tarjan(d, c ^ 1);
odd = (oddcyc - odd) > 0;
low[x] = std::min(low[x], low[d]);
if (low[d] == DFN[x]) {
jishu[++pcnt] = odd;
color[pcnt] = 0;
for (int tmp = 0; tmp != d; --stktop) {
tmp = stk[stktop];
addedge(pcnt, tmp, CAC);
fprintf(stderr, "LINK %d %d\n", pcnt, tmp);
}
addedge(x, pcnt, CAC);
fprintf(stderr, "lINK %d %d\n", x, pcnt);
oddcyc = QWQ;
}
} else if (DFN[d] < low[x])
low[x] = DFN[d];
}
}
int hson[MX], size[MX], dep[MX], fa[MX];
int Sji[MX];
void dfs(int x, int *head = CAC) {
Sji[x] += jishu[x];
fprintf(stderr, "Sji[%d] = %d col = %d ,ji = %d\n", x, Sji[x], color[x],
jishu[x]);
size[x] = 1;
for (int i = head[x], d; i; i = h[i].next) {
if ((d = h[i].node) == fa[x]) continue;
fa[d] = x, dep[d] = dep[x] + 1;
Sji[d] += Sji[x];
dfs(d);
size[x] += size[d];
if (size[d] > size[hson[x]]) hson[x] = d;
}
}
int top[MX];
void dfs2(int x, int topf, int *head = CAC) {
top[x] = topf;
for (int i = head[x], d; i; i = h[i].next) {
if ((d = h[i].node) == fa[x]) continue;
dfs2(d, d == hson[x] ? topf : d);
}
}
int LCA(int x, int y) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) std::swap(x, y);
x = fa[top[x]];
}
return dep[x] < dep[y] ? x : y;
}
int query(int x, int y) {
if (x == y) return 0;
if (find(x) != find(y)) return 0;
int lca = LCA(x, y);
if (Sji[x] + Sji[y] - 2 * Sji[lca] + jishu[lca]) return 1;
if (color[x] ^ color[y]) return 1;
return 0;
}
int main() {
memset(color, -1, sizeof color);
init();
pcnt = n = read(), m = read();
for (int i = 1, u, v; i <= m; ++i) {
u = read(), v = read();
addedge(u, v, ORG);
link(u, v);
}
for (int i = 1; i <= n; ++i)
if (!DFN[i]) tarjan(i);
for (int i = 1; i <= pcnt; ++i)
fprintf(stderr, "color[%d] = %d\n", i, color[i]);
memset(DFN, 0, sizeof DFN);
for (int i = 1; i <= n; ++i) {
if (!DFN[find(i)]) {
DFN[find(i)] = 1;
dfs(find(i));
dfs2(find(i), find(i));
}
}
int q = read();
while (q--) {
int u = read(), v = read();
printf("%s\n", query(u, v) ? "Yes" : "No");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[10010];
bool vis[1010][1010];
int main() {
scanf("%s", s);
int n = strlen(s);
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
if (!vis[4][4]) {
printf("4 3\n");
vis[4][4] = 1;
} else {
printf("4 1\n");
vis[4][4] = 0;
}
} else {
if (!vis[1][1]) {
printf("1 1\n");
vis[1][1] = 1;
} else {
printf("3 1\n");
vis[1][1] = 0;
}
}
}
return 0;
}
| 3 |
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef struct{
string s;
int dot;
}data;
int n;
string s;
data d;
vector<data> vec;
int dotcount(string s){
int count = 0;
for(int i = 0;i < s.size();i++){
if(s[i] != '.')break;
count++;
}
return count;
}
void check(int dot,int bgn,int ed){
bool ccount = true;
for(int i = bgn + 1;i < ed;i++){
if(vec[i].dot == dot){
for(int j = bgn + 1;j < i;j++){
vec[j].s[dot-1] = '|';
}
check(dot+1,bgn + 1,i);
check(dot,i,ed);
ccount = false;
break;
}
}
if(ccount && bgn + 1 < ed)check(dot+1,bgn+1,ed);
}
int main(){
while(1){
cin >> n;
if(n == 0)break;
vec.clear();
cin >> s;
cout << s << endl;
for(int i = 1;i < n;i++){
cin >> d.s;
d.dot = dotcount(d.s);
vec.push_back(d);
}
check(1,0,vec.size());
for(int i = 0;i < vec.size();i++){
vec[i].s[vec[i].dot-1] = '+';
}
for(int i = 0;i < vec.size();i++){
for(int j = 0;j < vec[i].dot;j++){
if(vec[i].s[j] == '.'){
vec[i].s[j] = ' ';
}
}
}
for(int i = 0;i < vec.size();i++){
cout << vec[i].s << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
struct node {
int l, r;
int mid() { return (l + r) >> 1; }
int val;
} t[maxn * 4];
int Beg[maxn], End[maxn], n, a[maxn];
int Lis;
int kind[maxn];
void build(int l, int r, int id) {
t[id].val = 0;
t[id].l = l;
t[id].r = r;
if (t[id].l == t[id].r) return;
int m = t[id].mid();
build(l, m, ((id) << 1));
build(m + 1, r, (id << 1 | 1));
}
int query(int l, int r, int id) {
if (l > r) return 0;
if (l == t[id].l && r == t[id].r) return t[id].val;
int m = t[id].mid();
if (m >= r)
return query(l, r, ((id) << 1));
else if (m < l)
return query(l, r, (id << 1 | 1));
else
return max(query(l, m, ((id) << 1)), query(m + 1, r, (id << 1 | 1)));
}
void update(int id, int pos, int add) {
if (t[id].l == t[id].r && t[id].l == pos) {
t[id].val = max(t[id].val, add);
return;
}
int m = t[id].mid();
if (pos <= m)
update(((id) << 1), pos, add);
else
update((id << 1 | 1), pos, add);
t[id].val = max(t[((id) << 1)].val, t[(id << 1 | 1)].val);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, maxn - 5, 1);
for (int i = 1; i <= n; i++) {
int maxx = query(1, a[i] - 1, 1);
Beg[i] = maxx + 1;
Lis = max(Lis, Beg[i]);
update(1, a[i], Beg[i]);
}
build(1, maxn - 5, 1);
for (int i = n; i >= 1; i--) {
int maxx = query(a[i] + 1, maxn - 5, 1);
End[i] = maxx + 1;
Lis = max(Lis, End[i]);
update(1, a[i], End[i]);
}
build(1, maxn - 5, 1);
for (int i = 1; i <= n; i++) {
if (Beg[i] + End[i] - 1 < Lis)
kind[i] = 1;
else if (query(a[i], maxn - 5, 1) == Lis)
kind[i] = 2;
else
kind[i] = 3;
update(1, a[i], Beg[i] + End[i] - 1);
}
build(1, maxn - 5, 1);
for (int i = n; i >= 1; i--) {
if (kind[i] == 1) continue;
if (query(1, a[i], 1) == Lis) kind[i] = 2;
update(1, a[i], Beg[i] + End[i] - 1);
}
for (int i = 1; i <= n; i++) printf("%d", kind[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 300005;
const long long M = 1005;
const long long mod = 1000000007;
const long long inf = (1 << 30);
const long long linf = (1LL << 61);
long long n, v[M], h, a[M], rez, sum;
int main() {
ios::sync_with_stdio(false);
cin.tie();
cin >> n >> h;
for (long long i = 1; i <= n; ++i) cin >> v[i];
for (long long k = 1; k <= n; ++k) {
for (long long i = 1; i <= k; ++i) a[i] = v[i];
sort(a + 1, a + k + 1);
sum = 0LL;
for (long long i = k; i >= 1; i -= 2) sum += a[i];
if (sum <= h) rez = k;
}
cout << rez;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<pi, pi> pp;
typedef pair<ll, ll> pl;
const double EPS = 1e-9;
const ll MOD = 1000000007;
const int inf = 1 << 30;
const ll linf = 1LL << 60;
ll a, b;
int main() {
cin >> b >> a;
ll ans = linf;
for (ll q = 1; q <= 10*b; q++) {
ll p = q*b/a;
ll x = q*b-p*a;
if (x >= b) continue;
if (p+x > q) {
ans = min(ans, q*b);
}
}
if (ans == linf) cout << -1 << endl;
else cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const long long int inf = 1e17;
bool cmp(pair<long long int, long long int>& a,
pair<long long int, long long int>& b) {
if (a.first != b.first)
return a.first > b.first;
else
return a.second < b.second;
}
vector<long long int> parent, size, visited, a, b;
vector<long long int> ans, xv;
vector<vector<long long int>> adj;
long long int modval(long long int n) { return n % mod; }
long long int modadd(long long int a, long long int b) {
return modval(modval(a) + modval(mod + modval(b)));
}
long long int modmul(long long int a, long long int b) {
return modval(modval(a) * modval(b));
}
long long int fast_expo(long long int base, long long int power,
long long int ans) {
if (power > 0) {
if (power & 1) ans = modmul(ans, base);
power >>= 1, base = modmul(base, base);
return fast_expo(base, power, ans);
} else
return ans;
}
long long int find_set(long long int v) {
if (v == parent[v]) return v;
return find_set(parent[v]);
}
void make_set(long long int v) {
parent[v] = v;
size[v] = 1;
}
void union_sets(long long int a, long long int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (size[a] < size[b]) swap(a, b);
parent[b] = a;
size[a] += size[b];
}
}
long long int findmsb(long long int n) {
for (long long int i = 29; i >= 0; i--) {
if (n >= (1 << i)) return i;
}
}
void ceasars_legions() {
long long int n;
scanf("%lld", &n);
long long int a[n + 1], sum = 0;
a[n] = -1;
for (long long int i = n, x; i >= 0; i--) {
if (a[i] == -1) {
if (i != 0) {
x = 1 << findmsb(i);
x += x - 1;
if (x - i > 0) a[x - i - 1] = -1;
} else
x = 0;
}
a[i] = x - i;
sum += a[i] + i;
}
cout << sum << '\n';
for (long long int i = 0; i <= n; i++) printf("%lld ", a[i]);
}
int32_t main() {
long long int t = 1;
while (t--) ceasars_legions();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
int n, p[MAXN];
bool vis[MAXN];
vector<int> cyc;
void dfs(int i) {
if (vis[i]) return;
vis[i] = true;
cyc.push_back(i);
dfs(p[i]);
}
bool cmp(const vector<int> &a, const vector<int> &b) {
return ((int)(a).size()) < ((int)(b).size());
}
vector<int> scramble(const vector<int> &a) {
int n = ((int)(a).size());
vector<int> res(n);
for (int i = 0, j = 0; j < n; i = (i + 2) % n, j++) res[i] = a[j];
return res;
}
vector<int> merge(const vector<int> &a, const vector<int> &b) {
assert(((int)(a).size()) == ((int)(b).size()));
int n = ((int)(a).size());
vector<int> res;
for (int i = 0; i < (int)(n); i++) {
res.push_back(a[i]);
res.push_back(b[i]);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
scanf("%d", &n);
for (int i = 0; i < (int)(n); i++) {
scanf("%d", p + i);
p[i]--;
}
vector<vector<int> > odd, even;
for (int i = 0; i < (int)(n); i++)
if (!vis[i]) {
cyc.clear();
dfs(i);
if (((int)(cyc).size()) & 1)
odd.push_back(cyc);
else
even.push_back(cyc);
}
sort((even).begin(), (even).end(), cmp);
vector<vector<int> > fin;
bool bad = false;
if (((int)(even).size()) & 1)
bad = true;
else {
for (int i = 0; i < ((int)(even).size()); i += 2) {
if (((int)(even[i]).size()) == ((int)(even[i + 1]).size()))
fin.push_back(merge(even[i], even[i + 1]));
else {
bad = true;
break;
}
}
}
if (!bad)
for (auto &c : odd) fin.push_back(scramble(c));
if (bad)
printf("-1\n");
else {
vector<int> res(n);
for (auto &c : fin)
for (int i = 0; i < (int)(((int)(c).size())); i++) {
int j = (i + 1) % ((int)(c).size());
res[c[i]] = c[j] + 1;
}
for (auto x : res) printf("%d ", x);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long big, lz;
};
node tree[100010 << 2];
int n, m, w, h;
void pushup(int rt) {
tree[rt].big = max(tree[rt << 1].big, tree[rt << 1 | 1].big);
}
void pushdown(int rt) {
int ls = rt << 1, rs = rt << 1 | 1;
if (tree[rt].lz) {
tree[ls].big = tree[rs].big = tree[rt].lz;
tree[ls].lz = tree[rs].lz = tree[rt].lz;
tree[rt].lz = 0;
}
}
void buildtree(int l, int r, int rt) {
int mid = (l + r) >> 1;
tree[rt].lz = 0;
if (l == r) {
cin >> tree[rt].big;
return;
}
buildtree(l, mid, rt << 1);
buildtree(mid + 1, r, rt << 1 | 1);
pushup(rt);
}
void updata(int L, int R, long long c, int l, int r, int rt) {
int mid = (l + r) >> 1;
if (L <= l && r <= R) {
tree[rt].lz = c;
tree[rt].big = c;
return;
}
pushdown(rt);
if (L <= mid) updata(L, R, c, l, mid, rt << 1);
if (R > mid) updata(L, R, c, mid + 1, r, rt << 1 | 1);
pushup(rt);
}
long long query(int L, int R, int l, int r, int rt) {
int mid = (l + r) >> 1;
long long res1, res2;
res1 = res2 = 0;
if (L <= l && r <= R) return tree[rt].big;
pushdown(rt);
if (L <= mid) res1 = query(L, R, l, mid, rt << 1);
if (R > mid) res2 = query(L, R, mid + 1, r, rt << 1 | 1);
pushup(rt);
if (res1 > res2)
return res1;
else
return res2;
}
int main() {
scanf("%d", &n);
buildtree(1, n, 1);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &w, &h);
long long tmp;
tmp = query(1, w, 1, n, 1);
printf("%I64d\n", tmp);
updata(1, w, (long long)(h + tmp), 1, n, 1);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
void init_ios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
const int N = 1005;
int n, m, res[2 * N], wyn[2 * N], p[2 * N], bla[2 * N];
char a[N][N];
vector<int> topo, child[2 * N], kto[2 * N];
bool vis[2 * N];
int Find(int x) {
if (x == p[x]) return x;
return p[x] = Find(p[x]);
}
void Union(int x, int y) {
x = Find(x);
y = Find(y);
if (x == y) return;
if (child[x].size() < child[y].size()) swap(x, y);
for (int c : child[y]) child[x].push_back(c);
for (int c : kto[y]) kto[x].push_back(c);
kto[y].clear();
child[y].clear();
p[y] = x;
}
void dfs(int v) {
vis[v] = true;
for (int x : child[v])
if (!vis[Find(x)]) dfs(Find(x));
topo.push_back(v);
}
void dfs2(int v) {
bla[v] = 1;
for (int x : child[v]) {
if (bla[Find(x)] == 0)
dfs2(Find(x));
else if (bla[Find(x)] == 1) {
cout << "No\n";
exit(0);
}
}
bla[v] = 2;
}
int main() {
init_ios();
cin >> n >> m;
for (int i = 1; i <= n + m; ++i) {
p[i] = i;
kto[i].push_back(i);
wyn[i] = 1;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
cin >> a[i][j];
if (a[i][j] == '<')
child[Find(i)].push_back(Find(n + j));
else if (a[i][j] == '>')
child[Find(n + j)].push_back(Find(i));
else
Union(i, n + j);
}
for (int i = 1; i <= n + m; ++i)
if (bla[Find(i)] == 0) dfs2(Find(i));
for (int i = 1; i <= n + m; ++i)
if (!vis[Find(i)]) dfs(Find(i));
reverse(topo.begin(), topo.end());
for (int i = 0; i + 1 < topo.size(); ++i) {
for (int el : child[topo[i]])
wyn[Find(el)] = max(wyn[Find(el)], 1 + wyn[topo[i]]);
}
for (int i = 1; i <= n + m; ++i)
for (int x : kto[Find(i)]) res[x] = wyn[Find(i)];
cout << "Yes\n";
for (int i = 1; i <= n; ++i) cout << res[i] << " ";
cout << "\n";
for (int i = n + 1; i <= n + m; ++i) cout << res[i] << " ";
cout << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 20;
int n, col[N], b[N], g[N];
vector<int> adj[N];
void dfs(int v, int c) {
col[v] = c;
for (auto u : adj[v])
if (!col[u]) dfs(u, 3 - c);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> b[i] >> g[i];
adj[--b[i]].push_back(--g[i]);
adj[g[i]].push_back(b[i]);
}
for (int i = 0; i < 2 * n; i++) adj[i].push_back(i ^ 1);
for (int i = 0; i < 2 * n; i++)
if (!col[i]) dfs(i, 1);
for (int i = 0; i < n; i++) cout << col[b[i]] << " " << col[g[i]] << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
int t;
cin >> t;
while (t--) {
scanf("%lld %lld", &n, &m);
long long x = n, s = 0;
if (n < m) {
s = (m - x) / 5;
x += s * 5;
if (m - x == 1 || m - x == 2)
s += 1;
else if (m == x)
s = s;
else
s += 2;
} else {
s = (x - m) / 5;
x -= s * 5;
if (x - m == 1 || x - m == 2)
s += 1;
else if (m != x)
s += 2;
}
printf("%lld\n", s);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T x) {
return x > 0 ? x : -x;
}
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<T> &x) {
s << "[";
for (auto it : x) {
s << it << ", ";
}
s << "]";
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const set<T> &x) {
s << "{";
for (auto it : x) {
s << it << ", ";
}
s << "}";
return s;
}
template <typename U, typename V>
ostream &operator<<(ostream &s, const pair<U, V> &x) {
s << "(" << x.first << ", " << x.second << ")";
return s;
}
template <typename T>
bool chmax(T &x, const T &y) {
if (x < y) {
x = y;
return true;
}
return false;
}
template <typename T>
bool chmin(T &x, const T &y) {
if (x > y) {
x = y;
return true;
}
return false;
}
const int maxn = 2e5 + 5;
struct tree {
long long tr[maxn * 4];
long long ad[maxn * 4];
int n;
tree(int n) : n(n) { build(1, 0, n - 1); }
void build(int v, int l, int r) {
tr[v] = 0;
ad[v] = 0;
if (l != r) {
int c = (l + r) >> 1;
build(2 * v, l, c);
build(2 * v + 1, c + 1, r);
}
}
void add(int v, int l, int r, int i, int j, long long val) {
if (i <= l && r <= j) {
ad[v] += val;
tr[v] += val;
return;
}
int c = (l + r) >> 1;
if (i <= c) {
add(2 * v, l, c, i, j, val);
}
if (c < j) {
add(2 * v + 1, c + 1, r, i, j, val);
}
tr[v] = ad[v] + min(tr[2 * v], tr[2 * v + 1]);
}
void add(int l, int r, long long val) { add(1, 0, n - 1, l, r, val); }
long long get(int v, int l, int r, int i, int j) {
if (i <= l && r <= j) {
return tr[v];
}
long long res = 1e18;
int c = (l + r) >> 1;
if (i <= c) {
chmin(res, get(2 * v, l, c, i, j));
}
if (c < j) {
chmin(res, get(2 * v + 1, c + 1, r, i, j));
}
return res + ad[v];
}
long long get(int l, int r) { return get(1, 0, n - 1, l, r); }
};
const long long INF = 1e18;
tree even(maxn / 2 + 1), odd((maxn + 1) / 2 + 1);
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
vector<int> b(n, a[0]);
for (int i = 1; i < n; i++) {
b[i] = a[i] - b[i - 1];
}
even.n = n / 2 + 1, odd.n = (n + 1) / 2 + 1;
for (int i = 0; i < n; i++) {
if (i & 1) {
odd.add(i / 2, i / 2, b[i]);
} else {
even.add(i / 2, i / 2, b[i]);
}
}
int q;
cin >> q;
while (q--) {
int type;
scanf("%d", &type);
if (type == 1) {
int l, r, k;
scanf("%d%d%d", &l, &r, &k);
if (l & 1) {
odd.add(l / 2, odd.n - 1, k);
if ((r - l + 1) & 1) {
even.add((r + 1) / 2, even.n - 1, -k);
} else {
odd.add((r + 1) / 2, odd.n - 1, -k);
}
} else {
even.add(l / 2, even.n - 1, k);
if ((r - l + 1) & 1) {
odd.add((r + 1) / 2, even.n - 1, -k);
} else {
even.add((r + 1) / 2, even.n - 1, -k);
}
}
} else {
int l, r;
scanf("%d%d", &l, &r);
long long pref = 0;
if (l > 0) {
if ((l - 1) & 1) {
pref = odd.get((l - 1) / 2, (l - 1) / 2);
} else {
pref = even.get((l - 1) / 2, (l - 1) / 2);
}
}
long long oddmin = INF, evenmin = INF;
if (l == r) {
if (l & 1) {
oddmin = odd.get(l / 2, r / 2);
} else {
evenmin = even.get(l / 2, r / 2);
}
} else {
if (r & 1) {
if (l & 1) {
oddmin = odd.get(l / 2, r / 2);
evenmin = even.get((l + 1) / 2, (r - 1) / 2);
} else {
oddmin = odd.get((l + 1) / 2, r / 2);
evenmin = even.get(l / 2, (r - 1) / 2);
}
} else {
if (l & 1) {
oddmin = odd.get(l / 2, (r - 1) / 2);
evenmin = even.get((l + 1) / 2, r / 2);
} else {
oddmin = odd.get((l + 1) / 2, (r - 1) / 2);
evenmin = even.get(l / 2, r / 2);
}
}
}
if (l & 1) {
oddmin += pref;
evenmin -= pref;
evenmin += 1;
} else {
oddmin -= pref;
evenmin += pref;
oddmin += 1;
}
if (evenmin <= 0 || oddmin <= 0) {
printf("0\n");
} else {
long long last = INF;
if (r & 1) {
last = odd.get(r / 2, r / 2);
if (l & 1) {
last += pref;
} else {
last -= pref;
last += 1;
}
} else {
last = even.get(r / 2, r / 2);
if (l & 1) {
last -= pref;
last += 1;
} else {
last += pref;
}
}
if (last == 1) {
printf("1\n");
} else {
printf("0\n");
}
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, d, m, a[200005], ans[200005];
set<pair<int, int> > s;
int main() {
cin >> n >> m >> d;
int i;
for (i = 0; i < n; i++) {
cin >> a[i];
s.insert({a[i], i});
}
int day = 0;
while (!s.empty()) {
day++;
int p = s.begin()->second;
ans[p] = day;
s.erase(s.begin());
while (true) {
auto j = s.lower_bound({a[p] + 1 + d, 0});
if (j == s.end()) break;
p = j->second;
ans[p] = day;
s.erase(j);
}
}
cout << day << '\n';
for (i = 0; i < n; i++) cout << ans[i] << ' ';
return 0;
}
| 3 |
#include<iostream>
#include<algorithm>
int N;
int count(int n, int b) {
int res = 0;
while(n > 0) {
res += n%b;
n /= b;
}
return res;
}
int main() {
std::cin >> N;
int ans = N;
for(int i = 0; i <= N; i += 9) {
ans = std::min(ans, count(i/9, 9)+count(N-i, 6));
}
std::cout << ans << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[11][111], b[11][111], c[11][111];
char str[111];
struct node {
int n, v;
node(int _n, int _v) { n = _n, v = _v; }
node() {}
friend bool operator<(node a, node b) { return a.v > b.v; }
} p[111];
int main() {
int n, m, cc;
while (~scanf("%d%d%d", &n, &m, &cc)) {
for (int i = 0; i < n; i++) {
scanf(" %*s", str);
for (int j = 0; j < m; j++) {
scanf("%d %d %d", &a[i][j], &b[i][j], &c[i][j]);
}
}
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
int t = 0, cnt = 0, q = cc;
for (int k = 0; k < m; k++) {
if (b[j][k] > a[i][k]) p[cnt++] = node(c[i][k], (b[j][k] - a[i][k]));
}
sort(p, p + cnt);
for (int k = 0; k < cnt; k++) {
if (q <= p[k].n) {
t += q * p[k].v;
break;
} else {
t += p[k].n * p[k].v;
q -= p[k].n;
}
}
res = max(res, t);
}
}
printf("%d\n", res);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[100003], cnt;
int main() {
cin >> n >> k;
long long d = 1LL << 62;
int id;
for (int i = 1; i <= k; i++) {
long long x;
scanf("%lld", &x);
long long num = n / x;
if (n - num * x < d) {
d = n - num * x;
id = i;
cnt = num;
}
}
cout << id << " " << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int l[200007], r[200007];
int main() {
int n, m;
cin >> n >> m;
if (1LL * m * (m - 1) < n) {
printf("NO");
return 0;
}
printf("YES\n");
for (int i = 1, x = 1; i <= n; i++, x++) {
l[i] = (i - 1) % m + 1;
r[i] = x % m + 1;
if (!(i % m)) x++;
printf("%d %d\n", l[i], r[i]);
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main(){
// 0 1 2 3 4 5 6 7 8 9 10 11 12
int days[]={0,31,29,31,30,31,30,31,31,30,31,30,31};
for(int i=2; i<=12; ++i){
days[i] += days[i-1];
}
char day[][20]={
"Thursday",
"Friday",
"Saturday",
"Sunday",
"Monday",
"Tuesday",
"Wednesday"
};
while(true){
// 月, 日
int m, d;
cin >> m >> d;
if(m == 0){
break;
}
cout << day[(days[m-1]+d-1)%7] <<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxx = 1000010;
struct node {
int num;
long long val;
bool operator<(const node &X) const {
if (val == X.val) return num > X.num;
return val < X.val;
}
};
struct nod {
int num;
int pos;
int bj;
} s[maxx];
struct no {
int l;
int r;
int sum;
long long val;
} tree[maxx];
bool cmp(nod a, nod b) { return a.num < b.num; }
priority_queue<node> q;
long long n, m, k, p;
long long ans = 0, total = 0, sum = 0;
long long a[maxx], b[maxx];
void build(int p, int l, int r) {
tree[p].l = l, tree[p].r = r;
int mid = (l + r) >> 1;
if (l == r) return;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
}
void update(int p, int c, long long val) {
int l = tree[p].l, r = tree[p].r;
if (l == r && l == c) {
tree[p].sum = 1;
tree[p].val = val;
return;
}
int mid = (l + r) >> 1;
if (c <= mid)
update(p << 1, c, val);
else
update(p << 1 | 1, c, val);
tree[p].val = tree[p << 1].val + tree[p << 1 | 1].val;
tree[p].sum = tree[p << 1].sum + tree[p << 1 | 1].sum;
}
long long query(int p, int rank) {
int l = tree[p].l, r = tree[p].r;
int mid = (l + r) >> 1;
if (l == r) return tree[p].val;
if (tree[p << 1].sum >= rank)
return query(p << 1, rank);
else
return query(p << 1 | 1, rank - tree[p << 1].sum);
}
int main() {
scanf("%lld", &n);
for (register int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
q.push(node{i, a[i]});
}
scanf("%lld", &m);
for (register int i = 1; i <= m; i++) {
scanf("%d%d", &s[i].num, &s[i].pos);
s[i].bj = i;
}
sort(s + 1, s + m + 1, cmp);
build(1, 1, n);
for (register int i = 1; i <= m; i++) {
while (total < s[i].num) {
int u = q.top().num;
long long val = q.top().val;
update(1, u, val);
q.pop();
total++;
}
b[s[i].bj] = query(1, s[i].pos);
}
for (register int i = 1; i <= m; i++) printf("%lld\n", b[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, n;
long long check(int l, int r, int m) {
return max(
(((a + (l - 1) * b + a + (r - 1) * b) * (r - l + 1)) / 2 - 1) / m + 1,
a + (r - 1) * b);
}
int main() {
scanf("%lld %lld %lld", &a, &b, &n);
while (n--) {
long long left, t, m;
scanf("%lld %lld %lld", &left, &t, &m);
long long l = left, r = left + t;
long long best = -1;
while (l < r - 1) {
long long meio = (l + r) / 2;
if (check(left, meio, m) <= t) {
best = max(best, meio);
l = meio + 1;
} else {
r = meio - 1;
}
}
if (check(left, l, m) <= t) {
best = max(best, l);
}
if (r >= left && check(left, r, m) <= t) {
best = max(best, r);
}
printf("%lld\n", best);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
class BinTree : vector<int> {
public:
explicit BinTree(int k = 0) { assign(k + 1, 0); }
int lowbit(int k) { return k & -k; }
int sum(int k) { return k > 0 ? sum(k - lowbit(k)) + (*this)[k] : 0; }
int last() { return size() - 1; }
void add(int k, int w) {
if (k > last()) return;
(*this)[k] += w;
add(k + lowbit(k), w);
}
};
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
bool cmp2(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first) return a.second < b.second;
return a.first < b.first;
}
int n, m;
vector<int> as;
vector<pair<int, int> > qs;
void solve() {
BinTree bt(n);
vector<pair<int, int> > bs;
for (int i = 1; i <= n; i++) {
bs.push_back(pair<int, int>(as[i], i));
}
sort(bs.begin(), bs.end(), cmp);
vector<pair<int, int> > qs2 = qs;
sort(qs2.begin(), qs2.end(), cmp2);
map<pair<int, int>, int> res;
int cnt = 0;
for (int i = 0; i < m; i++) {
pair<int, int> q = qs2[i];
int k = q.first, p = q.second;
while (cnt < k) {
pair<int, int> b = bs[cnt];
bt.add(b.second, 1);
cnt++;
}
int l = 1, r = n;
while (l <= r) {
int m = l + (r - l) / 2;
int c = bt.sum(m);
if (c < p)
l = m + 1;
else
r = m - 1;
}
res[q] = as[l];
}
for (int i = 0; i < m; i++) {
cout << res[qs[i]] << endl;
}
}
int main() {
scanf("%d", &n);
as = vector<int>(n + 1, 0);
for (int i = 1; i <= n; i++) {
scanf("%d", &as[i]);
}
scanf("%d", &m);
qs = vector<pair<int, int> >(m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &qs[i].first, &qs[i].second);
}
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
const int N = 2e5 + 7;
vector<int> b;
int a[N];
int n, m, h;
int seg[N * 4];
int laz[N * 4];
void spl(int v) {
for (int u = (v * 2); u <= (v * 2 + 1); u++) {
seg[u] += laz[v];
laz[u] += laz[v];
}
laz[v] = 0;
}
void add(int l, int r, int val, int v = 1, int s = 0, int e = b.size()) {
if (r <= s || e <= l) return;
if (l <= s && e <= r) {
seg[v] += val;
laz[v] += val;
return;
}
spl(v);
add(l, r, val, (v * 2), s, ((s + e) / 2));
add(l, r, val, (v * 2 + 1), ((s + e) / 2), e);
seg[v] = min(seg[(v * 2)], seg[(v * 2 + 1)]);
}
int sml(int x) { return upper_bound(b.begin(), b.end(), x) - b.begin(); }
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= m; i++) {
int x;
cin >> x;
b.push_back(h - x);
}
sort(b.begin(), b.end());
for (int i = 1; i <= n; i++) cin >> a[i];
int res = 0;
for (int i = m - 1; i >= 0; i--) add(i, i + 1, i - m);
for (int i = 1; i <= m; i++) add(0, sml(a[i]), 1);
if (seg[1] >= 0) res++;
for (int i = m + 1; i <= n; i++) {
add(0, sml(a[i]), 1);
add(0, sml(a[i - m]), -1);
if (seg[1] >= 0) res++;
}
cout << res;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void loadData(void);
int proc(void);
void printRes(int);
int a;
int main(int argc, char** argv) {
loadData();
printRes(proc());
return 0;
}
int proc(void) {
long long res = 0;
res += (long long)(a + a + a - 1) * (long long)a / (long long)2;
res += (long long)(a + a + a - 2) * (long long)(a - 1) / (long long)2;
res += (long long)(1 + a - 1) * (long long)(a - 1) * (long long)3;
return (int)(res % (long long)(2000000000));
}
void loadData(void) {
scanf("%d", &a);
return;
}
void printRes(int res) {
printf("%d\n", res);
return;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int dist[3005][3005];
vector<int> adj[3005];
pair<int, int> path[3005][3005];
set<tuple<int, int, int>> forbid;
int main() {
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 0; i < k; i++) {
int a, b, c;
cin >> a >> b >> c;
forbid.insert(tuple<int, int, int>(a, b, c));
}
memset(dist, 0x3f3f3f3f, sizeof dist);
queue<pair<int, int>> q;
dist[1][1] = 0;
q.push({1, 1});
while (!q.empty()) {
int u = q.front().first;
int v = q.front().second;
q.pop();
for (auto it : adj[v]) {
if (!forbid.count(tuple<int, int, int>(u, v, it)) &&
dist[v][it] > 1 + dist[u][v]) {
dist[v][it] = 1 + dist[u][v];
path[v][it] = {u, v};
q.push({v, it});
}
}
}
int best = 0x3f3f3f3f;
pair<int, int> ans;
for (int i = 1; i <= n; i++) {
if (dist[i][n] < best) {
best = dist[i][n];
ans = {i, n};
}
}
if (best == 0x3f3f3f3f) {
cout << -1 << '\n';
return 0;
}
cout << best << '\n';
vector<int> vi;
for (auto u = ans; u.second != 1; u = path[u.first][u.second]) {
vi.push_back(u.second);
}
vi.push_back(1);
for (int i = vi.size() - 1; i >= 0; i--) {
cout << vi[i] << ' ';
}
cout << '\n';
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
const int N=25,mo=1e9+7;
struct Matrix{
int a[N][N],n;
Matrix operator * (const Matrix &b)const{
Matrix c;c.n=n;
for(int i=0;i<n;i++)
for(int j=0;j<n;j++){
c.a[i][j]=0;
for(int k=0;k<n;k++)(c.a[i][j]+=1ll*a[i][k]*b.a[k][j]%mo)%=mo;
}
return c;
}
}a;
Matrix qpow(Matrix a,int b){
Matrix ans;ans.n=a.n;
for(int i=0;i<a.n;i++){
for(int j=0;j<a.n;j++)ans.a[i][j]=0;
ans.a[i][i]=1;
}
while(b){
if(b&1)ans=ans*a;
a=a*a,b>>=1;
}
return ans;
}
int main(){
a.n=21;
for(int i=0;i<5;i++)a.a[i<<1][i<<1|1]=a.a[i<<1|1][i<<1]=a.a[(i+1)<<1][i<<1]=1;
for(int i=10;i<=20;i++)a.a[i+1][i]=a.a[i][i]=1;
int t,n;scanf("%d",&t);
while(t--){
scanf("%d",&n);
printf("%d\n",qpow(a,n+10).a[20][0]);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
int main() {
int m, n, k, j, a, c, z, i, count = 0, y = 0;
scanf("%d %d %d", &n, &m, &k);
int x[n];
for (i = 0; i < n; i++) {
scanf("%d", &x[i]);
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
a = x[i];
if (a > x[j]) {
c = x[i];
x[i] = x[j];
x[j] = c;
}
}
}
if (k < m) {
for (i = 0; i < n; i++) {
count = count + x[i];
k--;
z = count + k;
y++;
if (z > m || z == m) {
printf("%d", y);
return 0;
}
}
if (z < m) printf("-1");
} else if (k >= m)
printf("0");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, ans;
string str;
cin >> n;
cin >> str;
ans = 0;
for (int i = (int)str.size() - 1; i >= 0; i--) {
if (str[i] == 'B') {
ans = (ans * 2) + 1;
} else {
ans = ans * 2;
}
}
cout << ans << "\n";
return 0;
}
| 2 |
#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <functional>
#include <bitset>
using namespace std;
signed main(){
int S, T, U, N, O, D; cin >> S >> T >> U >> N >> O >> D;
vector<int> e(T);
vector<int> c(T);
for(int i = 0; i < T; i++) cin >> e[i] >> c[i];
vector<int> h(N);
vector<int> a(N);
for(int i = 0; i < N; i++) cin >> h[i] >> a[i];
vector<vector<vector<int>>> dp1(T + 1, vector<vector<int>> (U + 1, vector<int> (S + 1, -1)));
dp1[0][0][0] = 0;
vector<vector<int>> dp2(N + 1, vector<int> (1000005, 0));
dp2[0][0] = 0;
// 1
for(int i = 0; i < T; i++){
for(int j = 0; j <= U; j++){
for(int k = 0; k <= S; k++){
if(dp1[i][j][k] == -1) continue;
// しない
dp1[i + 1][j][k] = max(dp1[i + 1][j][k], dp1[i][j][k]);
// 運動する
if(j + 1 <= U && k + e[i] <= S) dp1[i + 1][j + 1][k + e[i]] = max(dp1[i + 1][j + 1][k + e[i]], dp1[i][j][k] + c[i]);
}
}
}
/*
for(int i = 0; i <= T; i++){
for(int j = 0; j <= U; j++){
for(int k = 0; k <= S; k++){
cout << i << " " << j << " " << k << " " << dp1[i][j][k] << endl;
}
}
}
*/
for(int i = 0; i < N; i++){
for(int j = 0; j <= 100000; j++){
if(j < a[i]){
dp2[i + 1][j] = dp2[i][j];
}else{
dp2[i + 1][j] = max(dp2[i][j], dp2[i + 1][j - a[i]] + h[i]);
}
}
}
for(int j = 1; j <= 100000; j++) dp2[N][j] = max(dp2[N][j], dp2[N][j - 1]);
/*
cout << endl;
cout << endl;
for(int i = 0; i <= N; i++){
for(int j = 0; j <= 20; j++){
cout << dp2[i][j] << " ";
}
cout << endl;
}
cout << endl;
*/
vector<vector<int>> dp(D + 1, vector<int> (S + 1, -1));
dp[0][S] = 0;
for(int i = 0; i < D; i++){
for(int j = 0; j <= S; j++){
if(dp[i][j] == -1) continue;
int cur = min(S, j + O);
for(int use = 0; use <= cur; use++){
// cout << i << " " << j << " " << use << endl;
int nxt = cur - use;
int cal = dp1[T][U][use];
if(cal == -1) continue;
int add = dp2[N][cal];
dp[i + 1][nxt] = max(dp[i + 1][nxt], dp[i][j] + add);
}
}
}
int ans = -1;
for(int i = 0; i <= S; i++) ans = max(ans, dp[D][i]);
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, a[111][111];
cin >> m >> n >> k;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) cin >> a[i][j];
if (m <= k) {
int allOne = (1 << m) - 1, f[1024] = {0};
for (int j = 1; j <= n; j++) {
int mask = 0;
for (int i = 1; i <= m; i++) mask = mask << 1 | a[i][j];
for (int pattern = 0; pattern < allOne; pattern++)
f[pattern] += min(__builtin_popcount(pattern ^ mask),
__builtin_popcount(pattern ^ mask ^ allOne));
}
int ans = m * n;
for (int pattern = 0; pattern < allOne; pattern++)
ans = min(ans, f[pattern]);
if (ans > k) ans = -1;
cout << ans << endl;
} else {
int ans = m * n;
for (int fixedCol = 1; fixedCol <= n; fixedCol++) {
int flip = 0;
for (int j = 1; j <= n; j++) {
int dif = 0;
for (int i = 1; i <= m; i++) dif += a[i][j] ^ a[i][fixedCol];
flip += min(dif, m - dif);
}
ans = min(ans, flip);
}
if (ans > k) ans = -1;
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int casos;
unsigned long long a, b;
scanf("%d", &casos);
unsigned long long ul;
while (casos--) {
scanf("%llu %llu", &a, &b);
bitset<60> bitC(0);
if (a == b) {
cout << a << endl;
continue;
}
if (log2(b) - log2(a) >= 1) {
ul = pow(2, ((int)log2(b + 1)));
printf("%llu\n", ul - 1);
continue;
} else {
bitset<60> bitA(a);
bitset<60> bitB(b + 1);
bool fl = true;
for (int i = 59; i >= 0; i--) {
if (!(bitA[i] ^ bitB[i]) && fl) {
bitC[i] = (bitA[i]);
} else if (fl) {
fl = false;
bitC[i] = 0;
} else {
bitC[i] = 1;
}
}
}
unsigned long long rpta = bitC.to_ullong();
printf("%llu\n", rpta);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int vx[300000][4][4] = {}, vy[300000][4][4] = {};
int Index(char c) {
if (c == 'A') return 0;
if (c == 'C') return 1;
if (c == 'G') return 2;
return 3;
}
char NumToChar(int ind) {
if (ind == 0) return 'A';
if (ind == 1) return 'C';
if (ind == 2) return 'G';
return 'T';
}
vector<vector<char>> megT;
void Kiir(int n, int j, int a, int b) {
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
megT[j][i] = NumToChar(a);
else
megT[j][i] = NumToChar(b);
}
return;
}
void Kiir2(int n, int j, int a, int b) {
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
megT[i][j] = NumToChar(a);
else
megT[i][j] = NumToChar(b);
}
return;
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<char>> table(n, vector<char>(m));
megT.resize(n, vector<char>(m));
vector<int> v = {0, 1, 2, 3};
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> table[i][j];
for (int x = 0; x < 4; x++) {
for (int y = 0; y < 4; y++) {
if (x == y) continue;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (j % 2 == 0 && Index(table[i][j]) == x)
vx[i][x][y]++;
else if (j % 2 == 1 && Index(table[i][j]) == y)
vx[i][x][y]++;
}
}
}
}
for (int x = 0; x < 4; x++) {
for (int y = 0; y < 4; y++) {
if (x == y) continue;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (j % 2 == 0 && Index(table[j][i]) == x)
vy[i][x][y]++;
else if (j % 2 == 1 && Index(table[j][i]) == y)
vy[i][x][y]++;
}
}
}
}
vector<int> megVX, megVY;
int megX = -1, megY = -1;
do {
int akt = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
akt += max(vx[i][v[0]][v[1]], vx[i][v[1]][v[0]]);
else
akt += max(vx[i][v[2]][v[3]], vx[i][v[3]][v[2]]);
}
if (akt > megX) {
megVX = v;
megX = akt;
}
akt = 0;
for (int i = 0; i < m; i++) {
if (i % 2 == 0)
akt += max(vy[i][v[0]][v[1]], vy[i][v[1]][v[0]]);
else
akt += max(vy[i][v[2]][v[3]], vy[i][v[3]][v[2]]);
}
if (akt > megY) {
megVY = v;
megY = akt;
}
} while (next_permutation(v.begin(), v.end()));
if (megX >= megY) {
v = megVX;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (vx[i][v[0]][v[1]] > vx[i][v[1]][v[0]])
Kiir(m, i, v[0], v[1]);
else
Kiir(m, i, v[1], v[0]);
} else {
if (vx[i][v[2]][v[3]] > vx[i][v[3]][v[2]])
Kiir(m, i, v[2], v[3]);
else
Kiir(m, i, v[3], v[2]);
}
}
} else {
v = megVY;
for (int i = 0; i < m; i++) {
if (i % 2 == 0) {
if (vy[i][v[0]][v[1]] > vy[i][v[1]][v[0]])
Kiir2(n, i, v[0], v[1]);
else
Kiir2(n, i, v[1], v[0]);
} else {
if (vy[i][v[2]][v[3]] > vy[i][v[3]][v[2]])
Kiir2(n, i, v[2], v[3]);
else
Kiir2(n, i, v[3], v[2]);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << megT[i][j];
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n == 1 || n == 2) puts("-1");
if (n == 3) puts("210");
if (n >= 4) {
string s = "10";
for (int i = 0; i < n - 4; i++) {
s += '0';
}
n -= 4;
if (n % 6 == 0) s += "50";
if (n % 6 == 1) s += "80";
if (n % 6 == 2) s = s.substr(0, s.length() - 1), s += "170";
if (n % 6 == 3) s += "20";
if (n % 6 == 4) s = s.substr(0, s.length() - 1), s += "200";
if (n % 6 == 5) s = s.substr(0, s.length() - 1), s += "110";
cout << s << endl;
}
}
| 2 |
#include <iostream>
#include <cmath>
#include <vector>
using namespace std;
int main() {
//freopen ("input.txt","r", stdin);
//freopen ("output.txt","w", stdout);
cin.tie(0);
cin.sync_with_stdio(false);
int t;
cin >> t;
while (t > 0) {
t--;
long long n, k;
cin >> n >> k;
k--;
int a[n];
for (int i = 0; i < n; ++i) {
a[i] = 0;
}
int i = 1;
while (k > 0) {
if (i >= n) {
break;
}
a[i] = k % 2;
k /= 2;
i++;
}
if (k > 0 && i >= n) {
cout << -1 << endl;
continue;
}
i = n - 1;
while (i >= 0) {
if (a[i] == 0) {
cout << n - i << ' ';
i--;
}
else {
int t = i;
while (a[i] == 1) {
i--;
}
for (int k = n - i; k >= n - t; --k) {
cout << k << ' ';
}
i--;
}
}
cout << endl;
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
constexpr int maxn = 5e5 + 10;
bool mark[maxn];
int a[maxn], b[maxn], n;
vector<int> ans;
struct SegmentTree {
int tree[4 * maxn];
void build(int node, int i, int j) {
if (i == j) return (void)(tree[node] = b[i]);
int m = (i + j) >> 1;
build(node << 1, i, m);
build(node << 1 | 1, m + 1, j);
tree[node] = max(tree[node << 1], tree[node << 1 | 1]);
}
void upd(int node, int i, int j, int p) {
if (i == j) return (void)(tree[node] = 0);
int m = (i + j) >> 1;
if (p <= m)
upd(node << 1, i, m, p);
else
upd(node << 1 | 1, m + 1, j, p);
tree[node] = max(tree[node << 1], tree[node << 1 | 1]);
}
int query(int node, int i, int j, int r, int v) {
if (i > r || tree[node] <= v) return 0;
if (i == j) return i;
int m = (i + j) >> 1;
int p1 = query(node << 1, i, m, r, v);
return p1 ? p1 : query(node << 1 | 1, m + 1, j, r, v);
}
} seg;
void dfs(int u) {
mark[u] = 1;
seg.upd(1, 1, n, u);
if (!mark[b[u]]) dfs(b[u]);
int v = seg.query(1, 1, n, a[u] - 1, u);
while (v) {
dfs(v);
v = seg.query(1, 1, n, a[u] - 1, u);
}
ans.push_back(u);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) b[i] = n + 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] != -1)
b[a[i]] = i;
else
a[i] = n + 1;
}
seg.build(1, 1, n);
mark[n + 1] = 1;
for (int i = 1; i <= n; i++)
if (!mark[i]) dfs(i);
vector<int> final(n + 1);
for (int i = 0; i < n; i++) final[ans[i]] = i + 1;
for (int i = 1; i <= n; i++) printf("%d ", final[i]);
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void mysol() {
string s;
cin >> s;
map<char, long long> m;
for (char ch : s) m[ch]++;
if (m['1'] * m['0'] == 0)
cout << s;
else {
for (long long i = 0; i < s.size(); i++) cout << "10";
}
cout << endl;
}
int32_t main() {
fast();
long long t;
cin >> t;
while (t-- > 0) {
mysol();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[1001] = {0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0};
int n;
int main() {
scanf("%d", &n);
printf("%d\n", a[n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bitset<100001> c;
bool a = false;
int main() {
int n;
cin >> n;
int x, y;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
if (x == -1) c[i] = 1;
if (x != -1 && !y) {
c[i] = 1;
c[x] = 1;
}
}
for (int i = 1; i <= n; i++) {
if (!c[i]) {
cout << i << " ";
a = true;
}
if (i == n) cout << endl;
}
if (!a) cout << "-1" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n;
vector<pair<int, int>> vec(n);
for (int i = 0; i < n; i++) {
cin >> a >> b;
vec[i] = pair<int, int>(a, b);
}
sort(vec.begin(), vec.end());
vector<int> ymx(n, -1);
ymx[0] = vec[0].second;
for (int i = 1; i < n; i++) {
ymx[i] = max(ymx[i - 1], vec[i].second);
}
int count = 0;
int temp;
vector<int> nxt(n, -1);
for (int i = n - 1; i > 0; i--) {
if (vec[i].first > vec[i - 1].first) {
nxt[i] = i - 1;
}
}
for (int i = 1; i < n; i++) {
if (nxt[i] == -1) nxt[i] = nxt[i - 1];
}
if (nxt[n - 1] == -1) {
cout << 0 << endl;
return 0;
}
for (int i = n - 1; i > 0; i--) {
if (nxt[i] < 0) {
continue;
}
if (ymx[nxt[i]] > vec[i].second) {
count++;
}
}
cout << count << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool sign[1005];
vector<int> a[1005], b[1005];
int vst[1005];
queue<int> q;
bool have = false;
int check1() {
int res = 0;
for (int x = 1; x <= n; x++) {
memset(vst, -1, sizeof(vst));
vst[x] = 0;
q.push(x);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < (int)a[u].size(); i++) {
int v = a[u][i];
if (vst[v] == -1) {
vst[v] = vst[u] + 1;
q.push(v);
res = max(res, vst[v]);
}
}
}
for (int i = 1; i <= n; i++)
if (vst[i] == -1) return -1;
}
return res;
}
int check2() {
int res = 0;
for (int x = 1; x <= n; x++) {
memset(vst, -1, sizeof(vst));
vst[x] = 0;
q.push(x);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < (int)b[u].size(); i++) {
int v = b[u][i];
if (vst[v] == -1) {
vst[v] = vst[u] + 1;
q.push(v);
res = max(res, vst[v]);
}
}
}
for (int i = 1; i <= n; i++)
if (vst[i] == -1) return -1;
}
return res;
}
void backtrack(int u, int v) {
if (u == n) {
int res = min(check1(), check2());
if (res != -1 && !sign[res]) {
sign[res] = true;
if (res == m) {
int cnt = 0;
for (int i = 1; i <= n; i++) cnt += (int)a[i].size();
printf("%d\n", cnt / 2);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)a[i].size(); j++)
if (i < a[i][j]) printf("%d %d\n", i, a[i][j]);
}
have = true;
}
}
return;
}
a[u].push_back(v);
a[v].push_back(u);
if (v == n)
backtrack(u + 1, u + 2);
else
backtrack(u, v + 1);
a[u].pop_back();
a[v].pop_back();
b[u].push_back(v);
b[v].push_back(u);
if (v == n)
backtrack(u + 1, u + 2);
else
backtrack(u, v + 1);
b[u].pop_back();
b[v].pop_back();
}
int main() {
scanf("%d%d", &n, &m);
if (n <= 6) {
backtrack(1, 2);
if (!have) printf("-1\n");
} else {
if (m != 2 && m != 3)
printf("-1\n");
else if (m == 2) {
printf("%d\n", n);
for (int i = 1; i < n; i++) printf("%d %d\n", i, i + 1);
printf("%d 1\n", n);
} else {
int res = 1;
for (int i = 1; i <= n - 3; i++)
for (int j = i + 1; j <= n - 1; j++) res++;
printf("%d\n", res);
for (int i = 1; i <= n - 3; i++) {
for (int j = i + 1; j <= n - 1; j++) printf("%d %d\n", i, j);
}
printf("%d %d\n", n - 2, n);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void ga(int N, long long* A) {
for (int i(0); i < N; i++) scanf("%lld", A + i);
}
long long N, K, B, C, T[(1 << 18)], V, S, X;
long long df(long long A) { return min((A % 5) * C + (A / 5) * B, A * C); }
long long ev(long long I) {
priority_queue<long long> q;
long long t, S(0), X(1ll << 62), H;
for (int i(0); i < K - 1; i++) q.push(t = df(I - T[i])), S += t;
for (int k(K - 1); k < N; k++) {
t = df(I - T[k]), H = S + t;
for (int i(0); i < 5; i++)
if (!((I - T[k] - i) % 5)) X = min(X, H - K * df(I - T[k] - i));
if (q.top() > t) S -= q.top(), S += t, q.pop(), q.push(t);
}
return X;
}
int main(void) {
scanf("%lld%lld%lld%lld", &N, &K, &B, &C), ga(N, T);
sort(T, T + N), X = 1ll << 62;
for (int i(0); i < 5; i++) X = min(X, ev((1000000666) + i));
printf("%lld\n", X);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int i = 1, j = n * n, k, l;
for (k = 1; k <= n; k++) {
l = 1;
while (l <= (n / 2)) {
cout << i << " " << j << " ";
i++;
j--;
l++;
}
cout << endl;
}
return 0;
}
| 1 |
#include <cstdio>
#include <algorithm>
using namespace std;
int n,d[110],ans;
int main() {
scanf("%d",&n);
ans=0;
for (int i=1;i<=n;i++) {
scanf("%d",&d[i]);
ans+=d[i];
}
if (ans%10==0) {
sort(d+1,d+(n+1));
bool t=false;
for (int i=1;i<=n;i++)
if (d[i]%10!=0) {
ans-=d[i];
t=true;
break;
}
if (!t)
ans=0;
}
printf("%d\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(time(0));
const int32_t SMALL = LONG_MIN >> 1;
const int32_t BIG = LONG_MAX >> 1;
const int32_t MAXN = 500001;
int32_t st[MAXN], en[MAXN];
vector<int32_t> g[MAXN];
int32_t n, cur;
void dfs(int32_t u, int32_t p) {
for (int32_t v : g[u])
if (v != p) st[v] = ++cur;
en[u] = ++cur;
reverse(g[u].begin(), g[u].end());
for (int32_t v : g[u])
if (v != p) dfs(v, u);
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int32_t i = 1; i < n; i++) {
int32_t u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
st[1] = ++cur;
dfs(1, -1);
for (int32_t i = 1; i <= n; i++) cout << st[i] << " " << en[i] << endl;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
signed main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
ll mod = 1e9+7;
ll t;
string s;
cin>>t>>s;
ll n = s.size();
ll m=0;
if(n==1 && t<=9){
cout << t << endl;
return 0;
}
for(ll i=0;i<n;i++){
m*=10;
m%=mod;
m += s[i]-'0';
m%=mod;
}
if(s[0]!='0' && m==t){
cout << s << endl;
return 0;
}
ll ch[10][10]={};
for(ll i=0;i<10;i++){
for(ll j=0;j<10;j++){
for(ll k=0;k<n;k++){
ch[i][j]*=10;
ch[i][j]%=mod;
if(s[k]==(char)('0'+i)) ch[i][j] += j;
else ch[i][j] += s[k]-'0';
ch[i][j] %= mod;
}
}
}
vector<ll> v(10);
for(ll i=0;i<10;i++){
v[i]=i;
}
do{
if(v[s[0]-'0']==0) continue;
ll ret = m;
for(ll i=0;i<10;i++){
ret += ch[i][v[i]];
ret %= mod;
ret += mod - m;
ret %= mod;
}
if(ret == t){
for(ll i=0;i<n;i++){
cout << v[s[i]-'0'];
}
cout<<endl;
return 0;
}
}while(next_permutation(v.begin(),v.end()));
cout << -1 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool go(const map<long long, int>& all, int x,
multiset<long long, greater<long long>> trash) {
multiset<long long, greater<long long>> ends;
for (const auto& p : all) {
if (p.second < x) {
for (int i = p.second; i < x; ++i) {
ends.insert(p.first);
}
x = p.second;
} else {
for (int i = x; i < p.second; ++i) {
trash.insert(p.first);
}
}
}
if (trash.size() > ends.size()) {
return 0;
}
while (!trash.empty()) {
if (*ends.begin() >= *trash.begin()) {
trash.erase(trash.begin());
ends.erase(ends.begin());
} else {
return 0;
}
}
return 1;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout.setf(ios_base::fixed);
cout.precision(28);
int n;
cin >> n;
map<long long, int> all;
multiset<long long, greater<long long>> trash;
long long z = 1;
for (int i = 0; i < 50; ++i) {
all[z] = 0;
z <<= 1;
}
for (int i = 0; i < n; ++i) {
long long x;
cin >> x;
if (all.count(x)) {
++all[x];
} else {
trash.insert(x);
}
}
if (all[1] == 0 || !go(all, all[1], trash)) {
cout << "-1\n";
return 0;
}
int L = 0, R = all[1], M;
while (R - L > 1) {
M = (L + R) / 2;
if (go(all, M, trash)) {
R = M;
} else {
L = M;
}
}
int zz = all[1];
for (int i = R; i <= zz; ++i) {
cout << i << ' ';
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define sz(x) (int)x.size()
#define pb push_back
#define mp make_pair
#define fi(a, b) for(int i=a; i<=b; i++)
#define fj(a, b) for(int j=a; j<=b; j++)
#define fo(a, b) for(int o=a; o<=b; o++)
#define fdi(a, b) for(int i=a; i>=b; i--)
#define fdj(a, b) for(int j=a; j>=b; j--)
#define fdo(a, b) for(int o=a; o>=b; o--)
#ifdef LOCAL
#define err(...) fprintf(stderr, __VA_ARGS__)
#else
#define err(...) while(false) {}
#endif
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef long double ld;
typedef unsigned long long ull;
/////////////////////////////////
int const MAX = 1e5 + 41;
int n;
ll p;
ll w[MAX];
ll b[MAX];
void solve() {
ll cur = 0;
priority_queue<ll> pq;
fi(1, n) {
cur -= b[i] * p;
pq.push(b[i] * p + (100 - p) * w[i]);
}
int ans = 0;
while (cur < 0) {
ans++;
ll x = pq.top();
cur += x;
pq.pop();
}
printf("%d\n", ans);
}
int main() {
#ifdef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
scanf("%d %lld", &n, &p);
fi(1, n) {
scanf("%lld %lld", &w[i], &b[i]);
}
solve();
#ifdef LOCAL
err("ELAPSED TIME: %.3Lf\n", (ld) clock() / CLOCKS_PER_SEC);
#endif
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int a[N], b[N];
struct node {
int a, b, c;
};
vector<node> v;
int T[4 * N];
void inti(int n, int b, int e) {
if (b == e) {
T[n] = a[b];
return;
}
inti(n * 2, b, (b + e) / 2);
inti(n * 2 + 1, (b + e) / 2 + 1, e);
T[n] = T[n * 2] & T[n * 2 + 1];
}
int query1(int n, int b, int e, int i, int j) {
if (b > j || e < i) return 2147483647;
if (b >= i && e <= j) return T[n];
return query1(n * 2, b, (b + e) / 2, i, j) &
query1(n * 2 + 1, (b + e) / 2 + 1, e, i, j);
}
int main() {
int n, q;
cin >> n >> q;
while (q--) {
node nd;
scanf("%d%d%d", &nd.a, &nd.b, &nd.c);
v.push_back(nd);
}
for (int i = 0; i <= 30; i++) {
memset(b, 0, sizeof b);
for (int j = 0; j < v.size(); j++) {
int val = v[j].c;
if (val & (1 << i)) {
b[v[j].a]++;
b[v[j].b + 1]--;
}
}
for (int j = 1; j <= n; j++) {
b[j] += b[j - 1];
if (b[j]) a[j] |= (1 << i);
}
}
memset(T, 0, sizeof T);
inti(1, 1, n);
for (int i = 0; i < v.size(); i++) {
if (query1(1, 1, n, v[i].a, v[i].b) != v[i].c) {
puts("NO");
return 0;
}
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1025][1025], vis[1025];
bool flag;
bool ok() {
for (int i = 1; i <= n; i++)
if (a[i][0] != n) return 0;
return 1;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n - 1; ++j) cin >> a[i][j];
a[i][0] = 1;
}
for (int z = 0; z <= 0x3f3f3f3f; z++) {
if (ok()) {
cout << z << '\n';
return 0;
}
flag = 0;
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; i++) {
if (vis[i] || a[i][0] == n) continue;
int x = a[i][a[i][0]];
if (a[x][a[x][0]] == i && vis[i] == 0 && vis[x] < 1) {
a[i][0]++;
a[x][0]++;
vis[i] = vis[x] = 2 - 1;
flag = 1;
}
}
if (!flag) {
cout << -1 << '\n';
return 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
long long n, MOD;
long long w[100005];
long long q, l, r;
long long ph[100005];
long long LL;
long long qpow(long long x, long long y, long long MOD) {
long long ret = 1;
int flag = 0;
while (y) {
if (y & 1) {
ret = ret * x;
if (ret >= MOD) {
ret = ret % MOD;
flag = 1;
}
}
x = x * x;
if (x >= MOD) x = x % MOD + MOD;
y >>= 1;
}
if (flag) ret += MOD;
return ret;
}
long long Euler(long long n) {
long long ret = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) ret = ret / i * (i - 1);
while (n % i == 0) n /= i;
}
if (n > 1) ret = ret / n * (n - 1);
return ret % MOD;
}
long long solve(long long l, long long r, long long MOD) {
if (l == r) {
if (w[r] >= MOD)
return w[r] % MOD + MOD;
else
return w[r];
}
if (MOD == 1) return 1;
return qpow(w[l], solve(l + 1, r, ph[l - LL + 2]), ph[l - LL + 1]);
}
int main() {
scanf("%lld%lld", &n, &MOD);
ph[1] = MOD;
scanf("%lld", &w[1]);
for (int i = 2; i <= n; i++) {
scanf("%lld", &w[i]);
ph[i] = Euler(ph[i - 1]);
}
scanf("%lld", &q);
while (q--) {
scanf("%lld%lld", &l, &r);
if (l == r) {
printf("%lld\n", w[l] % MOD);
continue;
}
if (MOD == 1) {
printf("0\n");
continue;
}
long long i;
for (i = r - 1; ph[i - l + 2] == 1 && i >= l; i--)
;
long long y = w[i + 1];
for (; i >= l; i--) {
if (y >= ph[i - l + 2]) y = (y % ph[i - l + 2]) + ph[i - l + 2];
y = qpow(w[i], y, ph[i - l + 1]);
}
printf("%lld\n", y % MOD);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) solve();
return 0;
}
void solve() {
long long i, j, n, s;
cin >> n >> s;
vector<long long> a(n);
long long small, tot = 0;
for (i = 0; i < n; ++i) {
cin >> a[i];
tot += a[i];
}
small = *min_element(a.begin(), a.end());
if (s > tot) {
cout << -1;
return;
}
for (i = 0; i < n; ++i) s -= a[i] - small;
if (s <= 0) {
cout << small;
return;
}
if (s % n)
cout << small - (s / n) - 1;
else
cout << small - s / n;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n, k, t = 240, cnt = 0;
cin >> n >> k;
t -= k;
for (int i = 1; i <= n; i++) {
if (t - (5 * i) >= 0) {
t -= 5 * i;
cnt++;
} else
break;
}
cout << cnt << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, n, m, x = 0, t, ans = 0, sum = 0;
string s, a, b;
bool f = 0, flag = 0;
map<string, bool> mm;
cin >> a >> b;
mm[a] = 1;
mm[b] = 1;
cin >> n;
cout << a << " " << b << endl;
for (i = 0; i < n; i++) {
cin >> a >> b;
mm[a] = 0;
map<string, bool>::iterator it;
for (it = mm.begin(); it != mm.end(); it++) {
if (mm[it->first] == 1) {
cout << it->first;
break;
}
}
cout << " " << b << "\n";
mm[b] = 1;
}
return 0;
}
| 1 |
#include<cstdio>
using namespace std;
int main()
{
register int n,l,r,x,ans=0;
scanf("%d%d%d",&n,&l,&r);
while(n--)
{
scanf("%d",&x);
if(x<l||x>=r) ans++;
}
printf("%d\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,M;cin>>N>>M;
vector<int> A(N+1,0);
for(int i=0;i<M;i++){
int S,T;cin>>S>>T;
A.at(S)++;
A.at(T)++;
}
for(int i=1;i<=N;i++) cout<<A.at(i)<<endl;
}
| 0 |
#include <iostream>
#include <string>
using namespace std;
int main(void){
int A,B,X;
cin>>A>>B>>X;
if(A<=X&&X<=A+B) cout<<"YES";
else cout<<"NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) REP(i,0,n)
#define REP(i,s,e) for(int i=(s); i<(int)(e); i++)
#define pb push_back
#define all(r) (r).begin(),(r).end()
#define rall(r) (r).rbegin(),(r).rend()
#define fi first
#define se second
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const double EPS = 1e-8;
const double INF = 1e12;
const double PI = acos(-1);
#define X(r) real((r))
#define Y(r) imag((r))
typedef complex<double> P;
typedef complex<double> point;
namespace std {
bool operator < (const P& a, const P& b) {
return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
}
double cross(const P& a, const P& b) {
return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
return real(conj(a)*b);
}
struct L : public vector<P> {
L(const P &a, const P &b) {
push_back(a); push_back(b);
}
};
typedef vector<P> G;
typedef vector<P> polygon;
struct C {
P p; double r;
C(const P &p, double r) : p(p), r(r) { }
};
//??????????????????
int ccw(P a, P b, P c) {
b -= a; c -= a;
if (cross(b, c) > 0) return +1; // counter clockwise
if (cross(b, c) < 0) return -1; // clockwise
if (dot(b, c) < 0) return +2; // c--a--b on line
if (norm(b) < norm(c)) return -2; // a--b--c on line
return 0;
}
bool intersectSS(const L &s, const L &t) {
return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
//?????¨????????????????±???????
vector<point> crossPoint(const C& a, const C& b){
double d = abs(b.p-a.p);
double arg = atan2(Y(b.p-a.p), X(b.p-a.p));
double arg2 = acos((d*d+a.r*a.r-b.r*b.r)/(2*d*a.r));
if(abs(arg2)<EPS) return {a.r*complex<double>(cos(arg), sin(arg))+a.p};
if(abs(a.r-b.r)<d && d < a.r+b.r) return {a.r*complex<double>(cos(arg+arg2), sin(arg+arg2))+a.p, a.r*complex<double>(cos(arg-arg2), sin(arg-arg2))+a.p};
return {};
}
struct Edge{
int to;
double cost;
};
double dist[100010];
vector<Edge> es[100010];
int main(){
int n;
while(cin>>n && n){
vector<C> c;
rep(i, n){
double x, y, r;
cin>>x>>y>>r;
c.pb(C({x, y}, r));
}
vector<vector<P> > v;
for(int i = 0; i < n-1; i++) v.pb(crossPoint(c[i], c[i+1]));
rep(i, 100010) dist[i] = 1e18, es[i].clear();
dist[0] = 0.0;
int goal=n*2-1;
for(int i = -1; i <= (int)v.size(); i++) {
vector<point> ps;
int now;
if(i == -1) ps.pb(c[0].p), now = 0;
else if(i == v.size()) ps.pb(c.back().p), now = goal;
else ps = v[i], now = i*2+1;
for(auto&p:ps){
for(int k = -1; k <= (int)v.size(); k++){
if(k == i) continue;
vector<point> ps2;
int nxt;
if(k == -1) ps2.pb(c[0].p), nxt = 0;
else if(k == v.size()) ps2.pb(c.back().p), nxt = goal;
else ps2 = v[k], nxt = k*2+1;
for(auto& p2 : ps2){
bool f = true;
for(int l = (k < i ? k+1 : i+1); l < (k < i ? i:k); l++){
if(!intersectSS({p, p2}, {v[l][0], v[l][1]})) f = false;
}
if(f) {
es[now].pb({nxt, abs(p - p2)});
//es[nxt].pb({now, abs(p - p2)});
}
nxt++;
}
}
now++;
}
}
auto dijkstra = [&](){
typedef pair<double, int> PP;
priority_queue<PP, vector<PP>, greater<PP> > q;
PP p;
q.push({0.0, 0});
while(!q.empty()){
p = q.top(); q.pop();
int from = p.se;
double cost = p.fi;
if(dist[from] < cost - EPS) continue;
for(auto& e : es[from]) {
int to = e.to;
double newCost = cost+e.cost;
if(dist[to] > newCost + EPS) {
dist[to] = newCost;
q.push({dist[to], to});
}
}
}
};
dijkstra();
printf("%.15lf\n", dist[goal]);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 17, chk = 320;
deque<int> blocks[chk];
int ctr[N / chk][N];
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, q, c, l, r, k, prev, lidx, ridx, elem, st, en, num;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num;
blocks[i / chk].push_back(num);
ctr[i / chk][num]++;
}
cin >> q;
prev = 0;
while (q--) {
cin >> c >> l >> r;
l = (l + prev - 1) % n;
r = (r + prev - 1) % n;
if (l > r) swap(l, r);
lidx = l % chk;
ridx = r % chk;
st = l / chk;
en = r / chk;
elem = blocks[en][ridx];
if (c == 1) {
if (st == en) {
blocks[en].erase(blocks[en].begin() + ridx);
blocks[en].insert(blocks[en].begin() + lidx, elem);
} else {
blocks[en].erase(blocks[en].begin() + ridx);
ctr[en][elem]--;
for (int j = en; j > st; j--) {
int x = blocks[j - 1].back();
blocks[j - 1].pop_back();
ctr[j - 1][x]--;
blocks[j].push_front(x);
ctr[j][x]++;
}
blocks[st].insert(blocks[st].begin() + lidx, elem);
ctr[st][elem]++;
}
} else {
cin >> k;
k = (k + prev - 1) % n + 1;
prev = 0;
if (st == en) {
for (int j = lidx; j <= ridx; j++)
if (blocks[st][j] == k) prev++;
} else {
for (int j = lidx; j < chk; j++)
if (blocks[st][j] == k) prev++;
for (int j = 0; j <= ridx; j++)
if (blocks[en][j] == k) prev++;
for (int j = st + 1; j < en; j++) prev += ctr[j][k];
}
cout << prev << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int index(char c) {
char x[] = "Bulbasr";
for (int i = 0; i < 7; i++)
if (x[i] == c) return i;
return -1;
}
int a[10];
int main() {
char in[100002];
cin.getline(in, 100001);
int len = strlen(in);
for (int i = 0; i < len; i++) {
if (index(in[i]) != -1) a[index(in[i])]++;
}
int min = 1234567890;
for (int i = 0; i < 7; i++)
if (i != 1 && i != 4) {
if (min > a[i]) min = a[i];
} else {
if (min > (a[i] / 2)) min = a[i] / 2;
}
if (min == 1234567890)
cout << 0 << endl;
else
cout << min << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, d;
cin >> n >> d;
vector<pair<long long int, long long int>> friends(n);
vector<long long int> prefix(n);
vector<long long int> results;
results.reserve(n);
for (auto&& _friend : friends) cin >> _friend.first >> _friend.second;
sort(friends.begin(), friends.end());
prefix[0] = friends[0].second;
for (long long int i = 1; i < n; i++)
prefix[i] = prefix[i - 1] + friends[i].second;
for (long long int i = 0; i < n; i++) {
long long int l_min = i, r_max;
long long int l = i, r = n - 1;
while (r >= l) {
long long int m = (l + r) / 2;
if (friends[m].first >= friends[i].first + d) {
r = m - 1;
} else {
l = m + 1;
}
}
r_max = l - 1;
if (l_min == 0)
results.push_back(prefix[r_max]);
else
results.push_back(prefix[r_max] - prefix[l_min - 1]);
}
long long int _max = -1;
for (auto&& result : results)
if (result > _max) _max = result;
cout << _max;
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int main() {
int n, y;
cin >> n >> y;
y /= 1000;
for(int i = 0; i <= n;i++){
for(int j =0; j <= n-i; j++){
if(10*i + 5*j + (n-i-j)*1 == y){
cout << i << ' ' << j << ' ' << n-i-j << endl;
return 0;
}
}
}
cout << "-1 -1 -1" << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4010 + 10, mod = 1e9 + 7;
const int base[2] = {713, 739};
vector<string> get(int l, int r) {
vector<string> ans;
if (r < l) return ans;
cout << "? " << l << ' ' << r << endl;
int len = (r - l + 1);
for (int i = 0; i < len * (len + 1) / 2; i++) {
string s;
cin >> s;
sort(s.begin(), s.end());
ans.push_back(s);
}
return ans;
}
pair<int, int> hsh(string s) {
pair<long long, long long> ans = {0, 0};
int n = s.size();
for (int i = 0; i < n; i++) ans.first = (ans.first * base[0] + s[i]) % mod;
for (int i = 0; i < n; i++) ans.second = (ans.second * base[1] + s[i]) % mod;
return ans;
}
map<pair<long long, long long>, int> mp;
bool mark[N];
bool cmp(string s, string t) { return s.size() < t.size(); }
string get(string s, string t) {
map<char, int> cnt;
for (auto c : s) cnt[c]++;
for (auto c : t) cnt[c]--;
for (auto c : s)
if (cnt[c]) {
string ans = "";
ans += c;
return ans;
}
}
int cnt[N][N];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int m;
cin >> m;
int n = (m + 1) / 2;
string ans = "";
{
vector<string> v1 = get(1, n), v2 = get(1, n - 1);
for (auto u : v1) mp[hsh(u)]++;
for (auto u : v2) mp[hsh(u)]--;
vector<string> all;
for (auto u : v1) {
if (!mark[u.size()] && mp[hsh(u)]) {
mark[u.size()] = 1;
all.push_back(u);
}
}
sort(all.begin(), all.end(), cmp);
ans = all[0];
for (int i = 1; i < n; i++) {
ans = get(all[i], all[i - 1]) + ans;
}
}
while (ans.size() < m) ans += '?';
vector<string> v = get(1, m);
for (auto s : v)
for (auto v : s) cnt[s.size()][v]++;
for (int i = 0; i < m / 2; i++)
for (char c = 'a'; c <= 'z'; c++) {
int w = cnt[i + 1][c] - cnt[i][c] - (cnt[i + 2][c] - cnt[i + 1][c]);
w -= (ans[i] == c);
if (w) ans[m - i - 1] = c;
}
cout << "! " << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long n;
cin >> n;
vector<long> a(n),b(n);
for(long i=0;i<n;i++) cin >> a[i] >> b[i];
long res=0;
for(long i=n-1;i>=0;i--){
a[i]+=res;
if(a[i]%b[i]) res+=b[i]-(a[i]%b[i]);
}
cout << res << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int F = 4e5 + 5, M = 4e5 + 6, OO = 0x3f3f3f3f, MOD = 1e9 + 7;
int d[11];
int main() {
string a, s;
cin >> a >> s;
for (int i = 0; i < s.size(); i++) d[s[i] - '0']++;
for (int i = 0; i < a.size(); i++)
for (int j = 9; j >= 0; j--)
if (a[i] - '0' < j && d[j]) {
a[i] = char(j + '0');
d[j]--;
}
cout << a;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<multiset<int>> vec(1005), vec1(1005);
vector<set<int>> vec10(1005);
int main() {
int n, m, color, digram;
cin >> n >> m;
map<int, bool> mp;
vector<int> fin;
for (int i = 0; i < n; i++) {
cin >> color >> digram;
vec[digram].insert(color);
}
for (int i = 0; i < m; i++) {
cin >> color >> digram;
if (mp[digram]) {
vec1[digram].insert(color);
vec10[digram].insert(color);
} else {
vec1[digram].insert(color);
vec10[digram].insert(color);
mp[digram] = 1;
fin.push_back(digram);
}
}
int sum = 0, bea = 0;
for (int i = 0; i < fin.size(); i++) {
digram = fin[i];
sum += min(vec[digram].size(), vec1[digram].size());
for (auto it = vec10[digram].begin(); it != vec10[digram].end(); it++) {
bea += min(vec[digram].count(*it), vec1[digram].count(*it));
}
}
cout << sum << " " << bea;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long S; cin >> S;
int x2 = 1000000000;
int x3 = (x2 - S % x2) % x2;
int y3 = (S + x3) / x2;
cout << "0 0 1000000000 1 " << x3 << " " << y3 << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
map<char, char> H;
string s;
int flag = 1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
H['3'] = '3';
H['4'] = '6';
H['5'] = '9';
H['6'] = '4';
H['7'] = '7';
H['8'] = '0';
H['9'] = '5';
H['0'] = '8';
cin >> s;
for (int i = 0; i < s.length(); ++i)
if (!H.count(s[i]))
flag = 0;
else if (H[s[i]] != s[s.length() - 1 - i])
flag = 0;
if (flag)
cout << "Yes";
else
cout << "No";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using graph = vector<vector<int>>;
using pii = pair<int, int>;
using vpii = vector<pii>;
void solve() {
ll n, s, t;
cin >> n >> s >> t;
cout << n - min(s, t) + 1 << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) solve();
}
| 1 |
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
long n,m,p,j[65000],i,s;
while(cin>>n,n){
m=1;
for(s=i=0;i<n;i++){cin>>p;s+=p;}
for(i=0;i<n-1;i++){cin>>j[i];s+=j[i];}
sort(j,j+n-1);
for(;;){
if((m+1)*(s-j[m-1])>s*m){s-=j[m-1];m++;}else break;
if(m==n)break;
}
cout<<s*m<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main(void) {
scanf("%d", &n);
if (n % 2 == 0)
printf("-1\n");
else {
for (int i = 0; i < n; i++) {
printf("%d ", i);
}
printf("\n");
for (int i = 0; i < n; i++) {
printf("%d ", i);
}
printf("\n");
for (int i = 0; i < n; i++) {
printf("%d ", (i * 2) % n);
}
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long t[5005];
for (long long i = 1; i <= n; i++) {
cin >> t[i];
}
long long cnt[5005], ans[5005];
memset(ans, 0, sizeof ans);
for (long long i = 1; i <= n; i++) {
memset(cnt, 0, sizeof cnt);
long long bestColor = 0;
for (long long j = i; j <= n; j++) {
long long col = t[j];
cnt[col]++;
if (cnt[col] > cnt[bestColor] or
(cnt[col] == cnt[bestColor] and col < bestColor)) {
bestColor = col;
}
ans[bestColor]++;
}
}
for (long long i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
float m(int x0, int y0, int x, int y) {
float xx = x - x0;
float yy = y - y0;
float d = yy / xx;
return d;
}
int main() {
int n, x0, y0;
cin >> n >> x0 >> y0;
vector<int> a(n, 1);
vector<int> x(n);
vector<int> y(n);
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
}
for (int i = 0; i < n; i++) {
if (a[i] != 0) {
for (int j = i + 1; j < n; j++) {
if (a[j] != 0) {
if (x[i] - x0 == 0 && x[j] == x0) {
a[j] = 0;
continue;
}
if (m(x0, y0, x[i], y[i]) == m(x0, y0, x[j], y[j])) {
a[j] = 0;
}
}
}
}
}
cout << accumulate(a.begin(), a.end(), 0);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)5e5 + 7;
const int X = 30 + 7;
string s, t;
int n, m, x;
int best[X][N];
int pw(int a, int b, int mod) {
int r = 1;
while (b) {
if (b & 1) {
r = (long long)r * a % mod;
}
a = (long long)a * a % mod;
b /= 2;
}
return r;
}
int dv(int a, int b, int mod) {
return (long long)a * pw(b, mod - 2, mod) % mod;
}
const int C = 3;
const int mods[] = {1000000271, 1000000787, 1000000931};
struct T {
int a[C];
T() {
for (int j = 0; j < C; j++) {
a[j] = 0;
}
}
};
bool operator<(T f, T s) {
for (int i = 0; i < C; i++) {
if (f.a[i] != s.a[i]) {
return f.a[i] < s.a[i];
}
}
return 0;
}
T operator+(T f, T s) {
for (int j = 0; j < C; j++) {
f.a[j] += s.a[j];
if (f.a[j] >= mods[j]) {
f.a[j] -= mods[j];
}
}
return f;
}
T operator-(T f, T s) {
for (int j = 0; j < C; j++) {
f.a[j] -= s.a[j];
if (f.a[j] < 0) {
f.a[j] += mods[j];
}
}
return f;
}
T operator*(T f, T s) {
for (int j = 0; j < C; j++) {
f.a[j] = (long long)f.a[j] * s.a[j] % mods[j];
}
return f;
}
T operator^(T f, int x) {
for (int j = 0; j < C; j++) {
f.a[j] = pw(f.a[j], x, mods[j]);
}
return f;
}
T operator/(T f, T s) {
for (int j = 0; j < C; j++) {
f.a[j] = dv(f.a[j], s.a[j], mods[j]);
}
return f;
}
bool operator==(T f, T s) {
for (int j = 0; j < C; j++) {
if (f.a[j] != s.a[j]) {
return 0;
}
}
return 1;
}
const int K = (int)1e5 + 7;
T kwk[K], iki[K];
struct magma {
vector<T> lol;
int ln;
magma(string s) {
ln = (int)s.size();
lol.resize(ln + 1);
for (int j = 0; j < ln; j++) {
T now;
for (int k = 0; k < C; k++) {
now.a[k] = s[j] - 'a';
}
lol[j + 1] = lol[j] + now * kwk[j + 1];
}
}
T get(int l, int r) {
l++;
r++;
if (l <= r) {
T sol = lol[r] - lol[l - 1];
sol = sol * iki[l - 1];
return sol;
}
T x = get(l - 1, ln - 1);
T y = get(0, r - 1);
T it = kwk[ln - l + 1];
return x + y * it;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
T p26;
for (int j = 0; j < C; j++) {
p26.a[j] = 26;
kwk[0].a[j] = 1;
}
for (int j = 1; j < K; j++) {
kwk[j] = kwk[j - 1] * p26;
}
iki[K - 1] = kwk[0] / kwk[K - 1];
for (int j = K - 2; j >= 0; j--) {
iki[j] = iki[j + 1] * kwk[1];
}
cin >> n >> s >> m >> t >> x;
s = " " + s;
t = " " + t;
magma ms(s), mt(t);
function<int(int, int)> lcp_smart = [&](int i, int j) {
int ln1 = n - i + 1;
int ln2 = m - j + 1;
int sol = 0, lo = 1, hi = min(ln1, ln2);
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (ms.get(i, i + mid - 1) == mt.get(j, j + mid - 1)) {
sol = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
return sol;
};
for (int i = 1; i <= n; i++) {
for (int it = 0; it < x; it++) {
int lcp = lcp_smart(i, best[it][i - 1] + 1);
best[it + 1][i + lcp - 1] =
max(best[it + 1][i + lcp - 1], best[it][i - 1] + lcp);
}
for (int it = 0; it <= x; it++) {
best[it][i] = max(best[it][i], best[it][i - 1]);
}
}
if (best[x][n] == m) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005], c[100005];
int n;
void Add(int x, long long v) {
for (; x <= n; x += (x & -x)) c[x] += v;
}
long long Sum(int x) {
long long s = 0;
for (; x; x -= (x & -x)) s += c[x];
return s;
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
int j;
long long v;
cin >> v;
Add(i, v);
int s = i;
for (j = 20; j >= 0 && s < n; j--) {
while (s + (1 << j) <= n) {
s += (1 << j);
Add(s, v);
}
}
}
}
void output() {
long long sum = 0;
for (int i = 1; i < n; i++) cout << Sum(i) << endl;
}
int main() {
solve();
output();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, t;
cin >> n >> d;
int td = 0;
for (int i = 0; i < n; i++) {
cin >> t;
td += t;
}
if (td + (10 * (n - 1)) > d)
cout << -1;
else
cout << (d - td) / 5;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int price_buy[1001], price_sell[1001];
int vol_sell[1001], vol_buy[1001];
int s, b;
int orders, depth;
void init() {
int i;
for (i = 0; i < b; i++) {
price_buy[i] = 0;
vol_buy[i] = 0;
}
for (i = 0; i < s; i++) {
price_sell[i] = 0;
vol_sell[i] = 0;
}
s = b = 0;
}
int partition(int low, int high, int A[1001], int B[1001]) {
int pivot, i, j, temp1, temp2;
pivot = A[low];
i = low;
j = high + 1;
while (1) {
do {
++i;
} while (A[i] <= pivot && i <= high);
do {
--j;
} while (A[j] > pivot);
if (i >= j) break;
temp1 = A[i];
temp2 = B[i];
A[i] = A[j];
B[i] = B[j];
A[j] = temp1;
B[j] = temp2;
}
temp1 = A[low];
temp2 = B[low];
A[low] = A[j];
B[low] = B[j];
A[j] = temp1;
B[j] = temp2;
return j;
}
void quicksort(int low, int high, int A[1001], int B[1001]) {
int j;
if (low < high) {
j = partition(low, high, A, B);
quicksort(low, j - 1, A, B);
quicksort(j + 1, high, A, B);
}
}
int check(int price, char ch) {
int i;
if (ch == 'B') {
for (i = 0; i < b; i++) {
if (price_buy[i] == price) {
return i;
}
}
return b;
} else {
for (i = 0; i < s; i++) {
if (price_sell[i] == price) {
return i;
}
}
return s;
}
}
void readcase() {
int i, index;
int price, vol;
char ch, enter;
for (i = 0; i < orders; i++) {
getchar();
scanf("%c %d %d", &ch, &price, &vol);
index = check(price, ch);
if (ch == 'B') {
price_buy[index] = price;
vol_buy[index] += vol;
if (index == b) b++;
} else {
price_sell[index] = price;
vol_sell[index] += vol;
if (index == s) s++;
}
}
}
void sort_ascending() {
quicksort(0, s - 1, price_sell, vol_sell);
quicksort(0, b - 1, price_buy, vol_buy);
}
void print_answer() {
int i;
if (s >= depth) {
for (i = depth - 1; i >= 0; i--) {
printf("S %d %d\n", price_sell[i], vol_sell[i]);
}
} else {
for (i = s - 1; i >= 0; i--) {
printf("S %d %d\n", price_sell[i], vol_sell[i]);
}
}
if (b >= depth) {
for (i = b - 1; depth > 0; i--, depth--) {
printf("B %d %d\n", price_buy[i], vol_buy[i]);
}
} else {
for (i = b - 1; i >= 0; i--) {
printf("B %d %d\n", price_buy[i], vol_buy[i]);
}
}
}
void solvecase() {
sort_ascending();
print_answer();
}
int main() {
while (scanf("%d %d", &orders, &depth) == 2) {
readcase();
solvecase();
init();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long MIN;
long long gold[100005];
bool visit[100005];
vector<int> adj[100005];
void dfs(int source) {
MIN = min(MIN, gold[source]);
visit[source] = true;
for (int i = 0; i < adj[source].size(); i++) {
int w = adj[source][i];
if (!visit[w]) {
dfs(w);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> gold[i];
int u, v;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (!visit[i]) {
MIN = INT_MAX;
dfs(i);
ans += MIN;
}
}
cout << ans;
}
| 3 |
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <iomanip>
#include <cstring>
#include <cmath>
#define pb push_back
#define mk make_pair
#define eps 1e-8
#define fi first
#define se second
#define all(x) (x).begin(),(x).end()
using namespace std;
typedef long long ll;
typedef long double LD;
typedef unsigned int uii;
typedef pair<int,int> pii;
typedef pair<ll, ll> pll;
typedef pair<int, pair<int, int> >piii;
typedef unsigned long long ull;
typedef vector<int> vii;
typedef vector<ll> vll;
const int inf = 1e9;
const ll INF = 1e18;
// const int M = 1e9 + 7;
//__int128
ll n, a, b, M;
typedef vector<vll> mat;
ll mul(ll x, ll y, ll mod) {
ll ret = 0;
while(y) {
if(y & 1)
ret = (ret + x) % mod;
x = x * 2 % mod;
y >>= 1;
}
return ret;
}
mat mul(mat &A, mat &B){
mat C(A.size(), vll(B[0].size()));
for(int i = 0; i < (int)A.size(); i++){
for(int j = 0; j < (int)B.size(); j++){
for(int k = 0; k < (int)B.size(); k++){
C[i][j] = (C[i][j] + mul(A[i][k], B[k][j], M)) % M;
}
}
}
return C;
}
mat pow(mat A, ll n){
mat B((int)A.size(), vll((int)A.size()));
for(int i = 0; i < (int)A.size(); i++){
B[i][i] = 1;
}
while(n > 0){
if(n & 1) {
B = mul(B, A);
}
A = mul(A, A);
n >>= 1;
}
return B;
}
void test(mat A){
for(int i = 0; i < 3; ++i){
for(int j = 0; j < 3; ++j){
cout << A[i][j] << ' ';
}
cout << endl;
}
}
int main(int argc, char const *argv[])
{
#ifndef ONLINE_JUDGE
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> a >> b >> M;
ll base = 1;
ll res = 0;
ll c = 0, last = a - b, tot = 0;
for(int i = 0; i < 19; ++i, base *= 10){
if(base * 10 <= last) continue;
ll step = (base * 10 - last - 1) / b;
if(step + tot >= n){
step = n - tot;
}
if(step == 0) continue;
mat A(3, vll(3));
A[0][1] = A[1][1] = A[1][2] = A[2][2] = 1;
A[0][0] = base * 10;
A = pow(A, step);
res = (mul(res, A[0][0], M) + mul(last + b, A[0][1], M) + mul(b, A[0][2], M)) % M;
// cout << res << endl << endl;
last = last + step * b;
tot += step;
if(tot == n) break;
}
cout << res << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int main() {
long long k, d, t;
gn(k, d, t);
if (k % d == 0) {
print(t);
return 0;
}
t *= 2;
long long T = k * 2 + d - k % d;
long long ans = t / T * (k + d - k % d) * 2;
long long r = t % T;
if (r <= 2 * k)
ans += r;
else
ans += 2 * k + 2 * (r - 2 * k);
print(ans / 2);
if (ans & 1LL)
puts(".5");
else
puts(".0");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[1023];
vector<int> v, q;
int primes[1023];
long long int calc(const vector<int>& v, int k) {
vector<int> kk(k, 0);
kk[0] = 1;
int temp = 0;
for (int elem : v) {
temp += elem;
temp %= k;
kk[temp]++;
}
long long int res = 0;
for (int mod = 0; mod < k; mod++) {
res += (long long int)kk[mod] * (kk[mod] - 1) / 2;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
if (n >= m) {
cout << "YES" << endl;
return 0;
}
vector<int> v;
long long int sum = 0;
for (int i = 0; i < n; i++) {
int p;
cin >> p;
a[p % m]++;
v.push_back(p);
if (p == 0 || p % m == 0) {
cout << "YES" << endl;
return 0;
}
}
for (int i = 0; i <= m; i++) {
if (i == m - i) {
if (a[i] >= 2) {
cout << "YES" << endl;
return 0;
}
}
if (a[i] > 0 && a[m - i] > 0) {
cout << "YES" << endl;
return 0;
}
}
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= m; j++) {
if (i == j) {
if (i == j && (m - (i + j) == i || m - (i - j) == j)) {
if (a[i] >= 3) {
cout << "YES" << endl;
return 0;
}
}
} else if (a[i] > 0 && a[j] > 0 && a[m - (i + j)] > 0) {
cout << "YES" << endl;
return 0;
}
}
}
sort(v.begin(), v.end());
if (calc(v, m) == 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
/*---------------------DEBUGGING--------------------------------------------*/
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
/*-------------------------------------------------------------------------------------*/
//#define mp make_pair
#define pb push_back
#define ll long long
#define pii pair<int,int>
#define pcc pair<char,char>
#define F first
#define S second
#define int long long
#define pi 3.141592653589793238462643383279502
#define M 998244353//1000000007
#define rep(i,a,n) for(int i=a;i<n;i++)
#define INF 1000000000000000
#define N 200005
#define vi vector<int>
#define all(v) v.begin(),v.end()
#define endl "\n"
//#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
void solve()
{
int x;
cin>>x;
vi vis(10);
string res="";
while(x>0)
{
int mx=min(9LL,x);
bool f=false;
for(int i=mx;i>=1;i--)
{
if(!vis[i] && i<=x)
{
vis[i]=1;
x-=i;
res+=char(i+'0');
f=true;
break;
}
}
if(!f)
{
cout<<-1<<endl;
return;
}
}
sort(all(res));
cout<<res<<endl;
}
signed main()
{
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int tests;
cin>>tests;
for(int i=0;i<tests;i++)
{
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd;
const long long mod = 1e9 + 7;
const long long max_n = 1e5 + 3;
const long long inf = 2e9 + 3;
void run() {
long long n;
cin >> n;
vector<long long> a(n), b(n);
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < n; ++i) cin >> b[i];
for (long long i = 1; i < n; ++i) b[i] += b[i - 1];
for (long long i = n - 2; i >= 0; --i) a[i] += a[i + 1];
long long res = inf;
for (long long i = 0; i < n; ++i)
res = min(res, max(i + 1 != n ? a[i + 1] : 0, i ? b[i - 1] : 0));
cout << res << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
long long t = 1;
cin >> t;
while (t--) {
run();
}
}
| 3 |
#include <cstdio>
int main(){
int n,t,x,i;
scanf("%d%d%d",&n,&x,&t);
printf("%d\n", ((n/x) + ((n%x)?1:0)) * t);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
int cnt = 0, illegal = 0;
cin >> a >> b;
for (int i = 0; i < a; i++) {
int q;
cin >> q;
cnt = 0;
while (q) {
if (q % 10 == 4 || q % 10 == 7) cnt++;
q /= 10;
}
if (cnt > b) illegal++;
}
cout << a - illegal;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#include <array>
using namespace std;
using ULL = unsigned long long;
using UL = unsigned;
using LL = long long;
#define rep(i, n) for(UL i = 0; i < (n); i++)
struct Problem {
void Solve() {
UL V, E, r; cin >> V >> E >> r;
vector<vector<pair<UL, UL>>> G(V);
rep(i, E) {
UL a, b, d; cin >> a >> b >> d;
G[a].push_back({ b, d });
}
priority_queue<pair<UL, UL>, vector<pair<UL, UL>>, greater<pair<UL, UL>>> Q;
Q.push({ 0, r });
vector<UL> ans(V, (UL) -1);
while (Q.size()) {
pair<UL, UL> p = Q.top(); Q.pop();
if (ans[p.second] != (UL)-1) continue;
ans[p.second] = p.first;
for (auto e : G[p.second]) {
Q.push({ p.first + e.second, e.first });
}
}
rep(i, V) {
if (ans[i] == (UL)-1) cout << "INF" << endl;
else cout << ans[i] << endl;
}
}
Problem();
};
int main() {
unique_ptr<Problem> p(new Problem());
p->Solve();
return 0;
}
Problem::Problem() {
cout << fixed << setprecision(10);
}
| 0 |
#include<stdio.h>
#include<stdlib.h>
#include<string>
#include<iostream>
using namespace std;
struct Node {
int key;
Node *right, *left, *parent;
};
Node *root, *NIL;
Node * treeMinimum(Node *x) {
while ( x->left != NIL ) x = x->left;
return x;
}
Node * find(Node *u, int k) {
while ( u != NIL && k != u->key ) {
if ( k < u-> key ) u = u->left;
else u = u->right;
}
return u;
}
Node * treeSuccessor(Node *x) {
if ( x->right != NIL ) return treeMinimum(x->right);
Node *y = x->parent;
while ( y != NIL && x == y->right ) {
x = y;
y = y->parent;
}
return y;
}
void treeDelete(Node *z) {
Node *y;
Node *x;
if ( z->left == NIL || z->right == NIL ) y = z;
else y = treeSuccessor(z);
if ( y->left != NIL ) {
x = y->left;
} else {
x = y->right;
}
if ( x != NIL ) {
x->parent = y->parent;
}
if ( y->parent == NIL ) {
root = x;
} else {
if ( y == y->parent->left ) {
y->parent->left = x;
} else {
y->parent->right = x;
}
}
if ( y != z ) {
z->key = y->key;
}
free(y);
}
void insert(int k) {
Node *y = NIL;
Node *x = root;
Node *z;
z = (Node *)malloc(sizeof(Node));
z->key = k;
z->left = NIL;
z->right = NIL;
while ( x != NIL ) {
y = x;
if ( z ->key < x->key ) {
x = x->left;
} else {
x = x->right;
}
}
z->parent = y;
if ( y == NIL ) {
root = z;
} else {
if ( z->key < y->key ) {
y->left = z;
} else {
y->right = z;
}
}
}
void inorder(Node *u) {
if ( u == NIL ) return;
inorder(u->left);
printf(" %d", u->key);
inorder(u->right);
}
void preorder(Node *u) {
if ( u == NIL ) return;
printf(" %d", u->key);
preorder(u->left);
preorder(u->right);
}
int main() {
int n, i, x;
string com;
scanf("%d", &n);
for( i = 0; i < n; i++ ) {
cin >> com;
if ( com[0] == 'f' ) {
scanf("%d", &x);
Node *t = find(root, x);
if ( t != NIL ) printf("yes\n");
else printf("no\n");
} else if ( com == "insert" ) {
scanf("%d", &x);
insert(x);
} else if ( com == "print" ) {
inorder(root);
printf("\n");
preorder(root);
printf("\n");
} else if ( com == "delete" ) {
scanf("%d", &x);
treeDelete(find(root, x));
}
}
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.