solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void require(bool cond, const string& message = "Runtime error") {
if (!cond) {
cerr << message << endl;
assert(false);
}
}
void readData() {}
const int NMAX = 2004;
const long long P = 23;
const long long P2 = 123;
long long p[NMAX];
long long p2[NMAX];
void solve() {
p[0] = 1;
p2[0] = 1;
for (int i = 1; i <= int(NMAX - 1); ++i)
p[i] = p[i - 1] * P, p2[i] = p2[i - 1] * P2;
string s;
cin >> s;
string a, b;
cin >> a >> b;
long long pa = 0;
for (int i = 0; i < int(a.size()); ++i) pa += p[i] * (a[i] - 'a' + 1);
long long pa2 = 0;
for (int i = 0; i < int(a.size()); ++i) pa2 += p2[i] * (a[i] - 'a' + 1);
long long push_back = 0;
for (int i = 0; i < int(b.size()); ++i) push_back += p[i] * (b[i] - 'a' + 1);
long long pb2 = 0;
for (int i = 0; i < int(b.size()); ++i) pb2 += p2[i] * (b[i] - 'a' + 1);
vector<pair<long long, long long> > used;
used.reserve(s.size() * s.size());
vector<long long> ps(s.size() + 1);
vector<long long> ps2(s.size() + 1);
for (int i = 0; i < int(s.size()); ++i) {
ps[i + 1] = (s[i] - 'a' + 1) * p[i] + ps[i];
ps2[i + 1] = (s[i] - 'a' + 1) * p2[i] + ps2[i];
}
for (int i = 0; i < int(s.size()); ++i) {
if (i + a.size() > s.size()) break;
if (ps[i + a.size()] - ps[i] != pa * p[i]) continue;
if (ps2[i + a.size()] - ps2[i] != pa2 * p2[i]) continue;
for (int j = i; j < s.size(); ++j) {
if (i + a.size() > j + b.size()) continue;
if (j + b.size() > s.size()) break;
if (ps[j + b.size()] - ps[j] != push_back * p[j]) continue;
if (ps2[j + b.size()] - ps2[j] != pb2 * p2[j]) continue;
used.push_back(
make_pair((ps[j + b.size()] - ps[i]) * p[s.size() - i],
(ps2[j + b.size()] - ps2[i]) * p2[s.size() - i]));
}
}
sort(used.begin(), used.end());
cout << unique(used.begin(), used.end()) - used.begin() << endl;
}
int main() {
ios_base::sync_with_stdio(false);
readData();
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
const int MAX_HW = 405;
char c[MAX_HW][MAX_HW];
vector<int> B;
bool visited[MAX_HW][MAX_HW];
int dx[4] = {0,1,0,-1}, dy[4] = {1,0,-1,0};
ll cntB = 0, cntW = 0;
int H,W;
void dfs(int x, int y)
{
if (visited[x][y]) return;
visited[x][y] = true;
if (c[x][y] == '#') cntB++;
else cntW++;
rep(i,4)
{
int xx = x+dx[i], yy = y+dy[i];
if (xx >= 0 && xx < H && yy >= 0 && yy < W)
{
if (c[x][y] == '#' && c[xx][yy] == '.')
{
dfs(xx,yy);
}
else if (c[x][y] == '.' && c[xx][yy] == '#')
{
dfs(xx,yy);
}
}
}
return;
}
int main()
{
cin >> H >> W;
rep(i,H)
{
rep(j,W)
{
cin >> c[i][j];
}
}
ll ans = 0;
rep(i,H)
{
rep(j,W)
{
cntB = 0, cntW = 0;
dfs(i,j);
ans += cntB * cntW;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 98769876987698889LL;
const int MOD = 1e9 + 7;
const int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy8[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int dx4[] = {0, 0, 1, -1};
const int dy4[] = {1, -1, 0, 0};
const int N = 1e6 + 3;
int a = 0, b = 1;
int n, q;
int c = 0;
int ans[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int x;
cin >> x;
a += x;
if (a < 0) a += n;
a %= n;
b += x;
if (b < 0) b += n;
b %= n;
} else {
if (a % 2 == 1) {
a--;
if (a < 0) a += n;
b++;
b %= n;
} else {
b--;
if (b < 0) b += n;
a++;
a %= n;
}
}
}
int aa = a;
int l = 1;
do {
ans[aa] = l;
l += 2;
aa += 2;
aa %= n;
} while (aa != a);
aa = b;
l = 2;
do {
ans[aa] = l;
l += 2;
aa += 2;
aa %= n;
} while (aa != b);
for (int i = 0; i < n; i++) cout << ans[i] << " ";
}
| 4 |
#include <iostream>
#include <vector>
#include <cstring>
#include <string>
#include <algorithm>
#include <iomanip>
using namespace std;
struct die_t {
int top, front, right, left, back, bottom;
};
#define rotate_swap(x,a,b,c,d) swap(x.a, x.b); swap(x.b, x.c); swap(x.c, x.d);
void rotate_right(die_t& x) { rotate_swap(x, top, left, bottom, right); }
void rotate_left(die_t& x) { rotate_swap(x, top, right, bottom, left); }
void rotate_front(die_t& x) { rotate_swap(x, top, back, bottom, front); }
void rotate_back(die_t& x) { rotate_swap(x, top, front, bottom, back); }
int left(int top, int front) {
int l[4];
if(top == 1) {
l[0] = 5, l[1] = 4, l[2] = 2, l[3] = 3;
}
else if(top == 2) {
l[0] = 3, l[1] = 1, l[2] = 4, l[3] = 6;
}
else if(top == 3) {
l[0] = 1, l[1] = 2, l[2] = 6, l[3] = 5;
}
else if(top == 4) {
l[0] = 6, l[1] = 2, l[2] = 1, l[3] = 5;
}
else if(top == 5) {
l[0] = 6, l[1] = 4, l[2] = 1, l[3] = 3;
}
else {
l[0] = 2, l[1] = 4, l[2] = 5, l[3] = 3;
}
for(int i = 0; i < 4; i++) {
if(front == l[i]) return l[(i + 1) % 4];
}
exit(1);
}
const int MAX = 250;
const int CENTER = 120;
int b[MAX][MAX];
int h[MAX][MAX];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
while(cin >> n, n) {
for(int i = 0; i < MAX; i++) {
for(int j = 0; j < MAX; j++) {
b[i][j] = h[i][j] = 0;
}
}
while(n--) {
int t, f;
cin >> t >> f;
int l = left(t, f);
die_t d = die_t{ t, f, 7 - l, l, 7 - f, 7 - t };
int ni = CENTER, nj = CENTER;
h[ni][nj]++;
int x[] = { 6, 5, 4 };
bool flag = true;
while(flag) {
//if(h[ni][nj] == 1) break;
flag = false;
for(int i = 0; i < 3; i++) {
if(d.front == x[i] && h[ni][nj] - h[ni + 1][nj] >= 2) {
rotate_front(d);
h[ni][nj]--;
h[ni + 1][nj]++;
ni++;
flag = true;
break;
}
if(d.back == x[i] && h[ni][nj] - h[ni - 1][nj] >= 2) {
rotate_back(d);
h[ni][nj]--;
h[ni - 1][nj]++;
ni--;
flag = true;
break;
}
if(d.left == x[i] && h[ni][nj] - h[ni][nj + 1] >= 2) {
rotate_left(d);
h[ni][nj]--;
h[ni][nj + 1]++;
nj++;
flag = true;
break;
}
if(d.right == x[i] && h[ni][nj] - h[ni][nj - 1] >= 2) {
rotate_right(d);
h[ni][nj]--;
h[ni][nj - 1]++;
nj--;
flag = true;
break;
}
}
}
b[ni][nj] = d.top;
}
int c[7] = { 0 };
for(int i = 0; i < MAX; i++) {
for(int j = 0; j < MAX; j++) {
if(b[i][j]) c[b[i][j]]++;
}
}
for(int i = 1; i <= 6; i++) {
cout << c[i];
if(i == 6) cout << endl;
else cout << " ";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[500010];
long long ans;
char str[500010];
struct node {
int len, pos;
long long sum, tag_ch, tag_add;
} t[500010 << 2];
inline void update(int v, int l, int r) {
int mid = l + r >> 1;
if (t[v << 1].len > t[v << 1 | 1].len)
t[v].len = t[v << 1].len, t[v].pos = t[v << 1].pos;
else
t[v].len = t[v << 1 | 1].len, t[v].pos = t[v << 1 | 1].pos;
}
inline void pushup(int v, int l, int r) {
int mid = l + r >> 1;
t[v].sum = t[v << 1].sum + t[v << 1 | 1].sum;
}
inline void pushdown(int v, int l, int r) {
int mid = l + r >> 1;
if (t[v].tag_ch) {
t[v << 1].tag_ch = t[v << 1 | 1].tag_ch = t[v].tag_ch;
t[v << 1].sum = t[v].tag_ch * (mid - l + 1);
t[v << 1 | 1].sum = t[v].tag_ch * (r - mid);
t[v].tag_ch = 0;
}
if (t[v].tag_add) {
t[v << 1].tag_add += t[v].tag_add;
t[v << 1 | 1].tag_add += t[v].tag_add;
t[v << 1].sum += t[v].tag_add * (mid - l + 1);
t[v << 1 | 1].sum += t[v].tag_add * (r - mid);
t[v].tag_add = 0;
}
}
inline void ins(int v, int l, int r, int p_pos) {
if (l == r) {
t[v].len = a[l];
t[v].pos = r;
return;
}
int mid = l + r >> 1;
if (p_pos <= mid)
ins(v << 1, l, mid, p_pos);
else
ins(v << 1 | 1, mid + 1, r, p_pos);
update(v, l, r);
}
inline int query(int v, int l, int r, int l_len) {
if (t[v].len < l_len) return 0;
if (l == r) return t[v].pos;
int mid = l + r >> 1;
if (t[v << 1 | 1].len > l_len) return query(v << 1 | 1, mid + 1, r, l_len);
return query(v << 1, l, mid, l_len);
}
inline void change(int v, int l, int r, int x, int y, int z) {
if (x > y) return;
if (x <= l && r <= y) {
t[v].tag_add = 0;
t[v].tag_ch = z;
t[v].sum = 1ll * z * (r - l + 1);
return;
}
int mid = l + r >> 1;
pushdown(v, l, r);
if (x <= mid) change(v << 1, l, mid, x, y, z);
if (mid < y) change(v << 1 | 1, mid + 1, r, x, y, z);
pushup(v, l, r);
}
inline void add(int v, int l, int r, int x, int y, int z) {
if (x > y) return;
if (x <= l && r <= y) {
t[v].tag_add += z;
t[v].sum += 1ll * z * (r - l + 1);
return;
}
int mid = l + r >> 1;
pushdown(v, l, r);
if (x <= mid) add(v << 1, l, mid, x, y, z);
if (mid < y) add(v << 1 | 1, mid + 1, r, x, y, z);
pushup(v, l, r);
}
int main() {
scanf("%d%s", &n, str + 1);
int lst = 0;
for (int i = 1; i <= n; ++i) {
if (str[i] == '1') {
if (lst)
a[i] = i - lst + 1;
else
lst = i, a[i] = 1;
} else
lst = 0;
}
for (int i = 1; i <= n; ++i) {
if (str[i] == '1') {
int pre = query(1, 1, n, a[i]);
ins(1, 1, n, i);
if (pre)
change(1, 1, n, pre - a[i] + 1, i - a[i], a[i]);
else
change(1, 1, n, 1, i - a[i], a[i]);
add(1, 1, n, i - a[i] + 1, i, 1);
}
ans += t[1].sum;
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 9, mod = 998244353;
long long n, dp[N][3], f1[N], x, y;
vector<int> g[N];
int dfs(int x, int par) {
dp[x][2] = dp[x][1] = 1;
long long men = 1, ans1 = 1;
for (long long i = g[x].size() - 1; i >= 0; i--) {
if (g[x][i] != par) {
dfs(g[x][i], x);
f1[g[x][i]] = ans1;
ans1 *= (dp[g[x][i]][2] + dp[g[x][i]][0] * 2);
ans1 %= mod;
}
}
for (long long i = 0; i < g[x].size(); i++) {
if (g[x][i] != par) {
dp[x][0] =
(dp[x][0] + (((dp[x][1] * (dp[g[x][i]][1] + dp[g[x][i]][2])) % mod) *
f1[g[x][i]])) %
mod;
dp[x][2] *= (dp[g[x][i]][2] + dp[g[x][i]][0]);
dp[x][2] %= mod;
dp[x][1] *= (dp[g[x][i]][2] + dp[g[x][i]][0] * 2);
dp[x][1] %= mod;
men *= (dp[g[x][i]][2] + dp[g[x][i]][0]);
men %= mod;
}
}
dp[x][1] = (dp[x][1] - men + mod) % mod;
}
int main() {
cin >> n;
if (n == 1) {
cout << 1;
return 0;
}
for (long long i = 1; i < n; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
cout << (dp[1][0] + dp[1][2]) % mod;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, R, C;
string arr[1000100];
int best[1000100];
int dp[1000100][22];
int main() {
scanf("%d%d%d", &N, &R, &C);
for (int i = 1; i <= N; i++) {
cin >> arr[i];
}
int r = 1;
int cur = (int)arr[1].size() + 1;
for (int i = 1; i <= N; i++) {
while (r <= N && cur <= C + 1) {
r++;
if (r != N + 1) cur += arr[r].size() + 1;
}
best[i] = r;
cur -= (arr[i].size() + 1);
}
for (int i = 1; i <= N; i++) {
dp[i][0] = best[i];
}
for (int i = 1; i <= log2(N); i++) {
for (int j = 1; j <= N; j++) {
dp[j][i] = dp[dp[j][i - 1]][i - 1];
}
}
int beg = 1;
int ans = 0;
for (int i = 1; i <= N; i++) {
int node = i;
for (int j = 0; j <= log2(R); j++) {
if ((1 << j) & R) {
node = dp[node][j];
}
}
if (ans < node - i) {
ans = node - i;
beg = i;
}
}
cur = beg;
int nx = best[beg];
for (int i = 1; i <= R; i++) {
if (nx == cur) break;
for (int j = cur; j < nx; j++) {
cout << arr[j];
if (j != nx - 1) printf(" ");
}
printf("\n");
cur = best[cur];
nx = best[nx];
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100, M = 3e5 + 100, Q = 5e5 + 100;
struct event {
int from, to;
vector<int> v;
event() {
from = to = -1;
v = vector<int>();
}
event(int from, int to, vector<int> v) : from(from), to(to), v(v) {}
} ev[Q];
pair<int, int> qs[Q], e[M];
vector<pair<int, int> > cmps[N];
bool mark[M];
int par[N], p[N];
vector<int> cmp[N];
int root(int v) { return par[v] = (par[v] == v ? v : root(par[v])); }
void merge(int v, int u, int qI = -1) {
v = root(v);
u = root(u);
if (v == u) return;
if (cmp[v].size() > cmp[u].size()) swap(v, u);
if (qI >= 0) ev[qI] = event(v, u, cmp[v]);
for (auto i : cmp[v]) {
par[i] = u;
cmp[u].push_back(i);
}
}
void undo(int qI) {
int from = ev[qI].from, to = ev[qI].to;
if (from == -1) return;
for (auto v : ev[qI].v) par[v] = from;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < n; i++) {
cin >> p[i];
par[i] = i;
cmp[i] = {i};
}
for (int i = 0; i < m; i++) {
cin >> e[i].first >> e[i].second;
e[i].first--;
e[i].second--;
}
for (int i = 0; i < q; i++) {
cin >> qs[i].first >> qs[i].second;
qs[i].second--;
if (qs[i].first == 2) mark[qs[i].second] = true;
}
for (int i = 0; i < m; i++)
if (!mark[i]) merge(e[i].first, e[i].second);
for (int i = q - 1; i >= 0; i--) {
if (qs[i].first == 1) continue;
int ind = qs[i].second;
merge(e[ind].first, e[ind].second, i);
}
for (int i = 0; i < n; i++) {
for (auto j : cmp[i]) cmps[i].push_back(pair<int, int>(p[j], j));
sort(cmps[i].begin(), cmps[i].end());
}
for (int i = 0; i < q; i++) {
if (qs[i].first == 2) {
undo(i);
continue;
}
int v = qs[i].second;
v = root(v);
while (!cmps[v].empty() &&
(par[cmps[v].back().second] != v || p[cmps[v].back().second] == 0))
cmps[v].pop_back();
if (cmps[v].empty())
cout << "0\n";
else {
int cur = cmps[v].back().second;
cout << p[cur] << "\n";
p[cur] = 0;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long power(long long a, long long r) {
long long res = 1;
for (; r; r >>= 1, a = a * a % mod)
if (r & 1) res = res * a % mod;
return res;
}
long long f[6000], uf[6000];
long long C(int m, int n) {
if (m < n) return 0;
return f[m] * uf[n] % mod * uf[m - n] % mod;
}
long long g(int m, int n, int p) {
long long r = 0;
if (n == 0) return m == 0;
for (int u = 1, i = 0;; u = mod - u, i += 1) {
long long k = C(m - i * p + n - 1, n - 1) * C(n, i) % mod * u % mod;
if (k == 0) break;
r = (r + k) % mod;
}
return r;
}
int main() {
for (int i = 0; i < 6000; i += 1)
uf[i] = power(f[i] = i ? f[i - 1] * i % mod : 1, mod - 2);
int p, r, s;
cin >> p >> s >> r;
long long ans = 0;
for (int a = r; a <= s; a += 1)
for (int x = 1; a * x <= s && x <= p; x += 1) {
ans += C(p - 1, x - 1) * g(s - x * a, p - x, a) % mod *
power(x, mod - 2) % mod;
ans %= mod;
}
ans = ans * power(C(s - r + p - 1, p - 1), mod - 2) % mod;
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
string k, g;
int p = s1.length();
int ans = 0;
for (int i = 0; i <= (p / 2); i++) {
k += s1.at(i);
g = k;
if (i == p / 2) {
g = s1;
}
p = s1.length();
int q, r;
q = g.length();
r = s2.length();
if (r % q == 0 && p % q == 0) {
bool f = 0;
int t = 0;
for (int i = 0; i < (p / q); i++) {
for (int j = 0; j < q; j++) {
if (s1.at(j + t) != g.at(j)) {
f = 1;
}
}
t += q;
if (f) break;
}
t = 0;
for (int i = 0; i < (r / q); i++) {
for (int j = 0; j < q; j++) {
if (s2.at(j + t) != g.at(j)) {
f = 1;
}
}
t += q;
if (f) break;
}
if (!f) {
ans++;
}
}
}
cout << ans << endl;
}
| 4 |
#include<iostream>
#include<cmath>
#include<cstdio>
using namespace std;
int main(){
double x,y;
while(cin >> x >> y, x, y) printf("%.6lf\n", x*x + 2 * x*sqrt(x/2 * (x/2) + y*y) );
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long d, ct = 0, q = 0, l = 0, n = 0, k = 0, m = 0, i, x = 0, y = 0, z = 0,
j = 0, s = 0, r = 0;
int t;
char ch;
double dr;
string ss = "", str = "";
map<long long, long long> mp, mpp;
multiset<long long> st;
long long a[200003];
map<long long, long long> b;
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
cin >> t;
while (t--) {
st.clear();
mp.clear();
ss = "";
str = "";
s = k = d = l = m = r = q = i = j = z = x = y = ct = 0;
b.clear();
cin >> n >> k >> d;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < d; i++)
if (b[a[i]])
b[a[i]]++;
else
b[a[i]] = 1, ct++;
m = ct;
for (i = d; i < n; i++) {
b[a[i - d]]--;
if (b[a[i - d]] == 0) ct--;
b[a[i]]++;
if (b[a[i]] == 1) ct++;
m = min(ct, m);
}
cout << m << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[3];
int total;
int main() {
for (int i = 0; i < 3; i++) cin >> a[i];
int ans = 100000;
for (int i = 1; i <= 100; i++) {
int res = 0;
for (int j = 0; j < 3; j++) {
res += abs(a[j] - i);
}
ans = min(res, ans);
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210, MAX = 0x7f7f7f7f;
int N, cA, cB;
int nm[maxn];
int A[maxn], B[maxn];
int vi[maxn], cnt, vi2[maxn], cnt2;
struct Edge {
int to, cap;
Edge *next, *oppo;
};
Edge *E[maxn], Pr[maxn * maxn << 1];
int Es;
void addedge(int u, int v, int cap) {
Pr[++Es].to = v;
Pr[Es].cap = cap;
Pr[Es].oppo = &Pr[Es + 1];
Pr[Es].next = E[u];
E[u] = &Pr[Es];
Pr[++Es].to = u;
Pr[Es].cap = 0;
Pr[Es].oppo = &Pr[Es - 1];
Pr[Es].next = E[v];
E[v] = &Pr[Es];
}
int s, t;
int H[maxn];
queue<int> Q;
bool Makelevel() {
memset(H, 127, sizeof(H));
H[s] = 0;
Q.push(s);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (Edge *P = E[u]; P; P = P->next)
if (P->cap && H[P->to] > H[u] + 1) {
H[P->to] = H[u] + 1;
Q.push(P->to);
}
}
return H[t] < MAX;
}
int extend(int u, int res) {
int s = 0;
if (u == t) return res;
for (Edge *P = E[u]; P && s < res; P = P->next)
if (P->cap && H[P->to] == H[u] + 1) {
int t;
t = extend(P->to, min(res - s, P->cap));
s += t;
P->cap -= t;
P->oppo->cap += t;
}
if (!s) H[u] = MAX;
return s;
}
int MaxFlow() {
int ans = 0;
while (Makelevel()) ans += extend(s, MAX);
return ans;
}
int Ans[maxn], Anscnt;
void dfs(int u) {
vi[u] = cnt;
for (Edge *P = E[u]; P; P = P->next)
if (!vi[P->to])
if (((nm[u] & 1) && !P->cap) || (!(nm[u] & 1) && !P->oppo->cap))
dfs(P->to);
}
void dfs2(int u) {
Ans[++Anscnt] = u;
vi2[u] = cnt2;
for (Edge *P = E[u]; P; P = P->next)
if (!vi2[P->to])
if (((nm[u] & 1) && !P->cap) || (!(nm[u] & 1) && !P->oppo->cap))
dfs2(P->to);
}
void Work() {
if (cA != cB || MaxFlow() != cA * 2) {
puts("Impossible");
return;
}
for (int i = 1; i <= N; i++)
if (!vi[i]) cnt++, dfs(i);
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) {
int tot = 0;
for (int j = 1; j <= N; j++)
if (vi[j] == i) tot++;
printf("%d", tot);
Anscnt = 0;
cnt2++;
for (int j = 1; j <= N; j++)
if (vi[j] == i) {
dfs2(j);
break;
}
for (int j = 1; j <= Anscnt; j++) printf(" %d", Ans[j]);
printf("\n");
}
}
bool check(int n) {
for (int i = 2; i <= n / i; i++)
if (n % i == 0) return false;
return true;
}
void Init() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d", &nm[i]);
if (nm[i] & 1)
A[++cA] = i;
else
B[++cB] = i;
}
s = 0;
t = N + 1;
for (int i = 1; i <= cA; i++) addedge(s, A[i], 2);
for (int i = 1; i <= cB; i++) addedge(B[i], t, 2);
for (int i = 1; i <= cA; i++)
for (int j = 1; j <= cB; j++)
if (check(nm[A[i]] + nm[B[j]])) addedge(A[i], B[j], 1);
}
int main() {
Init();
Work();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, y, counter = 0;
cin >> n;
bool flag = 1;
int *x;
x = new int[n];
for (int i = 0; i < n; i++) cin >> x[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (x[i] < x[j] && i != j) {
flag = 0;
counter++;
}
}
if (flag) {
m = i + 1;
} else if (counter == 1)
y = x[i];
counter = 0;
flag = 1;
}
cout << m << endl << y;
delete[] x;
x = 0;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int b[999999], n, c[999999];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d",&c[i]);
}
b[1] = 0;
for (int i = 2; i <= n; i++) {
b[i] = b[i / 2] + b[(i + 1) / 2] + i;
}
sort(c, c + n);
for (int i = 0; i < n; i++) {
cout << c[i];
if (i < n - 1) {
cout << ' ';
}
else { cout << endl; }
}
cout << b[n] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) {
if (i % 2 == 0) {
cout << "#";
} else if (j == m - 1 && i % 4 == 1) {
cout << "#";
} else if (j == 0 && i % 4 == 3) {
cout << "#";
} else {
cout << ".";
}
}
cout << "\n";
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s;
int i,j,k,l,r,n,q;
cin >> n>> q;
int arr[n+1];
arr[0]=0;
cin >> s;
for(i=1;i<=n;i++)
{
k=s[i-1]-96;
arr[i]=arr[i-1]+k;
}
for(i=0;i<q;i++)
{
cin >> l >> r;
j=arr[r]-arr[l-1];
cout << j << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int a[maxn], n;
struct seginfo {
struct node {
long long mx, tag;
} t[maxn * 4];
int mov, a[maxn], cnt;
void build(int l, int r, int jd) {
if (l == r)
t[jd].mx = a[l];
else {
int mid = l + r >> 1;
build(l, mid, jd << 1), build(mid + 1, r, jd << 1 | 1);
t[jd].mx = min(t[jd << 1].mx, t[jd << 1 | 1].mx);
}
}
void mark(int jd, long long v) { t[jd].mx += v, t[jd].tag += v; }
void down(int jd) {
if (t[jd].tag)
mark(jd << 1, t[jd].tag), mark(jd << 1 | 1, t[jd].tag), t[jd].tag = 0;
}
void change(int l, int r, int i, int j, int v, int jd) {
if (j < l || i > r) return;
if (i <= l && r <= j)
mark(jd, v);
else {
int mid = l + r >> 1;
down(jd);
change(l, mid, i, j, v, jd << 1),
change(mid + 1, r, i, j, v, jd << 1 | 1);
t[jd].mx = min(t[jd << 1].mx, t[jd << 1 | 1].mx);
}
}
long long query(int l, int r, int i, int j, int jd) {
if (j < l || i > r) return (1ll << 60);
if (i <= l && r <= j) return t[jd].mx;
int mid = l + r >> 1;
down(jd);
return min(query(l, mid, i, j, jd << 1),
query(mid + 1, r, i, j, jd << 1 | 1));
}
void pre_treat(int sig) {
mov = sig;
for (int i = mov; i + 1 <= n; i += 2) a[cnt++] = ::a[i + 1] - ::a[i];
for (int i = 1; i < cnt; i++) a[i] += a[i - 1];
if (!cnt) return;
build(0, cnt - 1, 1);
}
void update(int l, int r, int k) {
if (l < mov) l = mov;
if (l > r) return;
if ((l - mov) & 1) change(0, cnt - 1, (l - mov) / 2, cnt - 1, k, 1);
if (!((r - mov) & 1)) change(0, cnt - 1, (r - mov) / 2, cnt - 1, -k, 1);
}
long long query(int l, int r) { return query(0, cnt - 1, l, r, 1); }
long long single(int l) {
if (l < 0) return 0;
return query(0, cnt - 1, l, l, 1);
}
} z[2];
int tag[maxn];
void add(int p, int v) {
for (; p <= n; p += p & -p) tag[p] += v;
}
int query(int p) {
int tmp = a[p];
for (; p; p -= p & -p) tmp += tag[p];
return tmp;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
z[0].pre_treat(1), z[1].pre_treat(2);
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int type, u, v, k;
scanf("%d%d%d", &type, &u, &v);
u++, v++;
if (type == 1) {
scanf("%d", &k);
z[0].update(u, v, k), z[1].update(u, v, k);
add(u, k), add(v + 1, -k);
} else {
int f_0 = query(u);
if (f_0 < 1) {
printf("0\n");
continue;
}
if (u == v) {
printf("%d\n", int(f_0 >= 0 && f_0 <= 2));
continue;
}
long long ta, tb;
if (u & 1) {
ta = z[0].query((u - 1) / 2, (v - 1) / 2 - (v & 1));
tb = z[1].query((u - 2) / 2 + (u != 1), (v - 2) / 2 - (!(v & 1)));
ta -= z[0].single((u - 1) / 2 - 1);
tb -= z[1].single((u - 2) / 2 + (u != 1) - 1);
} else {
ta = z[1].query((u - 2) / 2, (v - 2) / 2 - !(v & 1));
tb = z[0].query((u - 1) / 2 + 1, (v - 1) / 2 - (v & 1));
ta -= z[1].single((u - 2) / 2 - 1);
tb -= z[0].single((u - 1) / 2);
}
tb += f_0 - 1;
if (ta < 0 || tb < 0)
printf("0\n");
else if ((u ^ v) & 1) {
long long va;
if (u & 1)
va = z[0].query((v - 1) / 2 - (v & 1), (v - 1) / 2 - (v & 1)) -
z[0].single((u - 1) / 2 - 1);
else
va = z[1].query((v - 2) / 2 - !(v & 1), (v - 2) / 2 - !(v & 1)) -
z[1].single((u - 2) / 2 - 1);
printf("%d\n", int(va == 0));
} else {
long long vb = 0;
if (u & 1)
vb = z[1].query((v - 2) / 2 - !(v & 1), (v - 2) / 2 - !(v & 1)) -
z[1].single((u - 2) / 2 + (u != 1) - 1);
else
vb = z[0].query((v - 1) / 2 - (v & 1), (v - 1) / 2 - (v & 1)) -
z[0].single((u - 1) / 2);
vb += f_0 - 1;
printf("%d\n", int(vb == 0));
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int val, id;
} node;
node a[1000005];
bool cmp(node a, node b) {
if (a.val < b.val)
return 1;
else if (a.val == b.val)
return a.id < b.id;
return 0;
}
int dp1[1000005], dp2[1000005];
int d[1000005];
int lowbit(int x) { return x & (-x); }
void update(int x, int num) {
while (x <= 1000003) {
d[x] += num;
x += lowbit(x);
}
}
int getSum(int x) {
int s = 0;
while (x > 0) {
s += d[x];
x -= lowbit(x);
}
return s;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].val);
a[i].id = i;
}
sort(a + 1, a + n + 1, cmp);
a[0].val = 0;
for (int i = 1; i <= n; i++) {
if (a[i].val == a[i - 1].val)
dp1[a[i].id] = dp1[a[i - 1].id] + 1;
else
dp1[a[i].id] = 1;
}
a[n + 1].val = 0;
for (int i = n; i > 0; i--) {
if (a[i].val == a[i + 1].val)
dp2[a[i].id] = dp2[a[i + 1].id] + 1;
else
dp2[a[i].id] = 1;
update(dp2[a[i].id], 1);
}
long long res = 0LL;
for (int i = 1; i < n; i++) {
update(dp2[i], -1);
res += getSum(dp1[i] - 1);
}
printf("%I64d\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
if (n >= 0)
cout << n << endl;
else {
n = -(n);
while (n != 0) {
int x = n % 10;
v.push_back(x);
n = n / 10;
}
if (v[0] > v[1])
v.erase(v.begin());
else
v.erase(v.begin() + 1);
if (v.size() == 1 && v[0] == 0)
cout << 0;
else {
cout << "-";
for (auto it = v.rbegin(); it != v.rend(); it++) {
cout << (*it);
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct st1 {
int index;
int x;
int r;
};
struct st1 obj1[20000];
struct st2 {
int index;
int x;
int y;
};
struct st2 obj2[200100];
bool comp1(struct st1 obj3, struct st1 obj4) { return (obj3.x < obj4.x); }
bool comp2(struct st2 obj3, struct st2 obj4) { return (obj3.x < obj4.x); }
int main() {
int n, i, j, f, m, x, r;
cin >> n;
for (i = 0; i < n; i++) {
cin >> obj1[i].x >> obj1[i].r;
obj1[i].index = i + 1;
}
cin >> m;
for (i = 0; i < m; i++) {
cin >> obj2[i].x >> obj2[i].y;
obj2[i].index = i + 1;
}
sort(obj1, obj1 + n, comp1);
sort(obj2, obj2 + m, comp2);
int pt = 0, count = 0, x1, y1, r1;
map<int, int> mymap;
for (i = 0; i < m; i++) {
if (obj2[i].x <= obj1[pt].x + obj1[pt].r &&
obj2[i].x >= obj1[pt].x - obj1[pt].r) {
x1 = obj2[i].x - obj1[pt].x;
y1 = obj2[i].y;
r1 = obj1[pt].r;
if (x1 * x1 + y1 * y1 <= r1 * r1) {
if (mymap[pt] == 0) {
count++;
mymap[pt] = obj2[i].index;
} else {
if (mymap[pt] > obj2[i].index) {
mymap[pt] = obj2[i].index;
}
}
if (pt < n - 1 && obj2[i].x == obj1[pt + 1].x - obj1[pt + 1].r) {
if (mymap[pt + 1] == 0) {
count++;
mymap[pt + 1] = obj2[i].index;
} else {
if (mymap[pt + 1] > obj2[i].index) {
mymap[pt + 1] = obj2[i].index;
}
}
}
}
}
if (obj2[i].x > obj1[pt].x + obj1[pt].r) {
pt++;
i--;
}
}
cout << count << "\n";
map<int, int>::iterator it;
int hash[100100];
for (i = 0; i < n; i++) {
if (mymap[i] != 0) {
hash[obj1[i].index] = mymap[i];
} else {
hash[obj1[i].index] = -1;
}
}
for (i = 1; i <= n; i++) {
cout << hash[i] << " ";
}
cout << "\n";
cin >> i;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fast() ios_base::sync_with_stdio(0);cin.tie(0)
int INF=1e9;
int N,A,B,C;
vector<int> v;
int dfs(int cur,int a,int b,int c)
{if(cur==N)
{if(min({a,b,c})>0)
return abs(A-a)+abs(B-b)+abs(C-c)-30;
return INF;
}
int w=dfs(cur+1,a,b,c);
int x=dfs(cur+1,a+v[cur],b,c)+10;
int y=dfs(cur+1,a,b+v[cur],c)+10;
int z=dfs(cur+1,a,b,c+v[cur])+10;
return min({w,x,y,z});
}
int32_t main()
{int i;
fast();
cin>>N>>A>>B>>C;
v=vector<int>(N);
for(i=0;i<N;++i)
cin>>v[i];
cout<<dfs(0,0,0,0);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 10000;
const int M = 100000000;
int k, m;
std::vector<int> ans;
bool fl[M];
void init() { scanf("%d%d", &k, &m); }
void search(int val, int r, int p) {
if (r == 0) {
int d = abs(abs(val) - k);
if (d < N) {
ans.push_back(p * N + d);
ans.push_back(d * N + p);
}
return;
}
search(val + (r % 10), r / 10, p);
search(val - (r % 10), r / 10, p);
search(val * (r % 10), r / 10, p);
}
void solve() {
for (int i = 0; i < N; ++i) search(i % 10, i / 10, i);
for (int i = 0; i < (int)ans.size(); ++i) {
int x = ans[i];
if (fl[x])
continue;
else {
fl[x] = true;
printf("%08d\n", x);
--m;
if (m == 0) break;
}
}
}
int main() {
init();
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) {
if (!y) return x;
return gcd(y, x % y);
}
const long long MOD = 119 << 23 | 1;
const long long inf = 1e18;
long long power(long long x, long long y) {
long long res = 1ll;
x %= MOD;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % MOD;
y = y >> 1ll;
x = (x * x) % MOD;
}
return res;
}
long long inv(long long x) {
long long r = 1ll, t = x, k = MOD - 2ll;
while (k) {
if (k & 1ll) r = (long long)r * t % MOD;
t = (long long)t * t % MOD;
k >>= 1;
}
return r;
}
bool isPrime(long long x) {
if (x == 1) return false;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
const int nax = 5e5 + 13;
void prep() {}
void solve() {}
void read() {
int n, m, start, x, y, w;
cin >> n >> m;
vector<long long> d(n);
vector<pair<pair<int, int>, int>> V[n];
vector<pair<int, int>> last(n);
for (int i = 0; i < m; i++) {
cin >> x >> y >> w;
V[x - 1].push_back({{y - 1, w}, i});
V[y - 1].push_back({{x - 1, w}, i});
}
cin >> start;
start--;
bool res[m];
for (int i = 0; i < m; i++) res[i] = false;
set<pair<int, int>> q;
for (int i = 0; i < n; i++) {
d[i] = inf;
last[i] = {inf, -1};
}
d[start] = 0;
long long sum = 0;
q.insert({d[start], start});
while (!q.empty()) {
int akt = (*q.begin()).second;
q.erase(q.begin());
for (auto u : V[akt]) {
int v = u.first.first;
w = u.first.second;
int index = u.second;
if (d[v] > d[akt] + w) {
d[v] = d[akt] + w;
if (last[v].second != -1) {
res[last[v].second] = false;
sum -= last[v].first;
}
sum += w;
res[index] = true;
last[v] = {w, index};
q.insert({d[v], v});
} else if (d[v] == d[akt] + w) {
if (w < last[v].first) {
sum -= last[v].first;
last[v].first = w;
res[last[v].second] = false;
res[index] = true;
sum += w;
last[v] = {w, index};
}
}
}
}
cout << sum << endl;
for (int i = 0; i < m; i++)
if (res[i]) cout << i + 1 << ' ';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
int T = 1;
prep();
for (int i = 1; i <= T; i++) {
read();
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n, p = 0;
cin >> a >> b >> n;
while (n > 0) {
if (p % 2 == 0) {
for (int i = min(a, n); i >= 1; i--)
if (n % i == 0 && a % i == 0) {
n -= i;
p++;
break;
}
} else {
for (int i = min(b, n); i >= 1; i--)
if (n % i == 0 && b % i == 0) {
n -= i;
p++;
break;
}
}
}
((p - 1) % 2 == 0) ? cout << "0" : cout << "1";
}
| 1 |
#include <bits/stdc++.h>
const long long N = 100005, mod = 1000000007;
using namespace std;
long long n, m, i, j, k, l, r, t;
int main() {
cin >> n;
cout << n * 3 / 2 << endl;
for (i = 2; i <= n; i += 2) cout << i << " ";
for (i = 1; i <= n; i += 2) cout << i << " ";
for (i = 2; i <= n; i += 2) cout << i << " ";
return 0;
}
| 3 |
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
double f[1005][1005],dis[1005],a[1005][3];
bool b[1005];
int main()
{
int i,j,k,n;
double xi,xs,ys,xt,yt;
scanf("%lf%lf%lf%lf",&xs,&ys,&xt,&yt);
scanf("%d",&n);
a[0][0]=xs;a[0][1]=ys;a[0][2]=0;
a[n+1][0]=xt;a[n+1][1]=yt;a[n+1][2]=0;
for(i=1;i<=n;i++)
scanf("%lf%lf%lf",&a[i][0],&a[i][1],&a[i][2]);
n++;
for(i=0;i<=n;i++)
for(j=i+1;j<=n;j++){
f[i][j]=f[j][i]=max(0.0,sqrt((a[i][0]-a[j][0])*(a[i][0]-a[j][0])+(a[i][1]-a[j][1])*(a[i][1]-a[j][1]))-(a[i][2]+a[j][2]));
}
for(i=0;i<=1003;i++) dis[i]=1e18;
dis[0]=0;
for(i=0;i<n;i++){
xi=1e18;
k=0;
for(j=0;j<=n;j++){
if(b[j]==0&&dis[j]<xi){
xi=dis[j];
k=j;
}
}
b[k]=1;
for(j=0;j<=n;j++)
dis[j]=min(dis[j],dis[k]+f[k][j]);
}
printf("%.9lf",dis[n]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long p, d;
long long get_digit(long long x, int idx) {
for (int i = 0; i < idx; i++) x /= 10;
return x % 10;
}
int main() {
cin >> p >> d;
long long tmp = p;
int idx = -1;
long long res = tmp;
while (true) {
res = tmp;
idx++;
long long digit = get_digit(tmp, idx);
if (digit == 9) continue;
long long base = 1;
for (int i = 0; i < idx; i++) base *= 10;
if (base > tmp) break;
if (idx > 18) break;
tmp -= base * (digit + 1);
if (p - tmp > d) break;
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int s[5009][5009];
int n, m, k;
vector<pair<pair<int, int>, int> > v;
set<int> r[5009], c[5009];
bool hr[5009], hc[5009];
int main() {
cin >> n >> m >> k;
while (k--) {
int t, x, a;
scanf("%d%d%d", &t, &x, &a);
v.push_back(make_pair(make_pair(x, a), t));
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) r[i].insert(j);
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) c[i].insert(j);
for (int i = v.size() - 1; i >= 0; i--) {
int ch = v[i].second;
int pos = v[i].first.first;
int cl = v[i].first.second;
if (ch == 1) {
if (hr[pos]) continue;
for (set<int>::iterator it = r[pos].begin(); it != r[pos].end(); it++) {
s[pos][*it] = cl;
if (c[*it].find(pos) != c[*it].end()) c[*it].erase(pos);
}
hr[pos] = 1;
} else {
if (hc[pos]) continue;
for (set<int>::iterator it = c[pos].begin(); it != c[pos].end(); it++) {
s[*it][pos] = cl;
if (r[*it].find(pos) != r[*it].end()) r[*it].erase(pos);
}
hc[pos] = 1;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << s[i][j] << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define fi first
#define se second
using namespace std;
struct data {
int q, a, b;
};
long long q, sum = 0;
vector<data> v;
priority_queue<long long> pqs;
priority_queue<long long, vector<long long>,
greater<long long>>
pql;
void solve();
int main() {
cin >> q;
v.resize(q);
for(int i = 0; i < q; ++i) {
cin >> v[i].q;
if(v[i].q == 1) cin >> v[i].a >> v[i].b;
}
solve();
return 0;
}
void solve() {
for(int i = 0; i < q; ++i) {
if(v[i].q == 1) {
sum += v[i].b;
if(pqs.size() != pql.size()) {
sum -= v[i].a;
pqs.push(v[i].a);
sum += pqs.top() * 2;
pql.push(pqs.top());
pqs.pop();
}
else {
sum += v[i].a;
pql.push(v[i].a);
sum -= pql.top() * 2;
pqs.push(pql.top());
pql.pop();
}
}
else
cout << pqs.top() << " "
<< sum + (pqs.size() != pql.size()) * pqs.top()
<< endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main ()
{
int s, w;
cin >> s >> w;
cout << (w >= s?"un":"") << "safe\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
long long int result = 1, Mod = 1000000007;
char temp;
cin >> n >> m;
vector<set<char> > arr(m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> temp, arr[j].insert(temp);
for (int i = 0; i < m; i++) result *= arr[i].size(), result %= Mod;
cout << result << endl;
return 0;
}
| 3 |
#include<iostream>
using namespace std;
int main(){
int x,y;
cin >> x >> y;
if(x<=y){
cout << y-x << endl;
}
else{
cout << x-y << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
using matrix = vector<vector<long long>>;
const int MAXN = 520;
int a[MAXN];
int dp[MAXN][MAXN];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < MAXN; ++i) {
dp[i][0] = dp[i][1] = 1;
}
for (int len = 2; len <= n; ++len) {
for (int i = 0; i <= n - len; ++i) {
dp[i][len] = 1e9 + 1;
for (int j = 1; j < len; ++j) {
dp[i][len] = min(dp[i][len], dp[i][j] + dp[i + j][len - j]);
}
for (int j = i + 1; j < i + len; ++j) {
if (a[i] == a[j]) {
dp[i][len] = min(dp[i][len], dp[i + 1][j - i - 1] +
dp[j + 1][len - (j - i + 1)] -
(j == i + len - 1));
}
}
}
}
cout << dp[0][n];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,a,b,c,d; string s;
cin>>n>>a>>b>>c>>d>>s;
if(c<d) cout<<(s.substr(a-1,d-a+1).find("##")==-1?"Yes":"No")<<"\n";
else cout<<((s.substr(b-2,d-b+3).find("...")!=-1&&s.substr(a-1,c-a+1).find("##")==-1)?"Yes":"No")<<"\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> d;
long long hug(long long x) { return (x * (x + 1)) / 2; }
int main() {
long long n, x, a;
cin >> n >> x;
for (long long i = 0; i < n; i++) {
cin >> a;
d.push_back(a);
}
long long i = 0, j = 0, H = hug(d[0]), maxbr = -1, brdana = d[0], visak;
while (i < n) {
if (brdana < x) {
j++;
if (j == n) {
j = 0;
}
H += hug(d[j]);
brdana += d[j];
continue;
}
visak = brdana - x;
if ((H - hug(visak)) > maxbr) {
maxbr = H - hug(visak);
}
H -= hug(d[i]);
brdana -= d[i];
i++;
}
cout << maxbr << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int compare(const void* a, const void* b) { return *(int*)a - *(int*)b; }
int main() {
int n, d, m, total = 0;
cin >> n >> d;
int* arr = new int[n];
for (int i = 0; i < n; i++) cin >> arr[i];
cin >> m;
qsort(arr, n, sizeof(int), compare);
if (m <= n)
for (int i = 0; i < m; i++) total += arr[i];
else {
for (int i = 0; i < n; i++) total += arr[i];
for (int i = 0; i < m - n; i++) total -= d;
}
cout << total;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pi;
const int N = 1e6 + 10;
int n, siz, pos[N];
char s[N], t[N];
deque<int> q;
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
scanf("%s", t + 1);
int l = 1, r = 0, ans = 0;
pos[n + 1] = n + 1;
for (int i = n, cur = n; i >= 1; i--) {
if (t[i] == t[i + 1] && i >= pos[i + 1]) {
pos[i] = pos[i + 1];
continue;
}
cur = min(cur, i);
while (cur && s[cur] != t[i]) cur--;
if (!cur) {puts("-1"); return 0;}
pos[i] = cur;
if (i >= pos[i + 1]) {
siz--;
q.push_front(pos[i + 1] - siz - 1);
while (q.back() + siz >= i) q.pop_back();
q.push_back(i - siz);
} else {
while (!q.empty()) q.pop_back();
if (pos[i] < i) q.push_back(i - siz);
}
ans = max(ans, (int) q.size());
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int t;
string p = "abacaba";
string p1;
long long int check(string s, long long int ind) {
p1 = s;
if (p1.substr(ind, 7) == p) return true;
for (long long int i = ind; i < ind + 7; i++) {
if (p1[i] != p[i - ind] && p1[i] != '?') {
return false;
} else
p1[i] = p[i - ind];
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
vector<pair<long long int, long long int>> a(m + 1);
vector<long long int> a1(m + 1), c(m + 2, 0);
long long int ans = 0;
for (long long int i = 1; i <= m; i++) {
cin >> a[i].second >> a[i].first;
a1[i] = a[i].second;
}
sort(a1.begin() + 1, a1.begin() + m + 1);
for (long long int i = m; i >= 1; i--) c[i] = c[i + 1] + a1[i];
for (long long int i = 1; i <= m; i++) {
long long int t1 = a[i].first, t2 = a[i].second;
long long int ind =
lower_bound(a1.begin() + 1, a1.begin() + m + 1, t1) - a1.begin();
long long int nos = m - ind + 1;
long long int ans1 = c[max(ind, m - n + 1)];
if (nos >= n) {
ans = max(ans, ans1);
continue;
}
ans1 += (n - nos - 1) * t1 + t2;
if (t2 >= t1) ans1 -= t2, ans1 += t1;
ans = max(ans, ans1);
}
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long ar[300004];
long long sum[300004];
map<long long, long long> head;
map<long long, long long> tail;
int main() {
scanf("%I64d", &n);
for (long long i = 1; i <= n; i++) {
scanf("%I64d", &ar[i]);
if (ar[i] <= 0)
sum[i] = sum[i - 1];
else
sum[i] = sum[i - 1] + ar[i];
if (!head[ar[i]]) head[ar[i]] = i;
tail[ar[i]] = i;
}
long long ans = -1LL << 60, left, right;
map<long long, long long>::iterator it1 = head.begin(), it2 = tail.begin();
for (; it1 != head.end() && it2 != tail.end(); it1++, it2++) {
long long val = (*it1).first, x = (*it1).second, y = (*it2).second;
if (x == y) continue;
long long tmp = 0;
if (val < 0) tmp = 2 * val;
tmp += sum[y] - sum[x - 1];
if (tmp > ans) ans = tmp, left = x, right = y;
}
vector<long long> v;
for (long long i = 1; i <= n; i++)
if (i < left || i > right || (i > left && i < right && ar[i] < 0))
v.push_back(i);
long long sz = v.size();
printf("%I64d %I64d\n", ans, sz);
for (long long i = 0; i < sz; i++) printf("%I64d ", v[i]);
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000000 + 10;
const int NUM = 3;
long long ans = 0;
int n, m;
char s[MAX], t[MAX];
int sum[MAX][NUM][NUM];
int change(char a) {
if (a == 'R')
return 0;
else if (a == 'G')
return 1;
else
return 2;
}
int main() {
scanf("%s%s", s + 1, t + 1);
n = strlen(s + 1);
m = strlen(t + 1);
int l = 1, r = 1, j, k, i;
for (i = 1; i <= m; ++i) {
for (j = 0; j < 3; ++j)
for (k = 0; k < 3; ++k) sum[i][j][k] = sum[i - 1][j][k];
if (i != 1) sum[i][change(t[i - 1])][change(t[i])]++;
}
while (r + 1 <= m && t[r] != s[1]) ++r;
ans += r - l + 1;
for (i = 2; i <= n; ++i) {
++l, ++r;
if (t[l - 1] != s[i - 1]) --l;
if (l > m) break;
l = min(l, m);
r = min(r, m);
while (r + 1 <= m && t[r] != s[i]) ++r;
ans += r - l + 1;
if (change(s[i]) != change(s[i - 1]))
ans -= sum[r][change(s[i])][change(s[i - 1])] -
sum[l - 1][change(s[i])][change(s[i - 1])];
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long modulo(long long base, long long exponent, long long modulus);
long long choose(long long n, long long k);
long long inverse(long long a, long long m);
void build() {}
int main() {
build();
long long n;
cin >> n;
if (n < 5) {
cout << (n * (n - 1)) / 2 << endl;
return 0;
}
long long five = 5;
long long nine = 9;
long long realfive;
long long realnine;
while (five <= n) {
realfive = five;
realnine = nine;
five = 10 * five;
nine = 10 * nine + 9;
}
nine = realnine;
five = realfive;
long long ans = 0;
while (five <= n) {
ans += min(nine - 1, n) - (five - 1);
nine = nine + (realnine + 1);
five = ceil(nine / 2.0);
}
cout << ans << endl;
return 0;
}
long long modulo(long long base, long long exponent, long long modulus) {
if (modulus == 1) return 0;
long long result = 1;
base = base % modulus;
while (exponent > 0) {
if (exponent % 2 == 1) {
result = (result * base) % modulus;
}
exponent = exponent >> 1;
base = (base * base) % modulus;
}
return result;
}
long long choose(long long n, long long k) {
if (k == 0) return 1;
return (n * choose(n - 1, k - 1)) / k;
}
void EE(long long a, long long b, long long &co1, long long &co2) {
if (a % b == 0) {
co1 = 0;
co2 = 1;
return;
}
EE(b, a % b, co1, co2);
long long temp = co1;
co1 = co2;
co2 = temp - co2 * (a / b);
}
long long inverse(long long a, long long m) {
long long x, y;
EE(a, m, x, y);
if (x < 0) x += m;
return x;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
scanf("%d%d", &n, &m);
int ans = 987654321;
for (int i = 0; i <= m; i++) {
int x = i * 6;
int a = max(0, m - 2 * i);
int b = x - 3 + 6 * a;
int c = max(0, n - 2 * i);
int d = x + 2 * c;
ans = min(ans, max(b, d));
}
printf("%d", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
const int mod = 1e9 + 7;
int G[maxn][maxn], A[maxn][maxn], n, dp[maxn], g[maxn], w[maxn], q[maxn];
int Power(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = 1ll * ret * x % mod;
y >>= 1;
x = 1ll * x * x % mod;
}
return ret;
}
int Det(int A[maxn][maxn], int n) {
int ans = 1, sgn = 0;
for (int i = 0, cur = 0; i < n; ++i) {
int nxt = -1;
for (int j = cur; j < n; ++j)
if (A[j][i]) {
nxt = j;
break;
}
if (nxt == -1) continue;
if (cur != nxt) sgn ^= 1;
for (int j = 0; j < n; ++j) swap(A[cur][j], A[nxt][j]);
int t = Power(A[cur][i], mod - 2);
for (int j = cur + 1; j < n; ++j) {
int z = 1ll * A[j][i] * t % mod;
for (int k = i; k < n; ++k)
A[j][k] = (A[j][k] - 1ll * A[cur][k] * z % mod + mod) % mod;
}
++cur;
}
for (int i = 0; i < n; ++i) ans = 1ll * ans * A[i][i] % mod;
if (sgn && ans) ans = mod - ans;
return ans;
}
int Solve(int x) {
memset(A, 0, sizeof(A));
for (int i = 0; i < n; ++i) {
int sum = 0;
for (int j = 0; j < n; ++j)
if (i != j) {
if (G[i][j] == 1)
A[i][j] = x;
else
A[i][j] = 1;
sum += A[i][j];
A[i][j] = mod - A[i][j];
}
A[i][i] = sum;
}
return Det(A, n - 1);
}
inline void Update(int& x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int main(int argc, char* argv[]) {
scanf("%d", &n);
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) G[i][j] = G[j][i] = 1;
for (int i = 2; i <= n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
G[u][v] = G[v][u] = 0;
}
for (int i = 0; i < n; ++i) g[i] = Solve(i);
for (int i = 0; i < n; ++i) {
memset(dp, 0, sizeof(dp));
int y = g[i];
dp[0] = 1;
for (int j = 0; j < n; ++j)
if (i != j) {
y = 1ll * y * Power(i - j + mod, mod - 2) % mod;
for (int k = n - 1; k >= 0; --k) {
Update(dp[k + 1], dp[k]);
dp[k] = 1ll * dp[k] * (mod - j) % mod;
}
}
for (int e = 0; e < n; ++e)
for (int j = 0; j <= e; ++j) Update(w[e], 1ll * dp[j] * y % mod);
}
q[0] = w[0];
for (int i = 1; i < n; ++i) q[i] = (w[i] - w[i - 1] + mod) % mod;
for (int i = n - 1; i >= 0; --i) printf("%d ", q[i]);
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
const int inf = 0x3f3f3f3f;
void check_max(int &a, int b) { a = max(a, b); }
void check_min(int &a, int b) { a = min(a, b); }
int maze[maxn][maxn];
int n, m;
int moving[4][2] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
bool check(int x, int y) {
int nx = x + 1, ny = y + 1;
if (nx > n || ny > m) return false;
return true;
}
int calc(int x, int y) {
int res = 0;
for (int i = 0; i < 4; i++) {
int nx = x + moving[i][0], ny = moving[i][1] + y;
if (maze[nx][ny] == 1) res++;
}
return res;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%1d", &maze[i][j]);
int ans = 0;
vector<pair<int, int> > st;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (check(i, j)) {
if (calc(i, j) == 0)
continue;
else if (calc(i, j) == 1) {
ans += 3;
int sign = 0;
for (int k = 0; k < 4; k++) {
int nx = i + moving[k][0], ny = j + moving[k][1];
if (maze[nx][ny] == 1) {
st.push_back({nx, ny});
maze[nx][ny] = 0;
} else if (sign != 2 && maze[nx][ny] == 0) {
sign++;
st.push_back({nx, ny});
maze[nx][ny] = 1;
}
}
int flag = 0;
for (int k = 0; k < 4; k++) {
int nx = i + moving[k][0], ny = j + moving[k][1];
if (maze[nx][ny] == 0) {
st.push_back({nx, ny});
maze[nx][ny] = 1;
} else if (maze[nx][ny] == 1 && !flag) {
st.push_back({nx, ny});
maze[nx][ny] = 0;
flag = 1;
}
}
for (int k = 0; k < 4; k++) {
int nx = i + moving[k][0], ny = j + moving[k][1];
if (maze[nx][ny] == 1) {
maze[nx][ny] = 0;
st.push_back({nx, ny});
}
}
} else if (calc(i, j) == 2) {
ans += 2;
int flag = 0;
for (int k = 0; k < 4; k++) {
int nx = i + moving[k][0], ny = j + moving[k][1];
if (maze[nx][ny] == 0) {
st.push_back({nx, ny});
maze[nx][ny] = 1;
} else if (maze[nx][ny] == 1 && !flag) {
st.push_back({nx, ny});
maze[nx][ny] = 0;
flag = 1;
}
}
for (int k = 0; k < 4; k++) {
int nx = i + moving[k][0], ny = j + moving[k][1];
if (maze[nx][ny] == 1) {
maze[nx][ny] = 0;
st.push_back({nx, ny});
}
}
} else if (calc(i, j) == 3) {
ans += 1;
for (int k = 0; k < 4; k++) {
int nx = i + moving[k][0], ny = j + moving[k][1];
if (maze[nx][ny] == 1) {
maze[nx][ny] = 0;
st.push_back({nx, ny});
}
}
} else if (calc(i, j) == 4) {
ans += 4;
for (int k = 0; k < 3; k++) {
int nx = i + moving[k][0], ny = j + moving[k][1];
st.push_back({nx, ny});
maze[nx][ny] = 0;
}
int sign = 0;
for (int k = 0; k < 4; k++) {
int nx = i + moving[k][0], ny = j + moving[k][1];
if (maze[nx][ny] == 1) {
st.push_back({nx, ny});
maze[nx][ny] = 0;
} else if (sign != 2 && maze[nx][ny] == 0) {
sign++;
st.push_back({nx, ny});
maze[nx][ny] = 1;
}
}
int flag = 0;
for (int k = 0; k < 4; k++) {
int nx = i + moving[k][0], ny = j + moving[k][1];
if (maze[nx][ny] == 0) {
st.push_back({nx, ny});
maze[nx][ny] = 1;
} else if (maze[nx][ny] == 1 && !flag) {
st.push_back({nx, ny});
maze[nx][ny] = 0;
flag = 1;
}
}
for (int k = 0; k < 4; k++) {
int nx = i + moving[k][0], ny = j + moving[k][1];
if (maze[nx][ny] == 1) {
maze[nx][ny] = 0;
st.push_back({nx, ny});
}
}
}
}
printf("%d\n", ans);
for (int i = 0; i < st.size(); i++) {
printf("%d %d ", st[i].first, st[i].second);
if ((i + 1) % 3 == 0) printf("\n");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int interact(vector<int> S) {
cout << "? " << S.size() << ' ';
for (int i : S) {
cout << i << ' ';
}
cout << endl;
int x;
cin >> x;
return x;
}
vector<int> get_complement(vector<int> v, int n) {
vector<int> ask, occur(n + 1);
for (int i : v) occur[i] = 1;
for (int i = 1; i <= n; ++i) {
if (!occur[i]) ask.push_back(i);
}
return ask;
}
int main() {
int tc;
cin >> tc;
while (tc--) {
int n, k;
cin >> n >> k;
vector<vector<int>> S(k);
vector<int> ans(k);
for (int i = 0; i < k; ++i) {
int c;
cin >> c;
S[i].resize(c);
for (int j = 0; j < c; ++j) {
cin >> S[i][j];
}
}
vector<int> ask;
for (int i = 1; i <= n; ++i) {
ask.push_back(i);
}
int Max_element = interact(ask);
int st = 0, en = k - 1;
while (st < en) {
int mid = (st + en) / 2;
ask.clear();
for (int i = 0; i <= mid; ++i) {
for (int j : S[i]) ask.push_back(j);
}
int x = interact(ask);
if (x == Max_element)
en = mid;
else
st = mid + 1;
}
ask = get_complement(S[st], n);
for (int i = 0; i < k; ++i) {
if (i == st)
ans[i] = interact(ask);
else
ans[i] = Max_element;
}
cout << "! ";
for (int i : ans) cout << i << ' ';
cout << endl;
string correct;
cin >> correct;
}
return 0;
}
| 6 |
#include "bits/stdc++.h"
using namespace std;
int main() {
int K;
cin >> K;
cout << K/2*(K-K/2) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
long long mod = 1000000007;
using namespace std;
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
b >>= 1;
a = (a * a) % mod;
}
return res;
}
bool isprime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}
void solve() {
string s, t;
cin >> s >> t;
string p = s;
sort(p.begin(), p.end());
long long n = p.size();
if (n < 3) {
cout << p << endl;
return;
}
map<char, int> mp;
for (auto x : p) {
mp[x]++;
}
char first;
long long ib = 1001, ic = 1001;
for (int i = 0; i < 3; i++) {
if (t[i] == 'b')
ib = i;
else if (t[i] == 'c')
ic = i;
}
if (mp['a'] == 0 || mp['b'] == 0 || mp['c'] == 0 || t[0] != 'a') {
cout << p << endl;
return;
}
if (ib < ic)
first = 'b';
else
first = 'c';
string ans = "";
for (char c = 'a'; c <= 'z'; c++) {
if (c == 'b' && first == 'b')
ans += string(mp['c'], 'c');
else if (c == 'c' && first == 'b')
ans += string(mp['b'], 'b');
else
ans += string(mp[c], c);
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int rd() {
char c = getchar();
int s = 0, f = 1;
while (c > '9' || c < '0') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') s = s * 10 + c - '0', c = getchar();
return s * f;
}
const int N = 100100;
int n, m, c[N], L, R;
void add(int x, int y) {
while (x <= n) c[x] += y, x += x & -x;
}
int sum(int x) {
int res = 0;
while (x > 0) res += c[x], x -= x & -x;
return res;
}
int main() {
L = 1;
R = n = rd(), m = rd();
int flag = 0;
for (int i = 1; i <= n; ++i) add(i, 1);
while (m--) {
int op = rd();
if (op == 1) {
int p = rd();
if (p <= (R - L + 1 >> 1)) {
if (!flag) {
for (int i = p + L - 1, j = p + L; i >= L; i--, j++)
add(j, sum(i) - sum(i - 1));
L = L + p;
} else {
for (int i = R - p, j = R - p + 1; j <= R; i--, j++)
add(i, sum(j) - sum(j - 1));
R = R - p;
}
} else {
if (!flag) {
for (int i = L + p - 1, j = p + L; j <= R; j++, i--)
add(i, sum(j) - sum(j - 1));
R = L + p - 1;
} else {
for (int i = R - p, j = R - p + 1; i >= L; i--, j++)
add(j, sum(i) - sum(i - 1));
L = R - p + 1;
}
flag ^= 1;
}
} else if (op == 2) {
int l = rd() + 1, r = rd();
if (!flag) {
l = L + l - 1;
r = L + r - 1;
printf("%d\n", sum(r) - sum(l - 1));
} else {
l = R - l + 1;
r = R - r + 1;
printf("%d\n", sum(l) - sum(r - 1));
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
//https://atcoder.jp/contests/abc076/tasks/abc076_d
int n, x[103], v[102], m;
double l, r, ans = 0;
double f(double t, int i) {
if (t < x[i])
return v[i] + x[i] - t;
if (t > x[i + 1])
return v[i] + t - x[i + 1];
return v[i];
}
double sup(double t) {
double rv = m;
for (int i = 0; i < n + 2; i++) {
double s = f(t, i);
rv = min(rv, s);
}
return rv;
}
int main() {
cin >> n;
for (int i = 0, t; i < n; i++) {
cin >> t;
x[i + 2] = x[i + 1] + t;
}
x[n + 2] = x[n + 1];
for (int i = 0; i < n; i++) {
cin >> v[i + 1];
m = max(m, v[i + 1]);
}
for (double t = 0; t < x[n + 1]; t += 0.5)
ans += sup(t) + sup(t + 0.5);
cout <<fixed<< ans / 4 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long a = 1, b;
while (k - m * 2 > 0) {
k -= m * 2;
a++;
}
b = k / 2 + k % 2;
cout << a << ' ' << b << ' ';
if (k % 2 == 0)
cout << 'R';
else
cout << 'L';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const vector<int> bs = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 4, 3, 2, 1, 0};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
int m = bs.size(), l = 0, r = 0;
vector<int> p, q;
while (l < m && bs[l] != a) l++, r++;
while (r < m && bs[r] != b) p.emplace_back(bs[r++]);
r = ++l;
while (l < m && bs[l] != a) l++, r++;
while (r < m && bs[r] != b) q.emplace_back(bs[r++]);
if (int(p.size()) > int(q.size())) swap(p, q);
for (int j = 0; j < int(p.size()); j++) {
cout << p[j] << " ";
}
cout << b << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acosl(-1);
const int maxn = 2010;
const long long mod = 1e9 + 7;
const int inf = 1e9;
const long double eps = 1e-8;
int n;
int x[maxn], y[maxn];
int gone[maxn];
long double X, Y;
vector<pair<long double, long double> > ans;
int dcmp(long double x) {
if (x > eps) return 1;
if (x < -eps) return -1;
return 0;
}
bool check(long double dx, long double dy) {
long double len = sqrt(dx * dx + dy * dy);
dx /= len, dy /= len;
vector<long double> vec;
for (int i = 0; i < n; i++)
if (!gone[i]) {
vec.push_back(x[i] * dx + y[i] * dy);
}
sort(vec.begin(), vec.end());
long double c = X * dx + Y * dy;
int half = vec.size() / 2;
int Size = vec.size() - 1;
for (int i = 0; i < half; i++)
if (dcmp(vec[i] + vec[Size - i] - 2 * c)) {
return 0;
}
Size++;
if (half * 2 < Size && dcmp(vec[half] - c)) return 0;
if (dcmp(dx) < 0)
dx = -dx, dy = -dy;
else if (dcmp(dx) == 0)
dy = 1;
ans.push_back({dx, dy});
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &x[i], &y[i]), X += x[i], Y += y[i];
X /= n, Y /= n;
int num = n;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
if (!gone[i] && dcmp(x[i] - X) == 0 && dcmp(y[i] - Y) == 0) {
gone[i] = 1;
num--;
}
if (gone[i] || gone[j]) continue;
if (dcmp(x[i] + x[j] - 2 * X) == 0 && dcmp(y[i] + y[j] - 2 * Y) == 0) {
gone[i] = gone[j] = 1;
num -= 2;
}
}
if (num <= 1) {
printf("-1\n");
return 0;
}
if (num & 1) {
for (int i = 0; i < n; i++)
if (!gone[i]) {
long double dx = x[i] - X, dy = y[i] - Y;
check(-dy, dx);
}
} else {
int j = 0;
while (gone[j]) j++;
for (int i = j + 1; i < n; i++)
if (!gone[i]) {
long double midx = (long double)(x[i] + x[j]) / 2;
long double midy = (long double)(y[i] + y[j]) / 2;
long double dx = midx - X, dy = midy - Y;
check(-dy, dx);
}
}
int cnt = 0;
for (int i = 0; i < ans.size(); i++) {
bool ok = 1;
for (int j = 0; j < i; j++) {
if (dcmp(ans[i].first - ans[j].first) == 0 &&
dcmp(ans[i].second - ans[j].second) == 0) {
ok = 0;
break;
}
}
cnt += ok;
}
printf("%d", cnt);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a, b, c, d, e, f;
cin >> n;
cin >> c >> d;
cin >> a >> b;
cin >> e >> f;
int book1 = 0, book2 = 0;
if (a < c && b < d) {
book1 = 1;
} else if (a < c && b > d) {
book1 = 2;
} else if (a > c && b < d) {
book1 = 3;
} else if (a > c && b > d) {
book1 = 4;
}
if (e < c && f < d) {
book2 = 1;
} else if (e < c && f > d) {
book2 = 2;
} else if (e > c && f < d) {
book2 = 3;
} else if (e > c && f > d) {
book2 = 4;
}
if (book1 == book2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 100;
const long double pi = acos(-1.0);
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 - '0');
ch = getchar();
}
return x * f;
}
inline long long readll() {
long long x = 0;
int 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 - '0');
ch = getchar();
}
return x * f;
}
int main() {
int T = read();
while (T--) {
int a1 = read(), b1 = read(), a2 = read(), b2 = read();
if (a1 == a2) {
if (b1 + b2 == a1) {
puts("Yes");
continue;
}
}
if (a1 == b2) {
if (b1 + a2 == a1) {
puts("Yes");
continue;
}
}
if (b1 == a2) {
if (a1 + b2 == b1) {
puts("Yes");
continue;
}
}
if (b1 == b2) {
if (a1 + a2 == b1) {
puts("Yes");
continue;
}
}
puts("No");
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
int n, A[N], root;
vector<int>V[N];
using ll = long long;
void Dfs (int u, int fa) {
if (V[u].size() == 1) return ;
ll S = -A[u], D = 0;
for (auto v : V[u]) if (v != fa) {
Dfs(v, u);
S += A[v];
if (A[v] > D) D = A[v];
}
if (S < 0) puts("NO"), exit(0);
if (A[u] < D) puts("NO"), exit(0);
A[u] -= S;
if (A[u] < 0) puts("NO"), exit(0);
}
int main () {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &A[i]);
if (n == 2) return puts(A[1] == 1 && A[2] == 1 ? "YES" : "NO"), 0;
for (int i = 1, u, v; i < n; ++i) scanf("%d%d", &u, &v), V[u].emplace_back(v), V[v].emplace_back(u);
for (int i = 1; i <= n; ++i) if (V[i].size() > 1) { root = i; break; }
Dfs(root, 0);
puts(A[root] ? "NO" : "YES");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[10000];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), a[i] += a[i - 1];
double ans = 0;
for (int i = 0; i <= n; ++i)
for (int j = i + k; j <= n; ++j)
ans = max(ans, 1. * (a[j] - a[i]) / (j - i));
printf("%.10lf", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool is_any_abs(string s) {
for (char i : s) {
if (i == '0') return true;
}
return false;
}
int main() {
int n, d;
cin >> n >> d;
string s;
int ans = 0, cur = 0;
while (d--) {
cin >> s;
if (is_any_abs(s))
cur++;
else {
ans = max(ans, cur);
cur = 0;
}
}
ans = max(ans, cur);
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1e6 + 9, MOD = 1e9 + 7;
long long int Fact[N];
void getFactorial(long long int n) {
Fact[1] = Fact[0] = 1;
for (long long int i = 2; i <= n; i++) Fact[i] = i * Fact[i - 1] % MOD;
}
long long int power(long long int n, long long int p, long long int mod) {
long long int t = 1;
while (p) {
if (p & 1) t = (n * t) % mod;
n = (n * n) % mod;
p >>= 1;
}
return t;
}
long long int mulInv(long long int x, long long int mod) {
return power(x, mod - 2, mod);
}
long long int comp(long long int n, long long int k) {
return (Fact[n] * mulInv(Fact[n - k] * Fact[k] % MOD, MOD)) % MOD;
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
if (2 * k > min(n - 1, m - 1)) {
puts("0");
return 0;
}
getFactorial(N - 1);
printf("%d\n", (int)comp(n - 1, 2 * k) * comp(m - 1, 2 * k) % MOD);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<bool> primes(100006, false);
void sieve() {
for (long long i = 3; i <= 100006; i += 2) {
primes[i] = 1;
}
for (long long i = 3; i <= 100006; i += 2) {
if (primes[i] == 1) {
for (long long j = i * i; j <= 100006; j += i) {
primes[j] = 0;
}
}
}
primes[2] = 1;
primes[0] = primes[1] = 0;
}
int recpow(int x, int n) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return recpow((x * x), n / 2);
else
return (x * recpow((x * x), (n - 1) / 2));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string str;
int k;
cin >> str >> k;
set<char> s;
for (int i = 0; i < str.length(); i++) s.insert(str[i]);
int x = s.size();
if (str.length() < k)
cout << "impossible" << endl;
else {
if (s.size() > k)
cout << 0 << endl;
else
cout << abs(x - k) << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n;
string s;
int main() {
iostream::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
long long ans = 0, ct = 1;
while (ct * 10LL - 1 <= n) {
ct *= 10LL;
ans += 9LL;
}
long long kp = n - ct + 1;
while (kp) {
ans += kp % 10;
kp /= 10;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
long double PI = 4 * atan(1);
int n, m, k, a[100001], b, pos[100001];
long long ans;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i < n + 1; i++) {
cin >> a[i];
pos[a[i]] = i;
}
for (int i = 0; i < m; i++) {
cin >> b;
ans += ((pos[b] - 1) / k);
ans++;
if (pos[b] == 1) continue;
pos[b]--;
pos[a[pos[b]]]++;
a[pos[b] + 1] = a[pos[b]];
a[pos[b]] = b;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin>>S;
if (S[0]=='C') {
cout<<"Rainy" ;
}
else if (S[0]=='R'){
cout<<"Sunny";
}
else{
cout << "Cloudy" << endl;
}
}
| 0 |
#include <iostream>
#include <vector>
#include <string>
using namespace std;
struct RollingHash {
int n;
static const unsigned P = 1000000007U;
vector<unsigned long long> pow, phash;
RollingHash() : n(0) {}
template<typename T>
RollingHash(const T& s, unsigned long long Q = 1) {
n = s.size();
pow.resize(n + 1); phash.resize(n + 1);
pow[0] = Q; phash[0] = 0;
for(int i = 0; i < n; i++) {
pow[i + 1] = pow[i] * P;
phash[i + 1] = s[i] + phash[i] * P;
}
}
unsigned long long get(int i) const { return phash[i]; }
unsigned long long get(int i, int j) const { return get(j) - get(i) * pow[j - i]; }
};
int H, W, P;
struct Pat {
string b[100];
};
string b[1000];
RollingHash h[1000];
Pat ps[8];
RollingHash hs[8][100];
Pat rotate(Pat p) {
Pat r;
for(int i = 0; i < P; i++) {
r.b[i] = string(P, '0');
}
for(int i = 0; i < P; i++) {
for(int j = 0; j < P; j++) {
r.b[j][P - 1 - i] = p.b[i][j];
}
}
return r;
}
Pat mirror(Pat p) {
Pat r;
for(int i = 0; i < P; i++) {
r.b[i] = string(P, '0');
for(int j = 0; j < P; j++) {
r.b[i][P - 1 - j] = p.b[i][j];
}
}
return r;
}
int conv(char c) {
if('A' <= c && c <= 'Z') return c - 'A';
if('a' <= c && c <= 'z') return 26 + c - 'a';
if(isdigit(c)) return 52 + c - '0';
if(c == '+') return 62;
return 63;
}
int check(int x, int y, int k) {
for(int i = 0; i < P; i++) {
if(h[y + i].get(x, x + P) != hs[k][i].get(0, P)) return false;
}
return true;
}
void solve() {
int cnt = 0;
for(int i = 0; i < H - P + 1; i++) {
for(int j = 0; j < W - P + 1; j++) {
for(int k = 0; k < 8; k++) {
if(check(j, i, k)) {
cnt++;
break;
}
}
}
}
cout << cnt << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while(cin >> W >> H >> P, W | H | P) {
for(int i = 0; i < H; i++) {
b[i] = "";
string s;
cin >> s;
for(int j = 0; j < s.size(); j++) {
int x = conv(s[j]);
for(int k = 0; k < 6; k++) {
b[i] += char('0' + ((x >> (5 - k)) & 1));
}
}
h[i] = RollingHash(b[i]);
}
Pat p;
for(int i = 0; i < P; i++) {
string s;
cin >> s;
for(int j = 0; j < s.size(); j++) {
int x = conv(s[j]);
for(int k = 0; k < 6; k++) {
p.b[i] += char('0' + ((x >> (5 - k)) & 1));
}
}
}
int cnt = 0;
for(int i = 0; i < 4; i++) {
Pat m = mirror(p);
ps[cnt] = p;
for(int j = 0; j < P; j++) {
hs[cnt][j] = RollingHash(p.b[j]);
}
cnt++;
ps[cnt] = m;
for(int j = 0; j < P; j++) {
hs[cnt][j] = RollingHash(m.b[j]);
}
cnt++;
p = rotate(p);
}
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005], ap[100005];
int main() {
cin >> n;
int pos = 1;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++ap[a[i]];
while (ap[pos] != 0) {
++pos;
}
}
for (int i = 0; i < n; ++i) {
if (ap[a[i]] > 1 || a[i] > n) {
ap[a[i]]--;
a[i] = pos;
ap[pos]++;
while (ap[pos] != 0) {
++pos;
}
}
}
for (int i = 0; i < n; ++i) {
cout << a[i] << " ";
}
return 0;
}
| 2 |
#include<cstdio>
#include<cstring>
#include<algorithm>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i<=b;i--)
using namespace std;
const int mo=1e9+7;
int read()
{
char ch;
while (ch=getchar(),ch!='#' && ch!='.');
return ch=='#';
}
const int N=600;
int a[N][N],ok[N];
int main()
{
int n;
scanf("%d",&n);
fo(i,1,n)
{
fo(j,1,n) a[i][j]=read(),a[i][0]+=a[i][j];
}
int x=0,y=0,mx=0;
fo(i,1,n)
{
int num=0;
fo(j,1,n) num+=a[i][j];
if (num==n) x++;
mx=max(mx,num);
fo(j,1,n) if (a[i][j]) ok[j]=1;
}
fo(i,1,n)
{
int num=0;
fo(j,1,n) num+=a[j][i];
if (num==n) y++;
}
if (x) printf("%d",n-y); else
if (mx==0) printf("-1"); else
{
int ans=n*n;
fo(i,1,n)
//if (ok[i])
ans=min(ans,n-a[i][0]+(ok[i]==0));
ans+=n-y;
printf("%d",ans);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d;
cin >> d;
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long ans = 0;
for (int i = 0; i < n - 1; i++) {
ans += d - a[i];
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int N = 1e6 + 10;
const long long mod = 1e9 + 7;
const int base = 131;
const double pi = acos(-1);
const double eps = 1e-8;
inline long long ksm(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod, b >>= 1;
}
return ans;
}
unordered_map<long long, long long> mp;
long long vis[N], num[N], did[N];
long long n, m, k, x, y, z;
long long a[N], b[N], in[N];
long long cx, cy, cnt, ans, sum, flag, t, ff, q, w;
vector<int> v[N], res;
set<string> st;
bool topo() {
queue<int> q;
for (int i = 1; i <= n; i++) {
if (!in[i]) q.push(i);
}
cnt = 0;
while (q.size()) {
int x = q.front();
q.pop();
cnt++;
for (int to : v[x]) {
in[to]--;
if (in[to] == 0) q.push(to);
}
}
return cnt == n;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
v[x].push_back(y);
b[y]++;
}
for (int i = 1; i <= n; i++) {
if (b[i] > 0) {
b[i]--;
for (int j = 1; j <= n; j++) {
in[j] = b[j];
}
if (topo()) {
return cout << "YES" << endl, 0;
}
b[i]++;
}
}
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
#include <unistd.h>
using namespace std;
#define DEBUG(x) cerr<<#x<<": "<<x<<endl;
#define DEBUG_VEC(v) cerr<<#v<<":";for(int i=0;i<v.size();i++) cerr<<" "<<v[i]; cerr<<endl;
#define DEBUG_MAT(v) cerr<<#v<<endl;for(int i=0;i<v.size();i++){for(int j=0;j<v[i].size();j++) {cerr<<v[i][j]<<" ";}cerr<<endl;}
typedef long long ll;
#define int ll
#define vi vector<int>
#define vl vector<ll>
#define vii vector< vector<int> >
#define vll vector< vector<ll> >
#define vs vector<string>
#define pii pair<int,int>
#define pis pair<int,string>
#define psi pair<string,int>
#define pll pair<ll,ll>
template<class S, class T> pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) { return pair<S, T>(s.first + t.first, s.second + t.second); }
template<class S, class T> pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) { return pair<S, T>(s.first - t.first, s.second - t.second); }
template<class S, class T> ostream& operator<<(ostream& os, pair<S, T> p) { os << "(" << p.first << ", " << p.second << ")"; return os; }
#define X first
#define Y second
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep1(i,n) for(int i=1;i<=(n);i++)
#define rrep(i,n) for(int i=(n)-1;i>=0;i--)
#define rrep1(i,n) for(int i=(n);i>0;i--)
#define REP(i,a,b) for(int i=a;i<b;i++)
#define in(x, a, b) (a <= x && x < b)
#define All(c) c.begin(),c.end()
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 (a>b) { a = b; return 1; } return 0; }
#define UNIQUE(v) v.erase(std::unique(v.begin(), v.end()), v.end());
const ll inf = 1000000001;
const ll INF = (ll)1e18 + 1;
const double pi = 3.14159265358979323846;
#define Sp(p) cout<<setprecision(25)<< fixed<<p<<endl;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx2[8] = { 1,1,0,-1,-1,-1,0,1 }, dy2[8] = { 0,1,1,1,0,-1,-1,-1 };
#define fio() cin.tie(0); ios::sync_with_stdio(false);
const ll MOD = 1000000007;
//const ll MOD = 998244353;
// #define mp make_pair
//#define endl '\n'
void solve2(int n, int m) {
if (n == 2) {
cout << -1 << endl;
return;
}
vi x(m), y(m);
rep (i, m) {
cin >> x[i] >> y[i];
x[i]--; y[i]--;
}
vi num(n), w(n);
rep (i, n) {
num[i] = 1;
w[i] = i;
}
string s;
rrep (i, m) {
if (num[w[x[i]]] >= 2) {
num[w[x[i]]]--;
num[w[y[i]]]++;
s += 'v';
w[x[i]] = w[y[i]];
}
else if (num[w[y[i]]] >= 2) {
num[w[y[i]]]--;
num[w[x[i]]]++;
s += '^';
w[y[i]] = w[x[i]];
}
else {
num[w[x[i]]]--;
num[w[y[i]]]++;
s += 'v';
w[x[i]] = w[y[i]];
}
}
reverse(All(s));
cout << s << endl;
}
void solve1(int n, int m) {
vi x(m), y(m);
rep (i, m) {
cin >> x[i] >> y[i];
x[i]--; y[i]--;
}
vector<bitset<50001>> now(n);
rep (last, n) {
now[last][last] = true;
}
//DEBUG_VEC(now);
rrep (i, m) {
now[x[i]] = now[y[i]] = now[x[i]] | now[y[i]];
// rep (last, n) {
// now[x[i]][last] = now[y[i]][last] = now[x[i]][last] | now[y[i]][last];
// }
//DEBUG_VEC(now);
}
bitset<50001> ok;
ok.set();
rep (i, n) {
ok &= now[i];
}
int w = -1;
rep (i, n) {
if (ok[i]) {
w = i;
break;
}
}
if (w == -1) {
cout << -1 << endl;
return;
}
int last = w;
bitset<50001> now2;
now2[last] = true;
string ans;
rrep (i, m) {
if (now2[x[i]] or now2[y[i]]) {
if (not now2[x[i]]) {
now2[x[i]] = true;
ans += 'v';
}
else if (not now2[y[i]]) {
now2[y[i]] = true;
ans += '^';
}
else {
ans += 'v';
}
}
else {
ans += 'v';
}
}
reverse(All(ans));
cout << ans << endl;
}
signed main() {
fio();
int n, m, t;
cin >> n >> m >> t;
if (t == 2) {
solve2(n, m);
}
else {
solve1(n, m);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long, long long> &lhs, pair<long long, long long> &rhs) {
return (lhs.first * rhs.second) > (rhs.first * lhs.second);
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
vector<pair<long long, long long> > v(n);
long long cost = 0;
vector<string> s(n);
for (long long i = 0; i < n; i++) {
cin >> s[i];
long long &sc = v[i].first, &hc = v[i].second;
for (long long j = 0; j < s[i].size(); j++) {
if (s[i][j] == 'h') {
cost += sc;
hc++;
} else
sc++;
}
}
sort(v.begin(), v.end(), comp);
long long sc = 0;
for (long long i = 0; i < n; i++) {
cost += sc * v[i].second;
sc += v[i].first;
}
cout << cost;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int C = 26;
void add(int &x, int y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x) {
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % MOD;
b >>= 1;
a = 1ll * a * a % MOD;
}
return ret;
}
const int MAXN = 1e6 + 10;
long long n, A, c[2], m;
long long a[MAXN], pre[MAXN];
int sec[MAXN];
void solve() {
cin >> n >> A >> c[0] >> c[1] >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
iota(sec, sec + n, 0);
sort(sec, sec + n, [](int i, int j) { return a[i] < a[j]; });
for (int i = 0; i < n; i++) {
pre[i + 1] = pre[i] + a[sec[i]];
}
tuple<long long, long long, long long> best = {-1, -1, -1};
for (int r = n; ~r; --r) {
long long have = pre[n] - pre[r];
long long want = A * (n - r);
long long need = want - have;
if (need > m) {
break;
}
long long rem = m - need;
long long small = 0;
for (int i = 30; ~i; --i) {
long long maybe = small + (1LL << i);
if (maybe <= A) {
int j = r;
for (int k = 20; ~k; --k) {
if (j - (1 << k) >= 0 && a[sec[j - (1 << k)]] >= maybe) {
j -= 1 << k;
}
}
need = maybe * j - pre[j];
if (need <= rem) {
small = maybe;
}
}
}
best = max(best,
make_tuple(c[0] * (n - r) + c[1] * small, (long long)r, small));
}
auto [score, r, lo] = best;
cout << score << "\n";
for (int i = 0; i < n; i++) {
if (i < r) {
a[sec[i]] = max(a[sec[i]], lo);
} else {
a[sec[i]] = A;
}
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int te = 1;
for (int w = 1; w <= te; w++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1000 + 10;
pair<int, long long> dp[mxn][10 * mxn];
vector<long long> divors;
map<long long, int> rediv;
inline long long gcd(long long a, long long b) {
while (b) {
long long c = a % b;
a = b;
b = c;
}
return a;
}
void getdiv(long long k) {
for (long long i = 1; i <= sqrt(k); i++)
if (k % i == 0) {
divors.push_back(i);
if (i * i != k) divors.push_back(k / i);
}
sort(divors.begin(), divors.end());
for (int i = 0; i < divors.size(); i++) rediv[divors[i]] = i;
}
long long a[mxn];
long long g[mxn];
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
g[i] = gcd(a[i], k);
}
if (k == 1) {
printf("%d\n%d\n", 1, min_element(a + 1, a + n + 1) - a);
return 0;
}
getdiv(k);
int m = divors.size();
for (int i = 1; i < m; i++) dp[0][i] = make_pair(n + 1, 0);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++) {
int nk = rediv[divors[j] / gcd(divors[j], g[i])];
pair<int, long long> now =
make_pair(dp[i - 1][nk].first + 1, dp[i - 1][nk].second + a[i]);
dp[i][j] = min(dp[i - 1][j], now);
}
}
if (dp[n][m - 1].first > n)
printf("-1\n");
else {
printf("%d\n", dp[n][m - 1].first);
for (int i = n; i > 0; i--) {
if (dp[i][rediv[k]] != dp[i - 1][rediv[k]]) {
printf("%d%c", i, i == 1 ? '\n' : ' ');
k /= gcd(k, g[i]);
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long m, h1, a1, x1, y1, h2, a2, x2, y2;
cin >> m;
cin >> h1 >> a1 >> x1 >> y1 >> h2 >> a2 >> x2 >> y2;
int cnt = 0;
long long h11 = h1;
while (cnt <= m && h11 != a1) {
h11 = (x1 * h11 + y1) % m;
cnt++;
}
if (cnt > m) {
cout << -1 << endl;
return 0;
}
int cnt1 = 0;
long long h22 = h2;
while (cnt1 < cnt) {
h22 = (x2 * h22 + y2) % m;
cnt1++;
}
if (h22 == a2) {
cout << cnt << endl;
return 0;
}
long long ans = cnt;
cnt = 1;
long long h = (x1 * h11 + y1) % m;
while (cnt <= m && (h != h11)) {
h = (x1 * h + y1) % m;
cnt++;
}
if (cnt > m) {
cout << -1 << endl;
return 0;
}
long long c = 1, d = 0;
for (int i = 0; i < cnt; i++) {
c = (c * x2) % m;
d = (d * x2 + y2) % m;
}
long long e = h22;
int f = 0;
while (f <= m && e != a2) {
e = (c * e + d) % m;
f++;
}
if (f > m) {
cout << -1 << endl;
return 0;
}
ans = ans + 1LL * f * cnt;
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t, n, p;
int main() {
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n >> p;
int edge_count = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++) {
if (i != j) {
cout << j << " " << i << endl;
edge_count++;
}
if (edge_count == 2 * (i) + p) break;
}
}
}
| 1 |
#include <cstdio>
#include <map>
int Q;
long long q[100001], s[100001];
std::map < long long, long long > M;
int main()
{
scanf("%lld%d", q, &Q);
for (int i = 1; i <= Q; i++)
scanf("%lld", q + i);
M = { { q[Q], 1 } };
for (int i = Q - 1; ~i; i--)
{
auto it = M.upper_bound(q[i]);
for (auto j = it; j != M.end(); j++)
{
M[q[i]] += j -> first / q[i] * j -> second;
if (j -> first % q[i])
M[j -> first % q[i]] += j -> second;
}
M.erase(it, M.end());
}
for (auto &i : M)
s[i.first] += i.second;
for (int i = q[0] - 1; i; i--)
s[i] += s[i + 1];
for (int i = 1; i <= q[0]; i++)
printf("%lld\n", s[i]);
return 0;
}
| 0 |
//ALDS1_1
//ALDSC_1
#include<iostream>
using namespace std;
int gcd(int a,int b){
if(b==0)return a;
return gcd(b,a%b);
}
int main(){
int a,b;
cin>>a>>b;
cout<<gcd(a,b)<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, r, a, b;
vector<int> v, v2;
cin >> n >> l >> r;
for (long long int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
for (long long int i = 0; i < n; i++) {
cin >> b;
v2.push_back(b);
}
bool ans = true;
for (long long int i = 0; i < l - 1; i++) {
if (v[i] != v2[i]) {
ans = false;
break;
}
}
for (long long int i = r; i < n; i++) {
if (v[i] != v2[i]) {
ans = false;
break;
}
}
if (ans)
cout << "TRUTH" << endl;
else
cout << "LIE" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> c;
inline int link(int x) {
return lower_bound(c.begin(), c.end(), x) - c.begin() + 1;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
vector<int> a(n + 1);
c = vector<int>();
for (int i = 0; i < n; ++i) scanf("%d", &a[i]), c.push_back(a[i]);
sort(c.begin(), c.end());
vector<int> f(n + 1, 0);
int res = 0;
for (int i = 0; i < n; ++i) {
int x = link(a[i]);
f[x] = f[x - 1] + 1;
res = max(f[x], res);
}
printf("%d\n", n - res);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 1000000000000000100LL;
const int mod = 1000000007;
const int MAXN = 100010, LOG = 20;
int n, m, k, u, v, x, y, t, a, b, ans;
long long C(long long n, long long r) {
unsigned long long res = 1;
r = min(r, n - r);
for (int i = 1; i <= r; i++) {
if (res >= 1e17) break;
res = res * (n + 1 - i) / i;
}
return res;
}
long long check(long long m, long long k) {
long long res = 1, shit = k * m;
for (int i = 1; i <= k && shit; i++) {
long long cnt = C(k, i);
if (shit / i >= cnt) {
shit -= cnt * i;
res += cnt;
} else {
res += shit / i;
shit = 0;
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
cin >> n >> m;
int dwn = -1, up = n;
while (up - dwn > 1) {
int mid = (dwn + up) >> 1;
if (check(m, mid) >= n)
up = mid;
else
dwn = mid;
}
cout << up << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int a[maxn], b[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
}
sort(b + 1, b + n + 1);
int op = 0;
for (int i = n; i > 0; i--) {
if (a[i] != b[i]) {
op++;
for (int j = 1; j < i; j++) {
int t;
if (a[j] == b[i]) {
t = a[j];
a[j] = a[i];
a[i] = t;
break;
}
}
}
if (op > 1) break;
}
if (op > 1)
puts("NO");
else
puts("YES");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int A[1 << 10][1 << 10];
char H[1 << 10][1 << 10];
char V[1 << 10][1 << 10];
int R[1 << 10];
int f(int x, int y, int m) {
int a = R[x];
int b = R[y];
int i;
int res = 0;
for (i = (0); i < (m); ++i) {
if ((a ^ b) != (V[x][i] == 'N' ? 1 : 0)) ++res;
if (i != m - 1) {
if (H[x][i] == 'N') a ^= 1;
if (H[y][i] == 'N') b ^= 1;
}
}
return res;
}
int g(int x, int y, int n) {
int a = R[x];
int b = R[y];
int i;
int res = 0;
for (i = (0); i < (n); ++i) {
if ((a ^ b) != (H[i][x] == 'N' ? 1 : 0)) ++res;
if (i != n - 1) {
if (V[i][x] == 'N') a ^= 1;
if (V[i][y] == 'N') b ^= 1;
}
}
return res;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int i, j;
for (i = (0); i < (n); ++i) {
scanf("%s", H[i]);
if (i != n - 1) scanf("%s", V[i]);
}
int cnt[] = {0, 0};
for (i = (0); i < (n); ++i)
for (j = (0); j < (m); ++j) {
if (i != n - 1) ++cnt[V[i][j] == 'N' ? 1 : 0];
if (j != m - 1) ++cnt[H[i][j] == 'N' ? 1 : 0];
}
if (k == 1) {
if (cnt[0] * 4 >= 3 * (cnt[0] + cnt[1])) {
printf("YES\n");
for (i = (0); i < (n); ++i)
for (j = (0); j < (m); ++j) printf("1%c", j == m - 1 ? '\n' : ' ');
} else
printf("NO\n");
return 0;
}
if (n < m) {
memset(R, 0, sizeof(R));
for (i = (0); i < (n - 1); ++i)
if (2 * f(i, i + 1, m) > m - 1) R[i + 1] ^= 1;
for (i = (0); i < (n); ++i) {
int a = R[i];
for (j = (0); j < (m); ++j) {
A[i][j] = a;
if (j != m - 1 && H[i][j] == 'N') a ^= 1;
}
}
} else {
memset(R, 0, sizeof(R));
for (i = (0); i < (m - 1); ++i)
if (2 * g(i, i + 1, n) > n - 1) R[i + 1] ^= 1;
for (i = (0); i < (m); ++i) {
int a = R[i];
for (j = (0); j < (n); ++j) {
A[j][i] = a;
if (j != n - 1 && V[j][i] == 'N') a ^= 1;
}
}
}
printf("YES\n");
for (i = (0); i < (n); ++i)
for (j = (0); j < (m); ++j)
printf("%d%c", A[i][j] + 1, j == m - 1 ? '\n' : ' ');
return 0;
};
| 4 |
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s;
cin >> s;
int len = s.length();
int ans = len;
for (int i = 0; i < len; i++) {
if (s[i] != s[i + 1])
ans = min(ans,max(i+1,len-i-1));
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int arr[26];
memset(arr, 0, sizeof arr);
for (int i = 0; i < s.size(); ++i) {
++arr[s[i] - 'a'];
}
int diff = 0;
int mmim = 1e9;
for (int i = 0; i < 26; ++i) {
diff += (arr[i] != 0);
if (arr[i]) mmim = min(mmim, arr[i]);
}
if (diff == 4 || (diff == 3 && s.size() > 3) ||
(diff == 2 && s.size() >= 4 && mmim > 1)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
long long mod = 1000000009;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
bool is_vowel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y')
return 1;
return 0;
}
long double getDistance(long double x1, long double y1, long double x2,
long double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
long long extended_euclidean(long long a, long long b, long long &x,
long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long g = extended_euclidean(b, a % b, y, x);
y -= (a / b) * x;
return g;
}
long long power(long long base, long long p) {
if (p == 1) return base;
if (!p) return 1ll;
long long ret = power(base, p / 2);
ret *= ret;
ret %= mod;
if (p & 1) ret *= base;
return ret % mod;
}
pair<int, int> vec(pair<int, int> a, pair<int, int> b) {
pair<int, int> ret = pair<int, int>(a.first - b.first, a.second - b.second);
return ret;
}
long long getArea(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
pair<int, int> x = vec(a, b);
pair<int, int> y = vec(c, b);
return abs(x.first * y.second - x.second * y.first);
}
int n, arr[N];
vector<int> adj[N];
bool v[N];
int cnt = 0;
void dfs(int node) {
if (v[node]) return;
cnt++;
v[node] = 1;
for (int i = (0); i <= (int(adj[node].size()) - 1); ++i) dfs(adj[node][i]);
}
int main() {
cin >> n;
for (int i = (1); i <= (n); ++i) {
scanf("%d", &arr[i]);
adj[arr[i]].push_back(i);
adj[i].push_back(arr[i]);
}
int sum = 0;
for (int i = (1); i <= (n); ++i) {
if (v[i]) continue;
cnt = 0;
dfs(i);
sum += cnt - 1;
}
int way1 = 3 * n - sum;
int way2 = 7 * n + 1 - sum;
if (way2 % 2 == 0)
cout << "Um_nik";
else
cout << "Petr";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char c;
int main() {
int n, e = 0, m = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i], (a[i] > 0) ? e++ : 0;
sort(a, a + n);
cout << "1 " << a[0] << endl;
if (e == 0) {
cout << "2 " << a[1] << " " << a[2] << endl;
cout << n - 3 << " ";
for (int i = 3; i < n; i++) cout << a[i] << " ";
return 0;
}
for (int i = 1; i < n; i++)
if (a[i] == 0) m = i;
cout << n - m - 1 << " ";
for (int i = m + 1; i < n; i++) cout << a[i] << " ";
cout << endl;
cout << m << " ";
for (int i = 1; i < m + 1; i++) cout << a[i] << " ";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
map<int, long long> ns;
int min(int a, int b) { return a < b ? a : b; }
void once(int &k) {
if (ns.size() == 1) {
k = 0;
return;
}
int mid = (ns.rbegin()->first + ns.begin()->first) / 2;
if (mid == ns.begin()->first) {
k = 0;
return;
}
int nvh = ns.size() > 2 ? ((++ns.rbegin())->first) : mid;
int hv = ns.rbegin()->first, hq = ns.rbegin()->second;
long long diff_h = (hv - nvh);
long long total_h = diff_h * hq;
int nvl = ns.size() > 2 ? ((++ns.begin())->first) : mid;
int lv = ns.begin()->first, lq = ns.begin()->second;
long long diff_l = (-lv + nvl);
long long total_l = diff_l * lq;
long long q = min(min(total_h, total_l), k);
k -= q;
int t_s = q / lq;
long long t_sm = q % lq;
ns.erase(lv);
ns[lv + t_s] += lq;
if (t_sm != 0) {
ns[lv + t_s] -= t_sm;
ns[lv + t_s + 1] += t_sm;
if (ns[lv - t_s] == 0) {
ns.erase(lv - t_s);
}
}
int t_a = q / hq;
long long t_am = q % hq;
ns.erase(hv);
ns[hv - t_a] += hq;
if (t_am != 0) {
ns[hv - t_a] -= t_am;
ns[hv - t_a - 1] += t_am;
if (ns[hv - t_a] == 0) {
ns.erase(hv - t_a);
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
int cur;
scanf("%d", &cur);
ns[cur]++;
}
while (k != 0) {
once(k);
}
printf("%d", ns.rbegin()->first - ns.begin()->first);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<int> vc[N];
vector<pair<int, int> > vQ[N];
int n, m, Q;
int ans[N], t[N * 4];
void build(int k, int l, int r) {
t[k] = 1ll << 30;
if (l == r) return;
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
}
void pushdown(int k) {
t[k * 2] = min(t[k * 2], t[k]);
t[k * 2 + 1] = min(t[k * 2 + 1], t[k]);
}
void change(int k, int l, int r, int x, int y, int v) {
if (l == x && r == y) {
t[k] = min(t[k], v);
return;
}
pushdown(k);
int mid = (l + r) / 2;
if (y <= mid)
change(k * 2, l, mid, x, y, v);
else if (x > mid)
change(k * 2 + 1, mid + 1, r, x, y, v);
else {
change(k * 2, l, mid, x, mid, v);
change(k * 2 + 1, mid + 1, r, mid + 1, y, v);
}
t[k] = max(t[k * 2], t[k * 2 + 1]);
}
int ask(int k, int l, int r, int p, int v) {
if (l == r) return (t[k] > v ? l : -1);
int mid = (l + r) / 2;
pushdown(k);
if (p <= l) {
if (t[k * 2] > v) return ask(k * 2, l, mid, p, v);
return ask(k * 2 + 1, mid + 1, r, p, v);
}
int ans = (p <= mid ? ask(k * 2, l, mid, p, v) : -1);
return ans == -1 ? ask(k * 2 + 1, mid + 1, r, p, v) : ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (int)(1); i <= (int)(m); i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x ^ y) vc[x].push_back(y);
}
scanf("%d", &Q);
for (int i = (int)(1); i <= (int)(Q); i++) {
int x, y;
scanf("%d%d", &x, &y);
vQ[x].push_back(pair<int, int>(y, i));
}
build(1, 1, n);
for (int i = (int)(n); i >= (int)(1); i--) {
for (auto j : vc[i]) change(1, 1, n, i, j - 1, j);
for (auto j : vQ[i]) ans[j.second] = ask(1, 1, n, i, j.first);
}
for (int i = (int)(1); i <= (int)(Q); i++) printf("%d\n", ans[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, d;
int64_t cur_d = 0;
cin >> n >> d;
vector<int> tree(n);
vector<int> depth(n, 0);
vector<vector<int>> children(n);
queue<int> roots{{0}};
int cur_leaf = n - 1;
for (int i = 1; i < n; i++) {
tree[i] = i - 1;
children[i - 1].push_back(i);
cur_d += i;
depth[i] = i;
}
while (cur_d > d) {
int cur_root = roots.front();
if (depth[cur_leaf] <= depth[cur_root]) break;
if (cur_d - (depth[cur_leaf] - depth[cur_root]) >= d) {
cur_d -= (depth[cur_leaf] - depth[cur_root] - 1);
depth[cur_leaf] = depth[cur_root] + 1;
children[cur_root].push_back(cur_leaf);
tree[cur_leaf] = cur_root;
children[cur_leaf - 1].pop_back();
if (children[cur_root].size() >= 2) {
roots.pop();
for (int i = children[cur_root].size() - 1; i >= 0; i--) {
roots.push(children[cur_root][i]);
}
}
cur_leaf--;
continue;
} else {
if (children[cur_leaf - 1].size() >= 2) break;
depth[cur_leaf]--;
tree[cur_leaf]--;
cur_d--;
}
}
if (cur_d != d) {
cout << "NO\n";
continue;
}
cout << "YES\n";
for (int i = 1; i < n; i++) {
cout << tree[i] + 1 << ' ';
}
cout << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(unsigned long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (unsigned long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long int exp(long long int value, long long int power) {
long long int result = 1;
while (power > 0) {
if (power & 1LL) {
result *= value;
result %= 1000000007;
}
value *= value;
value %= 1000000007;
power /= 2LL;
}
return result;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int f1, f, cnt, len, p, q, r, t, i, j, k, l, n, m, x, y, z, b, c, s;
cin >> r >> c;
char a[r][c];
for (i = 0; i < r; i++) cin >> a[i];
k = 0;
f = 0;
for (i = 0; i < c; i++) {
f1 = 0;
for (j = 0; j < r; j++) {
if (a[j][i] == 'B') {
f = 1;
f1 = 1;
break;
}
}
if (f == 1 && (f1 == 0 || i == (c - 1))) {
k += 1;
f = 0;
}
}
cout << k;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-9;
void ASS(bool b) {
if (!b) {
++*(int*)0;
}
}
int n, m, x, y, z;
int main() {
cout.flags(ios::fixed);
cout.precision(2);
cin >> n >> m;
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &x, &y, &z);
if (x == y) {
printf("%d\n", z);
continue;
}
x--;
y--;
long long t = z / (m - 1);
int now = z % (m - 1);
if (t & 1) {
now = m - 1 - now;
}
int mov;
if ((t & 1) == 0)
mov = 1;
else
mov = -1;
if (now == 0) mov = 1;
if (now == m - 1) mov = -1;
long long ans = z;
if (mov == 1 && now > x) {
mov = -1;
ans += m - 1 - now;
now = m - 1;
}
if (mov == -1 && now < x) {
mov = 1;
ans += now;
now = 0;
}
if (mov == 1) {
ans += x - now;
now = x;
} else {
ans += now - x;
now = x;
}
if (now == 0) mov = 1;
if (now == m - 1) mov = -1;
if (mov == 1 && now > y) {
mov = -1;
ans += m - 1 - now;
now = m - 1;
}
if (mov == -1 && now < y) {
mov = 1;
ans += now;
now = 0;
}
if (mov == 1) {
ans += y - now;
now = y;
} else {
ans += now - y;
now = y;
}
int q = ans;
printf("%d\n", q);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[111111], l[111111], r[111111];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
if (a[i - 1] < a[i]) {
l[i] = l[i - 1] + 1;
} else {
l[i] = 1;
}
}
for (int i = n; 0 < i; i--) {
if (a[i] < a[i + 1]) {
r[i] = r[i + 1] + 1;
} else {
r[i] = 1;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (a[i - 1] + 1 < a[i + 1]) {
ans = max(ans, l[i - 1] + 1 + r[i + 1]);
} else {
ans = max(ans, l[i - 1] + 1);
ans = max(ans, r[i + 1] + 1);
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long inf;
const long double eps = 1e-8;
const long double pi = acos(-1.0);
template <class T>
long long chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
long long chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
T mmin(T a, T b) {
return a < b ? a : b;
}
template <class T>
T mmax(T a, T b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
long long dcmp(T a, T b) {
return a > b;
}
template <long long *a>
long long cmp_a(long long first, long long second) {
return a[first] < a[second];
}
struct __INIT__ {
__INIT__() { memset(&inf, 0x3f, sizeof(inf)); }
} __INIT___;
namespace io {
const long long SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
long long f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char first) {
*oS++ = first;
if (oS == oT) flush();
}
template <typename A>
inline bool read(A &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(char &first) {
while ((first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == ' ' ||
first == '\n' || first == '\r')
;
return first != EOF;
}
inline bool read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
;
if (*first == EOF) return 0;
while (!(*first == '\n' || *first == '\r'))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*first = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
return read(first) && read(second...);
}
template <typename A>
inline bool write(A first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char first) {
putc(first);
return 0;
}
inline bool write(const char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
inline bool write(char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
return write(first) || write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
pair<long long, long long> a[2505];
pair<long long, long long> b[5005];
long long c[2505];
long long cross(pair<long long, long long> a, pair<long long, long long> b) {
return a.first * b.second - a.second * b.first;
}
long long fx(pair<long long, long long> a) {
if (a.first >= 0 && a.second >= 0) return 0;
if (a.first <= 0 && a.second >= 0) return 1;
if (a.first <= 0 && a.second <= 0) return 2;
return 3;
}
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (fx(a) != fx(b)) return fx(a) < fx(b);
return cross(a, b) > 0;
}
signed main() {
long long n, m;
read(n);
for (long long i = 1; i <= n; ++i) {
read(a[i].first, a[i].second);
}
long long ans = 0;
for (long long i = 1; i <= n; ++i) {
c[i] = (long long)i * (i - 1) * (i - 2) / 6;
}
for (long long i = 1; i <= n; ++i) {
m = 0;
for (long long j = 1; j <= n; ++j) {
if (j != i)
b[++m] = make_pair(a[j].first - a[i].first, a[j].second - a[i].second);
}
sort(b + 1, b + m + 1, cmp);
for (long long i = 1; i <= m; ++i) b[i + m] = b[i];
ans += (long long)m * (m - 1) * (m - 2) * (m - 3) / 24;
for (long long i = 1, j = 1; i <= m + m; ++i) {
if (j == i - m) ++j;
while (j < i && cross(b[i], b[j]) > 0) ++j;
if (i > m) ans -= c[i - j];
}
}
write(ans, '\n');
return 0;
}
| 5 |
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <map>
#include <numeric>
#include <string>
#include <cmath>
#include <iomanip>
#include <queue>
#include <list>
#include <stack>
#include <cctype>
#include <cmath>
using namespace std;
/* typedef */
typedef long long ll;
/* constant */
const int INF = 1 << 30;
const int MAX = 500000;
const int mod = 1000000007;
const double pi = 3.141592653589;
/* global variables */
struct Node {
Node *left,
*right;
int key,
priority;
};
Node *root, *NIL;
/* function */
Node* rightRotate(Node* t);
Node* leftRotate(Node* t);
Node* insert(Node* t, int key, int priority);
Node* Delete(Node* t, int key);
Node* _delete(Node* t, int key);
Node* findNode(int key);
void preorder(Node* v);
void inorder(Node* v);
/* main */
int main(){
// main
int n, val, pri;
cin >> n;
string man;
for (int i = 0; i < n; i++) {
cin >> man;
if (man == "print") {
inorder(root); cout << '\n';
preorder(root); cout << '\n';
}
else {
cin >> val;
if (man == "insert") {
cin >> pri;
root = insert(root, val, pri);
}
else if (man == "delete" ) {
Node* target = findNode(val);
root = Delete(root, val);
}
else {
Node* ret_node = findNode(val);
if (ret_node != NIL)
cout << "yes" << '\n';
else
cout << "no" << '\n';
}
}
}
}
Node* rightRotate(Node* t) {
Node* s = t->left;
t->left = s->right;
s->right = t;
return s; // root of the subtree
}
Node* leftRotate(Node* t) {
Node* s = t->right;
t->right = s->left;
s->left = t;
return s; // root of the subtree
}
Node* insert(Node* t, int key, int priority) { // 再帰的に探索
if (t == NIL){
Node* N = new Node(); // 葉に到達したら新しい節点を生成して返す
N->left = NIL;
N->right = NIL;
N->key = key;
N->priority = priority;
return N;
}
if (key == t->key)
return t; // 重複したkeyは無視
if (key < t->key) { // 左の子へ移動
t->left = insert(t->left, key, priority); // 左の子へのポインタを更新
if (t->priority < t->left->priority) // 左の子の方が優先度が高い場合右回転
t = rightRotate(t);
}
else { // 右の子へ移動
t->right = insert(t->right, key, priority); // 右の子へのポインタを更新
if (t->priority < t->right->priority) // 右の子の方が優先度が高い場合左回転
t = leftRotate(t);
}
return t;
}
Node* Delete(Node* t, int key) {
if (t == NIL)
return NIL;
if (key < t->key) // 削除対象を検索
t->left = Delete(t->left, key);
else if (key > t->key)
t->right = Delete(t->right, key);
else
return _delete(t, key);
return t;
}
Node* _delete(Node* t, int key) { // 削除対象の節点の場合
if (t->left == NIL && t->right == NIL) // 葉の場合
return NIL;
else if (t->left == NIL) // 右の子のみを持つ場合左回転
t = leftRotate(t);
else if (t->right == NIL) // 左の子のみを持つ場合右回転
t = rightRotate(t);
else { // 左の子と右の子を両方持つ場合
if (t->left->priority > t->right->priority) // 優先度が高い方を持ち上げる
t = rightRotate(t);
else
t = leftRotate(t);
}
return Delete(t, key);
}
Node* findNode(int key) {
Node* x = root;
while (x != NIL) {
if (key == x->key)
return x;
else if (key < x->key) // 削除対象を検索
x = x->left;
else if (key > x->key)
x = x->right;
}
return x;
}
void preorder(Node* v) {
if (v != NIL) {
cout << ' ' << v->key;
preorder(v->left);
preorder(v->right);
}
}
void inorder(Node* v) {
if (v != NIL) {
inorder(v->left);
cout << ' ' << v->key;
inorder(v->right);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long k, d, x, z;
double ans = 0, y, t;
cin >> k >> d >> t;
x = k / d;
if (x * d != k) ++x;
y = k + (x * d - k) * 0.5;
z = t / y;
while (z * y > t) --z;
ans += x * d * z;
t -= z * y;
if (t > k)
t -= k, ans += k;
else
ans += t, t = 0;
if (t > 0) ans += t * 2;
printf("%.9f\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
if (n == 1) {
cout << (n) << endl;
;
cout << (n) << endl;
;
} else if (n == 2) {
cout << (1) << endl;
;
cout << (1) << endl;
;
} else if (n == 3) {
cout << (2) << endl;
;
cout << 1 << " " << 3 << endl;
} else if (n == 4) {
cout << (4) << endl;
;
cout << 2 << " " << 4 << " " << 1 << " " << 3 << endl;
} else {
cout << (n) << endl;
;
for (int i = (0); i < n / 2 + 1; i++) {
int d = 2 * i + 1;
if (d <= n) cout << d << " ";
}
for (int i = (0); i < n / 2 + 1; i++) {
int d = 2 * i + 2;
if (d <= n) cout << d << " ";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#include <list>
#include <stack>
using namespace std;
#define ll long long
#define fo(i,n) for(int i=0;i<n;i++)
#define rep(i,k,n) for(int i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define ini(a, i) memset(a, i, sizeof(a))
#define sortall(x) sort(all(x))
#define rev(x) reverse(all(x))
#define PI 3.1415926535897932384626
typedef pair<ll, ll> pii;
typedef pair<ll, ll> pl;
typedef vector<ll> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
typedef vector<pl> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
const int INF = 1000000007;
const long long INFLL = (ll)INF * (ll)INF;
#define ld long double
const ld EPS = 10e-9;
const unsigned int M = 1000000007;
#define int long long
long double pi = 2*acos(0.0);
// cout << fixed << setprecision(0) << pi <<" "<<npi<<endl;
//s.substr(start index,length)
//lower_bound
//upper_bound
//*max_element
//*min_element
//continue
// vector<vector<int>> vec( n , vector<int> (m, 0));
// in a matrix if i select cell a(i,j) then the parity of (i+j) all the adjacent cells is opposite
//check cube root
// double b=cbrt(x-a*a*a);
// if(floor(b)==b)
// {
// yes;return;
// }
//const bool is_in = container.find(element) != container.end();
//int chalao=1000000000000;
// x has cbrt(x) divisors
// pass string by reference
// PREFER DP[MIN_SIZE][MAX_SIZE] OVER DP[MAX_SIZE][MIN_SIZE]
int mod=1000000007;
// int dp[1003][1003];
// memset(dp,-1,sizeof(dp));
void solve()
{
int n;
cin>>n;
int a[n];
int flag=0;
for (int i = 0; i < n; ++i)
{
cin>>a[i];
double ash=sqrt((double)a[i]);
if(floor(ash)!=ceil(ash))
flag=1;
}
if(flag==1)
{
cout<<"YES"<<endl;
}
else
cout<<"NO"<<endl;
}
int32_t main()
{
clock_t start, end;
start = clock();
// ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif // ONLINE_JUDGE
// sieve();
// initalize();
int t=1;
cin>>t;
while(t--)
solve();
// cout<<primes.size();
//cout<<t1;
end = clock();
// // Calculating total time taken by the program.
// double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
// cout << "\nTime taken by program is : " << fixed << time_taken << setprecision(5);
// cout << " sec " << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
void read_input(int& n, int& k, std::vector<int>& walks) {
std::cin >> n >> k;
walks.resize(n);
for (size_t i = 0; i < n; ++i) {
std::cin >> walks[i];
}
}
long int sum_of_int_vector(const std::vector<int>& v) {
long int res = 0;
for (auto el : v) {
res += el;
}
return res;
}
std::vector<int> additional_walks(const int k, const std::vector<int>& walks) {
std::vector<int> res(walks.size(), 0);
int tmp;
for (size_t i = 1; i < walks.size(); ++i) {
if ((tmp = walks[i - 1] + walks[i] + res[i - 1]) < k) {
res[i] = k - tmp;
}
}
return res;
}
int main() {
int n;
int k;
std::vector<int> walks;
read_input(n, k, walks);
std::vector<int> res = additional_walks(k, walks);
std::cout << sum_of_int_vector(res) << '\n';
for (size_t i = 0; i < n; ++i) {
std::cout << walks[i] + res[i] << ' ';
}
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
const int N = 1003;
int n, m, dis[N], par[N];
vector<int> adj[N], ans;
int main(int argc, char const *argv[])
{
scanf("%d %d\n", &n, &m);
for (int i = 0; i < m; ++i)
{
int u, v;
scanf("%d %d\n", &u, &v);
adj[u].push_back(v);
}
for (int s = 1; s <= n; ++s)
{
queue<int> q;
for (int i = 1; i <= n; ++i)
{
par[i] = dis[i] = -1;
}
q.push(s);
dis[s] = 0;
while (!q.empty())
{
int u = q.front();
q.pop();
for (int v: adj[u])
{
if (dis[v] == -1)
{
par[v] = u;
dis[v] = 1 + dis[u];
q.push(v);
}
else if (v == s)
{
int cur = u;
vector<int> temp;
while (cur != -1)
{
temp.push_back(cur);
cur = par[cur];
}
if (temp.size() < ans.size() || ans.empty())
{
ans.clear();
for (int node: temp)
ans.push_back(node);
}
}
}
}
}
if (ans.empty())
printf("%d\n", -1);
else
{
printf("%d\n", (int)ans.size());
for (int node: ans)
printf("%d\n", node);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
long long size(const T& x) {
return x.size();
}
#pragma GCC optimize("Ofast")
template <class T>
T smod(T a, T b) {
return (a % b + b) % b;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long mod_pow(long long b, long long e, long long m) {
long long res = 1;
while (e) {
if (1 & e) res = res * b % m;
b = b * b % m;
e /= 2;
}
return res % m;
}
long long n, k;
vector<int> A;
vector<int> CNTK;
void precalc() {
CNTK[0] = (A[0] == k);
for (long long i = (1); i < (n); ++i) {
CNTK[i] = CNTK[i - 1] + (A[i] == k);
}
}
bool kexists(int l, int r) {
long long lo = (l == 0) ? 0 : CNTK[l - 1];
return (CNTK[r] - lo) >= 1;
}
void solve() {
cin >> n >> k;
A = vector<int>(n);
CNTK = vector<int>(n);
bool found = false;
for (long long i = (0); i < (n); ++i) {
cin >> A[i];
if (A[i] == k) {
found = true;
}
}
if (!found) {
cout << "no" << endl;
return;
}
if (n == 1) {
cout << "yes" << endl;
return;
}
for (long long i = (0); i < (n - 1); ++i) {
if (A[i] >= k && A[i + 1] >= k) {
cout << "yes" << endl;
return;
}
if (i + 2 < n) {
if (A[i] >= k && A[i + 2] >= k) {
cout << "yes" << endl;
return;
}
}
}
cout << "no" << endl;
}
int main() {
cin.sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.