solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
bool flag = 0;
long long n, t, sum;
map<char, long long> f;
map<char, bool> sta;
vector<pair<long long, char>> v;
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> s;
sta[s[0]] = 1;
reverse(s.begin(), s.end());
t = 1;
for (long long j = 0; j < (long long)s.size(); j++) {
f[s[j]] += t;
t *= 10;
}
}
for (char ch = 'a'; ch <= 'j'; ch++) {
if (f[ch]) v.push_back({f[ch], ch});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
t = 1;
for (long long i = 0; i < (long long)v.size(); i++) {
if (!flag && !sta[v[i].second])
flag = 1;
else {
sum += t * v[i].first;
t++;
}
}
cout << sum;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
std::vector<std::vector<std::vector<T>>> make_3d_vector(long long z,
long long y,
long long x,
T value = T{}) {
return std::vector<std::vector<std::vector<T>>>(
z, std::vector<std::vector<T>>(y, std::vector<T>(x, value)));
}
template <typename T>
std::vector<std::vector<T>> make_2d_vector(long long z, long long y,
T value = T{}) {
return std::vector<std::vector<T>>(z, std::vector<T>(y, value));
}
template <typename T>
std::vector<T> make_1d_vector(long long z, T value = T{}) {
return std::vector<T>(z, value);
}
void solve() {
long long a, b;
cin >> a >> b;
long long x = a;
a -= b;
if (a == 0) {
cout << "infinity";
return;
}
long long ct = 0;
for (long long i = 1; i * i <= a; i++) {
if (a % i == 0) {
ct++;
ct += (a / i != i && a / i > b);
ct -= (i <= b);
}
}
cout << ct;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
}
| 4 |
#include <bits/stdc++.h>
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
using namespace std;
int t;
int n, a[N], b[N];
int main() {
ios::sync_with_stdio(false);
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
if (a[0] != b[0]) {
printf("NO\n");
continue;
}
if (n == 1 && a[0] == b[0]) {
printf("YES\n");
continue;
}
bool flag = 0;
for (int i = n - 1; i >= 1; --i) {
flag = 0;
if (b[i] == a[i]) {
flag = 1;
continue;
} else if (b[i] < a[i]) {
for (int j = 0; j < i; ++j) {
if (a[j] == -1) {
flag = 1;
break;
}
}
} else if (b[i] > a[i]) {
for (int j = 0; j < i; ++j) {
if (a[j] == 1) {
flag = 1;
break;
}
}
}
if (flag == 0) break;
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, x, a[105];
int cnt;
int main() {
cin >> n >> k >> x;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - k; i++) {
cnt += a[i];
}
for (int i = n - k; i < n; i++) {
cnt += min(a[i], x);
}
cout << cnt;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int RI() { return 0; }
template <typename T>
int RI(T& a) {
int c;
int s = 1;
while (!((c = getchar()) == '-' || isdigit(c) || c == EOF))
;
if (c == EOF) return 0;
if (c == '-') {
s = -1;
c = getchar();
}
a = 0;
do {
a = 10 * a + s * (c - '0');
} while (isdigit(c = getchar()));
return 1;
}
template <typename T, typename... Args>
int RI(T& a, Args&... args) {
return RI(a) ? 1 + RI(args...) : 0;
}
template <typename T>
void __PI(T a) {
static const int maxd = 25;
static char d[maxd];
int i = maxd - 1;
int s = a < 0 ? -1 : 1;
do {
d[--i] = s * (a % 10) + '0';
} while (a /= 10);
if (s < 0) d[--i] = '-';
fputs(d + i, stdout);
}
template <char sep>
void __PSI() {}
template <char sep, typename T>
void __PSI(const T& a) {
putchar(sep), __PI(a);
}
template <char sep, typename T, typename... Args>
void __PSI(const T& a, const Args&... args) {
__PSI<sep, T>(a), __PSI<sep, Args...>(args...);
}
template <char sep = ' ', char end = '\n', typename T, typename... Args>
void PI(const T& a, const Args&... args) {
__PI(a), __PSI<sep, Args...>(args...), putchar(end);
}
const int maxn = 1.28e5;
double p[maxn];
double dp[maxn];
int main() {
int n;
RI(n);
for (__typeof(n + 1) i = (1) - ((1) > (n + 1));
i != (n + 1) - ((1) > (n + 1)); i += 1 - 2 * ((1) > (n + 1)))
scanf("%lf", p + i);
dp[0] = 0.0;
double ans = 0.0;
for (__typeof(n + 1) i = (1) - ((1) > (n + 1));
i != (n + 1) - ((1) > (n + 1)); i += 1 - 2 * ((1) > (n + 1))) {
dp[i] = (dp[i - 1] + p[i - 1]) * p[i];
ans += dp[i];
}
ans *= 2.0;
for (__typeof(n + 1) i = (1) - ((1) > (n + 1));
i != (n + 1) - ((1) > (n + 1)); i += 1 - 2 * ((1) > (n + 1)))
ans += p[i];
printf("%.15f\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
char c;
int num = 0, flg = 1;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flg = -1;
while (c >= '0' && c <= '9') {
num = num * 10 + c - 48;
c = getchar();
}
return num * flg;
}
int f[605][605], g[605], ind[605], oud[605];
int fir[605], nxt[100005], to[100005], cnt;
int n, m, mod;
int incnt, in[605], oucnt, ou[605];
void adde(int a, int b) {
to[++cnt] = b;
nxt[cnt] = fir[a];
fir[a] = cnt;
ind[b]++;
oud[a]++;
}
int fg;
void dfs(int u) {
if (fg == u) {
g[u] = 1;
return;
}
g[u] = 0;
int v, p;
for (p = fir[u]; p; p = nxt[p]) {
v = to[p];
if (g[v] == -1) dfs(v);
g[u] = (1ll * g[u] + 1ll * g[v]) % mod;
}
}
int ksm(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = 1ll * ans * x % mod;
y >>= 1;
x = 1ll * x * x % mod;
}
return ans;
}
void Gauss() {
int ans = 1, flg = 1;
int i, j, k;
for (i = 1; i <= incnt; i++) {
if (!f[i][i]) {
for (j = i + 1; j <= incnt; j++)
if (f[j][i]) break;
if (j > incnt) {
printf("0");
return;
}
flg = -flg;
for (k = 1; k <= oucnt; k++) swap(f[i][k], f[j][k]);
}
for (j = i + 1; j <= incnt; j++) {
if (!f[j][i]) continue;
int tmp = 1ll * f[j][i] * ksm(f[i][i], mod - 2) % mod;
for (k = i; k <= oucnt; k++)
f[j][k] =
(1ll * (1ll * f[j][k] - 1ll * f[i][k] * tmp) % mod + 1ll * mod) %
mod;
}
ans = 1ll * ans * f[i][i] % mod;
}
printf("%d\n", (1ll * ans * flg + 1ll * mod) % mod);
}
int main() {
int u, v, i, j;
n = gi();
m = gi();
mod = gi();
for (i = 1; i <= m; i++) {
u = gi();
v = gi();
adde(u, v);
}
for (i = 1; i <= n; i++)
if (!ind[i]) in[i] = ++incnt;
for (j = 1; j <= n; j++) {
if (!oud[j]) {
ou[j] = ++oucnt;
fg = j;
memset(g, -1, sizeof(g));
for (i = 1; i <= n; i++) {
if (!ind[i]) {
dfs(i);
f[in[i]][ou[j]] = g[i];
}
}
}
}
Gauss();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n;
long long c[30][30], b[30];
int main() {
cin >> s;
n = s.size();
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int k = 0; k <= 25; k++) {
c[k][s[i] - 'a'] += b[k];
ans = max(ans, c[k][s[i] - 'a']);
}
b[s[i] - 'a']++;
ans = max(ans, b[s[i] - 'a']);
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
cin >> b[i];
a[i] -= 1;
b[i] -= 1;
}
vector<int> ca(n), cb(n);
for (int i = 0; i < n; i++) {
ca[a[i]] += 1;
cb[b[i]] += 1;
}
long long ans = (long long)n * (n - 1) * (n - 2) / 6;
for (int i = 0; i < n; i++) {
ans -= 1LL * (ca[a[i]] - 1) * (cb[b[i]] - 1);
}
cout << ans << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
const double eps = 1e-8;
int a[maxn];
bool exs[maxn];
int main() {
int t, n;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
bool flag = 0;
memset(exs, 0, sizeof exs);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i] = (a[i] + i) % n;
if (a[i] < 0) a[i] += n;
if (exs[a[i]]) flag = 1;
exs[a[i]] = 1;
}
if (!flag)
puts("YES");
else
puts("NO");
}
}
| 4 |
#include <bits/stdc++.h>
int main() {
int w, y, m, t, x;
t = 6;
scanf("%d %d", &w, &y);
if (w == y)
x = 7 - w;
else if (w > y)
x = 7 - w;
else
x = 7 - y;
if (x % 2 == 0) {
x = x / 2;
t = t / 2;
}
if (x % 3 == 0) {
x = x / 3;
t = t / 3;
}
printf("%d/%d", x, t);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 10;
long long q;
long long st[N], ed[N], last[N], ans[N], cnt;
signed main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> q;
while (q--) {
long long op;
long long x;
cin >> op >> x;
if (op == 1) {
if (!st[x]) {
st[x] = ed[x] = ++cnt;
} else {
last[++cnt] = ed[x];
ed[x] = cnt;
}
} else {
long long y;
cin >> y;
if (x == y || !st[x]) continue;
if (!st[y]) {
st[y] = st[x];
ed[y] = ed[x];
} else {
last[st[x]] = ed[y];
ed[y] = ed[x];
}
st[x] = ed[x] = 0;
}
}
for (long long i = (1); i <= (5e5); i++) {
for (long long j = ed[i]; j; j = last[j]) ans[j] = i;
}
for (long long i = (1); i <= (cnt); i++) cout << ans[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<pair<long long int, long long int>, long long int> a,
pair<pair<long long int, long long int>, long long int> b) {
if (a.first.first != b.first.first)
return a.first.first < b.first.first;
else
return a.second < b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
pair<long long int, long long int> arr[n];
for (long long int i = 0; i < n; i++) {
cin >> arr[i].first >> arr[i].second;
}
long long int sec = 1;
long long int ans[n];
for (long long int i = 0; i < n; i++) {
if (sec < arr[i].first)
sec = arr[i].first;
else if (sec > arr[i].second) {
ans[i] = 0;
continue;
}
ans[i] = sec++;
}
for (long long int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN();
int main() {
int n, t;
scanf("%d%d", &n, &t);
string a;
cin >> a;
string b = "";
int i = 0;
while (i < a.size() && a[i] != '.') {
i++;
}
i++;
while (i < a.size() && a[i] < '5') {
i++;
}
if (i >= a.size()) {
cout << a;
return 0;
}
int d = 0;
while (t > 0 && a[i] != '.') {
if (a[i] >= '5') {
a[i] = '0';
if (a[i - 1] != '.') {
a[i - 1]++;
i--;
t--;
} else {
int j = i - 2;
while (j >= 0) {
if (a[j] == '9') {
a[j] = '0';
j--;
} else {
a[j]++;
break;
}
}
if (j < 0) d = 1;
i -= 2;
break;
}
} else
break;
}
if (d == 1) printf("1");
int k = 0;
while (k <= i) printf("%c", a[k++]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int inf = 0x3f3f3f3f;
const long long int INF = 1e18;
const int mod = 1e9 + 7;
const int maxn = 6e5 + 5;
const int maxm = 3e6 + 6;
struct node {
int to, next;
long long int w;
bool operator<(const node &_) const { return w < _.w; }
} e[maxm];
int n, q, s, idx;
int head[maxn], cnt;
int tree[2][maxn];
void init() {
memset(head, -1, sizeof(head));
cnt = 0;
memset(tree, 0, sizeof(tree));
idx = n;
}
void add(int u, int v, int w) {
e[cnt] = node{v, head[u], w};
head[u] = cnt++;
}
void build(int id, int l, int r, int f) {
tree[f][id] = ++idx;
if (l == r) {
if (!f)
add(idx, l, 0);
else
add(l, idx, 0);
return;
}
int mid = (l + r) >> 1;
build(id << 1, l, mid, f);
build(id << 1 | 1, mid + 1, r, f);
if (!f) {
add(tree[f][id], tree[f][id << 1], 0);
add(tree[f][id], tree[f][id << 1 | 1], 0);
} else {
add(tree[f][id << 1], tree[f][id], 0);
add(tree[f][id << 1 | 1], tree[f][id], 0);
}
}
vector<int> vs;
void query(int id, int l, int r, int ql, int qr, int f) {
if (ql <= l && r <= qr) {
vs.push_back(tree[f][id]);
return;
}
int mid = (l + r) >> 1;
if (ql <= mid) query(id << 1, l, mid, ql, qr, f);
if (qr > mid) query(id << 1 | 1, mid + 1, r, ql, qr, f);
}
long long int dis[maxn];
bool vis[maxn];
void dij(int st, int ed) {
priority_queue<node> q;
for (int i = 1; i <= maxn - 5; i++) {
dis[i] = INF;
vis[i] = 0;
}
dis[st] = 0;
q.push(node{st, 0, 0});
while (!q.empty()) {
node u = q.top();
q.pop();
if (vis[u.to]) continue;
vis[u.to] = 1;
for (int i = head[u.to]; ~i; i = e[i].next) {
int to = e[i].to;
if (dis[to] > dis[u.to] + e[i].w) {
dis[to] = dis[u.to] + e[i].w;
q.push(node{to, 0, -dis[to]});
}
}
}
}
void solve() {
while (~scanf("%d%d%d", &n, &q, &s)) {
init();
build(1, 1, n, 0);
build(1, 1, n, 1);
while (q--) {
int op, u, v, l, r, w;
scanf("%d%d", &op, &u);
if (op == 1) {
scanf("%d%d", &v, &w);
add(u, v, w);
} else if (op == 2) {
scanf("%d%d%d", &l, &r, &w);
vs.clear();
query(1, 1, n, l, r, 0);
for (int i = 0; i < (int)(vs).size(); i++) {
add(u, vs[i], w);
}
} else {
scanf("%d%d%d", &l, &r, &w);
vs.clear();
query(1, 1, n, l, r, 1);
for (int i = 0; i < (int)(vs).size(); i++) {
add(vs[i], u, w);
}
}
}
dij(s, n);
for (int i = 1; i <= n; i++) {
printf("%lld%c", dis[i] == INF ? -1ll : dis[i], i == n ? '\n' : ' ');
}
}
}
int main() {
int t = 1, cas = 1;
while (t--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int ar[n];
for (int i = 0; i < n; i++) {
scanf("%d", &ar[i]);
}
int c1 = 0, c2 = 0, c3 = 0;
for (int i = 0; i < n; i = i + 3) {
c1 = c1 + ar[i];
}
for (int i = 1; i < n; i = i + 3) {
c2 = c2 + ar[i];
}
for (int i = 2; i < n; i = i + 3) {
c3 = c3 + ar[i];
}
if (c1 > c2 && c1 > c3) {
printf("chest");
} else if (c2 > c3) {
printf("biceps");
} else {
printf("back");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int N, M, P, i, j, k, a, b, c, d, f, x, y, z, mini, n, p, s, ma;
long long int A[100];
char B[100][8];
cin >> M;
for (f = 0; f < M; f++) {
cin >> N;
s = 0;
long long int C[10000] = {0}, D[10000] = {0};
;
for (i = 0; i < N; i++) {
cin >> B[i];
x = stoi(B[i]);
C[x]++;
if (C[x] == 1) {
s++;
}
A[i] = x;
}
s = N - s;
;
cout << s << endl;
for (i = 0; i < N; i++) {
x = A[i];
if (D[x] == 0) {
cout << B[i] << endl;
D[x]++;
} else {
y = 0;
a = 1;
b = 1;
z = 0;
n = x % 10;
for (j = 0; j < 10; j++) {
if ((n + a) <= 9) {
c = x + a;
if (C[c] == 0) {
C[c]++;
z = a;
y = 1;
break;
}
}
if ((n - b) >= 0) {
d = x - b;
if (C[d] == 0) {
C[d]++;
z = -b;
y = 1;
break;
}
}
a++;
b++;
}
if (y == 1) {
p = B[i][3] + z;
B[i][3] = p;
B[i][4] = '\0';
cout << B[i] << endl;
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a = 4, b = 9, x;
for (long i = 0; i < long(3); i++) {
cin >> x;
a += x;
}
for (long i = 0; i < long(3); i++) {
cin >> x;
b += x;
}
cin >> x;
if ((int)(a / 5) + (int)(b / 10) <= x)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = ~0U >> 4;
bool a[1010][1010], b[1010][1010];
int U[1010][1010], D[1010][1010];
int L[1010][1010], R[1010][1010];
int N, M, Q;
void Renew(int x, int y) {
U[x][y] = U[x - 1][y] + 1;
D[x][y] = D[x + 1][y] + 1;
L[x][y] = L[x][y - 1] + 1;
R[x][y] = R[x][y + 1] + 1;
}
void Change(int x, int y) {
a[x][y] ^= 1;
if (a[x][y])
Renew(x, y);
else
U[x][y] = D[x][y] = L[x][y] = R[x][y] = 0;
for (int i = y + 1; i <= M; ++i)
if (a[x][i])
L[x][i] = L[x][i - 1] + 1;
else
break;
for (int i = y - 1; i >= 1; --i)
if (a[x][i])
R[x][i] = R[x][i + 1] + 1;
else
break;
for (int i = x + 1; i <= N; ++i)
if (a[i][y])
U[i][y] = U[i - 1][y] + 1;
else
break;
for (int i = x - 1; i >= 1; --i)
if (a[i][y])
D[i][y] = D[i + 1][y] + 1;
else
break;
}
int Query(int x, int y) {
if (a[x][y] == 0) return 0;
int ret = 0, Lm, Rm, Um, Dm;
Lm = Rm = inf;
for (int i = x; i >= 1; --i)
if (a[i][y]) {
Lm = min(Lm, L[i][y]);
Rm = min(Rm, R[i][y]);
ret = max(ret, (x - i + 1) * (Lm + Rm - 1));
} else
break;
Lm = Rm = inf;
for (int i = x; i <= N; ++i)
if (a[i][y]) {
Lm = min(Lm, L[i][y]);
Rm = min(Rm, R[i][y]);
ret = max(ret, (i - x + 1) * (Lm + Rm - 1));
} else
break;
Um = Dm = inf;
for (int i = y; i >= 1; --i)
if (a[x][i]) {
Um = min(Um, U[x][i]);
Dm = min(Dm, D[x][i]);
ret = max(ret, (y - i + 1) * (Um + Dm - 1));
} else
break;
Um = Dm = inf;
for (int i = y; i <= M; ++i)
if (a[x][i]) {
Um = min(Um, U[x][i]);
Dm = min(Dm, D[x][i]);
ret = max(ret, (i - y + 1) * (Um + Dm - 1));
} else
break;
return ret;
}
int main() {
scanf("%d%d%d", &N, &M, &Q);
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) {
scanf("%d", &a[i][j]);
if (a[i][j]) L[i][j] = L[i][j - 1] + 1, U[i][j] = U[i - 1][j] + 1;
}
for (int i = N; i >= 1; --i)
for (int j = M; j >= 1; --j)
if (a[i][j]) R[i][j] = R[i][j + 1] + 1, D[i][j] = D[i + 1][j] + 1;
for (int i = 1; i <= Q; ++i) {
int opt, x, y;
scanf("%d%d%d", &opt, &x, &y);
if (opt == 1)
Change(x, y);
else
printf("%d\n", Query(x, y));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
void test() {
long long n, ans = 0;
cin >> n;
long long a[n], b[n];
map<long long, long long> m, m1, m2;
map<long long, long long>::iterator ir;
for (long long i = 0; i < n; i++) {
cin >> a[i];
m[a[i]] = i + 1;
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
m1[b[i]] = i + 1;
}
for (long long i = 1; i < n + 1; i++) {
if (m1[i] >= m[i])
m2[m1[i] - m[i]]++;
else
m2[n + m1[i] - m[i]]++;
}
for (ir = m2.begin(); ir != m2.end(); ir++) {
ans = max(ans, ir->second);
}
cout << ans;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t = 1;
while (t--) {
test();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " = " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " = " << arg1 << " || ";
__f(comma + 1, args...);
}
template <class Ch, class Tr, class Container>
basic_ostream<Ch, Tr>& operator<<(basic_ostream<Ch, Tr>& os,
Container const& x) {
os << "{ ";
for (auto& y : x) os << y << " ; ";
return os << "}";
}
template <class X, class Y>
ostream& operator<<(ostream& os, pair<X, Y> const& p) {
return os << "[ " << p.first << ", " << p.second << "]";
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long k, x, y;
const long long L = 2e3 + 50;
long long dp[L][L];
long long rec(long long seq, long long as) {
if (dp[seq][as] != -1) return dp[seq][as];
if (seq >= k) {
return dp[seq][as] = 0;
}
if (as >= k) {
long long den = (1 - x + mod) % mod;
den = power(den, mod - 2, mod);
long long ret = (as * y) % mod;
ret *= den;
ret %= mod;
long long ret2 = (y * den) % mod;
ret2 *= x;
ret2 %= mod;
ret2 *= den;
ret2 %= mod;
ret += ret2;
ret %= mod;
return dp[seq][as] = ret;
}
long long ans1 = (x * rec(seq, as + 1)) % mod;
long long temp = (rec(seq + as, as) + as) % mod;
long long ans2 = (y * temp) % mod;
ans1 += ans2;
ans1 %= mod;
return dp[seq][as] = ans1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long pa, push_back;
cin >> k >> pa >> push_back;
long long den = (pa + push_back) % mod;
x = (pa * power(den, mod - 2, mod)) % mod;
y = (push_back * power(den, mod - 2, mod)) % mod;
for (long long i = 0; i <= 2 * k + 5; i++) {
for (long long j = 0; j <= k + 5; j++) {
dp[i][j] = -1;
}
}
cout << rec(0, 1) << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1E-9;
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double PI = 2 * acos(.0);
double dist(long long x, long long y, long long px, long long py) {
return sqrt(1.0 * ((x - px) * (x - px) + (y - py) * (y - py)));
}
int main() {
long long n, k;
double x, y, px, py;
double segment = 0;
cin >> n >> k;
cin >> px >> py;
for (int i = 0; i < (int)(n - 1); i++) {
cin >> x >> y;
segment += dist(x, y, px, py);
px = x;
py = y;
}
printf("%.9f\n", (k * segment / 50.0));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
vector<pair<long long, long long> > adj[300005];
bool visited[300005];
map<pair<long long, long long>, long long> mp;
map<pair<long long, long long>, long long> mp2;
long long dist[300005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
memset(dist, -1, sizeof(dist));
for (int i = 0; i < m; i++) {
long long a, b, c;
cin >> a >> b >> c;
adj[a].push_back({c, b});
adj[b].push_back({c, a});
mp[{min(a, b), max(a, b)}] = i + 1;
}
visited[1] = true;
set<pair<long long, long long> > s;
for (auto i : adj[1]) {
s.insert(i);
dist[i.second] = i.first;
mp2[i] = mp[{min(1LL, i.second), max(1LL, i.second)}];
}
vector<long long> taken;
while (taken.size() < k && !s.empty()) {
pair<long long, long long> p = *s.begin();
s.erase(p);
long long ver = p.second;
if (visited[ver]) {
continue;
}
visited[ver] = true;
taken.push_back(mp2[p]);
for (auto i : adj[ver]) {
long long w = i.first;
long long v2 = i.second;
if (dist[v2] == -1) {
dist[v2] = dist[ver] + w;
pair<long long, long long> p2 = {dist[v2], v2};
s.insert(p2);
mp2[p2] = mp[{min(v2, ver), max(v2, ver)}];
} else if (dist[v2] > dist[ver] + w) {
pair<long long, long long> p1 = make_pair(dist[v2], v2);
mp2.erase(p1);
s.erase(p1);
dist[v2] = dist[ver] + w;
pair<long long, long long> p2 = {dist[v2], v2};
s.insert(p2);
mp2[p2] = mp[{min(v2, ver), max(v2, ver)}];
}
}
}
cout << taken.size() << endl;
for (auto i : taken) {
cout << i << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool kontrol(int g, int b) {
if (b >= g - 1 && b <= (g + 1) * 2) return 1;
return 0;
}
int main() {
int gl, gr, bl, br;
cin >> gl >> gr >> bl >> br;
if (kontrol(gl, br) || kontrol(gr, bl))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long m, n, k, x, y, k1;
cin >> n >> m >> k;
if (0 <= k && k <= n - 1) {
cout << k + 1 << " " << 1;
} else if (n <= k && k <= n + m - 2) {
cout << n << " " << k - n + 2;
} else {
k1 = k - m - n + 1;
x = k1 / (m - 1);
y = k1 % (m - 1);
if (x % 2 == 0) {
cout << n - 1 - x << " " << m - y;
} else {
cout << n - 1 - x << " " << 2 + y;
}
}
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
int n, k;
const int MAXN = 1e5 + 5;
int a[MAXN];
void run() {
int mm, t;
bool flag, flag2;
int cnt = 0, ans = 0, begin = 1;
cin >> n >> k;
for (int i = 0; i < k; i++) {
cin >> mm;
flag = false;
flag2 = false;
for (int j = 0; j < mm; j++) {
cin >> t;
a[j] = t;
if ((!j) && 1 == t) {
flag = true;
flag2 = true;
}
if (j && flag) {
if (a[j] != a[j - 1] + 1) {
begin = a[j - 1];
flag = false;
} else if (j == mm - 1) {
begin = a[j];
}
}
if (j && flag2 && !flag) {
cnt++;
}
if (j && !flag2) {
cnt++;
}
}
}
cout << (cnt + (n - begin)) << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
run();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 2e5 + 10;
const long long int mod = 1e9 + 7;
long long int pw(long long int a, long long int b) {
long long int ans = 1;
a %= mod;
while (b) {
if (b % 2) ans = (ans * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return ans;
}
long long int mul(long long int a, long long int b) {
a = a % mod;
b = b % mod;
a *= b;
if (a >= mod) return a - mod;
return a;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int n, k;
cin >> n >> k;
long long int ans = pw(k, k - 1);
long long int ans2 = pw(n - k, n - k);
ans = mul(ans, ans2);
ans %= mod;
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[1000000];
int main() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cin >> arr[i];
if (n == 1) {
cout << "+";
return 0;
}
long long su = -arr[n - 1];
string hi = "-";
for (long long i = n - 2; i >= 0; i--) {
if (i <= 20) {
for (long long j = 0; j < (1 << (i + 1)); j++) {
long long yo = su;
for (long long k = 0; k <= i; k++) {
if (j & (1 << k))
yo += arr[k];
else
yo -= arr[k];
}
if (yo >= 0 && yo <= arr[0]) {
for (long long k = i; k >= 0; k--) {
if (j & (1 << k))
hi += '+';
else
hi += '-';
}
reverse(hi.begin(), hi.end());
cout << hi;
return 0;
}
}
break;
} else {
if (su >= 0)
su -= arr[i], hi += '-';
else
su += arr[i], hi += '+';
}
}
hi = "+";
su = arr[n - 1];
for (long long i = n - 2; i >= 0; i--) {
if (i <= 20) {
for (long long j = 0; j < (1 << (i + 1)); j++) {
long long yo = su;
for (long long k = 0; k <= i; k++) {
if (j & (1 << k))
yo += arr[k];
else
yo -= arr[k];
}
if (yo >= 0 && yo <= arr[0]) {
for (long long k = i; k >= 0; k--) {
if (j & (1 << k))
hi += '+';
else
hi += '-';
}
reverse(hi.begin(), hi.end());
cout << hi;
return 0;
}
}
break;
} else {
if (su >= 0)
su -= arr[i], hi += '-';
else
su += arr[i], hi += '+';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, s;
signed main() {
cin >> n;
s = 0;
for (int i = 1; i <= n; i++) {
long long x;
int y;
cin >> x;
if (x < 4)
y = 0;
else if (x < 16)
y = 1;
else if (x < 82)
y = 2;
else if (x < 6724)
y = 0;
else if (x < 50626)
y = 3;
else if (x < 2562991876ll)
y = 1;
else
y = 2;
s = s ^ y;
}
if (s > 0)
cout << "Furlo";
else
cout << "Rublo";
}
| 7 |
#include <bits/stdc++.h>
int b_i[140585];
int n;
int pivot_indx;
long long int a_i[140585];
void read_in() {
scanf("%d", &n);
pivot_indx = -1;
for (int i = 0; i < n; i++) {
scanf("%d", &b_i[i]);
}
for (int i = 0; i < n; i++) {
int j = (i + n - 1) % n;
if (b_i[i] > b_i[j]) {
pivot_indx = i;
break;
}
}
}
int main() {
read_in();
if (pivot_indx == -1) {
if (b_i[0] == 0) {
printf("YES\n");
for (int i = 0; i < n; i++) {
printf("2 ");
}
return 0;
}
printf("NO");
return 0;
}
a_i[pivot_indx] = b_i[pivot_indx];
int nxt_indx = (pivot_indx - 1 + n) % n;
long long int prev_value = a_i[pivot_indx];
for (int i = 0; i < n - 1; i++) {
int nxt_nxt_indx = (nxt_indx - 1 + n) % n;
int limit_value = b_i[nxt_nxt_indx];
if ((limit_value - b_i[nxt_indx]) < prev_value) {
a_i[nxt_indx] = prev_value + b_i[nxt_indx];
} else {
long long int div = (limit_value - b_i[nxt_indx]) / prev_value;
div++;
a_i[nxt_indx] = prev_value * div + b_i[nxt_indx];
}
prev_value = a_i[nxt_indx];
nxt_indx = nxt_nxt_indx;
}
printf("YES\n");
for (int i = 0; i < n; i++) {
printf("%I64d ", a_i[i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
long long T = 1;
while (T--) {
long long n;
cin >> n;
long long sma = 0, smg = 0;
string ans = "";
for (long long i = 0; i < n; i++) {
long long a, g;
cin >> a >> g;
if (abs(a + sma - smg) <= 500) {
sma += a;
ans += 'A';
} else {
smg += g;
ans += 'G';
}
}
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int len = 0;
bitset<4200000> flag;
char ans[2000006];
char pat[2000006];
inline void seg_update(int a, int b, int u, int l, int r, int delta) {
if (flag[u]) return;
if (b < l || a > r) return;
if (l == r) {
ans[l] = pat[l - delta];
flag[u] = 1;
len = max(len, l);
return;
}
if (a <= l && r <= b) {
int m = l + r >> 1;
seg_update(a, b, u * 2, l, m, delta);
seg_update(a, b, u * 2 + 1, m + 1, r, delta);
flag[u] = 1;
} else {
int m = l + r >> 1;
seg_update(a, b, u * 2, l, m, delta);
seg_update(a, b, u * 2 + 1, m + 1, r, delta);
}
}
int main() {
ios::sync_with_stdio(false);
scanf("%d\n", &n);
while (n--) {
int k;
scanf("%s %d", pat, &k);
int sz = strlen(pat);
while (k--) {
int p;
scanf("%d", &p);
seg_update(p, sz - 1 + p, 1, 1, 2000005, p);
}
}
for (int i = 1; i <= len; ++i) {
if (ans[i] == 0)
cout << 'a';
else
cout << ans[i];
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2ll * 1000 * 1000 * 1000 * 1000;
const int MAXN = 100 * 100 * 100 + 101;
int n, b[1000][1000];
char a[1000][1000];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[i][j] == '#' && a[i + 1][j] == '#' && a[i + 2][j] == '#' &&
a[i + 1][j - 1] == '#' && a[i + 1][j + 1] == '#') {
if (!b[i][j] && !b[i + 1][j] && !b[i + 2][j] && !b[i + 1][j - 1] &&
!b[i + 1][j + 1]) {
b[i][j]++;
b[i + 1][j]++;
b[i + 2][j]++;
b[i + 1][j + 1]++;
b[i + 1][j - 1]++;
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[i][j] == '#' && !b[i][j]) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> a, pre, ev;
vector<vector<long long>> nxt;
long long n;
int32_t main() {
cin >> n;
a.resize(n);
pre.assign(n + 1, 0);
ev.assign(2, 0);
ev[0] = 1;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
a[i] = __builtin_popcountll(a[i]);
pre[i + 1] = pre[i] + a[i];
ev[pre[i + 1] % 2]++;
}
nxt.resize(n, vector<long long>(64, n));
auto c2 = [&](long long x) { return x * (x - 1) / 2; };
long long cnt = c2(ev[1]) + c2(ev[0]);
for (long long l = 0; l < n; ++l) {
long long su = 0, mx = 0;
for (long long r = l; r < min(n, l + 70); ++r) {
su += a[r];
mx = max(mx, a[r]);
if (su < 2LL * mx && su % 2 == 0) cnt--;
}
}
cout << cnt << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
int solve() {
long long int n, k, l;
cin >> n >> k;
string s;
cin >> s;
l = s.size();
int cost = 0;
queue<string> q;
q.push(s);
mp[s] = 1;
while (!q.empty()) {
string top = q.front();
q.pop();
cost += l - (int)top.size();
k--;
if (k == 0) {
break;
}
for (int i = 0; i < (int)top.size(); i++) {
string temp = top;
temp.erase(i, 1);
if (mp[temp] == 0) {
q.push(temp);
mp[temp] = 1;
}
}
}
if (k >= 1) {
cost = -1;
}
cout << cost;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
t = 1;
while (t--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 1e5 + 10;
class Node {
public:
int counts[62];
bool lazy[62];
Node() {
for (int i = 0; i < 62; ++i) {
counts[i] = 0;
lazy[i] = false;
}
}
};
Node tree[MAXN << 2];
char s[MAXN];
bool lazy[62];
int n, m;
int char2Index(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
} else if (c >= 'a' && c <= 'z') {
return c - 'a' + 10;
} else {
return c - 'A' + 36;
}
}
void insert(int now, int pos, char c, int l, int r) {
if (pos >= l && pos <= r) {
int i = char2Index(c);
tree[now].counts[i]++;
}
if (l == r) return;
int mid = (l + r) >> 1;
if (pos <= mid)
insert(now << 1, pos, c, l, mid);
else
insert((now << 1) | 1, pos, c, mid + 1, r);
return;
}
void Delete(int now, int tl, int tr, int l, int r, char c) {
int i = char2Index(c);
if (tl == l && tr == r) {
tree[now].counts[i] = 0;
tree[now].lazy[i] = true;
return;
}
int mid = (tl + tr) >> 1;
if (l >= mid + 1) {
Delete((now << 1) | 1, mid + 1, tr, l, r, c);
} else if (r <= mid) {
Delete((now << 1), tl, mid, l, r, c);
} else {
Delete((now << 1), tl, mid, l, mid, c);
Delete((now << 1) | 1, mid + 1, tr, mid + 1, r, c);
}
tree[now].counts[i] =
min(tree[now].counts[i],
tree[now << 1].counts[i] + tree[(now << 1) | 1].counts[i]);
return;
}
int oriIndex(int dex) {
for (int i = 0; i < 62; ++i) lazy[i] = false;
int now = 1;
int cap = n;
int cts = 0;
int ans = 0;
int l = 1;
int r = n;
while (l != r) {
int mid = (l + r) >> 1;
for (int i = 0; i < 62; ++i) lazy[i] |= tree[now].lazy[i];
int left_total = 0;
for (int i = 0; i < 62; ++i) {
if (!lazy[i]) left_total += tree[now << 1].counts[i];
}
if (cts + left_total < dex) {
ans += (cap + 1) >> 1;
cts += left_total;
cap = cap >> 1;
now = (now << 1) | 1;
l = mid + 1;
} else {
cap = (cap + 1) >> 1;
now = (now << 1);
r = mid;
}
}
ans += cap;
return ans;
}
bool query(int pos) {
int now = 1;
int tl = 1;
int tr = n;
int i = char2Index(s[pos - 1]);
while (tl != tr) {
if (tree[now].counts[i] == 0) {
return false;
}
int mid = (tl + tr) >> 1;
if (pos <= mid) {
now = now << 1;
tr = mid;
} else {
now = (now << 1) | 1;
tl = mid + 1;
}
}
if (tree[now].counts[i] == 0) {
return false;
}
return tree[now].counts[i] != 0;
}
int l, r;
char c;
int main() {
scanf("%d", &n);
scanf("%d", &m);
scanf("%s", s);
for (int i = 0; i < (MAXN << 1); ++i) {
for (int j = 0; j < 62; ++j) tree[i].counts[j] = 0;
}
int s_len = strlen(s);
for (int i = 0; i < s_len; ++i) insert(1, i + 1, s[i], 1, n);
for (int j = 0; j < m; ++j) {
cin >> l >> r;
cin >> c;
int ol = oriIndex(l);
int _or = oriIndex(r);
Delete(1, 1, n, ol, _or, c);
}
for (int i = 1; i <= s_len; ++i) {
if (query(i)) cout << s[i - 1];
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100001];
int a[300001], b[300001], ans[100001];
bool vis[100001], vis2[100001];
int p[100001];
int root(int a) { return p[a] == a ? a : (p[a] = root(p[a])); }
void merge(int a, int b) {
a = root(a), b = root(b);
if (a != b) p[a] = b;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i], &b[i]);
g[a[i]].push_back(b[i]);
g[b[i]].push_back(a[i]);
}
int l = 0;
for (int i = 0; i < g[1].size(); i++) {
int v = g[1][i];
vis[v] = 1;
l = v;
}
for (int i = 0; i < g[l].size(); i++) {
int v = g[l][i];
if (vis[v]) vis2[v] = 1;
}
vector<int> x, y, z;
for (int i = 1; i <= n; i++) {
if (!vis[i])
x.push_back(i);
else if (vis[i] && !vis2[i])
y.push_back(i);
else
z.push_back(i);
}
for (int i = 1; i < x.size(); i++) {
merge(x[0], x[i]);
}
for (int i = 1; i < y.size(); i++) {
merge(y[0], y[i]);
}
for (int i = 1; i < z.size(); i++) {
merge(z[0], z[i]);
}
bool ok = 1;
for (int i = 1; i <= m; i++) {
if (root(a[i]) == root(b[i])) ok = 0;
}
if (x.size() + y.size() + z.size() != n || x.size() == 0 || y.size() == 0 ||
z.size() == 0)
ok = 0;
for (int i = 0; i < x.size(); i++) {
int u = x[i];
if (g[u].size() != y.size() + z.size()) ok = 0;
}
for (int i = 0; i < y.size(); i++) {
int u = y[i];
if (g[u].size() != x.size() + z.size()) ok = 0;
}
for (int i = 0; i < z.size(); i++) {
int u = z[i];
if (g[u].size() != x.size() + y.size()) ok = 0;
}
if (!ok)
printf("-1\n");
else {
for (int i = 0; i < x.size(); i++) {
ans[x[i]] = 1;
}
for (int i = 0; i < y.size(); i++) {
ans[y[i]] = 2;
}
for (int i = 0; i < z.size(); i++) {
ans[z[i]] = 3;
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 30;
const int mod = 1e9 + 7;
const double eps = 1e-7;
int n;
double k;
double arr[MAX];
bool solve(double val) {
double tot = 0;
for (int i = 1; i <= n; i++) {
if (arr[i] > val) {
tot = tot + (arr[i] - val);
}
}
tot *= 1 - k / 100;
for (int i = 1; i <= n; i++) {
if (arr[i] < val) {
tot = tot - (val - arr[i]);
}
}
return tot > -1e-12;
}
int main() {
cin >> n >> k;
double sum = 0;
for (int i = 1; i <= n; i++) cin >> arr[i];
double l = 0, h = 1000;
double ans = INT_MAX;
for (int i = 0; i < 100; i++) {
double mid = (l + h) / 2;
if (solve(mid)) {
l = mid;
ans = mid;
} else {
h = mid;
}
}
cout << setprecision(15) << l;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
ifstream in("text.in");
ofstream out("text.out");
multiset<int> mst;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, ans = 1;
cin >> n;
mst.insert(0);
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
if (mst.find(x) != mst.end()) {
mst.erase(mst.find(x));
mst.insert(i);
} else {
++ans;
mst.insert(i);
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005];
int mod[1005];
bool dp[1005][1005];
int main(void) {
int cnt = 0;
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
fill(mod, mod + 1001, 0);
memset(dp, false, sizeof(dp));
int s = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i] %= m;
s += a[i];
if (s >= m) s %= m;
}
if (n > m) {
printf("YES\n");
continue;
}
dp[0][0] = true;
bool ans = false;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++) {
dp[i][j] = dp[i - 1][j];
}
for (int j = 0; j < m; j++) {
if (dp[i - 1][j]) {
if ((j + a[i - 1]) % m == 0) ans = true;
dp[i][(j + a[i - 1]) % m] = true;
}
}
}
if (ans)
puts("YES");
else
puts("NO\n");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool SR(int &x) { return scanf("%d", &x) == 1; }
bool SR(long long &x) { return scanf("%lld", &x) == 1; }
bool SR(double &x) { return scanf("%lf", &x) == 1; }
bool SR(char *s) { return scanf("%s", s) == 1; }
bool RI() { return true; }
template <typename I, typename... T>
bool RI(I &x, T &...tail) {
return SR(x) && RI(tail...);
}
void SP(const int x) { printf("%d", x); }
void SP(const long long x) { printf("%lld", x); }
void SP(const double x) { printf("%.16lf", x); }
void SP(const char *s) { printf("%s", s); }
void PL() { puts(""); }
template <typename I, typename... T>
void PL(const I x, const T... tail) {
SP(x);
if (sizeof...(tail)) putchar(' ');
PL(tail...);
}
int a[2], b[2], c[2];
void read() {
for (int i = 0; i < int(2); i++) RI(a[i], b[i], c[i]);
}
void build() {}
void sol() {
for (int i = 0; i < int(2); i++)
if (a[i] == 0 && b[i] == 0 && c[i]) {
PL(0);
return;
}
long long d = a[0] * b[1] - a[1] * b[0];
long long dx = b[0] * c[1] - b[1] * c[0];
long long dy = c[0] * a[1] - c[1] * a[0];
if (d == 0) {
if (dx == 0 && dy == 0)
PL(-1);
else
PL(0);
} else
PL(1);
}
int main() {
read();
build();
sol();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 33;
int mp[N][N];
int sx, sy;
struct node {
int x, y;
} a[N];
int dp[1 << 25];
int pre[1 << 25];
int dis(int i, int j) {
return (a[i].x - a[j].x) * (a[i].x - a[j].x) +
(a[i].y - a[j].y) * (a[i].y - a[j].y);
}
vector<int> ans;
void solve() {
cin >> sx >> sy;
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].x >> a[i].y;
a[0] = {sx, sy};
int cnt = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
mp[i][j] = (a[i].x - a[j].x) * (a[i].x - a[j].x) +
(a[i].y - a[j].y) * (a[i].y - a[j].y);
}
}
int t = 0;
memset(dp, 0x3f, sizeof dp);
memset(pre, -1, sizeof pre);
dp[0] = 0;
int inf = 0x3f3f3f3f3f3f3f3f;
for (int s = 0; s < 1 << n; s++) {
if (dp[s] == inf) continue;
for (int i = 1; i <= n; i++) {
if (s & 1 << (i - 1)) continue;
for (int j = 1; j <= n; j++) {
if (s & 1 << (j - 1)) continue;
if (dp[s | (1 << (i - 1)) | (1 << (j - 1))] >
dp[s] + dis(j, 0) + dis(i, j) + dis(i, 0)) {
dp[s | (1 << (i - 1)) | (1 << (j - 1))] =
dp[s] + dis(j, 0) + dis(i, j) + dis(i, 0);
pre[s | (1 << (i - 1)) | (1 << (j - 1))] = s;
}
}
break;
}
}
int now = (1 << n) - 1;
ans.push_back(0);
while (now != -1) {
int s = pre[now];
if (s == -1) s = 0;
bool f = 1;
for (int i = 1; i <= n; i++) {
if (((s >> (i - 1)) & 1) != ((now >> (i - 1)) & 1)) {
ans.push_back(i);
f = 0;
}
}
ans.push_back(0);
now = s;
if (s == 0) break;
}
cout << dp[(1 << n) - 1] << endl;
for (auto iter : ans) cout << iter << " ";
}
signed main() {
int t = 1;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
const int M = 2e6 + 7;
long long g[M], q[M];
int n, a[N];
void push(int v, int lr, int rl) {
g[v << 1] += q[v];
g[v << 1 | 1] += q[v];
q[v << 1] += q[v];
q[v << 1 | 1] += q[v];
q[v] = 0;
}
void upd1(int v, int lr, int rl, int l, int x) {
if ((lr & rl) == l) {
g[v] += x;
return;
}
push(v, lr, rl);
int m = (lr + rl) >> 1;
if (l <= m)
upd1(v << 1, lr, m, l, x);
else
upd1(v << 1 | 1, m + 1, rl, l, x);
g[v] = max(g[v << 1], g[v << 1 | 1]);
}
void upd2(int v, int lr, int rl, int l, int r, int x) {
if (l > r) return;
if (lr == l && rl == r) {
q[v] += x;
g[v] += x;
push(v, lr, rl);
return;
}
push(v, lr, rl);
int m = (lr + rl) >> 1;
upd2(v << 1, lr, m, l, min(m, r), x);
upd2(v << 1 | 1, m + 1, rl, max(l, m + 1), r, x);
g[v] = max(g[v << 1], g[v << 1 | 1]);
}
int get(int v, int lr, int rl) {
if (g[v] < 0) return -1;
push(v, lr, rl);
if (lr == rl) return (g[v] ? -1 : lr);
int m = (lr + rl) >> 1;
int first = get(v << 1, lr, m);
int second = get(v << 1 | 1, m + 1, rl);
g[v] = max(g[v << 1], g[v << 1 | 1]);
return max(first, second);
}
int main() {
int w, z = 1;
scanf("%d %d", &n, &w);
while (z < n) z <<= 1;
long long sum = 0;
memset(g, (-1000000000000000007), sizeof(g));
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
g[z - 1 + i] = a[i] - sum;
sum += a[i];
}
for (int i = z - 1; i; --i) g[i] = max(g[i << 1], g[i << 1 | 1]);
for (int i = 0, x, y; i < w; ++i) {
scanf("%d %d", &x, &y);
upd1(1, 1, z, x, y - a[x]);
upd2(1, 1, z, x + 1, n, a[x] - y);
a[x] = y;
printf("%d\n", get(1, 1, z));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
string S[1000];
for (int i = 0; i < N; i++) cin >> S[i];
int A[1000];
for (int i = 0; i < M; i++) cin >> A[i];
int ans = 0;
for (int j = 0; j < M; j++) {
map<char, int> mp;
for (int i = 0; i < N; i++) mp[S[i][j]]++;
int mx = 0;
for (auto& p : mp) mx = max(mx, p.second);
ans += mx * A[j];
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 2e9;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, t, te;
cin >> s;
int pos, epos;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '.') pos = i;
if (s[i] == 'e') {
epos = i;
i++;
for (; i < s.size(); i++) t += s[i];
}
}
stringstream geek(t);
int inc, rem, last;
geek >> inc;
rem = epos - pos - 1;
if (rem == inc) {
for (int i = 0; i < pos; i++) cout << s[i];
for (int i = pos + 1; i < epos; i++) cout << s[i];
} else if (rem > inc) {
for (int i = 0; i < pos; i++) cout << s[i];
last = pos;
for (int i = pos + 1; inc; i++) cout << s[i], inc--, last = i;
bool ok = false;
for (int i = last + 1; i < epos; i++) {
te += s[i];
if (s[i] != '0') ok = true;
}
if (ok) cout << '.' << te;
} else {
for (int i = 0; i < pos; i++) cout << s[i];
for (int i = pos + 1; i < epos; i++) cout << s[i];
cout << string(inc - rem, '0');
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool fs(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
int main() {
int n;
fs(n);
vector<int> vv(n);
for (int i = 0; i < n; i++) {
fs(vv[i]);
}
for (int i = n - 1; i >= 0; i--) {
if (vv[i] != vv[n - 1]) {
cout << i + 1 << endl;
return 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> myvec;
long long int dp[100003];
int main() {
int t1, t2, x, index1, index2, time, n;
vector<int>::iterator it, it2;
cin >> n;
myvec.push_back(0);
dp[0] = 0;
for (int i = 0; i < n; i++) cin >> x, myvec.push_back(x);
for (int i = 1; i <= n; i++) {
time = myvec[i];
t1 = max(0, myvec[i] - 90);
t2 = max(0, myvec[i] - 1440);
it = upper_bound(myvec.begin(), myvec.end(), t1);
it2 = upper_bound(myvec.begin(), myvec.end(), t2);
index1 = it - myvec.begin();
index2 = it2 - myvec.begin();
if (myvec[i] - 90 < 0) {
dp[i] = min(dp[0] + 50, dp[0] + 120);
dp[i] = min(dp[i], dp[i - 1] + 20);
} else {
if (myvec[i] - 1440 < 0)
dp[i] = min(dp[index1 - 1] + 50, dp[0] + 120);
else
dp[i] = min(dp[index1 - 1] + 50, dp[index2 - 1] + 120);
dp[i] = min(dp[i], dp[i - 1] + 20);
}
}
for (int i = 1; i <= n; i++) cout << dp[i] - dp[i - 1] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dx[] = {1, 0, -1, 0};
long long dy[] = {0, 1, 0, -1};
long long gcd(long long x, long long y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
long long expo(long long n, long long m, long long p) {
long long r = 1;
n = n % p;
while (m > 0) {
if (m % 2) r = (r * n) % p;
n = (n * n) % p;
m = m / 2;
}
return r % p;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
map<double, long long> p;
vector<string> v(n);
for (long long j = 0; j < n; j++) {
string s;
cin >> s;
v[j] = s;
long long a = 0, b = 0, c = 0;
long long i = 1;
while (s[i] != '+') {
a = a * 10 + s[i] - '0';
i++;
}
i++;
while (s[i] != ')') {
b = b * 10 + s[i] - '0';
i++;
}
i++;
i++;
while (i != s.size()) {
c = c * 10 + s[i] - '0';
i++;
}
double aa = (a * 1.0 + b) / c;
p[aa]++;
}
for (long long j = 0; j < n; j++) {
string s = v[j];
long long a = 0, b = 0, c = 0;
long long i = 1;
while (s[i] != '+') {
a = a * 10 + s[i] - '0';
i++;
}
i++;
while (s[i] != ')') {
b = b * 10 + s[i] - '0';
i++;
}
i++;
i++;
while (i != s.size()) {
c = c * 10 + s[i] - '0';
i++;
}
double aa = (a * 1.0 + b) / c;
cout << p[aa] << ' ';
}
cout << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long c[1005];
long long a[1005];
int main() {
long long n, m;
long long i;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> c[i];
for (i = 1; i <= m; i++) cin >> a[i];
long long ans = 0;
long long j;
i = 1, j = 1;
while (i <= n && j <= n) {
if (c[i] <= a[j]) {
ans++;
i++;
j++;
} else {
i++;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
const long long INF = 2e18;
int n;
long long a[N], b[N], c;
bool flag = true;
inline int len(long long x) {
int res = 0;
while (x > 1) {
x /= 10;
res++;
}
return res;
}
int check(long long x) {
long long res = 0;
for (int i = 0; i < n; i++) {
if (len(a[i]) + len(x) >= 19) return 1;
res += a[i] * x / b[i];
if (res > c - n) return 1;
}
if (res < c - n) return -1;
return 0;
}
int main() {
cin >> n >> c;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
flag &= a[i] == 0;
}
if (c < n) return cout << 0, 0;
if (flag && c == n) return cout << -1, 0;
long long l = 1, r = INF;
while (l < r) {
long long m = (l + r) / 2;
if (check(m) < 0)
l = m + 1;
else
r = m;
}
long long lpos = l;
l = 1, r = INF;
while (l < r) {
long long m = (l + r) / 2;
if (check(m) <= 0)
l = m + 1;
else
r = m;
}
cout << l - lpos;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ans, n, m, z, b, c;
int a[10000000 + 10];
inline int read() {
int w = 1, x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') w = (ch == '-' ? (-1) : (1)), ch = getchar();
while (ch >= '0' && ch <= '9') x *= 10, x += ch - '0', ch = getchar();
x *= w;
return x;
}
int main() {
n = read(), m = read();
for (register int i = 1; i <= m; ++i)
z = read(), b = read(), c = read(), a[z] += c, a[b] -= c;
for (register int i = 1; i <= n; ++i) ans += ((a[i]) > (0) ? (a[i]) : (0));
printf("%d", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long expo(long long x, long long y) {
long long res = 1;
while (y) {
if (y % 2) res = (res * x % mod) % mod;
x = (x * x) % mod;
y /= 2;
}
return res;
}
long long inv(long long x) { return expo(x, mod - 2); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
string s;
cin >> s;
vector<long long> div;
for (long long i = 2; i <= n; i++)
if (n % i == 0) div.push_back(i);
if (div.size() == 0) {
cout << s << "\n";
return 0;
}
sort(div.begin(), div.end());
for (long long i = 0; i < div.size(); i++) {
string t = "";
for (long long j = 0; j < div[i]; j++) t += s[j];
reverse(t.begin(), t.end());
string t2 = "";
for (long long j = 0; j < div[i]; j++) t2 += t[j];
for (long long j = div[i]; j < n; j++) t2 += s[j];
s = t2;
}
cout << s;
cout << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long r, x, y, x1, y1;
cin >> r >> x >> y >> x1 >> y1;
long long dist = ceil(sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1)));
if (dist == 0) {
cout << 0 << "\n";
} else if (dist % (r * 2) == 0) {
cout << dist / (r * 2);
} else {
cout << dist / (r * 2) + 1 << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
int flag[1000010];
int prime[1000010];
int ans[100010];
int p[20];
int main() {
int pcnt = 0;
memset(flag, -1, sizeof(flag));
for (int i = 2; i <= 1000000; i++) {
if (flag[i]) prime[pcnt++] = i;
for (int j = 0; j < pcnt && prime[j] <= 1000000 / i; j++) {
flag[i * prime[j]] = 0;
if (i % prime[j] == 0) break;
}
}
int tcnt = 0;
for (int i = 0; i < pcnt; i++) {
int num = prime[i];
int cnt = 0;
while (num != 0) {
p[cnt++] = num % 10;
num /= 10;
}
int tnum = 0;
for (int i = 0; i < cnt; i++) tnum = tnum * 10 + p[i];
if (tnum != prime[i] && flag[tnum]) ans[tcnt++] = prime[i];
}
int n;
while (scanf("%d", &n) == 1) {
printf("%d\n", ans[n - 1]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) x = (x << 1) + (x << 3) + (c & 15), c = getchar();
return x;
}
const int MAXN = 1000;
int f1[MAXN + 10], f2[MAXN + 10];
int get_fa1(int x) {
if (f1[x] == x) return x;
return f1[x] = get_fa1(f1[x]);
}
int get_fa2(int x) {
if (f2[x] == x) return x;
return f2[x] = get_fa2(f2[x]);
}
struct node {
int u, v;
};
int main() {
int n, m1, m2;
n = read(), m1 = read(), m2 = read();
for (int i = 1; i <= n; ++i) f1[i] = f2[i] = i;
for (int i = 1; i <= m1; ++i) {
int x = read(), y = read();
f1[get_fa1(x)] = get_fa1(y);
}
for (int i = 1; i <= m2; ++i) {
int x = read(), y = read();
f2[get_fa2(x)] = get_fa2(y);
}
static node sta[MAXN + 10];
int top = 0;
for (int u = 1; u <= n; ++u)
for (int v = u + 1; v <= n; ++v) {
if (get_fa1(u) != get_fa1(v) && get_fa2(u) != get_fa2(v)) {
sta[++top].u = u;
sta[top].v = v;
f1[get_fa1(u)] = get_fa1(v);
f2[get_fa2(u)] = get_fa2(v);
}
}
printf("%d\n", top);
for (int i = 1; i <= top; ++i) printf("%d %d\n", sta[i].u, sta[i].v);
return 0;
}
| 3 |
#include <bits/stdc++.h>
template <typename T>
inline void checkMin(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
inline void checkMax(T &a, T b) {
if (a < b) a = b;
}
using namespace std;
const int MAX_N = 55;
const int MAX_D = 10010;
const int MAX_M = MAX_N * MAX_D;
int n, d;
bool dp[MAX_M];
int main() {
std::ios_base::sync_with_stdio(false);
cin >> n >> d;
dp[0] = true;
int ps = 0;
for (int i = 0; i < int(n); ++i) {
int x;
cin >> x;
for (int y = (ps += x); y >= x; --y) {
dp[y] |= dp[y - x];
}
}
int i = 0, ans = 0;
while (true) {
int j;
for (j = i + d; j > i; --j) {
if (dp[j]) {
break;
}
}
if (j == i) {
break;
}
++ans;
i = j;
}
printf("%d %d\n", i, ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i <= n; i += 1234567) {
for (int j = 0; j <= n - i; j += 123456) {
if ((n - i - j) % 1234 == 0) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 500005;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const long long MOD = 100000007;
const double eps = 1e-10;
const double pi = 3.1415926535;
long long qpow(long long a, long long b) {
long long tmp = a % MOD, ans = 1;
while (b) {
if (b & 1) {
ans *= tmp, ans %= MOD;
}
tmp *= tmp, tmp %= MOD, b >>= 1;
}
return ans;
}
long long lowbit(long long x) { return x & -x; }
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
long long mmax(long long a, long long b, long long c) {
return max(a, max(b, c));
}
long long mmin(long long a, long long b, long long c) {
return min(a, min(b, c));
}
void mod(long long &a) {
a += MOD;
a %= MOD;
}
bool chk(long long now) {}
long long half(long long l, long long r) {
while (l <= r) {
long long m = (l + r) / 2;
if (chk(m))
r = m - 1;
else
l = m + 1;
}
return l;
}
long long ll(long long p) { return p << 1; }
long long rr(long long p) { return p << 1 | 1; }
long long mm(long long l, long long r) { return (l + r) / 2; }
long long lg(long long x) {
if (x == 0) return 1;
return (long long)log2(x) + 1;
}
bool smleql(double a, double b) {
if (a < b || fabs(a - b) <= eps) return true;
return false;
}
bool bigeql(double a, double b) {
if (a > b || fabs(a - b) <= eps) return true;
return false;
}
bool eql(double a, double b) {
if (fabs(a - b) < eps) return 1;
return 0;
}
double len(double a, double b, double c, double d) {
return sqrt((a - c) * (a - c) + (b - d) * (b - d));
}
bool isp(long long x) {
if (x == 1) return false;
if (x == 2) return true;
for (long long i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
inline long long read() {
char ch = getchar();
long long s = 0, w = 1;
while (ch < 48 || ch > 57) {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= 48 && ch <= 57) {
s = (s << 1) + (s << 3) + ch - 48;
ch = getchar();
}
return s * w;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
if (!(a & 1) && !(b & 1))
return gcd(a >> 1, b >> 1) << 1;
else if (!(b & 1))
return gcd(a, b >> 1);
else if (!(a & 1))
return gcd(a >> 1, b);
else
return gcd(abs(a - b), min(a, b));
}
long long lcm(long long x, long long y) { return x * y / gcd(x, y); }
long long n;
void gao1() {
if (n == 4 || n == 5) {
cout << -1 << endl;
return;
}
cout << 1 << ' ' << 2 << endl;
cout << 1 << ' ' << 3 << endl;
cout << 1 << ' ' << 4 << endl;
for (long long i = 5; i <= n; ++i) cout << 4 << ' ' << i << endl;
}
void gao2() {
for (long long i = 2; i <= n; ++i) cout << 1 << ' ' << i << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n;
if (n == 2) {
cout << -1 << endl;
cout << 1 << ' ' << 2;
return 0;
} else if (n == 3) {
cout << -1 << endl;
cout << 1 << ' ' << 2 << endl;
cout << 2 << ' ' << 3;
return 0;
}
gao1();
gao2();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
const long long INF = 1e18;
const int MOD = 3;
const int N = 1e6;
bool prime[N];
void sieve(int n) {
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * 2; i <= n; i += p) prime[i] = false;
}
}
}
int c;
int dis(int x, int y) { return min(abs(x - y), c - abs(x - y)); }
int main() {
string s;
cin >> s;
long long n = s.size(), i, r = 0, b = 0, y = 0, g = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'R') {
int j = i;
while (j - 4 >= 0) {
j -= 4;
if (s[j] == '!') {
s[j] = 'R';
r++;
}
}
j = i;
while (j + 4 < n) {
j += 4;
if (s[j] == '!') {
s[j] = 'R';
r++;
}
}
} else if (s[i] == 'G') {
int j = i;
while (j - 4 >= 0) {
j -= 4;
if (s[j] == '!') {
s[j] = 'G';
g++;
}
}
j = i;
while (j + 4 < n) {
j += 4;
if (s[j] == '!') {
s[j] = 'G';
g++;
}
}
} else if (s[i] == 'B') {
int j = i;
while (j - 4 >= 0) {
j -= 4;
if (s[j] == '!') {
s[j] = 'B';
b++;
}
}
j = i;
while (j + 4 < n) {
j += 4;
if (s[j] == '!') {
s[j] = 'B';
b++;
}
}
} else if (s[i] == 'Y') {
int j = i;
while (j - 4 >= 0) {
j -= 4;
if (s[j] == '!') {
s[j] = 'Y';
y++;
}
}
j = i;
while (j + 4 < n) {
j += 4;
if (s[j] == '!') {
s[j] = 'Y';
y++;
}
}
}
}
cout << r << " " << b << " " << y << " " << g;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
stack<char> st;
int main() {
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) {
char ch = s[i];
if (!st.empty() && st.top() == ch)
st.pop();
else
st.push(ch);
}
if (st.empty())
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int c = a * b;
int n = c / 2;
cout << n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 361;
int piece[N];
int n;
int main() {
int ans = 0, st = 0, acm = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> piece[i];
for (int i = 0; i < 2 * n; i++) {
acm += piece[i % n];
while (acm > 180) acm -= piece[st], st = (st + 1) % n;
ans = max(ans, acm);
}
cout << 2 * (180 - ans) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int M = 998244353;
long long int inf = 1e18;
long long getpow(long long base, long long pow) {
long long res = 1;
base = base % M;
while (pow > 0) {
if (pow % 2 != 0) res = res * base;
res = res % M;
base = base * base;
base = base % M;
pow /= 2;
}
return res;
}
void swp(long long int *x, long long int *y) {
long long int t = *x;
*x = *y;
*y = t;
}
void swpc(char *c1, char *c2) {
char c = *c1;
*c1 = *c2;
*c2 = c;
}
void init(vector<long long int> &v, long long int n) {
for (long long int i = 0; i < n; i++) {
cin >> v[i];
}
}
void print(vector<long long int> &v) {
for (long long int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n";
}
void printc(vector<char> &v) {
for (long long i = 0; i < v.size(); i++) {
cout << v[i];
}
cout << "\n";
}
void initg(vector<vector<long long int> > &v, long long int m) {
long long int i, x, y;
for (i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t1, n, k, i, ans;
string s, s1, s2;
t1 = 1;
while (t1--) {
cin >> n >> k >> s;
unordered_set<string> st;
st.insert(s);
ans = 0;
queue<string> q;
q.push(s);
while (k > 0 && !q.empty()) {
s1 = q.front();
q.pop();
k--;
ans += n - s1.length();
for (i = 0; i < s1.length(); i++) {
s2 = s1.substr(0, i) + s1.substr(i + 1);
if (st.find(s2) == st.end()) {
q.push(s2);
st.insert(s2);
}
}
}
if (k > 0)
cout << -1 << "\n";
else
cout << ans << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<string, string> m;
string eval(string& s) {
int c = 0;
for (c = 0; c < s.size(); c++)
if (s[c] != '&') break;
int i;
for (i = c; i < s.size(); i++)
if (s[i] == '*') break;
string str = s.substr(c, i - c);
int rem = s.size() - i;
if (str == "void") {
rem = rem - c;
if (rem < 0) return "errtype";
return "void" + string(rem, '*');
}
if (m.find(str) == m.end()) return "errtype";
str = m[str];
if (str == "errtype") return "errtype";
for (i = str.size() - 1; i > -1; i--)
if (str[i] == '*') rem++;
rem = rem - c;
if (rem < 0) return "errtype";
return "void" + string(rem, '*');
}
int main() {
int n;
string op, A, B;
while (cin >> n) {
m.clear();
while (n--) {
cin >> op;
if (op == "typeof") {
cin >> A;
cout << eval(A) << endl;
} else {
cin >> A >> B;
m[B] = eval(A);
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
namespace Temps {
namespace Compare {
constexpr double eps = 1e-8;
inline void testZero(double& a) {
if (std::abs(a) <= eps) {
a = 0;
}
}
inline bool equal(double a, double b) { return std::abs(b - a) <= eps; }
inline bool notEqual(double a, double b) { return std::abs(b - a) > eps; }
inline bool less(double a, double b) { return a + eps < b; }
inline bool less_equal(double a, double b) { return a <= b + eps; }
inline bool greater(double a, double b) { return a > b + eps; }
inline bool greater_equal(double a, double b) { return a + eps >= b; }
inline bool in_interval(double u, double l, double r) {
if (l > r) {
std::swap(l, r);
}
return greater_equal(u, l) && less_equal(u, r);
}
inline bool in_interval_open(double u, double l, double r) {
if (l > r) {
std::swap(l, r);
}
return greater(u, l) && less(u, r);
}
}; // namespace Compare
struct Point;
struct Circle;
struct Vector;
struct Line;
struct Segment;
struct Point {
double x, y;
explicit constexpr Point(double x = 0, double y = 0) : x(x), y(y) {}
inline double distance(const Point& B) const {
return std::sqrt((x - B.x) * (x - B.x) + (y - B.y) * (y - B.y));
}
inline bool operator==(const Point& B) const {
return Compare::equal(x, B.x) && Compare::equal(y, B.y);
}
inline bool isnop() const { return x == INFINITY && y == INFINITY; }
inline Point add(const Vector& b) const;
inline Point mid(const Point& b) const {
return Point((x + b.x) / 2, (y + b.y) / 2);
}
inline bool operator<(const Point& b) const {
return x == b.x ? y < b.y : x < b.x;
}
inline double getAngle() const { return atan2(y, x); }
inline friend std::ostream& operator<<(std::ostream& os, const Point& b) {
os << "(" << b.x << "," << b.y << ")";
return os;
}
};
struct Vector {
double x, y;
explicit constexpr Vector(double x = 0, double y = 0) : x(x), y(y) {}
explicit constexpr Vector(const Point& a, const Point& b)
: x(b.x - a.x), y(b.y - a.y) {}
explicit constexpr Vector(const Point& a) : x(a.x), y(a.y) {}
explicit constexpr Vector(const Segment& a);
inline double cross(const Vector& B) const { return x * B.y - y * B.x; }
inline Vector mul(double p) const { return Vector(x * p, y * p); }
inline double mul(const Vector& b) const { return x * b.x + y * b.y; }
inline double getk() const { return y / x; }
inline double length() const { return std::sqrt(x * x + y * y); }
inline Vector rotater() const { return Vector(y, -x); }
inline Vector rotatel() const { return Vector(-y, x); }
inline Vector zoom(double newLen = 1) const {
double factor = newLen / length();
return Vector(x * factor, y * factor);
}
inline double degree(const Vector& b) const {
return std::acos(mul(b) / (length() * b.length()));
}
};
inline Point Point::add(const Vector& b) const {
return Point(x + b.x, y + b.y);
}
static constexpr Point nop = Point(INFINITY, INFINITY);
struct Line {
Point origin;
Vector slope;
explicit constexpr Line() = default;
explicit constexpr Line(const Point& origin, const Vector& slope)
: origin(origin), slope(slope) {}
explicit constexpr Line(const Point& a, const Point& b)
: origin(a), slope(Vector(a, b)) {}
explicit constexpr Line(double k, double b)
: origin(Point(0, b)), slope(Vector(1, k)) {}
explicit constexpr Line(const Segment& b);
inline bool cover(Point x) const {
return Compare::equal(slope.cross(Vector(origin, x)), 0);
}
inline Point cross(const Line& b) const {
double _x = Vector(origin, b.origin).cross(b.slope);
double _y = slope.cross(b.slope);
if (Compare::equal(_y, 0)) {
return nop;
}
_x /= _y;
return origin.add(slope.mul(_x));
}
inline double getk() const { return slope.getk(); }
inline double getb() const { return origin.y + (-origin.x) * getk(); }
inline double distance(const Point& b) const {
return cross(Line(b, slope.rotater())).distance(b);
}
inline double shadowLength(const Point& b) const {
Point shadow = cross(Line(b, slope.rotater()));
if (Compare::equal(slope.x, 0)) {
return (shadow.y - origin.y) / slope.y;
}
return (shadow.x - origin.x) / slope.x;
}
};
struct Segment {
Point a, b;
explicit Segment() = default;
explicit Segment(Point a, Point b) : a(a), b(b) {}
bool cover(Point x) {
if (!Compare::in_interval(x.x, a.x, b.x) ||
!Compare::in_interval(x.y, a.y, b.y)) {
return false;
}
return Line(a, b).cover(x);
}
inline Line getPlumb() const {
return Line(a.mid(b), Vector(a, b).rotater());
}
inline Point mid() const { return a.mid(b); }
inline double length() const { return Vector(a, b).length(); }
inline bool isCross(const Segment& t) const {
Point c = Line(*this).cross(Line(t));
if (c.isnop()) {
return false;
}
return Compare::in_interval(c.x, a.x, b.x) &&
Compare::in_interval(c.y, a.y, b.y) &&
Compare::in_interval(c.x, t.a.x, t.b.x) &&
Compare::in_interval(c.y, t.a.y, t.b.y);
}
inline bool isCross_open(const Segment& t) const {
Point c = Line(*this).cross(Line(t));
if (c.isnop()) {
return false;
}
return Compare::in_interval_open(c.x, a.x, b.x) &&
Compare::in_interval_open(c.y, a.y, b.y) &&
Compare::in_interval_open(c.x, t.a.x, t.b.x) &&
Compare::in_interval_open(c.y, t.a.y, t.b.y);
}
};
constexpr Line::Line(const Segment& b) : origin(b.a), slope(Vector(b.a, b.b)) {}
constexpr Vector::Vector(const Segment& a)
: x(a.b.x - a.a.x), y(a.b.y - a.a.y) {}
std::vector<Point> getConvex(std::vector<Point> ps) {
if (ps.size() <= 2) {
return ps;
}
std::sort(ps.begin(), ps.end(), [](Point a, Point b) {
return a.x == b.x ? a.y < b.y : a.x < b.x;
});
ps.erase(std::unique(ps.begin(), ps.end()), ps.end());
std::vector<Point> res;
for (Point p : ps) {
while (res.size() >= 2) {
Point &a = res[res.size() - 2], &b = res.back();
if (Compare::less_equal(Vector(b, p).cross(Vector(b, a)), 0)) {
break;
}
res.pop_back();
}
res.push_back(p);
}
res.pop_back();
std::size_t osize = res.size();
std::reverse(ps.begin(), ps.end());
for (Point p : ps) {
while (res.size() - osize >= 2) {
Point &a = res[res.size() - 2], &b = res.back();
if (Compare::less_equal(Vector(b, p).cross(Vector(b, a)), 0)) {
break;
}
res.pop_back();
}
res.push_back(p);
}
res.pop_back();
return res;
}
double getPerimeter(std::vector<Point> ps) {
std::size_t sz = ps.size();
double ans = 0;
for (std::size_t i = 0; i < sz; ++i) {
ans += ps[i].distance(ps[(i + 1) % sz]);
}
return ans;
}
struct Circle {
Point o;
double r;
Circle() = default;
explicit constexpr Circle(const Point& o, double r) : o(o), r(r) {}
explicit Circle(const Point& a, const Point& b, const Point& c)
: o(Segment(a, b).getPlumb().cross(Segment(b, c).getPlumb())),
r(o.distance(a)) {}
inline bool cover(const Point& p) const {
return Compare::less_equal(o.distance(p), r);
}
inline double perimeter() const { return 2 * 3.14159265358979323846 * r; }
};
} // namespace Temps
using namespace Temps;
class Scanner {
private:
static const int BUFFER_SIZE = 10000;
char buff[BUFFER_SIZE];
int buffPos, buffLim;
public:
Scanner() {
buffLim = fread(buff, 1, BUFFER_SIZE, stdin);
buffPos = 0;
}
private:
inline void flushBuff() {
buffLim = fread(buff, 1, BUFFER_SIZE, stdin);
if (buffLim == 0) {
buff[buffLim++] = '\n';
}
buffPos = 0;
}
inline bool isWS(char t) { return t <= ' '; }
inline bool isDig(char t) { return t >= '0' && t <= '9'; }
void nextPos() {
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
public:
inline char getchar() {
char ch = buff[buffPos];
nextPos();
return ch;
}
inline void next(char* s) {
while (isWS(buff[buffPos])) {
nextPos();
}
while (!isWS(buff[buffPos])) {
*s = buff[buffPos];
s++;
nextPos();
}
*s = '\0';
}
inline void nextLine(char* s) {
while (buff[buffPos] != '\n') {
nextPos();
}
if (buff[buffPos] == '\n') {
nextPos();
}
while (buff[buffPos] != '\n') {
*s = buff[buffPos];
s++;
buffPos++;
}
*s = '\0';
}
inline int nextInt() {
while (!isDig(buff[buffPos]) && buff[buffPos] != '-') {
nextPos();
}
int sign = (buff[buffPos] == '-') ? nextPos(), -1 : 1;
int res = 0;
while (isDig(buff[buffPos])) {
res = res * 10 + buff[buffPos] - '0';
nextPos();
}
return res * sign;
}
inline long long nextLong() {
while (!isDig(buff[buffPos]) && buff[buffPos] != '-') {
nextPos();
}
long long sign = (buff[buffPos] == '-') ? nextPos(), -1 : 1;
long long res = 0;
while (isDig(buff[buffPos])) {
res = res * 10 + buff[buffPos] - '0';
nextPos();
}
return res * sign;
}
inline int n() {
while (buff[buffPos] < '0' || buff[buffPos] > '9') {
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
int res = 0;
while (buff[buffPos] >= '0' && buff[buffPos] <= '9') {
res = res * 10 + (buff[buffPos] - '0');
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
return res;
}
inline long long nl() {
while (buff[buffPos] < '0' || buff[buffPos] > '9') {
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
long long res = 0;
while (buff[buffPos] >= '0' && buff[buffPos] <= '9') {
res = res * 10 + (buff[buffPos] - '0');
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
return res;
}
inline long long nlm(const int MOD) {
while (buff[buffPos] < '0' || buff[buffPos] > '9') {
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
long long res = 0;
while (buff[buffPos] >= '0' && buff[buffPos] <= '9') {
res = (res * 10 + (buff[buffPos] - '0')) % MOD;
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
return res;
}
inline double nextDouble() {
while (isWS(buff[buffPos])) {
nextPos();
}
int sign = (buff[buffPos] == '-') ? nextPos(), -1 : 1;
double res = 0;
while (isDig(buff[buffPos])) {
res = res * 10 + buff[buffPos] - '0';
nextPos();
}
if (buff[buffPos] == '.') {
nextPos();
double ep = 1;
while (isDig(buff[buffPos])) {
ep *= 0.1;
res += ep * (buff[buffPos] - '0');
nextPos();
}
}
return sign * res;
}
inline char nextChar() {
while (isWS(buff[buffPos])) nextPos();
char res = buff[buffPos];
nextPos();
return res;
}
};
Scanner sc;
template <class _Type>
void logArray(_Type a[], int n) {}
template <class T>
inline bool checkMin(T& a, T b) {
return (a > b ? a = b, 1 : 0);
}
template <class T>
inline bool checkMax(T& a, T b) {
return (a < b ? a = b, 1 : 0);
}
void preInit();
void init();
void solve();
int32_t main() {
preInit();
int T;
T = sc.nextInt();
while (T--) {
init();
solve();
}
return 0;
}
Point nextPoint() {
int x = sc.n(), y = sc.n();
return Point(x, y);
}
bool valid(Point a, Point b, Point c, Point d) {
Vector A = Vector(a, b);
Vector B = Vector(b, c);
Vector C = Vector(c, d);
Vector D = Vector(d, a);
double crossA = A.cross(B);
double crossB = B.cross(C);
double crossC = C.cross(D);
double crossD = D.cross(A);
if (Compare::equal(crossA, 0) || Compare::equal(crossB, 0) ||
Compare::equal(crossC, 0) || Compare::equal(crossD, 0)) {
return false;
}
bool signA = crossA > 0;
bool signB = crossB > 0;
bool signC = crossC > 0;
bool signD = crossD > 0;
return signA == signB && signB == signC && signC == signD;
}
bool attempt(Point m, Point a, Point b) {
Point b2 = m.add(Vector(b, m));
Point B = Circle(a, m, b2).o;
Point A = a.add(Vector(B, a));
Point C = m.add(Vector(B, m));
Point D = b.add(Vector(b2, B));
if (valid(A, B, C, D)) {
puts("YES");
printf("%.9lf %.9lf %.9lf %.9lf %.9lf %.9lf %.9lf %.9lf\n", A.x, A.y, B.x,
B.y, C.x, C.y, D.x, D.y);
return true;
}
return false;
}
void preInit() {}
void init() {}
void solve() {
Point A = nextPoint(), B = nextPoint(), C = nextPoint();
if (Compare::equal(Vector(A, B).cross(Vector(A, C)), 0)) {
puts("NO\n");
return;
}
if (attempt(A, B, C)) {
return;
}
if (attempt(B, C, A)) {
return;
}
if (attempt(C, A, B)) {
return;
}
puts("NO\n");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long sum[100004][35];
long long mi[100004][35];
long long pos[100004][35];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, x, t, m, y, z, k;
cin >> n >> k;
vector<long long> dest;
for (int i = 0; i < n; i++) {
cin >> pos[i][0];
}
for (int i = 0; i < n; i++) {
cin >> sum[i][0];
mi[i][0] = sum[i][0];
}
for (int j = 1; j < 35; j++) {
for (int i = 0; i < n; i++) {
sum[i][j] = sum[i][j - 1] + sum[pos[i][j - 1]][j - 1];
mi[i][j] = min(mi[i][j - 1], mi[pos[i][j - 1]][j - 1]);
pos[i][j] = pos[pos[i][j - 1]][j - 1];
}
}
for (int i = 0; i < n; i++) {
long long curr = i;
long long sumz = 0;
long long minz = (1ll << 60) - 1;
for (int j = 0; j < 35; j++) {
if ((k >> j) & 1) {
minz = min(minz, mi[curr][j]);
sumz += sum[curr][j];
curr = pos[curr][j];
}
}
cout << sumz << " " << minz << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
long long a, b;
cin >> a >> b;
long long mod = 1000000000 + 7;
long long x;
long long c = (a * (a + 1)) / 2;
c = c % mod;
c = (c * b) % mod;
c = (c + a) % mod;
x = c;
long long sum = 0;
for (int i = 1; i < b; ++i) {
sum += (x * i);
sum = sum % mod;
}
cout << sum;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 65536, B = 256;
int a[N], d[N], par[N];
vector<int> G[N], st;
int jump[N], mem[N][B], go[N][2], val[N], tot;
int newnode() {
++tot;
go[tot][0] = go[tot][1] = val[tot] = 0;
return tot;
}
void insert(int x, int v) {
int p = 1;
for (int i = (N / B) / 2; i >= 1; i >>= 1) {
int t = !!(x & i);
if (!go[p][t]) go[p][t] = newnode();
p = go[p][t];
}
val[p] = max(val[p], v);
}
void dfs(int x, int p = 0) {
st.push_back(x);
d[x] = d[p] + 1;
if ((int)st.size() >= B) {
tot = 0;
newnode();
for (int i = 0; i < B; ++i) {
int v = a[st[(int)st.size() - i - 1]] ^ i;
insert(v / B, v);
}
for (int y = 0; y < N / B; ++y) {
int p = 1;
for (int i = (N / B) / 2; i >= 1; i >>= 1) {
int t = !!(y & i);
if (go[p][t ^ 1]) {
p = go[p][t ^ 1];
} else {
p = go[p][t];
}
}
mem[x][y] = val[p] ^ (y * B);
}
jump[x] = st[(int)st.size() - B];
}
par[x] = p;
for (int u : G[x]) {
if (u == p) continue;
dfs(u, x);
}
st.pop_back();
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 2; i <= n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1);
for (int i = 0; i < q; ++i) {
int u, v;
scanf("%d%d", &u, &v);
int ans = a[v], dis = 0;
while (jump[v] && d[jump[v]] >= d[u]) {
ans = max(ans, mem[v][dis / B]);
v = par[jump[v]];
dis += B;
}
while (d[v] >= d[u]) {
ans = max(ans, a[v] ^ (dis++));
v = par[v];
}
printf("%d\n", ans);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, b, c;
cin >> n;
if (n == 1) {
cout << "-1";
return 0;
}
if (n % 2 == 1) {
b = n / 2;
b++;
cout << b * -1;
} else {
b = n / 2;
cout << b;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) {
if (a == 0 || b == 0) return a + b;
return a * (b / gcd(a, b));
}
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
int n, m;
int x1[50], y22[50], x2[50], y2[50];
bool chk[111][111];
struct Edge {
int to, r;
Edge* ori;
Edge* rev;
Edge(int T, int R) { to = T, r = R; }
};
vector<Edge*> v[203];
void addedge(int f, int t, int r) {
Edge* ori = new Edge(t, r);
Edge* rev = new Edge(f, 0);
ori->rev = rev;
rev->rev = ori;
v[f].push_back(ori);
v[t].push_back(rev);
}
const int S = 201, T = 202;
int level[203], work[203];
bool bfs() {
memset((level), -1, sizeof(level));
;
level[S] = 0;
queue<int> q;
q.push(S);
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto& nn : v[x]) {
int next = nn->to;
if (level[next] == -1 && nn->r > 0) {
level[next] = level[x] + 1;
q.push(next);
}
}
}
return level[T] != -1;
}
int dfs(int N, int des, int flow) {
if (N == des) return flow;
for (int& i = work[N]; i < v[N].size(); i++) {
int next = v[N][i]->to;
if (level[next] == level[N] + 1 && v[N][i]->r > 0) {
int df = dfs(next, des, min(v[N][i]->r, flow));
if (df > 0) {
v[N][i]->r -= df;
v[N][i]->rev->r += df;
return df;
}
}
}
return 0;
}
int main() {
vector<int> xx, yy;
scanf("%d%d", &n, &m);
for (int(i) = (0); (i) <= (m - 1); (i) += (1)) {
scanf("%d%d%d%d", x1 + i, y22 + i, x2 + i, y2 + i);
x2[i]++, y2[i]++;
xx.push_back(x1[i]);
xx.push_back(x2[i]);
yy.push_back(y22[i]);
yy.push_back(y2[i]);
}
sort(xx.begin(), xx.end());
xx.resize(unique(xx.begin(), xx.end()) - xx.begin());
sort(yy.begin(), yy.end());
yy.resize(unique(yy.begin(), yy.end()) - yy.begin());
int nx = xx.size(), ny = yy.size();
for (int(i) = (0); (i) <= (m - 1); (i) += (1)) {
x1[i] = lower_bound(xx.begin(), xx.end(), x1[i]) - xx.begin();
x2[i] = lower_bound(xx.begin(), xx.end(), x2[i]) - xx.begin();
y22[i] = lower_bound(yy.begin(), yy.end(), y22[i]) - yy.begin();
y2[i] = lower_bound(yy.begin(), yy.end(), y2[i]) - yy.begin();
for (int(ii) = (x1[i]); (ii) <= (x2[i] - 1); (ii) += (1))
for (int(jj) = (y22[i]); (jj) <= (y2[i] - 1); (jj) += (1))
chk[ii][jj] = 1;
}
for (int(i) = (0); (i) <= (nx - 2); (i) += (1))
addedge(S, i, xx[i + 1] - xx[i]);
for (int(i) = (0); (i) <= (ny - 2); (i) += (1))
addedge(i + nx, T, yy[i + 1] - yy[i]);
for (int(i) = (0); (i) <= (nx - 2); (i) += (1))
for (int(j) = (0); (j) <= (ny - 2); (j) += (1)) {
if (chk[i][j]) addedge(i, j + nx, 1987654321);
}
int ans = 0;
while (bfs()) {
memset((work), 0, sizeof(work));
;
while (1) {
int f = dfs(S, T, 1987654321);
if (f == 0) break;
ans += f;
}
}
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, d, h;
cin >> n >> d >> h;
if (d > 2 * h) {
cout << -1;
return 0;
}
if (d == 1 && h == 1 && n > 2) {
cout << -1;
return 0;
}
int h1 = 0;
int d1 = d - h;
int k = 1;
bool temp = true;
for (int i = 1; i <= n - 1; i++) {
if (h1 < h) {
cout << i << " " << i + 1 << endl;
h1++;
} else {
if (d1 > 1 && k < d1) {
if (temp) {
cout << 1 << " " << i + 1 << endl;
temp = false;
k = 1;
} else {
if (k < d1) {
cout << i << " " << i + 1 << endl;
k++;
}
}
} else {
if (d1 == 0)
cout << 2 << " " << i + 1 << endl;
else
cout << 1 << " " << i + 1 << endl;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
long long n, m, z, zz, i, tt, ans, qq, q1, q2;
long long a[400010], sum[400010], dsum[400010];
int main() {
scanf("%I64d", &n);
for (i = 1; i <= n; i++) scanf("%I64d", &a[i]);
m = (n + 1) / 2;
for (i = 1; i <= m; i++)
if (a[i] != a[n - i + 1]) break;
i--;
z = i;
for (i = m; i >= 1; i--)
if (a[i] != a[n - i + 1]) break;
i++;
zz = i;
for (i = zz; i <= n - zz + 1; i++) qq++;
if (z == (n + 1) / 2) {
printf("%I64d", (n + 1) * n / 2);
return 0;
}
memset(sum, 0, sizeof(sum));
memset(dsum, 0, sizeof(dsum));
tt = 0;
for (i = 1; i <= n; i++) sum[a[i]]++;
for (i = 1; i <= z; i++) sum[a[i]] = sum[a[i]] - 2;
for (i = 1; i <= n; i++)
if (sum[i] % 2 == 1) tt++;
if ((n % 2 == 0) && (tt == 0)) ans = ans + z * z - 1;
if ((n % 2 == 1) && (tt <= 1)) ans = ans + z * z - 1;
for (i = z + 1; i <= m; i++) {
if ((n % 2 == 0) && (tt == 0)) ans = ans + z + 1;
if ((n % 2 == 1) && (tt <= 1)) ans = ans + z + 1;
sum[a[i]]--;
q1 = i;
dsum[a[i]]++;
if (sum[a[i]] < dsum[a[i]]) break;
}
if ((q1 == m) && (n % 2 == 1))
q1 = 1;
else
q1 = 0;
memset(sum, 0, sizeof(sum));
memset(dsum, 0, sizeof(dsum));
tt = 0;
for (i = 1; i <= n; i++) sum[a[i]]++;
for (i = 1; i <= z; i++) sum[a[i]] = sum[a[i]] - 2;
for (i = 1; i <= n; i++)
if (sum[i] % 2 == 1) tt++;
for (i = n - z; i >= n - m + 1; i--) {
if ((n % 2 == 0) && (tt == 0)) ans = ans + z + 1;
if ((n % 2 == 1) && (tt <= 1)) ans = ans + z + 1;
q2 = i;
sum[a[i]]--;
dsum[a[i]]++;
if (sum[a[i]] < dsum[a[i]]) break;
}
if ((q2 == n - m + 1) && (n % 2 == 1))
q2 = 1;
else
q2 = 0;
memset(sum, 0, sizeof(sum));
memset(dsum, 0, sizeof(dsum));
for (i = z + 1; i <= zz - 1; i++) {
sum[a[i]]++;
dsum[a[n - i + 1]]++;
}
for (i = 1; i <= n; i++)
if (sum[i] != dsum[i]) break;
if (i == n + 1)
ans = ans + (m - zz + 2 - q1) * (z + 1) + (m - zz + 2 - q2) * (z + 1);
printf("%I64d", ans);
}
| 8 |
#include <bits/stdc++.h>
int dx[] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[] = {-1, 0, 1, 1, 1, 0, -1, -1};
using namespace std;
long long power(long long a, long long p, long long M) {
long long r = 1;
a = a % M;
while (p > 0) {
if (p % 2) r = (r * a) % M;
a = (a * a) % M;
p /= 2;
}
return r % M;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long multiply(long long a, long long b, long long m) {
return ((a % m) * (b % m)) % m;
}
void solve() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) scanf("%lld", &a[i]);
;
vector<long long> inc;
vector<long long> dec;
unordered_map<long long, long long> m;
for (long long i = 0; i < n; i++) {
if (m[a[i]] == 2) {
cout << "No";
return;
}
if (m[a[i]] == 1)
dec.push_back(a[i]);
else
inc.push_back(a[i]);
m[a[i]]++;
}
sort(inc.begin(), inc.end());
sort(dec.begin(), dec.end());
reverse(dec.begin(), dec.end());
cout << "Yes\n";
cout << inc.size() << "\n";
for (auto it : inc) cout << it << " ";
cout << "\n";
cout << dec.size() << "\n";
for (auto it : dec) cout << it << " ";
cout << "\n";
}
int main() {
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Inque {
int x, y;
long long w;
Inque(int _x, int _y, long long _w) : x(_x), y(_y), w(_w) {}
bool operator<(const Inque &r) const {
return w == r.w ? (y == r.y ? x < r.x : y < r.y) : w < r.w;
}
};
int row[100000 + 1], col[100000 + 1];
int n, m, r, k;
set<Inque> s;
priority_queue<Inque> Q;
int dy[4] = {0, 1, 0, -1};
int dx[4] = {1, 0, -1, 0};
long long ans;
void input(void) { scanf("%d %d %d %d", &n, &m, &r, &k); }
void process(void) {
int i, j, c;
for (i = 1, j = n, c = 1; i <= j;
i++, j--, c = min(c + 1, min(r, n - r + 1))) {
col[i] = col[j] = c;
}
for (i = 1, j = m, c = 1; i <= j;
i++, j--, c = min(c + 1, min(r, m - r + 1))) {
row[i] = row[j] = c;
}
Inque t = Inque((n + 1) / 2, (m + 1) / 2,
(long long)row[(m + 1) / 2] * col[(n + 1) / 2]);
Q.push(t);
s.insert(t);
while (!Q.empty() && k) {
t = Q.top();
Q.pop();
ans += t.w;
for (i = 0; i < 4; i++) {
int ty = t.y + dy[i];
int tx = t.x + dx[i];
if (ty > 0 && ty <= m && tx > 0 && tx <= n) {
Inque tt = Inque(tx, ty, (long long)row[ty] * col[tx]);
if (s.find(tt) == s.end()) {
Q.push(tt);
s.insert(tt);
}
}
}
k--;
}
printf("%.10lf\n", (double)ans / (n - r + 1) / (m - r + 1));
}
int main() {
input();
process();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int in[300000];
for (int i = 0; i < n; i++) {
cin >> in[i];
}
int l = 0, mi = m / 2, h = m;
while (h - l > 1) {
bool broken = false;
int level = 0;
for (int i = 0; i < n; i++) {
if (in[i] > level) {
if (in[i] + mi - m < level) level = in[i];
} else if (in[i] + mi < level) {
broken = true;
break;
}
}
if (broken) {
l = mi + 1;
} else {
h = mi + 1;
}
mi = (l + h) / 2 - 1;
}
cout << l;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 998244353;
int n, a[maxn], f[maxn][205][2], up_sum[205], down_sum[205];
void add(int &x, int y) {
x += y;
x %= mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
f[0][0][0] = 1;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
if (a[i] != -1) {
for (int pre = 0; pre < a[i]; pre++) {
add(f[i][a[i]][0], f[i - 1][pre][0]);
add(f[i][a[i]][0], f[i - 1][pre][1]);
}
add(f[i][a[i]][1], f[i - 1][a[i]][0]);
add(f[i][a[i]][1], f[i - 1][a[i]][1]);
for (int now = a[i] + 1; now <= 200; now++)
add(f[i][a[i]][1], f[i - 1][now][1]);
} else {
int sum = f[i - 1][0][0];
for (int j = 1; j <= 200; ++j) {
add(f[i][j][0], sum);
add(sum, f[i - 1][j][0]);
add(sum, f[i - 1][j][1]);
}
sum = 0;
for (int j = 200; j >= 1; --j) {
add(sum, f[i - 1][j][1]);
add(f[i][j][1], sum);
add(f[i][j][1], f[i - 1][j][0]);
}
}
}
int ans = 0;
for (int i = 1; i <= 200; i++) add(ans, f[n][i][1]);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("-ffloat-store")
using namespace std;
clock_t time_p = clock();
void aryanc403() {}
const long long int INF = 0xFFFFFFFFFFFFFFFL;
long long int seed;
mt19937 rng(seed = chrono::steady_clock::now().time_since_epoch().count());
inline long long int rnd(long long int l = 0, long long int r = INF) {
return uniform_int_distribution<long long int>(l, r)(rng);
}
class CMP {
public:
bool operator()(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return !(a.first < b.first || (a.first == b.first && a.second <= b.second));
}
};
void add(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt == m.end())
m.insert({x, cnt});
else
jt->second += cnt;
}
void del(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt->second <= cnt)
m.erase(jt);
else
jt->second -= cnt;
}
bool cmp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return a.first < b.first || (a.first == b.first && a.second < b.second);
}
const long long int mod = 998244353LL;
long long int T, n, i, j, k, in, cnt, l, r, u, v, x, y;
long long int m;
string s;
vector<long long int> a;
const int N = 2e5 + 5;
long long int fac[N + 5], inv[N + 5];
long long int po(long long int a, long long int n) {
if (n < 0) {
a = po(a, mod - 2);
n *= -1;
}
if (n == 0) return 1;
if (n % 2) return (a * po(a, n - 1)) % mod;
return po(a * a % mod, n / 2);
}
long long int nCr(long long int n, long long int r) {
if (n < 0 || r < 0 || r > n) return 0;
long long int ans = 1;
ans = (ans * fac[n]) % mod;
ans = (ans * inv[r]) % mod;
ans = (ans * inv[n - r]) % mod;
return ans;
}
void pre(long long int n) {
long long int i;
fac[0] = 1;
for (i = (1); i <= (n); ++i) fac[i] = (i * fac[i - 1]) % mod;
inv[n] = po(fac[n], mod - 2);
for (i = (n); i >= (1); --i) inv[i - 1] = (i * inv[i]) % mod;
assert(inv[0] == 1);
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{
cin >> n >> k;
a.clear();
a.reserve(n + 2);
a.push_back(0);
for (i = 0; i < (n); ++i) {
cin >> in;
a.push_back(in);
}
a.push_back(a[1]);
a[0] = a[n];
for (i = (1); i <= (n); ++i) cnt += (a[i] != a[i - 1]);
pre(cnt);
long long int ans = 0;
for (i = (0); i <= (cnt); ++i) {
long long int v = 1;
v = (v * nCr(cnt, i)) % mod;
v = (v * nCr(cnt - i, i)) % mod;
v = (v * po(k - 2, cnt - 2 * i)) % mod;
ans -= v;
;
}
ans %= mod;
ans *= po(k, n - cnt);
ans %= mod;
ans += po(k, n);
ans %= mod;
ans *= (mod + 1) / 2;
ans %= mod;
ans += mod;
ans %= mod;
cout << ans << "\n";
}
aryanc403();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (n > 4 && m == 3) {
printf("-1\n");
return 0;
}
for (int i = 0; i < m; i++) {
printf("%d %d\n", i, i * i);
}
for (int i = 0; i < n - m; i++) {
printf("%d %d\n", i, -i * i - 100000);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int T, n, L[2000 + 5], R[2000 + 5], x, y;
long long dp[2000 + 5][2000 + 5], F[2000 + 5][2000 + 5], Q1[2000 + 5][2000 + 5],
Q2[2000 + 5][2000 + 5];
char A[2000 + 5], B[2000 + 5];
inline long long calc1(int x, int y, int l, int r) {
!x && (x++);
!l && (l++);
return Q1[y][r] - Q1[y][l - 1] - Q1[x - 1][r] + Q1[x - 1][l - 1];
}
inline long long calc2(int x, int y, int l, int r) {
!x && (x++);
!l && (l++);
return Q2[y][r] - Q2[y][l - 1] - Q2[x - 1][r] + Q2[x - 1][l - 1];
}
inline void Solve() {
register int i, j;
scanf("%d%s%s", &n, A + 1, B + 1);
for (i = 0; i <= n + 1; i++)
for (j = 0; j <= n + 1; j++) dp[i][j] = F[i][j] = Q1[i][j] = Q2[i][j] = 0;
A[0] = B[0] = A[n + 1] = B[n + 1] = 0;
for (i = 1; i <= n; i += 2)
A[i] ^ '?' && (A[i] ^= 1), B[i] ^ '?' && (B[i] ^= 1);
for (i = 1; i <= n + 1; i++)
L[i] = (A[i] ^ '1' ? L[i - 1] : i), R[i] = (B[i] ^ '1' ? R[i - 1] : i);
F[0][0] = 1;
for (i = 1; i <= n + 1; i++) {
for (j = 1; j <= n + 1; j++) {
Q1[i][j] = Q1[i - 1][j] + Q1[i][j - 1] - Q1[i - 1][j - 1];
Q2[i][j] = Q2[i - 1][j] + Q2[i][j - 1] - Q2[i - 1][j - 1];
if (A[i] == '0' || B[j] == '0') continue;
x = L[i - 1];
y = R[j - 1];
F[i][j] = (calc1(x, i - 1, y, j - 1) + F[x][y]) % 1000000007;
dp[i][j] = (F[i][j] * ((i - j) > 0 ? (i - j) : -(i - j)) +
calc2(x, i - 1, y, j - 1) + dp[x][y]) %
1000000007;
if (A[i] == '?' || B[j] == '?') Q1[i][j] += F[i][j], Q2[i][j] += dp[i][j];
}
}
printf("%lld\n", dp[n + 1][n + 1]);
}
int main() {
scanf("%d", &T);
while (T--) Solve();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool greatter(pair<int, int> a, pair<int, int> b) { return a.first > b.first; }
int main() {
int n, s;
cin >> n >> s;
vector<pair<int, int>> vp;
for (int i = 0; i < n; ++i) {
int fl, t;
cin >> fl >> t;
vp.push_back(make_pair(fl, t));
}
sort(vp.begin(), vp.end(), greatter);
int curr = 0, currpos = s, time = 0;
for (int j = 0; j < vp.size(); ++j) {
time = currpos - vp[j].first;
currpos = vp[j].first;
curr += time;
int x = vp[j].second - curr;
if (x < 0) x = 0;
curr += x;
}
curr += currpos;
cout << curr << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long px1[133000], px2[133000], py1[133000], py2[133000], sx1[133000],
sx2[133000], sy1[133000], sy2[133000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long a[n + 1], b[n + 1], c[n + 1], d[n + 1];
for (unsigned long long i = 1; i < n + 1; i++)
cin >> a[i] >> b[i] >> c[i] >> d[i];
px1[0] = -9999999999, px2[0] = 9999999999, py1[0] = -9999999999,
py2[0] = 9999999999;
for (unsigned long long i = 1; i < n + 1; i++) {
px1[i] = max(a[i], px1[i - 1]);
px2[i] = min(c[i], px2[i - 1]);
py1[i] = max(b[i], py1[i - 1]);
py2[i] = min(d[i], py2[i - 1]);
}
sx1[n + 1] = -9999999999, sx2[n + 1] = 9999999999, sy1[n + 1] = -9999999999,
sy2[n + 1] = 9999999999;
for (unsigned long long i = n + 1 - 1; i >= 1; i--) {
sx1[i] = max(a[i], sx1[i + 1]);
sx2[i] = min(c[i], sx2[i + 1]);
sy1[i] = max(b[i], sy1[i + 1]);
sy2[i] = min(d[i], sy2[i + 1]);
}
long long ax1, ax2, ay1, ay2;
for (unsigned long long i = 1; i < n + 1; i++) {
ax1 = max(px1[i - 1], sx1[i + 1]);
ax2 = min(px2[i - 1], sx2[i + 1]);
ay1 = max(py1[i - 1], sy1[i + 1]);
ay2 = min(py2[i - 1], sy2[i + 1]);
if (ax1 <= ax2 && ay1 <= ay2) {
cout << ax1 << " " << ay1 << endl;
return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, i, n, j, count;
cin >> m;
int *p = new int[m];
for (i = 0; i < m; i++) {
cin >> p[i];
}
cin >> n;
int *q = new int[n];
for (i = 0; i < n; i++) {
cin >> q[i];
}
sort(p, p + m);
sort(q, q + n);
j = n - 1;
int add = 0;
while (j >= 0) {
count = p[0];
while (count != 0) {
add += q[j];
j--;
if (j < 0) {
break;
}
count--;
}
if (j < 0) {
break;
}
j -= 2;
}
cout << add << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
vector<int> w[100000];
long long v[100000];
pair<long long, long long> go(int x, int p) {
pair<long long, long long> res = make_pair(0, 0);
for (int i = 0; i < ((int)(w[x]).size()); i++)
if (w[x][i] != p) {
pair<long long, long long> tmp = go(w[x][i], x);
res.first = max(res.first, tmp.first);
res.second = max(res.second, tmp.second);
}
if (v[x] + res.first - res.second < 0)
res.first -= v[x] + res.first - res.second;
else
res.second += v[x] + res.first - res.second;
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i + 1 < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
w[a].push_back(b);
w[b].push_back(a);
}
for (int i = 0; i < n; i++) scanf("%I64d", &v[i]);
pair<long long, long long> res = go(0, -1);
cout << res.first + res.second << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
cout << max(n, m) - 1 << " " << min(n, m) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[1000] = {0};
int b = 0, maxi = 0;
int n;
cin >> n;
string s[n];
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (s[i] == s[j]) b++;
maxi = max(maxi, b);
b = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (s[i] == s[j]) b++;
if (b == maxi) {
cout << s[i];
return 0;
} else
b = 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, c = 0, d = 0, l = 0, w = 0, l1 = 0, w1 = 0;
cin >> n;
long long a[n], b[n];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> b[i];
for (long long i = 0; i < n; i++) {
if (a[i] == 0) l++;
if (a[i] == 1) l1++;
if (b[i] == 1) w1++;
if (b[i] == 0) w++;
if (a[i] == 0 && b[i] == 1) c++;
if (b[i] == 0 && a[i] == 1) d++;
}
if (l1 == n && w1 == n) {
cout << "-1" << endl;
return 0;
}
if (l == n) {
cout << "-1" << endl;
return 0;
}
if (w == n) {
cout << "1" << endl;
return 0;
}
if (d == 0)
cout << "-1" << endl;
else {
long long ans = (c / d) + 1;
cout << ans << endl;
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
template <typename Arg1>
//print with endl
void pn(Arg1&& arg1)
{ cout<<arg1<<"\n";}
template <typename Arg1, typename... Args>
void pn(Arg1&& arg1, Args&&... args)
{ cout<<arg1<<"\n"; pn(args...); }
//print with space
template <typename Arg1>
void ps(Arg1&& arg1)
{ cout<<arg1<<" ";}
template <typename Arg1, typename... Args>
void ps(Arg1&& arg1, Args&&... args)
{ cout<<arg1<<" "; ps(args...); }
template <typename Arg1>
void pvs(Arg1&& arg1, ll n)
{ for(ll i=0;i<n;i++)ps(arg1[i]); }
template <typename Arg1>
void pvn(Arg1&& arg1, ll n)
{ for(ll i=0;i<n;i++)pn(arg1[i]); }
ll sum(ll n){
ll v=0;
while(n!=0){
v+=(n%10);
n/=10;
}
return v;
}
ll log(ll n, ll b)
{ ll c=0;
while(n>(b-1))
{ c++; n/=b; } return c; }
#define fast ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define mod 1000000007 //10^9+7
#define st string
#define ull unsigned long long
#define pb push_back
#define mp make_pair
#define vi vector <int>
#define vll vector <long long>
#define f0(i,a) for(i=0;i<a;i++)
#define f1(i,a) for(i=1;i<=n;i++)
#define all(a) a.begin(),a.end()
#define sz(a) a.size()
#define lb lower_bound
#define ub upper_bound
#define pl pair<ll,ll>
#define vpl vector<pl>
#define ff first
#define ss second
#define um unordered_map
#define dsort(v) sort(v); reverse(v);
#define maxall(v) *max_element(all(v))
#define minall(v) *min_element(all(v))
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) a/__gcd(a,b)*b
#define Y "YES"
#define N "NO"
#define endl "\n"
#define debug(x) cout << #x << " : " << x << nl;
const ll MOD = 998244353;
const ll inf = 1e18;
const ll MAX = 2e5 + 1;
ll GCD(ll a,ll b){
if(b==0)
return a;
else
return GCD(b,a%b);
}
ll mulmod(ll x,ll n,ll M)
{
ll result=1;
while(n>0)
{
if(n% 2 ==1)
result=(result * x)%M;
x=(x*x)%M;
n=n/2;
}
return result;
}
/////////////////////////
bool isPowerOfTwo(ll n)
{
if (n == 0)
return 0;
while (n != 1)
{
if (n%2 != 0)
return 0;
n = n/2;
}
return 1;
}
void solve(){
ll i;
ll n;
cin>>n;
vll v(n);
f0(i,n) cin>>v[i];
f0(i,n){
if(v[i]&1)
cout<<v[i]<<" ";
}
f0(i,n){
if(!(v[i]&1))
cout<<v[i]<<" ";
}
cout<<endl;
}
int main(){
fast;
#ifdef Local
freopen("inp.txt", "r", stdin);
// freopen("out.txt", "w", stdin);
#endif
// solve();/*
ll t;
cin>>t;
for(ll tt=1;tt<=t;tt++)
{
// cout<<"Case #"<<tt<<": ";
solve();
}
//*/
}
| 0 |
#include <bits/stdc++.h>
int T, n, m, dd, tou[1000005], col[1000005], colors, low[1000005], dfn[1000005],
stack[1000005], tail, sz;
int num1[1000005], num2[1000005];
struct aa {
int p, next;
} da[1000005 * 2];
bool v[1000005], f[1000005];
void add(int x, int y) {
da[++dd].p = y;
da[dd].next = tou[x];
tou[x] = dd;
}
void dit(int x) {
++colors;
while (stack[tail] != x) {
f[stack[tail]] = 0;
col[stack[tail]] = colors;
--tail;
}
col[stack[tail]] = colors;
f[stack[tail]] = 0;
--tail;
}
void dfs(int x) {
dfn[x] = low[x] = ++sz;
v[x] = f[x] = 1;
stack[++tail] = x;
for (int i = tou[x]; i; i = da[i].next) {
int vi = da[i].p;
if (!v[vi]) {
dfs(vi);
low[x] = std::min(low[x], low[vi]);
} else if (f[vi])
low[x] = std::min(low[x], dfn[vi]);
}
if (low[x] == dfn[x]) dit(x);
}
int main() {
scanf("%d", &T);
while (T--) {
colors = 0;
scanf("%d%d", &n, &m);
tail = 0;
for (int i = 1; i <= n; i++) {
f[i] = v[i] = 0;
col[i] = 0;
tou[i] = 0;
dfn[i] = low[i] = 0;
}
dd = 0;
sz = 0;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) dfs(i);
}
int cnt = 0;
for (int i = 1; i <= n; i++)
if (col[i] == 1) ++cnt;
if (cnt == n)
printf("No\n");
else {
printf("Yes\n");
printf("%d %d\n", cnt, n - cnt);
for (int i = 1; i <= n; i++)
if (col[i] == 1) printf("%d ", i);
printf("\n");
for (int i = 1; i <= n; i++)
if (col[i] != 1) printf("%d ", i);
printf("\n");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string in;
cin >> in;
int f[10] = {0};
for (int i = 0; i < n; i++) {
if (in[i] == 'L') {
for (int j = 0; j < 10; j++) {
if (f[j] == 0) {
f[j] = 1;
break;
}
}
} else if (in[i] == 'R') {
for (int j = 9; j >= 0; j--) {
if (f[j] == 0) {
f[j] = 1;
break;
}
}
} else {
f[in[i] - '0'] = 0;
}
}
for (int i = 0; i < 10; i++) {
cout << f[i];
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int arr[n][m];
string str;
for (int i = 0; i < n; i++) {
cin >> str;
for (int j = 0; j < m; j++) {
arr[i][j] = str.at(j) - '0';
}
}
int pre[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
pre[i][j] = 0;
for (int a = 0; a <= i; a++) {
for (int b = 0; b <= j; b++) {
pre[i][j] += arr[a][b];
}
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int a = 0; a <= i; a++) {
for (int b = 0; b <= j; b++) {
int q1, q2, q3;
if (b == 0)
q1 = 0;
else
q1 = pre[i][b - 1];
if (a == 0)
q2 = 0;
else
q2 = pre[a - 1][j];
if (a == 0 or b == 0)
q3 = 0;
else
q3 = pre[a - 1][b - 1];
if (pre[i][j] - q1 - q2 + q3 == 0) {
ans = max(ans, (i - a + j - b + 2) * 2);
}
}
}
}
}
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100100;
vector<int> g1[nmax];
vector<int> g2[nmax];
int par[nmax][20];
int level[nmax];
int have[nmax];
int f[nmax];
bool iscomplex[nmax];
bool used[nmax];
int p[nmax];
stack<int> st;
int find(int v) {
if (p[v] == v) return v;
return p[v] = find(p[v]);
}
void unite(int v, int u) {
v = find(v);
u = find(u);
if (rand() & 1) {
p[v] = u;
} else {
p[u] = v;
}
}
const int mod = 1000000007;
void dfs1(int v, int prev) {
used[v] = true;
st.push(v);
for (int(i) = 0; (i) < (int((g1[v]).size())); ++(i)) {
int to = g1[v][i];
if (!used[to]) {
dfs1(to, v);
} else if (to != prev && !iscomplex[f[to]]) {
int last;
do {
last = st.top();
st.pop();
f[last] = v;
} while (last != to);
iscomplex[v] = true;
}
}
if (!st.empty() && st.top() == v) st.pop();
}
void dfs2(int v, int prev) {
used[v] = true;
level[v] = level[prev] + 1;
par[v][0] = prev;
for (int(i) = 0; (i) < (19); ++(i)) par[v][i + 1] = par[par[v][i]][i];
have[v] = have[prev] + iscomplex[v];
for (int(i) = 0; (i) < (int((g2[v]).size())); ++(i)) {
int to = g2[v][i];
if (!used[to]) dfs2(to, v);
}
}
int lca(int v, int u) {
if (level[v] < level[u]) swap(v, u);
for (int i = 20; i--;)
if (level[v] - (1 << i) >= level[u]) v = par[v][i];
if (u == v) return v;
for (int i = 20; i--;)
if (par[v][i] != par[u][i]) {
v = par[v][i];
u = par[u][i];
}
return par[v][0];
}
int r[nmax][2];
int binpow(long long x, long long n, int mod) {
long long a = 1;
while (n) {
if (n & 1) a = a * x % mod;
x = x * x % mod;
n >>= 1;
}
return a;
}
int main() {
int n, m, k;
scanf("%d%d", &n, &m);
int x, y;
for (int(i) = 0; (i) < (m); ++(i)) {
scanf("%d%d", &x, &y);
--x, --y;
g1[x].push_back(y);
g1[y].push_back(x);
r[i][0] = x;
r[i][1] = y;
}
for (int(i) = 0; (i) < (n); ++(i)) {
f[i] = i;
p[i] = i;
}
memset((used), 0, sizeof(used));
dfs1(0, -1);
for (int(i) = 0; (i) < (m); ++(i)) {
x = r[i][0];
y = r[i][1];
x = f[x];
y = f[y];
if (find(x) != find(y)) {
unite(x, y);
g2[x].push_back(y);
g2[y].push_back(x);
}
}
memset((used), 0, sizeof(used));
dfs2(f[0], f[0]);
int q, t;
scanf("%d", &q);
for (int(i) = 0; (i) < (q); ++(i)) {
scanf("%d%d", &x, &y);
x = f[x - 1];
y = f[y - 1];
t = lca(x, y);
int ans = have[x] + have[y] - 2 * have[t] + iscomplex[t];
printf("%d\n", binpow(2, ans, mod));
}
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mod (ll)1e9+7;
#define test ll t;cin>>t;while(t--)
#define endl "\n"
#define pb push_back
#define vi vector<int>
#define vvi vector<vi>
#define vl vector<ll>
#define vvl vector<vl>
#define vp vector<pair<int,int>>
#define pf push_front
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define scanint(x) int x;cin>>x;
#define scanll(x) ll x;cin>>x;
#define scanstr(str) string str;cin>>str;
#define scanchr(chr) char chr;cin>>chr;
#define all(c) (c).begin(), (c).end()
#define vecread(vec) for(auto &x:vec){cin>>x;}
#define calcTime cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl
#define debug(a) cout<<a<<endl;
#define debug2(a,b) cout<<a<<" "<<b<<endl;
#define debug3(a,b,c) cout<<a<<" "<<b<<" "<<c<<endl;
#define joker(V) for(auto X:V)cout<<X<<" ";cout<<endl;
#define papiya(Mp) for(auto X:Mp)cout<<X.first<<" "<<X.second<<endl;
void solve(){
scanint(n)
vi arr(n);
vecread(arr);
sort(all(arr));
vvl dp(n, vl(n));
for (size_t g = 0; g < n; g++)
{
for(int i = 0, j = g; j < n; i++, j++){
if(g == 0){
dp[i][j] = 0;
} else if(g == 1){
dp[i][j] = abs(arr[i] - arr[j]);
} else {
dp[i][j] = arr[j] - arr[i] + min(dp[i + 1][j], dp[i][j - 1]);
}
}
}
cout << dp[0][n - 1] << endl;
}
int main()
{
fast
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif
// test
// {
solve();
// }
calcTime;
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pi = pair<int, int>;
const int mod = 1e9 + 7;
const ll inf = ll(1e18);
const double PI = acos(-1), eps = 1e-9;
const int mxn = 1e5, mxa = 5e3;
int n, k;
set<char> vowels{'a', 'e', 'i', 'o', 'u'};
void solve() {
cin >> n >> k;
set<string> st;
while (n--) {
vector<string> cur;
for (int i = 0; i < 4; ++i) {
string second;
cin >> second;
vi v;
for (int j = 0; j < (int)(second).size(); ++j) {
if (vowels.count(second[j])) v.push_back(j);
}
if ((int)(v).size() >= k) {
int idx = v[(int)(v).size() - k];
cur.push_back(second.substr(idx, (int)(second).size() - idx));
}
}
if ((int)(cur).size() < 4)
st.insert("");
else if (cur[0] == cur[1] && cur[1] == cur[2] && cur[2] == cur[3])
;
else if (cur[0] == cur[1] && cur[2] == cur[3])
st.insert("aabb");
else if (cur[0] == cur[2] && cur[1] == cur[3])
st.insert("abab");
else if (cur[0] == cur[3] && cur[1] == cur[2])
st.insert("abba");
else
st.insert("");
}
if (st.count(""))
cout << "NO\n";
else if (st.empty())
cout << "aaaa\n";
else if ((int)(st).size() != 1)
cout << "NO\n";
else
cout << *(st.begin()) << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool g[10000];
int n;
int a[2010][2010];
int b[10000];
bool check() {
int t, w;
t = 0;
w = 1;
b[1] = 1;
for (int i = 0; i <= n; i++) g[i] = 0;
g[1] = 1;
while (t < w) {
t++;
for (int i = 1; i <= n; i++)
if (!g[i] && a[b[t]][i]) {
g[i] = 1;
b[++w] = i;
}
}
return (w == n);
}
int main() {
int k;
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
if (a[i][j] > 0) a[i][j] = 1;
}
if (!check())
printf("NO\n");
else {
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
k = a[i][j], a[i][j] = a[j][i], a[j][i] = k;
if (check())
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
while (scanf("%d%d%d%d", &a, &b, &c, &d) == 4) {
int L1 = c, R1 = 2 * c, L2 = d, R2 = 2 * d;
if (L1 <= R2 && L2 <= R1 && R2 < 2 * b) {
int t1 = max(L1, L2);
printf("%d %d %d\n", 2 * a, 2 * b, t1);
} else
printf("-1\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 3e5 + 233;
int n, m, A[N];
inline int check(int t) {
for (int i = 1, last = 0; i <= n; ++i) {
if (A[i] + t >= m) {
int left = t - (m - A[i]);
if (left >= last) {
continue;
}
}
if (A[i] >= last) {
last = A[i];
continue;
}
if (A[i] + t >= last) {
continue;
}
return 0;
}
return 1;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", A + i);
int l = 0, r = m, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
std::cout << ans << std::endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y, c;
int main() {
scanf("%I64d%I64d%I64d%I64d", &n, &x, &y, &c);
x--;
y--;
long long k = 1, sec = 0;
;
long long e_up = y, e_down = y, e_left = x, e_right = x;
while (k < c) {
sec++;
k = ((long long)2 * sec + 1) * ((long long)2 * sec + 1) -
(long long)2 * sec - 2 * sec * sec;
e_up--;
e_down++;
e_left--;
e_right++;
if (sec == 6) {
x = x + 1;
x = x - 1;
}
if (e_up < 0) {
long long d = -e_up;
k -= (2 + (d - 1) * 2) / 2 * d;
}
if (e_left < 0) {
long long d = -e_left;
k -= (2 + (d - 1) * 2) / 2 * d;
}
if (e_down >= n) {
long long d = e_down - n + 1;
k -= (2 + (d - 1) * 2) / 2 * d;
}
if (e_right >= n) {
long long d = e_right - n + 1;
k -= (2 + (d - 1) * 2) / 2 * d;
}
if (x + 1 + y + 1 <= sec) {
long long d = sec + 1 - (x + 1 + y + 1);
k += (long long)(1 + d) * d / 2;
}
if (n - x + n - y <= sec) {
long long d = sec + 1 - (n - x + n - y);
k += (long long)(1 + d) * d / 2;
}
if (n - x + 1 + y <= sec) {
long long d = sec + 1 - (n - x + y + 1);
k += (long long)(1 + d) * d / 2;
}
if (x + 1 + n - y <= sec) {
long long d = sec + 1 - (x + 1 + n - y);
k += (long long)(1 + d) * d / 2;
}
}
printf("%I64d", sec);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
string x[400] = {
"YES", "NO", "NO", "YES", "NO", "NO", "NO", "NO", "NO", "YES",
"YES", "YES", "YES", "NO", "NO", "YES", "NO", "YES", "NO", "YES",
"NO", "NO", "YES", "NO", "NO", "YES", "NO", "NO", "YES", "YES",
"NO", "YES", "NO", "YES", "NO", "NO", "YES", "YES", "NO", "NO",
"YES", "NO", "YES", "YES", "NO", "YES", "YES", "YES", "NO", "YES",
"NO", "NO", "YES", "YES", "YES", "YES", "YES", "NO", "NO", "NO",
"YES", "NO", "NO", "NO", "NO", "NO", "NO", "NO", "NO", "NO",
"YES", "NO", "YES", "NO", "NO", "NO", "YES", "YES", "NO", "NO",
"YES", "NO", "NO", "NO", "NO", "NO", "NO", "NO", "NO", "NO",
"YES", "NO", "NO", "NO", "NO", "NO", "NO", "YES", "YES", "YES",
"NO", "YES", "NO", "NO", "NO", "YES", "NO", "YES", "NO", "YES",
"NO", "NO", "NO", "NO", "YES", "YES", "NO", "YES", "NO", "NO",
"NO", "YES", "NO", "YES", "YES", "YES", "NO", "YES", "NO", "NO",
"NO", "YES", "NO", "NO", "NO", "YES", "NO", "NO", "NO", "YES",
"YES", "YES", "YES", "YES", "YES", "YES", "NO", "YES", "NO", "NO",
"NO", "NO", "NO", "NO", "NO", "NO", "YES", "NO", "YES", "NO",
"YES", "NO", "YES", "NO", "NO", "YES", "NO", "NO", "NO", "YES",
"NO", "NO", "NO", "NO", "YES", "NO", "NO", "NO", "NO", "NO",
"NO", "YES", "NO", "NO", "NO", "NO", "NO", "YES", "YES", "NO",
"YES", "NO", "YES", "YES", "YES", "NO", "YES", "YES", "NO", "NO",
"NO", "NO", "YES", "NO", "YES", "YES", "NO", "NO", "YES", "NO",
"NO", "NO", "YES", "YES", "NO", "NO"};
for (int i = 0; i < 216; i++) cout << x[i] << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double qmin = 0x7fffffff;
int main(void) {
long long a, b;
cin >> a >> b;
if (a < b) {
puts("-1");
return 0;
}
{
int x = a + b;
int now = ceil(x / b / 2);
while (x / double(now) / 2.0 < b) now--;
qmin = min(qmin, x / double(now) / 2.0);
}
{
int x = a - b;
int now = ceil(x / b / 2);
while (x / double(now) / 2.0 < b) now--;
qmin = min(qmin, x / double(now) / 2.0);
}
printf("%.12lf\n", qmin);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long n, k, a[N];
long long pre[N], precnt[N];
int b[N], now, num = 1;
long long cnt[N];
long long cal(long long val, int x) {
if (cnt[x] >= k) return 0;
int res = k - cnt[x];
long long q1 = precnt[x - 1] * (val - 1) - pre[x - 1];
long long q2 = pre[now] - pre[x] - (precnt[now] - precnt[x]) * (val + 1);
long long ans1 = 0, ans2 = 0, ans3 = 0;
if (precnt[x - 1] >= res)
ans1 = q1 + res;
else
ans1 = 1e18;
if (precnt[now] - precnt[x] >= res)
ans2 = q2 + res;
else
ans2 = 1e18;
ans3 = q1 + q2 + res;
ans1 = min(ans1, ans2);
ans1 = min(ans1, ans3);
return ans1;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
if (a[i] != a[i + 1]) {
now++;
b[now] = a[i];
cnt[now] = num;
num = 1;
} else
num++;
}
for (int i = 1; i <= now; i++)
pre[i] = pre[i - 1] + b[i] * cnt[i], precnt[i] = precnt[i - 1] + cnt[i];
long long ans = 1e18;
for (int i = 1; i <= now; i++) {
ans = min(ans, cal(b[i], i));
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
string s;
int pSum1[200004];
int pSum2[200004];
int min1, min2, max1, max2;
int fmin, fmax, lmin, lmax;
int width, heigth, pwidth, pheigth;
int i1, i2;
long long ans;
for (int i = 0; i < T; i++) {
s.clear();
cin >> s;
pSum1[0] = 0;
pSum2[0] = 0;
min1 = 0;
min2 = 0;
max1 = 0;
max2 = 0;
i1 = 0, i2 = 0;
for (int j = 0; j < s.length(); j++) {
if (s[j] == 'W') {
pSum1[i1 + 1] = pSum1[i1] + 1;
if (pSum1[i1 + 1] > max1) max1 = pSum1[i1 + 1];
i1++;
}
if (s[j] == 'S') {
pSum1[i1 + 1] = pSum1[i1] - 1;
if (pSum1[i1 + 1] < min1) min1 = pSum1[i1 + 1];
i1++;
}
if (s[j] == 'A') {
pSum2[i2 + 1] = pSum2[i2] - 1;
if (pSum2[i2 + 1] < min2) min2 = pSum2[i2 + 1];
i2++;
}
if (s[j] == 'D') {
pSum2[i2 + 1] = pSum2[i2] + 1;
if (pSum2[i2 + 1] > max2) max2 = pSum2[i2 + 1];
i2++;
}
}
width = max2 - min2 + 1;
heigth = max1 - min1 + 1;
pwidth = width;
pheigth = heigth;
fmin = -1;
fmax = -1;
for (int j = 0; j < i1 + 1; j++) {
if (pSum1[j] == min1) {
lmin = j;
if (fmin == -1) fmin = j;
}
if (pSum1[j] == max1) {
lmax = j;
if (fmax == -1) fmax = j;
}
}
if ((fmin > lmax || fmax > lmin) && heigth > 2) pheigth--;
fmin = -1;
fmax = -1;
for (int j = 0; j < i2 + 1; j++) {
if (pSum2[j] == min2) {
lmin = j;
if (fmin == -1) fmin = j;
}
if (pSum2[j] == max2) {
lmax = j;
if (fmax == -1) fmax = j;
}
}
if ((fmin > lmax || fmax > lmin) && width > 2) pwidth--;
ans = min((long long)heigth * pwidth, (long long)pheigth * width);
cout << ans << '\n';
}
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.