solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
int dp[41][450][450];
int a[40], b[40], c[40];
int main() {
int n, m1, m2; scanf("%d%d%d", &n, &m1, &m2);
rep(i, n)scanf("%d%d%d", &a[i], &b[i], &c[i]);
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0] = 0;
rep(i, n) {
rep(j, 400)rep(k, 400) {
dp[i + 1][j][k] = min(dp[i + 1][j][k], dp[i][j][k]);
dp[i + 1][j + a[i]][k + b[i]] = min(dp[i + 1][j + a[i]][k + b[i]], dp[i][j][k] + c[i]);
}
}
int Min = INF;
for (int i = 1; i*m1 <= 400 && i*m2 <= 400; i++)
Min = min(Min, dp[n][m1*i][m2*i]);
if (Min == INF)puts("-1");
else printf("%d\n", Min);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i = 1, sum = 0;
cin >> n;
while (sum < n) {
sum = (i * (i + 1)) / 2;
i++;
}
if (sum == n)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n - 1];
for (auto &x : a) cin >> x;
vector<long long> pref(n);
pref[0] = 0;
long long left = 1, right = n;
map<long long, long long> mp;
mp[0] = 1;
for (int i = 1; i < n; i++) {
pref[i] = pref[i - 1] + a[i - 1];
left = max(left, 1 - pref[i]);
right = min(right, n - pref[i]);
if (mp[pref[i]]) {
cout << -1;
return 0;
}
mp[pref[i]] = 1;
}
if (right >= left) {
for (auto &x : pref) cout << x + left << " ";
} else
cout << -1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int MAXlen = 2e4 + 10;
double eps = 1e-4;
int a[100100];
int BIT[32];
int main() {
int T;
scanf("%d", &T);
while (T--) {
memset(BIT, 0, sizeof(BIT));
int n, i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
int temp = a[i];
int num = 0;
while (temp) {
BIT[num++] += temp & 1;
temp >>= 1;
}
}
int flag = 1;
{
for (i = 30; i >= 0; i--) {
if (BIT[i] == 1) {
flag = 2;
break;
}
if (BIT[i] & 1) {
int temp = BIT[i] / 2;
if (temp & 1) {
if ((n - BIT[i]) & 1)
flag = 2;
else
flag = 0;
break;
} else {
flag = 2;
break;
}
} else
continue;
}
}
if (flag == 0)
printf("LOSE\n");
else if (flag == 1)
printf("DRAW\n");
else
printf("WIN\n");
}
return 0;
}
| 2 |
//#define _GLIBCXX_DEBUG
#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <deque>
#include <algorithm>
#include <cassert>
using namespace std;
#define FOREACH(it,c) for(__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define TIMES(i,n) for(int i = 0; i < (n); ++i)
typedef long long Cost;
const long long INF = 1000*1000*10*10*2*10LL;
struct Edge {
int from, to;
Cost cost;
Edge() {}
Edge(int f, int t, Cost c) : from(f), to(t), cost(c) {}
};
struct DistTag {
int size;
deque<Cost> buf, newbie;
DistTag(int size) : size(size), buf(size, INF) {
//newbie.reserve(size);
}
bool insert(Cost val) {
if(buf.back() <= val) return false;
deque<Cost>::iterator ins_pos = upper_bound(newbie.begin(), newbie.end(), val);
newbie.insert(ins_pos, val);
if(static_cast<int>(newbie.size()) > size) newbie.pop_back();
return true;
}
bool has(Cost val) {
return buf.back() >= val;
}
void flush() {
FOREACH(it, newbie) {
deque<Cost>::iterator ins_pos = upper_bound(buf.begin(), buf.end(), *it);
buf.insert(ins_pos, *it);
}
buf.resize(size);
newbie.clear();
}
};
struct State {
int pos;
Cost cost;
State() {}
State(int p, Cost c) : pos(p), cost(c) {}
bool operator <(const State &other) const {
return cost > other.cost; // Reversed
}
};
typedef vector<Edge> EdgeList;
void check_reachable(int start, const vector<EdgeList> &graph, vector<unsigned char> &reachable) {
queue<int> q;
q.push(start);
reachable[start] = 1;
while(!q.empty()) {
int cur = q.front();
q.pop();
FOREACH(it, graph[cur]) {
if(!reachable[it->to]) {
reachable[it->to] = 1;
q.push(it->to);
}
}
}
}
bool relax(const vector<EdgeList> &graph, vector<Cost> &dist) {
bool updated = false;
FOREACH(list_it, graph) {
FOREACH(it, *list_it) {
const Cost cost = dist[it->from] + it->cost;
if(dist[it->to] > cost) {
dist[it->to] = cost;
updated = true;
}
}
}
return updated;
}
pair<int,Cost> search(int start, const vector<EdgeList> &graph, int N, int P, int K) {
vector<DistTag> dist(graph.size(), DistTag(K));
dist[start].insert(0);
TIMES(_, static_cast<int>(graph.size())*K) {
TIMES(i, static_cast<int>(graph.size())) {
DistTag &dt = dist[i];
if(dt.newbie.size() == 0) continue;
vector<int> tmp;
FOREACH(it, graph[i]) {
assert(it->from == i);
// Corner case: loop edge
if(it->to == i) {
FOREACH(nit, dt.newbie) {
tmp.push_back(*nit + it->cost);
}
} else {
FOREACH(nit, dt.newbie) {
//cout << "insert " << i << ' ' << it->to << endl;
dist[it->to].insert(*nit + it->cost);
}
}
}
dt.flush();
FOREACH(tit, tmp) {
dt.insert(*tit);
}
}
}
pair<int,Cost> res(0, 0);
vector<Cost> costs;
TIMES(i, P) {
FOREACH(it, dist[(N-1)*P+i].buf) {
costs.push_back(*it);
}
}
sort(costs.begin(), costs.end());
TIMES(i, min(K, static_cast<int>(costs.size()))) {
if(costs[i] == INF) break;
res.first++;
res.second += costs[i];
}
return res;
}
pair<int,Cost> solve(int N) {
vector<int> color_of(N);
TIMES(i, N) {
cin >> color_of[i];
--color_of[i];
}
int M;
cin >> M;
vector<Edge> edges(M);
TIMES(i, M) {
Edge &e = edges[i];
cin >> e.from >> e.to >> e.cost;
--e.from; --e.to;
}
int K;
cin >> K;
vector<int> prohibited;
{
string str;
cin >> str;
FOREACH(it, str) {
prohibited.push_back(*it - '0' - 1);
}
}
const int P = prohibited.size();
vector<vector<int> > next_prohibited_pos(P, vector<int>(4, 0));
{
int shadow = 0;
TIMES(i, P) {
next_prohibited_pos[i][prohibited[i]] = i+1;
if(i > 0) {
TIMES(j, 4) {
if(j != prohibited[i]) next_prohibited_pos[i][j] = next_prohibited_pos[shadow][j];
}
shadow = next_prohibited_pos[shadow][prohibited[i]];
}
}
}
const int start = 0+next_prohibited_pos[0][color_of[0]];
vector<EdgeList> graph(N*P);
FOREACH(it, edges) {
TIMES(i, P) {
// Cannot reach this state.
if(i > 0 && prohibited[i-1] != color_of[it->from]) continue;
int np = next_prohibited_pos[i][color_of[it->to]];
if(np < P) {
graph[it->from*P+i].push_back(Edge(it->from*P+i, it->to*P+np, it->cost));
//cout << it->from << ' ' << i << ' ' << it->to << ' ' << np << endl;
}
}
}
// Remove all unreachable nodes.
// It causes fake negative loop detection.
vector<unsigned char> reachable(N*P, 0);
check_reachable(start, graph, reachable);
TIMES(i, N*P) {
if(!reachable[i]) graph[i].clear();
}
// Check if it has negative loop
vector<Cost> dist(N*P, INF);
dist[start] = 0;
TIMES(_, N*P) {
relax(graph, dist);
}
vector<Cost> tmp_last(P);
TIMES(i, P) {
tmp_last[i] = dist[(N-1)*P+i];
}
TIMES(_, N*P) {
relax(graph, dist);
TIMES(i, P) {
if(dist[(N-1)*P+i] != tmp_last[i]) return make_pair(-1, -1);
}
}
// Corner case: cannot start
if(P == 1 && prohibited[0] == color_of[0]) return make_pair(0, 0);
pair<int,Cost> res = search(start, graph, N, P, K);
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int N;
while(cin >> N) {
if(!N) break;
pair<int,Cost> ans = solve(N);
if(ans.first == -1) cout << -1 << endl;
else cout << ans.first << ' ' << ans.second << endl;
}
return 0;
} | 0 |
#include<cstdio>
#define LL long long
using namespace std;
const LL N=2e5+1;
LL i,n,m,ans;
LL a[N];
int main()
{
scanf("%lld%lld",&n,&m);
for (i=1;i<=n;++i)
++a[i%m];
ans=a[0]*a[0]*a[0];
if (!(m%2))
ans+=a[m>>1]*a[m>>1]*a[m>>1];
printf("%lld",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long binsearch(long long n, long long k) {
long long l = 0, r = n + 1;
while (r - l > 1) {
long long m = (l + r) / 2;
if (m * (m - 1) / 2 <= k) {
l = m;
} else {
r = m;
}
}
return l;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
if (n * (n - 1) / 2 < k) {
cout << "Impossible" << endl;
} else {
long long m = binsearch(n, k);
long long to_add = k - m * (m - 1) / 2;
if (to_add == 0) {
cout << string(m, '(') + string(m, ')');
for (long long i = 0; i < n - m; i++) {
cout << "()";
}
} else {
for (long long z = 0; z < m; ++z) {
cout << '(';
if (to_add - 1 == z) {
cout << "()";
}
}
cout << string(m, ')');
for (long long i = 0; i < n - m - 1; i++) {
cout << "()";
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n,x,d,t,ans;
int lg(int x) {
if (x==1) return 0;
return lg(x>>1)+1;
}
int main()
{
scanf("%d",&n);
for (int i=1;i<=n;i++) {
scanf("%d",&x);
int c=lg(x); d=0;
if (x!=1<<c) d=1;
if (t>c) t=c,d=0;
if (t<c) ans+=c-t,t=c;
if (d) ans++,t++;
}
printf("%d\n",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline char read() {
static const int IN_LEN = 1000000;
static char buf[IN_LEN], *s, *t;
return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin),
(s == t ? -1 : *s++) : *s++);
}
template <class T>
inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = read(); !isdigit(c); c = read()) {
if (c == '-') iosig = true;
if (c == -1) return;
}
for (x = 0; isdigit(c); c = read()) x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig) x = -x;
}
const int OUT_LEN = 10000000;
char obuf[OUT_LEN], *ooh = obuf;
inline void print(char c) {
if (ooh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
*ooh++ = c;
}
template <class T>
inline void print(T x) {
static int buf[30], cnt;
if (x == 0)
print('0');
else {
if (x < 0) print('-'), x = -x;
for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
while (cnt) print((char)buf[cnt--]);
}
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
const int N = 300005;
int n, m, top, stk[N];
long long K, B, val[N];
int main() {
read(n), read(m), stk[top = 1] = n;
while (m--) {
static int opt, x, y;
read(opt), read(x);
if (opt == 1)
n += x, stk[top = 1] = n, val[1] = -B;
else if (opt == 2) {
long long now = -(long long)K * n - B;
while (top > 1 && (long double)(val[top] - now) * stk[top - 1] >=
(long double)(val[top - 1] - val[top]) * stk[top])
stk[top - 1] += stk[top], --top;
stk[++top] = x, n += x, val[top] = now;
} else
B += x, read(y), K += y;
while (top > 1 && val[top - 1] - val[top] <= stk[top - 1] * K)
stk[top - 1] += stk[top], --top;
x = n - stk[top] + 1;
print(x), print(' '), print(val[top] + K * (x - 1) + B), print('\n');
}
return flush(), 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vp;
int p_l, p_r, v_l, v_r;
inline void pre(void) {
for (int i = 1; i <= 9; i++) {
int max_mask = (1 << i);
for (int mask = 0; mask < max_mask; mask++) {
int curr = 0;
int mul = 1;
for (int j = 0; j < i; j++) {
if (mask & (1 << j)) {
curr += (mul * 7);
} else {
curr += (mul * 4);
}
mul *= 10;
}
vp.push_back(curr);
}
}
sort(vp.begin(), vp.end());
}
int K;
inline long double power(long double a, int p) {
long double ret = 1;
while (p > 0) {
if (p & 1) {
ret *= a;
}
a *= a;
p /= 2;
}
return ret;
}
int inrange(int a, int b, int l, int r) {
int ret = min(b, r) - max(a, l) + 1;
ret = max(ret, 0);
return ret;
}
inline void ReadInput(void) {
scanf("%d", &p_l);
scanf("%d", &p_r);
scanf("%d", &v_l);
scanf("%d", &v_r);
scanf("%d", &K);
}
inline void solve(void) {
pre();
double ans = 0;
for (int i = 0; i < vp.size(); i++) {
if (i + K > vp.size()) break;
int prev = (i ? vp[i - 1] : 0);
int next = (i + K < (int)vp.size() ? vp[i + K] : 1e9 + 1);
int cnt1, cnt2;
cnt1 = inrange(v_l, v_r, prev + 1, vp[i]);
cnt2 = inrange(p_l, p_r, vp[i + K - 1], next - 1);
double g, f;
g = cnt1 / (double)(v_r - v_l + 1);
f = cnt2 / (double)(p_r - p_l + 1);
ans += (g * f);
bool flag = false;
if (cnt1 and cnt2) flag = true;
cnt1 = inrange(p_l, p_r, prev + 1, vp[i]);
cnt2 = inrange(v_l, v_r, vp[i + K - 1], next - 1);
g = cnt1 / (double)(p_r - p_l + 1);
f = cnt2 / (double)(v_r - v_l + 1);
ans += (g * f);
if (K == 1 and cnt1 and cnt2 and flag) {
g /= cnt1;
f /= cnt2;
ans -= (g * f);
}
}
printf("%.10lf\n", ans);
}
inline void Refresh(void) {}
int main() {
ReadInput();
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int calc(int a, int b, int x){
return a*(100+x)/100 + b*(100+x)/100;
}
int main(){
int x, y, s;
while(cin >> x >> y >> s){
if(x+y+s == 0) break;
int ans = 0;
for(int i = 1 ; i <= s ; i++){
for(int j = 1 ; j+i <= s ; j++){
if(calc(i, j, x) == s) ans = max(ans, calc(i, j, y));
}
}
cout << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int q[100010];
long long x[100010], y[100010];
int get(int l, int r, long long xx, long long yy) {
int ans = q[l], i, j, k;
long long fenzi = y[q[l]] - yy;
long long fenmu = x[q[l]] - xx;
for (i = l + 1; i <= r; i++)
if (fenzi * (x[q[i]] - xx) < fenmu * (y[q[i]] - yy)) {
ans = q[i];
fenzi = y[q[i]] - yy;
fenmu = x[q[i]] - xx;
}
return ans;
}
int cnt;
int BS(long long xx, long long yy) {
int l = 1, r = cnt;
while (r - l >= 10) {
int m1 = l + (r - l) / 3;
int m2 = r - (r - l) / 3;
if ((y[q[m1]] - yy) * (x[q[m2]] - xx) >= (y[q[m2]] - yy) * (x[q[m1]] - xx))
r = m2;
else
l = m1;
}
return get(l, r, xx, yy);
}
int fa[100010];
int first[100010], nxt[100010], vv[100010];
int finfa(int n) {
if (n == fa[n]) return n;
return fa[n] = finfa(fa[n]);
}
int vis[100010];
vector<pair<int, int> > V[100010];
int ans[100010];
void dfs(int n) {
fa[n] = n;
int e;
for (e = first[n]; e; e = nxt[e]) {
dfs(vv[e]);
fa[vv[e]] = n;
}
vis[n] = 1;
for (e = 0; e < V[n].size(); e++)
if (vis[V[n][e].first]) ans[V[n][e].second] = finfa(V[n][e].first);
}
int rig[100010];
int main() {
int n, i, j, k;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%I64d%I64d", &x[i], &y[i]);
rig[n] = n;
int e = 2;
for (i = n - 1; i >= 1; i--) {
j = i + 1;
while ((y[j] - y[i]) * (x[rig[j]] - x[i]) <
(y[rig[j]] - y[i]) * (x[j] - x[i]))
j = rig[j];
rig[i] = j;
int u = rig[i];
int v = i;
nxt[e] = first[u], vv[e] = v, first[u] = e++;
}
int m;
scanf("%d", &m);
for (i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
V[u].push_back(make_pair(v, i));
V[v].push_back(make_pair(u, i));
}
dfs(n);
for (i = 1; i <= m; i++) printf("%d ", ans[i]);
puts("");
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
const int N=15;
char a[N][N],b[N][N];
int n,m,match[N],use[N];
inline int Equal(int x,int y) {
for (int i=1;i<=n;i++) {
if (b[i][x]!=b[n-i+1][y]) return 0;
}
return 1;
}
inline void check() {
int res=m&1;
memset(use,0,sizeof(use));
int now=1;
for (int i=1;i<=n;i++) {
if (i==match[i]) {
for (int j=1;j<=m;j++)
b[(n+1)>>1][j]=a[i][j];
}
if (i<match[i]) {
for (int j=1;j<=m;j++) {
b[now][j]=a[i][j];
b[n-now+1][j]=a[match[i]][j];
}
++now;
}
}
for (int i=1;i<=m;i++) {
if (use[i]) continue;
for (int j=i+1;j<=m;j++)
if (!use[j]&&Equal(i,j)) {
use[i]=j; use[j]=i;
break;
}
if (!use[i]) {
int flag=1;
// for (int j=1;j<=n;j++)
// if (b[j][i]!=b[n-j+1][i]) flag=0;
if (!flag) return;
if (--res<0) return;
}
}
puts("YES"); exit(0);
}
void dfs(int x,int res) {
if (x==n+1) return (void) (check());
if (match[x]) return (void) (dfs(x+1,res));
if (res) {
int flag=1;
// for (int i=1;i<=m;i++)
// if (a[x][i]!=a[x][m-i+1]) flag=0;
if (flag) {
match[x]=x;
dfs(x+1,0);
match[x]=0;
}
}
for (int i=x+1;i<=n;i++) {
if (!match[i]) {
match[i]=x; match[x]=i;
dfs(x+1,res);
match[i]=0; match[x]=0;
}
}
}
int main() {
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++) scanf("%s",a[i]+1);
dfs(1,n&1);
puts("NO");
return 0;
}
/*
3 3
aac
bab
cba
*/ | 0 |
#include <bits/stdc++.h>
using namespace std;
char str[1005][1005], tmp[1005][1005];
set<int> row, col;
inline void paint(int x1, int y1, int x2, int y2) {
for (int i = x1; i <= x2; i++) tmp[i][y1] = tmp[i][y2] = '#';
for (int i = y1; i <= y2; i++) tmp[x1][i] = tmp[x2][i] = '#';
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", str[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (j && j + 1 != m && str[i][j] == '#' && str[i][j - 1] == '#' &&
str[i][j + 1] == '#')
row.insert(i);
if (i && i + 1 != n && str[i][j] == '#' && str[i - 1][j] == '#' &&
str[i + 1][j] == '#')
col.insert(j);
}
}
if (row.size() > 4) row.erase(++ ++row.begin(), -- --row.end());
if (col.size() > 4) col.erase(++ ++col.begin(), -- --col.end());
for (auto x1 : row)
for (auto y1 : col) {
for (auto x2 : row)
for (auto y2 : col) {
for (auto x3 : row)
for (auto y3 : col) {
for (auto x4 : row)
for (auto y4 : col) {
if (x2 - x1 < 2 || y2 - y1 < 2 || x4 - x3 < 2 || y4 - y3 < 2)
continue;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) tmp[i][j] = '.';
}
paint(x1, y1, x2, y2);
paint(x3, y3, x4, y4);
bool f = true;
for (int i = 0; i < n && f; i++) {
for (int j = 0; j < m && f; j++) {
if (str[i][j] != tmp[i][j]) f = false;
}
}
if (f) {
puts("YES");
printf("%d %d %d %d\n", x1 + 1, y1 + 1, x2 + 1, y2 + 1);
;
printf("%d %d %d %d\n", x3 + 1, y3 + 1, x4 + 1, y4 + 1);
;
return 0;
}
}
}
}
}
puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[3][3];
while (cin >> a[0][0]) {
int r = 0, flag = 1;
for (int i = 1; i < 3; i++) cin >> a[0][i];
for (int j = 0; j < 3; j++) {
cin >> a[1][j];
a[2][j] = a[0][j] - a[1][j];
if (a[2][j] > 0) {
r += a[2][j] / 2;
a[0][j] -= a[2][j] / 2 * 2;
}
}
for (int j = 0; j < 3; j++) {
if (a[2][j] < 0) {
int t = r + a[2][j];
if (t < 0) {
flag = 0;
break;
} else {
r = t;
}
}
}
if (flag)
cout << "Yes\n";
else
cout << "No\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, k, l, n, m, sum, an, K;
const long long N = 51;
long long va[N], vb[N];
typedef long long arr[N][N];
arr a, b, c, d;
void cheng(arr &a, arr b) {
memset(c, 2, sizeof(c));
for (long long i = 0; i <= K; i++)
for (long long j = 0; j <= K; j++)
for (long long k = 0; k <= K; k++)
c[i][j] = min(c[i][j], a[i][k] + b[k][j]);
memcpy(a, c, sizeof(a));
}
int main() {
scanf("%I64d%I64d", &n, &m);
K = 2 * n;
for (long long i = 1; i <= n; i++) scanf("%I64d", &va[i]), va[n + i] = va[i];
for (long long i = 1; i <= n; i++) scanf("%I64d", &vb[i]), vb[n + i] = vb[i];
memset(b, 2, sizeof(b));
for (long long i = 0; i <= K; i++) b[i][i] = 0;
for (long long i = 1; i <= K; i++) {
memset(d, 2, sizeof(d));
for (long long j = 0; j <= K; j++) {
if (j + 1 <= K) d[j][j + 1] = va[i];
if (j) d[j][j - 1] = vb[i];
}
cheng(b, d);
}
memset(a, 2, sizeof(a));
a[0][0] = 0;
m /= 2;
while (m) {
if (m & 1) cheng(a, b);
cheng(b, b);
m /= 2;
}
printf("%I64d\n", a[0][0]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
char s[3003], t[3003];
long long dp[3003][3003];
int main() {
scanf("%s", s + 1);
scanf("%s", t + 1);
long long lens = strlen(s + 1);
long long lent = strlen(t + 1);
long long i, j, k;
for (i = 1; i <= lens + 1; i++) dp[i][i - 1] = 1;
for (i = 1; i <= lens; i++) {
j = i - 1;
for (k = 1; k + j <= lens; k++) {
if (s[i] == t[k] || k > lent)
dp[k][k + j] = (dp[k][k + j] + dp[k + 1][k + j]) % mod;
if (s[i] == t[k + j] || k + j > lent)
dp[k][k + j] = (dp[k][k + j] + dp[k][k + j - 1]) % mod;
}
}
long long ans = 0;
for (i = lent; i <= lens; i++) ans = (ans + dp[1][i]) % mod;
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n;
pair<int, int> a[maxn];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
int t;
scanf("%d", &t);
a[i] = make_pair(t, i);
}
sort(a + 1, a + n + 1, greater<pair<int, int> >());
printf("%d\n", (n + 1) / 2);
for (int i = 2; i <= n; i += 2) {
printf("%d ", a[i].second);
}
if (n & 1)
printf("%d\n", a[n].second);
else
puts("");
printf("%d\n", n / 2);
for (int i = 1; i <= n - (n & 1); i += 2) {
printf("%d ", a[i].second);
}
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 10;
struct NUM {
int num;
int cnt;
bool operator<(const NUM& Val) const { return Val.cnt > cnt; }
} num[M];
int tmp[M];
int A[M], B[M], C[M];
priority_queue<NUM> que;
int n_case;
void sap(int a, int b, int c) {
if (a < b) a ^= b ^= a ^= b;
if (a < c) c ^= a ^= c ^= a;
if (b < c) c ^= b ^= c ^= b;
A[n_case] = a;
B[n_case] = b;
C[n_case++] = c;
}
int main() {
int n;
while (cin >> n) {
int cnt = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &tmp[i]);
}
sort(tmp, tmp + n);
int s = 0;
num[s].num = tmp[0];
num[s].cnt = 1;
for (int i = 1; i < n; i++) {
if (tmp[i] == tmp[i - 1]) {
num[s].cnt++;
} else {
num[++s].cnt = 1;
num[s].num = tmp[i];
}
}
for (int i = 0, ca = n / 3; i <= s; i++) {
num[i].cnt = (num[i].cnt > ca) ? (ca) : (num[i].cnt);
que.push(num[i]);
}
n_case = 0;
while (!que.empty()) {
NUM aa = que.top();
que.pop();
if (que.empty()) break;
NUM bb = que.top();
que.pop();
if (que.empty()) break;
NUM cc = que.top();
que.pop();
sap(aa.num, bb.num, cc.num);
if (--aa.cnt > 0) que.push(aa);
if (--bb.cnt > 0) que.push(bb);
if (--cc.cnt > 0) que.push(cc);
}
cout << n_case << endl;
for (int i = 0; i < n_case; i++) {
printf("%d %d %d\n", A[i], B[i], C[i]);
}
while (!que.empty()) que.pop();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[1005];
int f[26];
int main() {
scanf("%s", s);
int N = strlen(s);
for (int i = 0; i < N; ++i) f[s[i] - 'a']++;
int c = 0;
for (int i = 0; i < 26; ++i)
if (f[i] & 1) ++c;
if (c == 0 || (c & 1))
printf("First");
else
printf("Second");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, ans[151][151];
int query(int X1, int Y1, int X2, int Y2) {
printf("? %d %d %d %d\n", X1, Y1, X2, Y2);
fflush(stdout);
int ret;
scanf("%d", &ret);
return ret;
}
void gao(int X1, int Y1, int X2, int Y2) {
ans[X2][Y2] = ans[X1][Y1] ^ (!query(X1, Y1, X2, Y2));
}
void print() {
puts("!");
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
printf("%d", ans[i][j]);
}
puts("");
}
}
void rev() {
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (i % 2 != j % 2) {
ans[i][j] ^= 1;
}
}
}
}
void check(int X1, int Y1, int X2, int Y2) {
if (query(X1, Y1, X2, Y2) != (ans[X1][Y1] == ans[X2][Y2])) rev();
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
ans[i][j] = -1;
}
}
ans[1][1] = 1;
ans[N][N] = 0;
gao(1, 1, 2, 2);
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (ans[i][j] != -1) continue;
if (i % 2 != j % 2) continue;
if (j - 2 > 0) {
gao(i, j - 2, i, j);
} else {
gao(i - 2, j, i, j);
}
}
}
ans[1][2] = 1;
gao(1, 2, 2, 3);
ans[2][1] = ans[2][3] ^ (!query(2, 1, 2, 3));
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (ans[i][j] != -1) continue;
if (i % 2 == j % 2) continue;
if (j - 2 > 0) {
gao(i, j - 2, i, j);
} else {
gao(i - 2, j, i, j);
}
}
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (i % 2 == j % 2 && i - 1 > 0 && j + 1 <= N &&
ans[i][j] != ans[i - 1][j + 1]) {
if (j + 2 <= N) {
check(i - 1, j, i, j + 2);
} else {
check(i - 1, j, i + 1, j + 1);
}
print();
return 0;
}
}
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (i % 2 != j % 2 && i - 1 > 0 && j + 1 <= N &&
ans[i][j] != ans[i - 1][j + 1]) {
if (i - 2 > 0) {
check(i - 2, j, i, j + 1);
} else if (j - 1 > 0) {
check(i - 1, j - 1, i, j + 1);
} else {
assert(i == 2 && j == 1);
check(1, 1, 2, 3);
}
print();
return 0;
}
}
}
int v[110], v2[110];
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
v[i + j] = ans[i][j];
v2[i + j] = v[i + j];
}
}
for (int i = 3; i <= 2 * N + 3; i += 2) {
v2[i] ^= 1;
}
bool pa;
int sp;
for (int i = 2; i <= 2 * N - 3; i++) {
if ((v[i] == v[i + 3] && v[i + 1] == v[i + 2]) !=
(v2[i] == v2[i + 3] && v2[i + 1] == v2[i + 2])) {
pa = (v[i] == v[i + 3] && v[i + 1] == v[i + 2]);
sp = i;
break;
}
}
int nx, ny;
if (sp <= N + 1) {
nx = sp - 1;
ny = 1;
} else {
nx = N;
ny = sp - N;
}
if (query(nx, ny, nx, ny + 3) != pa) {
rev();
}
print();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int (i)=(0);(i)<(int)(n);++(i))
using ll = long long;
using namespace std;
int main() {
ll t;
cin >> t;
ll ans = t;
ll up = 0;
ll down = 0;
ll tm = 0;
for (ll speed=1; speed<t; speed*=3) {
up += speed;
tm++;
if (speed > 3) {
down += speed/3;
tm++;
}
ll tmptm = tm;
ll tmpt = t - up - down;
if (tmpt < 0) break;
for (ll sp=speed; sp>=1; sp/=3) {
if (tmpt / sp >= 1) {
tmptm += tmpt / sp;
tmpt -= sp * (tmpt/sp);
}
}
ans = min(ans, tmptm);
}
cout << ans << endl;
}
| 0 |
#include <iostream>
#include <string>
using namespace std;
using llong = long long;
int main() {
string s;
llong y, m, d;
while (cin >> s, s == "HEISEI") {
cin >> y >> m >> d;
if (y > 31 || (y >= 31 && m >= 5)) {
printf("? %lld %lld %lld\n", y - 30, m, d);
}
else {
printf("HEISEI %lld %lld %lld\n", y, m, d);
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long max(long long a, long long b) {
if (a < b)
return b;
else
return a;
}
long long min3(long long a, long long b, long long c) {
return min(a, min(b, c));
}
long long max3(long long a, long long b, long long c) {
return max(a, max(b, c));
}
long long ceil1(long long x, long long y) {
if (x % y)
return (x + y) / y;
else
return x / y;
}
long long NC = 100;
long long N = 1e7 + 9;
const long long second = 1e6 + 7;
long long mod(long long n);
long long gcd(long long a, long long b);
long long modM(long long n, long long m);
long long modA(long long n, long long m);
long long modS(long long n, long long m);
long long power(long long a, long long b);
void pra(long long a[], long long n);
void ipgraph(long long n, long long m);
vector<vector<long long> > v;
vector<bool> vis;
void solve() {
long long n;
cin >> n;
string s;
cin >> s;
vector<long long> sum(n + 1);
sum[0] = 0;
for (long long i = 0; i < n; i++) {
sum[i + 1] = sum[i] + s[i] - '0';
}
map<long long, long long> mp;
for (long long i = 0; i < n; i++) mp[sum[i + 1] - i - 1]++;
long long ans = 0;
mp[0]++;
for (auto x : mp) {
ans += (x.second) * (x.second - 1) / 2;
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
while (t--) solve();
cerr << endl
<< "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
void ipgraph(long long n, long long m) {
v.assign(n, {});
vis.assign(n, 0);
long long x, y;
char ch;
for (long long i = 0; i < m; i++) {
cin >> x >> ch >> y;
x--, y--;
v[y].push_back(x);
v[x].push_back(y);
}
}
long long gcd(long long a, long long b) {
if (b > a) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long a, long long b) {
if (b == 0) return 1;
long long c = power(a, b / 2);
if (b % 2 == 0)
return modM(c, c);
else
return modM(modM(c, c), a);
}
void pra(long long a[], long long n) {
for (long long i = 0; i < n; i++) cout << a[i] << " ";
cout << '\n';
}
long long mod(long long n) { return (n % N + N) % N; }
long long modM(long long n, long long m) { return ((n % N * m % N) + N) % N; }
long long modA(long long n, long long m) { return ((n % N + m % N) + N) % N; }
long long modS(long long n, long long m) { return ((n % N - m % N) + N) % N; }
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long tinh(long long a, int x) { return (a - (!(a % 2) == x)); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
long long a[100005], sumodd[100005], l[100005], r[100005], res, m;
cin >> n;
sumodd[0] = 0;
for (int i = 1; i < n; ++i) {
cin >> a[i];
sumodd[i + 1] = sumodd[i] + tinh(a[i], 1);
}
l[1] = 0;
for (int i = 2; i <= n; ++i)
if (a[i - 1] > 1)
l[i] = l[i - 1] + tinh(a[i - 1], 0);
else
l[i] = 0;
r[n] = 0;
for (int i = n - 1; i > 0; --i)
if (a[i] > 1)
r[i] = r[i + 1] + tinh(a[i], 0);
else
r[i] = 0;
res = 0;
m = 0;
for (int j = 1; j <= n; ++j) {
res = max(res, r[j] + sumodd[j] + m);
m = max(m, l[j] - sumodd[j]);
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int N = 3e5 + 10;
int n;
vector<int> a, b;
int tree[4 * N];
int q;
map<int, vector<int> > pos;
void no() { printf("NO\n"); }
void yes() { printf("YES\n"); }
int queryMin(int node, int lo, int hi, int l, int r) {
if (r < lo || hi < l) return inf;
if (l <= lo && hi <= r) return tree[node];
int mid = (lo + hi) / 2;
return min(queryMin(2 * node + 1, lo, mid, l, r),
queryMin(2 * node + 2, mid + 1, hi, l, r));
}
int queryMin(int to) {
if (to < 0) {
return inf;
}
return queryMin(0, 0, n - 1, 0, to);
}
void update(int node, int lo, int hi, int i, int d) {
if (i < lo || hi < i) return;
if (lo == hi) {
tree[node] = d;
return;
}
int mid = (lo + hi) / 2;
update(2 * node + 1, lo, mid, i, d);
update(2 * node + 2, mid + 1, hi, i, d);
tree[node] = min(tree[2 * node + 1], tree[2 * node + 2]);
}
void update(int i, int d) { update(0, 0, n - 1, i, d); }
void solve() {
scanf("%d", &n);
a.resize(n);
b.resize(n);
for (int &x : a) scanf("%d", &x);
for (int &x : b) scanf("%d", &x);
vector<int> c = a, d = b;
sort(c.begin(), c.end());
sort(d.begin(), d.end());
if (c != d) {
no();
return;
}
for (int i = 0; i < n; i++) {
pos[a[i]].push_back(i);
update(i, a[i]);
}
for (auto &v : pos) {
reverse(v.second.begin(), v.second.end());
}
bool done = false;
for (int i = 0; i < n; i++) {
int loc = pos[b[i]].back();
pos[b[i]].pop_back();
if (queryMin(loc - 1) < b[i]) {
no();
done = 1;
break;
}
update(loc, inf);
}
for (int i = 0; i < n; i++) {
update(i, inf);
}
if (!done) yes();
pos.clear();
}
int main() {
for (int i = 0; i < N; i++) update(i, inf);
scanf("%d", &q);
while (q--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool isrange(int second, int first, int n, int m) {
if (0 <= second && second < n && 0 <= first && first < m) return true;
return false;
}
int dy[4] = {1, 0, -1, 0}, dx[4] = {0, 1, 0, -1},
ddy[8] = {1, 0, -1, 0, 1, 1, -1, -1}, ddx[8] = {0, 1, 0, -1, 1, -1, 1, -1};
const int MAX = 202020;
pair<long long int, long long int> arr[MAX];
int n, k;
struct inf {
long long int val, tot;
int lw, wh;
bool operator<(inf a) const { return val < a.val; }
};
priority_queue<inf> pq;
bool can(long long int first) {
priority_queue<inf> q = pq;
for (int e = 1; e <= k; e++) {
inf now = q.top();
q.pop();
long long int lim = e - now.lw - 1;
long long int nlim = -now.val - now.lw;
if (lim > nlim) {
if (e < k) return false;
long long int df = lim - nlim;
if (df >= 1) return false;
}
if (e == k) return true;
long long int kk = now.tot - (lim + 1) * arr[now.wh].second + first;
if (kk < 0) return false;
long long int f1 = (kk / arr[now.wh].second) + e;
q.push({-f1, kk, e, now.wh});
}
return true;
}
int main(void) {
scanf("%d%d", &n, &k);
for (int e = 0; e < n; e++) scanf("%lld", &arr[e].first);
for (int e = 0; e < n; e++) scanf("%lld", &arr[e].second);
for (int e = 0; e < n; e++)
pq.push({-(arr[e].first / arr[e].second), arr[e].first, 0, e});
long long int ll = 0, rr = 2e12, ans = 1e18, mid;
while (ll <= rr) {
mid = (ll + rr) / 2;
if (can(mid)) {
ans = min(ans, mid);
rr = mid - 1;
} else
ll = mid + 1;
}
if (ans == 1e18) ans = -1;
printf("%lld", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int W,H,N;
cin >> W >> H >> N;
int xmin=0,xmax=W,ymin=0,ymax=H;
for(int i=0;i<N;i++){
int x,y,a;
cin >> x >> y >> a;
if(a==1)xmin=max(xmin,x);
if(a==2)xmax=min(xmax,x);
if(a==3)ymin=max(ymin,y);
if(a==4)ymax=min(ymax,y);
}
cout << max(0,(xmax-xmin))*max(0,(ymax-ymin)) << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long l, r;
} p[111111];
int cmp(const void *a, const void *b) {
node c = *(node *)a, d = *(node *)b;
if (c.l != d.l) return c.l > d.l ? 1 : -1;
return c.r > d.r ? 1 : -1;
}
int main() {
int n;
long long L, R, k, b;
scanf("%d", &n);
scanf("%I64d%I64d", &L, &R);
for (int i = 0; i < n; i++) {
scanf("%I64d%I64d", &k, &b);
p[i].l = L * k + b;
p[i].r = R * k + b;
}
qsort(p, n, sizeof(p[0]), cmp);
int flag = 1;
for (int i = 0; i < n - 1; i++)
if (p[i].l <= p[i + 1].l && p[i].r <= p[i + 1].r)
continue;
else {
flag = 0;
break;
}
if (!flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
template <class T>
inline void read(T &res) {
res = 0;
bool bo = 0;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-')
bo = 1;
else
res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
const int N = 1e5 + 5;
int n, x;
char s[N];
void work() {
read(n);
read(x);
scanf("%s", s + 1);
int now = 0, sum = 0, ans = 0;
for (int i = 1; i <= n; i++)
if (s[i] == '0')
sum++;
else
sum--;
for (int i = 1; i <= n; i++) {
if (sum == 0 && now == x) return (void)puts("-1");
if (sum) {
int tmp = (x - now) / sum;
if (tmp >= 0 && 1ll * sum * tmp + now == x) ans++;
}
if (s[i] == '0')
now++;
else
now--;
}
printf("%d\n", ans);
}
int main() {
int T;
read(T);
while (T--) work();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, j, M = 1000000007LL, res;
set<char> st;
string arr[110];
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) cin >> arr[i];
res = 1;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
st.insert(arr[j][i]);
}
res = (res * st.size()) % M;
st.clear();
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n;
int ones = 0, evens = 0;
for (int i = 0; i < n; i++) {
cin >> t;
if (t % 2 == 0)
evens++;
else
ones++;
}
if (ones % 2 == 0) {
cout << evens;
} else
cout << ones;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using ii = pair<int, int>;
using lu = unsigned long long;
using l = long long;
using vs = vector<string>;
using vii = vector<ii>;
using vl = vector<l>;
using vvl = vector<vl>;
using vvvl = vector<vvl>;
using ll = pair<l, l>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using mll = unordered_map<l, l>;
using sl = unordered_set<l>;
const l INF = numeric_limits<l>::max();
const double EPS = 1e-10;
const double PI = 3.14159265358979323846;
const l e0 = 1, e3 = 1000, e5 = 100000, e6 = 10 * e5, e7 = 10 * e6,
e8 = 10 * e7, e9 = 10 * e8;
const char lf = '\n';
void solve(istream& in, ostream& out);
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve(cin, cout);
}
const l MOD = e9 + 7;
struct point {
double x, y;
point() {}
point(double _x, double _y) : x(_x), y(_y) {}
double operator*(const point& o) { return x * o.x + y * o.y; }
point operator*(const double m) { return point(x * m, y * m); }
double operator^(const point& o) { return x * o.y - y * o.x; }
point operator-(const point& o) { return point(x - o.x, y - o.y); }
point operator+(const point& o) { return point(x + o.x, y + o.y); }
double operator>>(const point& o) {
point d = (*this - o);
return d * d;
}
double distance(const point& o) { return sqrt(*this >> o); }
bool equal(double a, double b) const {
if (abs(a - b) < EPS) return true;
if (abs(a) < EPS || abs(b) < EPS) return false;
return (abs((a - b) / a) < EPS) && (abs((a - b) / b) < EPS);
}
bool operator<(const point& o) const {
if (o.x != x) return x < o.x;
if (not equal(o.x, x)) return x < o.x;
return y < o.y;
}
};
l segment_intersection(point a, point b, point c, point d, point& o1,
point& o2) {
point x = c - a, y = d - a, z = b - a;
double t = (x ^ z) + (z ^ y);
if (abs(t) < EPS) {
if (abs(x ^ y) < EPS) {
vector<point> v = {a, b, c, d};
sort(begin(v), end(v));
o1 = v[1];
o2 = v[2];
return 2;
} else {
return 0;
}
}
t = (x ^ y) / t;
if (t < 0 or t > 1) return 0;
o1 = o2 = a + z * t;
return 1;
}
ostream& operator<<(ostream& s, const point& p) {
s << "(" << p.x << ", " << p.y << ")";
return s;
}
using vp = vector<point>;
vp intersect(double a, double b, double c, point p) {
vp z;
if (b != 0) {
z.emplace_back(p.x, (-c - a * p.x) / b);
}
if (a != 0) {
z.emplace_back((-c - b * p.y) / a, p.y);
}
return z;
}
void solve(istream& in, ostream& out) {
double a, b, c;
in >> a >> b >> c;
point q, w;
in >> q.x >> q.y >> w.x >> w.y;
double z = abs(q.x - w.x) + abs(q.y - w.y);
auto iq = intersect(a, b, c, q), iw = intersect(a, b, c, w);
for (auto x : iq)
for (auto y : iw) {
z = min(z, q.distance(x) + x.distance(y) + y.distance(w));
}
out << setprecision(12) << z << lf;
}
| 4 |
// ※※※ 解答不能 ※※※
// koosaga氏.
// https://atcoder.jp/contests/code-festival-2016-quala/submissions/893805
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using P = pair<int, int>;
#define repex(i, a, b, c) for(int i = a; i < b; i += c)
#define repx(i, a, b) repex(i, a, b, 1)
#define rep(i, n) repx(i, 0, n)
#define repr(i, a, b) for(int i = a; i >= b; i--)
#define a first
#define b second
#define pb push_back
vector<P> gph[200005];
int n, m, k;
bool vis[200005];
LL val[200005], l, r;
void dfs(int x, LL v){
if(vis[x]){
if(val[x] != v){
puts("No");
exit(0);
}
return;
}
vis[x] = 1;
val[x] = v;
if(x <= n) l = max(l, v);
else r = min(r, v);
for(auto &i : gph[x]) dfs(i.a, v + i.b);
}
int main(){
scanf("%d %d %d", &n, &m, &k);
rep(i, k){
int x, y, v;
scanf("%d %d %d", &x, &y, &v);
gph[x].pb(P(y + n, v));
gph[y + n].pb(P(x, -v));
}
repx(i, 1, n + m + 1){
if(!vis[i]){
l = -1e18, r = 1e18;
dfs(i, 0);
if(l > r) return !puts("No");
}
}
puts("Yes");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct edg {
int to, nxt, fro;
long long w;
bool is;
} e[N << 1];
struct Node {
int v;
long long w;
Node(){};
Node(int _v, long long _w) : v(_v), w(_w){};
};
bool operator<(Node x, Node y) { return x.w > y.w; }
int n, m, cnt = 1, head[N], f[N], id[N], num, ro, dfn[N], que;
long long dis[50][N], tdis[N], dep[N], fa[N][25];
bool vis[N];
priority_queue<Node> q;
void add(int u, int v, long long w) {
cnt++;
e[cnt].fro = u;
e[cnt].to = v;
e[cnt].nxt = head[u];
head[u] = cnt;
e[cnt].w = w;
}
void diji(int s) {
memset(dis[id[s]], 0x3f, sizeof(dis[id[s]]));
memset(vis, 0, sizeof(vis));
dis[id[s]][s] = 0;
q.push(Node(s, 0));
while (q.size()) {
int u = q.top().v;
q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (dis[id[s]][u] + e[i].w < dis[id[s]][v]) {
dis[id[s]][v] = dis[id[s]][u] + e[i].w;
q.push(Node(v, dis[id[s]][v]));
}
}
}
}
void dfs(int u) {
vis[u] = 1;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (vis[v]) continue;
dep[v] = dep[u] + 1;
fa[v][0] = u;
tdis[v] = e[i].w + tdis[u];
e[i].is = e[i ^ 1].is = 1;
dfs(v);
}
}
int getlca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int d = dep[u] - dep[v];
for (int i = 20; i >= 0; i--)
if (d & (1 << i)) u = fa[u][i];
if (u == v) return u;
for (int i = 20; i >= 0; i--)
if (fa[u][i] != fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
}
return fa[u][0];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
add(u, v, w);
add(v, u, w);
}
dfs(1);
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= n; i++) fa[i][j] = fa[fa[i][j - 1]][j - 1];
for (int i = 2; i <= cnt; i++) {
if (e[i].is) continue;
if (!id[e[i].fro]) {
id[e[i].fro] = ++num;
dfn[num] = e[i].fro;
diji(e[i].fro);
}
if (!id[e[i].to]) {
id[e[i].to] = ++num;
dfn[num] = e[i].to;
diji(e[i].to);
}
}
scanf("%d", &que);
while (que--) {
int x, y;
scanf("%d%d", &x, &y);
int lca = getlca(x, y);
long long ans = tdis[x] + tdis[y] - 2 * tdis[lca];
for (int i = 1; i <= num; i++) ans = min(ans, dis[i][x] + dis[i][y]);
printf("%lld\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long SIZE = 5e4 + 5;
const long long mod = 998244353;
void solution() {
long long n, k, q, s = 0;
cin >> n;
vector<long long> empro(1000001, 0);
map<long long, long long> em;
map<long long, long long> aaa;
vector<long long> anses;
anses.push_back(0);
bool pro = 0;
for (long long i = 0; i < n; ++i) {
cin >> q;
if (q > 0) {
if (s == 0 and pro == 1) {
anses.push_back(i);
pro = 1;
em = aaa;
em[q] = 1;
s++;
empro[q]++;
continue;
}
if (em[q] == 0) {
em[q] = 1;
s++;
empro[q]++;
pro = 1;
} else if (s == 0) {
anses.push_back(i);
pro = 1;
em = aaa;
em[q] = 1;
s++;
empro[q]++;
} else {
cout << -1;
return;
}
} else {
if (em[-q] == 0 || empro[-q] == 0) {
cout << -1;
return;
} else if (empro[-q] == 1) {
empro[-q] = 0;
s--;
}
if (i == n - 1) {
anses.push_back(n);
}
}
}
if (s != 0 or n % 2 == 1) {
cout << -1;
return;
}
if (anses.size() == 0) {
cout << 1 << '\n' << n;
return;
}
cout << anses.size() - 1 << '\n';
for (long long i = 1; i < anses.size(); i++) {
cout << anses[i] - anses[i - 1] << " ";
}
}
int main() {
solution();
int k = 0;
for (int i = 0; i < 100; ++i) {
k++;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[102][102];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q, x, y, tp;
cin >> n >> m >> q;
memset(a, 0, sizeof a);
vector<int> v[q];
for (int i = 0; i < q; i++) {
cin >> tp;
if (tp == 3) {
v[i].push_back(tp);
cin >> x >> y >> tp;
v[i].push_back(x);
v[i].push_back(y);
v[i].push_back(tp);
} else {
v[i].push_back(tp);
cin >> tp;
v[i].push_back(tp);
}
}
reverse(v, v + q);
for (int i = 0; i < q; i++) {
if (v[i][0] == 3) {
x = v[i][1];
y = v[i][2];
a[x][y] = v[i][3];
} else if (v[i][0] == 2) {
y = v[i][1];
for (int i = n; i > 0; i--) {
a[i + 1][y] = a[i][y];
}
a[1][y] = a[n + 1][y];
} else {
x = v[i][1];
for (int i = m; i > 0; i--) {
a[x][i + 1] = a[x][i];
}
a[x][1] = a[x][m + 1];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << a[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> arr(n);
for (auto &item : arr) {
cin >> item;
}
int r1 = 0;
int r2 = 0;
int res;
for (auto &item : arr) {
if (item > 0)
r1++;
else if (item < 0)
r2++;
}
if (r1 >= ceil(n / 2.0))
res = 1;
else if (r2 >= ceil(n / 2.0))
res = -1;
else
res = 0;
cout << res << endl;
return 0;
}
| 1 |
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll MOD = 998244353;
const ll INF = (ll)1000000007 * 1000000007;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef long double ld;
typedef complex<ld> Point;
const ld eps = 1e-11;
const ld pi = acos(-1.0);
typedef pair<ll, ll> LP;
typedef pair<ld, ld> LDP;
const int MAX_N = (1 << 18);
int t; ll dat[2 * MAX_N - 1][2];
int n;
void init() {
t = 1;
while(t < 2*n)t *= 2;
rep(i, 2 * t - 1) {
rep(j, 2) {
dat[i][j] = -INF;
}
}
}
void update(int k, int j, ll a) {
k += t - 1;
dat[k][j] = a;
while (k > 0) {
k = (k - 1) / 2;
int le = k * 2 + 1; int ri = k * 2 + 2;
if (dat[ri][0] != -INF || dat[ri][1] != -INF) {
dat[k][0] = max(dat[le][0] + dat[ri][0], dat[le][1] + dat[ri][1]);
dat[k][1] = max(dat[le][0] + dat[ri][1], dat[le][1] + dat[ri][0]);
}
else {
dat[k][0] = dat[le][0];
dat[k][1] = dat[le][1];
}
}
}
int main(){
int q; cin >> n >> q; init();
rep(i, 2 * n) {
int a; cin >> a;
update(i, 0, a);
}
rep(i, 2 * n) {
int b; cin >> b;
if (i > 0 && i < 2 * n - 1) {
update(i, 1, b);
}
}
rep(i, q) {
int p; ll x, y; cin >> p >> x >> y; p--;
update(p, 0, x);
if (p > 0 && p < 2 * n - 1) {
update(p, 1, y);
}
cout << dat[0][0] << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
int n, h, arr[2000 + 7];
long long int dp[2][2000 + 7];
long long int solve() {
long long int tmp, i, j, k;
bool pre = 0, nw = 1;
memset((dp[0]), 0, sizeof(dp[0]));
dp[0][0] = 1;
for (i = 1; i <= n; i++) {
memset((dp[nw]), 0, sizeof(dp[nw]));
for (j = 0; j <= n; j++) {
long long int &ret = dp[nw][j];
if ((arr[i] + j + 1) == h)
ret = (dp[pre][j] * (j + 1) % 1000000007 +
dp[pre][j + 1] * (j + 1) % 1000000007) %
1000000007;
else if ((arr[i] + j) == h)
ret = (dp[pre][j] + dp[pre][j - 1]) % 1000000007;
}
pre ^= 1;
nw ^= 1;
}
return dp[pre][0];
}
int main() {
long long int ans;
int i, j, k;
while (scanf("%d %d", &n, &h) == 2) {
for (i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
}
memset((dp), 0, sizeof(dp));
ans = solve();
printf("%lld\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int res = 0, c;
while (c = getchar(), c < '0' || c > '9')
;
do {
res = res * 10 + (c ^ 48);
} while (c = getchar(), c >= '0' && c <= '9');
return res;
}
pair<pair<int, int>, int> S[500010];
int ask[500010];
set<int> Set;
int main() {
int N = read(), X = 0, Y = 0;
for (int i = 1; i <= N; i++) {
int a = getchar(), b = read(), c = read();
if (b > c) swap(b, c);
if (a == '+') {
X = max(b, X);
Y = max(c, Y);
} else {
puts(b >= X && c >= Y ? "YES" : "NO");
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
long long int ans;
if (k % (n - 1) != 0)
ans = n * (k / (n - 1)) + k % (n - 1);
else
ans = n * (k / (n - 1)) - 1 + k % (n - 1);
cout << ans << "\n";
}
return 0;
}
| 3 |
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int dp[100001][10];
int main(){
int n,m;
int a[10];
string id;
cin>>n>>id;
cin>>m;
for(int i=0;i<m;i++)cin>>a[i];
dp[0][0]=1;
for(int i=0;i<n;i++){
for(int j=0;j<10;j++){
if(id[i]=='*'){
for(int k=0;k<m;k++){
int x=a[k];
if((n-i)%2==0){
x*=2;
if(10<=x)x=x/10+x%10;
}
dp[i+1][(j+x)%10]+=dp[i][j];
}
}else{
int x=id[i]-'0';
if((n-i)%2==0){
x*=2;
if(10<=x)x=x/10+x%10;
}
dp[i+1][(j+x)%10]+=dp[i][j];
}
}
}
cout<<dp[n][0]<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2222;
int c[maxn][10][2];
int a[maxn][maxn];
int Abs(int a) { return a < 0 ? -a : a; }
int x[10], y[10], xx[10], yy[10], l[11][11], num[111111];
const int INF = 111111111;
int main() {
int n, m, i, j, t, s, k;
scanf("%d%d%d%d", &n, &m, &k, &s);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++)
if (!c[i][a[i][j]][0]) c[i][a[i][j]][0] = j;
for (j = m; j >= 1; j--)
if (!c[i][a[i][j]][1]) c[i][a[i][j]][1] = j;
}
for (i = 1; i <= k; i++) {
for (j = 1; j <= k; j++) {
x[j] = y[j] = INF;
xx[j] = INF, yy[j] = 0;
}
for (j = 1; j <= k; j++)
for (t = 1; t <= n; t++) {
if (c[t][j][0] && x[j] + y[j] > c[t][j][0] + t)
x[j] = t, y[j] = c[t][j][0];
if (c[t][j][1] && yy[j] - xx[j] < c[t][j][1] - t)
xx[j] = t, yy[j] = c[t][j][1];
if (!c[t][i][1]) continue;
if (x[j] != INF) {
l[i][j] = max(l[i][j], Abs(t - x[j]) + Abs(c[t][i][1] - y[j]));
l[i][j] = max(l[i][j], Abs(t - xx[j]) + Abs(c[t][i][0] - yy[j]));
}
}
}
for (i = 1; i <= k; i++) {
for (j = 1; j <= k; j++) {
x[j] = y[j] = 0;
xx[j] = 0, yy[j] = INF;
}
for (t = n; t >= 1; t--) {
if (c[t][j][1] && x[j] + y[j] < c[t][j][1] + t)
x[j] = t, y[j] = c[t][j][1];
if (c[t][j][0] && xx[j] - yy[j] > t - c[t][j][0])
xx[j] = t, yy[j] = c[t][j][0];
if (!c[t][i][0]) continue;
if (x[j]) {
l[i][j] = max(l[i][j], Abs(t - x[j]) + Abs(c[t][i][0] - y[j]));
l[i][j] = max(l[i][j], Abs(t - xx[j]) + Abs(c[t][i][1] - yy[j]));
}
}
}
for (i = 1; i <= k; i++)
for (j = i; j <= k; j++) l[i][j] = l[j][i] = max(l[i][j], l[j][i]);
int ans = 0;
for (i = 1; i <= s; i++) {
scanf("%d", &num[i]);
if (i > 1) ans = max(ans, l[num[i]][num[i - 1]]);
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long s[100005]{0};
pair<long long, long long> p[100005];
for (int i = 0; i < m; i++) {
int u, v;
long long d;
cin >> u >> v >> d;
u--;
v--;
s[u] -= d;
s[v] += d;
}
for (int i = 0; i < n; i++) p[i] = pair<long long, long long>(s[i], i);
sort(p, p + n);
vector<int> u, v;
vector<long long> d;
int i = 0;
int j = n - 1;
while (i < j) {
if (p[i].first + p[j].first < 0) {
u.push_back(p[i].second);
v.push_back(p[j].second);
d.push_back(p[j].first);
p[i].first += p[j].first;
p[j].first = 0;
j--;
} else if (p[i].first + p[j].first > 0) {
u.push_back(p[i].second);
v.push_back(p[j].second);
d.push_back(-p[i].first);
p[j].first += p[i].first;
p[i].first = 0;
i++;
} else {
if (p[i].first == 0) {
i++;
j--;
continue;
}
u.push_back(p[i].second);
v.push_back(p[j].second);
d.push_back(p[j].first);
p[i].first = 0;
p[j].first = 0;
i++;
j--;
}
}
int l = u.size();
cout << l << endl;
for (int i = 0; i < l; i++)
cout << u[i] + 1 << " " << v[i] + 1 << " " << d[i] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-15, PI = acos(-1);
const int MOD = int(1e9) + 7, MX = int(1e5) + 1;
const int N = 2010;
int memo[N][N];
string a, b;
int ED() {
int n = int(a.size()), m = int(b.size());
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i - 1] == b[j - 1])
memo[i][j] = 1 + memo[i - 1][j - 1];
else
memo[i][j] = memo[i - 1][j - 1];
int mn = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) mn = max(mn, memo[i][j]);
return m - mn;
}
void solve() {
cin >> a >> b;
printf("%d\n", ED());
}
int main() { solve(); }
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T, flag, a;
long long ans;
while (cin >> T) {
a = 0;
ans = 1;
flag = 0;
while (T--) {
int n;
cin >> n;
if (n == 0 && flag == 1) {
a++;
}
if (n == 1) {
flag = 1;
if (a != 0) {
ans = ans * (a + 1);
a = 0;
}
}
}
if (flag == 0) ans = 0;
printf("%I64d\n", ans);
}
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
long N,A,B,C,l[9],ans=LONG_MAX;
void dfs(int n,int a,int b,int c,int v){
if(n==N){
if(a&&b&&c)ans=min(ans,abs(a-A)+abs(b-B)+abs(c-C)+v);
return;
}
dfs(n+1,a,b,c,v);
dfs(n+1,a+l[n],b,c,v+10*(a>0));
dfs(n+1,a,b+l[n],c,v+10*(b>0));
dfs(n+1,a,b,c+l[n],v+10*(c>0));
}
int main(void){
cin>>N>>A>>B>>C;
for(int i=0;i<N;i++)cin>>l[i];
dfs(0,0,0,0,0);
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a=0;
string d,f;
cin >>d;
cin >>f;
for(int s=0;s<3;s++){
if(d[s]==f[s])
a++;}
cout <<a <<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long power(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret *= a;
a *= a;
if (ret >= MOD) ret %= MOD;
if (a >= MOD) a %= MOD;
b >>= 1;
}
return ret;
}
long long inv(long long x) { return power(x, MOD - 2); }
const int N = 1e6 + 5;
int n, k;
char A[N], B[27];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
cin >> n >> k;
if (n < k) {
cout << "-1\n";
return 0;
}
if (k == 1 && n != 1) {
cout << "-1";
return 0;
}
for (int i = 0; i < 26; i++) B[i] = 'a' + i;
int left = k - 2;
for (int i = 1; i <= n - (k - 2); i += 2) {
A[i] = 'a';
A[i + 1] = 'b';
}
int cur = 2;
for (int i = n - (k - 2) + 1; i <= n; i++) {
A[i] = B[cur];
cur++;
}
for (int i = 1; i <= n; i++) cout << A[i];
}
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define rep(i,N) for(ll (i)=0;(i)<(N);(i)++)
const int mod = 1000000007;
int main(){
int n;
cin >> n;
vector<int> a(n), b(n), c(n);
rep(i, n) cin >> a[i];
rep(i, n) cin >> b[i];
rep(i, n) cin >> c[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
ll l = 0, r = 0;
ll ans = 0;
for(int i = 0; i < n; ++i) {
while(l < n && a[l] < b[i]) ++l;
while(r < n && b[i] >= c[r]) ++r;
ans += l * (n - r);
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 4e3 + 10, mod = 998244353;
int dp[2][M], base = 2005;
int mul(int x, int y) { return 1ll * x * y % mod; }
void inc(int& x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int a[M];
int main() {
int n, K;
scanf("%d%d", &n, &K);
dp[0][base] = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
int now = i & 1, pre = 1 - now;
for (int j = base - n; j <= base + n; j++) dp[now][j] = 0;
int x = a[i], y = (i == n) ? a[1] : a[i + 1];
if (x == y) {
for (int j = base - n; j <= base + n; j++)
dp[now][j] = mul(K, dp[pre][j]);
continue;
}
int add = 0, way = K - 2;
for (int j = base - n; j <= base + n; j++)
inc(dp[now][j], mul(dp[pre][j], way));
add = 1, way = 1;
for (int j = base - n + add; j <= base + n; j++)
inc(dp[now][j], mul(dp[pre][j - add], way));
add = -1, way = 1;
for (int j = base - n; j <= base + n + add; j++)
inc(dp[now][j], mul(dp[pre][j - add], way));
}
int ans = 0;
for (int i = 1; i <= n; i++) {
inc(ans, dp[n & 1][base + i]);
}
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double a, h;
int main (){
cin >> a >> h;
cout << ceil(a/h) << endl;
}
| 0 |
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 200010
#define ll long long
using namespace std;
int n, nxt[N], d, len[2];
ll L, R, ans[26], D[1010][2], s[2], s1[2][26];
char S[N];
inline void kmp(){
nxt[0]=nxt[1]=0; int j;
for(int i=2; i<=n; i++){
j=nxt[i-1]; while(j&&S[i]!=S[j+1])j=nxt[j];
if(S[i]==S[j+1])j++; nxt[i]=j;
}
}
inline void solve(ll m, int f){
len[0]=n; len[1]=d;
memset(D, 0, sizeof(D)); D[1][0]=1; D[2][1]=1;
if(m<=n+d){
for(int i=1; i<=n; i++)if(i<=m)ans[S[i]-'a']+=f;
for(int i=1; i<=d; i++)if(n+i<=m)ans[S[i]-'a']+=f;
return;
}
memset(s1, 0, sizeof(s1));
for(int i=1; i<=n; i++)s1[0][S[i]-'a']++;
for(int i=1; i<=d; i++)s1[1][S[i]-'a']++;
s[0]=1; s[1]=0; ll now=n+d; int p;
for(int i=3; i<=1000; i++){
D[i][0]=s[0]; D[i][1]=s[1];
now+=D[i][0]*len[0]+D[i][1]*len[1];
s[0]+=D[i-1][0]; s[1]+=D[i-1][1];
if(now>=m){
while(m>n+d){
for(int j=1; j<=i; j++)if(m>=D[j][0]*len[0]+D[j][1]*len[1]){
for(int k=0; k<=25; k++)ans[k]+=s1[0][k]*D[j][0]*f;
for(int k=0; k<=25; k++)ans[k]+=s1[1][k]*D[j][1]*f;
m-=D[j][0]*len[0]+D[j][1]*len[1];
}
}
for(int j=1; j<=n; j++)if(j<=m)ans[S[j]-'a']+=f;
for(int j=1; j<=d; j++)if(n+j<=m)ans[S[j]-'a']+=f;
return;
}
}
}
int main(){
scanf("%s", S+1); n=strlen(S+1); n>>=1;
scanf("%lld%lld", &L, &R);
kmp(); d=n-nxt[n];
memset(ans, 0, sizeof(ans)); solve(R, 1); solve(L-1, -1);
for(int i=0; i<=24; i++)printf("%lld ", ans[i]); printf("%lld", ans[25]);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(unordered_map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long gcd(long long a, long long b) {
if (b > a) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
string numberToString(unsigned long long n) {
ostringstream geek;
geek << n;
string s = geek.str();
return s;
}
long long stringToNumber(string s) {
stringstream stream(s);
long long x = 0;
stream >> x;
return x;
}
long long expo(long long a, long long b, long long mod) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return res;
}
void extendgcd(long long a, long long b, long long *v) {
if (b == 0) {
v[0] = 1;
v[1] = 0;
v[2] = a;
return;
}
extendgcd(b, a % b, v);
long long x = v[1];
v[1] = v[0] - v[1] * (a / b);
v[0] = x;
return;
}
long long mminv(long long a, long long b) {
long long arr[3];
extendgcd(a, b, arr);
return arr[0];
}
long long mminvprime(long long a, long long b) { return expo(a, b - 2, b); }
bool revsort(long long a, long long b) { return a > b; }
void swap(int &x, int &y) {
int temp = x;
x = y;
y = temp;
}
long long combination(long long n, long long r, long long m, long long *fact,
long long *ifact) {
long long val1 = fact[n];
long long val2 = ifact[n - r];
long long val3 = ifact[r];
return (((val1 * val2) % m) * val3) % m;
}
void google(int t) { cout << "Case #" << t << ": "; }
vector<long long> sieve(int n) {
int *arr = new int[n + 1]();
vector<long long> vect;
for (int i = 2; i <= n; i++)
if (arr[i] == 0) {
vect.push_back(i);
for (int j = 2 * i; j <= n; j += i) arr[j] = 1;
}
return vect;
}
long long mod_add(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long mod_mul(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long mod_sub(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long mod_div(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (mod_mul(a, mminvprime(b, m), m) + m) % m;
}
long long phin(long long n) {
long long number = n;
if (n % 2 == 0) {
number /= 2;
while (n % 2 == 0) n /= 2;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
while (n % i == 0) n /= i;
number = (number / i * (i - 1));
}
}
if (n > 1) number = (number / n * (n - 1));
return number;
}
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
long long even = 0;
long long odd = 0;
for (int i = 0; i < n; i++) {
cin >> v[i];
if (v[i] % 2 == 0) {
even++;
} else {
odd++;
}
}
if (n % 2 == 0) {
if (even != odd) {
cout << -1;
return;
}
} else {
if (abs(even - odd) != 1) {
cout << -1;
return;
}
}
int evenOdd = INT_MAX;
vector<long long> evenOff;
vector<long long> oddOff;
if (even >= odd) {
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (v[i] % 2 != 0) {
oddOff.push_back(i);
}
} else {
if (v[i] % 2 == 0) {
evenOff.push_back(i);
}
}
}
evenOdd = 0;
for (int i = 0; i < evenOff.size(); i++) {
evenOdd += abs(evenOff[i] - oddOff[i]);
}
};
;
int oddEven = INT_MAX;
vector<long long> evenOff1;
vector<long long> oddOff1;
if (odd >= even) {
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (v[i] % 2 == 0) {
evenOff1.push_back(i);
}
} else {
if (v[i] % 2 != 0) {
oddOff1.push_back(i);
}
}
}
oddEven = 0;
for (int i = 0; i < evenOff1.size(); i++) {
oddEven += abs(evenOff1[i] - oddOff1[i]);
}
}
cout << min(evenOdd, oddEven);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
const int maxn = 1e7 + 7, moe = 998244353;
inline long long qow(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % moe;
x = x * x % moe;
y = y >> 1;
}
return res;
}
int inv[maxn], ik[maxn], s[maxn];
long long f[maxn], c, ret, n, m, k, p, ans;
int pe[maxn];
signed main() {
n = read(), m = read(), k = read();
p = qow(m, moe - 2);
inv[1] = ik[1] = 1;
for (register int i = 2; i <= k; i++) {
inv[i] = (moe - 1ll * inv[moe % i] * (moe / i) % moe) % moe;
if (!s[i]) {
pe[++pe[0]] = i;
ik[i] = qow(i, k);
}
for (register int j = 1; j <= pe[0] && pe[j] * i <= k; j++) {
s[pe[j] * i] = 1;
ik[pe[j] * i] = 1ll * ik[pe[j]] * ik[i] % moe;
if (i % pe[j] == 0) break;
}
}
c = n - k, ret = 1;
f[0] = 1;
for (register int i = 1; i <= k; i++) {
ret = ret * (moe - p) % moe * (c + i - 1) % moe * 1ll * inv[i] % moe;
f[i] = (f[i - 1] * (1 - p + moe) % moe + ret) % moe;
}
ret = 1;
for (register int i = 0; i <= k; i++) {
if (i) ret = ret * p % moe * (n - i + 1) % moe * 1ll * inv[i] % moe;
ans = (ans + ret * 1ll * ik[i] % moe * f[k - i] % moe) % moe;
}
ans = (ans % moe + moe) % moe;
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = (int)1e9 + 7;
vector<int> g[200200];
void solve() {
int n, k;
scanf("%d%d\n", &n, &k);
vector<char> A(n);
for (int i = 0; i < n; i++) {
scanf("%c", &A[i]);
}
scanf("\n");
for (int i = 0; i <= n; i++) g[i].clear();
int last1 = -1;
for (int i = 0; i < n; i++) {
if (A[i] == 'W') {
if (last1 != -1) {
int len = i - last1;
if (len > 0) {
g[len].push_back(i);
}
}
last1 = i;
}
}
vector<int> order;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
order.push_back(g[i][j]);
}
}
for (int i = 0; i < n; i++) {
if (A[i] == 'W') {
order.push_back(i);
break;
}
}
for (int i = 0; i < order.size(); i++) {
int pos = order[i];
int q = pos - 1;
while (k > 0 && q >= 0 && A[q] != 'W') {
A[q] = 'W';
k--;
q--;
}
}
bool hasSeen1 = false;
for (int i = 0; i < n; i++) {
if (A[i] == 'W') {
hasSeen1 = true;
}
if (A[i] == 'L' && hasSeen1 && k > 0) {
A[i] = 'W';
k--;
}
}
for (int i = 0; i < n; i++) {
if (A[i] == 'L' && k > 0) {
A[i] = 'W';
k--;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (A[i] == 'W') {
if (i >= 1 && A[i - 1] == 'W')
ans += 2;
else
ans += 1;
}
}
cout << ans << endl;
}
int main() {
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int a,b,c;
int main() {
cin>>a>>b>>c;
cout<<(a-c)/(c+b)<<'\n';
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 200005;
const int MOD = 1e9 + 7;
int n, m;
int A[MN];
const int ME = MN;
const int INF = 0x3f3f3f3f;
struct edge {
int v, next, cap;
} E[ME * 2];
int vec[MN], NE;
int gap[MN], lev[MN], cur[MN], pre[MN], aug[MN];
void init(int n) {
NE = 0;
for (int i = 0; i <= n; i++) vec[i] = -1;
}
inline void addedge(int u, int v, int w = 1, int rw = 0) {
E[NE].v = v, E[NE].cap = w, E[NE].next = vec[u], vec[u] = NE++;
E[NE].v = u, E[NE].cap = rw, E[NE].next = vec[v], vec[v] = NE++;
}
int isap(int s, int e, int n) {
int i, u = s, max_flow = 0;
for (i = 0; i <= n; i++) lev[i] = gap[i] = 0, cur[i] = vec[i];
pre[s] = -1;
aug[s] = INF;
while (lev[s] < n) {
if (u == e) {
int c = aug[e];
max_flow += c;
for (int v = pre[e]; v != -1; v = pre[v]) {
i = cur[v];
E[i].cap -= c;
E[i ^ 1].cap += c;
aug[E[i].v] -= c;
if (E[i].cap == 0) u = v;
}
continue;
}
for (i = cur[u]; i != -1; i = E[i].next) {
int v = E[i].v;
if (E[i].cap > 0 && lev[u] == lev[v] + 1) {
aug[v] = min(aug[u], E[i].cap);
cur[u] = i;
pre[v] = u;
u = v;
break;
}
}
if (i == -1) {
if (--gap[lev[u]] == 0) return max_flow;
int mlev = n;
for (i = vec[u]; i != -1; i = E[i].next)
if (E[i].cap > 0) mlev = min(lev[E[i].v], mlev);
gap[lev[u] = mlev + 1]++;
cur[u] = vec[u];
if (u != s) u = pre[u];
}
}
return max_flow;
}
bool isprime(int a) {
if (a == 1) return 0;
for (int i = 2; i * i <= a; i++) {
if (a % i == 0) return 0;
}
return 1;
}
vector<int> v[505], ANS[505];
bool vis[505];
void dfs(int u, int id) {
if (u == 0 || u == n + 1) return;
vis[u] = 1;
ANS[id].push_back(u);
for (int i = vec[u]; i != -1; i = E[i].next) {
int v = E[i].v;
if (vis[v]) continue;
if (A[u] % 2) {
if (E[i].cap != 1) {
E[i].cap++;
dfs(v, id);
}
} else {
if (E[i].cap) {
E[i].cap--;
dfs(v, id);
}
}
}
}
int main() {
scanf("%d", &n);
init(n + 123);
for (int i = (1); i < (n + 1); ++i) {
scanf("%d", &A[i]);
if (A[i] & 1)
addedge(0, i, 2);
else
addedge(i, n + 1, 2);
}
for (int i = (1); i < (n + 1); ++i) {
if (A[i] & 1)
for (int j = (1); j < (n + 1); ++j)
if (isprime(A[i] + A[j])) addedge(i, j, 1);
}
int ans = isap(0, n + 1, n + 3);
if (ans != n) {
printf("Impossible\n");
return 0;
}
ans = 0;
for (int i = (1); i < (n + 1); ++i) {
if (!vis[i]) dfs(i, ans++);
}
printf("%d\n", ans);
for (int i = (0); i < (ans); ++i) {
printf("%d ", ANS[i].size());
for (int j = 0; j < ANS[i].size(); j++) printf("%d ", ANS[i][j]);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
char s[210000], t[210000];
int n, m, f[210000], g[210000], ans, r, now, te;
int main() {
scanf("%s%s", s + 1, t + 1);
n = strlen(s + 1);
m = strlen(t + 1);
for (int i = 1; i <= n; i++) {
if (now < m && t[now + 1] == s[i]) now++;
f[i] = now;
}
now = g[n + 1] = m + 1;
for (int i = n; i >= 1; i--) {
if (now > 1 && t[now - 1] == s[i]) now--;
g[i] = now;
}
r = 1;
for (int i = 0; i <= n; i++) {
while (r <= n && f[i] + 1 >= g[r + 1]) r++;
te = r - i - 1;
if (te > ans) ans = te;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int a, b, c;
cin >> a >> b >> c;
int m;
cin >> m;
vector<pair<int, string> > items(m);
for (int i = 0; i < m; i++) {
int val;
string type;
cin >> val >> type;
items[i] = pair<int, string>(val, type);
}
sort(items.begin(), items.end());
long long int sum_num = 0, sum_val = 0;
for (int i = 0; i < m; i++) {
pair<int, string> p = items[i];
if (p.second == "USB") {
if (a > 0) {
a--;
sum_num++;
sum_val += p.first;
} else if (c > 0) {
c--;
sum_num++;
sum_val += p.first;
}
} else {
if (b > 0) {
b--;
sum_num++;
sum_val += p.first;
} else if (c > 0) {
c--;
sum_num++;
sum_val += p.first;
}
}
}
cout << sum_num << " " << sum_val << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int cases;
cin >> cases;
while (cases) {
cases--;
long long int a, b, c;
cin >> a >> b >> c;
cout << a + b + c - 1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long modsize = 303030;
vector<long long> fac(modsize);
vector<long long> inv(modsize);
vector<long long> facinv(modsize);
void modcalc() {
if (modsize == 0) abort();
fac[0] = 1;
fac[1] = 1;
inv[1] = 1;
facinv[0] = 1;
facinv[1] = 1;
for (long long i = 2; i < modsize; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
facinv[i] = facinv[i - 1] * inv[i] % mod;
}
}
long long modinv(long long a) {
if (a == 0) abort();
long long b = mod, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0) u += mod;
return u;
}
long long modpow(long long a, long long b) {
long long ans = 1;
a %= mod;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long modcomb(long long n, long long k) {
if (n < 0 || k < 0 || n < k) return 0;
return fac[n] * facinv[k] % mod * facinv[n - k] % mod;
}
long long modperm(long long n, long long k) {
if (n < 0 || k < 0 || n < k) return 0;
return fac[n] * facinv[n - k] % mod;
}
long long modhom(long long n, long long k) {
if (n < 0 || k < 0 || (n == 0 && k > 0)) return 0;
if (n == 0 && k == 0) return 1;
return fac[n + k - 1] * facinv[k] % mod * facinv[n - 1] % mod;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int n;
cin >> n;
vector<int> a(2 * n);
long long sum = 0;
for (int i = 0; i < (2 * n); i++) {
cin >> a[i];
sum += a[i];
}
modcalc();
sort(a.begin(), a.end());
long long leftsum = 0;
for (int i = 0; i < (n); i++) leftsum += a[i];
long long rightsum = sum - leftsum;
long long s = rightsum - leftsum;
s %= mod;
cout << modcomb(2 * n, n) * s % mod << endl;
}
| 2 |
#include<cstdio>
using namespace std;
int main(){
int g[13] = {0, 0, 2, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0};
int x, y; scanf("%d %d", &x, &y);
puts(g[x] == g[y] ? "Yes" : "No");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000013;
int n, m;
pair<int, int> a[N];
vector<int> q[N];
bool read() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
int l, r;
scanf("%d%d", &l, &r);
a[i] = make_pair(l, r);
}
for (int i = 0; i < m; i++) {
int cnt;
scanf("%d", &cnt);
q[i].push_back(0);
for (int j = 0; j < cnt; j++) {
int p;
scanf("%d", &p);
q[i].push_back(p);
}
q[i].push_back(1000 * 1000 + 3);
}
return true;
}
int ans[N];
vector<int> xs[N];
vector<pair<int, int> > qq[N];
int t[N];
int sum(int r) {
int ans = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ans += t[r];
return ans;
}
int sum(int l, int r) { return sum(r) - sum(l - 1); }
void inc(int i, int add) {
for (; i < N; i = (i | (i + 1))) t[i] += add;
}
void solve() {
for (int i = 0; i < n; i++) xs[a[i].second].push_back(a[i].first);
for (int i = 0; i < m; i++)
for (int j = 0; j < q[i].size() - 1; j++) {
int l = q[i][j] + 1, r = q[i][j + 1] - 1;
qq[r].push_back(make_pair(l, i));
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < xs[i].size(); j++) {
int y = xs[i][j];
inc(y, 1);
}
for (int j = 0; j < qq[i].size(); j++) {
int id = qq[i][j].second;
ans[id] += sum(qq[i][j].first, i);
}
}
for (int i = 0; i < m; i++) {
printf("%d\n", n - ans[i]);
}
}
int main() {
read();
solve();
return 0;
}
| 5 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
#include<vector>
#include<string>
#define reep(a,s,d) for(int a=d;a<s;a++)
#define rep(a,s) reep(a,s,0)
using namespace std;
struct edge{
int to,cost,tick;
edge(int to,int cost,int tick):to(to),cost(cost),tick(tick){}
edge(){}
};
bool operator<(const edge &a,const edge &b){
return a.cost>b.cost;
}
int main(){
int c,n,m,s,d;
while(cin>>c>>n>>m>>s>>d,c){
vector<edge> G[128];
rep(i,m){
int a,b,c;
cin>>a>>b>>c;
G[--a].push_back(edge(--b,c,0));
G[b].push_back(edge(a,c,0));
}
bool vis[16][128];
memset(vis,false,sizeof(vis));
priority_queue<edge> Q;
Q.push(edge(s-1,0,0));
int ret=-1;
while(!Q.empty()){
edge n=Q.top();Q.pop();
if(vis[n.tick][n.to])continue;
vis[n.tick][n.to]=true;
if(n.to==d-1){
if(ret!=-1)ret=min(ret,n.cost);
else ret=n.cost;
}
rep(i,G[n.to].size()){
Q.push(edge(G[n.to][i].to,n.cost+G[n.to][i].cost,n.tick));
if(n.tick<c){
Q.push(edge(G[n.to][i].to,n.cost+G[n.to][i].cost/2,n.tick+1));
}
}
}
cout<<ret<<endl;
}
} | 0 |
#include <bits/stdc++.h>
char s[1010], t[1010];
int a[27] = {0}, b[27] = {0}, n, m, x, y, l;
int f(int k) {
int s = 0;
for (int i = 1; i <= 26; i++)
if (a[i]) {
s += a[i] / k;
if (a[i] % k) s++;
}
return s;
}
int main() {
scanf("%s", s);
l = strlen(s);
for (int i = 0; i < l; i++) a[s[i] - 96]++;
scanf("%d", &n);
x = 0;
for (int i = 1; i <= 26; i++)
if (a[i]) x++;
if (x > n) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= l; i++)
if (f(i) <= n) {
x = n - f(i);
printf("%d\n", i);
for (int j = 1; j <= 26; j++)
if (a[j]) {
y = a[j] / i;
if (a[j] % i) y++;
while (y--) printf("%c", j + 96);
}
while (x--) printf("z");
printf("\n");
return 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> divs[111111];
int is_pr[111111];
int is_on[111111];
int in_use[111111];
int n, m;
char data[1111];
int main() {
gets(data);
sscanf(data, "%d%d", &n, &m);
for (int i = 2; i <= n; ++i) {
is_pr[i] = 1;
}
for (int i = 2; i * i <= n; ++i) {
if (is_pr[i]) {
for (int j = i * i; j <= n; j += i) {
is_pr[j] = 0;
}
}
}
for (int i = 2; i <= n; ++i) {
if (is_pr[i]) {
for (int j = i; j <= n; j += i) {
divs[j].push_back(i);
}
}
}
for (int i = 0; i < m; ++i) {
gets(data);
char sym;
int val;
sscanf(data, "%c%d", &sym, &val);
if (sym == '+') {
if (in_use[val]) {
printf("Already on\n");
} else {
bool ok = 1;
for (int j = 0; j < (int)((divs[val]).size()); ++j) {
int divisor = divs[val][j];
if (is_on[divisor]) {
printf("Conflict with %d\n", is_on[divisor]);
ok = 0;
break;
}
}
if (ok) {
for (int j = 0; j < (int)((divs[val]).size()); ++j) {
int divisor = divs[val][j];
is_on[divisor] = val;
}
in_use[val] = 1;
printf("Success\n");
}
}
} else {
if (!in_use[val]) {
printf("Already off\n");
} else {
in_use[val] = 0;
for (int j = 0; j < (int)((divs[val]).size()); ++j) {
int divisor = divs[val][j];
is_on[divisor] = 0;
}
printf("Success\n");
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> v;
int row[1010] = {0}, col[1010] = {0};
char g[1010][1010];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> g[i][j];
if (g[i][j] == '*') row[i]++, col[j]++, v.push_back({i, j});
};
int mx_col = 0, mx_row = 0, max_covered = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (row[i] + col[j] - (g[i][j] == '*') > max_covered)
mx_row = i, mx_col = j,
max_covered = row[i] + col[j] - (g[i][j] == '*');
for (auto i : v)
if (i.first != mx_row && i.second != mx_col) {
cout << "NO";
return 0;
}
cout << "YES" << endl << mx_row + 1 << " " << mx_col + 1 << endl;
}
| 2 |
#include<bits/stdc++.h>
long long t,n,x,a,b,ans;
using namespace std;
int main()
{
cin>>n>>x>>a;
if(a>x)
{
ans+=a-x;
a=x;
}
for(int i=2;i<=n;i++)
{
cin>>b;
if(a+b>x)
{
t=a+b-x;
ans+=t;
b=b-t;
}
a=b;
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
long long a, b;
long long t = 0;
long long sum = 0;
cin >> a >> b;
while (b != 0) {
sum += a / b;
t = b;
b = a % b;
a = t;
}
cout << sum << endl;
return 0;
}
| 1 |
#define _USE_MATH_DEFINES
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<bitset>
#include<cassert>
#include<cctype>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<functional>
#include<limits>
#include<list>
#include<map>
#include<set>
#include<stack>
#include<string>
#include<sstream>
#include<queue>
#include<vector>
using namespace std;
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3fLL
#define EPS (1e-10)
#define equals(a,b) (fabs((a)-(b)) < EPS)
//0?¬?
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) :x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(a * x, a * y); }
Point operator/(double a) { return Point(x / a, y / a); }
bool operator<(const Point &p)const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p)const { return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS; }
double abs() { return sqrt(norm()); }
double norm() { return x*x + y*y; }
//Vector????????¢
Point rotate(double rad) { return Point(x*cos(rad) - y*sin(rad), x*sin(rad) + y*cos(rad)); }
};
inline ostream &operator << (ostream &os, const Point &p) { os << p.x << " " << p.y; return os; }
inline istream &operator >> (istream &is, Point &p) { double x, y; is >> x >> y; p = Point(x, y); return is; }
//1?¬?
typedef Point Vector;
class Segment {
public:
Point p1, p2;
Segment(Point p1 = Point(), Point p2 = Point(1, 1)) :p1(p1), p2(p2) {}
Vector vec() { return p2 - p1; }
};
typedef Segment Line;
//2?¬?
class Circle {
public:
Point c; //center
double r; //radius
Circle(Point c = Point(), double r = 0.0) :c(c), r(r) {}
};
typedef vector<Point> Polygon;
//?????? dot product
double dot(Vector a, Vector b) { return a.x*b.x + a.y*b.y; }
//?????? cross product
double cross(Vector a, Vector b) { return a.x*b.y - a.y*b.x; }
//????????¢??? radian ??? ??? degree
double rad(double deg) { return M_PI*deg / 180; }
//????§? argument
double arg(Vector p) { return atan2(p.y, p.x); }
//?\???¢??? polar form
Vector polar(double r, double a) { return Point(cos(a)*r, sin(a)*r); }
//??´?????????
bool isOrthogonal(Vector a, Vector b) { return equals(dot(a, b), 0.0); }
bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) { return isOrthogonal(a1 - a2, b1 - b2); }
bool isOrthogonal(Segment s1, Segment s2) { return equals(dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0); }
//????????????
bool isParallel(Vector a, Vector b) { return equals(cross(a, b), 0.0); }
bool isParallel(Point a1, Point a2, Point b1, Point b2) { return isParallel(a1 - a2, b1 - b2); }
bool isParallel(Segment s1, Segment s2) { return equals(cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0); }
//?°???±
Point project(Segment s, Point p) {
Vector base = s.p2 - s.p1;
double r = dot(p - s.p1, base) / base.norm();
return s.p1 + base*r;
}
//????°?
Point reflect(Segment s, Point p) { return p + (project(s, p) - p)*2.0; }
//??????(p0,p1)????????????p2???????????¢???
enum { ONLINE_FRONT = -2, CLOCKWISE, ON_SEGMENT, COUNTER_CLOCKWISE, ONLINE_BACK };
int ccw(Point p0, Point p1, Point p2) {
Vector a = p1 - p0, b = p2 - p0;
if (cross(a, b) > EPS)return COUNTER_CLOCKWISE;
if (cross(a, b) < -EPS)return CLOCKWISE;
if (dot(a, b) < -EPS)return ONLINE_BACK; //p2 p0 p1
if (a.norm() < b.norm())return ONLINE_FRONT; //p0 p1 p2
return ON_SEGMENT;
}
//??´?????¨??´??????????????????
bool intersect(Point p1, Point p2, Point p3, Point p4) {
return (ccw(p1, p2, p3)*ccw(p1, p2, p4) <= 0 &&
ccw(p3, p4, p1)*ccw(p3, p4, p2) <= 0);
}
bool intersect(Segment s1, Segment s2) { return intersect(s1.p1, s1.p2, s2.p1, s2.p2); }
//(?????????????¶????)
//2??????????????¢
double getDistance(Point a, Point b) { return (a - b).abs(); }
//??´?????¨???????????¢
double getDistanceLP(Line l, Point p) { return abs(cross(l.p2 - l.p1, p - l.p1) / (l.p2 - l.p1).abs()); }
//????????¨???????????¢
double getDistanceSP(Segment s, Point p) {
if (dot(s.p2 - s.p1, p - s.p1) < 0.0)return (p - s.p1).abs();
if (dot(s.p1 - s.p2, p - s.p2) < 0.0)return (p - s.p2).abs();
return getDistanceLP(s, p);
}
//????????¨??????????????¢
double getDistance(Segment s1, Segment s2) {
if (intersect(s1, s2))return 0.0;
return min(
min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)),
min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2))
);
}
//?????¨??´??????????????????
bool intersect(Circle c, Line l) { return getDistanceLP(l, c.c) <= c.r; }
//?????¨???????????????????????±?????\????????° 4???-1??????
int intersect(Circle c1, Circle c2) {
int d = getDistance(c1.c, c2.c);
if (d > c1.r + c2.r)return -1;//4
if (d == c1.r + c2.r)return 3;
if (d + c1.r == c2.r || d + c2.r == c1.r)return 1;
if (d + c1.r < c2.r || d + c2.r < c1.r)return 0;
return 2;
}
//????????¨???????????????
Point getCrossPoint(Segment s1, Segment s2) {
assert(intersect(s1, s2));
Vector base = s2.p2 - s2.p1;
double a1 = abs(cross(base, s1.p1 - s2.p1)); //area1
double a2 = abs(cross(base, s1.p2 - s2.p1)); //area2
double t = a1 / (a1 + a2);
return s1.p1 + (s1.p2 - s1.p1)*t;
}
//??´?????¨??´????????????
//Point getCrossPointLL(Line l1, Line l2) {}
//?????¨??´????????????
pair<Point, Point> getCrossPoints(Circle c, Line l) {
assert(intersect(c, l));
Vector pr = project(l, c.c);
Vector e = (l.p2 - l.p1) / (l.p2 - l.p1).abs();
double base = sqrt(c.r*c.r - (pr - c.c).norm());
return make_pair(pr + e*base, pr - e*base);
}
//?????¨????????????
pair<Point, Point> getCrossPoints(Circle c1, Circle c2) {
assert(intersect(c1, c2));
double d = (c1.c - c2.c).abs();
double a = acos((c1.r*c1.r + d*d - c2.r*c2.r) / (2 * c1.r*d));
double t = arg(c2.c - c1.c);
return make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a));
}
//????????????
enum { OUT = 0, ON, IN };
int contains(Polygon g, Point p) {
int n = g.size();
bool x = false;
for (int i = 0; i < n; i++) {
Point a = g[i] - p, b = g[(i + 1) % n] - p;
if (abs(cross(a, b)) < EPS&&dot(a, b) < EPS)return ON;
if (a.y > b.y)swap(a, b);
if (a.y < EPS&&EPS<b.y&&cross(a, b)>EPS)x = !x;
}
return (x ? IN : OUT);
}
//????§???¢?????¢???
double area(Polygon g) {
double a = 0;
for (size_t i = 0; i < g.size(); i++)
a += cross(g[i], g[(i + 1) % g.size()]);
return a / 2.0;
}
//?????§????????????????¨??????????
bool isConvex(Polygon g) {
for (int i = 0; i < g.size(); i++)
if (ccw(g[i], g[(i + 1) % g.size()], g[(i + 2) % g.size()]) == CLOCKWISE)
return false;
return true;
}
int main() {
Circle c1, c2;
cin >> c1.c >> c1.r >> c2.c >> c2.r;
cout << (intersect(c1, c2) == -1 ? 4 : intersect(c1, c2)) << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int nega = 1;
while (!isdigit(ch)) {
if (ch == '-') nega = -1;
ch = getchar();
}
int ans = 0;
while (isdigit(ch)) {
ans = ans * 10 + ch - 48;
ch = getchar();
}
if (nega == -1) return -ans;
return ans;
}
int fa[200005];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
signed main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) fa[i] = i;
int ans = 0;
for (int i = 1; i <= k; i++) {
int u = read(), v = read();
int fu = find(u), fv = find(v);
if (fu != fv)
fa[fu] = fv;
else
ans++;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10000010;
int pri[N], st[N];
long long f[N];
void init() {
int top = 0;
for (int i = 2; i < N; i++) {
if (!st[i]) pri[top++] = i, st[i] = i;
for (int j = 0; j < top && pri[j] * i < N; j++) {
st[pri[j] * i] = pri[j];
if (i % pri[j] == 0) break;
}
}
f[1] = 1;
for (int i = 2; i < N; i++) {
int t = st[i], j = i, s = 0;
while (j % t == 0) j /= t, s++;
f[i] = f[j];
if (s & 1) f[i] *= t;
}
for (int i = 2; i < N; i++) f[i] += f[i - 1];
}
int main() {
init();
int n, a;
cin >> a >> n;
cout << f[a + n - 1] - f[a - 1] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<bool> S(64), X(64);
uint64_t Sint, Xint;
cin >> Sint >> Xint;
for (uint64_t i = 0; i < 64; ++i) {
S[i] = (bool)(Sint & (1ULL << i));
X[i] = (bool)(Xint & (1ULL << i));
}
vector<bool> C(64);
for (int i = 0; i < 63; ++i) {
C[i] = S[i + 1] ^ X[i + 1];
}
C[63] = false;
for (int i = 1; i < 64; ++i) {
if (X[i] && C[i] != C[i - 1]) {
cout << 0 << endl;
return 0;
}
}
if (X[0] && C[0]) {
cout << 0 << endl;
return 0;
}
if (X[0] != S[0]) {
cout << 0 << endl;
return 0;
}
uint64_t NPossibs = 1;
for (int i = 0; i < 64; ++i) {
if (X[i]) {
NPossibs *= 2;
}
}
if (Sint == Xint) NPossibs -= 2;
cout << NPossibs << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
struct node {
int x, y;
} k[maxn];
int w[maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> w[i];
k[i].x = w[i];
}
sort(w + 1, w + n + 1);
for (int i = 1; i <= n; i++) {
int a = k[i].x;
k[i].y = lower_bound(w + 1, w + n + 1, a) - (w + 1);
}
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
if (k[a].x > k[b].x) {
k[a].y--;
}
if (k[a].x < k[b].x) {
k[b].y--;
}
}
for (int i = 1; i <= n; i++) {
cout << k[i].y << ' ';
}
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int n, dp[110][10007];
int solve(int pos, int s) {
if (pos == n) {
if (s & 1) return s;
return 0;
}
int &ret = dp[pos][s];
if (ret != -1) return ret;
int x = solve(pos + 1, a[pos] + s);
int y = solve(pos + 1, s);
return ret = max(x, y);
}
int main() {
while (cin >> n) {
for (__typeof((n)-1) i = (0); i <= (n)-1; ++i) cin >> a[i];
memset(dp, -1, sizeof dp);
int ans = solve(0, 0);
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000 * 1000 * 1000 + 7;
const int INF = 2000 * 1000 * 1000;
const double EPS = 1e-9;
const double pi = acos(-1.0);
template <typename T>
inline T sqr(T n) {
return (n * n);
}
struct st {
int x, num, col;
bool operator<(const st& s) const { return (x < s.x); }
};
bool cmp(const st& lhs, const st& rhs) { return lhs.num < rhs.num; }
st a[110];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].x);
a[i].num = i;
}
sort(a, a + n);
for (int i = 0; i < n; i++) a[i].col = i % 2;
sort(a, a + n, cmp);
for (int i = 0; i < n; i++) cout << a[i].col << ' ';
return 0;
}
| 1 |
#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
int main()
{
int q;
for(;cin>>q;)
{
for(;q--;)
{
int c,a,n;
int ans=0;
cin>>c>>a>>n;
while(n>0&&a>0&&c>0)
{
c--;a--;n--;
ans++;
}
while(a>0&&c>1)
{
c-=2;a--;
ans++;
}
while(c>2)
{
c-=3;
ans++;
}
cout<<ans<<endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
long long s;
cin >> n >> k >> s;
int pos = 1;
long long step = s / k, r = s - step * k;
if (step == 0 || (step == n - 1 && r > 0) || (step >= n)) {
cout << "NO";
return 0;
}
cout << "YES\n";
for (int i = 1; i <= k; i++) {
if (i <= r) {
if (pos == 1) {
pos += (step + 1);
cout << pos << " ";
} else {
pos = 1;
cout << pos << " ";
}
} else {
if (i % 2 == 1) {
pos += step;
cout << pos << " ";
} else {
pos -= step;
cout << pos << " ";
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, num=0;
cin >> N;
for(int i=1; i<N; ++i){
num += (N-1)/i;
}
cout << num <<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
namespace math {
template <typename T>
T gcd(T a, T b) {
if (a < 0) a = -a;
if (b < 0) b = -b;
while (b > 0) {
T r = a % b;
a = b;
b = r;
}
return a;
}
} // namespace math
template <typename C>
int SZ(const C& c) {
return (int)c.size();
}
template <size_t n, class... Types>
struct TupleHashHelper {
static std::size_t calc(const std::tuple<Types...>& t) {
using std::size_t;
std::hash<typename std::tuple_element<n - 1, std::tuple<Types...>>::type>
elemHash;
return elemHash(std::get<n - 1>(t)) +
31013 * TupleHashHelper<n - 1, Types...>::calc(t);
}
};
template <class... Types>
struct TupleHashHelper<0, Types...> {
static std::size_t calc(const std::tuple<Types...>&) { return 0; }
};
template <class... Types>
struct TupleHash {
std::size_t operator()(const std::tuple<Types...>& t) const {
static const size_t n = std::tuple_size<std::tuple<Types...>>::value;
return TupleHashHelper<n, Types...>::calc(t);
}
};
class Solution {
public:
void solve(std::istream& in, std::ostream& out) {
int n;
in >> n;
vector<int> x(n), y(n);
for (int i = 0; i < n; ++i) in >> x[i] >> y[i];
unordered_map<tuple<int, int, int>, set<int>, TupleHash<int, int, int>>
lines;
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) {
using math::gcd;
int a = y[j] - y[i], b = x[i] - x[j];
int c = -a * x[i] - b * y[i];
int d = gcd(gcd(a, b), c);
if (a < 0) {
a = -a;
b = -b;
c = -c;
} else if (a == 0 && b < 0) {
b = -b;
c = -c;
}
auto t = make_tuple(a / d, b / d, c / d);
lines[t].insert(i);
lines[t].insert(j);
}
long long res = (long long)n * (n - 1) * (n - 2) / 6;
for (const auto& p : lines) {
long long s = SZ(p.second);
res -= s * (s - 1) * (s - 2) / 6;
}
out << res << endl;
}
};
void solve(std::istream& in, std::ostream& out) {
out << std::setprecision(12);
Solution solution;
solution.solve(in, out);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
solve(in, out);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 250;
int a[maxn + 5], cnt[maxn * 10], mx, T, sum, flag, r, mn;
double S;
int main() {
int T;
scanf("%d", &T);
while (T--) {
mx = 0;
flag = 0;
mn = 2000;
S = 0;
memset(cnt, 0, sizeof cnt);
for (int i = 1; i <= maxn; i++) {
scanf("%d", &a[i]);
mx = max(mx, a[i]);
mn = min(mn, a[i]);
if (mx > 2000) break;
cnt[a[i]]++;
S += a[i];
}
if (mx > 2000) {
printf("%.0lf\n", S / maxn);
continue;
}
r = 0;
sum = cnt[0];
for (int l = 0; l <= mx / 2; l++) {
while (r < mx && r < l + mx / 2) sum += cnt[r++];
if (sum > 0.7 * maxn) {
flag = 1;
break;
}
sum -= cnt[l];
}
if (flag == 1)
printf("%.0lf\n", S / maxn);
else
printf("%.0lf\n", (mn + mx) / 2.0);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void bfs(vector<int> &S, int K) {
deque<int> Q;
Q.push_front(1);
while(!Q.empty()) {
int v = Q.front();
Q.pop_front();
int nv = v * 10 % K;
if(S[nv] > S[v]) {
S[nv] = S[v];
Q.push_front(nv);
}
nv = (v + 1) % K;
if(S[nv] > S[v] + 1) {
S[nv] = S[v] + 1;
Q.push_back(nv);
}
}
}
int main() {
int K;
cin >> K;
vector<int> S(K, 100100101);
S[1] = 1;
bfs(S, K);
cout << S[0] << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char s[5];
char op[5];
int main(){
int cnt;
scanf("%s",s);
for(int i=0;i<8;i++){
cnt=s[0]-'0';
for(int j=0;j<3;j++){
if(i&(1<<j)){
op[j]='+';
cnt+=s[j+1]-'0';
} else {
op[j]='-';
cnt-=s[j+1]-'0';
}
}
if(cnt==7){
printf("%c",s[0]);
for(int j=1;j<=3;j++)printf("%c%c",op[j-1],s[j]);
printf("=7\n");
return 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
template <typename _T>
void read(_T &x) {
_T f = 1;
x = 0;
char s = getchar();
while (s > '9' || s < '0') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = (x << 3) + (x << 1) + (s ^ 48);
s = getchar();
}
x *= f;
}
template <typename _T>
_T Fabs(_T x) {
return x < 0 ? -x : x;
}
long long n, sum[105], tot, a[105];
long long dp[105][105][105], b[105];
signed main() {
read(n);
tot = 1;
for (int i = 1; i <= n; i++) scanf("%1d", &b[i]);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 2; i <= n; i++)
for (int j = 1; j < i; j++) a[i] = max(a[j] + a[i - j], a[i]);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) sum[i] += (b[i] == b[j]);
for (int l = n; l > 0; l--)
for (int r = l; r <= n; r++) {
for (int i = l; i < r; i++)
if (b[r] == b[i])
for (int j = 0; j <= sum[r]; j++)
dp[l][r][j] =
max(dp[l][r][j], dp[i + 1][r - 1][0] + dp[l][i][j + 1]);
for (int i = 0; i <= sum[r]; i++)
dp[l][r][i] = max(dp[l][r][i], dp[l][r - 1][0] + a[i + 1]);
}
printf("%lld\n", dp[1][n][0]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
struct shark {
int l;
int r;
} sh[100005];
long double ans = 0;
int main() {
int l, r;
scanf("%d%d", &n, &p);
for (int i = 0; i < n; i++) {
scanf("%d%d", &l, &r);
sh[i].l = l;
sh[i].r = r;
}
if (n > 2) {
sh[n].l = sh[0].l;
sh[n].r = sh[0].r;
}
for (int i = 0; i < n; i++) {
long long cnt = 0;
if (sh[i].r >= p) {
int left = sh[i].l + p - sh[i].l % p;
if (sh[i].l % p == 0) {
left = sh[i].l;
}
int right = sh[i].r - sh[i].r % p;
if (left <= right) {
cnt = (right - left) / p;
cnt++;
} else
cnt = 0;
}
long long prob = sh[i].r - sh[i].l + 1;
long long cnt2 = 0;
if (sh[i + 1].r >= p) {
int left = sh[i + 1].l + p - sh[i + 1].l % p;
if (sh[i + 1].l % p == 0) {
left = sh[i + 1].l;
}
int right = sh[i + 1].r - sh[i + 1].r % p;
if (left <= right) {
cnt2 = (right - left) / p;
cnt2++;
} else
cnt2 = 0;
}
long long prob2 = sh[i + 1].r - sh[i + 1].l + 1;
if (cnt * prob2 + cnt2 * prob - (cnt * cnt2) > 0)
ans += (long double)(cnt * prob2 + cnt2 * prob - (cnt * cnt2)) /
(prob * prob2) * 2000;
}
cout << fixed << setprecision(7) << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
string vow = "AEIOUY";
string s;
int res = INT_MIN;
cin >> s;
for (int i = 0; i < s.length(); i++)
for (int j = 0; j < vow.length(); j++)
if (s[i] == vow[j]) v.push_back(i);
if (v.size() == 0)
res = s.length() + 1;
else {
res = v.front() + 1;
for (int i = 1; i < v.size(); i++) res = max(res, v[i] - v[i - 1]);
res = max(res, (int)s.length() - v.back());
}
cout << res << endl;
return 0;
}
| 1 |
//#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cmath>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <cstdlib>
#include <ctime>
#include <stack>
#include <iomanip>
#include <queue>
using namespace std;
typedef long long ll;
typedef int itn;
//min({a,b,c,d});
int a[100], b[100];
int main()
{
ll t;
cin >> t;
int n, mx, nm;
for (int _ = 0; _ < t; _++)
{
cin >> n;
for (int i = 0; i < n; i++)
{
cin >> a[i];
b[i] = a[i];
if (a[i] == 1)
nm = i;
if (a[i] == n)
mx = i;
}
if (nm == 0 && mx == n - 1)
{
sort(b, b + n);
bool x = true;
for (int i = 0; i < n && x; i++)
{
if (a[i] != b[i])
x = false;
}
if (x)
{
cout << 0 << endl;
}
else
{
cout << 1 << endl;
}
}
else if (nm == 0 || mx == n - 1)
{
cout << 1 << endl;
}
else if (nm == n - 1 && mx == 0)
{
cout << 3 << endl;
}
else
{
cout << 2 << endl;
}
}
return 0;
} | 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int INF = 2e9;
const int MOD = 1e9 + 7;
const int MB = 20;
vector<vector<pair<int, int>>> q;
vector<int> col;
void rec(int c1, int c2, int v, int u, int num) {
if (q[v][c1].first == -1) {
q[v][c1] = {u, num};
col[num] = c1;
return;
}
auto p = q[v][c1];
col[p.second] = c2;
q[v][c2] = p;
q[v][c1] = {u, num};
q[p.first][c1] = {-1, -1};
rec(c2, c1, p.first, v, p.second);
}
void solve() {
int a, b, m;
cin >> a >> b >> m;
int n = a + b;
vector<int> deg(n);
vector<pair<int, int>> edges(m);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
y += a;
edges[i] = {x, y};
deg[x]++;
deg[y]++;
}
int mx = *max_element(deg.begin(), deg.end());
col.resize(m);
q.resize(n, vector<pair<int, int>>(mx, {-1, -1}));
for (int i = 0; i < m; i++) {
int x = edges[i].first;
int y = edges[i].second;
int c1 = -1, c2 = -1;
for (int j = 0; j < mx; j++) {
if (q[x][j].first == -1 && q[y][j].first == -1) {
c1 = j;
c2 = j;
break;
}
if (q[x][j].first == -1) {
c1 = j;
}
if (q[y][j].first == -1) {
c2 = j;
}
}
if (c2 == c1) {
q[x][c1] = {y, i};
q[y][c1] = {x, i};
col[i] = c1;
continue;
}
col[i] = c1;
q[x][c1] = {y, i};
rec(c1, c2, y, x, i);
}
cout << mx << '\n';
for (int i : col) cout << (i + 1) << " ";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(12);
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int freq[10001], ar[10001];
int n, cnt, x;
int main() {
cin >> n;
cnt = 0;
for (int i = 1; i <= 100; i++) freq[i] = 0;
for (int i = 1; i <= n; i++) {
cin >> x;
if (freq[x] == 0) {
cnt++;
ar[cnt] = x;
}
freq[x]++;
}
if (cnt > 3)
cout << -1 << endl;
else {
for (int i = 1; i <= cnt - 1; i++) {
for (int j = i + 1; j <= cnt; j++) {
if (ar[i] > ar[j]) {
int temp = ar[i];
ar[i] = ar[j];
ar[j] = temp;
}
}
}
if (cnt == 1) cout << 0 << endl;
if (cnt == 2) {
int temp = (ar[1] + ar[2]) / 2;
if (2 * temp == ar[1] + ar[2])
cout << temp - ar[1] << endl;
else
cout << ar[2] - ar[1] << endl;
}
if (cnt == 3) {
if (2 * ar[2] == ar[1] + ar[3])
cout << ar[2] - ar[1] << endl;
else
cout << -1 << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a = 0, b = 0;
int m[200005];
cin >> n;
for (int i(0); i < n; i++) {
char c;
cin >> c;
if (c == 'D') {
m[i] = 1;
a++;
} else {
m[i] = 2;
b++;
}
}
int x = 0, y = 0;
while (true) {
for (int i(0); i < n; i++) {
if (m[i] == 1) {
if (y > 0) {
m[i] = 0;
y--;
a--;
} else
x++;
}
if (m[i] == 2) {
if (x > 0) {
m[i] = 0;
x--;
b--;
} else
y++;
}
}
if (a <= 0) {
cout << 'R';
return 0;
}
if (b <= 0) {
cout << 'D';
return 0;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int uni[100000],n,m,r[100000];
int find(int a){
if(a!=uni[a])a=find(uni[a]);
return a;
}
bool same(int a,int b){
return find(a)==find(b);
}
void unit(int a,int b){
int c=find(a),d=find(b);
if(r[c]>r[d])uni[d]=c;
else{uni[c]=d;
if(r[c]==r[d])r[c]++;
}
}
int main() {
cin>>n>>m;
for(int i=0;i<n;i++){uni[i]=i;r[i]=0;}
for(int i=0;i<m;i++){
int a,b,c;
cin>>c>>a>>b;
if(c)cout<<(same(a,b)?1:0)<<endl;
else unit(a,b);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k = 0, k1 = 0;
cin >> n;
int a[n + 10], b[n + 10];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
int k = 0;
for (int j = 1; j <= n; j++) {
if (abs(a[i] - a[j]) % 2 == 1) k++;
}
b[i] = k;
}
sort(b + 1, b + n + 1);
cout << b[1];
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void answer() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int done = 1;
for (int i = 1; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i] != a[j]) {
if (done) {
cout << "YES" << endl;
done = 0;
}
cout << i + 1 << " " << j + 1 << endl;
break;
}
}
}
if (done) {
cout << "NO" << endl;
}
}
int main() {
int test;
cin >> test;
while (test--) {
answer();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10, MOD = 1000 * 1000 * 1000 + 7,
INF = 2 * 1000 * 1000 * 1000;
const double EPS = 1e-9;
int val[11];
int len[11];
string queries[maxn];
int mul(int a, int b) { return ((long long)a * b) % MOD; }
int add(int a, int b) { return (a + b) % MOD; }
int fastPow(int a, int b) {
int ret = 1;
while (b != 0) {
if (b % 2 == 1) {
ret = mul(ret, a);
}
b /= 2;
a = mul(a, a);
}
return ret % MOD;
}
int main() {
for (int i = 0; i <= 9; i++) {
val[i] = i;
len[i] = 1;
}
string str;
cin >> str;
reverse(str.begin(), str.end());
int query;
cin >> query;
for (int i = 0; i < query; i++) {
cin >> queries[i];
}
for (int i = query - 1; i >= 0; i--) {
int digit = queries[i][0] - '0';
string nextStr = queries[i].substr(3);
reverse(nextStr.begin(), nextStr.end());
int nextVal = 0;
int sumLen = 0;
for (int j = 0; j < (int)((nextStr).size()); j++) {
int curDigit = nextStr[j] - '0';
nextVal = add(nextVal, mul(val[curDigit], fastPow(10, sumLen)));
sumLen = (sumLen + len[curDigit]) % (MOD - 1);
}
val[digit] = nextVal;
len[digit] = sumLen;
}
int ans = 0;
int sumLen = 0;
for (int i = 0; i < (int)((str).size()); i++) {
int curDigit = str[i] - '0';
ans = add(ans, mul(val[curDigit], fastPow(10, sumLen)));
sumLen = (sumLen + len[curDigit]) % (MOD - 1);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long dp[502][502];
int n, m, mod;
long long calc(int o, int z) {
if (o == 0 && z == 0) return 1;
if (dp[o][z] != -1) {
return dp[o][z];
}
long long ans = 0;
if (o > 0 && z > 0)
ans = (ans + (((calc(o, z - 1) * o) % mod) * z) % mod) % mod;
if (z > 1) ans = (ans + (calc(o + 2, z - 2) * (z * (z - 1) / 2)) % mod) % mod;
if (o > 1) ans = (ans + (calc(o - 2, z) * (o * (o - 1) / 2)) % mod) % mod;
return dp[o][z] = ans;
}
int main() {
char ch;
cin >> n >> m >> mod;
vector<int> v(n, 0);
for (int i = 0; i < 502; ++i)
for (int j = 0; j < 502; ++j) dp[i][j] = -1;
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
cin >> ch;
if (ch == '1') ++v[j];
}
}
int z = 0, o = 0;
for (int i = 0; i < n; ++i) {
if (v[i] == 0)
++z;
else if (v[i] == 1)
++o;
}
cout << calc(o, z) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d, n;
int a[2000];
int k = 0;
cin >> d >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) k += (0 - a[i - 1] + d) % d;
cout << k;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const int mo = 998244353;
struct str {
string s;
int hash = 0;
friend str& operator+=(str& a, const char& c) {
a.s += c;
a.hash = a.hash * 2 + (c - '0') % mo;
return a;
}
friend bool operator==(const str& a, const str& b) {
return a.hash == b.hash && a.s == b.s;
}
} s[N];
int a[N];
int main() {
int n;
scanf("%d", &n);
for (auto i = (1); i <= (n); ++i) scanf("%d", &a[i]);
for (auto i = (1); i <= (n); ++i) {
int x = -1;
for (auto j = (1); j <= (i - 1); ++j) s[i] += a[j] >= i ? '1' : '0';
for (auto j = (0); j <= (i - 1); ++j)
if (s[i] == s[j]) {
x = j;
break;
}
int cnt = min(a[i], i);
for (auto j = (i); j >= (0); --j) {
if (cnt && j != x)
--cnt, s[j] += '1';
else
s[j] += '0';
}
}
printf("%d\n", n + 1);
for (auto i = (0); i <= (n); ++i) printf("%s\n", s[i].s.c_str());
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.