solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
int n;
while (cin >> n) {
cin >> s;
int gold = 0, cnt = 0, prev = 0, ans = 0;
for (auto ch : s) {
if (ch == 'G')
gold++, cnt++;
else
prev = cnt, cnt = 0;
ans = max(ans, prev + cnt + 1);
}
ans = min(ans, gold);
cout << ans << endl;
}
return 0;
}
| 2 |
//AOJ0338.cpp
#include <iostream>
using namespace std;
int gcd(int m,int n){
if(n==0)
return m;
return gcd(n,m%n);
}
int main(){
int W, H, C;
cin >> W >> H >> C;
int g = gcd(W,H);
cout << W/g*H/g*C <<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
map<string, int> mp;
set<string> st;
int c = 1;
int m = 0;
while (n--) {
string s;
cin >> s;
mp[s]++;
m = max(m, mp[s]);
}
cout << m << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int sol[123123];
int on[123123];
int matrix[142][142];
int matrix_2[142][142];
int main() {
int n, m, h;
cin >> n >> m >> h;
for (int i = 1; i <= m; i++) cin >> on[i];
for (int i = 1; i <= n; i++) cin >> sol[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> matrix[i][j];
matrix_2[i][j] = 31231212;
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
if (matrix_2[j][i] > on[i]) matrix_2[j][i] = on[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (matrix_2[i][j] > sol[i]) matrix_2[i][j] = sol[i];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (matrix[i][j])
cout << matrix_2[i][j] << " ";
else
cout << "0 ";
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string repeat(string s, int n) {
string s1 = s;
for (int i = 1; i < n; i++) s += s1;
return s;
}
string getString(char x) {
string s(1, x);
return s;
}
void optimizeIO() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
class Graph {
int V;
list<int> *adj;
void DFSUtil(int v, bool visited[], bool e);
public:
Graph(int V);
void addEdge(int v, int w);
void DFS(int v);
};
Graph::Graph(int V) {
this->V = V;
adj = new list<int>[V];
}
void Graph::addEdge(int v, int w) {
adj[v].push_back(w);
adj[w].push_back(v);
}
vector<int> v1, v2;
void Graph::DFSUtil(int v, bool visited[], bool e) {
if (e) {
v1.push_back(v + 1);
} else {
v2.push_back(v + 1);
}
visited[v] = true;
list<int>::iterator i;
for (i = adj[v].begin(); i != adj[v].end(); ++i)
if (!visited[*i]) DFSUtil(*i, visited, !e);
}
void Graph::DFS(int v) {
bool *visited = new bool[V];
for (int i = 0; i < V; i++) visited[i] = false;
int x = 0, y = 0;
DFSUtil(v, visited, true);
}
int main() {
optimizeIO();
int t, x, y;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
Graph g(n);
for (int i = 0; i < m; i++) {
cin >> x >> y;
g.addEdge(x - 1, y - 1);
}
g.DFS(0);
if (v1.size() <= v2.size()) {
cout << v1.size() << endl;
for (int i = 0; i < v1.size() - 1; i++) {
cout << v1[i] << " ";
}
cout << v1[v1.size() - 1] << endl;
} else {
cout << v2.size() << endl;
for (int i = 0; i < v2.size() - 1; i++) {
cout << v2[i] << " ";
}
cout << v2[v2.size() - 1] << endl;
}
v1.clear();
v2.clear();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
const int MAXN = 2e5 + 10;
vector<int> idx;
string s1, s2;
template <class T>
class string_hash {
public:
const T& s;
vector<long long> hash, power;
long long mod = 1e9 + 9;
string_hash(const T& _s) : s(_s), hash(_s.size() + 1), power(_s.size() + 1) {}
void init(long long p) {
for (int i = 0; i < s.size(); i++) hash[i + 1] = (hash[i] + s[i]) * p % mod;
power[0] = 1;
for (int i = 0; i < s.size(); i++) power[i + 1] = power[i] * p % mod;
}
long long get(int begin, int end) {
long long res;
res = hash[end] - hash[begin] * power[end - begin] % mod;
res = res >= 0 ? res : res + mod;
return res;
}
};
int get_random() {
static mt19937 rng(1223);
static uniform_int_distribution<int> dist(1000000, 10000000);
return dist(rng);
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
string tmp;
cin >> tmp;
for (auto i = (0); i < (n); i++) {
if (tmp[i] == '0') {
idx.push_back(i);
s1.push_back(i % 2 + '0');
s2.push_back(1 - i % 2 + '0');
}
}
int q;
vector<vector<int> > qs;
cin >> q;
for (auto i = (0); i < (q); i++) {
qs.push_back(vector<int>(10));
for (auto j = (0); j < (3); j++) {
cin >> qs.back()[j];
}
qs.back()[0]--;
qs.back()[1]--;
qs.back()[3] =
lower_bound((idx).begin(), (idx).end(), qs.back()[0]) - idx.begin();
qs.back()[4] =
lower_bound((idx).begin(), (idx).end(), qs.back()[0] + qs.back()[2]) -
idx.begin();
qs.back()[5] =
lower_bound((idx).begin(), (idx).end(), qs.back()[1]) - idx.begin();
qs.back()[6] =
lower_bound((idx).begin(), (idx).end(), qs.back()[1] + qs.back()[2]) -
idx.begin();
qs.back()[7] = 1;
}
string_hash<string> sh1(s1), sh2(s2);
for (auto tc = (0); tc < (10); tc++) {
long long rn = get_random();
sh1.init(rn);
sh2.init(rn);
for (auto i = (0); i < (q); i++) {
if (qs[i][7] == 0) continue;
long long v1 = qs[i][0] % 2 ? sh1.get(qs[i][3], qs[i][4])
: sh2.get(qs[i][3], qs[i][4]);
long long v2 = qs[i][1] % 2 ? sh1.get(qs[i][5], qs[i][6])
: sh2.get(qs[i][5], qs[i][6]);
if (v1 != v2) {
qs[i][7] = 0;
}
}
}
for (auto i = (0); i < (q); i++) {
cout << (qs[i][7] ? "YES" : "NO") << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
string ans = {s[0], s[1]};
int mx = 0;
map<string, int> mp;
for (int i = 0; i + 1 < n; ++i) mp[{s[i], s[i + 1]}]++;
for (auto p : mp)
if (p.second > mx) mx = p.second, ans = p.first;
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool cmp_pair_F_2(pair<int, int> x, pair<int, int> y) {
return x.first > y.first;
}
bool cmp_pair_S_2(pair<int, int> x, pair<int, int> y) {
return x.second > y.second;
}
bool cmp_pair_S_1(pair<int, int> x, pair<int, int> y) {
return x.second < y.second;
}
bool cmp(int x, int y) { return x > y; }
const int N = 152, M = (N * (N - 1)) / 2;
int dp[2][N][M];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k, s;
cin >> n >> k >> s;
if ((n * (n - 1) / 2) <= s) {
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
sort((v).begin(), (v).end());
int c = 0;
for (int i = 0; i < k; i++) c += v[i];
cout << c;
} else {
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) dp[0][i][j] = 1e9, dp[1][i][j] = 1e9;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
int now = i & 1;
if (!i)
dp[now][0][0] = x;
else {
dp[now][i][0] = dp[1 - now][i - 1][0] + x;
for (int j = 0; j <= i; j++) {
for (int t = 0; t <= s; t++) {
(dp[now][j][t]) = min((dp[now][j][t]), (dp[1 - now][j][t]));
if (!j)
(dp[now][j][i]) = min((dp[now][j][i]), (x));
else {
if (t >= i - j && dp[1 - now][j - 1][t - (i - j)] != 1e9)
(dp[now][j][t]) =
min((dp[now][j][t]), (dp[1 - now][j - 1][t - (i - j)] + x));
}
}
}
}
}
int c = 1e9;
for (int i = 0; i <= s; i++) (c) = min((c), (dp[(n - 1) & 1][k - 1][i]));
cout << c;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 200000 + 5;
int a[M];
int b[M];
int c[M];
struct TREE {
int l;
int r;
int minv;
int s;
int x;
} tree[4 * M];
void build(int l, int r, int node) {
tree[node].l = l;
tree[node].r = r;
tree[node].x = 0;
if (l == r) {
tree[node].minv = c[l];
tree[node].s = c[l];
return;
} else {
int m = (l + r) / 2;
build(l, m, node * 2);
build(m + 1, r, node * 2 + 1);
tree[node].s = tree[node * 2].s + tree[node * 2 + 1].s;
tree[node].minv = min(tree[node * 2].minv, tree[node * 2 + 1].minv);
}
}
void pushDown(int node) {
if (tree[node].x != 0) {
int x = tree[node].x;
int m = (tree[node].l + tree[node].r) / 2;
int l = tree[node].l;
int r = tree[node].r;
tree[node * 2].x = tree[node * 2].x + x;
tree[node * 2].s = tree[node * 2].s + (m - l + 1) * x;
tree[node * 2].minv = tree[node * 2].minv + x;
tree[node * 2 + 1].x = tree[node * 2 + 1].x + x;
tree[node * 2 + 1].s = tree[node * 2 + 1].s + (r - m) * x;
tree[node * 2 + 1].minv = tree[node * 2 + 1].minv + x;
tree[node].x = 0;
}
}
void update(int l, int r, int node, int val) {
if (l <= tree[node].l && tree[node].r <= r) {
tree[node].x += val;
tree[node].s = tree[node].s + (tree[node].r - tree[node].l + 1) * val;
tree[node].minv = tree[node].minv + val;
} else {
int m = (tree[node].l + tree[node].r) / 2;
pushDown(node);
if (r <= m) {
update(l, r, node * 2, val);
} else {
if (l >= m + 1) {
update(l, r, node * 2 + 1, val);
} else {
update(l, m, node * 2, val);
update(m + 1, r, node * 2 + 1, val);
}
}
tree[node].s = tree[node * 2].s + tree[node * 2 + 1].s;
tree[node].minv = min(tree[node * 2].minv, tree[node * 2 + 1].minv);
}
}
int qs(int l, int r, int node) {
if (l <= tree[node].l && tree[node].r <= r) {
return tree[node].s;
} else {
int m = (tree[node].l + tree[node].r) / 2;
pushDown(node);
if (r <= m) {
return qs(l, r, node * 2);
} else {
if (l >= m + 1) {
return qs(l, r, node * 2 + 1);
} else {
int s1 = qs(l, m, node * 2);
int s2 = qs(m + 1, r, node * 2 + 1);
return s1 + s2;
}
}
}
}
int qminv(int l, int r, int node) {
if (l <= tree[node].l && tree[node].r <= r) {
return tree[node].minv;
} else {
int m = (tree[node].l + tree[node].r) / 2;
pushDown(node);
if (r <= m) {
return qminv(l, r, node * 2);
} else {
if (l >= m + 1) {
return qminv(l, r, node * 2 + 1);
} else {
int min1 = qminv(l, m, node * 2);
int min2 = qminv(m + 1, r, node * 2 + 1);
return min(min1, min2);
}
}
}
}
int main() {
time_t t_start, t_end;
t_start = clock();
int n, m, h;
cin >> n >> m >> h;
for (int i = 1; i <= m; i++) {
cin >> b[i];
}
sort(b + 1, b + m + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= m; i++) {
c[i] = m - i + 1;
}
build(1, m, 1);
for (int i = 1; i <= m; i++) {
int idx = lower_bound(b + 1, b + m + 1, h - a[i]) - b;
if (idx <= m) {
update(1, idx, 1, -1);
} else {
;
}
}
int minv = qminv(1, m, 1);
int s = qs(1, 1, 1);
int ans = 0;
if (minv >= 0 && s == 0) {
ans = 1;
}
for (int i = m + 1; i <= n; i++) {
int idx = lower_bound(b + 1, b + m + 1, h - a[i]) - b;
if (idx <= m) {
update(1, idx, 1, -1);
} else {
;
}
int j = i - m;
int jdx = lower_bound(b + 1, b + m + 1, h - a[j]) - b;
if (jdx <= m) {
update(1, jdx, 1, 1);
}
minv = qminv(1, m, 1);
s = qs(1, 1, 1);
if (minv >= 0 && s == 0) {
ans++;
}
}
cout << ans << endl;
t_end = clock();
return 0;
}
| 5 |
#include <iostream>
#include <complex>
#include <cmath>
using namespace std;
typedef complex<double> P;
// real -> X
// imag -> Y
bool isIntersect(P p1, P p2, P p3, P p4){
return (
((p1.real() - p2.real()) * (p3.imag() - p1.imag()) + (p1.imag() - p2.imag()) * (p1.real() - p3.real())) *
((p1.real() - p2.real()) * (p4.imag() - p1.imag()) + (p1.imag() - p2.imag()) * (p1.real() - p4.real()))
) > 0.0;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
double xa, ya, xb, yb, xc, yc, xd, yd;
// 0 0 1 0 1 1 0 1
char c0;
while(cin >> xa >> c0 >> ya >> c0){
cin >> xb >> c0 >> yb >> c0;
cin >> xc >> c0 >> yc >> c0;
cin >> xd >> c0 >> yd;
P a(xa, ya);
P b(xb, yb);
P c(xc, yc);
P d(xd, yd);
cout << ((isIntersect(a, c, b, d) || isIntersect(b, d, a, c)) ? "NO" : "YES") << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r;
cin >> n >> r;
double s = sin(3.14159265358979323846 / n);
double R = (double)(r * s) / (1 - s);
printf("%.6f\n", R);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int k1, k2, k3;
int main() {
cin >> k1 >> k2 >> k3;
if (k1 == 1 || k2 == 1 || k3 == 1) {
cout << "YES";
return 0;
}
if ((k1 == 2 && k2 == 2) || (k1 == 2 && k3 == 2) || (k2 == 2 && k3 == 2)) {
cout << "YES";
return 0;
}
if (k1 == 3 && k2 == 3 && k3 == 3) {
cout << "YES";
return 0;
}
if ((k1 == 2 && k2 == 4 && k3 == 4) || (k1 == 4 && k2 == 2 && k3 == 4) ||
(k1 == 4 && k2 == 4 && k3 == 2)) {
cout << "YES";
return 0;
}
cout << "NO";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const long long inf = 1e15 + 15;
int n, m, q;
int a[N], b[N], c[N];
vector<int> v[N];
long long pot[N];
long long dist[N];
priority_queue<pair<long long, int> > pq;
bool visited[N];
void solve() {
for (int i = 1; i <= n; ++i) {
dist[i] = inf;
}
dist[1] = 0;
while (!pq.empty()) {
pq.pop();
}
pq.push({0, 1});
while (!pq.empty()) {
int node = pq.top().second;
visited[node] = 1;
long long cost = -pq.top().first;
pq.pop();
if (dist[node] < cost) {
continue;
}
for (int edge : v[node]) {
int next = b[edge];
if (dist[next] > cost + c[edge]) {
dist[next] = cost + c[edge];
pq.push({-cost - c[edge], next});
}
}
}
for (int i = 1; i <= m; ++i) {
long long tmp = dist[a[i]] - dist[b[i]] + c[i];
tmp = min(tmp, 1LL << 30);
c[i] = tmp;
}
for (int i = 1; i <= n; ++i) {
pot[i] += dist[i];
}
}
int newdist[N];
int head[N];
int nxt[N];
int val[N];
int cur;
int done[N];
int when;
void update() {
for (int i = 1; i <= n; ++i) {
newdist[i] = n;
}
cur = 0;
newdist[1] = 0;
++when;
head[0] = ++cur;
val[cur] = 1;
nxt[cur] = 0;
for (int level = 0; level < n; ++level) {
while (head[level]) {
int node = val[head[level]];
head[level] = nxt[head[level]];
if (done[node] == when) {
continue;
}
done[node] = when;
for (int edge : v[node]) {
int next = b[edge];
int cost = level + c[edge];
if (newdist[next] > cost) {
newdist[next] = cost;
if (head[cost]) {
++cur;
val[cur] = next;
nxt[cur] = head[cost];
head[cost] = cur;
} else {
head[cost] = ++cur;
val[cur] = next;
nxt[cur] = 0;
}
}
}
}
}
for (int i = 1; i <= m; ++i) {
c[i] += newdist[a[i]] - newdist[b[i]];
}
for (int i = 1; i <= n; ++i) {
pot[i] += newdist[i];
}
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= m; ++i) {
scanf("%d %d %d", a + i, b + i, c + i);
v[a[i]].emplace_back(i);
}
solve();
while (q--) {
int type;
scanf("%d", &type);
if (type == 1) {
int finish;
scanf("%d", &finish);
if (visited[finish]) {
printf("%lld\n", pot[finish]);
} else {
printf("-1\n");
}
} else {
int siz, idx;
scanf("%d", &siz);
while (siz--) {
scanf("%d", &idx);
++c[idx];
}
update();
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[5002];
vector<pair<long long, int> > v;
int d[5002][5002], vis[5002], c[5002];
long long k[5002], p[5002];
void bfs(int src, int n) {
int i, u, v;
for (i = 1; i <= n; i++) d[src][i] = (int)1e9 + 7;
;
d[src][src] = 0;
memset(vis, 0, sizeof(vis));
vis[src] = 1;
queue<int> q;
q.push(src);
while (!q.empty()) {
u = q.front();
q.pop();
for (i = 0; i < graph[u].size(); i++) {
v = graph[u][i];
if (!vis[v]) {
d[src][v] = min(d[src][v], d[src][u] + 1);
q.push(v);
vis[v] = 1;
}
}
}
}
bool check(int t, int n, int g, int r, int b) {
int i;
long long cost = 0, cnt = 0;
for (i = 0; i < v.size(); i++) {
if (cost <= (long long)b && cnt >= (long long)r) return 1;
if (cost > (long long)b) return 0;
if (d[g][c[v[i].second]] > t) continue;
if (cnt + k[v[i].second] > r)
cost += (long long)((r - cnt) * p[v[i].second]), cnt = (long long)r;
else
cost += (long long)(k[v[i].second] * p[v[i].second]),
cnt += (long long)k[v[i].second];
}
if (cost <= (long long)b && cnt >= r) return 1;
return 0;
}
int main() {
int n, m, i, q, x, y, w, g, r, b;
scanf("%d %d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
graph[x].push_back(y);
graph[y].push_back(x);
}
scanf("%d", &w);
for (i = 1; i <= w; i++) {
scanf("%d %I64d %I64d", &c[i], &k[i], &p[i]);
v.push_back({p[i], i});
}
sort(v.begin(), v.end());
for (i = 1; i <= n; i++) {
bfs(i, n);
}
scanf("%d", &q);
while (q--) {
int L, R, mid;
L = 0, R = n;
scanf("%d %d %d", &g, &r, &b);
if (!check(R, n, g, r, b)) {
printf("-1\n");
continue;
}
while (L != R) {
mid = (L + R) / 2;
if (check(mid, n, g, r, b))
R = mid;
else
L = mid + 1;
}
printf("%d", L);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, l, a[10005], b[10005];
bool cmp(int x, int y) { return x < y; }
bool used[10005][10005];
bool can_do() {
for (int i = 1; i <= l; i++) {
int ans = -1, cx, cy, hans = -1;
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++)
if (used[j][k] == 1)
continue;
else if ((j + k) > a[i])
continue;
else if ((j + m - k) > ans) {
ans = j + m - k;
cx = j;
cy = k;
} else if ((j + m - k) == ans && (j + k) > hans) {
ans = j + m - k;
cx = j;
cy = k;
}
if (ans == -1) return 0;
used[cx][cy] = 1;
}
for (int i = 1; i <= q; i++) {
int ans = -1, cx, cy;
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++)
if (used[j][k] == 1)
continue;
else if ((j + m - k + 1) > b[i])
continue;
else if ((j + m - k) > ans) {
ans = j + m - k;
cx = j;
cy = k;
}
if (ans == -1) return 0;
used[cx][cy] = 1;
}
return 1;
}
int main() {
scanf("%d%d%d", &n, &m, &l);
for (int i = 1; i <= l; i++) scanf("%d", &a[i]);
sort(a + 1, a + l + 1, cmp);
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%d", &b[i]);
sort(b + 1, b + q + 1, cmp);
memset(used, 0, sizeof(used));
if (can_do() == 1)
printf("YES\n");
else
printf("NO\n");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long getMaximumEnergy(int n, int k, const vector<long long> a,
const vector<long long> d) {
if (k >= 2) {
long long ret = max(0LL, a[n - 1] - d[n - 1]);
long long lowestCost = d[0];
long long totalBenefit = a[n - 1];
for (int i = 0; i < n - 1; i++) {
lowestCost = min(lowestCost, d[i]);
totalBenefit += a[i];
}
ret = max(ret, totalBenefit - lowestCost);
return ret;
} else if (k == 0) {
long long best = 0;
long long totalBenefit = 0;
for (int i = n - 1; i >= 0; i--) {
totalBenefit += a[i];
best = max(best, totalBenefit - d[i]);
}
return best;
} else if (k == 1) {
vector<long long> cycleBenefit(n);
long long cheapest = d[0];
long long totalBenefit = 0;
for (int i = 0; i < n; i++) {
cheapest = min(cheapest, d[i]);
totalBenefit += a[i];
cycleBenefit[i] = max(0LL, totalBenefit - cheapest);
}
vector<vector<pair<long long, long long>>> lineBenefit(n);
totalBenefit = 0;
vector<pair<long long, long long>> bestScore;
bestScore.push_back(make_pair(0, -1));
for (int i = n - 1; i >= 0; i--) {
totalBenefit += a[i];
long long thisTurn = totalBenefit - d[i];
bestScore.push_back(make_pair(thisTurn, i));
sort(bestScore.begin(), bestScore.end());
reverse(bestScore.begin(), bestScore.end());
while ((int)bestScore.size() > 2) bestScore.pop_back();
lineBenefit[i] = bestScore;
}
long long TYPE1_ANSWER = 0;
for (int i = 1; i < n - 1; i++) {
long long thisRound = cycleBenefit[i] + lineBenefit[i + 1][0].first;
TYPE1_ANSWER = max(TYPE1_ANSWER, thisRound);
}
long long TYPE2_ANSWER = 0;
for (int i = 0; i < n - 2; i++) {
long long thisRound = 0;
for (int t = 0; t < 2; t++) {
long long currentBenefit = lineBenefit[0][t].first;
if (lineBenefit[0][t].second == i + 1) continue;
if (lineBenefit[0][t].second <= i) {
currentBenefit -= a[i + 1];
currentBenefit += max(0LL, a[i + 1] - d[i + 1]);
}
thisRound = max(thisRound, currentBenefit);
}
thisRound = max(thisRound, lineBenefit[i + 1][0].first);
TYPE2_ANSWER = max(TYPE2_ANSWER, thisRound);
}
return max(TYPE1_ANSWER, TYPE2_ANSWER);
} else {
assert(false);
}
}
int main() {
int tc = 1;
while (tc--) {
int n, k;
scanf("%d%d", &n, &k);
vector<long long> a(n);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
vector<long long> d(n);
for (int i = 0; i < n; i++) scanf("%lld", &d[i]);
long long ans = getMaximumEnergy(n, k, a, d);
printf("%lld\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int mxn = 600000;
int n, q;
long long a[mxn], b[mxn], d[mxn], first[mxn], p[mxn], it[mxn];
struct segTree {
int l, r;
segTree *tl, *tr;
long long vl, lv, rv, second;
segTree(int l, int r) : l(l), r(r) {
vl = lv = rv = second = 0;
if (l != r) {
int mid = (l + r) / 2;
tl = new segTree(l, mid);
tr = new segTree(mid + 1, r);
pul();
} else {
upd(it[l] < n);
}
}
void upd(int x) {
(lv += mod + x * a[it[l]] * p[1] % mod) %= mod;
(rv += mod + x * a[it[l]] * p[1] % mod) %= mod;
second += x;
}
void pul() {
vl = (tl->vl + tr->vl + tl->lv * tr->rv) % mod;
lv = (p[tr->second] * tl->lv + tr->lv) % mod;
rv = (tl->rv + p[tl->second] * tr->rv) % mod;
second = tl->second + tr->second;
}
void add(int x, int v) {
if (x < l || r < x) return;
if (l == r) return upd(v);
tl->add(x, v), tr->add(x, v);
pul();
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
p[0] = 1;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = d[i] = it[i] = i;
p[i + 1] = (mod + 1) / 2 * p[i] % mod;
}
cin >> q;
for (int i = 0; i < q; i++) {
int x;
cin >> x >> a[n + i];
x--;
b[n + i] = d[x], d[x] = it[n + i] = n + i;
}
sort(it, it + n + q, [&](int x, int y) { return a[x] < a[y]; });
for (int i = 0; i < n + q; i++) first[it[i]] = i;
segTree tre(0, n + q - 1);
cout << tre.vl << '\n';
for (int i = 0; i < q; i++) {
tre.add(first[b[n + i]], -1);
tre.add(first[n + i], 1);
cout << tre.vl << '\n';
}
return 0;
}
| 6 |
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <bitset>
using namespace std;
int n;
vector<vector<int>> g;
vector<int> color;
vector<int> parts;
vector<pair<int, int>> ps;
bool dfs(int u, int c) {
color[u] = c;
parts[c]++;
for (int v: g[u]) {
if (~color[v]) {
if (color[v] == color[u]) return false;
} else {
if (!dfs(v, c ^ 1)) return false;
}
}
return true;
}
bool is_bipartite() {
color.assign(n, -1);
parts.assign(2, 0);
for (int u = 0; u < n; u++) if (color[u] == -1) {
if (!dfs(u, 0)) return false;
ps.emplace_back(parts[0], parts[1]);
parts.assign(2, 0);
}
return true;
}
int main() {
cin.tie(nullptr); ios::sync_with_stdio(false);
int m; cin >> n >> m;
g.resize(n);
for (int i = 0; i < m; i++) {
int a, b; cin >> a >> b; a--; b--;
g[a].emplace_back(b);
g[b].emplace_back(a);
}
if (!is_bipartite()) return !(cout << -1 << endl);
map<int, int> diff;
for (auto &p: ps) diff[abs(p.first - p.second)]++;
bitset<(int)2e5 + 1> dp; dp.set(n);
vector<int> ds;
for (auto &p: diff) {
int u = 1;
while (p.second >= u) {
ds.emplace_back(p.first * u);
p.second -= u, u <<= 1;
}
if (p.second) ds.emplace_back(p.first * p.second);
}
for (auto d: ds) dp = dp << d | dp >> d;
long long ma = 0;
for (int d = 0; d <= n; d++) if (dp[d + n]) {
int t = (n - d) / 2;
ma = max(ma, 1LL * t * (t + d));
}
cout << ma - m << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int n, t;
string s;
int main() {
cin >> n >> t >> s;
for (int j = 0; j < t; j++) {
for (int i = 0; i < n - 1; i++) {
if (s[i] == 'B' && s[i + 1] == 'G') {
swap(s[i], s[i + 1]);
i++;
}
}
}
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3, "Ofast", "inline")
inline int MAX(int x, int y) { return x > y ? x : y; }
inline int MIN(int x, int y) { return x < y ? x : y; }
using namespace std;
template <typename T>
T gcd(T a, T b) {
while (b ^= a ^= b ^= a %= b)
;
return a;
}
inline char nc() {
static char buf[1000000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <typename T>
inline void read(T& sum) {
char ch = getchar();
T tf = 0;
sum = 0;
while ((ch < '0' || ch > '9') && (ch != '-')) ch = getchar();
tf = ((ch == '-') && (ch = getchar()));
while (ch >= '0' && ch <= '9') sum = sum * 10 + (ch - 48), ch = getchar();
(tf) && (sum = -sum);
}
template <typename T>
inline void write(T x) {
char F[200];
T tmp = x > 0 ? x : -x;
if (x < 0) putchar('-');
T cnt = 0;
while (tmp > 0) {
F[cnt++] = tmp % 10 + '0';
tmp /= 10;
}
while (cnt > 0) putchar(F[--cnt]);
}
void seino();
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t = 1;
cin >> t;
while (t--) seino();
return 0;
}
void seino() {
long long a, b, c;
cin >> a >> b >> c;
if (a == b || c == a || c == b)
cout << "-1\n";
else {
long long s = (MAX(a, b) - MIN(a, b));
if (s * 2 < a || s * 2 < b || s * 2 < c)
cout << "-1\n";
else {
long long ans = (s + c) % (s * 2);
if (ans == 0) ans = (s * 2);
cout << ans << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, temp1, temp2, ans = 0, parts[10000];
scanf("%d%d", &n, &m);
for (int i = 1; i < n + 1; i++) scanf("%d", &parts[i]);
for (int i = 0; i < m; i++) {
scanf("%d%d", &temp1, &temp2);
ans += min(parts[temp1], parts[temp2]);
}
printf("%d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k, sum = 0;
cin >> m >> n >> k;
long long brea[m];
for (int i = 0; i < m; i++) {
cin >> brea[i];
}
long long a[m - 1];
for (int i = 0; i < m - 1; i++) {
a[i] = brea[i + 1] - brea[i];
}
sort(a, a + m - 1);
long long i;
for (i = 0; i <= m - 1 - k; i++) {
sum += a[i];
}
sum += k;
cout << sum;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
int numOfShift(int n, int m) {
vector<NumberOf> number(n);
string s;
int ans = 1000;
for (int i = 0; i < n; ++i) {
cin >> s;
for (int j = 0; j < m; ++j) {
int temp = min(j, m - j);
number[i].data[type(s[j])] = min(number[i].data[type(s[j])], temp);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < n; ++k) {
if (i != j && i != k && j != k) {
ans = min(
ans, number[i].data[0] + number[j].data[1] + number[k].data[2]);
}
}
}
}
return ans;
}
int type(char a) {
if (isdigit(a)) return 0;
if (isalpha(a)) return 1;
return 2;
}
struct NumberOf {
NumberOf() {
data.resize(3);
data[0] = data[1] = data[2] = 1000;
}
void print() {
cout << "d=" << data[0] << " a=" << data[1] << " s=" << data[2] << endl;
}
vector<int> data;
};
private:
};
int main() {
int n, m;
cin >> n >> m;
Solution s;
cout << s.numOfShift(n, m);
}
| 3 |
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
class Point {
public:
int x, y;
Point(int a = 0, int b = 0)
{
int x = a;
int y = b;
};
bool operator <(const Point& p) const {
return y < p.y || (y == p.y && x < p.x);
}
};
inline bool direct(Point& base, Point& a, Point& b) {
return (a.x - base.x)*(b.y - base.y) - (a.y - base.y)*(b.x - base.x) < 0;
}
int main() {
int n, i;
int k = 2;
Point* P;
Point* H;
scanf("%d", &n);
P = new Point[n];
for (i = 1; i <= n; ++i) {
scanf("%d%d",&P[i - 1].x, &P[i - 1].y);
}
sort(P, P + n);
H = new Point[2*n];
H[0] = P[0];
H[1] = P[1];
for (i = 0; i < n - 2; ++i) {
while (k >= 2 && direct(H[k - 2],H[k - 1],P[i + 2])) k--;
H[k++] = P[i + 2];
}
H[k++] = P[n - 2];
for (i = n; i > 2; i--) {
while (k >= 2 && direct(H[k - 2],H[k - 1],P[i - 3])) k--;
H[k++] = P[i - 3];
}
printf("%d\n", k - 1);
for (i = 0; i < k - 1; ++i) {
printf("%d %d\n", H[i].x, H[i].y);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, s1;
cin >> s >> s1;
reverse(s.begin(), s.end());
if (s == s1) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, m, p, x, y;
using namespace std;
int main() {
cin >> n >> m >> p;
while (p--) {
cin >> x >> y;
if (x <= 5 || y <= 5 || n - x <= 4 || m - y <= 4) return puts("YES"), 0;
}
puts("NO");
return 0;
}
| 3 |
#include<stdio.h>
#include<algorithm>
using namespace std;
int p[30];
int q[30];
char str[8];
int main(){
int sz=0;
int sz2=0;
int a;scanf("%d",&a);
int b;scanf("%d",&b);
for(int i=0;i<b;i++){
int c;scanf("%s%d",str,&c);
if(str[0]=='D')p[sz++]=-c;
}
int d;scanf("%d",&d);
for(int i=0;i<d;i++){
int c;scanf("%s%d",str,&c);
if(str[0]=='D'&&str[1]=='D')q[sz2++]=-c;
}
std::sort(p,p+sz);
std::sort(q,q+sz2);
int ret=0;
for(int i=0;i<=a;i++){
int val=0;
for(int j=0;j<i;j++)val-=p[j];
for(int j=0;j<(a-i)/2;j++)val-=q[j];
ret=max(ret,val);
}
printf("%d\n",ret);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
int n;
int main() {
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
int Fid = -1;
{
vector<int> cnt(n);
for (auto i : a) cnt[i]++;
int mx = max_element(cnt.begin(), cnt.end()) - cnt.begin();
if (count(cnt.begin(), cnt.end(), cnt[mx]) >= 2) {
cout << n;
return 0;
}
Fid = mx;
}
vector<set<int>> var(n);
for (int i = 1; i <= n; i++) {
var[a[i - 1]].insert(i);
}
vector<int> s = {0};
for (int i : var[Fid]) s.push_back(i);
s.push_back(n + 1);
int ret = 0;
for (auto it = s.begin(); it != prev(s.end()); it++)
ret = max(ret, *next(it) - *it - 1);
for (int v = 0; v < n; v++) {
if (v == Fid) continue;
var[v].insert(0);
var[v].insert(n + 1);
int cur = 0;
vector<int> beg = {0};
vector<int> pos = {0};
int cnt = 1;
auto get_dp = [&](int p) {
assert(p < cnt);
int id = upper_bound(pos.begin(), pos.end(), p) - pos.begin() - 1;
return s[beg[id] + p - pos[id]];
};
for (auto it = var[v].begin(); it != prev(var[v].end()); it++) {
int L = *it;
int R = *next(it);
int sL = upper_bound(s.begin(), s.end(), L) - s.begin();
int sR = upper_bound(s.begin(), s.end(), R) - s.begin();
if (sL == sR) {
cur--;
continue;
}
int to = cur + sR - sL - 1;
while (cur < cnt && sL < sR) {
cur++;
if (cur > 0) {
ret = max(ret, s[sL] - get_dp(cur - 1) - 1);
}
sL++;
}
if (cur >= cnt) {
pos.push_back(cur);
beg.push_back(sL - 1);
cnt += sR - sL + 1;
}
cur = to;
}
}
cout << ret;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4 * 1e5 + 5;
vector<int> g[N];
int n, dp[N], res[N];
int dfs(int i, int p = -1) {
dp[i] = 1;
for (auto j : g[i]) {
if (j != p) {
dp[i] += dfs(j, i);
}
}
return dp[i];
}
int dfs2(int i, int p = -1) {
for (auto j : g[i]) {
if (j != p && dp[j] * 2 > n) {
return dfs2(j, i);
}
}
return i;
}
void dfs3(int i, int p, int c1, int c2) {
if (c1 * 2 >= n) res[i] = 1;
if ((dp[i] + c2) * 2 >= n) res[i] = 1;
for (auto j : g[i]) {
if (j != p) {
dfs3(j, i, c1, c2);
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(0);
int a = dfs2(0);
dfs(a);
res[a] = 1;
int mx = -1, mx2 = -1, v;
for (auto j : g[a]) {
if (dp[j] > mx) {
mx2 = mx;
mx = dp[j];
v = j;
} else if (dp[j] > mx2) {
mx2 = dp[j];
}
}
for (auto j : g[a]) {
if (j == v)
dfs3(j, a, dp[j], mx2);
else
dfs3(j, a, dp[j], mx);
}
for (int i = 0; i < n; ++i) cout << res[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = ~0U >> 1;
const long long LINF = ~(((long long)0x1) << 63) / 2;
template <class T>
bool get_max(T &a, T &b) {
return b > a ? a = b, 1 : 0;
}
template <class T>
bool get_min(T &a, T &b) {
return b < a ? a = b, 1 : 0;
}
const long long MOD = 1000000007LL;
int t, k;
string lstr, rstr;
char A[1005], B[1005];
long long dp[1105][1105][3][2];
int digit[1105];
int nlim = 1100;
long long dfs(int pos, int luck_pos, int less, int have) {
if (pos == 0) return have;
if (!(less == 1) && dp[pos][luck_pos][less][have] != -1)
return dp[pos][luck_pos][less][have];
long long ans = 0;
if (less == 2) {
ans = (ans + dfs(pos - 1, nlim, 2, 0)) % MOD;
for (int i = 1; i <= 9; i++) {
if (i == 4 || i == 7)
ans = (ans + dfs(pos - 1, pos - 1, 0, 0)) % MOD;
else
ans = (ans + dfs(pos - 1, nlim, 0, 0)) % MOD;
}
} else {
int lim = (less ? digit[pos - 1] : 9);
if (have) {
for (int i = 0; i <= lim; i++) {
ans += dfs(pos - 1, 0, less && i == lim, 1);
ans %= MOD;
}
if (!(less == 1)) dp[pos][luck_pos][less][have] = ans;
return ans;
}
for (int i = 0; i <= lim; i++) {
if (i == 4 || i == 7) {
if (luck_pos != nlim && luck_pos - pos + 1 <= k) {
ans += dfs(pos - 1, pos - 1, less && i == lim, 1);
} else {
ans += dfs(pos - 1, pos - 1, less && i == lim, 0);
}
} else {
ans += dfs(pos - 1, luck_pos, less && i == lim, have);
}
ans %= MOD;
}
}
ans %= MOD;
if (!(less == 1)) dp[pos][luck_pos][less][have] = ans;
return ans;
}
long long solve(string str) {
int n = str.size();
for (int i = n - 1; i >= 0; i--) {
digit[n - 1 - i] = str[i] - '0';
}
long long ans = 0;
ans += dfs(n - 1, nlim, 2, 0);
ans %= MOD;
for (int i = 1; i <= digit[n - 1]; i++) {
if (i != digit[n - 1]) {
if (i == 4 || i == 7) {
ans += dfs(n - 1, n - 1, 0, 0);
} else {
ans += dfs(n - 1, nlim, 0, 0);
}
} else {
if (i == 4 || i == 7) {
ans += dfs(n - 1, n - 1, 1, 0);
} else {
ans += dfs(n - 1, nlim, 1, 0);
}
}
ans %= MOD;
}
return ans % MOD;
}
int main() {
scanf("%d%d", &t, &k);
memset(dp, -1, sizeof(dp));
while (t--) {
cin >> A >> B;
for (int i = strlen(A) - 1; i >= 0; i--) {
if (A[i] == '0')
A[i] = '9';
else {
A[i]--;
break;
}
}
char *p = A;
if (*p == '0' && *(p + 1) != 0) p++;
long long ans1 = solve(p);
long long ans2 = solve(B);
ans1 %= MOD;
ans2 %= MOD;
long long re = (ans2 - ans1 + MOD) % MOD;
cout << re << endl;
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define maxn 100000
int a[maxn+5];
int main(){
int n,k,q,x;scanf("%d%d%d",&n,&k,&q);
k=q-k+1;
for(int i=0;i<q;i++)scanf("%d",&x),a[x]++;
for(int i=1;i<=n;i++)if(a[i]>=k)puts("Yes");else puts("No");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[3] = {0, 0, 0};
int find(int x) {
for (int i = 0; i < 3; i++)
if (arr[i] == x) return i;
return -1;
}
int main() {
string input;
for (int i = 0; i < 3; i++) {
cin >> input;
if (input[1] == '>')
arr[input[0] - 'A']++;
else
arr[input[2] - 'A']++;
}
for (int i = 0; i < 3; i++)
if (find(i) == -1) {
cout << "Impossible\n";
return 0;
}
cout << (char)(find(0) + 'A') << (char)(find(1) + 'A')
<< (char)(find(2) + 'A') << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, t, tr, a;
int r[5005][2], c[5005][2];
int main() {
cin >> n >> m >> k;
for (int l = 0; l < k; l++) {
scanf("%i%i%i", &t, &tr, &a);
if (t == 1) {
r[tr][0] = a;
r[tr][1] = l + 1;
} else {
c[tr][0] = a;
c[tr][1] = l + 1;
}
}
for (int l = 1; l <= n; ++l) {
for (int l2 = 1; l2 <= m; l2++) {
if (r[l][1] > c[l2][1])
printf("%i ", r[l][0]);
else
printf("%i ", c[l2][0]);
}
printf("\n");
}
return 0;
}
| 2 |
#include <stdio.h>
#include <math.h>
#define rep(i, n) for(int i=0; i<(int)(n); i++)
typedef long long Int;
int N, M, L, P[200], T[200], V[200];
double zp[200][200], zt[200][200];
Int C[100][100];
int main() {
C[0][0] = 1;
rep(i, 80) rep(j, 80) C[i+1][j]+=C[i][j], C[i+1][j+1]+=C[i][j];
scanf("%d%d%d", &N, &M, &L);
rep(i, N) scanf("%d%d%d", P+i, T+i, V+i);
rep(i, N) rep(j, M+1) {
const double p = P[i]/100.0;
zt[i][j] = (double)L/V[i] + (double)j*T[i];
zp[i][j] = (double)C[M][j] * pow(p, j) * pow(1-p, M-j);
}
rep(i, N) {
double ans = 0;
if(V[i]!=0) rep(j, M+1) {
double f = 1.0;
rep(k, N) if(i!=k) {
double p = 0;
rep(l, M+1) if(zt[i][j]<zt[k][l]) p += zp[k][l];
f *= p;
}
ans += zp[i][j] * f;
}
printf("%.9f\n", ans);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void R(T &x) {
char ch = getchar();
x = 0;
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch <= '9' && ch >= '0'; ch = getchar()) x = x * 10 + ch - '0';
}
inline long long gcd(long long a, long long b) {
if (b == 0) return a;
for (long long c = a % b; c; a = b, b = c, c = a % b)
;
return b;
}
const int N = 200005;
pair<int, int> a[N];
int n;
inline long double pow(long double a, int b) {
long double ans = 1;
for (; b; b >>= 1) {
if (b & 1) ans = ans * a;
a = a * a;
}
return ans;
}
inline int Abs(int x) { return x < 0 ? -x : x; }
long long query(pair<int, int> a, pair<int, int> b) {
if (b.first == a.first)
return a.second < b.second ? -((long long)b.second - a.second) : 0;
else {
long long dx = Abs(b.first - a.first), dy = Abs(b.second - a.second);
long long g = gcd(dx, dy);
if (b.first > a.first) {
if (b.second == a.second)
return dx * b.second;
else
return ((dx + 1) * ((long long)a.second + b.second + 1) - g - 1) / 2 -
b.second;
} else {
if (b.second == a.second)
return -dx * (b.second + 1);
else
return -(((dx + 1) * ((long long)a.second + b.second + 1) + g + 1) / 2 -
a.second - 1);
}
}
}
void solves() {
long double tot = pow(2, n) - 1 - n - (long double)n * (n - 1) / 2, ans = 0;
for (int d = 1; d < n - 1; ++d) {
for (int i = 1; i <= n; ++i) {
int j = (i + d - 1) % n + 1;
ans += (pow(2, n - d - 1) - 1) / tot * query(a[i], a[j]);
}
}
ans += 1;
printf("%.15lf\n", (double)ans);
}
void solveb() {
long double ans = 0;
for (int d = 1; d < 50; ++d) {
for (int i = 1; i <= n; ++i) {
int j = (i + d - 1) % n + 1;
ans += pow(0.5, d + 1) * query(a[i], a[j]);
}
}
ans += 1;
printf("%.15f\n", (double)ans);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", &a[i].first, &a[i].second);
int mi = 0;
for (int i = 1; i <= n; ++i) {
mi = min(mi, a[i].second);
}
for (int i = 1; i <= n; ++i) a[i].second -= mi;
reverse(a + 1, a + n + 1);
if (n <= 200)
solves();
else
solveb();
return 0;
}
| 4 |
#include <iostream>
#include <map>
using namespace std;
int main()
{
string s;
cin >> s;
map<char,int> m;
for(int i=0; i<s.length(); i++){
m[s[i]]++;
}
int paircount = 0;
long long div = 1;
bool bOdd = false;
for(map<char,int>::iterator p = m.begin(); p != m.end(); p++){
if((*p).second % 2 == 1){
if(!bOdd){
bOdd = true;
}else{
cout << 0 << endl;
return 0;
}
}
int pair = (*p).second / 2;
paircount += pair;
while(pair > 1){
div *= pair;
pair--;
}
}
long long ret = 1;
while(paircount > 1){
ret *= paircount;
paircount--;
}
cout << ret / div << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
struct Dinic{
const int INF=1<<28;
struct edge {
int to,cap,rev;
edge(){}
edge(int to,int cap,int rev):to(to),cap(cap),rev(rev){}
};
int n;
vector<vector<edge> > G;
vector<map<int,int> > M;
vector<int> level,iter;
Dinic(){}
Dinic(int sz):n(sz),G(n),M(n),level(n),iter(n){}
void add_edge(int from,int to,int cap){
M[from][to]=G[from].size();
M[to][from]=G[to].size();
G[from].push_back(edge(to,cap,G[to].size()));
// undirected
//G[to].push_back(edge(from,cap,G[from].size()-1));
// directed
G[to].push_back(edge(from,0,G[from].size()-1));
}
void bfs(int s){
fill(level.begin(),level.end(),-1);
queue<int> que;
level[s]=0;
que.push(s);
while(!que.empty()){
int v=que.front();que.pop();
for(int i=0;i<(int)G[v].size();i++){
edge &e = G[v][i];
if(e.cap>0&&level[e.to]<0){
level[e.to]=level[v]+1;
que.push(e.to);
}
}
}
}
int dfs(int v,int t,int f){
if(v==t) return f;
for(int &i=iter[v];i<(int)G[v].size();i++){
edge &e=G[v][i];
if(e.cap>0&&level[v]<level[e.to]){
int d = dfs(e.to,t,min(f,e.cap));
if(d>0){
e.cap-=d;
G[e.to][e.rev].cap+=d;
return d;
}
}
}
return 0;
}
int flow(int s,int t,int lim){
int fl=0;
for(;;){
bfs(s);
if(level[t]<0||lim==0) return fl;
fill(iter.begin(),iter.end(),0);
int f;
while((f=dfs(s,t,lim))>0){
fl+=f;
lim-=f;
}
}
}
int flow(int s,int t){
return flow(s,t,INF);
}
//cap==1 only
bool back_edge(int s,int t,int from, int to){
for(int i=0;i<(int)G[from].size();i++) {
edge& e=G[from][i];
if(e.to==to) {
if(e.cap==0&&flow(from,to,1)==0) {
flow(from,s,1);
flow(t,to,1);
return 1;
}
}
}
return 0;
}
};
int dx[]={1,-1,0,0};
int dy[]={0,0,-1,1};
int main(){
int test;
cin>>test;
r(o,test){
int h,w,sum=0;
cin>>w>>h;
int a[h][w];
r(i,h)r(j,w)cin>>a[i][j],sum+=a[i][j];
Dinic D(h*w+2);
int SRC=h*w;
int SINK=h*w+1;
r(i,h){
r(j,w){
if((i+j)%2){
D.add_edge(SRC,i*w+j,a[i][j]);
r(k,4){
int y=i+dy[k];
int x=j+dx[k];
if(y<0||x<0||y>=h||x>=w)continue;
D.add_edge(i*w+j,y*w+x,1e8);
}
}
else D.add_edge(i*w+j,SINK,a[i][j]);
}
}
cout<<"Case "<<o+1<<": "<<sum-D.flow(SRC,SINK,1e8)<<endl;
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main () {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.length()+1, id = 0;
vector<int> p(n), c(n), t(n), lcp(n-1);
vector<vector<int>> cnt(n);
for (int i=0; i<n; i++) {
p[i]= i;
}
sort(begin(p), end(p), [&](const int& i, const int& j) {
if (i == n-1)
return true;
if (j == n-1)
return false;
return s[i] < s[j];
});
c[p[0]] = 0; c[p[1]] = 1;
for (int i=2; i<n; i++)
c[p[i]] = c[p[i-1]] + (s[p[i]] != s[p[i-1]]);
for (int k = 2; k<2*n && c[p[n-1]]<n-1; k*=2) {
for (auto &v : cnt)
v.clear();
for (int i=0; i<n; i++)
cnt[c[(p[i]-(k/2)+n+n)%n]].emplace_back((p[i]-(k/2)+n+n)%n);
id = 0;
for (const auto & v : cnt)
for (const int & x : v)
p[id++] = x;
t[1] = 0;
for (int i=1; i<n; i++)
t[i] = t[i-1] + (!(c[p[i]] == c[p[i-1]] && c[(p[i]+(k/2))%n] == c[(p[i-1]+(k/2))%n]));
for (int i=0; i<n; i++)
c[p[i]] = t[i];
}
for (int i=0; i<n; i++)
t[p[i]] = i;
int k = 0;
for (int i=0; i<n-1; i++) {
if (t[i] == n-1) {
k = 0;
continue;
}
int j = p[t[i]+1];
while (i+k<n-1 && j+k<n-1 && s[i+k] == s[j+k])
k++;
lcp[t[i]] = k;
if (k)
--k;
}
ll ans = s.length();
for (ll i=1; i<n; i++) {
ans += (ll)s.length()-i-(ll)lcp[p[i]];
}
cout << ans << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int bases[41], tails[41];
int minLen, maxLen;
int log2(long long n) {
if (n <= 1) return (int)n;
return 1 + log2(n >> 1);
}
bool calc() {
for (int i = 2; i <= 40; i++) {
if (bases[i] > bases[i - 1]) {
tails[i - 1] += bases[i] - bases[i - 1];
bases[i] = bases[i - 1];
}
}
for (int i = 40; i > 0; i--) {
if (!tails[i]) continue;
if (bases[i] < tails[i]) return false;
for (int j = 1; j <= i; j++) {
bases[j] -= tails[i];
}
for (int j = 0; j < tails[i]; j++) {
for (int k = i + 1; k <= 40; k++) {
if (bases[k] > 0)
bases[k]--;
else
break;
}
}
minLen += tails[i];
}
maxLen = minLen + bases[1];
int tailFree = bases[1];
int currBase = 1;
while (tailFree > 0) {
for (int i = currBase + 1; i <= 40; i++) {
if (bases[i] == bases[currBase])
currBase++;
else
break;
}
if (tailFree - 1 >= currBase) {
tailFree -= currBase + 1;
bases[currBase]--;
} else
break;
}
minLen += bases[currBase];
return true;
}
int main() {
int n;
scanf("%d\n", &n);
for (int i = 0; i < n; i++) {
long long ai;
scanf("%lld", &ai);
int order = log2(ai);
if (ai == 1LL << (order - 1))
bases[order]++;
else
tails[order]++;
}
if (!calc()) {
printf("-1\n");
} else {
for (int i = minLen; i <= maxLen; i++) printf("%d ", i);
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int v[n];
bool possible = 1;
bool tab[1000042] = {0};
int valMax = 0;
for (int i = 0; i < n; i++) {
cin >> v[i];
valMax = max(valMax, v[i]);
if (v[i] > i + 1) {
possible = 0;
}
tab[v[i]] = 1;
}
if (!possible) {
cout << "-1";
return 0;
}
int mex = 0;
vector<int> manque;
for (int i = 0; i <= valMax; i++) {
if (!tab[i]) {
manque.push_back(i);
}
}
int curManque = 0;
vector<int> rep;
for (int i = 0; i < n; i++) {
if (mex == v[i]) {
if (curManque < manque.size() && manque[curManque] <= mex) {
curManque++;
}
if (curManque >= manque.size()) {
rep.push_back(valMax + 1);
if (valMax == 1000000) {
cout << "-1";
return 0;
}
} else {
rep.push_back(manque[curManque]);
curManque++;
}
} else {
rep.push_back(mex);
mex = v[i];
}
}
for (int i = 0; i < rep.size(); i++) cout << rep[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 50 + 10;
char a[N][N];
int n, m;
void read() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", a[i]);
}
}
bool been[N][N];
int px[] = {1, -1, 0, 0};
int py[] = {0, 0, 1, -1};
bool ok(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
int dfs(int x, int y) {
been[x][y] = true;
int cnt = 1;
for (int k = 0; k < 4; ++k) {
int x1 = x + px[k], y1 = y + py[k];
if (ok(x1, y1) && a[x1][y1] == '#' && !been[x1][y1]) {
cnt += dfs(x1, y1);
}
}
return cnt;
}
bool connected() {
int cnt = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == '#') {
++cnt;
}
been[i][j] = false;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == '#') {
if (dfs(i, j) != cnt) {
return false;
} else {
return true;
}
}
}
}
return true;
}
int main() {
read();
int cnt = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == '#') {
++cnt;
}
}
}
if (cnt < 3) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == '#') {
a[i][j] = '.';
if (!connected()) {
printf("1\n");
return 0;
}
a[i][j] = '#';
}
}
}
printf("2\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[100100], n, ans, temp, l, r, m;
int main() {
cin >> n >> m;
if (n <= m)
cout << n << endl;
else {
ans = m;
temp = ceil(sqrtl((n - m) * 8 + 1));
ans += ceil((temp - 1) / (double)2.0000);
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> months(12);
int k, count = 0;
scanf("%d", &k);
for (int i = 0; i < 12; i++) scanf("%d", &months[i]);
sort(months.begin(), months.end());
for (int i = 11; i >= 0; i--) {
if (k <= 0) {
printf("%d\n", count);
return 0;
}
k = k - months[i];
count++;
}
if (k <= 0) {
printf("%d\n", count);
return 0;
}
printf("-1\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int i = 0, h = 0;
while (i < s.length()) {
if (s[i] == '<' && s[i + 1] >= 'a' && s[i + 1] <= 'z') {
for (int j = 0; j < h; j++) {
cout << " ";
}
cout << '<' << s[i + 1] << '>' << endl;
h += 2;
i += 3;
} else if (s[i] == '<' && s[i + 1] == '/') {
h -= 2;
for (int j = 0; j < h; j++) {
cout << " ";
}
cout << '<' << s[i + 1] << s[i + 2] << '>' << endl;
i += 4;
} else {
for (int j = 0; j < h; j++) {
cout << " ";
}
while (i < s.length() && s[i] != '<') {
cout << s[i];
i++;
}
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool isVowel(char s) {
if (s == 'a' || s == 'e' || s == 'i' || s == 'o' || s == 'u') {
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s1, s2, s3;
int vowel_count_in_s1 = 0, vowel_count_in_s2 = 0, vowel_count_in_s3 = 0;
getline(cin, s1);
getline(cin, s2);
getline(cin, s3);
for (int i = 0; i < s1.length(); ++i) {
if (isVowel(s1[i])) {
++vowel_count_in_s1;
}
}
for (int i = 0; i < s2.length(); ++i) {
if (isVowel(s2[i])) {
++vowel_count_in_s2;
}
}
for (int i = 0; i < s3.length(); ++i) {
if (isVowel(s3[i])) {
++vowel_count_in_s3;
}
}
if (vowel_count_in_s1 == 5 && vowel_count_in_s2 == 7 &&
vowel_count_in_s3 == 5) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
constexpr int kInf = int(1E9 + 10);
int dp[260][260][260];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, q, a = 0, b = 0, c = 0, k, nxt;
vector<int> v[26];
string s, qs, sa, sb, sc;
cin >> n >> q >> s;
sa.resize(1000);
sb.resize(1000);
sc.resize(1000);
dp[0][0][0] = 0;
for (int i = 0; i < n; i++) v[s[i] - 'a'].push_back(i);
for (int i = 0; i < 26; i++) v[i].push_back(n);
while (q--) {
cin >> qs;
if (qs[0] == '+') {
cin >> k >> qs;
qs[0] -= 'a';
if (k == 1) {
sa[a++] = qs[0];
for (int i = 0; i <= b; i++)
for (int j = 0; j <= c; j++) {
nxt = kInf;
if (dp[a - 1][i][j] < n)
nxt = min(nxt, *lower_bound(v[qs[0]].begin(), v[qs[0]].end(),
dp[a - 1][i][j]));
if (i > 0 && dp[a][i - 1][j] < n)
nxt = min(nxt, *lower_bound(v[sb[i - 1]].begin(),
v[sb[i - 1]].end(), dp[a][i - 1][j]));
if (j > 0 && dp[a][i][j - 1] < n)
nxt = min(nxt, *lower_bound(v[sc[j - 1]].begin(),
v[sc[j - 1]].end(), dp[a][i][j - 1]));
if (nxt < n)
dp[a][i][j] = nxt + 1;
else
dp[a][i][j] = kInf;
}
} else if (k == 2) {
sb[b++] = qs[0];
for (int i = 0; i <= a; i++)
for (int j = 0; j <= c; j++) {
nxt = kInf;
if (dp[i][b - 1][j] < n)
nxt = min(nxt, *lower_bound(v[qs[0]].begin(), v[qs[0]].end(),
dp[i][b - 1][j]));
if (i > 0 && dp[i - 1][b][j] < n)
nxt = min(nxt, *lower_bound(v[sa[i - 1]].begin(),
v[sa[i - 1]].end(), dp[i - 1][b][j]));
if (j > 0 && dp[i][b][j - 1] < n)
nxt = min(nxt, *lower_bound(v[sc[j - 1]].begin(),
v[sc[j - 1]].end(), dp[i][b][j - 1]));
if (nxt < n)
dp[i][b][j] = nxt + 1;
else
dp[i][b][j] = kInf;
}
} else {
sc[c++] = qs[0];
for (int i = 0; i <= a; i++)
for (int j = 0; j <= b; j++) {
nxt = kInf;
if (dp[i][j][c - 1] < n)
nxt = min(nxt, *lower_bound(v[qs[0]].begin(), v[qs[0]].end(),
dp[i][j][c - 1]));
if (i > 0 && dp[i - 1][j][c] < n)
nxt = min(nxt, *lower_bound(v[sa[i - 1]].begin(),
v[sa[i - 1]].end(), dp[i - 1][j][c]));
if (j > 0 && dp[i][j - 1][c] < n)
nxt = min(nxt, *lower_bound(v[sb[j - 1]].begin(),
v[sb[j - 1]].end(), dp[i][j - 1][c]));
if (nxt < n)
dp[i][j][c] = nxt + 1;
else
dp[i][j][c] = kInf;
}
}
} else {
cin >> k;
if (k == 1)
a--;
else if (k == 2)
b--;
else
c--;
}
if (dp[a][b][c] < kInf)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int askcnt = 0;
bool ask(long long l, long long r) {
askcnt++;
assert(askcnt <= 4500);
printf("%lld %lld\n", l, r);
fflush(stdout);
char s[5];
scanf("%s", s);
if (s[0] == 'Y') {
if (l == r) exit(0);
return true;
}
if (s[0] == 'N') return false;
exit(0);
}
void guess(long long l, long long r) {
long long sz = r - l + 1;
int rnd = rand() % sz;
ask(l + rnd, l + rnd);
}
void reduce(long long& l, long long& r) {
long long sz = r - l + 1;
while (sz > 50) {
long long mid = (l + r) / 2;
if (ask(l, mid)) {
l = max(l - k, 1LL);
r = min(mid + k, n);
} else {
l = max(mid + 1 - k, 1LL);
r = min(r + k, n);
}
sz = r - l + 1;
}
guess(l, r);
l = max(1LL, l - k);
r = min(n, r + k);
}
int main() {
srand(time(NULL));
scanf("%lld %lld", &n, &k);
long long l = 1, r = n;
while (1) reduce(l, r);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const long double PI = acos(-1.0);
const long double EPS = 1e-10;
const long long LINF = 1e15;
const int INF = 1e9 + 7;
struct Actor {
int s, f, k, id;
Actor(int s = 0, int f = 0, int k = 0, int id = 0) {
this->s = s;
this->f = f;
this->k = k;
this->id = id;
}
bool operator<(const Actor a) const {
return (f < a.f || f == a.f && id < a.id);
}
};
struct Event {
char isActor;
int id, start;
Event(char isActor, int id, int start) {
this->isActor = isActor;
this->id = id;
this->start = start;
}
bool operator<(const Event &e) const {
return (start < e.start || start == e.start && isActor);
}
};
vector<Event> events;
int main() {
int n;
cin >> n;
vector<pair<int, int> > parts(n);
for (int i = 0; i < int(n); i++) {
cin >> parts[i].first >> parts[i].second;
events.push_back(Event(false, i, parts[i].first));
}
int m;
cin >> m;
vector<Actor> actors(m);
for (int i = 0; i < int(m); i++) {
cin >> actors[i].s >> actors[i].f >> actors[i].k;
actors[i].id = i;
events.push_back(Event(true, i, actors[i].s));
}
sort(events.begin(), events.end());
set<pair<int, int> > qa;
vector<int> answer(parts.size());
for (int i = 0; i < int(events.size()); i++) {
if (events[i].isActor) {
qa.insert(make_pair(actors[events[i].id].f, events[i].id));
} else {
if (qa.size() == 0) {
cout << "NO";
return 0;
}
auto it = qa.upper_bound(make_pair(parts[events[i].id].second - 1, INF));
if (it != qa.end()) {
answer[events[i].id] = it->second;
actors[it->second].k--;
pair<int, int> p = *it;
qa.erase(it);
if (actors[p.second].k > 0)
qa.insert(make_pair(actors[p.second].f, p.second));
} else {
cout << "NO";
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 0; i < int(answer.size()); i++) {
cout << answer[i] + 1 << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5;
vector<int> g[N + 100];
vector<pair<int, int> > ele;
int subt[N + 100], center, n, ans[N + 100];
void dfs(int v, int par) {
int mx = 0;
subt[v] = 1;
for (auto it : g[v]) {
if (it != par) {
dfs(it, v);
subt[v] += subt[it];
mx = max(subt[it], mx);
}
}
mx = max(mx, n - subt[v]);
if (mx <= n / 2) {
center = v;
}
}
void dfs2(int v, int par, int sum, int anc) {
if (sum <= n / 2) {
ans[v] = 1;
}
for (int sz = ele.size(), i = 0; i < sz && i < 2; i++) {
if (ele[i].second == anc) continue;
if (n - subt[v] - ele[i].first <= n / 2) {
ans[v] = 1;
}
}
for (auto it : g[v]) {
if (it != par) {
dfs2(it, v, sum, anc);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
dfs(center, 0);
for (auto it : g[center]) {
ele.push_back(make_pair(subt[it], it));
}
sort(ele.begin(), ele.end());
reverse(ele.begin(), ele.end());
for (auto it : g[center]) {
dfs2(it, center, n - subt[it], it);
}
ans[center] = 1;
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char m[3][3][3][5];
int main() {
int cnt0 = 0, cnt1 = 0;
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j)
for (int k = 0; k < 3; ++k) {
scanf("%s", m[i][k][j]);
}
int x, y;
scanf("%d %d", &x, &y);
x = (x - 1) % 3;
y = (y - 1) % 3;
int cnt = 0;
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j)
if (m[x][y][i][j] == '.') {
m[x][y][i][j] = '!';
cnt++;
}
if (!cnt) {
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j)
for (int k = 0; k < 3; ++k)
for (int s = 0; s < 3; ++s)
if (m[i][j][k][s] == '.') m[i][j][k][s] = '!';
}
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) printf("%s ", m[i][k][j]);
printf("\n");
}
printf("\n");
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int h1, m1, s1, h2, m2, s2, t[4];
for(int i = 0; i < 3;i++){
cin>>h1>>m1>>s1>>h2>>m2>>s2;
t[i] = (h2 * 3600 + m2 * 60 + s2) - (h1 * 3600 + m1 * 60 + s1);
}
for(int i = 0; i < 3; i++){
cout<<(t[i]/3600)<<" "<<((t[i]%3600)/60)<<" "<<((t[i]%3600)%60)<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
#define MAX 5000
#define MOD 1000000007
ll solve(ll level,ll X){
if(X==0){
return 0;
}
if(X==((1ull<<(level+2))-3)){
return (1ull<<(level+1))-1;
}
ll x=(1ull<<(level+1))-1;
if(X<x){
return solve(level-1,X-1);
}else if(X>x){
return (1ull<<level)+solve(level-1,X-x);
}else{
return 1ull<<(level);
}
}
int main(){
ll N,X;
cin>>N>>X;
cout<<solve(N,X)<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
unsigned a[2001];
int main() {
int n, k;
unsigned res = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, (a + n));
int i = n - 1;
while (i >= 0) {
res += (a[i] - 1) * 2;
i -= k;
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double const pi = 3.1415926536;
int main() {
int n, x, y;
cin >> n >> x >> y;
if (x == n / 2 && y == n / 2) {
cout << "NO";
return (0);
;
}
if (x == n / 2 + 1 && y == n / 2 + 1) {
cout << "NO";
return (0);
;
}
if (x == n / 2 + 1 && y == n / 2) {
cout << "NO";
return (0);
;
}
if (x == n / 2 && y == n / 2 + 1) {
cout << "NO";
return (0);
;
}
cout << "YES";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> par;
long long find(long long u) {
if (u == par[u]) return u;
return par[u] = find(par[u]);
}
void tests() {
long long n;
cin >> n;
par.assign(n, 0);
for (long long i = 0; i < n; i++) par[i] = i;
vector<pair<long long, long long> > a(n);
for (long long i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
if (a[i].first == a[j].first || a[i].second == a[j].second) {
long long x = find(i), y = find(j);
par[y] = x;
}
}
}
set<long long> s;
for (long long i = 0; i < n; i++) s.insert(find(i));
cout << s.size() - 1 << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
tests();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 10;
int N, M, S[MAX_N];
vector<int> tours[MAX_N];
vector<int> end_with[2];
vector<int> parity_last[2][2];
void init() {
char _S[MAX_N];
scanf("%s", _S + 1);
N = strlen(_S + 1);
for (int i = 1; i <= N; i++) S[i] = _S[i] == 'R';
}
void partition() {
for (int i = 1; i <= N; i++) {
if (end_with[S[i] ^ 1].empty()) {
end_with[S[i] ^ 1].push_back(++M);
}
int t = end_with[S[i] ^ 1].back();
end_with[S[i] ^ 1].pop_back();
tours[t].push_back(i);
end_with[S[i]].push_back(t);
}
for (int i = 1; i <= M; i++) {
parity_last[tours[i].size() & 1][S[tours[i].back()]].push_back(i);
}
}
void adjust() {
if (M == 1) return;
if (!parity_last[1][0].empty() || !parity_last[1][1].empty()) return;
if (parity_last[0][0].empty() || parity_last[0][1].empty()) return;
int a = parity_last[0][0].back(), b = parity_last[0][1].back();
parity_last[0][0].pop_back();
parity_last[0][1].pop_back();
if (tours[a].front() < tours[b].front()) {
tours[b].insert(tours[b].begin(), tours[a].front());
tours[a].erase(tours[a].begin());
} else {
tours[a].insert(tours[a].begin(), tours[b].front());
tours[b].erase(tours[b].begin());
}
parity_last[1][0].push_back(a);
parity_last[1][1].push_back(b);
}
void print(vector<int> v) {
for (int i : v) {
printf("%d ", i);
}
}
void construct() {
int curr = -1;
if (parity_last[1][0].size() != parity_last[1][1].size()) {
curr = parity_last[1][1].size() > parity_last[1][0].size();
} else {
curr = parity_last[0][0].size() > parity_last[0][1].size();
}
printf("%d\n", M - 1);
while (!parity_last[0][curr ^ 1].empty()) {
print(tours[parity_last[0][curr ^ 1].back()]);
parity_last[0][curr ^ 1].pop_back();
}
while (!parity_last[1][curr].empty()) {
print(tours[parity_last[1][curr].back()]);
parity_last[1][curr].pop_back();
while (!parity_last[0][curr].empty()) {
print(tours[parity_last[0][curr].back()]);
parity_last[0][curr].pop_back();
}
curr ^= 1;
}
printf("\n");
}
int main() {
init();
partition();
adjust();
construct();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int64_t DESPACITO = 2e18;
const int INF = 2e9, MOD = 1e9 + 7;
const int N = 2e5 + 5;
int indeg[N];
struct DSU {
int n, components;
vector<int> data, rootID, roots;
DSU(int n)
: n(n),
components(n),
data(vector<int>(n + 1, -1)),
rootID(vector<int>(n + 1, -1)) {}
int par(int x) { return data[x] < 0 ? x : data[x] = par(data[x]); }
int SZ(int x) { return -data[par(x)]; }
bool merge(int x, int y) {
x = par(x);
y = par(y);
if (x == y) return false;
if (-data[x] < -data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
components--;
return true;
}
void getRoots() {
int cnt = 0;
for (int i = 0; i < n; i++) {
if (data[i] >= 0) continue;
rootID[i] = cnt++;
roots.emplace_back(i);
}
assert(cnt == components);
}
};
int32_t main() {
cin.tie(nullptr)->sync_with_stdio(false);
int i, n, m, ans = 0;
cin >> n >> m;
vector<vector<int>> g(n);
DSU d(n);
for (i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
d.merge(--u, --v);
g[u].emplace_back(v);
indeg[v]++;
}
d.getRoots();
vector<vector<int>> components(d.components);
for (i = 0; i < n; i++) components[d.rootID[d.par(i)]].emplace_back(i);
auto topsort = [&](vector<int>& nodes) {
queue<int> q;
int size = 0;
for (auto& u : nodes)
if (!indeg[u]) q.push(u);
while (!q.empty()) {
auto v = q.front();
q.pop();
size++;
for (auto& x : g[v])
if (!--indeg[x]) q.push(x);
}
return int(nodes.size()) - (size == int(nodes.size()));
};
for (auto& v : components) ans += topsort(v);
cout << ans << '\n';
}
| 2 |
#include <iostream>
#include <vector>
using namespace std;
void show_vec(vector<string> &vec){
int N = vec.size();
for(int i=0; i<N; ++i){
cout << vec[i];
if(i < N-1){
cout << " ";
}
}
cout << endl;
}
int main(){
string temp;
int N;
cin >> N;
vector <string> data1(N), data2(N);
vector<int> keep_num;
// Input
for(int i=0; i<N; ++i){
cin >> data1[i];
data2[i] = data1[i];
}
// Bubble Sort
for(int i=0; i<N; ++i){
for(int j=N-1; i+1<=j; --j){
if(data1[j][1] < data1[j-1][1]){
temp = data1[j];
data1[j] = data1[j-1];
data1[j-1] = temp;
}
}
}
// Selection Sort
int minj;
for(int i=0; i<N; ++i){
minj = i;
for(int j=i; j<N; ++j){
if(data2[j][1] < data2[minj][1]){
minj = j;
}
}
temp = data2[i];
data2[i] = data2[minj];
data2[minj] = temp;
}
// Judge
show_vec(data1);
cout << "Stable" << endl; //bubble sort is stable
show_vec(data2);
for(int i=0; i<N; ++i){
if(data1[i][0] != data2[i][0]){
cout << "Not stable" << endl;
return 0;
}
}
cout << "Stable" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
long long gcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0, y = 1;
return b;
}
long long x1, y1;
long long d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long inv(long long a) {
long long x, y;
gcd(a, MOD, x, y);
return (x % MOD + MOD) % MOD;
}
long long fact(long long a) {
long long res = 1;
for (long long i = 2; i <= a; ++i) res = res * i % MOD;
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n;
cin >> n;
long long powerP = 0, powerX = 0, count = 1;
bool flagBW = false, flagWB = false;
for (long long i = 0; i < n; ++i) {
string d;
cin >> d;
if (d == "BB" || d == "WW") count = 0;
if (d == "BB")
powerX += 2;
else if (d == "BW") {
++powerX;
flagBW = true;
} else if (d == "WB") {
++powerX;
flagWB = true;
} else if (d == "??") {
powerP += 2;
count = 2 * count % MOD;
} else if (d != "WW") {
if (d.find('B') != -1) {
++powerP;
++powerX;
d[d.find('?')] = 'W';
} else {
++powerP;
d[d.find('?')] = 'B';
}
if (d == "BW")
flagBW = true;
else
flagWB = true;
}
}
long long k = n - powerX;
if (k < 0 || powerP < k)
cout << 0;
else {
long long ans =
(fact(powerP) * inv(fact(k)) % MOD) * inv(fact(powerP - k)) % MOD;
if (count > 0) ans = (ans - count + !flagBW + !flagWB + MOD) % MOD;
cout << ans;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
long long ans = 100000000;
for (int x = 1; x <= n; x++) {
int elc = 0;
for (int i = 1; i <= n; i++) {
if (x >= i)
elc += 4 * (x - 1) * a[i];
else
elc += 4 * (i - 1) * a[i];
}
ans = ans > elc ? elc : ans;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int T, N;
char S[300007], p[300007];
int End[300007], ans[300007], length[300007], num[300007];
vector<int> Spot[300007];
set<int> mch[300007];
queue<int> q;
struct State {
int next[26];
int fail, cnt;
} Tree[300007];
struct Aho {
int Size;
void init() {
Size = 1;
while (!q.empty()) q.pop();
memset(End, 0, sizeof(End));
for (int i = 0; i < 300007; i++) ans[i] = 1e9;
for (int i = 0; i < 300007; i++) {
memset(Tree[i].next, 0, sizeof(Tree[i].next));
Tree[i].fail = Tree[i].cnt = 0;
}
}
void Add_string(char *S, int id, int tot) {
int L = strlen(S);
length[id] = L;
int now = 0;
for (int i = 0; i < L; i++) {
char c = S[i];
if (!Tree[now].next[c - 'a']) Tree[now].next[c - 'a'] = Size++;
now = Tree[now].next[c - 'a'];
}
Tree[now].cnt++;
End[now] = id;
num[id] = tot;
}
void GetFail() {
int now = 0;
Tree[now].fail = -1;
q.push(now);
while (!q.empty()) {
now = q.front();
q.pop();
for (int i = 0; i < 26; i++) {
int to = Tree[now].next[i];
if (to) {
if (Tree[to].cnt) mch[to].insert(to);
if (now == 0)
Tree[to].fail = 0;
else {
int pos = Tree[now].fail;
while (pos != -1) {
if (Tree[pos].next[i]) {
Tree[to].fail = Tree[pos].next[i];
for (set<int>::iterator it = mch[Tree[to].fail].begin();
it != mch[Tree[to].fail].end(); it++) {
mch[to].insert(*it);
}
break;
}
pos = Tree[pos].fail;
}
if (pos == -1) Tree[to].fail = 0;
}
q.push(to);
}
}
}
}
void match(char *S) {
int L = strlen(S);
int now = 0;
for (int i = 0; i < L; i++) {
char c = S[i];
if (Tree[now].next[c - 'a'])
now = Tree[now].next[c - 'a'];
else {
int pos = Tree[now].fail;
while (pos != -1 && Tree[pos].next[c - 'a'] == 0) pos = Tree[pos].fail;
if (pos == -1)
now = 0;
else
now = Tree[pos].next[c - 'a'];
}
int temp = now;
for (set<int>::iterator it = mch[now].begin(); it != mch[now].end();
it++) {
int id = End[*it];
Spot[id].push_back(i);
if (Spot[id].size() >= num[id] && num[id] > 0) {
int last = Spot[id].size() - 1;
ans[id] = min(ans[id], Spot[id][last] - Spot[id][last - num[id] + 1] +
length[id]);
}
}
}
for (int i = 1; i <= N; i++) {
if (ans[i] == 1e9)
cout << -1 << endl;
else
cout << ans[i] << endl;
}
}
} aho;
int main() {
std::ios::sync_with_stdio(false);
T = 1;
while (T--) {
aho.init();
cin >> S;
cin >> N;
for (int i = 0; i < N; i++) {
int num;
cin >> num;
cin >> p;
aho.Add_string(p, i + 1, num);
}
aho.GetFail();
aho.match(S);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int N = 1000005;
int n, m, typ, o1, o2, h[N], nxt[N], adj[N], x[N], y[N], t, rd[N], q[N], sz[N];
bool tag[N];
inline void topo() {
register int top, top1, top2;
top1 = top2 = 0;
for (register int i = 1; i <= n; ++i)
if (!rd[i]) q[++top2] = i;
while (top1 < top2) {
top = q[++top1];
if (top1 == top2) sz[top] += n - top2;
if (top1 + 1 == top2) {
register bool flag = 0;
for (register int i = h[q[top2]]; i; i = nxt[i])
if (rd[adj[i]] == 1) {
flag = 1;
break;
}
flag ? tag[top] = 1 : sz[top] += n - top2;
}
for (register int i = h[top]; i; i = nxt[i])
if (!--rd[adj[i]]) q[++top2] = adj[i];
}
}
int main() {
scanf("%d%d", &n, &m);
register int i;
auto add = [&](const int u, const int v) {
nxt[++t] = h[u], h[u] = t, adj[t] = v, ++rd[v];
};
for (i = 1; i <= m; ++i) scanf("%d%d", &x[i], &y[i]), add(x[i], y[i]);
for (topo(), i = 1; i <= n; ++i) h[i] = rd[i] = 0;
t = 0;
for (i = 1; i <= m; ++i) add(y[i], x[i]);
for (topo(), i = 1; i <= n; ++i)
if (!tag[i]) o1 += (sz[i] >= n - 1), o2 += (sz[i] >= n - 2);
printf("%d", o2);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long Inf = 1e10;
const int N = 100005;
const int P = 1000000007;
int IN() {
int x = 0;
int f = 0, ch = 0;
for ((ch = getchar()); ch < 48 || ch > 57; (ch = getchar())) f = (ch == '-');
for (; ch >= 48 && ch <= 57; (ch = getchar()))
x = (x << 1) + (x << 3) + ch - 48;
return f ? (-x) : x;
}
int Pow(int x, int y, int p) {
int A = 1;
for (; y; y >>= 1, x = (long long)x * x % p)
if (y & 1) A = (long long)A * x % p;
return A;
}
int u[2005][1005], n, m, c, ans;
int col[2005][2005], D[N];
vector<pair<int, int> > ord, que;
void solve(pair<int, int> e) {
int a = e.first, b = e.second;
for (int c = (int)1; c <= (int)ans; c++) {
if (!u[a][c] && !u[b][c]) {
u[a][c] = b;
u[b][c] = a;
col[a][b] = col[b][a] = c;
return;
}
}
for (int c = (int)1; c <= (int)ans; c++) {
if (!u[a][c]) {
int d = u[b][c];
if (d) {
u[d][c] = 0;
u[b][c] = 0;
que.push_back(make_pair(b, d));
}
solve(e);
return;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &c);
for (int i = (int)1; i <= (int)c; i++) {
int X = IN(), Y = IN();
ord.push_back(make_pair(X, Y + n));
que.push_back(make_pair(X, Y + n));
D[X]++, D[Y + n]++;
}
for (int i = (int)1; i <= (int)n + m; i++) ans = max(ans, D[i]);
while (que.size()) {
auto i = que.back();
que.pop_back();
solve(i);
}
printf("%d\n", ans);
for (auto i : ord) printf("%d ", col[i.first][i.second]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,m;
cin>>n>>m;
int h=0;
int g=1000000000;
for(int i=0;i<m;i++){
int a,s;
cin>>a>>s;
h=max(h,a);
g=min(g,s);
}
if(h>g){
cout<<0<<endl;
}
else{
cout<<g-h+1<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, a[200005];
ll ans;
int main() {
cin >> n;
for (int i=0; i<n; i++) cin >> a[i];
sort(a, a+n, greater<int>());
for (int i=0; i<n-1; i++) ans+=a[(i+1)/2];
cout << ans;
} | 0 |
#pragma GCC target ("avx2")
#pragma GCC optimize ("O3")
#pragma GCC optimize ("unroll-loops")
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
void __print(bool x) {cerr << (x ? "true" : "false");}void __print(int x) {cerr << x;} void __print(long x) {cerr << x;} void __print(long long x) {cerr << x;} void __print(unsigned x) {cerr << x;} void __print(unsigned long x) {cerr << x;} void __print(unsigned long long x) {cerr << x;} void __print(float x) {cerr << x;} void __print(double x) {cerr << x;} void __print(long double x) {cerr << x;} void __print(char x) {cerr << '\'' << x << '\'';} void __print(const char *x) {cerr << '"' << x << '"';} void __print(const string &x) {cerr << '"' << x << '"';} template<typename T, typename V> void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} template<typename T> void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} void _print() {cerr << "]\n";} template <typename T, typename... V> void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define D(x...) cerr << "[" << #x << "] = ["; _print(x);
#else
#define D(x...)
#endif
typedef long long int ll;
typedef long double ld;
typedef pair<ll, ll> pl;
typedef vector<ll> vl;
#define oset tree<ll, null_type, less<>, rb_tree_tag,tree_order_statistics_node_update>
#define F(i, start, end) for(ll i = (start); i < (end); ++i)
#define FD(i, start, end) for(ll i = (start-1); i >= (end); --i)
#define A(x) (x).begin(), (x).end()
#define G(x) ll x; cin >> x;
#define K first
#define V second
#define tr(x, v) for (auto x : v)
#define MULT G(T) while(T--)
ll MOD = 998244353; // 1000000007;
pair<ll, ll> dir[4] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
ll inv(ll a, ll b){return 1<a ? b - inv(b%a,a)*b/a : 1;}
#define NN
int main() {
ios_base::sync_with_stdio(false); cin.tie(nullptr);
MULT {
G(n) G(k)
vl a(n);
F(i,0,n) cin >> a[i];
vl p(n);
partial_sum(A(a), p.begin());
ll mn = 0;
F(i,1,n) mn = max(mn, (ll)roundl(ceill(100. * a[i] / k)) - p[i-1]);
cout << mn << '\n';
};
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool f[10000005];
int main() {
int n;
cin >> n;
memset(f, true, sizeof(f));
f[1] = false;
for (int i = 2; i * i <= 10000000; i++) {
if (f[i] == false) continue;
int j = i * i;
while (j <= 10000000) {
f[j] = false;
j += i;
}
}
for (int i = 2; i <= 10000000; i++) {
if (f[i] == true) {
n--;
cout << i << " ";
if (n == 0) return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int no_of_elements;
scanf("%d", &no_of_elements);
vector<int> element(no_of_elements);
for (int i = 0; i < no_of_elements; i++) scanf("%d", &element[i]);
sort((element).begin(), (element).end());
if (no_of_elements == 1) {
printf("%d", element[0] == 1 ? 2 : 1);
return 0;
}
printf("1 ");
for (int i = 1; i < no_of_elements - 1; i++) printf("%d ", element[i - 1]);
if (element[no_of_elements - 1] == 1)
printf("2");
else
printf("%d", element[no_of_elements - 2]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
namespace std {
bool operator<(const complex<int> &c1, const complex<int> &c2) {
if (c1.imag() == c2.imag()) {
return c1.real() < c2.real();
} else {
return c1.imag() < c2.imag();
}
}
} // namespace std
double cross_product(complex<int> a, complex<int> b) {
return (conj(a) * b).imag();
}
bool is_in(complex<int> a, complex<int> b, complex<int> p) {
return (cross_product(b - a, p - a) >= 0);
}
int n;
vector<complex<int>> make_frame(vector<complex<int>> P){
vector<complex<int>> ans;
for (int i = 0; i < n; i++) {
while (ans.size() > 1 &&
!is_in(ans[ans.size() - 2],
ans[ans.size() - 1], P[i])) {
ans.pop_back();
}
ans.push_back(P[i]);
}
return ans;
}
int main() {
cin >> n;
vector<complex<int>> P(n);
vector<complex<int>> ans_right;
vector<complex<int>> ans_left;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
P[i] = complex<int>(x, y);
}
sort(P.begin(), P.end());
ans_right = make_frame(P);
reverse(P.begin(), P.end());
ans_left = make_frame(P);
cout << ans_right.size() + ans_left.size() -2 << endl;
for (int i = 0; i < ans_right.size() - 1; i++)
cout << ans_right[i].real() << ' ' << ans_right[i].imag() << endl;
for (int i = 0; i < ans_left.size() - 1; i++)
cout << ans_left[i].real() << ' ' << ans_left[i].imag() << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int Pow(long long int B, long long int P) {
long long int R = 1;
while (P > 0) {
if (P % 2 == 1) R = (R * B);
P /= 2;
B = (B * B);
}
return R;
}
int BigMod(long long int B, long long int P, long long int M) {
long long int R = 1;
while (P > 0) {
if (P % 2 == 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return (int)R;
}
int prime[90000];
bool flag[1010];
int sieve() {
int i, j, total = 0, val;
val = sqrt(1010) + 1;
flag[0] = flag[1] = 1;
for (i = 2; i < val; i++)
if (!flag[i])
for (j = i; j * i <= 1010; j++) flag[i * j] = 1;
for (i = 2; i <= 1010; i++)
if (!flag[i]) prime[total++] = i;
return total;
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / (gcd(a, b)));
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
int main() {
int i, j, f;
string str;
while (cin >> str) {
f = 1;
for (i = 0, j = (int)str.size() - 1; i <= (int)str.size() / 2; i++, j--) {
if (str[i] != str[j] ||
str[i] != 'A' && str[i] != 'H' && str[i] != 'I' && str[i] != 'M' &&
str[i] != 'O' && str[i] != 'T' && str[i] != 'U' &&
str[i] != 'V' && str[i] != 'W' && str[i] != 'X' &&
str[i] != 'Y' && str[j] != 'A' && str[j] != 'H' &&
str[j] != 'I' && str[j] != 'M' && str[j] != 'O' &&
str[j] != 'T' && str[j] != 'U' && str[j] != 'V' &&
str[j] != 'W' && str[j] != 'X' && str[j] != 'Y') {
f = 0;
break;
}
}
if (!f)
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 100;
const int MOD = 998244353;
string s;
struct Graph {
bool bipartite;
int color[N];
int n;
struct Edge {
int u, v, same;
Edge(int u = 0, int v = 0, int same = 0) : u(u), v(v), same(same){};
int nxt(int x) { return x ^ u ^ v; }
};
vector<Edge> adj[N];
void addEdge(int u, int v, int same) {
adj[u].push_back({u, v, same});
adj[v].push_back({u, v, same});
}
void dfs(int u) {
if (!bipartite) return;
for (auto &edge : adj[u]) {
int v = edge.nxt(u);
if (color[v]) {
if (edge.same && color[v] != color[u]) {
bipartite = false;
return;
}
if (!edge.same && color[v] == color[u]) {
bipartite = false;
return;
}
continue;
}
if (edge.same)
color[v] = color[u];
else
color[v] = 3 - color[u];
dfs(v);
}
}
void initial(int nv, int lens) {
n = 2 * lens;
bipartite = true;
memset(color, 0, sizeof color);
for (int i = 1; i <= n; ++i) adj[i].clear();
for (int i = nv + 1; i <= lens; ++i) {
color[i + lens] = 1;
if (s[i] == '1') color[i] = 2;
if (s[i] == '0') color[i] = 1;
}
color[nv + lens] = color[lens] = 2;
for (int i = 1; i <= lens / 2; ++i) addEdge(i, lens - i + 1, 1);
for (int i = 1; i <= nv / 2; ++i) addEdge(i + lens, nv - i + 1 + lens, 1);
for (int i = 1; i <= nv; ++i)
if (s[i] == '?')
continue;
else
addEdge(i, i + lens, (s[i] == '0'));
for (int i = 1; i <= n; ++i)
if (color[i]) dfs(i);
}
long long px(int n) {
if (n == 0) return 1;
long long tmp = px(n >> 1);
tmp = (tmp * tmp) % MOD;
if (n & 1) tmp = (tmp + tmp) % MOD;
return tmp;
}
long long ways() {
long long comp = 0;
for (int i = 1; i <= n; ++i)
if (!color[i]) {
color[i] = 1;
dfs(i);
comp++;
}
if (!bipartite) return 0;
return px(comp);
}
} graph;
int main() {
cin >> s;
reverse(s.begin(), s.end());
int n = s.size();
s = ' ' + s;
long long rez = 0;
for (int i = 1; i <= n; ++i) {
graph.initial(i, n);
long long ways = graph.ways();
rez = (rez + ways) % MOD;
}
cout << rez;
}
| 4 |
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
const int mod=1000000007;
int fpow(int x,int y)
{
if(y==0)
return 1;
int ret=fpow(x,y>>1);
ret=(long long)ret*ret%mod;
if(y&1)
ret=(long long)ret*x%mod;
return ret;
}
int q[10101],qn;
int f[10101];
int main()
{
int n,k;
int ans=0;
scanf("%d%d",&n,&k);
qn=0;
for(int i=1;i*i<=n;i++)
if(n%i==0)
{
q[++qn]=i;
if(i*i!=n)
q[++qn]=n/i;
}
sort(q+1,q+1+qn);
for(int i=1;i<=qn;i++)
{
f[i]=fpow(k,(q[i]+1)>>1);
for(int j=1;j<i;j++)
if(q[i]%q[j]==0)
(f[i]+=mod-f[j])%=mod;
}
for(int i=1;i<=qn;i++)
if(q[i]&1)
ans=((long long)f[i]*q[i]+ans)%mod;
else
ans=((long long)f[i]*q[i]/2+ans)%mod;
printf("%d",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
int n, r;
long long a[maxn], b[maxn], S;
int base[70];
void Gauss() {
for (int i = 1; i <= n; i++) {
for (int j = 60; j >= 0; j--) {
if (a[i] >> j & 1) {
if (!base[j]) {
base[j] = i;
r++;
break;
} else
a[i] ^= a[base[j]];
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d %I64d", &a[i], &b[i]);
S ^= a[i];
a[i] ^= b[i];
}
Gauss();
for (int i = 60; i >= 0; i--) {
if (S >> i & 1) {
S ^= a[base[i]];
}
}
if (S) {
printf("1/1\n");
} else {
printf("%I64d/%I64d\n", (1ll << r) - 1, (1ll << r));
}
}
| 1 |
#include <iostream>
using namespace std;
int res[200000];
int main(){
int n,en;
cin>>n;
for(int i=1;i<n;i++){
cin>>en;
en--;
res[en]++;
}
for(int i=0;i<n;i++)cout<<res[i]<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long a, b, c, p, q;
cin >> a;
if (a == 1 || a == 2) {
cout << -1;
return 0;
}
if (a % 2 == 1) {
b = (a * a - 1) / 2;
c = b + 1;
} else {
p = a / 2;
q = 1;
b = p * p - q * q;
c = p * p + q * q;
}
if (b > 1000000000000000000 || c > 1000000000000000000) cout << 5 / 0;
cout << b << " " << c;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
char str[1000][1000], str1[] = "bcdfghjklmpqrstvwxyz";
int i, j, k, c = 0, s = 0;
scanf("%s", str[0]);
for (i = 0; i < strlen(str[0]); i++) {
for (j = 0; j < strlen(str1); j++) {
if (str[0][i] == str1[j]) {
s = s + 1;
if (str[0][i + 1] == 'a' || str[0][i + 1] == 'e' ||
str[0][i + 1] == 'i' || str[0][i + 1] == 'o' ||
str[0][i + 1] == 'u') {
c = c + 1;
}
}
}
}
if (s == c) {
printf("YES");
} else {
printf("NO");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int modular_pow(long long int base, long long int exponent,
int modulus) {
long long int result = 1;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % modulus;
exponent = exponent >> 1;
base = (base * base) % modulus;
}
return result;
}
long long int mo[2][101] = {0};
int main() {
mo[1][0] = 1;
long long int n, k1, m, sol = 0;
cin >> n >> k1 >> m;
int i, x = 0, j, k, y, m1;
for (i = 0; i < n - 1; i++) {
m1 = modular_pow(10, i, k1);
for (j = 0; j < 10; j++) {
y = ((j % k1) * m1) % k1;
for (k = 0; k < k1; k++) {
mo[x][(k + y) % k1] += mo[!x][k];
mo[x][(k + y) % k1] %= m;
}
}
sol += ((mo[x][0] - 1) * 9 * modular_pow(10, n - i - 2, m)) % m;
sol = sol % m;
mo[x][0] = 1;
for (k = 0; k < k1; k++) {
mo[!x][k] = 0;
}
x = x ^ 1;
}
m1 = modular_pow(10, n - 1, k1);
for (j = 1; j < 10; j++) {
y = ((j % k1) * m1) % k1;
for (k = 0; k < k1; k++) {
mo[x][(k + y) % k1] += mo[!x][k];
mo[x][(k + y) % k1] %= m;
}
}
sol += mo[x][0] % m;
while (sol < 0) sol += m;
cout << sol % m << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
const int lg = 21;
int a[N];
int dp[N][lg];
int last[lg];
int n, q;
bool query(int x, int y) {
int r = 0;
for (int k = 0; k < lg; k++) {
if ((a[x] >> k) & 1) {
r = max(r, dp[y][k]);
}
}
return r >= x;
}
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
for (int k = 0; k < lg; k++) {
if ((a[i] >> k) & 1) dp[i][k] = i;
for (int p = 0; p < lg; p++) {
if ((a[i] >> p) & 1) {
dp[i][k] = max(dp[i][k], dp[last[p]][k]);
}
}
}
for (int k = 0; k < lg; k++) {
if ((a[i] >> k) & 1) {
last[k] = i;
}
}
}
while (q--) {
int x, y;
cin >> x >> y;
if (query(x, y)) {
puts("Shi");
} else {
puts("Fou");
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
int a[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
bool possible = true;
for (int i = m - 2; i > 0; i--) {
for (int j = n - 2; j > 0; j--) {
int amin = min(a[i][j + 1], a[i + 1][j]);
int amax = max(a[i][j - 1], a[i - 1][j]);
if (a[i][j] != 0) {
if (a[i][j] > amax && a[i][j] < amin)
;
else {
possible = false;
break;
}
} else {
if (amax < amin - 1) {
a[i][j] = amin - 1;
} else {
possible = false;
break;
}
}
}
if (possible == false) break;
}
int sum = 0;
if (possible == false)
cout << -1 << endl;
else {
for (int i = 0; i < m; i++) {
for (int j = 0; j < n - 1; j++) {
if (a[i][j] < a[i][j + 1])
;
else {
possible = false;
break;
}
}
if (possible == false) break;
}
if (possible == false)
cout << -1 << endl;
else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m - 1; j++) {
if (a[j][i] < a[j + 1][i])
;
else {
possible = false;
break;
}
}
if (possible == false) break;
}
if (possible == false)
cout << -1 << endl;
else {
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
sum += a[i][j];
}
}
cout << sum << endl;
}
}
}
}
| 3 |
#include<iostream>
using namespace std;
int main()
{
int a,b;
cin>>a>>b;
b=b-1;
a=a-1;
if(b%a==0) cout<<b/a;
else cout<<(b/a)+1;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
inline int addmod(int x, int y) {
return (x % 1000000007 + y % 1000000007) % 1000000007;
}
inline int submod(int x, int y) {
return (x % 1000000007 - y % 1000000007 + 1000000007) % 1000000007;
}
inline int mulmod(int x, int y) {
return (x % 1000000007 * 1LL * y % 1000000007) % 1000000007;
}
inline int nextSubMask(int i, int mask) { return (i - 1) & mask; }
void we_r_done() {
cout << "NO";
exit(0);
}
void debug(bool ok, string mssg) {
if (ok) return;
cout << mssg;
exit(0);
}
struct Operation {
string name;
int pos;
char c;
Operation(string n, int p, char cc) {
name = n;
pos = p;
c = cc;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
s = "$" + s;
t = "$" + t;
int dp[n + 1][m + 1];
dp[0][0] = 0;
for (int j = 1; j <= m; j++) {
dp[0][j] = j;
for (int i = 1; i <= n; i++) {
dp[i][0] = i;
if (s[i] == t[j]) {
dp[i][j] = dp[i - 1][j - 1];
} else {
dp[i][j] = min(dp[i - 1][j - 1], min(dp[i][j - 1], dp[i - 1][j])) + 1;
}
}
}
stack<Operation> stk;
for (int i = n, j = m; i || j;) {
if (s[i] == t[j]) {
j--;
i--;
} else if (i && j && dp[i][j] == dp[i - 1][j - 1] + 1) {
stk.push(Operation("REPLACE", i, t[j]));
j--;
i--;
} else if (i && dp[i][j] == dp[i - 1][j] + 1) {
stk.push(Operation("DELETE", i, '#'));
i--;
} else if (j && dp[i][j] == dp[i][j - 1] + 1) {
stk.push(Operation("INSERT", i + 1, t[j]));
j--;
} else
break;
}
int now = 0;
assert(dp[n][m] == stk.size());
cout << stk.size() << endl;
while (stk.size()) {
Operation op = stk.top();
stk.pop();
cout << op.name << " " << op.pos + now;
if (op.name != "DELETE") cout << " " << op.c;
cout << endl;
if (op.name[0] == 'D')
now--;
else if (op.name[0] == 'I')
now++;
}
assert(stk.size() == 0);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void oj() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
map<long long, long long> mp;
long long maxi = -1, start = -1;
for (long long i = 0; i < n; i++) {
cin >> v[i];
mp[v[i]] = 1 + mp[v[i] - 1];
if (mp[v[i]] > maxi) {
maxi = mp[v[i]];
start = v[i];
}
}
cout << maxi << "\n";
start = start - maxi + 1;
for (long long i = 0; i < n; i++) {
if (v[i] != start) continue;
cout << i + 1 << " ";
start++;
}
}
signed main() {
oj();
solve();
return 0;
}
| 6 |
//#pragma GCC optimize(2)
#include<cstdio>
#define L 1<<23
#define C (c=*A++)
#define ENS //__attribute__((optimize("-O2")))
#define NES //__attribute__((optimize("-O2"))) __inline__ __attribute__((always_inline))
#define N 1000001
int MAPLE,n,l[N],r[N],cnt,last,wt,ss[19];char fl[L],*A=fl,s[N],t[N];bool fg=true;
NES void read(int&x){char c;for(x=0;'0'>C||c>'9';);while('0'<=c&&c<='9')x=(x<<3)+(x<<1)+c-48,C;}NES void print(int x){if(!x)putchar(48);else{for(wt=0;x;ss[++wt]=x%10,x/=10);for(;wt;putchar(ss[wt--]+48));}}
ENS int main()
{int i,j;char c;
for(fl[fread(fl,1,L,stdin)]=EOF,read(n);'a'>C||c>'z';);for(i=1;i<=n;s[i]=c,C,i++);while('a'>C||c>'z');for(i=1;i<=n;t[i]=c,C,i++);
for(last=i=n,j=n+1;i;fg&=s[i]==t[i],i--)
if(t[i]!=t[i-1])
{if((--j)>i)j=i;
for(;j&&s[j]!=t[i];j--);if(!j)return puts("-1"),0;
l[++cnt]=j,r[cnt]=last,last=i-1;
}if(fg)return puts("0"),0;for(l[0]=n+1,i=1;i<=cnt;i++)for(;l[i-MAPLE]<r[i]+MAPLE;MAPLE++);print(MAPLE);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long p, long long m) {
long long r = 1;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
const int MaxN = 5e3 + 555;
const long long INF = 1e9 + 10;
const long long MOD = 1e9 + 7;
int n, a, b, k, dp[MaxN][MaxN], sum[MaxN];
void f(int i) {
for (int j = 1; j <= n; j++) sum[j] = (sum[j - 1] + dp[i][j]) % MOD;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> b >> k;
for (int i = 1; i <= n; i++) dp[0][i] = 1;
f(0);
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= n; j++) {
int dist = abs(j - b) - 1;
int r = min(n, j + dist), l = max(1, j - dist);
if (j != b)
dp[i][j] = (1LL * sum[r] - sum[l - 1] - dp[i - 1][j] + 2 * MOD) % MOD;
}
f(i);
}
cout << dp[k][a];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 22, INF = INT_MAX >> 1;
int n, m, a[Maxn][Maxn], d[1 << Maxn];
char s[Maxn][Maxn];
int findlowzero(int x) {
int i;
for (i = 0; i < Maxn; i++)
if (!((x >> i) & 1)) return i;
return 19;
}
int main(int argc, const char* argv[]) {
ios::sync_with_stdio(0);
int i, j, k;
cin >> n >> m;
for (i = 0; i < n; i++) cin >> s[i];
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) cin >> a[i][j];
int Max = 1 << n;
for (i = 1; i < Max; i++) d[i] = INF;
for (i = 0; i < Max; i++) {
int tmp = findlowzero(i);
for (j = 0; j < m; j++) {
d[i | (1 << tmp)] = min(d[i | (1 << tmp)], d[i] + a[tmp][j]);
int sum = 0, mx = 0, bits = 0;
for (k = 0; k < n; k++)
if (s[tmp][j] == s[k][j]) {
sum += a[k][j];
mx = max(mx, a[k][j]);
bits |= (1 << k);
}
d[i | bits] = min(d[i | bits], d[i] + sum - mx);
}
}
cout << d[(1 << n) - 1] << endl;
return 0;
}
| 5 |
#include<iostream>
using namespace std;
int a,b,c;
int main(){
cin>>a>>b>>c;
cout<<(a-c)/(b+c)<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, k, a[N], deg[N], id[N], cnt, mi[N], mx[N], ans[N];
bool used[N];
vector<int> g[N], r[N];
vector<pair<int, int> > v[N];
queue<int> q;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i])
used[mx[i] = mi[i] = a[i]];
else {
mx[i] = k;
mi[i] = 1;
}
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
r[v].push_back(u);
deg[v]++;
}
for (int i = 1; i <= n; i++)
if (!deg[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
id[++cnt] = u;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!(--deg[v])) q.push(v);
}
}
if (cnt < n) {
cout << "-1\n";
return 0;
}
for (int it = n, i; it; it--) {
i = id[it];
for (int j = 0; j < g[i].size(); j++) mi[i] = max(mi[i], mi[g[i][j]] + 1);
}
for (int it = 1, i; it <= n; it++) {
i = id[it];
for (int j = 0; j < r[i].size(); j++) mx[i] = min(mx[i], mx[r[i][j]] - 1);
}
for (int i = 1; i <= n; i++) {
if (mi[i] > mx[i]) {
cout << "-1\n";
return 0;
}
v[mi[i]].push_back(pair<int, int>(mx[i], i));
}
for (int i = 1; i <= k; i++) {
for (int j = 0; j < v[i].size(); j++) pq.push(v[i][j]);
if (!used[i]) {
if (pq.empty()) {
cout << "-1\n";
return 0;
}
ans[pq.top().second] = i;
pq.pop();
}
while (!pq.empty() && pq.top().first == i) {
ans[pq.top().second] = i;
pq.pop();
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n, k;
cin >> t;
while (t--) {
cin >> n >> k;
long long int a[n], b[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i] + k;
}
long long int *mini = min_element(b, b + n);
int flag = 0;
for (long long int i = 0; i < n; i++) {
if (abs(a[i] - (*mini)) <= k)
;
else
flag = -1;
}
if (flag == 0)
cout << *mini << "\n";
else
cout << "-1\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dfs(vector<vector<int> > &v, int node, vector<int> &val, vector<int> &a,
int parent, int psum, int d) {
int n = v[node].size();
if (d % 2 && a[node] < psum)
return 0;
else if (d % 2)
val[node] = a[node] - psum;
else {
int minimum = INT_MAX;
for (int i = 0; i < n; i++) minimum = min(minimum, a[v[node][i]] - psum);
if (minimum >= 0 && n) val[node] = minimum;
}
for (int i = 0; i < n; i++) {
if (dfs(v, v[node][i], val, a, node, psum + val[node], d + 1) == 0)
return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<vector<int> > v(n);
for (int i = 1; i <= n - 1; i++) {
int parent;
cin >> parent;
parent--;
v[parent].push_back(i);
}
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> val(n);
if (dfs(v, 0, val, a, 0, 0, 1) == 0)
cout << -1 << endl;
else {
long long int sum = 0;
for (int i = 0; i < n; i++) sum = sum + val[i];
cout << sum << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long curr_b, curr_s, curr_c;
unsigned long long b = 0, s = 0, c = 0;
unsigned long long cost_b, cost_s, cost_c, money;
bool solve(unsigned long long mid) {
unsigned long long need_b = mid * b, need_c = mid * c, need_s = mid * s;
unsigned long long temp_b = 0, temp_c = 0, temp_s = 0;
if (need_b > curr_b) temp_b = need_b - curr_b;
if (need_c > curr_c) temp_c = need_c - curr_c;
if (need_s > curr_s) temp_s = need_s - curr_s;
unsigned long long cost = temp_b * cost_b + temp_c * cost_c + temp_s * cost_s;
return (money >= cost);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string x;
cin >> x;
for (auto i = 0; i < (int)(((int)((x).size()))); i++) {
if (x[i] == 'B') b++;
if (x[i] == 'S') s++;
if (x[i] == 'C') c++;
}
cin >> curr_b >> curr_s >> curr_c;
cin >> cost_b >> cost_s >> cost_c;
cin >> money;
unsigned long long st = 0, en = 1e18, mid, ret = 0, initial = LLONG_MAX;
while (st <= en) {
mid = (st + en) / 2;
if (solve(mid)) {
st = mid + 1, ret = mid;
} else
en = mid - 1;
}
cout << ret;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int solve(int s, vector<int> ar) {
int n = ar.size();
int times = 0;
set<int> usados;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (ar[i] + ar[j] == s && i != j && (usados.find(i) == usados.end()) &&
(usados.find(j) == usados.end())) {
times++;
usados.insert(i);
usados.insert(j);
}
return times;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> pesoParticipante;
for (int m = 0; m < n; m++) {
int input;
cin >> input;
pesoParticipante.push_back(input);
}
int times = 0;
for (int s = 0; s <= 100; s++)
times = max(times, solve(s, pesoParticipante));
cout << times << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
int m_score = max(3 * a / 10, a - a * c / 250);
int v_score = max(3 * b / 10, b - b * d / 250);
if (m_score == v_score) {
cout << "Tie" << endl;
} else if (m_score > v_score) {
cout << "Misha" << endl;
} else {
cout << "Vasya" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int u = 0, l = 0, up[s.length()], lo[s.length()];
for (int i = 0; i < s.length(); i++) {
if (s[i] > 92)
l++;
else
u++;
up[i] = u;
lo[i] = l;
}
int ans = min(l, u);
for (int i = 0; i < s.length() - 1; i++) {
ans = min(ans, lo[i] + u - up[i]);
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
int n, k;
int a[1005];
int mn[405][405];
int mx[405][405];
int s[405];
int dp[55][405][405];
int get(int l, int r) {
int ret = s[r] - (l ? s[l - 1] : 0);
return ret;
}
int main() {
int n, k;
cin >> n >> k;
for (int(i) = (0); (i) < (n); ++(i)) {
cin >> a[i];
if (i) s[i] = s[i - 1];
s[i] += a[i];
}
for (int(i) = (0); (i) < (404); ++(i))
for (int(j) = (0); (j) < (404); ++(j))
for (int(q) = (0); (q) < (55); ++(q)) dp[q][i][j] = -INF;
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (i); (j) < (n); ++(j)) dp[1][i][j] = 0;
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (i); (j) < (n); ++(j)) {
mn[i][j] = mx[i][j] = i;
for (int(t) = (i); (t) < (j + 1); ++(t)) {
if (get(mn[i][j], j) > get(t, j)) mn[i][j] = t;
if (get(mx[i][j], j) < get(t, j)) mx[i][j] = t;
}
}
for (int(c) = (1); (c) < (k); ++(c))
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (i); (j) < (n); ++(j)) {
if (dp[c][i][j] < 0) continue;
int cur;
for (int(e) = (j + 1); (e) < (n); ++(e)) {
cur = mn[j + 1][e];
dp[c + 1][cur][e] = max(dp[c + 1][cur][e],
dp[c][i][j] + abs(get(cur, e) - get(i, j)));
cur = mx[j + 1][e];
dp[c + 1][cur][e] = max(dp[c + 1][cur][e],
dp[c][i][j] + abs(get(cur, e) - get(i, j)));
}
}
int ans = 0;
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (i); (j) < (n); ++(j)) ans = max(ans, dp[k][i][j]);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
cin >> t;
while (t--) {
long long int a = 0, b = 0, c = 0, d = 0, e = 0, p = 0, q = 0, r = 0;
long long int ans = 0, res = 0, cnt = 0, sum = 0, diff = 0, mul = 1,
val = 0;
string s;
long long int n = 0, m = 0, k = 0;
cin >> n;
cin >> m;
long long int all = 0, diagonal = 0;
for (long long int i = 0; i < n; i++) {
cin >> a >> b >> c >> d;
if (a == b && b == c && c == d && a == d)
all = 1;
else if (b == c)
diagonal = 1;
}
if (m % 2) {
cout << ("NO") << '\n';
} else if (m == 4 || m == 2) {
if (diagonal || all)
cout << ("YES") << '\n';
else
cout << ("NO") << '\n';
} else {
if (all)
cout << ("YES") << '\n';
else if (diagonal)
cout << ("YES") << '\n';
else
cout << ("NO") << '\n';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.x >> p.y;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.x << ' ' << p.y;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(int x) { return 8 * sizeof(int) - __builtin_clz(x); }
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.x) ^ (u(p.y) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
int n, k;
vector<vector<int>> g;
int dist[100007];
bool check(int v, int k, int p) {
if (k == 0) {
return g[v].size() == 1;
}
if (g[v].size() < 3) return false;
if (p != -1 && g[v].size() == 3) return false;
for (auto nv : g[v])
if (nv != p && !check(nv, k - 1, v)) return false;
return true;
}
bool check() {
queue<int> q;
memset(dist, -1, sizeof(dist));
for (int i = 0; i < n; ++i)
if (g[i].size() == 1) {
q.push(i);
dist[i] = 0;
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto nv : g[v]) {
if (dist[nv] == -1) {
dist[nv] = dist[v] + 1;
q.push(nv);
}
}
}
int p = -1;
for (int i = 0; i < n; ++i) {
if (dist[i] == k) p = i;
}
if (p == -1) return false;
return check(p, k, -1);
}
class TaskB {
public:
void solve(std::istream& in, std::ostream& out) {
in >> n >> k;
g.clear();
g.resize(n);
int u, v;
for (int i = 1; i < n; ++i) {
in >> u >> v;
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
if (check()) {
out << "Yes" << endl;
} else {
out << "No" << endl;
}
}
};
int main() {
TaskB solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int l = b.size();
int st = a.size() - 1;
int ar[l + 3];
memset(ar, -1, sizeof ar);
ar[l] = st + 1;
for (int i = l - 1; i >= 0; i--) {
while (st >= 0 && a[st] != b[i]) {
st--;
}
if (st >= 0) {
ar[i] = st;
st--;
} else
break;
}
int ans = 0;
int pre = 0;
for (int i = 0; i < a.size(); i++) {
int la = ar[pre];
if (la != -1) ans = max(ans, la - i);
if (pre < l && a[i] == b[pre]) {
pre++;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, h;
cin >> n >> m >> h;
vector<int> front_view;
vector<int> left_view;
for (int i = 0; i < m; i++) {
int input;
cin >> input;
front_view.push_back(input);
}
for (int i = 0; i < n; i++) {
int input;
cin >> input;
left_view.push_back(input);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int input;
cin >> input;
if (input == 1) {
cout << min(front_view[j], left_view[i]) << " ";
} else {
cout << 0 << " ";
}
}
cout << endl;
}
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main(void){
int f, c;
cin >> f;
c = (f-30)>>1;
cout << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int b[10000005];
int n, a;
long long ans;
int main() {
cin >> a >> n;
for (int i = 1; i * i <= 10 * 1000 * 1000; i++) {
int cur = i * i;
int j = 1;
while (cur * j <= a + n - 1) b[cur * j] = j++;
}
for (int i = a; i <= a + n - 1; i++) ans += b[i];
cout << ans;
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.