solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int nm = 22;
const double eps = 1E-6;
const int mm = 1048577;
const double pi = 3.1415926535897932384626433832795;
int n;
double l, r, x[nm], y[nm], a[nm];
double f[mm];
void nhap() {
scanf("%d%lf%lf", &n, &l, &r);
int i;
for (i = 1; i <= n; ++i) {
scanf("%lf%lf%lf", &x[i], &y[i], &a[i]);
a[i] = a[i] * pi / 180.0;
}
}
int bit(int i, int j) { return ((i >> j) & 1); }
int batbit(int i, int j) { return ((1 << j) | i); }
double tinh(int i, int j) {
double goc1 = atan2(y[j], x[j] - f[i]);
double goc2 = pi - goc1;
if (fabs(a[j] - goc2) < eps || a[j] > goc2) return r;
double goc3 = goc2 - a[j];
double goc4 = pi - goc3;
if (fabs(goc4 - pi / 2.0) < eps) return x[j];
double a2 = -tan(goc4), c = a2 * x[j] + y[j];
if (c / a2 > r)
return r;
else
return c / a2;
}
void xuli() {
int i, j, last = (1 << n) - 1, i2;
for (i = 0; i <= last; ++i) f[i] = l;
for (i = 0; i < last; ++i) {
for (j = 0; j < n; ++j) {
if (!bit(i, j)) {
i2 = batbit(i, j);
f[i2] = max(f[i2], tinh(i, j + 1));
}
}
}
printf("%.7lf", f[i2] - l);
}
int main() {
nhap();
xuli();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int N = 3e5 + 50;
int t;
int n;
int st[N];
int ans = 0;
int main() {
cin >> t;
while (t--) {
cin >> n;
memset(st, 0, sizeof st);
ans = 0;
string belt;
cin >> belt;
int flag1 = 0;
int flag2 = 0;
for (int i = 0; i < n; i++) {
if (belt[i] == '-') {
if (!st[i]) st[i] = 1;
if (!st[(i + 1) % n]) st[(i + 1) % n] = 1;
} else if (belt[i] == '>')
flag1 = 1;
else
flag2 = 1;
}
if (flag1 && flag2) {
for (int i = 0; i < n; i++)
if (st[i]) ans++;
} else
ans = n;
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
multiset<long long> order;
for (int i = 0; i < n; ++i) {
long long a;
cin >> a;
order.insert(a);
}
long long add = 0, ans = -1e18;
while (order.size() > 1) {
long long cur = *order.begin() + add;
ans = max(ans, cur);
add -= cur;
order.erase(order.begin());
}
ans = max(ans, *order.begin() + add);
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt;
cin >> tt;
while (tt--) solve();
return 0;
}
| 3 |
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<iostream>
using namespace std;
/*
* mode0なら最小値、mode1なら最大値を返す。
*/
int getval(int mode, int* rep, int begin, int end) {
int result;
result = rep[begin];
for (int i = begin + 1; i < end; i++) {
if (mode == 0 && result > rep[i]) {
result = rep[i];
}
if (mode == 1 && result < rep[i]) {
result = rep[i];
}
}
return result;
}
int main() {
int size;
int a[1000];
int ans[1000];
cin >> size;
for (int i = 0; i < size; i++)cin >> a[i];
int querySize;
cin >> querySize;
int method;
int b, e;
for (int i = 0; i < querySize; i++) {
cin >> method >> b >> e;
ans[i] = getval(method, a, b, e);
}
for (int i = 0; i < querySize; i++) {
printf("%d\n", ans[i]);
}
// system("pause");
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;++i)
#define rrep(i,n) for(int i=n-1;i>0;--i)
#define yesno(flg) if(flg){cout<<"Yes"<<endl;}else{cout<<"No"<<endl;}
#define Vi vector<int>
#define Vl vector<long long>
#define pb(a) push_back(a)
using namespace std;
typedef long long ll;
const int inf=1000000000;
const int np=1000000007;
struct edge{
int myc,to,c,cost;
};
struct pos{
int to,cost,color;
};
int dy[]={0, 0, 1, -1};
int dx[]={1, -1, 0, 0};
int main() {
int n,x,y,z;
int a[101]={};
int b[101]={};
int c[101]={};
int a1,b1,c1;
cin>>n;
cin>>x;
rep(i,x){
cin>>a1;
a[a1]=1;
}
cin>>y;
rep(i,y){
cin>>b1;
b[b1]=1;
}
cin>>z;
rep(i,z){
cin>>c1;
c[c1]=1;
}
int total=0;
for(int i=1;i<n+1;++i){
if(c[i]>0&&(b[i]>0||a[i]==0))total++;
}
cout<<total<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
vector<string> start, End;
vector<vector<int> > dead, dist, graph, Rgraph, people, lab;
int n, T, V, s, t;
const int inf = 100000;
vector<int> parent;
bool BFS() {
bool visited[V];
for (int i = 0; i < V; ++i) visited[i] = 0;
queue<int> q;
q.push(s);
visited[s] = true;
parent[s] = -1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v = 0; v < V; v++) {
if (visited[v] == false && Rgraph[u][v] > 0) {
q.push(v);
parent[v] = u;
visited[v] = true;
}
}
}
return (visited[t] == true);
}
int fordFulkerson() {
int u, v;
parent.assign(V, -1);
int max_flow = 0;
while (BFS()) {
int path_flow = INT_MAX;
for (v = t; v != s; v = parent[v]) {
u = parent[v];
path_flow = min(path_flow, Rgraph[u][v]);
}
for (v = t; v != s; v = parent[v]) {
u = parent[v];
Rgraph[u][v] -= path_flow;
Rgraph[v][u] += path_flow;
}
max_flow += path_flow;
}
return max_flow;
}
void bfs(int r, int c) {
queue<pair<int, int> > q;
q.push(pair<int, int>(r, c));
dead[r][c] = 0;
while (!q.empty()) {
pair<int, int> x = q.front();
q.pop();
int a = x.first;
int b = x.second;
for (int i = 0; i < 4; ++i) {
int c = a + dx[i];
int d = b + dy[i];
if (c >= 0 && d >= 0 && c < n && d < n) {
if (start[c][d] != 'Z' && start[c][d] != 'Y' && dead[c][d] == inf) {
dead[c][d] = dead[a][b] + 1;
q.push(pair<int, int>(c, d));
}
}
}
}
}
void bfs2(int r, int p) {
int y, yy;
dist[r][p] = 0;
if (End[r][p] >= '1' && End[r][p] <= '9') {
graph[people[r][p]][lab[r][p]] = inf;
Rgraph[people[r][p]][lab[r][p]] = inf;
}
queue<pair<int, int> > q;
q.push(pair<int, int>(r, p));
while (!q.empty()) {
pair<int, int> x = q.front();
q.pop();
int a = x.first;
int b = x.second;
for (int i = 0; i < 4; ++i) {
int c = a + dx[i];
int d = b + dy[i];
if (c >= 0 && d >= 0 && c < n && d < n) {
if (dist[c][d] == inf && start[c][d] != 'Y' && start[c][d] != 'Z') {
dist[c][d] = dist[a][b] + 1;
if (dist[c][d] <= T && dist[c][d] <= dead[c][d]) {
if (dist[c][d] < dead[c][d]) q.push(pair<int, int>(c, d));
if (dist[c][d] <= dead[c][d] && End[c][d] >= '1' &&
End[c][d] <= '9') {
graph[people[r][p]][lab[c][d]] = inf;
Rgraph[people[r][p]][lab[c][d]] = inf;
}
}
}
}
}
}
}
int main() {
int i, j, k, l;
scanf("%d %d", &n, &T);
dead.assign(n, vector<int>(n, inf));
string ch;
for (i = 0; i < n; ++i) {
cin >> ch;
start.push_back(ch);
}
for (i = 0; i < n; ++i) {
cin >> ch;
End.push_back(ch);
}
people.assign(n, vector<int>(n, -1));
lab.assign(n, vector<int>(n, -1));
int cnt = 1;
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
if (start[i][j] >= '1' && start[i][j] <= '9') {
people[i][j] = cnt;
cnt++;
}
}
}
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
if (End[i][j] >= '1' && End[i][j] <= '9') {
lab[i][j] = cnt;
++cnt;
}
}
}
V = cnt + 1;
s = 0;
t = V - 1;
graph.assign(V, vector<int>(V, 0));
Rgraph.assign(V, vector<int>(V, 0));
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
if (start[i][j] >= '1' && start[i][j] <= '9') {
graph[s][people[i][j]] = start[i][j] - '0';
Rgraph[s][people[i][j]] = start[i][j] - '0';
}
if (End[i][j] >= '1' && End[i][j] <= '9') {
graph[lab[i][j]][t] = End[i][j] - '0';
Rgraph[lab[i][j]][t] = End[i][j] - '0';
}
}
}
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
if (start[i][j] == 'Z') {
bfs(i, j);
goto done;
}
}
}
done : {};
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
if (start[i][j] >= '1' && start[i][j] <= '9') {
dist.assign(n, vector<int>(n, inf));
bfs2(i, j);
}
}
}
cout << fordFulkerson();
}
| 5 |
#include <iostream>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
for(int i=0;i<1002;++i){
if(i*8/100==a && i/10==b){
cout<<i;
break;
}
else if(i==1001){
cout<<"-1";
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 10;
long long read() {
long long 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;
}
long long k, m, n;
long long x0, hhakioi, ax, ay, bx, by, x, y, t;
struct node {
long long x, y;
} a[maxn];
long long tot = 0;
signed main() {
x0 = read();
hhakioi = read();
ax = read();
ay = read();
bx = read();
by = read();
x = read();
y = read();
t = read();
long long now = 1;
for (;; now++) {
a[++tot] = (node){x0, hhakioi};
x0 = ax * x0 + bx;
hhakioi = ay * hhakioi + by;
if (x0 >= 2e16 || hhakioi >= 2e16) break;
}
long long ans = 0;
for (register long long i = 1; i <= tot; i++) {
for (register long long j = i; j <= tot; j++) {
long long min_ = abs(x - a[i].x) + abs(y - a[i].y) +
abs(a[j].x - a[i].x) + abs(a[j].y - a[i].y);
min_ = min(min_, abs(x - a[j].x) + abs(y - a[j].y) +
abs(a[j].x - a[i].x) + abs(a[j].y - a[i].y));
if (min_ <= t) ans = max(ans, j - i + 1);
}
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using db = double;
using vi = vector<int>;
const int inf = 0x3f3f3f3f;
const db eps = 1e-8;
const int mod = 1e9 + 7;
ll qpow(ll a, ll b) {
ll ret = 1;
while (b) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int n = s.size();
cout << "3\n";
cout << "L 2"
<< "\n";
cout << "R 2"
<< "\n";
cout << "R " << 2 * n - 1 << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
int head[N], nxt[N], w[N], to[N];
int cnt = 0;
void add_edge(int u, int v, int dis) {
to[cnt] = v;
w[cnt] = dis;
nxt[cnt] = head[v];
head[u] = cnt++;
}
int depth[100];
bool bfs() {
queue<int> q;
while (!q.empty()) {
q.pop();
}
memset(depth, 0, sizeof depth);
depth[1] = 1;
q.push(1);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = nxt[i]) {
if (w[i] > 0 && depth[to[i]] == 0) {
depth[to[i]] = depth[u] + 1;
q.push(to[i]);
}
}
}
if (depth[9] == 0) return 0;
return 1;
}
int dfs(int u, int flow) {
if (u == 9) {
return flow;
}
for (int i = head[u]; i != -1; i = nxt[i]) {
if (depth[u] + 1 == depth[to[i]] && (w[i] != 0)) {
int di = dfs(to[i], min(flow, w[i]));
if (di) {
w[i] -= di;
w[i ^ 1] += di;
return di;
}
}
}
return 0;
}
int n;
int Dinic() {
int ans = 0;
while (bfs()) {
int d = dfs(1, n);
while (d) {
ans += d;
d = dfs(1, n);
}
}
return ans;
}
int main() {
memset(head, -1, sizeof head);
cin >> n;
int a[3], b[3];
for (int i = 0; i < 3; i++) cin >> a[i];
for (int j = 0; j < 3; j++) cin >> b[j];
int num2 = min(a[0], b[1]) + min(a[1], b[2]) + min(a[2], b[0]);
int num = n;
num -= min(b[0], a[0] + a[1]);
num -= min(b[1], a[1] + a[2]);
num -= min(b[2], a[2] + a[0]);
cout << num << " " << num2 << endl;
return 0;
}
| 5 |
#include <sstream>
#include <fstream>
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <string>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <utility>
#include <cassert>
#include <bitset>
#define rep(i,x,n) for(int i=x;i<n;i++)
#define per(i,x,n) for(int i=n-1;i>=x;i--)
using namespace std;
#define ll long long
//head
int n, L;
int l, r, mid;
struct Bottle {
int up, down, val;
bool operator < (const Bottle a)const {
return val > a.val;
}
} a[100005];
ll b[100005], c[100005], sum[100005];
bool check(int x) {
x--;
rep(k, 1, n + 1) {
if(c[k] <= x)
continue;
ll p = L - a[k].up, go = 0;
if(k <= x && sum[x + 1] - a[k].val >= p)
return 1;
if(k > x && sum[x] >= p)
return 1;
}
return 0;
}
inline char gc() {
static char buf[1<<20], *head = buf, *tail = buf;
return (head == tail && (tail = (head = buf) + fread(buf, 1, 1 << 20, stdin), head == tail)? -1: *head++);
}
template <typename T> inline bool read(T &x) {
static bool f;
static char c;
for (c = gc(), f = false; !isdigit(c); c =gc()) {
if (c == EOF)
return false;
else if (c == 45)
f = true;
}
for (x = 0; isdigit(c); c = gc())
x = x * 10 + c - 48;
if (f)
x = -x;
return true;
}
int main() {
read(n);read(L);
rep(i, 1, n + 1)read(a[i].up),read(a[i].down),a[i].val = a[i].up - a[i].down;
rep(i, 1, n + 1)read(b[i]);
sort(a + 1, a + n + 1);
rep(i, 1, n + 1)sum[i] = sum[i - 1] + a[i].val;
ll cnt = 1, dis = 0;
rep(i, 2, n + 1) {
dis += (a[i].val - b[cnt]);
if(dis <= 0)
break;
cnt++;
}
c[1] = cnt;
int k = 2;
for(; k <= n; k++) {
if(cnt < k - 1 || cnt == n)
break;
dis += (a[k - 1].val - a[k].val);
while(dis > 0 && cnt < n)
cnt++, dis += (a[cnt + 1].val - b[cnt]);
c[k] = cnt;
}
for(; k <= n; k++)
c[k] = cnt;
int day = 1;
for(int i = 1; a[i].val > 0 && i <= n; i++, day++);
l = 1, r = day;
while(l < r) {
mid = (l + r) / 2;
if(check(mid))
r = mid;
else
l = mid + 1;
}
if(check(l))
cout << l << endl;
else
cout << -1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long l, r;
cin >> l >> r;
long long q = (r - l + 1) / 2;
vector<long long> v;
long long a = l;
cout << "YES\n";
for (int i = 0; i < q; i++) {
cout << a << " " << a + 1 << endl;
a += 2;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int n, a, b, c, t[200015];
int main() {
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i <= n; ++i) scanf("%d", &t[i]);
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (t[i] == 1) {
if (a)
--a;
else if (b)
--b, ++c;
else if (c)
--c;
else
++ans;
} else {
if (b)
--b;
else
ans += 2;
}
}
printf("%d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 202;
int n, m;
int from[SIZE * SIZE], to[SIZE * SIZE], cst[SIZE * SIZE], mat[SIZE][SIZE];
void floyd() {
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
mat[i][j] = mat[j][i] = min(mat[i][j], mat[i][k] + mat[k][j]);
}
int main() {
for (int i = 0; i < SIZE; i++) {
fill(mat[i], mat[i] + SIZE, 1 << 28);
mat[i][i] = 0;
}
scanf("%d%d", &n, &m);
int a, b, c;
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &a, &b, &c);
--a, --b, c *= 2;
mat[a][b] = mat[b][a] = c;
from[i] = a, to[i] = b, cst[i] = c;
}
floyd();
int mn = 1 << 28;
for (int k = 0; k < m; k++) {
map<int, vector<int> > ev;
set<pair<int, int> > lf, rt;
int len = cst[k];
for (int i = 0; i < n; i++) {
int a = mat[i][from[k]], b = mat[i][to[k]];
int x = (b + len - a) / 2;
if (x > 0 && x <= len) ev[x].push_back(i);
if (a < b + len)
lf.insert(make_pair((a), (i)));
else
rt.insert(make_pair((b), (i)));
}
ev[0];
for (auto it = (ev).begin(); (it) != ev.end(); ++(it)) {
vector<int> &v = it->second;
for (int l = 0; l < ((int)(v).size()); l++) {
int i = v[l];
int a = mat[i][from[k]], b = mat[i][to[k]];
lf.erase(make_pair((a), (i)));
rt.insert(make_pair((b), (i)));
}
int x1 = 0, x2 = 0;
if (((int)(lf).size())) x1 = lf.rbegin()->first;
if (((int)(rt).size())) x2 = rt.rbegin()->first;
int ps = (x1 + x2 + len) / 2 - x1;
if (ps > len || ps < 0) continue;
mn = min(mn, max(x1 + ps, x2 + len - ps));
}
}
printf("%.1lf\n", mn / 2.0);
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int N;
ll A[200010],X[200010];
ll mem[200010];
ll MAX[200010];
ll aa[200010],bb[200010];
ll ans = 0;
int main()
{
scanf("%d",&N);
for(int i = 1; i <= N; i++)
{
scanf("%lld%lld",X + i,A + i);
A[i] += A[i - 1];
}
for(int i = 1; i <= N; i++)aa[i] = A[i] - X[i];
for(int i = 1; i <= N; i++)bb[i] = A[i - 1] - X[i];
ll mm = -1001001001001001001;
for(int i = N; i > 0; i--)
{
mm = max(mm,aa[i]);
MAX[i] = mm;
}
for(int i = 1; i <= N; i++)
{
ans = max(ans,MAX[i] - bb[i]);
}
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < v.size(); i++) os << v[i] << " ";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
for (typename set<T>::iterator it = v.begin(); it != v.end(); it++)
os << *it << " ";
}
const double eps = 1e-9;
const int mod = 1e9 + 7;
const int N = 1e6 + 5;
int sgn(double a) { return a < -eps ? -1 : a < eps ? 0 : 1; }
int gi() {
int w = 0;
bool q = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') q = 0, c = getchar();
while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
return q ? w : -w;
}
int A[N], B[N];
int main() {
int n = gi();
for (int i = (1); i <= (n); i++) {
A[i] = gi(), B[i] = gi();
}
long long ans = n;
sort(A + 1, A + n + 1);
sort(B + 1, B + n + 1);
for (int i = (1); i <= (n); i++) {
ans += max(A[i], B[i]);
}
cout << ans;
return 0;
}
| 4 |
#include<iostream>
using namespace std;
int main()
{
int n;
cin>>n;
int a[5][4][11]={0};
int b,f,r,v;
for(int i=0;i<n;i++)
{
cin>>b>>f>>r>>v;
a[b][f][r]+=v;
}
for(int i=1;i<=4;i++)
{
for(int j=1;j<=3;j++)
{
for(int k=1;k<=10;k++)
{
cout<<" "<<a[i][j][k];
}
cout<<endl;
}
if(i!=4)cout<<"####################"<<endl;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
const int N=1000005;
int n,a[N],cnt[3],b[3],c[3],pre[N],nxt[N];char s[N];vector<int>V;
inline bool cmp(int x,int y){return cnt[x]<cnt[y];}
inline void del(int x){pre[nxt[x]]=pre[x];nxt[pre[x]]=nxt[x];cnt[a[x]]--;}
int main()
{
scanf("%s",s+1);n=strlen(s+1);a[0]=a[n+1]=-1;
for(int i=0;i<=n;i++)pre[i+1]=i,nxt[i]=i+1;
for(int i=1;i<=n;i++)cnt[a[i]=s[i]-'A']++;
for(int i=1;i<=n;i++)if(a[i]==a[i-1])del(i);
c[0]=0;c[1]=1;c[2]=2;sort(c,c+3,cmp);
b[c[0]]=0;b[c[1]]=1;b[c[2]]=2;V.clear();
for(int i=nxt[0];i!=n+1;i=nxt[i])if(a[i]==c[2]&&a[pre[i]]!=a[nxt[i]])V.push_back(i);
for(int i=0;i<V.size()&&cnt[c[2]]>cnt[c[1]];i++)del(V[i]);V.clear();
for(int i=nxt[0];i!=n+1;i=nxt[i])if(a[i]==c[2]&&a[pre[i]]==c[0]&&a[nxt[i]]==c[0])V.push_back(i);
for(int i=0;i<V.size()&&cnt[c[2]]>cnt[c[1]];i++)del(V[i]),del(nxt[V[i]]);
V.clear();for(int i=nxt[0];i!=n+1;i=nxt[i])if(a[i]==c[2]&&a[nxt[i]]==c[1])V.push_back(i);
for(int i=0;i<V.size()&&cnt[c[1]]>cnt[c[0]];i++)if(a[pre[V[i]]]!=c[0]||a[nxt[nxt[V[i]]]]!=c[0])del(V[i]),del(nxt[V[i]]);
V.clear();for(int i=nxt[0];i!=n+1;i=nxt[i])if(a[i]==c[2]&&a[pre[i]]==c[1])V.push_back(i);
for(int i=0;i<V.size()&&cnt[c[1]]>cnt[c[0]];i++)if(a[nxt[V[i]]]!=c[0]||a[pre[pre[V[i]]]]!=c[0])del(V[i]),del(pre[V[i]]);
if(cnt[0]==cnt[1]&&cnt[0]==cnt[2])for(int i=nxt[0];i!=n+1;i=nxt[i])putchar('A'+a[i]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
vector<long long> fact, ifact, invs;
long long combmod(int n, int k, long long MOD, int M = 1e5) {
if (!fact.size()) {
fact.resize(M + 1);
ifact.resize(M + 1);
invs.resize(M + 1);
fact[0] = ifact[0] = invs[0] = fact[1] = ifact[1] = invs[1] = 1;
for (int i = 2; i <= M; i++) {
fact[i] = fact[i - 1] * i % MOD;
invs[i] = MOD - MOD / i * invs[MOD % i] % MOD;
ifact[i] = ifact[i - 1] * invs[i] % MOD;
}
}
return fact[n] * ifact[k] % MOD * ifact[n - k] % MOD;
}
int main(int argc, char** argv) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(15);
if (argc == 2 && atoi(argv[1]) == 123456789) {
freopen("d:\\code\\cpp\\contests\\stdin", "r", stdin);
}
combmod(1, 1, MOD, 1e2);
long long D;
cin >> D;
vector<long long> ps;
long long p = 2;
while (p * p <= D) {
int e = 0;
if (D % p == 0) ps.push_back(p);
while (D % p == 0) {
e++;
D /= p;
}
p++;
}
if (D > 1) ps.push_back(D);
int q;
cin >> q;
for (int(i) = 0; (i) < (q); (i)++) {
long long u, v;
cin >> u >> v;
int a[100] = {}, b[100] = {};
for (int k = 0; k < ps.size(); k++) {
while (u % ps[k] == 0) {
u /= ps[k];
a[k]++;
}
while (v % ps[k] == 0) {
v /= ps[k];
b[k]++;
}
}
long long sol = 1;
int s1 = 0, s2 = 0;
for (int k = 0; k < ps.size(); k++) {
int g = min(a[k], b[k]);
s1 += a[k] - g;
s2 += b[k] - g;
sol *= ifact[a[k] - g];
sol %= MOD;
sol *= ifact[b[k] - g];
sol %= MOD;
}
sol *= fact[s1];
sol %= MOD;
sol *= fact[s2];
sol %= MOD;
cout << sol << endl;
}
if (argc == 2 && atoi(argv[1]) == 123456789)
cout << clock() * 1.0 / CLOCKS_PER_SEC << " sec\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int res[1000005], p[1000005];
void solve() {
long long int n, t;
cin >> n;
set<long long int> s;
for (long long int i = 1; i <= n; i++) cin >> p[i];
cin >> t;
for (long long int i = 0; i < t; i++) {
long long int x;
cin >> x;
s.insert(x);
}
stack<pair<long long int, long long int> > st;
for (long long int i = n; i >= 1; i--)
if (st.empty() || st.top().first != p[i] || s.find(i) != s.end())
st.push({p[i], i});
else {
res[i] = p[i];
res[st.top().second] = (-p[i]);
st.pop();
}
if (!st.empty()) {
cout << "NO";
exit(0);
}
cout << "YES\n";
for (long long int i = 1; i <= n; i++) cout << res[i] << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int qc = 1;
for (long long int i = 1; i <= qc; i++) solve();
}
| 5 |
#include<iostream>
#include <algorithm>
using namespace std;
int main(){
while(true){
int n;
int m=10000000;
cin>>n;
if(n==0)break;
int s[n];
for(int i=0;i<n;i++){
cin>>s[i];
}
sort(s,s+n);
for(int i=0;i<n-1;i++){
if(s[i+1]-s[i]<m){
m=s[i+1]-s[i];
}
}
cout<<m<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 1000 + 10, LG = 20;
int par[N][LG], h[N];
int lca(int v, int u) {
if (h[v] < h[u]) swap(v, u);
for (int i = 0; i < LG; i++)
if ((1 << i) & (h[v] - h[u])) v = par[v][i];
if (v == u) return v;
for (int i = LG - 1; i >= 0; i--)
if (par[v][i] != par[u][i]) v = par[v][i], u = par[u][i];
return par[v][0];
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n = 4;
h[2] = h[3] = h[4] = 1;
par[2][0] = par[3][0] = par[4][0] = 1;
int Q;
cin >> Q;
int ans = 2, mx = 1;
while (Q--) {
int p;
cin >> p;
for (auto v : {n + 1, n + 2}) {
par[v][0] = p;
h[v] = h[p] + 1;
for (int i = 1; i < LG; i++) par[v][i] = par[par[v][i - 1]][i - 1];
}
if (h[n + 1] > h[mx])
mx = n + 1, ans++;
else
ans = max(ans, h[n + 1] + h[mx] - 2 * h[lca(n + 1, mx)]);
cout << ans << '\n';
n += 2;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const long long int mrx = 1e6 + 5, M = 1e9 + 7;
long long int mx = INT_MIN, mn = INT_MAX;
using namespace std;
long long int x1, x2, s, t1, t2, p, d;
long long int poezd, igor;
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cin >> s >> x1 >> x2;
cin >> t1 >> t2;
cin >> p >> d;
if (t2 <= t1) {
cout << abs(x1 - x2) * t2;
return 0;
} else {
if (d == 1) {
if (x1 < x2) {
if (p == x1) {
cout << (x2 - x1) * t1;
} else if (p < x1) {
cout << min((x2 - x1) * t2, (x2 - p) * t1);
} else {
cout << min((x2 - x1) * t2, (s - p) * t1 + s * t1 + x2 * t1);
}
} else {
cout << min((x1 - x2) * t2, (s - p) * t1 + (s - x2) * t1);
}
}
if (d == -1) {
if (x1 < x2) {
cout << min((x2 - x1) * t2, p * t1 + x2 * t1);
} else {
if (p == x1) {
cout << (x1 - x2) * t1;
} else if (p < x1) {
cout << min((x1 - x2) * t2, p * t1 + s * t1 + (s - x2) * t1);
} else {
cout << min((x1 - x2) * t2, (p - x2) * t1);
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-9;
template <class T>
bool INRANGE(T x, T a, T b) {
return a <= x && x <= b;
}
template <class T>
void amin(T &a, T v) {
if (a > v) a = v;
}
template <class T>
void amax(T &a, T v) {
if (a < v) a = v;
}
int ROUND(double x) { return (int)(x + 0.5); }
bool ISINT(double x) { return fabs(ROUND(x) - x) <= EPS; }
bool ISEQUAL(double x, double y) {
return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y)));
}
double SQSUM(double x, double y) { return x * x + y * y; }
int main() {
int a, b, c;
cin >> a >> b >> c;
int ans = min(a + c + b, a + c + c + a);
amin(ans, b + c + c + b);
amin(ans, a + a + b + b);
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 1;
int n, m, x, y, c, canw, w[MAXN], b[MAXN], dp[MAXN][MAXN];
bool vis[MAXN];
vector<int> G[MAXN];
vector<int> comps[MAXN];
void dfs(int cur, int c) {
comps[c].push_back(cur);
vis[cur] = true;
for (int i = 0; i < G[cur].size(); i++)
if (!vis[G[cur][i]]) dfs(G[cur][i], c);
}
int rec(int idx, int remainW) {
if (idx == c) return 0;
int& ans = dp[idx][remainW];
if (ans != -1) return ans;
ans = rec(idx + 1, remainW);
int totalW = 0, totalB = 0;
for (int i = 0; i < comps[idx].size(); i++) {
if (remainW >= w[comps[idx][i]])
ans =
max(ans, b[comps[idx][i]] + rec(idx + 1, remainW - w[comps[idx][i]]));
totalW += w[comps[idx][i]];
totalB += b[comps[idx][i]];
}
if (remainW >= totalW)
ans = max(ans, totalB + rec(idx + 1, remainW - totalW));
return ans;
}
int solve() {
for (int i = 0; i < n; i++)
if (!vis[i]) dfs(i, c++);
memset(dp, -1, sizeof(dp));
return rec(0, canw);
}
int main() {
scanf("%d %d %d", &n, &m, &canw);
for (int i = 0; i < n; i++) scanf("%d", &w[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
for (int i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
x--, y--;
G[x].push_back(y);
G[y].push_back(x);
}
printf("%d\n", solve());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, p;
long long dp[30][300000];
long long f[300000], finv[300000];
inline long long qpow(long long a, long long b, long long p) {
long long k = 1;
while (b) {
if (b & 1) k = k * a % p;
a = a * a % p;
b >>= 1;
}
return k;
}
long long num, is[30];
inline long long getdp(long long i, long long j) {
if (i == 0 && j != 0) return 0;
if (dp[i][j] != -1) return dp[i][j];
dp[i][j] = 0;
__int128 res = 0;
for (long long u = j;; u = (u - 1) & j) {
res += getdp(i - 1, u) * finv[j - u];
if (u == 0) break;
}
res %= p;
dp[i][j] = res;
return dp[i][j];
}
signed main() {
ios::sync_with_stdio(false);
cin >> n >> k >> p;
if (n % 2 == 1) cout << qpow(k, n, p), exit(0);
f[0] = finv[0] = 1;
for (long long i = 1; i <= 250000; i++) f[i] = f[i - 1] * i % p;
finv[250000] = qpow(f[250000], p - 2, p);
for (long long i = 250000 - 1; i >= 1; i--)
finv[i] = finv[i + 1] * (i + 1) % p;
memset(dp, -1, sizeof(dp));
dp[0][0] = 1;
cout << (qpow(k, n, p) - getdp(k, n) * f[n] % p + p) % p;
cerr << endl << 1.0 * clock() / CLOCKS_PER_SEC;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1099;
long long n, t, k1, k2, mark[N], x, v, ans, mark2[N], y;
vector<int> g[N];
int dfs(int x, int par) {
if (mark[x] == 1) {
ans = x;
return 0;
}
for (long long i = 0; i < g[x].size(); i++) {
if (g[x][i] != par) dfs(g[x][i], x);
}
}
int main() {
cin >> t;
for (long long pop = 0; pop < t; pop++) {
for (long long i = 0; i < n + 1; i++) {
mark[i] = 0, mark2[i] = 0;
g[i].clear();
}
cin >> n;
for (long long i = 1; i < n; i++) {
cin >> x >> y;
g[y].push_back(x);
g[x].push_back(y);
}
cin >> k1;
for (long long i = 0; i < k1; i++) {
cin >> x;
mark[x] = 1;
}
cin >> k2;
for (long long i = 0; i < k2; i++) {
cin >> x;
mark2[x] = 1;
}
cout << "B " << x << endl;
cin >> v;
ans = 0;
dfs(v, 0);
cout << "A " << ans << endl;
cin >> v;
if (mark2[v] == 1)
cout << "C " << ans << endl;
else
cout << "C " << -1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
int a[1000010];
int main() {
int i, j, k, n;
for (scanf("%d", &n), k = 0, i = 0; i < n; scanf("%d", &j), k += j == 2, i++)
;
if (n == 1) {
printf("1\n");
return 0;
}
if (k > n - 2) k = n - 2;
for (a[1] = 1, a[2] = 2, i = 3; i <= n; i++)
a[i] = (a[i - 1] + (long long)a[i - 2] * (i - 1)) % 1000000007;
for (i = n - k; i < n; i++) a[i + 1] = (long long)a[i] * (i + 1) % 1000000007;
printf("%d\n", a[n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
template <class T1, class T2>
using p = pair<T1, T2>;
template <class T1, class T2>
using m = vector<pair<T1, T2>>;
template <class T>
using vv = vector<vector<T>>;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &t) {
os << "{";
for (int(i) = 0; (i) < (t.size()); ++(i)) {
os << t[i] << ",";
}
os << "}" << endl;
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
template <class T>
inline bool MX(T &l, const T &r) {
return l < r ? l = r, 1 : 0;
}
template <class T>
inline bool MN(T &l, const T &r) {
return l > r ? l = r, 1 : 0;
}
vector<string> s_p_l_i_t(const string &s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void e_r_r(vector<string>::iterator it) {}
template <typename T, typename... Args>
void e_r_r(vector<string>::iterator it, T a, Args... args) {
if (*it == " 1" || *it == "1")
cerr << endl;
else
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << ", ";
e_r_r(++it, args...);
}
const long long MOD = 1e9 + 7;
bool cmp(pair<long long, long long> &a, pair<long long, long long> &b) {
return a.first < b.first;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long n, curmax = 0;
cin >> n;
vector<long long> x(n), res(n);
for (long long int i = 0; i < n; i++) cin >> x[i];
for (long long i = n - 1; i >= 0; i--) {
if (curmax < x[i])
res[i] = 0;
else
res[i] = curmax - x[i] + 1;
curmax = max(curmax, x[i]);
}
for (long long int i = 0; i < n; i++) cout << res[i] << " ";
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int a,b,c,tot,ans;
int main(void){
cin>>a>>b;
for(int i=0;i<a;i++){
cin>>c;
tot+=c;
if(tot<=b)ans+=1;
}
cout<<ans+1<<endl;
}
| 0 |
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
const int mod = 1000000007;
long long modpow(long long n, int k) {
long long r = 1;
while (k > 0) {
if (k & 1) r = (r * n) % mod;
n = (n * n) % mod;
k >>= 1;
}
return r;
}
int main() {
int N, K;
cin >> N >> K;
vector<int> D;
for (int i = 1; i*i <= N; ++i) if (N % i == 0) {
D.push_back(i);
if (N/i > i) D.push_back(N/i);
}
sort(D.begin(), D.end());
map<int, int> num;
long long res = 0;
for (int i = 0; i < D.size(); ++i) {
int d = D[i];
long long r = modpow(K, (d + 1) / 2);
for (int j = 0; j < i; ++j) if (d % D[j] == 0) {
r = (r - num[D[j]] + mod) % mod;
}
num[d] = r;
if (d % 2) {
res = (res + r * d) % mod;
} else {
res = (res + r * (d / 2)) % mod;
}
}
cout << res << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e5;
void solve() {
int n;
string s, ss;
cin >> n >> ss;
s = ss;
vector<int> h;
for (int i = 0; i < n; i++) {
if (ss[i] == 'H') h.push_back(i);
}
int ans = inf;
for (int start = 0; start < n; start++) {
int ed = (start + (int)h.size()) % n, tmp = 0;
vector<bool> a(n, false);
for (int i = start; i != ed; i = (i + 1) % n) {
a[i] = true;
}
for (auto e : h) {
if (!a[e]) tmp++;
}
ans = min(ans, tmp);
}
cout << ans << endl;
return;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[5005], b[5005], c[5005];
double m[102][102];
int main() {
int n, e, deg = 0;
scanf("%d%d", &n, &e);
for (int i = 0; i < e; ++i) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
--a[i];
--b[i];
}
for (int i = 1; i < n - 1; ++i) {
for (int j = 0; j < e; ++j) {
if (a[j] == i) {
m[i - 1][b[j]] += 1;
m[i - 1][a[j]] -= 1;
}
if (b[j] == i) {
m[i - 1][b[j]] -= 1;
m[i - 1][a[j]] += 1;
}
}
}
const double eps = 1e-8;
for (int i = 0; i < n - 2; ++i) {
int ind = -1;
for (int j = i; j < n - 2; ++j)
if (fabs(m[j][i + 1]) > eps) {
ind = j;
break;
}
if (ind == -1) {
continue;
}
for (int j = 0; j < n; ++j) swap(m[i][j], m[ind][j]);
double a = m[i][i + 1];
for (int j = i + 1; j < n; ++j) m[i][j] /= a;
for (int j = i + 1; j < n - 2; ++j) {
double coef = -m[j][i + 1];
for (int t = i + 1; t < n; ++t) m[j][t] += m[i][t] * coef;
}
}
for (int i = n - 3; i >= 0; --i) {
for (int j = i - 1; j >= 0; --j) {
double coef = -m[j][i + 1];
for (int t = i + 1; t < n; ++t) m[j][t] += m[i][t] * coef;
}
}
m[n - 2][n - 2] = 1;
m[n - 2][n - 1] = -1;
double l = 0, r = 1e+9;
for (int i = 0; i < e; ++i) {
if ((a[i] ? m[a[i] - 1][n - 1] : 0) - (b[i] ? m[b[i] - 1][n - 1] : 0) >
eps) {
r = min(r, c[i] / ((a[i] ? m[a[i] - 1][n - 1] : 0) -
(b[i] ? m[b[i] - 1][n - 1] : 0)));
l = max(l, -c[i] / ((a[i] ? m[a[i] - 1][n - 1] : 0) -
(b[i] ? m[b[i] - 1][n - 1] : 0)));
}
if ((a[i] ? m[a[i] - 1][n - 1] : 0) - (b[i] ? m[b[i] - 1][n - 1] : 0) <
-eps) {
l = max(l, c[i] / ((a[i] ? m[a[i] - 1][n - 1] : 0) -
(b[i] ? m[b[i] - 1][n - 1] : 0)));
r = min(r, -c[i] / ((a[i] ? m[a[i] - 1][n - 1] : 0) -
(b[i] ? m[b[i] - 1][n - 1] : 0)));
}
}
if (l - eps > r) r = 0;
double ans = 0;
for (int i = 0; i < e; ++i) {
if (b[i] == n - 1)
ans += r * ((a[i] ? m[a[i] - 1][n - 1] : 0) -
(b[i] ? m[b[i] - 1][n - 1] : 0));
if (a[i] == n - 1)
ans -= r * ((a[i] ? m[a[i] - 1][n - 1] : 0) -
(b[i] ? m[b[i] - 1][n - 1] : 0));
}
printf("%.8lf\n", ans);
for (int i = 0; i < e; ++i) {
printf("%.8lf\n", r * ((a[i] ? m[a[i] - 1][n - 1] : 0) -
(b[i] ? m[b[i] - 1][n - 1] : 0)));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ABS(int a) {
if (a < 0) a = -a;
return a;
}
int nod(int a, int b) {
if (0 == a) return b;
if (0 == b) return a;
if (a == b) return a;
return nod(a % b, b % a);
}
int main() {
int n;
static int x[100010];
int i, j;
int a, b;
int *p;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &x[i]);
}
scanf("%d%d", &a, &b);
sort(x, x + n);
p = unique(x, x + n);
n = p - x;
int last = n - 1;
int go = 1;
int r = 0;
while (a > b) {
while (last >= 0 && a - a % x[last] < b) last--;
go = 1;
for (j = last; j >= 0; j--) {
if (x[j] <= go) break;
if (a - go > a - a % x[j] && a - a % x[j] >= b) {
go = a % x[j];
}
}
a -= go;
r++;
}
cout << r << endl;
return 0;
}
| 5 |
#include<iostream>
using namespace std;
int main()
{
int a,b;
cin>>a>>b;
if(a+b==15)cout<<"+"<<endl;
else if(a*b==15)cout<<"*"<<endl;
else cout<<"x"<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char temple[110][110];
vector<pair<int, int> > res;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
cin >> temple[i][j];
}
}
for (int i = 1; i <= n; ++i) {
bool found = false;
for (int j = 1; j <= n; ++j) {
if (temple[i][j] != 'E') {
res.push_back(make_pair(i, j));
found = true;
break;
}
}
if (!found) {
res.clear();
break;
}
}
if (res.size() == 0) {
for (int j = 1; j <= n; ++j) {
bool found = false;
for (int i = 1; i <= n; ++i) {
if (temple[i][j] != 'E') {
res.push_back(make_pair(i, j));
found = true;
break;
}
}
if (!found) {
res.clear();
break;
}
}
}
if (res.size() == 0) {
cout << -1 << endl;
} else {
for (int i = 0; i < res.size(); ++i) {
cout << res[i].first << " " << res[i].second << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long m, s;
};
const int maxn = 100000 + 10;
node p[maxn];
long long sum[maxn];
int n;
long long d;
bool cmp(const node &a, const node &b) { return a.m < b.m; }
int main() {
cin >> n >> d;
for (int i = 1; i <= n; i++) cin >> p[i].m >> p[i].s;
sort(p + 1, p + 1 + n, cmp);
p[n + 1].m = 1000000000 + 10;
sum[0] = 0;
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + p[i].s;
long long ans = -1;
for (int i = 1; i <= n; i++) {
int l = i + 1;
int r = n + 1;
int pos = i + 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (p[mid].m >= p[i].m + d) {
pos = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
if (sum[pos - 1] - sum[i - 1] > ans) ans = sum[pos - 1] - sum[i - 1];
}
cout << ans << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int n,m,k;
char grid[1000][1000];
int steps[1000][1000];
queue<pair<int,int> > q;
int dx[4]={0,1,0,-1};
int dy[4]={1,0,-1,0};
bool ok(int i,int j){
return i>=0&&i<n&&j>=0&&j<m;
}
void BFS(int x,int y){
memset(steps,0x3f,sizeof(steps));
q.push(make_pair(x,y));
steps[x][y]=0;
while(!q.empty()){
pair<int,int> cur=q.front();
q.pop();
for(int i=0;i<4;i++){
int nx=cur.first+dx[i];
int ny=cur.second+dy[i];
if(ok(nx,ny)&&grid[nx][ny]!='#'&&steps[nx][ny]>=1e9){
steps[nx][ny]=steps[cur.first][cur.second]+1;
q.push(make_pair(nx,ny));
}
}
}
}
int main(){
//freopen("input.txt","r",stdin);
//freopen("output.txt","w",stdout);
cin>>n>>m>>k;
pair<int,int> stt;
for(int i=0;i<n;i++)
{
scanf("%s",grid[i]);
for(int j=0;j<m;j++){
if(grid[i][j]=='S')
stt=make_pair(i,j);
}
}
BFS(stt.first,stt.second);
int res=1e9;
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(grid[i][j]!='#'&&steps[i][j]<=k){
int mmin=min(min(i,j),min(n-i-1,m-j-1));
res=min(res,(mmin+k-1)/k+1);
}
}
}
cout<<res<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace ::std;
const long double PI = acos(-1);
const int MOD = 1000000000 + 7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int add(long long a, long long b) {
return (a % MOD + b % MOD + 2 * MOD) % MOD;
}
int mul(long long a, long long b) {
return ((a % MOD + MOD) * (b % MOD + MOD)) % MOD;
}
long long pow_mod(long long a, long long b) {
long long res = 1LL;
a = add(a, 0);
while (b) {
if (b & 1) res = mul(res, a);
b >>= 1;
a = mul(a, a);
}
return res;
}
long long fastexp(long long a, long long b) {
long long res = 1LL;
while (b) {
if (b & 1) res = res * a;
b >>= 1;
a *= a;
}
return res;
}
int gcdExtendido(int a, int b, int *x, int *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtendido(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
};
int modInverso(int a, int m) {
int x, y;
int g = gcdExtendido(a, m, &x, &y);
if (g != 1)
return -1;
else
return (x % m + m) % m;
}
const int N = 55;
int n, m, k;
int v[N][N];
bool vis[N][N];
vector<pair<int, pair<int, int> > > positions;
vector<vector<int> > answer;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int parentx[N][N];
int parenty[N][N];
bool validPos(int i, int j) { return i >= 0 and j >= 0 and i < n and j < m; }
void BFS(int sx, int sy) {
queue<int> Q;
Q.push(sx);
Q.push(sy);
Q.push(0);
v[sx][sy] = 0;
vis[sx][sy] = true;
positions.push_back(make_pair(v[sx][sy], make_pair(sx, sy)));
while (!Q.empty()) {
int ux = Q.front();
Q.pop();
int uy = Q.front();
Q.pop();
int d = Q.front();
Q.pop();
for (int i = 0; i < 4; i++) {
int vx = ux + dx[i];
int vy = uy + dy[i];
if (validPos(vx, vy) and !vis[vx][vy]) {
v[vx][vy] = d + 1;
vis[vx][vy] = true;
Q.push(vx);
Q.push(vy);
Q.push(d + 1);
positions.push_back(make_pair(d + 1, make_pair(vx, vy)));
parentx[vx][vy] = ux;
parenty[vx][vy] = uy;
}
}
}
}
bool comp(pair<int, pair<int, int> > &a, pair<int, pair<int, int> > &b) {
return a.first < b.first;
}
int main() {
scanf("%d %d %d", &(n), &(m), &(k));
BFS(0, 0);
sort((positions).begin(), (positions).end(), comp);
stack<int> S;
int ans = 0;
for (int i = k - 1; i >= 0; i--) {
int x = positions[i].second.first;
int y = positions[i].second.second;
vector<int> c;
while (x != 0 or y != 0) {
S.push(y + 1);
S.push(x + 1);
int carryx = parentx[x][y];
int carryy = parenty[x][y];
x = carryx;
y = carryy;
ans += 1;
}
S.push(1);
S.push(1);
ans += 1;
while (!S.empty()) {
c.push_back(S.top());
S.pop();
}
answer.push_back(c);
}
cout << ans << endl;
for (int i = 0; i < answer.size(); i++) {
for (int j = 0; j < answer[i].size(); j += 2) {
printf("(%d,%d) ", answer[i][j], answer[i][j + 1]);
}
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int i, ans;
int num[2005];
while (scanf("%d%d", &n, &k) != EOF) {
ans = 0;
for (i = 0; i < n; i++) scanf("%d", &num[i]);
sort(num, num + n);
for (i = n - 1; i >= 0; i = i - k) ans += (num[i] - 1) * 2;
printf("%d\n", ans);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2003;
const int mod = 1e9 + 7;
int tag[N << 2], mn[N << 2], mx[N << 2], sum[N << 2];
vector<int> vx, vy;
void solve(int pos, int l, int r, int v) {
tag[pos] = mx[pos] = mn[pos] = v;
sum[pos] = 1ll * (vx.back() - vx[v]) * (vx[r] - vx[l]) % mod;
}
void pushup(int pos) {
sum[pos] = (sum[pos << 1] + sum[pos << 1 | 1]) % mod;
mn[pos] = min(mn[pos << 1], mn[pos << 1 | 1]);
mx[pos] = max(mx[pos << 1], mx[pos << 1 | 1]);
}
void pushdown(int pos, int l, int r) {
if (tag[pos] == -1) return;
int m = l + r >> 1;
solve(pos << 1, l, m, tag[pos]);
solve(pos << 1 | 1, m, r, tag[pos]);
tag[pos] = -1;
}
void build(int pos, int l, int r, const vector<int>& a) {
tag[pos] = -1;
if (l + 1 == r) {
mn[pos] = mx[pos] = a[l];
sum[pos] = 1ll * (vx.back() - vx[a[l]]) * (vx[r] - vx[l]) % mod;
return;
}
int m = l + r >> 1;
build(pos << 1, l, m, a);
build(pos << 1 | 1, m, r, a);
pushup(pos);
}
void upd(int pos, int l, int r, int x, int y, int v) {
if (l >= y || r <= x || mn[pos] >= v) return;
if (l >= x && r <= y && mx[pos] <= v) {
solve(pos, l, r, v);
return;
}
pushdown(pos, l, r);
int m = l + r >> 1;
upd(pos << 1, l, m, x, y, v);
upd(pos << 1 | 1, m, r, x, y, v);
pushup(pos);
}
int main() {
int n, k, L;
scanf("%d%d%d", &n, &k, &L);
vector<int> x(n), y(n), c(n);
for (int i = (0); i < (n); i++) {
scanf("%d%d%d", &x[i], &y[i], &c[i]);
--c[i];
}
vx = x, vy = y;
vx.push_back(-1);
vx.push_back(L);
vy.push_back(-1);
vy.push_back(L);
sort(vx.begin(), vx.end());
sort(vy.begin(), vy.end());
vector<int> px(n), py(n);
iota(px.begin(), px.end(), 0);
iota(py.begin(), py.end(), 0);
sort(px.begin(), px.end(), [&](int i, int j) { return x[i] < x[j]; });
sort(py.begin(), py.end(), [&](int i, int j) { return y[i] < y[j]; });
for (int i = (0); i < (n); i++) x[px[i]] = y[py[i]] = i + 1;
long long ans = 0;
for (int u = k; u <= n; ++u) {
vector<int> r(n, n + 1), cnt(k);
vector<set<int>> s(n);
int cur = 0;
for (int l = 0, i = 0; l < n; ++l) {
while (i < n && cur < k) {
int j = px[i];
if (y[j] <= u && !cnt[c[j]]++) cur++;
++i;
}
if (cur == k) r[l] = i;
int j = px[l];
if (y[j] <= u && !--cnt[c[j]]) --cur;
}
build(1, 0, n, r);
for (int i = (0); i < (n); i++) {
if (y[i] <= u) s[c[i]].insert(x[i]);
}
long long res = 0;
for (int d = 0; d < u; ++d) {
res = (res + 1ll * (vy[d + 1] - vy[d]) * sum[1]) % mod;
int j = py[d];
auto it = s[c[j]].erase(s[c[j]].find(x[j]));
int r = it == s[c[j]].end() ? n + 1 : *it;
int l = it == s[c[j]].begin() ? 0 : *prev(it);
upd(1, 0, n, l, x[j], r);
}
ans = (ans + 1ll * res * (vy[u + 1] - vy[u])) % mod;
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long k, sum = 0;
cin >> k;
string s;
cin >> s;
int len = s.length();
for (int i = 0; i < len; i++) {
sum += s[i] - '0';
}
if (sum >= k)
cout << "0\n";
else {
sort(s.begin(), s.end());
long long ans = 0;
for (int i = 0; i < len; i++) {
ans++;
sum += 9 - (s[i] - '0');
if (sum >= k) break;
}
cout << ans << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, num[200010], ins = -1, des = 123456789, res[200010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
for (int i = 1; i <= n; i++) {
if (num[i] > ins && (num[i] >= des || num[i] < num[i + 1]))
ins = num[i], res[i] = 0;
else if (des > num[i])
des = num[i], res[i] = 1;
else
return 0 * puts("NO");
}
printf("YES\n%d", res[1]);
for (int i = 2; i <= n; i++) printf(" %d", res[i]);
return 0;
}
| 3 |
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#define For(i,j,k) for(int i=j;i<=k;i++)
#define Dow(i,j,k) for(int i=j;i>=k;i--)
#define LL long long
using namespace std;
inline int read() {
int x = 0,f = 1;
char ch = getchar();
while(ch<'0'||ch>'9') { if(ch=='-') f = -1; ch = getchar(); }
while(ch>='0'&&ch<='9') { x = x *10+ch-48 ; ch = getchar(); }
return x * f ;
}
const int N = 1e5+11;
int n,m;
int a[N];
LL p[N*2];
LL all,ans;
int main() {
n=read(); m=read();
all = 0;
For(i, 0, n-1) a[i]=read();
For(i, 1, n-1) {
int l = a[i-1], r = a[i];
if(l>r) r+=m;
all+= r-l;
if( r-l>1 ) {
p[l+2] += 1;
p[r+1] -= r-(l+2)+1 +1;
p[r+2] += r-(l+2)+1;
}
}
For(i, 1, 2*m) p[i]+=p[i-1];
For(i, 1, 2*m) p[i]+=p[i-1];
For(i, 1, m) ans=max(ans,p[i]+p[i+m]);
printf("%lld\n",all-ans);
return 0;
} | 0 |
//https://onlinejudge.u-aizu.ac.jp/beta/room.html#KUPC2020Spring/problems/B
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
//#pragma GCC optimize ("-O3")
using namespace std; void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
typedef long long ll; const int inf = INT_MAX / 2; const ll infl = 1LL << 60;
template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
//---------------------------------------------------------------------------------------------------
/*---------------------------------------------------------------------------------------------------
∧＿∧
∧＿∧ （´<_｀ ） Welcome to My Coding Space!
（ ´_ゝ`） / ⌒i @hamayanhamayan0
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
---------------------------------------------------------------------------------------------------*/
// v back
// .-------.
// / up /|
// /_______/ |
// left > | | | < right
// | front | /
// | |/
// '-------'
// ^ down
struct Dice {
int up, down, left, right, front, back;
Dice() {}
Dice(int up, int down, int left, int right, int front, int back) : up(up), down(down), left(left), right(right), front(front), back(back) {}
};
Dice rotateToLeft(Dice from) { return Dice(from.right, from.left, from.up, from.down, from.front, from.back); }
Dice rotateToRight(Dice from) { return rotateToLeft(rotateToLeft(rotateToLeft(from))); }
Dice rotateToFront(Dice from) { return Dice(from.back, from.front, from.left, from.right, from.up, from.down); }
Dice rotateToBack(Dice from) { return rotateToFront(rotateToFront(rotateToFront(from))); }
Dice rotateByDxdy(Dice from, int dxdy) {
if (dxdy == 0) return rotateToBack(from);
else if (dxdy == 1) return rotateToRight(from);
else if (dxdy == 2) return rotateToFront(from);
else return rotateToLeft(from);
}
int H, W;
string S[100];
//---------------------------------------------------------------------------------------------------
bool vis[100][100][7][7];
int dx[4] = { 0, 1, 0, -1 }, dy[4] = { -1, 0, 1, 0 };
Dice cache[7][7];
#define yes "YES"
#define no "NO"
string solve() {
Dice initialDice(1, 6, 4, 3, 2, 5);
queue<pair<int, int>> que;
vis[0][0][initialDice.down][initialDice.right] = true;
cache[initialDice.down][initialDice.right] = initialDice;
que.push({ 0, initialDice.down * 10 + initialDice.right });
while (!que.empty()) {
auto q = que.front(); que.pop();
int x = q.first % 100;
int y = q.first / 100;
int downValue = q.second / 10;
int rightValue = q.second % 10;
auto dice = cache[downValue][rightValue];
if (y == H - 1 && x == W - 1) return yes;
rep(d, 0, 4) {
int xx = x + dx[d];
int yy = y + dy[d];
if (0 <= xx && xx < W && 0 <= yy && yy < H) {
auto dice2 = rotateByDxdy(dice, d);
cache[dice2.down][dice2.right] = dice2;
if (S[yy][xx] - '0' == dice2.down && !vis[yy][xx][dice2.down][dice2.right]) {
vis[yy][xx][dice2.down][dice2.right] = true;
que.push({ yy * 100 + xx, dice2.down * 10 + dice2.right });
}
}
}
}
return no;
}
//---------------------------------------------------------------------------------------------------
void _main() {
cin >> H >> W;
rep(y, 0, H) cin >> S[y];
cout << solve() << endl;
}
/* ///////////////////////// writeup1 start
///////////////////////// writeup2 start
到達可能性といえばBFS。BFSだろうなぁと思って考えていくと解ける。
状態は(x座標, y座標, サイコロの下の面の数字, サイコロの右の面の数字)で表現する。
遷移は4方向なので、BFSしても間に合う。
サイコロについては、真面目にサイコロクラスを作ってBFSをした。満足。
…と思ったらMLE！
泣く泣く、queueに突っ込むのはサイコロの数字だけにして、
サイコロクラスのインスタンスはキャッシュに突っ込んで使いまわしたらAC。
///////////////////////// writeup2 end */
//
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(void){
int A, B;
cin >> A >> B;
cout << max(max(A+B,A-B),A*B) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
cout << m + n - 1 << '\n';
for (int i = 1; i <= n; ++i) {
cout << 1 << ' ' << i << '\n';
}
for (int i = 2; i <= m; ++i) {
cout << i << ' ' << 1 << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long k;
int main() {
cin >> n >> k;
long long b;
long long c = 0, a;
cin >> b;
for (int i = 2; i <= n; i++) {
cin >> a;
if (b > a)
c++;
else {
b = a, c = 1;
}
if (c == k) {
cout << b;
return 0;
}
}
cout << b;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2222;
int n, h;
double dp[N][N][2][2];
int a[N];
int lf[N], rg[N];
double p;
double get(int i, int j, int t1, int t2) {
return (i > j ? 0.0 : dp[i][j][t1][t2]);
}
int main() {
ios::sync_with_stdio(false);
scanf("%d%d%lf", &n, &h, &p);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
sort(a + 1, a + n + 1);
rg[n] = n;
for (int i = n - 1; i >= 1; i--)
if (a[i + 1] - a[i] < h)
rg[i] = rg[i + 1];
else
rg[i] = i;
lf[1] = 1;
for (int i = 2; i <= n; i++)
if (a[i] - a[i - 1] < h)
lf[i] = lf[i - 1];
else
lf[i] = i;
for (int i = n; i >= 1; i--)
for (int j = i; j <= n; j++)
for (int t1 = 0; t1 < 2; t1++)
for (int t2 = 0; t2 < 2; t2++) {
double ret = 0.0;
int from, to;
if (i == j) {
{
from = a[i];
to = a[i] + h;
if (i > 1) from = max(from, t1 == 0 ? a[i - 1] : a[i - 1] + h);
if (i < n) to = min(to, t2 == 0 ? a[i + 1] - h : a[i + 1]);
if (from < to) ret += (to - from) * (1 - p);
}
{
from = a[i] - h;
to = a[i];
if (i > 1) from = max(from, t1 == 0 ? a[i - 1] : a[i - 1] + h);
if (i < n) to = min(to, t2 == 0 ? a[i + 1] - h : a[i + 1]);
if (from < to) ret += (to - from) * p;
}
} else {
{
from = a[i] - h;
to = a[i];
if (i > 1) from = max(from, t1 == 0 ? a[i - 1] : a[i - 1] + h);
if (j < n) to = min(to, t2 == 0 ? a[j + 1] - h : a[j + 1]);
if (from < to) ret += (to - from) * p;
ret += dp[i + 1][j][0][t2] * p;
}
{
from = a[i];
to = a[rg[i]] + h;
if (i > 1) from = max(from, t1 == 0 ? a[i - 1] : a[i - 1] + h);
if (j < n) to = min(to, t2 == 0 ? a[j + 1] - h : a[j + 1]);
if (from < to) ret += (to - from) * (1 - p);
ret += get(rg[i] + 1, j, 1, t2) * (1 - p);
}
{
from = a[lf[j]] - h;
to = a[j];
if (i > 1) from = max(from, t1 == 0 ? a[i - 1] : a[i - 1] + h);
if (j < n) to = min(to, t2 == 0 ? a[j + 1] - h : a[j + 1]);
if (from < to) ret += (to - from) * p;
ret += get(i, lf[j] - 1, t1, 0) * p;
}
{
from = a[j];
to = a[j] + h;
if (i > 1) from = max(from, t1 == 0 ? a[i - 1] : a[i - 1] + h);
if (j < n) to = min(to, t2 == 0 ? a[j + 1] - h : a[j + 1]);
if (from < to) ret += (to - from) * (1 - p);
ret += dp[i][j - 1][t1][1] * (1 - p);
}
ret *= 0.5;
}
dp[i][j][t1][t2] = ret;
}
printf("%.7lf", dp[1][n][0][0]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const double PI = 3.14159265358979323846;
const int INF = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long a, b;
cin >> a >> b;
if (a == 1 && b == 1)
cout << 1;
else {
long long c = 0;
while (a > 0 && b > 0) {
if (a > b) {
c += a / b;
a %= b;
} else {
c += b / a;
b %= a;
}
}
cout << c;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, z;
int id;
} zt[100005];
bool cmp(node a, node b) {
if (a.x == b.x) {
if (a.y == b.y) return a.z > b.z;
return a.y > b.y;
}
return a.x > b.x;
}
int main() {
int n, Max = 0, Min;
int key1 = 0, key2 = -1;
int a[3];
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &a[0], &a[1], &a[2]);
sort(a, a + 3);
zt[i].x = a[2];
zt[i].y = a[1];
zt[i].z = a[0];
zt[i].id = i;
if (a[0] > Max) {
Max = a[0];
key1 = i;
}
}
sort(zt, zt + n, cmp);
for (int i = 0; i < n - 1; i++) {
if (zt[i].x == zt[i + 1].x && zt[i].y == zt[i + 1].y) {
Min = min(zt[i].y, zt[i].z + zt[i + 1].z);
if (Min > Max) {
Max = Min;
key1 = zt[i].id;
key2 = zt[i + 1].id;
}
}
}
if (key2 != -1) {
cout << "2" << endl;
cout << key1 + 1 << " " << key2 + 1 << endl;
} else {
cout << "1" << endl;
cout << key1 + 1 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double D;
#define INF 2000000000000000000
ll n,m,a[20],z[1<<20];
D p[20],ans;
ll gcd(ll x,ll y){
if(x%y==0)return y;
return gcd(y,x%y);
}
ll lcm(ll x,ll y){
x/=gcd(max(x,y),min(x,y));
if(x>INF/y)return INF;
return x*y;
}
int main(void){
scanf("%lld%lld",&n,&m);
for(int i=0;i<n;i++)scanf("%lld",a+i);
for(int i=0;i<n;i++){
D x;
scanf("%lf",&x);
p[i]=x/100;
}
for(int k=1;k<1<<n;k++){
ll s=1,w=0;
for(int i=0;i<n;i++){
if(k>>i&1){
w++;
s=lcm(s,a[i]);
}
}
if(w%2)z[k]=m/s;
else z[k]=-m/s;
}
for(int i=0;i<n;i++)for(int k=0;k<1<<n;k++)if(k>>i&1)z[k]+=z[k^(1<<i)];
for(int k=1;k<1<<n;k++){
D o=1;
for(int i=0;i<n;i++){
if(k>>i&1)o*=p[i];
else o*=(1-p[i]);
}
ans+=o*D(z[k]);
}
printf("%.8lf\n",ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
char a[n][m];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> a[i][j];
}
}
long long counter = 0;
for (int i = n - 1; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == 'D') ++counter;
}
}
for (int i = m - 1; i < m; ++i) {
for (int j = 0; j < n; ++j) {
if (a[j][i] == 'R') ++counter;
}
}
cout << counter << "\n";
}
int main() {
ios::sync_with_stdio(1);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, flag = 0, i, j;
char a[5][5];
cin >> n;
map<int, int> mp;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
cin >> a[i][j];
if (a[i][j] == '.')
continue;
else
mp[a[i][j] - '0']++;
}
}
for (auto it = mp.begin(); it != mp.end(); it++) {
if (it->second > 2 * n) {
flag = 1;
break;
}
}
if (flag == 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2020;
const double pi = acos(-1), eps = 1e-7;
int n;
long long ans;
struct Point {
int x, y;
double sl;
void in() { scanf("%d%d", &x, &y); }
Point() {}
Point(int a, int b) : x(a), y(b) {}
double Get(int a, int b) { return atan2(y - b, x - a); }
double operator<(const Point &a) const { return sl < a.sl; }
} P[M];
double ang[M];
int tot;
long long Calc(long long a) { return ((a * (a - 1)) >> 1); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) P[i].in();
for (int i = 1, k; i <= n; i++) {
tot = 0;
k = 1;
for (int j = 1; j <= n; j++) {
if (i == j) continue;
ang[++tot] = P[j].Get(P[i].x, P[i].y);
}
sort(ang + 1, ang + tot + 1);
for (int j = 1; j <= tot && ang[j] <= eps; j++) {
while (k <= tot && ang[k] < ang[j] + pi) ++k;
ans += 1ll * (k - j - 1) * (k - j - 2) * (tot - k + j) *
(tot - k + j - 1) / 2;
}
}
printf("%I64d\n", (ans >> 1));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pr = pair<int, int>;
using prll = pair<long, long>;
using V = vector<int>;
using Vll = vector<long long>;
template <typename T, typename TT>
pr operator+(pair<T, TT> a, pair<T, TT> b) {
return {a.first + b.first, a.second + b.second};
}
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
for (auto itr : t) s << itr << " ";
return s;
}
ll a, b, n;
int main() {
int T;
cin >> T;
while (T--) {
cin >> a >> b >> n;
if (a > b) swap(a, b);
int ans = 0;
while (a <= n && b <= n) {
a += b;
ans++;
if (a > n) break;
b += a;
ans++;
}
cout << ans << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[100100], b[100100], pa[100100], pb[100100];
long long ans = 10e17;
void go(long long x) {
long long t = 0;
int i = lower_bound(a, a + n, x) - a;
t += x * i - pa[i];
i = lower_bound(b, b + m, x) - b;
t += pb[m] - pb[i] - x * (m - i);
ans = min(ans, t);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + m);
pa[0] = 0;
pb[0] = 0;
for (int i = 1; i <= n; i++) pa[i] = pa[i - 1] + a[i - 1];
for (int i = 1; i <= m; i++) pb[i] = pb[i - 1] + b[i - 1];
for (int i = 0; i < n; i++) go(a[i]);
for (int i = 0; i < m; i++) go(b[i]);
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename S, typename T>
ostream& operator<<(ostream& out, pair<S, T> const& p) {
out << '(' << p.first << ", " << p.second << ')';
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> const& v) {
long long l = v.size();
for (long long i = 0; i < l - 1; i++) out << v[i] << ' ';
if (l > 0) out << v[l - 1];
return out;
}
template <typename T>
void trace(const char* name, T&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename T, typename... Args>
void trace(const char* names, T&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
trace(comma + 1, args...);
}
long long n, m, p;
vector<long long> a, b, ans;
void print(map<long long, long long>& ma) {
for (auto& e : ma) {
cout << __FUNCTION__ << ' ' << 58 << " = ";
trace("e", e);
}
}
void func(vector<long long>& v, long long mod) {
long long si = v.size();
if (si < m) return;
map<long long, long long> ma;
for (long long i = 0; i < m; i++) ma[b[i]]++;
auto& a = v;
for (long long i = 0; i < m; i++) {
ma[a[i]]--;
if (ma[a[i]] == 0) ma.erase(a[i]);
}
if (ma.size() == 0) ans.push_back(mod);
for (long long i = m; i < si; i++) {
ma[a[i - m]]++;
if (ma[a[i - m]] == 0) ma.erase(a[i - m]);
ma[a[i]]--;
if (ma[a[i]] == 0) ma.erase(a[i]);
if (ma.size() == 0) {
long long ind = i - m + 1;
ind = ind * p + mod;
ans.push_back(ind);
}
}
}
void solve() {
cin >> n >> m >> p;
a.resize(n);
b.resize(m);
for (auto& e : a) cin >> e;
for (auto& e : b) cin >> e;
vector<long long> arr[p];
for (long long i = 0; i < n; i++) {
arr[i % p].push_back(a[i]);
}
for (long long i = 0; i < p; i++) {
func(arr[i], i);
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (auto& e : ans) {
cout << e + 1 << ' ';
}
cout << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) solve();
}
| 2 |
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
//#pragma GCC optimize ("-O3")
using namespace std; void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
typedef long long ll; const int inf = INT_MAX / 2; const ll infl = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a = b; return 1; } return 0; }
//---------------------------------------------------------------------------------------------------
#define def make_pair(0,0)
template<class V, int NV> struct SegTree { //[l,r)
V comp(V& l, V& r) { return max(l, r); };
vector<V> val; SegTree() { val = vector<V>(NV * 2, def); }
V get(int x, int y, int l = 0, int r = NV, int k = 1) {
if (r <= x || y <= l)return def; if (x <= l && r <= y)return val[k];
auto a = get(x, y, l, (l + r) / 2, k * 2);
auto b = get(x, y, (l + r) / 2, r, k * 2 + 1);
return comp(a, b);
}
void update(int i, V v) {
i += NV; val[i] = v;
while (i > 1) i >>= 1, val[i] = comp(val[i * 2], val[i * 2 + 1]);
}
void add(int i, V v) { update(i, val[i + NV] + v); }
V operator[](int x) { return get(x, x + 1); }
};
/*---------------------------------------------------------------------------------------------------
∧＿∧
∧＿∧ （´<_｀ ） Welcome to My Coding Space!
（ ´_ゝ`） / ⌒i
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
---------------------------------------------------------------------------------------------------*/
int N, A[101010];
SegTree<pair<int,ll>, 1 << 17> st;
//---------------------------------------------------------------------------------------------------
void _main() {
cin >> N;
rep(i, 0, N) cin >> A[i];
rep(i, 0, N) {
auto p = st.get(0, A[i]);
p.first++;
p.second += A[i];
chmax(p, st[A[i]]);
st.update(A[i], p);
}
cout << st.get(0, 1 << 17).second << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
if (!(n & 1)) {
cout << (n >> 1) << "\n";
while (n != 0) {
cout << 2 << " ";
n -= 2;
}
} else {
vector<long long> v;
while (n > 3) {
v.push_back(2);
n -= 2;
}
v.push_back(3);
cout << v.size() << "\n";
for (auto i : v) {
cout << i << " ";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
double gcd(double a, double b) {
if (b == 0) return a;
return gcd(b, double(int(a) % int(b)));
}
long long int MOD = 1000000007;
long long int power(long long int b, long long int e, long long int m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
void solve() {
long long int n;
cin >> n;
;
long long int c;
vector<pair<long long int, long long int>> v;
for (long long int i = 0; i < n; i++) {
cin >> c;
v.push_back({c, i + 1});
}
sort(v.begin(), v.end());
if (n == 2) {
cout << "1" << '\n'
<< v[0].second << '\n'
<< "1" << '\n'
<< v[1].second << '\n';
return;
}
if (n % 2 != 0)
cout << (n + 1) / 2 << '\n';
else
cout << n / 2 << '\n';
for (int i = 0; i < n; i += 2) cout << v[i].second << " ";
cout << '\n' << n / 2 << '\n';
for (int i = 1; i < n; i += 2) cout << v[i].second << " ";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
for (long long int I = 0; I < t; I++) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int a[200200], b[200200];
int main() {
int n, i, j, k, x, y, curr, temp, m;
long long int ans, rose = 0;
long long int ta, tb;
scanf("%d %d %lld %lld %d", &n, &m, &ta, &tb, &k);
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
a[i] += ta;
}
for (i = 1; i <= m; i++) scanf("%lld", &b[i]);
if (k >= min(n, m)) {
printf("-1\n");
return 0;
}
int used = 0, low, mid, high;
long long int dest;
for (i = 1; i <= n; i++) {
if (used > k) break;
dest = a[i];
low = 1;
high = m;
mid = (low + high) / 2;
ans = -1;
while (low <= high) {
if (dest > b[mid]) {
low = mid + 1;
} else {
ans = mid;
high = mid - 1;
}
mid = (low + high) / 2;
}
if (ans + (k - used) > m || ans == -1) {
printf("-1\n");
return 0;
}
ans += (k - used);
rose = max(rose, b[ans] + tb);
used++;
}
printf("%lld\n", rose);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, f, x, i, j, m;
scanf("%lld", &n);
long long a[n];
for (i = 0; i < n; i++) scanf("%lld", &a[i]);
scanf("%lld%lld", &x, &f);
long long ans = 0;
for (i = 0; i < n; i++) {
if (a[i] > x) {
long long temp = a[i] / (x + f);
ans += temp;
a[i] -= temp * (x + f);
if (a[i] > x) ans++;
}
}
ans = ans * f;
printf("%lld\n", ans);
}
| 6 |
#include <bits/stdc++.h>
const int N = 1e6 + 7;
long long a[N], f[N], yks[N];
int n, q;
template <class T>
void G(T &num) {
static char a;
static bool fl;
for (a = getchar(), fl = false; a > '9' || a < '0'; a = getchar())
if (a == '-') fl = true;
for (num = 0; a >= '0' && a <= '9'; a = getchar())
num = (num << 3) + (num << 1) + a - '0';
if (fl) num = -num;
}
void Min(long long &x, long long y) {
if (x > y) x = y;
}
long long solve(long long k) {
long long ans = 0x3f3f3f3f3f3f3f3f;
int p1 = 0, p2;
for (p2 = 1; a[p2] < k; ++p2) f[p2] = 0, yks[p2] = a[p2];
for (; p2 <= n; ++p2) {
while (a[p2] - a[p1] > k) ++p1;
f[p2] = f[p1] + 1;
yks[p2] = yks[p1];
}
for (int i = 1; i <= n; ++i)
if (yks[i] + a[n] - a[i] <= k) Min(ans, f[i] + 1);
return ans;
}
int main() {
G(n), G(q);
for (int i = 1; i <= n; ++i) G(a[i]), a[i] += a[i - 1];
long long k;
while (q--) {
G(k);
printf("%I64d\n", solve(k));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
inline void gmax(T1& a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1& a, T2 b) {
if (b < a) a = b;
}
const long long inf = 0x3f3f3f3f;
const long long maxn = 1e2 + 5;
void solve() {
long long n, k;
while (cin >> n >> k) {
long long t = k - (n % k);
cout << n + t << endl;
}
}
int main() {
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
if (n < 6)
cout << "-1" << endl;
else {
cout << "1 2\n2 3\n3 4\n3 5\n2 6" << endl;
for (i = 7; i <= n; i++) cout << "2 " << i << endl;
}
for (i = 2; i <= n; i++) cout << "1 " << i << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<vector<int>> graph;
namespace lca {
vector<int> dfsArr;
vector<int> height;
vector<int> first;
void dfs(int cur, int par = -1, int curHeight = 0) {
dfsArr.push_back(cur);
height[cur] = curHeight;
first[cur] = dfsArr.size() - 1;
for (auto next : graph[cur])
if (next != par) {
dfs(next, cur, curHeight + 1);
dfsArr.push_back(cur);
}
}
vector<int> tree;
void buildTree(int vert, int lArr, int rArr) {
if (lArr == rArr)
tree[vert] = dfsArr[lArr];
else {
int mArr = (lArr + rArr) / 2;
int firVert = vert * 2 + 1;
int secVert = vert * 2 + 2;
buildTree(firVert, lArr, mArr);
buildTree(secVert, mArr + 1, rArr);
if (height[tree[firVert]] < height[tree[secVert]])
tree[vert] = tree[firVert];
else
tree[vert] = tree[secVert];
}
}
int findMin(int vert, int lArr, int rArr, int lQuery, int rQuery) {
if (lQuery == lArr && rQuery == rArr) return tree[vert];
int mArr = (lArr + rArr) / 2;
if (rQuery <= mArr)
return findMin(vert * 2 + 1, lArr, mArr, lQuery, rQuery);
else if (lQuery > mArr)
return findMin(vert * 2 + 2, mArr + 1, rArr, lQuery, rQuery);
int min1 = findMin(vert * 2 + 1, lArr, mArr, lQuery, mArr);
int min2 = findMin(vert * 2 + 2, mArr + 1, rArr, mArr + 1, rQuery);
if (height[min1] < height[min2]) return min1;
return min2;
}
void init() {
height.resize(graph.size());
first.resize(graph.size());
dfsArr.reserve(graph.size() * 2);
dfs(0);
tree.resize(4 * dfsArr.size());
buildTree(0, 0, dfsArr.size() - 1);
}
int getDist(int v, int u) {
int t1 = first[v];
int t2 = first[u];
if (t1 > t2) swap(t1, t2);
int lcaV = findMin(0, 0, dfsArr.size() - 1, t1, t2);
return height[v] + height[u] - height[lcaV] * 2;
}
} // namespace lca
int main() {
int n;
cin >> n;
graph.resize(n);
for (int i = 1; i < n; ++i) {
int a;
cin >> a;
--a;
graph[a].push_back(i);
graph[i].push_back(a);
}
lca::init();
int curD = 0;
int left = 0;
int right = 0;
for (int i = 1; i < n; ++i) {
int temp = 0;
if ((temp = lca::getDist(left, i)) > curD)
curD = temp, right = i;
else if ((temp = lca::getDist(right, i)) > curD)
curD = temp, left = i;
cout << curD << ' ';
}
cout << '\n';
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int N;
long long a,b;
int main(){
cin >> N;
long long sum = 0,mi = 1e18;
bool judge = false;
for(int i=0;i<N;i++){
cin >> a >> b;
if(a!=b) judge = true;
sum += a;
if(a>b) mi = min(mi,b);
}
if(!judge) cout << 0 << endl;
else cout << sum-mi << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, tot, cnt1, cnt2, f[10000];
struct nd {
int x, y;
long long v;
} e[2000010], a[10000], ret1[10000], ret2[10000];
int find(int x) {
if (f[x] != x) f[x] = find(f[x]);
return f[x];
}
bool cmp(nd x, nd y) { return x.v < y.v; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].x, &a[i].y);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].v);
for (int i = 1; i <= n; i++) {
++tot;
e[tot].x = n + 1, e[tot].y = i, e[tot].v = a[i].v;
}
for (int i = 1; i <= n; i++) scanf("%d", &a[i].v);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
++tot;
e[tot].x = i, e[tot].y = j;
e[tot].v = (a[i].v + a[j].v) *
((long long)abs(a[i].x - a[j].x) + abs(a[i].y - a[j].y));
}
sort(e + 1, e + tot + 1, cmp);
for (int i = 1; i <= n + 1; i++) f[i] = i;
long long ans = 0;
for (int i = 1; i <= tot; i++) {
int fx = find(e[i].x), fy = find(e[i].y);
if (fx == fy) continue;
ans += e[i].v, f[fx] = fy;
if (e[i].x == n + 1)
ret1[++cnt1] = e[i];
else
ret2[++cnt2] = e[i];
}
cout << ans << endl;
cout << cnt1 << endl;
for (int i = 1; i <= cnt1; i++) cout << ret1[i].y << " ";
cout << endl << cnt2 << endl;
for (int i = 1; i <= cnt2; i++) cout << ret2[i].x << " " << ret2[i].y << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int round(int n, int m) {
float t = (100.00 * m) / n;
int p = (int)(t + 0.5000);
return p;
}
const int size = 1e5 + 7;
int arr[size];
int proc[size];
int vis[size];
int ind[1000];
int main() {
int n, k;
memset(arr, 0, sizeof(arr));
cin >> n >> k;
for (int x = 0; x < 1000; x++) ind[x] = -1;
int ans = 0;
for (int i = 0; i < n; i++) cin >> arr[i];
int l = 0, t = 1;
for (int i = 0; i < min(k, n); i++) {
proc[i] = 0;
ind[i] = i;
}
memset(vis, 0, sizeof(vis));
l = min(k, n);
int m = 0;
while (m < n) {
int t = 0;
for (int i = 0; i < k; i++) {
if (proc[i] == -1) continue;
proc[i]++;
if (proc[i] == round(n, m) && !vis[i]) {
vis[i] = 1;
ans++;
}
if (proc[i] == arr[ind[i]]) {
proc[i] = -1;
t++;
if (l < n) {
proc[i] = 0;
vis[i] = 0;
ind[i] = l++;
}
}
}
m += t;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char num[10000 + 10];
char changed[11][10000 + 10];
int n, k;
int _count[11];
struct Fabs {
int aabs;
int location;
char num;
int aim;
};
Fabs old[10000 + 10];
bool cmp(Fabs a, Fabs b);
void change(int a);
int cmps(int a, int b);
int main() {
cin >> n >> k;
cin >> num;
for (int i = 0; i < 11; i++) _count[i] = 0;
for (int i = 0; i <= 9; i++) {
change(i);
}
int _max = 0;
for (int i = 1; i <= 9; i++) {
if (cmps(i, _max) == 1) _max = i;
}
cout << _count[_max] << endl;
cout << changed[_max] << endl;
return 0;
}
void change(int a) {
int j = 0;
for (int i = 0; i < n; i++) {
old[j].aabs = abs(int(num[i] - '0') - a);
old[j].location = i;
old[j].num = num[i];
old[j].aim = a;
j++;
}
sort(old, old + j, cmp);
for (int i = 0; i < k; i++) {
_count[a] += old[i].aabs;
changed[a][old[i].location] = (old[i].aim + '0');
}
for (int i = k; i < n; i++) changed[a][old[i].location] = old[i].num;
}
bool cmp(Fabs a, Fabs b) {
if (a.aabs != b.aabs) return a.aabs < b.aabs;
if (a.num != b.num) return a.num > b.num;
if (a.num > (b.aim + '0')) return a.location < b.location;
return a.location > b.location;
}
int cmps(int a, int b) {
if (_count[a] < _count[b])
return 1;
else if (_count[a] > _count[b])
return 2;
else {
if (strcmp(changed[a], changed[b]) < 0)
return 1;
else
return 2;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > A;
int n, x, y;
void no() {
cout << "NO\n";
exit(0);
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int n;
cin >> n;
if (n & 1) no();
for (int i = 0; i <= n; i++) {
if (i != n)
cin >> x >> y;
else {
x = A[0].first;
y = A[0].second;
}
A.push_back({x, y});
if (i > n / 2) {
if (A[i].second - A[i - 1].second !=
-A[i - n / 2].second + A[i - n / 2 - 1].second)
no();
if (A[i].first - A[i - 1].first !=
-A[i - n / 2].first + A[i - n / 2 - 1].first)
no();
}
}
cout << "YES\n";
return 0;
}
| 2 |
#include<iostream>
#include<cstdio>
using namespace std;
int main() {
int n;
scanf("%d",&n);
puts(n%10==9||n/10==9?"Yes":"No");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long K;
int head[100010], v[100010 << 1], nxt[100010 << 1], tot = 0;
inline void add_edge(int s, int e) {
tot++;
v[tot] = e;
nxt[tot] = head[s];
head[s] = tot;
tot++;
v[tot] = s;
nxt[tot] = head[e];
head[e] = tot;
}
int siz[100010], mx[100010], rt;
int depth[100010];
int *son[100010], at[100010];
bool vis[100010];
int seq[100010], T = 0;
void findroot(int u, int f) {
siz[u] = 1;
mx[u] = 0;
for (int i = head[u]; i; i = nxt[i])
if (v[i] ^ f) {
findroot(v[i], u);
mx[u] = max(mx[u], siz[v[i]]);
siz[u] += siz[v[i]];
}
mx[u] = max(mx[u], n - siz[u]);
if (!rt || mx[u] < mx[rt]) rt = u;
}
bool leaf[100010];
int deg[100010];
struct B {
int *head, *v, *nxt, tot = 0, Top;
void init(int siz) {
siz++;
head = new int[siz + 2];
memset(head, 0, sizeof(int) * (siz + 2));
v = new int[siz + 2];
memset(v, 0, sizeof(int) * (siz + 2));
nxt = new int[siz + 2];
memset(nxt, 0, sizeof(int) * (siz + 2));
Top = siz + 1;
}
void add_edge(int dep, int u) {
tot++;
v[tot] = u;
nxt[tot] = head[dep];
head[dep] = tot;
}
void Del(int dep) { head[dep] = nxt[head[dep]]; }
pair<int, int> query() {
while (!head[Top]) Top--;
return make_pair(v[head[Top]], Top);
}
} B[100010];
long long L, R;
int bel[100010];
void pre_dfs(int u, int f) {
siz[u] = 1;
for (int i = head[u]; i; i = nxt[i])
if (v[i] ^ f) {
pre_dfs(v[i], u);
siz[u] += siz[v[i]];
}
}
int fa[100010];
void dfs(int u, int f, int tp) {
vis[u] = true;
bel[u] = tp;
at[u] = 0;
L += depth[u];
R += depth[u];
for (int i = head[u]; i; i = nxt[i])
if (v[i] ^ f) {
fa[v[i]] = u;
depth[v[i]] = depth[u] + 1;
dfs(v[i], u, tp);
at[u]++;
}
son[u] = new int[at[u] + 1];
son[u][0] = 0;
at[u] = 0;
if (at[u] == 0) leaf[u] = true;
for (int i = head[u]; i; i = nxt[i])
if (v[i] ^ f) {
at[u]++;
son[u][at[u]] = v[i];
if (!leaf[v[i]]) deg[u]++;
}
if (u != rt && !deg[u]) {
B[tp].add_edge(depth[u], u);
}
if (u != rt) L -= siz[u] / 2 * 2;
}
void search(int u, int f) {
if (vis[u]) seq[++T] = u;
for (int i = head[u]; i; i = nxt[i])
if (v[i] ^ f) search(v[i], u);
}
inline void rd(int &x) {
x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
}
char num[20];
int numst;
void print(int x) {
if (x == 0)
putchar('0');
else {
numst = 0;
while (x) {
num[++numst] = '0' + x % 10;
x /= 10;
}
while (numst) {
putchar(num[numst]);
numst--;
}
}
}
void output(int x, int y) {
vis[x] = vis[y] = false;
print(x);
putchar(' ');
print(y);
puts("");
}
int main() {
rd(n);
scanf("%lld", &K);
int s, e;
for (int i = 1; i < n; ++i) {
rd(s);
rd(e);
add_edge(s, e);
}
rt = 0;
findroot(1, 0);
pre_dfs(rt, 0);
for (int i = head[rt]; i; i = nxt[i]) B[v[i]].init(siz[v[i]]);
B[0].init(2 * n);
depth[rt] = 0;
vis[rt] = true;
for (int i = head[rt]; i; i = nxt[i]) {
fa[v[i]] = rt;
depth[v[i]] = 1;
dfs(v[i], rt, v[i]);
B[0].add_edge(siz[v[i]], v[i]);
}
if (K < L || R < K || (K - L) & 1) {
puts("NO");
return 0;
}
puts("YES");
long long sum = 0, To = (R - K) / 2;
while (To) {
pair<int, int> tmp = B[0].query();
int node = tmp.first, siz = tmp.second;
while (true) {
tmp = B[node].query();
int u = tmp.first;
while (at[u] && !vis[son[u][at[u]]]) at[u]--;
if (at[u] == 0) {
B[node].Del(tmp.second);
} else
break;
}
tmp = B[node].query();
int u = tmp.first;
if (depth[u] > To) {
while (depth[u] > To + 1) u = fa[u];
output(u, fa[u]);
To = 0;
break;
} else {
To -= depth[u];
int z = at[u] - 1, b = son[u][at[u]];
while (z && !vis[son[u][z]]) z--;
if (!z) {
output(u, b);
B[bel[u]].Del(depth[u]);
if (fa[u] != rt) {
deg[fa[u]]--;
if (!deg[fa[u]]) B[bel[u]].add_edge(depth[fa[u]], fa[u]);
}
} else {
output(b, son[u][z]);
at[u] = z - 1;
while (at[u] && !vis[son[u][at[u]]]) at[u]--;
if (!at[u] && fa[u] != rt) {
deg[fa[u]]--;
if (!deg[fa[u]]) B[bel[u]].add_edge(depth[fa[u]], fa[u]);
}
}
}
B[0].Del(siz);
siz -= 2;
if (siz > 1) B[0].add_edge(siz, node);
}
search(rt, 0);
for (int i = 1; i <= T / 2; ++i) output(seq[i], seq[i + T / 2]);
return 0;
}
| 5 |
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 100010
#define ll long long
using namespace std;
int n, map[N][4], b[4], w1[N], w2[N], flag1[N], flag2[N], x, pos[N], s[N];
ll sum1, sum2;
inline char gc(){
static char now[1<<16], *S, *T;
if(S==T){T=(S=now)+fread(now, 1, 1<<16, stdin); if(S==T)return EOF;}
return *S++;
}
inline int read(){
int x=0, f=1; char ch=gc();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1; ch=gc();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0'; ch=gc();}
return x*f;
}
inline void ins(int x){for(int i=x; i<=n; i+=i&(-i))s[i]++;}
inline int cs(int x){int s1=0; for(int i=x; i; i-=i&(-i))s1+=s[i]; return s1;}
int main(){
n=read();
for(int i=1; i<=3; i++)
for(int j=1; j<=n; j++)map[j][i]=read();
for(int i=1; i<=n; i++){
for(int j=1; j<=3; j++)b[j]=map[i][j];
if(b[1]>b[3])swap(b[1], b[3]);
if(b[1]+1!=b[2]||b[2]+1!=b[3]){printf("No"); return 0;}
if(b[3]%3){printf("No"); return 0;}
x=b[3]/3; if((x^i)&1){printf("No"); return 0;}
if(i&1){w1[(i+1)>>1]=(x+1)>>1; flag1[(i+1)>>1]=map[i][3]==b[3]?0:1;}
else{w2[i>>1]=x>>1; flag2[i>>1]=map[i][3]==b[3]?0:1;}
}
sum1=0; for(int i=1; i<=(n+1)/2; i++)sum1+=flag1[i];
sum2=0; for(int i=1; i<=n/2; i++)sum2+=flag2[i];
for(int i=1; i<=(n+1)/2; i++)pos[w1[i]]=i; for(int i=1; i<=(n+1)/2; i++)w1[i]=pos[i];
for(int i=1; i<=n/2; i++)pos[w2[i]]=i; for(int i=1; i<=n/2; i++)w2[i]=pos[i];
memset(s, 0, sizeof(s));
for(int i=(n+1)/2; i; i--){sum2+=cs(w1[i]-1); ins(w1[i]);}
memset(s, 0, sizeof(s));
for(int i=n/2; i; i--){sum1+=cs(w2[i]-1); ins(w2[i]);}
if((!(sum1&1))&&(!(sum2&1)))printf("Yes"); else printf("No");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[11000], b[11000];
int main() {
string s, t;
cin >> s >> t;
int ls = s.length();
int lt = t.length();
if (ls != lt) {
cout << "No" << endl;
return 0;
} else {
for (int i = 0; i < ls; i++) {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u') {
if (t[i] == 'a' || t[i] == 'e' || t[i] == 'i' || t[i] == 'o' ||
t[i] == 'u') {
} else {
cout << "No" << endl;
return 0;
}
} else {
if (t[i] == 'a' || t[i] == 'e' || t[i] == 'i' || t[i] == 'o' ||
t[i] == 'u') {
cout << "No" << endl;
return 0;
}
}
}
}
cout << "Yes" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, suma, minim, maxim, pos1, pos2;
long long v[300001];
char c;
long long nrok(long long v[300001]) {
int ans = 0;
suma = 0;
minim = 600001;
for (int j = 1; j <= n; j++) {
suma += v[j];
if (suma < minim) minim = suma;
}
if (minim >= 0) ans++;
for (int j = n; j >= 2; j--) {
minim += v[j];
if (minim >= 0) ans++;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
minim = 6000001;
for (int i = 1; i <= n; i++) {
cin >> c;
if (c == '(') v[i] = 1;
if (c == ')') v[i] = -1;
suma += v[i];
}
if (suma != 0) {
cout << 0 << '\n';
cout << 1 << " " << 1;
return 0;
}
maxim = nrok(v);
pos1 = 1;
pos2 = 1;
for (int i = 1; i < n; i++)
for (int l = i + 1; l <= n; l++) {
swap(v[i], v[l]);
long long x = nrok(v);
if (x > maxim) {
maxim = x;
pos1 = i;
pos2 = l;
}
swap(v[i], v[l]);
}
cout << maxim << '\n' << pos1 << " " << pos2;
return 0;
}
| 4 |
#include<iostream>
using namespace std;
int J[1000][1000]={0};
int O[1000][1000]={0};
int I[1000][1000]={0};
char maps[1000][1000];
int main(){
int m,n,k;
int a,b,c,d;
cin>>m>>n>>k;
for(int i=1;i<=m;i++){
for(int j=1;j<=n;j++){
cin>>maps[i][j];
J[i][j]=J[i][j-1];
O[i][j]=O[i][j-1];
I[i][j]=I[i][j-1];
if(maps[i][j]=='J'){
J[i][j]=J[i][j]+1;
}
else if(maps[i][j]=='O'){
O[i][j]=O[i][j]+1;
}
else{
I[i][j]=I[i][j]+1;
}
}
}
for(int i=0;i<k;i++){
cin>>a>>b>>c>>d;
int jcount=0;
int ocount=0;
int icount=0;
for(int j=a;j<=c;j++){
jcount=jcount+J[j][d]-J[j][b];
ocount=ocount+O[j][d]-O[j][b];
icount=icount+I[j][d]-I[j][b];
if(maps[j][b]=='J'){
jcount++;
}
else if(maps[j][b]=='O'){
ocount++;
}
else{
icount++;
}
}
cout<<jcount<<" "<<ocount<<" "<<icount<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll md = 1000000007;
ll exp(ll a, ll b) {
ll r = 1ll;
while (b > 0) {
if (b & 1) {
r = r * (a % md);
r = (r + md) % md;
}
b >>= 1;
a = (a % md) * (a % md);
a = (a + md) % md;
}
return (r + md) % md;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll Min(ll a, ll b) {
if (a < b) return a;
return b;
}
ll Max(ll a, ll b) {
if (a > b) return a;
return b;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
ll n, m, t, l, h;
cin >> n >> m;
long long ml = m, mh = m, pt = 0;
bool foo = true;
while (n--) {
cin >> t >> l >> h;
if (!foo) continue;
long long x = t - pt;
ml = Max(ml - x, l);
mh = Min(mh + x, h);
if (ml > mh)
foo = false;
else
pt = t;
}
if (foo)
cout << "YES";
else
cout << "NO";
cout << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, tmp, z, j, i, last;
int usg(int a, int b) {
if (a == 0 || b == 0) return a + b;
if (a > b)
return usg(b, a % b);
else
return usg(a, b % a);
}
int main() {
cin >> n >> k;
if (n / 2 > k) {
cout << "-1" << endl;
return 0;
};
if (n == 1 && k > 0) {
cout << "-1" << endl;
return 0;
};
if (n == 1 && k == 0) {
cout << "1" << endl;
return 0;
};
z = n / 2;
for (i = 1; i < z; i++) printf("%d %d ", i * 2 - 1, i * 2);
last = (z - 1) * 2;
z = k - (z - 1);
j = 0;
while (j * z <= last) j++;
printf("%d %d ", j * z, (j + 1) * z);
if (n % 2 == 1) printf("1000000000\n");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long long int INF = (long long int)1e15;
void solve() {
long long int N;
cin >> N;
long long int d = 0;
long long int p = 2;
while (N > p - 1) {
p *= 2;
d++;
}
cout << d << endl;
long long int n = 1;
long long int s = 1;
for (long long int(i) = (0); (i) < (d); ++(i)) {
long long int r = (d - i);
long long int ok = 0, ng = n + 1;
while (abs(ok - ng) > 1) {
long long int mid = (ok + ng) / 2;
if ((n + mid) * r + s <= N)
ok = mid;
else
ng = mid;
}
cout << ok << " ";
n += ok;
s += n;
}
cout << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long int Q;
cin >> Q;
for (long long int(_) = (0); (_) < (Q); ++(_)) {
solve();
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N], par[N], h[N];
bool mark[N];
vector<int> adj[N];
void dfs(int root) {
mark[root] = true;
par[root] = -1;
for (auto v: adj[root]) {
if (!mark[v])
dfs(v);
if (h[v] + 1 > h[root]) {
h[root] = h[v] + 1;
par[root] = v;
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m, u, v;
cin >> n >> m;
for (int i = 0; i < n + m - 1; i++) {
cin >> u >> v;
adj[--v].push_back(--u);
}
for (int i = 0; i < n; i++)
if (!mark[i])
dfs(i);
for (int i = 0; i < n; i++)
cout << par[i] + 1 << "\n";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2010;
long long n, k;
char mp[maxn][maxn];
long long dp[maxn][maxn];
bool visited[maxn][maxn];
queue<pair<long long, long long> > que[2];
char min_char[2];
void push_in(long long idx, long long i, long long j) {
if (i < n && j < n && !visited[i][j]) {
visited[i][j] = true;
que[idx].push(make_pair(i, j));
min_char[idx] = min(min_char[idx], mp[i][j]);
}
}
void solve() {
memset(dp, -1, sizeof dp);
if (mp[0][0] == 'a')
dp[0][0] = k;
else
dp[0][0] = k - 1;
long long max_sum = -1;
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < n; ++j) {
long long cost = mp[i][j] == 'a' ? 0 : 1;
if (i - 1 >= 0) dp[i][j] = max(dp[i][j], dp[i - 1][j] - cost);
if (j - 1 >= 0) dp[i][j] = max(dp[i][j], dp[i][j - 1] - cost);
if (dp[i][j] != -1) max_sum = max(max_sum, i + j);
}
}
long long cnt = 0;
min_char[cnt] = 'z';
if (max_sum == -1)
push_in(cnt, 0, 0);
else {
for (long long i = 0; i < max_sum + 1; ++i) putchar('a');
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < n; ++j)
if (dp[i][j] != -1 && i + j == max_sum) {
push_in(cnt, i + 1, j);
push_in(cnt, i, j + 1);
}
}
while (true) {
if (que[cnt].empty()) break;
putchar(min_char[cnt]);
min_char[cnt ^ 1] = 'z';
while (!que[cnt].empty()) {
long long x, y;
tie(x, y) = que[cnt].front();
que[cnt].pop();
if (mp[x][y] != min_char[cnt]) continue;
push_in(cnt ^ 1, x + 1, y);
push_in(cnt ^ 1, x, y + 1);
}
cnt ^= 1;
}
puts("");
}
int main() {
scanf("%lld%lld", &n, &k);
for (long long i = 0; i < n; ++i) scanf("%s", mp[i]);
solve();
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
long long n, x, y, c;
long long progr(long long first, long long last, long long cnt) {
long long ans = first + last;
if (ans % 2 == 0)
ans /= 2;
else {
assert(cnt % 2 == 0);
cnt /= 2;
}
return ans * cnt;
}
long long vuxid1(long long len) {
if (len <= 0) return 0;
return progr(1, 1 + 2 * (len - 1), len);
}
long long vuxid2(long long len) {
if (len <= 0) return 0;
return progr(1, 1 + 1 * (len - 1), len);
}
long long check(long long mid) {
long long ans = 1 + progr(0, 4 * mid, mid + 1);
long long a[4];
a[0] = x - 1;
a[1] = n - y;
a[2] = n - x;
a[3] = y - 1;
for (int i = 0; i < 4; ++i) {
long long tmp = mid - a[i];
long long pans = vuxid1(mid - a[i]);
ans -= vuxid1(mid - a[i]);
}
for (int i = 0; i < 4; ++i) {
long long tmp = mid - a[i] - a[(i + 1) % 4] - 1;
long long pans = vuxid2(mid - a[i] - a[(i + 1) % 4] - 1);
ans += vuxid2(mid - a[i] - a[(i + 1) % 4] - 1);
}
return ans;
}
int main() {
cin >> n >> x >> y >> c;
long long l = -1;
long long r = 2 * n + 1;
check(11);
while (l < r - 1) {
long long mid = (l + r) / 2;
if (check(mid) >= c)
r = mid;
else
l = mid;
}
cout << r << endl;
return 0;
}
| 2 |
#include <iostream>
using namespace std;
const int INF = 999999999;
const int rot[] = {4, 1, 4, 1, 2, 1, 2, 1};
int main ()
{
int n[8];
while (cin >> n[0]) {
for (int i = 1; i < 8; i++) cin >> n[i];
int min_c = INF, min_n = INF;
int res = 0;
for (int i = 0; i < 8; i++) {
int c = 0, num = 0;
int LL = 10000000;
for (int j = 0; j < 8; j++) {
int k = (j + i) % 8;
int t = n[j] - rot[k];
if (t > 0) c += t;
num += rot[k] * LL;
LL /= 10;
}
if (min_c > c) {
min_c = c;
min_n = num;
res = i;
} else if (min_c == c && min_n > num) {
min_n = num;
res = i;
}
}
for (int i = res; i < res + 7; i++) {
cout << rot[i % 8] << " ";
}
cout << rot[(res + 7) % 8] << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> occ(26);
for (int i = 0; i < 26; i++) occ[i] = 0;
for (int i = 0; i < n; i++) {
char x;
cin >> x;
occ[x - 'A']++;
}
sort(occ.rbegin(), occ.rend());
long long ans = 0;
for (auto el : occ) {
long long x = min(k, el);
ans += x * x;
k -= x;
if (k == 0) break;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int ipow(long long int base, long long int exp) {
long long int result = 1;
while (exp) {
if (exp & 1) {
result *= base;
result %= 1000000007;
}
exp >>= 1;
base *= base;
base %= 1000000007;
}
return result;
}
long long int a, b, l, m, t;
long long int srch(long long int pro) {
long long int a1 = a + (l - 1) * b;
long long int ax = b;
long long int bx = 2 * a1 - b;
long long int cx = -2 * pro;
long long int temp = bx * bx - 4 * ax * cx;
temp = (long long int)sqrt((double)temp);
long long int ans = max(-bx + temp, -bx - temp);
ans = ans / (2 * ax);
return ans;
}
long long int srchx(long long int lst) {
long long int str = l;
long long int en = lst;
long long int ans = -1;
while (str <= en) {
long long int mid = (str + en) / 2;
long long int temp = a + (mid - 1) * b;
if (temp > t)
en = mid - 1;
else {
str = mid + 1;
ans = max(ans, mid);
}
}
return ans;
}
int main() {
long long int n;
cin >> a >> b >> n;
while (n--) {
cin >> l >> t >> m;
long long int tmp = srch(m * t);
cout << srchx(tmp + l - 1) << endl;
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=55;
const int maxm=2466;
const ll inf=0x3f3f3f3f3f3f3f3f;//long long最大值，8个3f
#define tp tuple<ll,ll,ll>
vector<tp> G[maxn];//存每个点所能到达的点
ll c[maxn],d[maxn];//此点换钱的钱数和花费时间
ll dp[maxn][maxm];
int main(){
int n,m,s;
scanf("%d%d%d",&n,&m,&s);
s=min(2450,s);//防止越界，取2450（最大容量）以下。
for(int i=1;i<=m;i++){
ll u,v,a,b;
scanf("%lld%lld%lld%lld",&u,&v,&a,&b);
G[u].push_back(tp(v,a,b)); //点 钱 时间
G[v].push_back(tp(u,a,b));
}
for(int i=1;i<=n;i++)
scanf("%d%d",&c[i],&d[i]);
fill(dp[0],dp[0]+54*2465,inf);//全部初始化为inf的骚操作
dp[1][s]=0;//初始化起点
//优先队列，按照tuple三个值（从前往后）升序
priority_queue<tp,vector<tp>,greater<tp>> pq;
pq.push(tp(0,1,s));
while(!pq.empty()){
tp cur;
cur=pq.top();
pq.pop();
ll t=get<0>(cur),u=get<1>(cur),w=get<2>(cur);//取tuple值
if(dp[u][w]>t) continue; //可有可无的判重
for(auto i:G[u]){//遍历vector
ll v=get<0>(i),toa=get<1>(i),tob=get<2>(i);
if(dp[v][w-toa]>t+tob&&w>=toa){//如果有足够钱可达且这样走比原有dp更快
dp[v][w-toa]=t+tob;
pq.push(tp(t+tob,v,w-toa));//存入状态
}
}
if(dp[u][min(2450LL,w+c[u])]>t+d[u]){//如果充1次钱后比原有dp更快
dp[u][min(2450LL,w+c[u])]=t+d[u];
pq.push(tp(t+d[u],u,min(2450LL,w+c[u])));//存入状态
}
//这里只充一次钱，因为接下来会有下一次充钱的状态到来~
}
for(int i=2;i<=n;i++){
ll ans=inf;
for(int j=0;j<=2450;j++)
ans=min(ans,dp[i][j]);//取到达时剩下的不同钱中最快的
printf("%lld\n",ans);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 1) return a - 1;
if (b == 0) return 10000000;
return a / b + gcd(b, a % b);
}
int main() {
int n, answ = 10000000;
cin >> n;
for (int i = 0; i < n; i++) answ = min(answ, gcd(n, i));
if (n == 1) answ = 0;
cout << answ << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int n;
int a, b;
int t[N];
int p[N];
bool lls(int c1, int c2) {
if (a > b) {
if (t[c1] < t[c2]) return true;
return (t[c1] == t[c2] && c1 < c2);
} else {
if (t[c1] > t[c2]) return true;
return (t[c1] == t[c2] && c1 < c2);
}
}
int res[N];
int main() {
scanf("%d%d%d", &n, &a, &b);
if (a == b) {
for (int i = 0; i < a; i++) printf("1 ");
for (int i = 0; i < a; i++) printf("2 ");
return 0;
}
for (int i = 0; i < n; i++) {
scanf("%d", t + i);
p[i] = i;
}
sort(p, p + n, lls);
for (int i = 0; i < a; i++) res[p[i]] = 1;
for (int i = 0; i < b; i++) res[p[a + i]] = 2;
for (int i = 0; i < n; i++) printf("%d ", res[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, l, v;
int a[205];
double ans;
double p[205];
double dp[205][205][405];
int main() {
cin >> n >> l >> v;
for (int i = 1; i <= n; i++) {
cin >> p[i];
p[i] /= 100;
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dp[0][0][v + 200] = 1;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= i; j++) {
for (int k = 0; k <= 400; k++) {
dp[i + 1][j][k] += (1 - p[i + 1]) * dp[i][j][k];
if (min(k + a[i + 1], 400) > 0)
dp[i + 1][j + 1][min(k + a[i + 1], 400)] += p[i + 1] * dp[i][j][k];
}
}
}
for (int i = 200; i <= 400; i++) {
for (int j = l; j <= n; j++) {
ans += dp[n][j][i];
}
}
cout << setprecision(6) << fixed << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, temp, ans;
while (cin >> a) {
cin >> b >> c;
cout << (b * c) + (a - 1) * (b + c - 1);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
const int MAXN = 1e5 + 10, inf = 1e9 + 10, MAX = 1e4 + 10;
using namespace std;
int w, l;
int a[MAXN];
int main() {
scanf("%d%d", &w, &l);
for (int i = 1; i < w; i++) {
scanf("%d", &a[i]);
a[i] += a[i - 1];
}
int maxSum = 1000000009;
for (int i = l; i < w; i++) maxSum = min(maxSum, a[i] - a[i - l]);
printf("%d\n", maxSum);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const double pi = 3.14159265358979323846;
int n, m, k;
vector<int> a;
vector<int> b;
bool read() {
if (!(cin >> n >> m >> k)) return false;
a.resize(n);
b.resize(m);
for (int i = 0; i < int(n); ++i) cin >> a[i];
for (int i = 0; i < int(m); ++i) cin >> b[i];
return true;
}
void solve() {
int l = 0;
sort(a.begin(), a.end());
sort(b.begin(), b.end());
for (int i = 0; i < int(n); ++i) {
while (l < m && a[i] > b[l]) l++;
if (n - i > m - l) {
cout << "YES";
return;
}
}
cout << "NO";
}
int main() {
while (read()) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N;
long long C[1001][1001];
long long dp[1001];
long long color[1001];
long long combination(int n, int p) {
if (n == p || p == 0) {
return C[n][p] = 1;
}
if (C[n][p] != -1) {
return C[n][p];
} else {
long long ans = combination(n - 1, p) % 1000000007L;
ans = ans + (combination(n - 1, p - 1) % 1000000007L);
return C[n][p] = ans % 1000000007L;
}
}
long long solve(int k) {
if (k == 1) {
return 1;
} else if (dp[k] != -1) {
return dp[k];
} else {
long long sum = 0;
for (int i = 1; i <= k; i++) {
sum += color[i];
}
sum--;
long long ans = combination(sum, color[k] - 1);
ans *= solve(k - 1);
ans %= 1000000007L;
return dp[k] = ans;
}
}
int main() {
scanf("%d\n", &N);
for (int i = 1; i <= N; i++) {
cin >> color[i];
}
memset(dp, -1, sizeof dp);
memset(C, -1, sizeof C);
long long ans = solve(N);
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c<'0' | c> '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
template <class T>
void __stl_print__(T &x) {
cerr << "[";
for (__typeof((x).end()) i = (x).begin(); i != (x).end(); ++i)
cerr << (i != x.begin() ? ", " : "") << *i;
cerr << "]" << endl;
}
template <class T, class U>
inline T max(T &a, U &b) {
return a > b ? a : b;
}
template <class T, class U>
inline T min(T &a, U &b) {
return a < b ? a : b;
}
template <class T, class U>
inline T swap(T &a, U &b) {
T tmp = a;
a = b;
b = tmp;
}
const long long INF = (1ll) << 50;
const int mx = 1e5 + 7;
const int mod = 1000000007;
const double pi = 2 * acos(0.0);
int EQ(double d) {
if (fabs(d) < 1e-7) return 0;
return d > 1e-7 ? 1 : -1;
}
int n;
bool arr[mx];
void check(int div) {
for (__typeof((div)-1) i = (0); i <= ((div)-1); ++i) {
bool f = 1;
for (int j = 0; j < n; j += div)
if (!arr[(i + j) % n]) {
f = 0;
break;
}
if (f) {
cout << "YES" << endl;
exit(0);
}
}
}
int main() {
n = ({
int a;
read(a);
a;
});
for (__typeof((n)-1) i = (0); i <= ((n)-1); ++i)
arr[i] = ({
int a;
read(a);
a;
});
int sz = sqrt(n);
for (__typeof(sz) i = (1); i <= (sz); ++i) {
if (n % i == 0) {
int a = i, b = n / i;
if ((n / a) >= 3) check(a);
if ((n / b) >= 3) check(b);
}
}
cout << "NO" << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void smn(T &a, const T &b) {
if (b < a) a = b;
}
template <class T>
inline void smx(T &a, const T &b) {
if (b > a) a = b;
}
template <class T>
inline T rev(const T &a) {
T _ = a;
reverse(_.begin(), _.end());
return _;
}
const double eps = 1e-9;
const long double leps = 1e-14;
const int MN = 2000 + 1000;
bool mp[MN][MN];
bool mark[MN][MN];
int n;
int c1, c2;
pair<int, int> f1, f2, f3, f4;
int dis(pair<int, int> a, pair<int, int> b) {
return ((((a.first - b.first)) * ((a.first - b.first)))) +
((((a.second - b.second)) * ((a.second - b.second))));
}
void dfs(int a, int b) {
mark[a][b] = 1;
if (a < f1.first || (a == f1.first && b < f1.second))
f1 = pair<int, int>(a, b);
if (a < f2.first || (a == f2.first && b > f2.second))
f2 = pair<int, int>(a, b);
if (a > f3.first || (a == f3.first && b > f3.second))
f3 = pair<int, int>(a, b);
if (a > f4.first || (a == f4.first && b < f4.second))
f4 = pair<int, int>(a, b);
for (int i = a - 1; i <= a + 1; i++)
for (int j = b - 1; j <= b + 1; j++)
if (abs(a - i) + abs(j - b) == 1 && i >= 0 && j >= 0 && i < n && j < n &&
mp[i][j] && !mark[i][j])
dfs(i, j);
}
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> mp[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (!mark[i][j] && mp[i][j]) {
f1 = f2 = f3 = f4 = pair<int, int>(i, j);
dfs(i, j);
if (dis(f1, f2) == dis(f2, f3) && dis(f1, f2) == dis(f3, f4) &&
dis(f1, f2) == dis(f4, f1))
c1++;
else
c2++;
}
cout << c2 << " " << c1 << '\n';
return 0;
}
| 5 |
#include <iostream>
using namespace std;
int main()
{
int l, m, n, s, r, i;
while (cin >> l && l)
{
s = 0;
r = 0;
for (i = 0; i < 12; i++)
{
cin >> m >> n;
s += m-n;
if (!r && s >= l)
r = i+1;
}
if (r == 0)
cout << "NA" << endl;
else
cout << r << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long ans, a, b, c;
int main() {
cin >> a >> b >> c;
if (a > b) swap(a, b);
if (a > c) swap(a, c);
if (b > c) swap(b, c);
ans = ((b + a - 1) * (c + a - 1)) - ((a - 1) * a);
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int const N = 2e5 + 20;
int n, m, a[N], p[N], ans;
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int k = 1; k * n <= m; k++) {
p[n - 1] = min(a[n - 1], m * k - (k - 1) * k / 2 * n);
for (int i = n - 2; i >= 0; i--) {
p[i] = min(p[i + 1] - k, a[i]);
}
if (p[0] < (k - 1) * k / 2 * n + k) {
continue;
}
int shift = m - k * n, res = p[0], val = p[0];
for (int i = 1; i < n; i++) {
val += k;
int x = min(shift, p[i] - val);
shift -= x;
val += x;
res += val;
}
ans = max(ans, res);
}
cout << ans << '\n';
}
| 5 |