solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 1e4 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<ll> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
ll ans = 0;
for (int i = 0; i < n; ++i) {
ans = (ans + a[i] * a[n - i - 1]) % MOD;
}
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int SS = 4 * N;
long long n, q, k, a, b;
long long seg[SS][2];
void modif(int ind, int val, int s = 0, int e = n, int v = 1) {
if (ind < s || ind >= e) return;
if (e - s == 1) {
seg[v][0] += val, seg[v][0] = min(seg[v][0], a);
seg[v][1] += val, seg[v][1] = min(seg[v][1], b);
return;
}
int mid = (s + e) / 2;
modif(ind, val, s, mid, 2 * v);
modif(ind, val, mid, e, 2 * v + 1);
for (int i = 0; i < 2; i++) seg[v][i] = seg[2 * v][i] + seg[2 * v + 1][i];
}
long long get(int l, int r, int ind, int s = 0, int e = n, int v = 1) {
if (l >= e || r <= s) return 0;
if (l <= s && e <= r) return seg[v][ind];
int mid = (s + e) / 2;
long long res = 0;
res += get(l, r, ind, s, mid, 2 * v);
res += get(l, r, ind, mid, e, 2 * v + 1);
return res;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> a >> b >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int d, x;
cin >> d >> x;
d--;
modif(d, x);
} else {
int d;
cin >> d;
d--;
cout << get(0, d, 1) + get(d + k, n, 0) << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const char name[] = "LMW";
const int INF = 0x3f3f3f3f;
int N, W[3][30], pow3[15];
map<pair<int, int>, pair<int, int> > stor;
int main() {
pow3[0] = 1;
for (int i = 1; i < 15; i++) pow3[i] = 3 * pow3[i - 1];
while (~scanf("%d", &N)) {
stor.clear();
int hl = N >> 1, le = N - hl, ans = -INF;
long long mask = 0;
for (int i = 0; i < N; i++)
for (int j = 0; j < 3; j++) scanf("%d", &W[j][i]);
if (N == 1) {
int cnt = 0;
char res[3] = {0};
for (int i = 0; i < 3 && cnt < 2; i++)
if (!W[i][0]) res[cnt++] = name[i];
if (cnt < 2)
puts("Impossible");
else
puts(res);
continue;
}
for (int m = 0, res[3], tem; m < pow3[hl]; m++) {
tem = m;
memset(res, 0, sizeof(res));
for (int i = 0; i < hl; i++) {
for (int j = 0; j < 3; j++)
if (j != tem % 3) res[j] += W[j][i];
tem /= 3;
}
res[1] -= res[0];
res[2] -= res[0];
auto it = stor.find(pair<int, int>(res[1], res[2]));
if (it == stor.end()) {
stor.insert(make_pair(pair<int, int>(res[1], res[2]),
pair<int, int>(res[0], m)));
} else {
if (it->second.first < res[0])
it->second.first = res[0], it->second.second = m;
}
}
for (int m = 0, res[3], tem; m < pow3[le]; m++) {
tem = m;
memset(res, 0, sizeof(res));
for (int i = hl; i < N; i++) {
for (int j = 0; j < 3; j++)
if (j != tem % 3) res[j] += W[j][i];
tem /= 3;
}
res[1] -= res[0];
res[2] -= res[0];
auto it = stor.find(pair<int, int>(-res[1], -res[2]));
if (it != stor.end() && it->second.first + res[0] > ans) {
ans = it->second.first + res[0];
mask = (long long)m * pow3[hl] + it->second.second;
}
}
if (ans == -INF)
puts("Impossible");
else {
char res[3] = {0};
for (int i = 0; i < N; i++, mask /= 3, puts(res))
for (int j = 0, cnt = 0; j < 3 && cnt < 2; j++)
if (j != mask % 3) res[cnt++] = name[j];
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dp[5123][5123];
int nxt[5123][5123];
string s;
inline int add(int a, int b) {
if (a + b >= 1000000007) {
return a + b - 1000000007;
}
return a + b;
}
int main() {
int n, i, j, k, l;
cin >> n;
cin >> s;
s = s + "$";
dp[n][n] = 1;
nxt[n][n] = n;
for (i = n - 1; i >= 0; --i) {
dp[i][n] = 1;
dp[i][n + 1] = 0;
nxt[i][n] = n;
for (j = n - 1; j > i; --j) {
if (s[i] == s[j]) {
nxt[i][j] = nxt[i + 1][j + 1];
} else {
nxt[i][j] = j;
}
dp[i][j] = dp[i][j + 1];
if (s[j] == '0' || s[i] == '0') {
continue;
}
k = nxt[i][j];
l = j - i;
if (k - j + 1 <= l && k < n) {
if (s[k] > s[i + k - j]) {
dp[i][j] = add(dp[i][j], dp[j][min(n + 1, j + l)]);
continue;
}
}
dp[i][j] = add(dp[i][j], dp[j][min(n + 1, j + l + 1)]);
}
}
cout << dp[0][1] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int gcd(int m, int n) { return n ? gcd(n, m % n) : m; }
int a[1005];
int b[1005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < n; ++i) scanf("%d", &b[i]);
sort(a, a + n);
sort(b, b + n);
for (int i = 0; i < n; ++i) printf("%d ", a[i]);
cout << endl;
for (int i = 0; i < n; ++i) printf("%d ", b[i]);
cout << endl;
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
clock_t __stt;
inline void TStart() { __stt = clock(); }
inline void TReport() {
printf("\nTaken Time : %.3lf sec\n",
(double)(clock() - __stt) / CLOCKS_PER_SEC);
}
template <typename T>
T MIN(T a, T b) {
return a < b ? a : b;
}
template <typename T>
T MAX(T a, T b) {
return a > b ? a : b;
}
template <typename T>
T ABS(T a) {
return a > 0 ? a : (-a);
}
template <typename T>
void UMIN(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
void UMAX(T &a, T b) {
if (b > a) a = b;
}
char s[1000005];
bool a[1000005];
int n, sum, pr[1000005], sf[1000005];
int mnpr[1000005], mxsf[1000005];
bool ok[1000005];
namespace SA {
int n, cnt[1000005], rk[2000005], vy[1000005], ls[1000005], tmp[1000005];
void bsort() {
int i;
memset(cnt, 0, sizeof(cnt));
for (i = 0; i < n; ++i) ++cnt[vy[i]];
for (i = 1; i <= n + 3 || i <= 30; ++i) cnt[i] += cnt[i - 1];
for (i = n - 1; i >= 0; --i) tmp[--cnt[vy[i]]] = i;
memset(cnt, 0, sizeof(cnt));
for (i = 0; i < n; ++i) ++cnt[rk[tmp[i]]];
for (i = 1; i <= n + 3 || i <= 30; ++i) cnt[i] += cnt[i - 1];
for (i = n - 1; i >= 0; --i) ls[--cnt[rk[tmp[i]]]] = tmp[i];
memset(tmp, 0, sizeof(tmp));
}
void getsa() {
int i, j, cv;
memset(rk, 0, sizeof(rk));
memset(vy, 0, sizeof(vy));
for (i = 0; i < n; ++i) {
rk[i] = !a[i];
}
for (i = 2; i <= n * 2; i <<= 1) {
for (j = 0; j < n; ++j) {
vy[j] = rk[(j + (i >> 1)) % n];
}
bsort();
cv = 1;
for (j = 0; j < n; ++j) {
if (j && (rk[ls[j - 1]] != rk[ls[j]] || vy[ls[j - 1]] != vy[ls[j]])) ++cv;
tmp[ls[j]] = cv;
}
memcpy(rk, tmp, sizeof(tmp));
}
}
} // namespace SA
int main() {
int i, j, k;
scanf("%s", s);
n = strlen(s);
for (i = 0; i < n; ++i) {
a[i] = (s[i] == '(');
pr[i] = sf[i] = (a[i] ? 1 : -1);
sum += pr[i];
}
for (i = 1; i < n; ++i) pr[i] += pr[i - 1];
for (i = n - 2; i >= 0; --i) sf[i] += sf[i + 1];
for (i = 0; i < n; ++i) mnpr[i] = MIN((i ? mnpr[i - 1] : 2000000000), pr[i]);
for (i = n - 1; i >= 0; --i)
mxsf[i] = MAX((i == n - 1 ? -2000000000 : mxsf[i + 1]), sf[i]);
SA::n = n;
SA::getsa();
if (sum <= 0) {
for (i = 1; i < n; ++i) {
if (mxsf[i] + pr[i - 1] <= 0 && pr[i - 1] - mnpr[i - 1] <= 0) {
ok[i] = 1;
}
}
if (mxsf[0] <= 0) ok[0] = 1;
for (i = 0; i < n; ++i) {
if (ok[SA::ls[i]]) {
for (j = 0; j < -sum; ++j) {
printf("(");
}
for (j = 0; j < n; ++j) {
printf("%c", s[(SA::ls[i] + j) % n]);
}
printf("\n");
return 0;
}
}
} else {
for (i = 1; i < n; ++i) {
if (mnpr[i - 1] + sf[i] >= 0 && sf[i] - mxsf[i] >= 0) {
ok[i] = 1;
}
}
if (mnpr[n - 1] >= 0) ok[0] = 1;
for (i = 0; i < n; ++i) {
if (ok[SA::ls[i]]) {
for (j = 0; j < n; ++j) {
printf("%c", s[(SA::ls[i] + j) % n]);
}
for (j = 0; j < sum; ++j) {
printf(")");
}
printf("\n");
return 0;
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101;
int p[maxn], dp[maxn][maxn][2];
int calc(int pos, int odds, int evens, int nxt) {
if (odds < 0 || evens < 0 || pos < 0) return 1e9;
int& ans = dp[pos][evens][nxt];
if (pos == 0 && p[pos] == -1) return ans = (evens == nxt);
if (pos == 0 && p[pos] != -1) return ans = (p[pos] != nxt);
if (ans != -1) return ans;
if (p[pos] != -1) {
ans = calc(pos - 1, odds, evens, p[pos]) + (p[pos] != nxt);
return ans;
}
ans = calc(pos - 1, odds - 1, evens, 1) + (1 != nxt);
ans = min(ans, calc(pos - 1, odds, evens - 1, 0) + (0 != nxt));
return ans;
}
int main() {
int n;
cin >> n;
memset(p, -1, sizeof(p));
memset(dp, -1, sizeof(dp));
int even = n / 2, odd = n - even;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (!a) continue;
p[i] = a & 1;
if (a & 1)
odd--;
else
even--;
}
int ans = min(calc(n - 1, odd, even, 1), calc(n - 1, odd, even, 0));
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int direct[][2] = {0, 1, -1, 1, -1, 0, -1, -1, 0, -1, 1, -1, 1, 0, 1, 1};
struct node {
long long int dir;
long long int x, y;
node(long long int a, long long int b, long long int c)
: x(a), y(b), dir(c) {}
};
bool flag[300][300];
bool nowflag[300][300][9];
queue<node> que;
long long int bfs(long long int side, long long int t) {
long long int ans = 0;
memset(nowflag, false, sizeof(nowflag));
while (t-- && !que.empty()) {
node tem = que.front();
que.pop();
for (long long int i = 1; i <= side; ++i) {
if (!flag[tem.x + direct[(tem.dir + 1 + 8) % 8][0] * i]
[tem.y + direct[(tem.dir + 1 + 8) % 8][1] * i]) {
ans++;
flag[tem.x + direct[(tem.dir + 1 + 8) % 8][0] * i]
[tem.y + direct[(tem.dir + 1 + 8) % 8][1] * i] = true;
}
if (!flag[tem.x + direct[(tem.dir - 1 + 8) % 8][0] * i]
[tem.y + direct[(tem.dir - 1 + 8) % 8][1] * i]) {
ans++;
flag[tem.x + direct[(tem.dir - 1 + 8) % 8][0] * i]
[tem.y + direct[(tem.dir - 1 + 8) % 8][1] * i] = true;
}
}
if (!nowflag[tem.x + direct[(tem.dir + 1 + 8) % 8][0] * side]
[tem.y + direct[(tem.dir + 1 + 8) % 8][1] * side]
[(tem.dir + 1 + 8) % 8]) {
nowflag[tem.x + direct[(tem.dir + 1 + 8) % 8][0] * side]
[tem.y + direct[(tem.dir + 1 + 8) % 8][1] * side]
[(tem.dir + 1 + 8) % 8] = true;
que.push(node(tem.x + direct[(tem.dir + 1 + 8) % 8][0] * side,
tem.y + direct[(tem.dir + 1 + 8) % 8][1] * side,
(tem.dir + 1 + 8) % 8));
}
if (!nowflag[tem.x + direct[(tem.dir - 1 + 8) % 8][0] * side]
[tem.y + direct[(tem.dir - 1 + 8) % 8][1] * side]
[(tem.dir - 1 + 8) % 8]) {
nowflag[tem.x + direct[(tem.dir - 1 + 8) % 8][0] * side]
[tem.y + direct[(tem.dir - 1 + 8) % 8][1] * side]
[(tem.dir - 1 + 8) % 8] = true;
que.push(node(tem.x + direct[(tem.dir - 1 + 8) % 8][0] * side,
tem.y + direct[(tem.dir - 1 + 8) % 8][1] * side,
(tem.dir - 1 + 8) % 8));
}
}
return ans;
}
int main(int argc, char const *argv[]) {
long long int n;
scanf("%I64d", &n);
long long int side;
long long int ans = 0;
scanf("%I64d", &ans);
for (long long int i = 1; i <= ans; ++i) {
flag[150 + direct[0][0] * i][150 + direct[0][1] * i] = true;
flag[150 + direct[0][0] * i][150 + direct[0][1] * i] = true;
}
que.push(node(150, ans + 150, 0));
for (long long int i = 1; i < n; ++i) {
scanf("%I64d", &side);
ans += bfs(side, que.size());
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int to[N << 1], nxt[N << 1], head[N], cnt = 0, d[N], n, m, st, vis[N];
bool a[N];
vector<int> b;
inline void add(int x, int y) {
to[cnt] = y;
nxt[cnt] = head[x];
head[x] = cnt++;
}
inline void dfs(int x) {
vis[x] = 1;
b.push_back(x);
for (int i = head[x]; ~i; i = nxt[i]) {
if (!vis[to[i]]) {
dfs(to[i]);
b.push_back(x);
vis[x]++;
if (vis[to[i]] % 2 != a[to[i]]) {
vis[to[i]]++;
vis[x]++;
b.push_back(to[i]);
b.push_back(x);
}
}
}
return;
}
inline int solve() {
int st = -1;
int i;
for (i = 1; i <= n; i++) {
if (a[i] == 1) {
st = i;
break;
}
}
if (st == -1) return 0;
memset(vis, 0, sizeof(vis));
b.clear();
dfs(st);
if (vis[st] % 2 != a[st]) {
vis[st]--;
b.erase(b.begin());
}
for (register int i = 1; i <= n; ++i)
if (vis[i] % 2 != a[i]) return -1;
return b.size();
}
signed main() {
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &m);
memset(d, 0, sizeof(d));
for (register int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
d[x]++, d[y]++;
}
for (register int i = 1; i <= n; ++i) scanf("%d", &a[i]);
int ans = solve();
printf("%d\n", ans);
if (ans != -1) {
int res = b.size();
if (res > 0) printf("%d", b[0]);
for (register int i = 1; i <= res - 1; ++i) {
printf(" %d", b[i]);
}
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, bool> mp;
vector<long long> g1[1009], g2[1009];
struct sp {
long long x = 0, a = 0, f = 0;
};
struct bs {
long long x = 0, d = 0;
};
sp ship[1009];
bs base[1009];
vector<vector<long long>> dist(1009, vector<long long>(1009, 1e18 + 9));
vector<long long> mt(1009, -1);
vector<bool> used(1009);
void floyd(long long n) {
for (long long k = 1; k <= n; k++)
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
void get_bp_graph(long long s, long long b, long long n) {
for (long long i = 0; i < s; i++) {
sp cur_s = ship[i];
for (long long j = 0; j < b; j++) {
bs cur_b = base[j];
if (dist[cur_b.x][cur_s.x] <= cur_s.f && cur_b.d <= cur_s.a)
g2[i + 1].push_back(j + 1);
}
}
}
bool try_kuhn(long long v) {
if (used[v]) return false;
used[v] = true;
for (auto u : g2[v]) {
if (mt[u] == -1 || try_kuhn(mt[u])) {
mt[u] = v;
return true;
}
}
return false;
}
signed main() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
if (mp[{u, v}] || u == v) continue;
mp[{u, v}] = mp[{v, u}] = true;
dist[u][v] = dist[v][u] = 1;
g1[v].push_back(u);
g1[u].push_back(v);
}
for (long long i = 1; i <= n; i++) dist[i][i] = 0;
long long s, b, k, h;
cin >> s >> b >> k >> h;
for (long long i = 0; i < s; i++) {
cin >> ship[i].x >> ship[i].a >> ship[i].f;
}
for (long long i = 0; i < b; i++) {
cin >> base[i].x >> base[i].d;
}
floyd(n);
get_bp_graph(s, b, n);
for (long long i = 1; i <= s; ++i) {
if (g2[i].empty()) continue;
used.assign(s + 1, false);
try_kuhn(i);
}
long long cnt = 0;
for (long long i = 1; i <= b; ++i) {
if (mt[i] != -1) cnt++;
}
cout << min(s * h, cnt * k) << endl;
}
| 7 |
#include <bits/stdc++.h>
const long long INF = 4e18L + 1;
const int IINF = 2e9 + 1;
const int limit = 1048576;
using namespace std;
const int N = 2e5, M = 2e5;
int n, m;
array<vector<pair<int, int> >, N + 1> nei;
array<bool, M + 1> is_true;
array<bool, N + 1> root_visited;
struct root_finder {
int root;
root_finder(int v) : root(-1) { dfs(v, 0); }
void dfs(int v, int p) {
root_visited[v] = true;
for (auto& w : nei[v]) {
if (root_visited[w.first] and w.first != p and root == -1) {
root = w.first;
if (w.second > 0) {
is_true[w.second] = true;
}
} else if (!root_visited[w.first]) {
dfs(w.first, v);
}
}
}
};
array<bool, N + 1> solver_visited;
void dfs(int v) {
solver_visited[v] = true;
for (auto& w : nei[v]) {
if (!solver_visited[w.first]) {
if (w.second > 0) {
is_true[w.second] = true;
}
dfs(w.first);
}
}
}
int ez_cnt = 0;
array<int, M + 1> pos_clause, neg_clause;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (long long i = (long long)1; i < (long long)n + 1; i++) {
int k;
cin >> k;
for (long long _ = (long long)0; _ < (long long)k; _++) {
int x;
cin >> x;
if (x > 0) {
if (pos_clause[x] != 0) {
nei[pos_clause[x]].push_back({pos_clause[x], x});
nei[i].push_back({i, x});
} else {
pos_clause[x] = i;
}
} else {
x = -x;
if (neg_clause[x] != 0) {
nei[neg_clause[x]].push_back({neg_clause[x], -x});
nei[i].push_back({i, -x});
} else {
neg_clause[x] = i;
}
}
}
}
for (long long i = (long long)1; i < (long long)m + 1; i++) {
if (pos_clause[i] != 0 and neg_clause[i] != 0) {
nei[pos_clause[i]].push_back({neg_clause[i], -i});
nei[neg_clause[i]].push_back({pos_clause[i], i});
} else {
if (pos_clause[i] != 0) {
nei[pos_clause[i]].push_back({pos_clause[i], i});
} else if (neg_clause[i] != 0) {
nei[neg_clause[i]].push_back({neg_clause[i], -i});
}
}
}
for (long long i = (long long)1; i < (long long)n + 1; i++) {
if (!solver_visited[i]) {
root_finder rt(i);
if (rt.root != -1) {
dfs(rt.root);
} else {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
for (long long i = (long long)1; i < (long long)m + 1; i++) {
cout << is_true[i];
}
cout << "\n";
return 0;
}
| 8 |
/**
fast forces 1600
problem set 1700,1800
atcoder problems
some random dp problem from the sheet
**/
#include<bits/stdc++.h>
#define int long long
#define pb push_back
using namespace std;
const int inf = 1e18+7;
const int mod = 1e9+7;
signed main(){
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int t;
cin>>t;
while(t--){
int n;
cin>>n;
if(n == 1){
cout<<0<<endl;
}
else if(n==2){
cout<<1<<endl;
}
else if(n == 3){
cout<<2<<endl;
}
else if(n%2){
cout<<3<<endl;
}
else{
cout<<2<<endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100, MAXM = 330, INF = 0x3f3f3f3f;
int n, m, a[MAXN], ans = 0, anspos = 0;
struct T {
int l, r, id;
T(int l = 0, int r = 0, int id = 0) : l(l), r(r), id(id) {}
} s[MAXM];
vector<T> ei[MAXN], bi[MAXN];
struct no {
int beg, end, mid, mn, lz;
no *l, *r;
no(int beg, int end, int v[])
: beg(beg), end(end), mid((beg + end) >> 1), lz(0), mn(v[beg]) {
if (beg != end)
l = new no(beg, mid, v), r = new no(mid + 1, end, v),
mn = min(l->mn, r->mn);
}
~no() {
if (beg != end) delete l, delete r;
}
void refresh() {
if (beg != end) l->lz += lz, r->lz += lz;
mn += lz;
lz = 0;
}
void update(int a, int b, int inc) {
if (end < a || b < beg) return;
if (a <= beg && end <= b) return void(lz += inc);
l->update(a, b, inc), r->update(a, b, inc), l->refresh(), r->refresh();
mn = min(l->mn, r->mn);
}
int getMin(int a, int b) {
if (end < a || b < beg) return INF;
refresh();
if (a <= beg && end <= b) return mn;
return min(l->getMin(a, b), r->getMin(a, b));
}
};
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
no seg(1, n, a);
for (int i = 1, l, r; i <= m; ++i)
scanf("%d %d", &l, &r), ei[r].push_back(T(l, r, i)),
bi[l].push_back(T(l, r, i)), seg.update(l, r, -1), s[i] = T(l, r, i);
for (int i = 1; i <= n; ++i) {
for (const T& x : ei[i - 1]) seg.update(x.l, x.r, -1);
for (const T& x : bi[i]) seg.update(x.l, x.r, 1);
if (a[i] - seg.getMin(1, n) > ans)
ans = a[i] - seg.getMin(1, n), anspos = i;
}
vector<int> temp;
for (int i = 1; i <= m; ++i)
if (anspos < s[i].l || s[i].r < anspos) temp.push_back(s[i].id);
printf("%d\n%d\n", ans, temp.size());
for (const int& x : temp) printf("%d ", x);
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5+10;
#define int long long
const int inf = 1e15;
int t,n1,n2,n3,a[maxn],b[maxn],c[maxn],d[maxn];
signed main()
{
cin >> n1 >> n2 >> n3;
int sum1 = 0,sum2 = 0,sum3 = 0;
for(int i=1;i<=n1;i++) { cin >> a[i]; sum1 += a[i]; }
for(int i=1;i<=n2;i++) { cin >> b[i]; sum2 += b[i]; }
for(int i=1;i<=n3;i++) { cin >> c[i]; sum3 += c[i]; }
sort( a+1,a+1+n1 ); sort( b+1,b+1+n2 ); sort( c+1,c+1+n3 );
int ans1 = 0,ans2 = 0,ans3 = 0;
ans1 = sum1+sum2+sum3-2*(b[1]+c[1]);//分别留下一个给A
ans2 = sum1+sum2+sum3-2*(a[1]+c[1]);
ans3 = sum1+sum2+sum3-2*(a[1]+b[1]);
ans1 = max( ans1,max(sum1+sum2-sum3,sum1+sum3-sum2));//只留下一个
ans1 = max( ans1,sum2+sum3-sum1);
cout << max( ans1,max(ans2,ans3) );
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18, N = 500100, MOD = 998244353, K = 27;
vector<long long> t;
long long n;
long long sum(long long r) {
long long result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t[r];
return result;
}
void inc(long long i, long long delta) {
for (; i <= n; i = (i | (i + 1))) t[i] += delta;
}
long long sum(long long l, long long r) { return sum(r) - sum(l - 1); }
long long ind(std::vector<long long> &a, long long x) {
auto it = std::lower_bound(a.begin(), a.end(), x);
return it - a.begin();
}
int32_t main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
long long n;
std::cin >> n;
std::vector<long long> a(n), zeroInd;
std::vector<std::pair<long long, long long>> negInd;
long long cntNeg = 0;
for (long long i = 0; i < n; ++i) {
std::cin >> a[i];
cntNeg += (a[i] < 0);
if (a[i] == 0) {
zeroInd.push_back(i);
}
if (a[i] < 0) {
negInd.push_back({-a[i], i});
}
}
std::vector<long long> used(n);
;
std::sort(negInd.begin(), negInd.end());
for (long long i = 0; i < (long long)zeroInd.size() - 1; ++i) {
used[zeroInd[i]] = 1;
std::cout << 1 << ' ' << zeroInd[i] + 1 << ' ' << zeroInd[i + 1] + 1
<< '\n';
}
if (cntNeg % 2 == 1) {
used[negInd[0].second] = 1;
if (zeroInd.empty()) {
std::cout << 2 << ' ' << negInd[0].second + 1 << '\n';
} else {
used[zeroInd.back()] = 1;
std::cout << 1 << ' ' << zeroInd.back() + 1 << ' ' << negInd[0].second + 1
<< '\n';
if (zeroInd.size() != n - 1) {
std::cout << 2 << ' ' << negInd[0].second + 1 << '\n';
}
}
} else if (!zeroInd.empty() && zeroInd.size() != n) {
std::cout << 2 << ' ' << zeroInd.back() + 1 << '\n';
used[zeroInd.back()] = 1;
}
long long r = 1;
for (long long i = 0; i < n; ++i) {
if (used[i]) {
continue;
}
r = std::max(r, i + 1);
while (r < n && used[r]) {
++r;
}
if (r < n) {
std::cout << 1 << ' ' << i + 1 << ' ' << r + 1 << '\n';
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int b, g, n;
cin >> b >> g >> n;
int ans = 0;
for (int i = 0; i <= n; i++) {
int x = i, y = n - i;
if (x <= b && y <= g) {
ans++;
}
}
cout << ans;
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin>>t;
while(t--)
{
int n,one=0,two=0,ans=0,flag=1;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
{
cin>>a[i];
if(a[i]==1 || a[i]==3)
ans++;
}
cout<<ans<<"\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 0, num;
cin >> n;
int arra[n];
for (int i = 0; i < n; i++) {
cin >> arra[i];
}
for (int i = 0; i < n - 1; i++) {
if (arra[i] > arra[i + 1]) {
c++;
if (c > 1) {
break;
} else {
num = i + 1;
}
}
}
if (c == 0) {
cout << '0';
} else if (c > 1 || (c == 1 && arra[0] < arra[n - 1])) {
cout << "-1";
} else {
cout << n - num;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string p[100010];
long long n, ans, maxn;
int main() {
cin >> n;
for (register int i = 1; i <= n; i++) cin >> p[i];
for (register int c = 0; c <= 25; c++) {
maxn = 0;
int judge, l, r, mid;
for (register int i = 1; i <= n; i++) {
judge = 1;
mid = 0;
for (register int j = 0; j <= (int)p[i].size() - 1; j++)
if (p[i][j] != c + 'a') judge = 0;
int cnt = 0, bo = 1;
for (register int j = 0; j <= (int)p[i].size() - 1; j++)
cnt += bo, bo = (bo && p[i][j] == c + 'a');
l = cnt - 1;
cnt = 0;
bo = 1;
for (register int j = p[i].size() - 1; j >= 0; j--)
cnt += bo, bo = (bo && p[i][j] == c + 'a');
r = cnt - 1;
cnt = 0;
bo = 1;
for (register int j = 0; j <= (int)p[i].size() - 1; j++) {
cnt = (p[i][j] == c + 'a') ? cnt + 1 : 0;
mid = max(mid, cnt);
}
if (judge)
maxn = maxn + (maxn + 1) * p[i].size();
else if (maxn == 0)
maxn = mid;
else
maxn = max(mid, l + r + 1);
}
ans = max(ans, maxn);
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100002;
int n;
int main() {
scanf("%d", &n);
long long ans = 0;
for (int(i) = (1); (i) <= (int)(n); (i)++) {
long long x, m;
scanf("%lld%lld", &x, &m);
if (x & 1) ans ^= x, --m, ++x;
if ((m >> 1) & 1) ans ^= 1;
if (m & 1) ans ^= (x + m - 1);
}
if (ans)
printf("tolik\n");
else
printf("bolik\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int p[N][28], deep[N], log2n;
int lca(int a, int b) {
if (deep[a] > deep[b]) swap(a, b);
int dh = deep[b] - deep[a];
for (int i = 0; (1 << i) <= dh; i++)
if (1 << i & dh) b = p[b][i];
if (a != b) {
for (int i = log2n; i >= 0; i--)
if (p[a][i] != p[b][i]) a = p[a][i], b = p[b][i];
a = p[a][0];
}
return a;
}
int main() {
int ans = 2, a = 2, b = 4, t1, t2, cnt = 4, n, t;
scanf("%d", &n);
log2n = (log(n) * 1.0 / log(2));
p[2][0] = p[3][0] = p[4][0] = 1;
deep[2] = deep[3] = deep[4] = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &t);
p[++cnt][0] = t, deep[cnt] = deep[t] + 1, p[++cnt][0] = t,
deep[cnt] = deep[t] + 1;
for (int j = 1; j <= log2n; j++)
p[cnt][j] = p[cnt - 1][j] = p[p[cnt][j - 1]][j - 1];
int t1 = lca(cnt, a), t2 = lca(cnt, b);
if (deep[cnt] + deep[a] - 2 * deep[t1] > ans)
b = cnt, ans = deep[cnt] + deep[a] - 2 * deep[t1];
else if (deep[cnt] + deep[b] - 2 * deep[t2] > ans)
a = cnt, ans = deep[cnt] + deep[b] - 2 * deep[t2];
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int N = 2e5 + 9;
int t, n, k, a[N];
vector<int> v[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
v[i].clear();
a[i] = 0;
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
v[x].push_back(i);
}
int d = 0;
for (int i = 1; i <= n; i++) {
while (v[i].size() > k) v[i].pop_back();
d = (d + (int)v[i].size()) % k;
}
for (int i = 1; i <= n; i++)
while (d > 0 && !v[i].empty()) v[i].pop_back(), d--;
int cur = 1;
for (int i = 1; i <= n; i++) {
for (auto j : v[i]) {
a[j] = cur++;
if (cur > k) cur = 1;
}
}
for (int i = 1; i <= n; i++) cout << a[i] << " ";
cout << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double pi = acosl(-1.), eps = 1e-9;
inline int power(int a, int b, int m = mod, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
char s[10];
int flag;
void que(long long l, long long r) {
printf("%I64d %I64d\n", l, r);
fflush(stdout);
scanf("%s", s);
if (s[0] == 'Y')
flag = 1;
else
flag = 0;
if (l == r && flag) exit(0);
}
int main() {
srand(time(0));
long long st = 1;
long long ed, k, md;
cin >> ed >> k;
long long n = ed;
while (1) {
if (st + 30ll < ed) {
md = st + ed + 1 >> 1;
st = max(st - k, 1ll);
ed = min(ed + k, n);
que(st, md);
if (flag) {
ed = md;
} else {
st = md + 1;
}
} else {
st = max(st - k, 1ll);
ed = min(ed + k, n);
md = st + (rand() % ((int)(ed - st + 1)));
que(md, md);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 4e6 + 100;
struct inf {
int x, r, f;
} a[nmax];
struct segment_tree {
int l, r;
long long q;
} seg[nmax];
int n, k, cnt, mx;
int root[nmax], actual[nmax];
void build(int i, int l, int r) {
if (l == r) return;
seg[i].l = ++cnt, seg[i].l = ++cnt;
build(seg[i].l, l, ((l + r) >> 1)), build(seg[i].r, ((l + r) >> 1) + 1, r);
}
bool cmp(inf a, inf b) { return a.r > b.r; }
vector<int> b;
int bs0(int v) {
int l = 0, r = n - 1, a = -1;
while (l <= r) {
int m = (l + r) >> 1;
if (actual[b[m]] >= v)
a = b[m], r = m - 1;
else
l = m + 1;
}
return a;
}
int bs1(int v) {
int l = 0, r = n - 1, a = -1;
while (l <= r) {
int m = (l + r) >> 1;
if (actual[b[m]] <= v)
a = b[m], l = m + 1;
else
r = m - 1;
}
return a;
}
void upd(int x, int i, int l, int r, int p) {
if (l == r) {
seg[i].q = seg[x].q + 1;
return;
}
if (p >= l && p <= ((l + r) >> 1))
seg[i].r = seg[x].r, upd(seg[x].l, seg[i].l = ++cnt, l, ((l + r) >> 1), p);
else
seg[i].l = seg[x].l,
upd(seg[x].r, seg[i].r = ++cnt, ((l + r) >> 1) + 1, r, p);
seg[i].q = seg[seg[i].l].q + seg[seg[i].r].q;
}
int get(int i, int l, int r, int u, int v) {
if (l > v || r < u) return 0;
if (l >= u && r <= v) return seg[i].q;
return get(seg[i].l, l, ((l + r) >> 1), u, v) +
get(seg[i].r, ((l + r) >> 1) + 1, r, u, v);
}
unordered_map<int, int> compressed;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = (int)1; i <= (int)n; i++) cin >> a[i].x >> a[i].r >> a[i].f;
b.resize(n);
for (int i = (int)1; i <= (int)n; i++) b[i - 1] = a[i].x;
sort(b.begin(), b.end());
int c = 0;
long long rs = 0;
for (int i = (int)0; i <= (int)n - 1; i++)
if (!compressed[b[i]]) actual[++c] = b[i], b[i] = compressed[b[i]] = c;
for (int i = (int)1; i <= (int)n; i++)
a[i].x = compressed[a[i].x], mx = max(mx, a[i].x), root[a[i].f] = -1;
build(root[0] = 0, 1, mx);
sort(a + 1, a + n + 1, cmp);
for (int i = (int)1; i <= (int)n; i++) {
int x = a[i].x, r = a[i].r, f = a[i].f,
x0 = bs0(max(actual[1], actual[x] - r)),
x1 = bs1(min(actual[c], actual[x] + r));
for (int j = (int)max(1, f - k); j <= (int)min((int)1e4, f + k); j++)
if (root[j] != -1) {
rs += get(root[j], 1, mx, x0, x1);
}
if (root[f] != -1) {
int tmp = ++cnt;
upd(root[f], tmp, 1, mx, x);
root[f] = tmp;
} else {
upd(0, root[f] = ++cnt, 1, mx, x);
}
}
cout << rs;
}
| 7 |
#include <bits/stdc++.h>
const int N = 2010;
char grid[N][N];
int deg[N][N];
int dir[][2] = {0, 1, 0, -1, 1, 0, -1, 0};
int n, m;
bool check(int x, int y) {
if (x >= 0 && y >= 0 && x < n && y < m && grid[x][y] == '.') return true;
return false;
}
int main() {
while (~scanf("%d %d", &n, &m)) {
for (int i = 0; i < n; i++) memset(deg[i], 0, sizeof(int) * m);
for (int i = 0; i < n; i++) scanf("%s", grid[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (grid[i][j] == '.')
for (int k = 0; k < 4; k++)
if (check(i + dir[k][0], j + dir[k][1])) deg[i][j]++;
std::queue<int> qx, qy;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (deg[i][j] == 1) qx.push(i), qy.push(j);
while (!qx.empty()) {
int x = qx.front(), y = qy.front();
qx.pop(), qy.pop();
for (int i = 0; i < 4; i++) {
int nx = x + dir[i][0], ny = y + dir[i][1];
if (check(nx, ny)) {
if (i == 0) grid[x][y] = '<', grid[nx][ny] = '>';
if (i == 1) grid[x][y] = '>', grid[nx][ny] = '<';
if (i == 2) grid[x][y] = '^', grid[nx][ny] = 'v';
if (i == 3) grid[x][y] = 'v', grid[nx][ny] = '^';
deg[nx][ny] = 0;
for (int j = 0; j < 4; j++) {
int nnx = nx + dir[j][0], nny = ny + dir[j][1];
if (check(nnx, nny) && --deg[nnx][nny] == 1)
qx.push(nnx), qy.push(nny);
}
}
}
}
bool flag = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (grid[i][j] == '.') {
flag = false;
puts("Not unique");
break;
}
if (!flag) break;
}
if (flag)
for (int i = 0; i < n; i++) grid[i][m] = '\0', printf("%s\n", grid[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int tc, a, b, x;
cin >> tc;
while (tc--) {
x = 0;
cin >> a >> b;
while (a >= b) {
if (a % b == 0) {
a = a / b;
x++;
} else {
x = x + (a % b);
a = a - (a % b);
}
}
x = x + a;
cout << x << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
static int n, k;
int main(void) {
scanf("%d%d", &n, &k);
printf("%d\n", k * (6 * n - 1));
for (int i = 0; i < n; ++i) {
printf("%d %d %d %d\n", k * (6 * i + 1), k * (6 * i + 2), k * (6 * i + 3),
k * (6 * i + 5));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int cnt = 0;
string a, b;
cin >> a >> b;
for (int i = 0; i < n; i++) {
int j = i;
if (a[i] != b[i])
cnt += 2;
else {
if (a[i] == '0' && i < n && a[i + 1] != b[i + 1])
cnt += 1;
else if (a[i] == '0' && i < n && a[i + 1] == b[i + 1] &&
a[i + 1] == '1') {
cnt += 2;
i++;
} else if (a[i] == '0')
cnt += 1;
else if (a[i] == '1' && i < n && a[i + 1] == '0' &&
a[i + 1] == b[i + 1]) {
cnt += 2;
i++;
}
}
}
cout << cnt << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
const long long mod = 1e9;
#pragma GCC optimize("-O2")
const long long INF = 10000000;
long long getIInput() {
cout.flush();
long long x;
cin >> x;
return x;
}
void flash() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(9);
}
bool equ(string s1, string s2) {
if (s1 == s2) {
return true;
} else if (s1.length() % 2 == 0 && s2.length() % 2 == 0) {
string p11 = s1.substr(0, (s1.length() / 2));
string p12 = s1.substr((s1.length() / 2), (s1.length() / 2));
string p21 = s2.substr(0, (s2.length() / 2));
string p22 = s2.substr((s2.length() / 2), (s2.length() / 2));
return ((equ(p11, p21) && equ(p12, p22)) ||
(equ(p11, p22) && equ(p12, p21)));
} else
return false;
}
string smallest(string s) {
if (s.length() % 2 == 1) return s;
string s1 = smallest(s.substr(0, s.length() / 2));
string s2 = smallest(s.substr(s.length() / 2, s.length() / 2));
if (s1 < s2)
return s1 + s2;
else
return s2 + s1;
}
void solve();
int32_t main() {
flash();
long long t;
t = 1;
while (t--) {
solve();
}
return 0;
}
void solve() {
string s1, s2;
cin >> s1 >> s2;
string yo = smallest(s1);
string yo2 = smallest(s2);
cerr << yo << " " << yo2 << "\n";
if (yo == yo2) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N;
int main() {
cin >> N;
vector<pair<long long, long long> > tree;
for (int i = 0; i < N; i++) {
long long x, h;
cin >> x >> h;
tree.push_back(make_pair(x, h));
}
int ans = min(2, N);
for (int i = 1; i < N - 1; i++) {
if (tree[i - 1].first + tree[i].second < tree[i].first) {
ans++;
} else if (tree[i].first + tree[i].second < tree[i + 1].first) {
ans++;
tree[i].first += tree[i].second;
}
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
char c[1010];
int main() {
cin >> n >> c;
for (int i = 0; i < n; i++) {
int l = i - 1, r = i, L = 1, R = 1;
while (l >= 0 && c[l] != 'L') L += c[l--] == 'R';
while (r <= n - 2 && c[r] != 'R') R += c[r++] == 'L';
cout << max(L, R) << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, int> soinnsuu(long long int a) {
map<long long int, int> ans;
for (long long i = 2; i * i <= a; ++i) {
while (a % i == 0) {
ans[i]++;
a /= i;
}
}
if (a != 1) ans[a]++;
return ans;
}
const int mod = 1000000007;
struct Mod {
public:
int num;
Mod() : num(0) { ; }
Mod(long long int n) : num((n % mod + mod) % mod) { ; }
Mod(int n) : num((n % mod + mod) % mod) { ; }
operator int() { return num; }
};
Mod operator+(const Mod a, const Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator+(const long long int a, const Mod b) { return Mod(a) + b; }
Mod operator++(Mod &a) { return a + Mod(1); }
Mod operator-(const Mod a, const Mod b) {
return Mod((mod + a.num - b.num) % mod);
}
Mod operator-(const long long int a, const Mod b) { return Mod(a) - b; }
Mod operator--(Mod &a) { return a - Mod(1); }
Mod operator*(const Mod a, const Mod b) {
return Mod(((long long)a.num * b.num) % mod);
}
Mod operator*(const long long int a, const Mod b) { return Mod(a) * b; }
Mod operator+=(Mod &a, const Mod b) { return a = a + b; }
Mod operator+=(long long int &a, const Mod b) { return a = a + b; }
Mod operator-=(Mod &a, const Mod b) { return a = a - b; }
Mod operator-=(long long int &a, const Mod b) { return a = a - b; }
Mod operator*=(Mod &a, const Mod b) { return a = a * b; }
Mod operator*=(long long int &a, const Mod b) { return a = a * b; }
Mod operator^(const Mod a, const int n) {
if (n == 0) return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2) res = res * a;
return res;
}
Mod inv(const Mod a) { return a ^ (mod - 2); }
Mod operator/(const Mod a, const Mod b) {
assert(b.num != 0);
return a * inv(b);
}
Mod operator/(const long long int a, const Mod b) {
assert(b.num != 0);
return Mod(a) * inv(b);
}
Mod operator/=(Mod &a, const Mod b) {
assert(b.num != 0);
return a = a * inv(b);
}
Mod fact[1024000], factinv[1024000];
void init() {
fact[0] = Mod(1);
factinv[0] = 1;
for (int i = 0; i < 1024000 - 1; ++i) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(const int a, const int b) {
return fact[a] * factinv[b] * factinv[a - b];
}
using namespace std;
const int INF = 2147483647;
const long long int L_INF = 9223372036854775807;
struct Edge {
int src, dst;
int capacity;
int cost;
Edge(int src, int dst, int acap, int acost)
: src(src), dst(dst), capacity(acap), cost(acost) {}
};
bool operator<(const Edge &e, const Edge &f) { return e.cost > f.cost; }
pair<int, int> minimumCostFlow(const vector<vector<Edge>> &ag, int s, int t) {
vector<vector<Edge>> g(ag);
for (int i = 0; i < ag.size(); ++i) {
for (int j = 0; j < ag[i].size(); ++j) {
int d = ag[i][j].dst;
int s = ag[i][j].src;
bool ok = false;
for (int k = 0; k < ag[d].size(); ++k) {
if (ag[d][k].src == s) {
ok = true;
break;
}
}
if (!ok) {
g[d].push_back(Edge(d, s, 0, ag[i][j].cost));
}
}
}
const int n = g.size();
vector<vector<int>> capacity(n, vector<int>(n)), cost(n, vector<int>(n)),
flow(n, vector<int>(n));
for (int u = 0; u < (int)n; ++u)
for (auto e = (g[u]).begin(); e != (g[u]).end(); ++e) {
capacity[e->src][e->dst] += e->capacity;
cost[e->src][e->dst] += e->cost;
}
pair<int, int> total;
vector<int> h(n);
for (int F = INF; F > 0;) {
vector<int> d(n, INF);
d[s] = 0;
vector<int> p(n, -1);
priority_queue<Edge> Q;
for (Q.push(Edge(-2, s, 0, 0)); !Q.empty();) {
Edge e = Q.top();
Q.pop();
if (p[e.dst] != -1) continue;
p[e.dst] = e.src;
for (auto f = (g[e.dst]).begin(); f != (g[e.dst]).end(); ++f)
if ((capacity[f->src][f->dst] - flow[f->src][f->dst]) > 0) {
if (d[f->dst] >
d[f->src] + (cost[f->src][f->dst] + h[f->src] - h[f->dst])) {
d[f->dst] =
d[f->src] + (cost[f->src][f->dst] + h[f->src] - h[f->dst]);
Q.push(Edge(f->src, f->dst, 0, d[f->dst]));
}
}
}
if (p[t] == -1) break;
int f = F;
for (int u = t; u != s; u = p[u])
f = min(f, (capacity[p[u]][u] - flow[p[u]][u]));
for (int u = t; u != s; u = p[u]) {
total.first += f * cost[p[u]][u];
flow[p[u]][u] += f;
flow[u][p[u]] -= f;
}
F -= f;
total.second += f;
for (int u = 0; u < (int)n; ++u) h[u] += d[u];
}
return total;
}
long long int gcd(long long int l, long long int r) {
assert(l > 0 && r > 0);
if (l > r)
return gcd(r, l);
else {
if (r % l) {
return gcd(l, r % l);
} else {
return l;
}
}
}
int main() {
int n;
cin >> n;
set<int> sos;
vector<vector<Edge>> g;
vector<map<long long, int>> mps;
vector<int> nums;
for (int i = 0; i < n; ++i) {
long long int l;
cin >> l;
map<long long int, int> mp(soinnsuu(l));
mps.push_back(mp);
nums.push_back(l);
}
vector<int> costs;
map<long long int, int> finalmap;
for (int i = 0; i < n; ++i) {
long long int l;
cin >> l;
costs.push_back(l);
}
for (int i = 0; i < n; ++i) {
if (finalmap.count(nums[i])) {
finalmap[nums[i]] = min(finalmap[nums[i]], costs[i]);
} else {
finalmap[nums[i]] = costs[i];
}
for (auto it = finalmap.begin(); it != finalmap.end(); ++it) {
long long int agcd = gcd(it->first, nums[i]);
if (finalmap.count(agcd)) {
finalmap[agcd] = min(finalmap[agcd], it->second + costs[i]);
} else {
finalmap[agcd] = it->second + costs[i];
}
}
}
int ans = finalmap[1];
if (ans) {
cout << ans << endl;
} else {
cout << -1 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n, e[5001][5001];
int fac[5001], ifac[5001];
long long ans;
inline int add(int x, int y) { return x + y < mod ? x + y : x + y - mod; }
inline int power(int a, int n) {
int tp = 1;
while (n) {
if (n & 1) tp = 1ll * tp * a % mod;
a = 1ll * a * a % mod, n >>= 1;
}
return tp;
}
int main() {
cin >> n;
fac[0] = 1;
for (int i = 1; i <= n; i++) {
fac[i] = 1ll * fac[i - 1] * i % mod, e[i][0] = 1;
for (int j = 1; j < i; j++)
e[i][j] =
(1ll * (i - j) * e[i - 1][j - 1] + 1ll * (j + 1) * e[i - 1][j]) % mod;
}
ifac[n] = power(fac[n], mod - 2);
for (int i = n - 1; ~i; i--) ifac[i] = 1ll * ifac[i + 1] * (i + 1) % mod;
for (int i = 1; i <= n; i++) {
ans = 0;
for (int j = i; j <= n; j++) ans += 1ll * e[j][i - 1] * ifac[j], ans %= mod;
printf("%lld%c", ans * fac[n] % mod, " \n"[i == n]);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int32_t dx[] = {2, 2, -2, -2, 1, 1, -1, -1};
int32_t dy[] = {1, -1, 1, -1, 2, -2, 2, -2};
vector<long long> fac(100005, -1);
void init() {
fac[1] = 1;
for (long long i = 2; i < 100005; i++) {
if (fac[i] != -1) continue;
fac[i] = i;
for (long long j = i * i; j < 100005; j += i) {
if (fac[j] != -1) continue;
fac[j] = i;
}
}
}
int32_t main() {
init();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<long long> arr(n);
for (long long i = 0; i < n; ++i) cin >> arr[i];
vector<long long> count(100005, 0);
long long answer = 1;
for (long long i = 0; i < n; ++i) {
long long temp = arr[i];
long long maxChainLength = 0;
while (temp != 1) {
long long curr = fac[temp];
maxChainLength = max(maxChainLength, count[curr]);
while (fac[temp] == curr) {
temp /= fac[temp];
}
}
answer = max(answer, 1 + maxChainLength);
temp = arr[i];
while (temp != 1) {
long long curr = fac[temp];
count[curr] = max(count[curr], 1 + maxChainLength);
while (fac[temp] == curr) {
temp /= fac[temp];
}
}
}
cout << answer << endl;
}
| 3 |
#include <bits/stdc++.h>
int n, m, a[1000006], b[1000006], pin, sd;
bool u[1000006], flag;
inline int read() {
int n = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
n = n * 10 + c - '0';
c = getchar();
}
return n * f;
}
void e1(int x) {
puts("YES");
for (int i = 1; i <= n; ++i)
if (i != x) printf("%d %d\n", i, x);
}
int main() {
register int i, j, x, gs;
n = read();
for (i = 1; i <= n; ++i) {
a[i] = read();
if (a[i] == i) {
e1(i);
return 0;
}
}
for (i = 1; i <= n; ++i)
if (!u[i]) {
b[++pin] = i;
u[i] = true;
for (x = a[i], gs = 1; x != i; x = a[x], ++gs) b[++pin] = x, u[x] = true;
if (gs & 1) return 0 * printf("NO");
if (gs == 2) {
flag = 1;
sd = i;
}
}
if (!flag) return 0 * printf("NO");
puts("YES");
printf("%d %d\n", sd, a[sd]);
for (i = 1, x = sd; i <= n; ++i, x = a[x]) {
if (b[i] == sd || b[i] == a[sd]) continue;
printf("%d %d\n", x, b[i]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int n, b, g, counter;
int main() {
cin >> b >> g >> n;
for (int i = 0; i <= n; i++)
if (i <= b && (n - i) <= g) counter++;
cout << counter << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool cons[10];
int main() {
int n, m;
cin >> n >> m;
int a[10];
for (int i = 0; i < n; i++) cin >> a[i];
int temp;
for (int i = 0; i < m; i++) {
cin >> temp;
cons[temp] = true;
}
for (int i = 0; i < n; i++) {
if (cons[a[i]]) cout << a[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int pp(int *a, int p, int r) {
int x = a[r], i = p - 1, buf;
for (int j = p; j < r; ++j)
if (a[j] < x) {
i++;
buf = a[i];
a[i] = a[j];
a[j] = buf;
}
if (a[i + 1] != a[r]) {
buf = a[i + 1];
a[i + 1] = a[r];
a[r] = buf;
}
return i + 1;
}
void sort(int *a, int p, int r) {
if (p < r) {
int q = pp(a, p, r);
sort(a, p, q - 1);
sort(a, q + 1, r);
}
}
int main() {
int n, a, *b, kol = 0, kol1 = 0;
scanf("%d", &n);
b = new int[100];
for (int i = 0; i < 100; i++) b[i] = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a);
b[a - 1]++;
}
for (int i = 0; i < 100; i++) {
kol += b[i] / 4;
b[i] -= b[i] / 4 * 4;
}
for (int i = 0; i < 100; i++)
if (b[i] >= 2) kol1++;
kol += kol1 / 2;
printf("%d", kol);
delete[] b;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast", "unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long inf = numeric_limits<long long>::max() / 2;
const long double eps = 1e-9;
const long double pi = acos(-1);
inline void solve(), read();
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
read();
solve();
return 0;
}
struct comp {
long long n = 1;
vector<long long> worst, best;
comp() {}
comp(vector<long long>& w, vector<long long>& b) { worst = w, best = b; }
bool operator<(const comp& c) const {
for (long long i = 0; i < (long long)((best).size()); i++) {
if (best[i] >= c.worst[i]) {
return 0;
}
}
return 1;
}
void merge(const comp& c) {
n += c.n;
for (long long i = 0; i < (long long)((best).size()); i++) {
(best[i]) = ((best[i]) < (c.best[i])) ? (c.best[i]) : (best[i]);
(worst[i]) = ((worst[i]) > (c.worst[i])) ? (c.worst[i]) : (worst[i]);
}
}
};
long long n, k;
vector<vector<long long> > s;
set<comp> q;
inline void solve() {
for (long long i = 0; i < n; i++) {
comp c(s[i], s[i]);
auto it0 = q.lower_bound(c), it1 = q.upper_bound(c);
while (it0 != it1) {
c.merge(*it0);
it0 = q.erase(it0);
}
q.insert(c);
auto it = q.rbegin();
cout << it->n << "\n";
}
}
inline void read() {
cin >> n >> k;
s.resize(n, vector<long long>(k, 0));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < k; j++) {
cin >> s[i][j];
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<vector<int>, int> seen;
int query(int x1, int y1, int x2, int y2) {
vector<int> cur;
cur.push_back(x1);
cur.push_back(y1);
cur.push_back(x2);
cur.push_back(y2);
if (seen.find(cur) != seen.end()) return seen[cur];
cout << "? " << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << '\n';
cin >> m;
return seen[cur] = m;
}
signed main() {
cin >> n;
set<vector<int> > ans;
if (true) {
vector<int> tmp;
int x1 = 1, x2 = n, y1 = 1, y2 = n;
int st = 1, end = n;
while (true) {
if (st == end) break;
int mid = (st + end) / 2;
m = query(x1, y1, mid, y2);
if (mid == st && m == 1) break;
if (m == 0) {
if (st == mid)
st++;
else
st = mid;
} else {
end = mid;
}
}
x2 = st;
st = 1, end = x2;
while (true) {
if (st == end) break;
int mid = (st + end + 1) / 2;
m = query(mid, y1, x2, y2);
if (mid == end && m == 1) break;
if (m == 0) {
if (mid == end)
end--;
else
end = mid;
} else {
st = mid;
}
}
x1 = end;
st = 1, end = n;
while (true) {
if (st == end) break;
int mid = (st + end) / 2;
m = query(x1, y1, x2, mid);
if (mid == st && m == 1) break;
if (m == 0) {
if (st == mid)
st++;
else
st = mid;
} else {
end = mid;
}
}
y2 = st;
st = 1, end = y2;
while (true) {
if (st == end) break;
int mid = (st + end + 1) / 2;
m = query(x1, mid, x2, y2);
if (mid == end && m == 1) break;
if (m == 0) {
if (mid == end)
end--;
else
end = mid;
} else {
st = mid;
}
}
y1 = end;
tmp.push_back(x1);
tmp.push_back(y1);
tmp.push_back(x2);
tmp.push_back(y2);
ans.insert(tmp);
}
if (true) {
vector<int> tmp;
int x1 = 1, x2 = n, y1 = 1, y2 = n;
int st = 1, end = n;
while (true) {
if (st == end) break;
int mid = (st + end + 1) / 2;
m = query(mid, y1, x2, y2);
if (mid == end && m >= 1) break;
if (m == 0) {
if (mid == end)
end--;
else
end = mid;
} else {
st = mid;
}
}
x1 = end;
st = x1, end = n;
while (true) {
if (st == end) break;
int mid = (st + end) / 2;
m = query(x1, y1, mid, y2);
if (mid == st && m >= 1) break;
if (m == 0) {
if (st == mid)
st++;
else
st = mid;
} else {
end = mid;
}
}
x2 = st;
st = 1, end = n;
while (true) {
if (st == end) break;
int mid = (st + end + 1) / 2;
m = query(x1, mid, x2, y2);
if (mid == end && m >= 1) break;
if (m == 0) {
if (mid == end)
end--;
else
end = mid;
} else {
st = mid;
}
}
y1 = end;
st = y1, end = n;
while (true) {
if (st == end) break;
int mid = (st + end) / 2;
m = query(x1, y1, x2, mid);
if (mid == st && m >= 1) break;
if (m == 0) {
if (st == mid)
st++;
else
st = mid;
} else {
end = mid;
}
}
y2 = st;
tmp.push_back(x1);
tmp.push_back(y1);
tmp.push_back(x2);
tmp.push_back(y2);
ans.insert(tmp);
}
if (ans.size() == 1) {
vector<int> tmp;
int x1 = 1, x2 = n, y1 = 1, y2 = n;
int st = 1, end = n;
while (true) {
if (st == end) break;
int mid = (st + end) / 2;
m = query(x1, y1, x2, mid);
if (mid == st && m == 1) break;
if (m == 0) {
if (st == mid)
st++;
else
st = mid;
} else {
end = mid;
}
}
y2 = st;
st = 1, end = y2;
while (true) {
if (st == end) break;
int mid = (st + end + 1) / 2;
m = query(x1, mid, x2, y2);
if (mid == end && m == 1) break;
if (m == 0) {
if (mid == end)
end--;
else
end = mid;
} else {
st = mid;
}
}
y1 = end;
st = 1, end = n;
while (true) {
if (st == end) break;
int mid = (st + end) / 2;
m = query(x1, y1, mid, y2);
if (mid == st && m == 1) break;
if (m == 0) {
if (st == mid)
st++;
else
st = mid;
} else {
end = mid;
}
}
x2 = st;
st = 1, end = x2;
while (true) {
if (st == end) break;
int mid = (st + end + 1) / 2;
m = query(mid, y1, x2, y2);
if (mid == end && m == 1) break;
if (m == 0) {
if (mid == end)
end--;
else
end = mid;
} else {
st = mid;
}
}
x1 = end;
tmp.push_back(x1);
tmp.push_back(y1);
tmp.push_back(x2);
tmp.push_back(y2);
ans.insert(tmp);
}
if (ans.size() == 1) {
vector<int> tmp;
int x1 = 1, x2 = n, y1 = 1, y2 = n;
int st = 1, end = n;
while (true) {
if (st == end) break;
int mid = (st + end + 1) / 2;
m = query(x1, mid, x2, y2);
if (mid == end && m == 1) break;
if (m == 0) {
if (mid == end)
end--;
else
end = mid;
} else {
st = mid;
}
}
y1 = end;
st = y1, end = n;
while (true) {
if (st == end) break;
int mid = (st + end) / 2;
m = query(x1, y1, x2, mid);
if (mid == st && m == 1) break;
if (m == 0) {
if (st == mid)
st++;
else
st = mid;
} else {
end = mid;
}
}
y2 = st;
st = 1, end = n;
while (true) {
if (st == end) break;
int mid = (st + end + 1) / 2;
m = query(mid, y1, x2, y2);
if (mid == end && m == 1) break;
if (m == 0) {
if (mid == end)
end--;
else
end = mid;
} else {
st = mid;
}
}
x1 = end;
st = x1, end = n;
while (true) {
if (st == end) break;
int mid = (st + end) / 2;
m = query(x1, y1, mid, y2);
if (mid == st && m == 1) break;
if (m == 0) {
if (st == mid)
st++;
else
st = mid;
} else {
end = mid;
}
}
x2 = st;
tmp.push_back(x1);
tmp.push_back(y1);
tmp.push_back(x2);
tmp.push_back(y2);
ans.insert(tmp);
}
cout << "! ";
for (auto el : ans)
for (auto num : el) cout << num << ' ';
cout << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, p2 = 1;
long long A[100010];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> A[i];
for (; p2 * 2 <= n; p2 *= 2) {
};
long long ans = 0;
for (int i = 1; i < n; i++) {
while (i + p2 > n) p2 /= 2;
A[i + p2] += A[i];
ans += A[i];
A[i] = 0;
cout << ans << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
long long h, r;
scanf("%I64d%I64d", &r, &h);
long long sum = 0;
sum += h / r * 2;
long long tmp = h % r;
if (4 * tmp * tmp >= 3 * r * r)
sum += 3;
else if (2 * tmp >= r)
sum += 2;
else
sum += 1;
printf("%I64d\n", sum);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double Pi = acos(-1.0);
inline int cmp(double x, double y = 0, double tol = 1e-8) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
struct point {
double x, y;
point(double x = 0, double y = 0) : x(x), y(y) {}
point operator+(point q) { return point(x + q.x, y + q.y); }
point operator-(point q) { return point(x - q.x, y - q.y); }
point operator*(double t) { return point(x * t, y * t); }
point operator/(double t) { return point(x / t, y / t); }
double operator*(point q) { return x * q.x + y * q.y; }
double operator%(point q) { return x * q.y - y * q.x; }
double mod() { return sqrt(x * x + y * y); }
point rotate(double t) {
return point(x * cos(t) - y * sin(t), x * sin(t) + y * cos(t));
}
int cmp(point q) const {
if (int t = ::cmp(x, q.x)) return t;
return ::cmp(y, q.y);
}
bool operator==(point q) const { return cmp(q) == 0; }
bool operator!=(point q) const { return cmp(q) != 0; }
bool operator<(point q) const { return cmp(q) < 0; }
static point pivot;
};
point point::pivot;
double poly_area(vector<point>& T) {
double s = 0;
int n = T.size();
for (int i = 0; i < n; i++) s += T[i] % T[(i + 1) % n];
return s / 2;
}
point line_intersect(point p, point q, point r, point s) {
point a = q - p, b = s - r, c = point(p % q, r % s);
return point(point(a.x, b.x) % c, point(a.y, b.y) % c) / (a % b);
}
vector<point> halfplane(vector<point>& p, pair<point, point> semiplano) {
vector<point> q;
point p1 = semiplano.first, p2 = semiplano.second;
int n = p.size();
for (int i = 0; i < n; i++) {
double c = (p2 - p1) % (p[i] - p1);
double d = (p2 - p1) % (p[(i + 1) % n] - p1);
if (cmp(c) >= 0) q.push_back(p[i]);
if (cmp(c * d) < 0)
q.push_back(line_intersect(p1, p2, p[i], p[(i + 1) % n]));
}
return q;
}
vector<point> semi_plano_cruzado(vector<pair<point, point> > semiplano) {
vector<point> p;
p.push_back(point(-1e9, -1e9));
p.push_back(point(-1e9, +1e9));
p.push_back(point(+1e9, +1e9));
p.push_back(point(+1e9, -1e9));
int n = semiplano.size();
for (int i = 0; i < n; i++) {
p = halfplane(p, semiplano[i]);
if (p.size() == 0) break;
}
return p;
}
int main() {
double w, h, a;
cin >> w >> h >> a;
double gama = atan(w / h);
double beta = atan(h / w);
vector<point> p, q;
p.push_back(point(-0.5 * w, -0.5 * h));
p.push_back(point(-0.5 * w, 0.5 * h));
p.push_back(point(0.5 * w, 0.5 * h));
p.push_back(point(0.5 * w, -0.5 * h));
a = a * Pi / 180;
double teta = 0.5 * Pi + a - gama - beta;
q.push_back(point(-0.5 * w, -0.5 * h));
q.push_back(point(-0.5 * w, 0.5 * h));
q.push_back(point(0.5 * w, 0.5 * h));
q.push_back(point(0.5 * w, -0.5 * h));
for (int i = 0; i < 4; i++) q[i] = q[i].rotate(teta);
for (int i = 0; i < 4; i++) {
p = halfplane(p, make_pair(q[(i + 1) % 4], q[i]));
}
printf("%.9lf\n", fabs(poly_area(p)));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> a;
vector<vector<vector<long long>>> dp;
long long solve(long long i, long long j, long long x, long long l) {
if (x == 0) {
if (a.size() - i < l) return 0;
return -1e12;
}
if (i == a.size()) {
if (x == 0) return 0;
return -1e12;
}
if (dp[i][j][x] != -1) return dp[i][j][x];
if (i - j <= l)
return dp[i][j][x] =
max(a[i] + solve(i + 1, i, x - 1, l), solve(i + 1, j, x, l));
else
return dp[i][j][x] = solve(i + 1, j, x, l);
}
void tests() {
long long n, k, x;
cin >> n >> k >> x;
a.resize(n + 1);
dp.assign(n + 1,
vector<vector<long long>>(n + 1, vector<long long>(x + 1, -1)));
a[0] = 0;
for (long long i = 0; i < n; i++) cin >> a[i + 1];
long long ans = solve(1, 0, x, k);
if (ans < 0) ans = -1;
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
tests();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d %d", &n, &m);
char c[n];
scanf("%s", c);
int l, r;
char c1, c2;
for (int i = 0; i < m; i++) {
cin >> l >> r >> c1 >> c2;
l--, r--;
for (int j = l; j <= r; j++) {
if (c[j] == c1) {
c[j] = c2;
}
}
}
cout << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, x, y, z;
int f[100005];
int main() {
scanf("%d%d", &n, &m);
for (; m; --m) {
scanf("%d%d%d", &x, &y, &z);
k = 7;
k -= f[x];
k -= f[y];
k -= f[z];
if (!f[x]) f[x] = k & -k, k -= k & -k;
if (!f[y]) f[y] = k & -k, k -= k & -k;
if (!f[z]) f[z] = k & -k, k -= k & -k;
}
for (i = 1; i <= n; ++i) {
if (f[i] == 1)
printf("1");
else if (f[i] == 2)
printf("2");
else
printf("3");
if (i == n)
printf("\n");
else
printf(" ");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> l(n), r(n);
for (int i = 0; i < n; i++) cin >> l[i] >> r[i];
for (int i = 0; i < n; i++) {
if (l[i] == r[i])
cout << l[i] << " " << r[i] << " " << l[i] << '\n';
else {
int ego = l[i] - 1;
for (int j = 0; j < n; j++) {
if (i != j) {
if (l[i] == l[j]) {
if (l[i] <= l[j] and r[j] <= r[i]) {
ego = max(ego, r[j]);
}
}
}
}
cout << l[i] << " " << r[i] << " " << ego + 1 << "\n";
}
}
cout << endl;
}
int main() {
ios::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4200;
const double eps = 1e-6;
int n;
int main() {
double t, sum = 0;
scanf("%d", &n);
int tot = 0;
for (int i = 1; i <= (n << 1); i++) {
scanf("%lf", &t);
t = t - (int)t;
if (t < eps) tot++;
sum += (t < eps ? 0 : 1 - t);
}
double ans = 1e9;
for (int i = max(n - tot, 0); i <= n; i++) ans = min(ans, fabs(sum - i));
printf("%.3f\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int w, id, n;
vector<int> words;
vector<string> tmpwords;
vector<vector<int> > probs;
vector<vector<string> > tmpprobs;
map<string, int> in, has;
void input() {
cin >> w;
for (int i = 0; i < w; ++i) {
string word;
cin >> word;
tmpwords.push_back(word);
has[word] = 1;
in[word] = 0;
}
scanf("%d", &n);
while (n--) {
vector<string> vet;
int k;
scanf("%d", &k);
while (k--) {
string word;
cin >> word;
if (!has[word]) continue;
vet.push_back(word);
in[word] = 0;
}
tmpprobs.push_back(vet);
}
}
void rename() {
for (typeof(in.begin()) it = in.begin(); it != in.end(); ++it) {
it->second = id++;
}
for (int i = 0; i < tmpwords.size(); ++i) words.push_back(in[tmpwords[i]]);
for (int i = 0; i < tmpprobs.size(); ++i) {
vector<int> vet;
for (int j = 0; j < tmpprobs[i].size(); ++j)
vet.push_back(in[tmpprobs[i][j]]);
probs.push_back(vet);
}
}
int best = 0x3f3f3f3f;
int pos;
vector<int> occ[15];
void print() {
if (best == 0x3f3f3f3f)
printf("Brand new problem!\n");
else {
printf("%d\n", pos);
best = w * (w - 1) / 2 - best + 1;
printf("[:");
for (int i = 0; i < best; ++i) printf("|");
printf(":]\n");
}
}
bool monta(int p) {
for (int i = 0; i < words.size(); ++i) occ[i].clear();
for (int i = 0; i < words.size(); ++i) {
int w = words[i];
bool gg = 0;
for (int j = 0; j < probs[p].size(); ++j) {
int z = probs[p][j];
if (z != w) continue;
gg = 1;
occ[i].push_back(j);
}
if (!gg) return 0;
}
return 1;
}
int vis[1 << 15][15 * 15];
int solve(int far) {
memset(vis, 0x3f, sizeof vis);
priority_queue<pair<int, pair<int, int> > > que;
vis[0][0] = 0;
que.push(make_pair(0, make_pair(0, 0)));
bool out[15 * 15] = {0};
int res = far;
int gg = (1 << w) - 1;
while (!que.empty()) {
int b = -que.top().first;
int m = que.top().second.first;
int i = que.top().second.second;
que.pop();
if (vis[m][i] < b) continue;
if (i >= res) continue;
if (m == gg) {
res = i;
continue;
}
int c = 0;
for (int j = 0; j < words.size(); ++j) {
if (m & 1 << j) continue;
++c;
vector<int>::iterator it = lower_bound(occ[j].begin(), occ[j].end(), b);
if (it == occ[j].end()) continue;
int ni = i + c - 1;
int nm = m | 1 << j;
if (vis[nm][ni] > *it) {
vis[nm][ni] = *it;
que.push(make_pair(-(*it), make_pair(nm, ni)));
}
}
}
return res;
}
int main() {
input();
rename();
for (int i = 0; i < probs.size(); ++i) {
if (!monta(i)) continue;
int r = solve(best);
if (r < best) best = r, pos = i + 1;
}
print();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long f[110][2][2];
int ans[110];
int n;
long long k;
long long calc(long long x, long long a, long long b) {
if (f[x][a][b] != -1) return f[x][a][b];
f[x][a][b] = 0;
int y = n - x + 1;
if (x > y) return f[x][a][b] = 1;
for (int i = 0; i < 2; i++)
if (ans[x] == -1 || ans[x] == i)
for (int j = 0; j < 2; j++)
if (ans[y] == -1 || ans[y] == j)
if (i == j || x < y)
if (a || i <= j)
if (b || i + j <= 1)
f[x][a][b] += calc(x + 1, a || (i < j), b || ((i + j) <= 0));
return f[x][a][b];
}
int main() {
scanf("%d %I64d", &n, &k);
k++;
memset(f, -1, sizeof(f));
memset(ans, -1, sizeof(ans));
if (calc(1, 0, 0) < k) return puts("-1"), 0;
for (int i = 1; i <= n; i++) {
memset(f, -1, sizeof(f));
ans[i] = 0;
if (calc(1, 0, 0) < k) {
k -= calc(1, 0, 0);
ans[i] = 1;
}
}
for (int i = 1; i <= n; i++) printf("%d", ans[i]);
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const double pi = acos(-1);
const double eps = 1e-5;
const int INF = 0x3f3f3f3f;
const long long int INFLL = 0x3f3f3f3f3f3f3f3f;
long long int a[200010];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int T;
cin >> T;
while (T--) {
int n, x;
cin >> n >> x;
int sum = 0;
int cnt = 0;
for (int i = (1); i <= (n); i++) {
cin >> a[i];
sum += a[i] - x;
if (a[i] == x) cnt++;
}
if (cnt == n)
cout << 0 << '\n';
else if (!sum || cnt)
cout << 1 << '\n';
else
cout << 2 << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int nm = 0, fh = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') fh = -1;
for (; isdigit(c); c = getchar()) nm = nm * 10 + c - '0';
return nm * fh;
}
int n, mod, pw[200020], a[200020];
long long ans;
inline int get(int x) {
int res = 0;
while (x) x /= 10, res++;
return res;
}
struct HASH {
int tot, to[200020], cnt[200020], nt[200020], fs[999983];
inline void Ins(int x) {
for (int i = fs[x % 999983]; i; i = nt[i])
if (to[i] == x) {
cnt[i]++;
return;
}
to[++tot] = x, cnt[tot] = 1, nt[tot] = fs[x % 999983], fs[x % 999983] = tot;
}
inline int qry(int x) {
for (int i = fs[x % 999983]; i; i = nt[i])
if (to[i] == x) return cnt[i];
return 0;
}
} Hs[11];
int main() {
n = read(), mod = read(), pw[0] = 1;
for (int i = 1; i <= 10; i++) pw[i] = 10ll * pw[i - 1] % mod;
for (int i = 1; i <= n; i++) a[i] = read(), Hs[get(a[i])].Ins(a[i] % mod);
for (int i = 1; i <= n; i++) {
int now = ((long long)a[i] * pw[get(a[i])] % mod + a[i]) % mod;
if (!now) ans--;
for (int j = 1; j <= 10; j++) {
int tmp = (long long)a[i] * pw[j] % mod, dat = (mod - tmp) % mod;
ans += (long long)Hs[j].qry(dat);
}
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[5100][5100], f[5100][5100];
char str[5500];
int main() {
int n, i, j, m, now, ans;
cin >> n >> m;
gets(str);
for (i = 0; i < n; ++i) {
gets(str);
now = 0;
for (j = 0; j < m; ++j) {
if (str[j] == '0')
now = 0;
else
f[j][i] = ++now;
}
}
ans = 0;
for (i = 0; i < m; ++i) {
sort(&f[i][0], &f[i][0] + n);
for (j = n - 1; j >= 0; --j) {
ans = max(ans, ((n - j) * f[i][j]));
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
constexpr int mod = (int)1e9 + 7;
long long mod_mul(long long a, long long b) {
a = a % mod;
b = b % mod;
return (((a * b) % mod) + mod) % mod;
}
long long mod_add(long long a, long long b) {
a = a % mod;
b = b % mod;
return (((a + b) % mod) + mod) % mod;
}
long long binpow(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long binmul(long long a, long long b) {
long long res = 0;
a %= mod;
while (b > 0) {
if (b & 1) res = (res + a) % mod;
a = (a + a) % mod;
b >>= 1;
}
return res;
}
long long area(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c) {
return abs(a.first * b.second + b.first * c.second + c.first * a.second -
a.second * b.first - b.second * c.first - c.second * a.first);
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long min(long long a, long long b) {
if (a < b) {
return a;
}
return b;
}
long long max(long long a, long long b) {
if (a > b) {
return a;
}
return b;
}
double intlog(long long n, long long base) {
return (double)log(n) / log(base);
}
long long t, m, temp, temp2, root, q, k, i, j, r, u, v, w, n, p;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
vector<long long> a(n);
for (i = 0; i < n; i++) {
cin >> a[i];
}
long long res = 0;
long long p = 0;
for (int i = n - 1; i >= 0; i--) {
res += a[i] + p;
p += a[i] - 1;
}
cout << res << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
bool visited1[1000005], visited2[1000005];
long long counter = 0;
long long scc[1000005] = {0};
long long val[1000005] = {0};
long long dp[1000005];
vector<pair<long long, long long>> edg[1000005], redg[1000005];
stack<long long> dfsSatck;
vector<pair<long long, pair<long long, long long>>> ed;
vector<pair<long long, long long>> compg[1000005];
long long mushroomsCollected(long long m) {
n = (sqrt(8ll * m + 1ll) - 1ll) / 2ll;
long long ret = (12ll * m + 12ll * m * n - n * (n + 1ll) * (2ll * n + 1ll) -
3ll * n * (n + 1ll)) /
12ll;
return ret;
}
void dfs1(long long n) {
if (!visited1[n]) {
visited1[n] = true;
for (long long i = 0ll; i < (long long)edg[n].size(); i++) {
dfs1(edg[n][i].first);
}
dfsSatck.push(n);
}
}
void dfs2(long long n) {
if (!visited2[n]) {
visited2[n] = true;
scc[n] = counter;
for (long long i = 0ll; i < (long long)redg[n].size(); i++) {
dfs2(redg[n][i].first);
}
}
}
long long finalVal(int n) {
if (dp[n] == -1) {
long long maximum = 0;
for (long long i = 0ll; i < (long long)compg[n].size(); i++) {
maximum = max(compg[n][i].second + finalVal(compg[n][i].first), maximum);
}
dp[n] = val[n] + maximum;
return dp[n];
} else {
return dp[n];
}
}
int main() {
ios_base::sync_with_stdio(false);
long long int precision = numeric_limits<double>::digits10;
cin >> n >> m;
for (long long i = 0ll; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
edg[u].push_back(make_pair(v, w));
redg[v].push_back(make_pair(u, w));
ed.push_back(make_pair(u, make_pair(v, w)));
}
for (long long i = 1; i <= n; i++) {
if (!visited1[i]) dfs1(i);
}
for (long long repeater = 1; repeater <= n; repeater++) {
long long temp = dfsSatck.top();
dfsSatck.pop();
if (!visited2[temp]) {
counter++;
dfs2(temp);
}
}
for (long long i = 0ll; i < (long long)ed.size(); i++) {
long long u = scc[ed[i].first], v = scc[ed[i].second.first],
w = ed[i].second.second;
if (u == v) {
val[u] += mushroomsCollected(w);
} else {
compg[u].push_back(make_pair(v, w));
}
}
long long start;
cin >> start;
memset(dp, -1, sizeof(dp));
cout << finalVal(scc[start]) << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long s = 0;
int m, k, l, d, x, y, z, n, i, j, e = 0, t = 0;
double a, b, c;
int main() {
cin >> n >> m >> k >> l >> d >> e;
s = 2 * (n * m + k * l + d * e) + (n - l) * (n - l);
cout << s;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int val[300005];
vector<pair<int, long long> > v[300005];
long long ans[300005];
struct node {
int x, y, id;
friend bool operator<(node a, node b) {
if (a.x == b.x)
return a.y < b.y;
else
return a.x > b.x;
}
} q[300005];
long long bs(int x, int y) {
int lef = 0, rig = v[x].size() - 1, mid;
while (lef <= rig) {
mid = (lef + rig) >> 1;
if (v[x][mid].first > y) {
rig = mid - 1;
} else if (v[x][mid].first < y)
lef = mid + 1;
else
return v[x][mid].second;
}
return -1;
}
long long solve(int x, int y) {
long long ret = 0, d;
for (int i = x; i <= n; i += y) {
d = bs(i, y);
if (d == -1)
ret += val[i];
else {
ret += d;
break;
}
}
v[x].push_back(make_pair(y, ret));
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &q[i].x, &q[i].y);
q[i].id = i;
}
sort(q + 1, q + n + m);
for (int i = 1; i <= m; i++) {
if (q[i].x == q[i - 1].x && q[i].y == q[i - 1].y)
ans[q[i].id] = ans[q[i - 1].id];
else
ans[q[i].id] = solve(q[i].x, q[i].y);
}
for (int i = 1; i <= m; i++) printf("%I64d\n", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 110, TOF = 400000;
long long n, m, k, u, v, x, y, t, a, b, ans;
long long A[MAXN];
int dp[MAXN][TOF];
long long solve(int i, long long j) {
if (j < TOF && dp[i][j] != -1) return dp[i][j];
if (i == 0) return j;
if (j <= 1) return j;
long long ans = solve(i - 1, j) - solve(i - 1, j / A[i]);
if (j < TOF) dp[i][j] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(dp, -1, sizeof(dp));
cin >> n >> k;
for (int i = 1; i <= k; i++) cin >> A[i];
sort(A + 1, A + k + 1);
if (A[1] == 1) return cout << 0 << '\n', 0;
cout << solve(k, n);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long maxn = 2 * 1e5 + 10;
long long n;
vector<vector<long long>> edges;
vector<long long> b, is_bud, l;
long long buds = 0, all_leaves = 0, leaves0 = 0;
;
void dfs(long long v, long long p) {
long long gch = 0, lsum = 0;
for (long long to : edges[v]) {
if (to == p) continue;
dfs(to, v);
lsum += l[to];
if (is_bud[to]) continue;
if (edges[to].size() - b[to] == 1) {
gch++;
}
}
if (v != 0 && edges[v].size() - 1 - b[v] == gch && gch > 0) {
buds++;
b[p]++;
is_bud[v] = 1;
if (p != 0 && edges[p].size() - b[p] == 1) all_leaves++;
}
}
long long solve() {
cin >> n;
for (long long i = 0; i < n; i++) {
edges[i].clear();
b[i] = 0;
is_bud[i] = 0;
l[i] = 0;
}
buds = 0;
set<long long> neib;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
u--, v--;
if (u > v) swap(u, v);
if (u == 0) neib.insert(v);
edges[u].push_back(v);
edges[v].push_back(u);
}
all_leaves = 0, leaves0 = 0;
for (long long i = 1; i < n; i++) {
l[i] = (edges[i].size() == 1);
all_leaves += (edges[i].size() == 1);
}
dfs(0, -1);
for (long long i = 1; i < n; i++) {
if (edges[i].size() - b[i] == 1 && neib.find(i) != neib.end()) leaves0++;
}
if (leaves0 > 0) {
cout << all_leaves - buds << "\n";
} else {
cout << all_leaves - max(0ll, buds - 1) << "\n";
}
return 0;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
edges.resize(maxn);
b.resize(maxn);
is_bud.resize(maxn);
l.resize(maxn);
long long tt = 1;
cin >> tt;
while (tt--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 1; i < n; i++) {
if (s[i] < s[i - 1]) {
cout << "YES\n";
cout << i << " " << i + 1 << endl;
return 0;
}
}
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool IsStrictLeftTurn(pair<double, double> p1, pair<double, double> p2,
pair<double, double> p3) {
return (p2.first - p1.first) * (p3.second - p1.second) -
(p2.second - p1.second) * (p3.first - p1.first) >
1e-8;
}
vector<pair<double, double> > ConvexHull(vector<pair<double, double> > points) {
sort(points.begin(), points.end());
points.erase(unique(points.begin(), points.end()), points.end());
vector<pair<double, pair<double, double> > > p;
vector<pair<double, double> > ans;
int tn = ((int)points.size());
double midx = 0.0, midy = 0.0;
for (int(i) = 0; (i) < (tn); ++(i)) midx += points[i].first;
for (int(i) = 0; (i) < (tn); ++(i)) midy += points[i].second;
midx /= (double)tn;
midy /= (double)tn;
for (int(i) = 0; (i) < (tn); ++(i))
p.push_back(make_pair(
atan2((double)points[i].second - midy, (double)points[i].first - midx),
points[i]));
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
for (int(i) = 0; (i) < (tn); ++(i)) {
ans.push_back(p[i].second);
while (((int)ans.size()) > 2) {
int bz = ((int)ans.size());
if (IsStrictLeftTurn(ans[bz - 1], ans[bz - 2], ans[bz - 3])) break;
swap(ans[bz - 1], ans[bz - 2]);
ans.pop_back();
}
}
int pd = 0;
while (((int)ans.size()) - pd > 2) {
if (!IsStrictLeftTurn(ans[pd], ans[((int)ans.size()) - 1],
ans[((int)ans.size()) - 2])) {
ans.pop_back();
continue;
}
if (!IsStrictLeftTurn(ans[pd + 1], ans[pd], ans[((int)ans.size()) - 1])) {
pd++;
continue;
}
break;
}
vector<pair<double, double> > trans;
for (int(i) = (pd); (i) < (((int)ans.size())); ++(i)) trans.push_back(ans[i]);
return trans;
}
bool PointEquals(pair<double, double> p1, pair<double, double> p2) {
return abs(p1.first - p2.first) <= 1e-8 && abs(p1.second - p2.second) <= 1e-8;
}
bool IsIntersecting(pair<pair<double, double>, pair<double, double> > segment1,
pair<pair<double, double>, pair<double, double> > segment2,
int* parallel, pair<double, double>* intersection_point) {
double xx1 = segment1.first.first;
double yy1 = segment1.first.second;
double xx2 = segment1.second.first;
double yy2 = segment1.second.second;
double xx3 = segment2.first.first;
double yy3 = segment2.first.second;
double xx4 = segment2.second.first;
double yy4 = segment2.second.second;
*parallel = 0;
if (fabs((yy4 - yy3) * (xx2 - xx1) - (xx4 - xx3) * (yy2 - yy1)) <= 1e-8) {
*parallel = 1;
if (PointEquals(segment1.first, segment2.first) ||
PointEquals(segment1.first, segment2.second)) {
*intersection_point = segment1.first;
return true;
} else if (PointEquals(segment1.second, segment2.first) ||
PointEquals(segment1.second, segment2.second)) {
*intersection_point = segment1.second;
return true;
}
return false;
}
double ua = ((xx4 - xx3) * (yy1 - yy3) - (yy4 - yy3) * (xx1 - xx3)) /
((yy4 - yy3) * (xx2 - xx1) - (xx4 - xx3) * (yy2 - yy1));
double& xi = (*intersection_point).first;
double& yi = (*intersection_point).second;
xi = xx1 + ua * (xx2 - xx1);
yi = yy1 + ua * (yy2 - yy1);
return ((xi + 1e-8 >= fmin(xx1, xx2)) && (xi - 1e-8 <= fmax(xx1, xx2)) &&
(yi + 1e-8 >= fmin(yy1, yy2)) && (yi - 1e-8 <= fmax(yy1, yy2)) &&
(xi + 1e-8 >= fmin(xx3, xx4)) && (xi - 1e-8 <= fmax(xx3, xx4)) &&
(yi + 1e-8 >= fmin(yy3, yy4)) && (yi - 1e-8 <= fmax(yy3, yy4)));
}
double PolygonArea(vector<pair<double, double> > polygon) {
double ret = 0;
for (int(i) = 0; (i) < (((int)polygon.size())); ++(i)) {
ret += (double)(polygon[i].first *
polygon[(i + 1) % ((int)polygon.size())].second);
ret -= (double)(polygon[i].second *
polygon[(i + 1) % ((int)polygon.size())].first);
}
return abs(ret) / 2.0;
}
double PolarAngle(pair<double, double> the_point) {
if (fabs(the_point.first) <= 1e-8 && fabs(the_point.second) <= 1e-8)
return -1.0;
if (fabs(the_point.first) <= 1e-8)
return (the_point.second > 1e-8 ? 1.0 : 3.0) * acos(0);
double theta = atan(1.0 * the_point.second / the_point.first);
if (the_point.first > 1e-8)
return (the_point.second >= -1e-8 ? theta : (4 * acos(0) + theta));
return (2 * acos(0) + theta);
}
int PointInsidePolygon(vector<pair<double, double> > polygon,
pair<double, double> the_point) {
int n = polygon.size();
double ang = 0.0;
for (int i = n - 1, j = 0; j < n; i = j++) {
pair<double, double> v(polygon[i].first - the_point.first,
polygon[i].second - the_point.second);
pair<double, double> w(polygon[j].first - the_point.first,
polygon[j].second - the_point.second);
double va = PolarAngle(v);
double wa = PolarAngle(w);
double xx = wa - va;
if (va < -0.5 || wa < -0.5 || fabs(fabs(xx) - 2 * acos(0)) < 1e-8) {
return true;
}
if (xx < -2 * acos(0))
ang += xx + 4 * acos(0);
else if (xx > 2 * acos(0))
ang += xx - 4 * acos(0);
else
ang += xx;
}
return (ang * ang > 1.0);
}
vector<pair<double, double> > window;
vector<pair<double, double> > PolygonIntersection(
vector<pair<double, double> > p1, vector<pair<double, double> > p2) {
vector<pair<double, double> > ps;
for (int(i) = 0; (i) < (((int)p1.size())); ++(i))
if (PointInsidePolygon(p2, p1[i])) ps.push_back(p1[i]);
for (int(i) = 0; (i) < (((int)p2.size())); ++(i))
if (PointInsidePolygon(p1, p2[i])) {
bool ok = true;
for (int(j) = 0; (j) < (((int)ps.size())); ++(j))
if (PointEquals(ps[j], p2[i])) {
ok = false;
break;
}
if (ok) ps.push_back(p2[i]);
}
for (int(i) = 0; (i) < (((int)p1.size())); ++(i))
for (int(j) = 0; (j) < (((int)p2.size())); ++(j)) {
pair<double, double> inter;
int dummy;
pair<pair<double, double>, pair<double, double> > seg1 =
make_pair(p1[i], p1[(i + 1) % ((int)p1.size())]);
pair<pair<double, double>, pair<double, double> > seg2 =
make_pair(p2[j], p2[(j + 1) % ((int)p2.size())]);
if (IsIntersecting(seg1, seg2, &dummy, &inter) && !dummy) {
bool ok = true;
for (int(k) = 0; (k) < (((int)ps.size())); ++(k))
if (PointEquals(ps[k], inter)) {
ok = false;
break;
}
if (ok) ps.push_back(inter);
}
}
if (((int)ps.size()) <= 2) {
return vector<pair<double, double> >();
}
vector<pair<double, double> > ch = ConvexHull(ps);
return ch;
}
int main() {
int n;
int h;
int f;
cin >> n >> h >> f;
for (int(i) = 0; (i) < (n); ++(i)) {
int buf1, buf2;
scanf("%d%d", &buf1, &buf2);
window.push_back(make_pair((double)buf1, (double)buf2));
}
vector<vector<pair<double, double> > > enemy;
pair<double, double> toplight = make_pair(0.0, (double)f);
pair<double, double> botlight = make_pair(0.0, -1.0 * (double)f);
pair<pair<double, double>, pair<double, double> > topseg =
make_pair(make_pair(0.0, (double)h), make_pair(1.0, (double)h));
pair<pair<double, double>, pair<double, double> > botseg = make_pair(
make_pair(0.0, -1.0 * (double)h), make_pair(1.0, -1.0 * (double)h));
double ret = 0.0;
for (int(i) = 0; (i) < (n); ++(i)) {
pair<double, double> intersection;
int dummy;
pair<pair<double, double>, pair<double, double> > leftseg =
make_pair(toplight, make_pair(window[i].first, (double)h));
pair<pair<double, double>, pair<double, double> > rightseg =
make_pair(toplight, make_pair(window[i].second, (double)h));
vector<pair<double, double> > p;
IsIntersecting(topseg, leftseg, &dummy, &intersection);
p.push_back(intersection);
IsIntersecting(topseg, rightseg, &dummy, &intersection);
p.push_back(intersection);
IsIntersecting(botseg, rightseg, &dummy, &intersection);
p.push_back(intersection);
IsIntersecting(botseg, leftseg, &dummy, &intersection);
p.push_back(intersection);
enemy.push_back(p);
ret += PolygonArea(p);
}
for (int(i) = 0; (i) < (n); ++(i)) {
pair<double, double> intersection;
int dummy;
pair<pair<double, double>, pair<double, double> > leftseg =
make_pair(botlight, make_pair(window[i].first, -1.0 * (double)h));
pair<pair<double, double>, pair<double, double> > rightseg =
make_pair(botlight, make_pair(window[i].second, -1.0 * (double)h));
vector<pair<double, double> > p;
IsIntersecting(topseg, leftseg, &dummy, &intersection);
p.push_back(intersection);
IsIntersecting(topseg, rightseg, &dummy, &intersection);
p.push_back(intersection);
IsIntersecting(botseg, rightseg, &dummy, &intersection);
p.push_back(intersection);
IsIntersecting(botseg, leftseg, &dummy, &intersection);
p.push_back(intersection);
ret += PolygonArea(p);
for (int(j) = 0; (j) < (((int)enemy.size())); ++(j)) {
ret -= PolygonArea(PolygonIntersection(p, enemy[j]));
}
}
printf("%.9lf\n", ret);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void show(const vector<T> &a) {
for (T x : a) cout << x << " ";
cout << '\n';
}
vector<long long> xx = {1, 0, -1, 0};
vector<long long> yy = {0, 1, 0, -1};
string dir = "LRUD";
const long long N = 2e5 + 50, oo = 3e18 + 500;
const long long mod = 1e9 + 7;
const long double eps = 1e-7, PI = 2 * acos(0.0);
long long n, m, k;
long long cnt = 0;
long long lg = 18;
vector<long long> g[N];
vector<long long> rg[N];
vector<long long> visit(N, 0);
signed main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n >> m >> k;
vector<vector<long long> > t(n, vector<long long>(m));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> t[i][j];
}
}
vector<vector<long long> > del(m);
for (long long j = 0; j < m; j++) {
long long num = 0;
for (long long i = 0; i < n; i++) {
if (t[i][j] == 1) {
cnt = 0;
long long score = 0;
for (long long z = i; z < n && cnt < k; z++) {
score += t[z][j];
cnt++;
}
del[j].push_back(score);
}
}
}
vector<long long> dp(n * m + 1, oo);
dp[0] = 0;
for (long long j = 0; j < m; j++) {
vector<long long> ndp(n * m + 1, oo);
for (long long w = 0; w <= n * m; w++) {
ndp[w] = min(ndp[w], dp[w]);
;
for (long long d = 0; d < ((long long)(del[j].size())); d++) {
long long score = del[j][d];
if (w >= score) ndp[w] = min(ndp[w], dp[w - score] + d);
;
}
}
dp = ndp;
}
for (long long w = n * m; w >= 0; w--) {
if (dp[w] != oo) {
return cout << w << " " << dp[w], 0;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> n >> m;
bool ex[m][26];
for (int i = 0; i < m; i++) {
for (int j = 0; j < 26; j++) ex[i][j] = false;
}
string s;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++) {
ex[j][int(s[j] - 'A')] = true;
}
}
long long answ = 1, t;
for (int i = 0; i < m; i++) {
t = 0;
for (int j = 0; j < 26; j++) {
if (ex[i][j]) t++;
}
answ *= (t);
answ %= 1000000007;
}
cout << answ;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector<int> v(n), rank(n + 1), v1(m);
for (int i = 0; i < n; i++) {
cin >> v[i];
rank[v[i]] = i + 1;
}
for (int i = 0; i < m; i++) cin >> v1[i];
long long cnt = 0;
long long pre = 0;
for (int i = 0; i < m; i++) {
if (rank[v1[i]] < pre) {
cnt += 1;
} else {
int k = rank[v1[i]] - 1;
k -= i;
cnt += (2 * k + 1);
pre = rank[v1[i]];
}
}
cout << cnt << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100010;
const int INF = 1000000;
int n;
stack<int> killers;
int main() {
cin >> n;
int values[n + 1], life[n + 1];
for (int i = 1; i <= n; ++i) {
cin >> values[i];
}
life[0] = INF;
values[0] = 0;
killers.push(0);
for (int i = 1; i <= n; ++i) {
life[i] = 1;
while (killers.size() && values[i] > values[killers.top()]) {
life[i] = max(life[i], life[killers.top()] + 1);
killers.pop();
}
killers.push(i);
}
int sol = 0;
for (int i = 1; i <= n; ++i) {
if (life[i] < INF) {
sol = max(sol, life[i]);
}
}
cout << sol << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
vector<int> ans;
vector<int> dist;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, s, d;
cin >> n >> m >> s >> d;
if (d == 1) {
cout << "IMPOSSIBLE\n";
return 0;
}
for (int temp, i = 0; i < n; ++i) {
cin >> temp;
v.push_back(temp);
}
sort(v.begin(), v.end());
int prevS = -1000000001;
int prevO = -1;
for (int i = 0; i < n; ++i) {
if (v[i] - prevO - 2 >= s) {
ans.push_back(1);
dist.push_back(prevO - prevS + 2);
ans.push_back(0);
dist.push_back(v[i] - prevO - 2);
prevS = prevO = v[i];
} else if (v[i] - prevS + 2 <= d) {
prevO = v[i];
} else {
cout << "IMPOSSIBLE\n";
return 0;
}
}
if (prevO - prevS + 2) {
ans.push_back(1);
dist.push_back(prevO - prevS + 2);
if (m - prevO - 1) {
ans.push_back(0);
dist.push_back(m - prevO - 1);
}
}
for (int i = 1; i < ans.size(); ++i) {
if (!ans[i]) {
cout << "RUN " << dist[i] << "\n";
} else {
cout << "JUMP " << dist[i] << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, ans = 1, t[maxn], lst[maxn], pos[maxn];
int main() {
scanf("%d", &n);
lst[1] = 0, pos[0] = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &t[i]);
if (lst[pos[t[i]]] == t[i])
pos[i] = pos[t[i]], lst[pos[i]] = i;
else
lst[++ans] = i, pos[i] = ans;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 5;
int a[N][N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
a[0][1] = 1;
a[1][1] = 0;
a[1][2] = 1;
a[2][1] = -1;
a[2][2] = 0;
a[2][3] = 1;
for (int i = 3; i <= n; i++) {
for (int j = 1; j <= i + 1; j++) a[i][j] = a[i - 1][j - 1];
for (int j = 1; j <= i + 1; j++) a[i][j] += a[i - 2][j];
for (int j = 1; j <= i; j++) {
if (abs(a[i][j]) >= 2) a[i][j] %= 2;
}
}
cout << n << endl;
for (int i = 1; i <= n + 1; i++) cout << a[n][i] << ' ';
cout << endl;
cout << n - 1 << endl;
for (int i = 1; i <= n; i++) cout << a[n - 1][i] << ' ';
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long n, x, ci;
unsigned long long Even = 0, Odd = 0, MIN = 10e9 + 1;
cin >> n;
while (n--) {
cin >> x;
if (x % 2 == 0)
Even += x;
else {
ci++;
MIN = min(MIN, x);
Odd += x;
}
}
if (ci % 2 == 0)
cout << Even + Odd;
else
cout << Even + Odd - MIN;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& t) {
return in >> t.first >> t.second;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2>& t) {
return out << t.first << " " << t.second;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& t) {
for (long long i = 0; i < t.size(); i++) in >> t[i];
return in;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T>& t) {
for (long long i = 0; i < t.size(); i++) out << t[i] << " ";
return out;
}
vector<long long> mem(1e5 + 10, -1e18);
long long n;
long long get(long long pos) {
pos = (pos) % n;
if (mem[pos] != -1e18) return mem[pos];
cout << "? " << (pos) % n + 1 << endl;
long long ans;
cin >> ans;
return mem[pos] = ans;
}
signed main() {
long long rrrr = 1e5;
cin >> n;
long long n2 = n / 2;
long long a = get(0) - get(0 + n2);
if (a == 0) return cout << "! 1", 0;
if (abs(a) % 2 != 0) return cout << "! -1", 0;
long long l = 0, r = n / 2;
while (l < r) {
long long m = (l + r) / 2;
if (get(m) - get(m + n2) == 0) return cout << "! " << m + 1 << endl, 0;
if (get(m) - get(m + n2) < 0 == get(l) - get(l + n2) < 0) {
l = m;
} else
r = m;
}
cout << "! " << l + 1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int freq[1103];
int n, k, time1 = 0, min, len, t, time2 = 0, c, c1;
cin >> n >> k;
for (int i = 0; i < 1103; i++) freq[i] = 0;
for (int i = 1; i <= n; i++) {
string str;
cin >> str;
int l = str.length();
freq[l]++;
}
string pass;
cin >> pass;
len = pass.length();
int cnt = 0;
for (int j = 0; j < len; j++) {
cnt += freq[j];
}
int Min = cnt + cnt / k * 5 + 1;
cnt = -1;
for (int j = 0; j <= len; j++) {
cnt += freq[j];
}
int Max = cnt + cnt / k * 5 + 1;
printf("%d %d\n", Min, Max);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long N;
cin >> N;
string a;
cin >> a;
map<char, char> mp;
for (long long i = 0; i < 9; ++i) {
char temp;
cin >> temp;
mp['0' + i + 1] = temp;
}
for (long long i = 0; i < N; ++i) {
if (a.at(i) < mp[a.at(i)]) {
long long now = i;
while (true) {
if (a.at(now) <= mp[a.at(now)]) {
a.at(now) = mp[a.at(now)];
now += 1;
if (now == a.size()) {
break;
}
} else {
break;
}
}
break;
}
}
cout << a << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const int base = 1e9;
const int MAX = 2e5;
const long double EPS = 1e-10;
const long double PI = acos(-1.);
int n, m;
int D, E, v;
int d[MAX];
int e[MAX];
int x1, x2, adlsdss, y2;
int drab() {
int cur = INF;
int pos = lower_bound(d, d + D, adlsdss) - d;
if (pos < D) {
cur = min(cur, abs(adlsdss - d[pos]) + abs(y2 - d[pos]) + abs(x1 - x2));
}
pos--;
if (pos >= 0) {
cur = min(cur, abs(adlsdss - d[pos]) + abs(y2 - d[pos]) + abs(x1 - x2));
}
return cur;
}
int lift() {
int cur = INF;
int pos = lower_bound(e, e + E, adlsdss) - e;
if (pos < E) {
cur = min(cur, abs(adlsdss - e[pos]) + abs(y2 - e[pos]) +
(abs(x1 - x2) + v - 1) / v);
}
pos--;
if (pos >= 0) {
cur = min(cur, abs(adlsdss - e[pos]) + abs(y2 - e[pos]) +
(abs(x1 - x2) + v - 1) / v);
}
return cur;
}
int solve() {
int best = INF;
if (x1 == x2) {
return abs(adlsdss - y2);
}
if (D) {
best = min(best, drab());
}
if (E) {
best = min(best, lift());
}
return best;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> D >> E >> v;
for (int i = (0); i < (D); ++i) {
cin >> d[i];
}
for (int j = (0); j < (E); ++j) {
cin >> e[j];
}
int q;
cin >> q;
for (int i = (0); i < (q); ++i) {
cin >> x1 >> adlsdss >> x2 >> y2;
cout << solve() << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class Pool {
public:
Pool(int n, double* a) : m_n(n), m_svArray(1 << n), m_a(a) {}
const vector<double>& get(int n);
private:
int m_n;
vector<vector<double> > m_svArray;
double* m_a;
};
const vector<double>& Pool::get(int n) {
if (!m_svArray[n].empty()) return m_svArray[n];
vector<int> onePos;
int ntemp = n;
for (int i = 0; i < m_n; i++) {
if (ntemp & 0x1) onePos.push_back(i);
ntemp = ntemp >> 1;
}
int num = onePos.size();
if (num == 1) {
m_svArray[n].resize(m_n);
m_svArray[n][m_n - 1 - onePos[0]] = 1;
} else {
m_svArray[n].resize(m_n);
double fac = 2.0 / (num * (num - 1));
for (int i = 0; i < num - 1; i++) {
int n1 = n & (((1 << m_n) - 1) ^ (1 << onePos[i]));
const vector<double>& v1 = get(n1);
for (int j = i + 1; j < num; j++) {
int n2 = n & (((1 << m_n) - 1) ^ (1 << onePos[j]));
const vector<double>& v2 = get(n2);
for (int k = 0; k < m_n; k++) {
m_svArray[n][k] +=
fac * (m_a[(m_n - 1 - onePos[j]) * m_n + (m_n - 1 - onePos[i])] *
v1[k] +
m_a[(m_n - 1 - onePos[i]) * m_n + (m_n - 1 - onePos[j])] *
v2[k]);
}
}
}
}
return m_svArray[n];
}
int main() {
int n;
cin >> n;
double a[n * n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i * n + j];
}
}
Pool pool(n, a);
const vector<double>& result = pool.get((1 << n) - 1);
cout.precision(6);
cout.setf(ios::fixed, ios::floatfield);
for (int i = 0; i < n; i++) {
cout << result[i] << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1000100][3];
int main() {
int n;
cin >> n;
for (int i = 0; i < 1000010; i++) a[i][0] = 0;
int r;
int max_length = 0;
int nomer = 0;
int length = 1000000;
for (int i = 0; i < n; i++) {
cin >> r;
if (a[r][0] == 0) {
a[r][0] = 1;
a[r][1] = i + 1;
a[r][2] = i + 1;
} else if (a[r][0] == 1) {
a[r][0] = 2;
a[r][2] = i + 1;
} else {
a[r][0]++;
a[r][2] = i + 1;
}
if (max_length < a[r][0]) {
nomer = r;
max_length = a[r][0];
length = a[r][2] - a[r][1];
}
if (max_length == a[r][0] && length > a[r][2] - a[r][1]) {
nomer = r;
length = a[r][2] - a[r][1];
}
}
cout << a[nomer][1] << " " << a[nomer][2] << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
cin >> c;
string s;
cin >> s;
string keyboard = "qwertyuiopasdfghjkl;zxcvbnm,./";
if (c == 'R') {
for (int i = 0; i < s.length(); i++) {
int n = keyboard.find(s[i], 0);
s[i] = keyboard[n - 1];
}
for (int i = 0; i < s.length(); i++) cout << s[i];
} else {
for (int i = 0; i < s.length(); i++) {
int n = keyboard.find(s[i], 0);
s[i] = keyboard[n + 1];
}
for (int i = 0; i < s.length(); i++) cout << s[i];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, ans1, ans2;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
if (n % 2 == 0) {
ans1 = 4;
ans2 = n - 4;
} else {
ans1 = 9;
ans2 = n - 9;
}
cout << ans1 << " " << ans2 << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1111, base = 1e9 + 7;
int n, a[26], f[N][3];
char s[N];
int main() {
scanf("%d%s", &n, s);
for (int i = 0; i < 26; ++i) scanf("%d", &a[i]);
f[0][0] = 1;
for (int i = 1; i <= n; ++i) {
if (!i) continue;
int len = 1e9 + 7;
f[i][1] = -1e9 + 7;
f[i][2] = 1e9 + 7;
for (int j = i - 1; j >= 0; --j) {
len = min(len, a[s[j] - 'a']);
if (len < i - j) break;
f[i][0] = (f[i][0] + f[j][0]) % base;
f[i][1] = max(f[i][1], max(i - j, f[j][1]));
f[i][2] = min(f[i][2], f[j][2] + 1);
}
}
for (int i = 0; i < 3; ++i) printf("%d\n", f[n][i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int hd[N], pre[N], to[N], num;
int dep[N], len[N], cnt, llen[N], rlen[N], fa[N];
bool flag;
void adde(int x, int y) {
num++;
pre[num] = hd[x];
hd[x] = num;
to[num] = y;
}
void dfs1(int v, int ffa) {
len[v] = 0;
fa[v] = ffa;
for (int i = hd[v]; i; i = pre[i]) {
int u = to[i];
if (u == ffa) continue;
dep[u] = dep[v] + 1;
dfs1(u, v);
len[v] = max(len[v], len[u] + 1);
}
}
void dfs2(int v, int ffa, int md) {
int fi = md, se = 0, th = 0;
for (int i = hd[v]; i; i = pre[i]) {
int u = to[i];
if (u == ffa) continue;
int lu = len[u] + 1;
if (lu > fi)
th = se, se = fi, fi = lu;
else if (lu > se)
th = se, se = lu;
else if (lu > th)
th = lu;
}
if (fi >= cnt && se >= cnt && th >= cnt) flag = 1;
for (int i = hd[v]; i; i = pre[i]) {
int u = to[i];
if (u == ffa) continue;
int lu = len[u] + 1;
dfs2(u, v, (lu == fi ? se : fi) + 1);
}
}
int main() {
int tes;
scanf("%d", &tes);
while (tes--) {
int n, s, t;
scanf("%d%d%d", &n, &s, &t);
num = 0;
for (int i = 1; i <= n; i++) hd[i] = 0;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
adde(x, y), adde(y, x);
}
dep[s] = 0;
dfs1(s, 0);
cnt = dep[t];
for (int i = cnt, v = t; i >= 0; i--, v = fa[v]) {
rlen[i] = len[v];
}
dep[t] = 0;
dfs1(t, 0);
for (int i = 0, v = s; i <= cnt; i++, v = fa[v]) {
llen[i] = len[v];
}
int l = 0, r = cnt;
for (int i = 1; i <= n; i++) {
l = max(l, r - (cnt - rlen[r]));
if (l >= r) break;
r = min(r, l + (cnt - llen[l]));
if (l >= r) break;
}
if (l < r) {
puts("NO");
continue;
}
flag = 0;
dfs1(1, 0), dfs2(1, 0, 0);
if (flag)
puts("YES");
else
puts("NO");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-12;
int S;
int A[3];
double ans[3];
int main() {
scanf("%d", &S);
int sum = 0;
for (int i = 0; i < 3; i++) {
scanf("%d", &A[i]);
sum += A[i];
}
if (A[0] == 0 && A[1] == 0 && A[2] == 0) {
puts("0 0 0");
return 0;
}
for (int i = 0; i < 3; i++) {
ans[i] = 1.0 * S * A[i] / sum;
printf("%.12lf ", ans[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int x, l, i, j, poz_gas, ok;
char s[105];
int main() {
cin >> x;
for (l = 1; l <= x; l++) {
cin >> i;
cin.get();
cin.get(s, 105);
for (j = 0; j < i; j++) {
if (strchr("8", s[j]) && ok == 0) {
poz_gas = j;
ok = 1;
}
}
if (i - poz_gas >= 11 && ok == 1)
cout << "YES\n";
else
cout << "NO\n";
poz_gas = 0;
ok = 0;
cin.get();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long P = 1000000009;
long long pow(long long was, long long exp) {
if (exp == 1) return was;
if (exp % 2 == 0) {
long long r = pow(was, exp / 2);
return (r * r) % P;
} else {
long long r = pow(was, exp / 2);
return (((r * r) % P) * was) % P;
}
}
int main() {
long long n, m, k, z, f, q, ans;
cin >> n >> m >> k;
z = n / k;
f = n - m;
if (f >= z) {
ans = m;
} else {
q = z - f;
ans = pow(2, q);
if (ans == 0) ans = P;
ans--;
ans = 2 * ans;
ans %= P;
ans = ans * (k % P);
ans %= P;
ans += (m - k * q);
}
cout << ans % P;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int even = 0, odd = 0, a, x, n;
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> a;
if (a % 2 == 1)
odd++;
else
even++;
}
int m = min(even, x - 1);
int d = x - m;
if (d % 2 == 0) {
d++;
}
if (odd >= d && d <= x)
cout << "Yes\n";
else
cout << "No\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 30;
long long lis[N];
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> lis[i];
}
sort(lis, lis + n);
long long x, a, y, b;
cin >> x >> a >> y >> b;
long long k;
cin >> k;
long long g = a * b / gcd(a, b);
long long maj = 0;
for (int i = n - n / g; i < n; i++) {
maj += lis[i] / 100 * (x + y);
}
long long maj1 = 0, maj2 = 0;
for (int i = n - n / g - (n / a - n / g); i < n - n / g; i++) {
maj1 += lis[i] / 100 * x;
}
for (int i = n - n / g - (n / a - n / g) - (n / b - n / g);
i < n - n / g - (n / a - n / g); i++) {
maj1 += lis[i] / 100 * y;
}
for (int i = n - n / g - (n / b - n / g); i < n - n / g; i++) {
maj2 += lis[i] / 100 * y;
}
for (int i = n - n / g - (n / b - n / g) - (n / a - n / g);
i < n - n / g - (n / b - n / g); i++) {
maj2 += lis[i] / 100 * x;
}
maj += max(maj1, maj2);
if (maj < k) {
cout << -1 << endl;
continue;
}
long long l = -1, r = n;
while (r - l > 1) {
long long mid = (r + l) / 2;
long long maj = 0;
for (int i = n - mid / g; i < n; i++) {
maj += lis[i] / 100 * (x + y);
}
long long maj1 = 0, maj2 = 0;
for (int i = n - mid / g - (mid / a - mid / g); i < n - mid / g; i++) {
maj1 += lis[i] / 100 * x;
}
for (int i = n - mid / g - (mid / a - mid / g) - (mid / b - mid / g);
i < n - mid / g - (mid / a - mid / g); i++) {
maj1 += lis[i] / 100 * y;
}
for (int i = n - mid / g - (mid / b - mid / g); i < n - mid / g; i++) {
maj2 += lis[i] / 100 * y;
}
for (int i = n - mid / g - (mid / b - mid / g) - (mid / a - mid / g);
i < n - mid / g - (mid / b - mid / g); i++) {
maj2 += lis[i] / 100 * x;
}
maj += max(maj1, maj2);
if (maj < k) {
l = mid;
continue;
}
r = mid;
}
cout << r << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[10];
char v;
int a, b, c, n, x;
int main() {
scanf("%d", &n);
a = -2000000000;
b = 2000000000;
for (; n; --n) {
scanf(" %s %d %c", s, &x, &v);
if (s[0] == '<') {
if (s[1] == '\0') --x;
if (v == 'N') {
s[0] = '>';
++x;
}
} else {
if (s[1] == '\0') ++x;
if (v == 'N') {
s[0] = '<';
--x;
}
}
if (s[0] == '<' && b > x) b = x;
if (s[0] == '>' && a < x) a = x;
}
if (a <= b)
printf("%d\n", a);
else
printf("Impossible\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int arr[101];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
swap(arr[0], arr[n - 1]);
for (int i = 0; i < n; i++) cout << arr[i] << ' ';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int tree[1000005], a[1000005], b[1000005], n, tr[1000005], drr[1000005],
dr[1000005];
void update(int index) {
while (index <= n + 1) {
tree[index]++;
index += (index & (-index));
}
}
int query(int index) {
int sum = 0;
while (index > 0) {
sum += tree[index];
index -= (index & (-index));
}
return sum;
}
void up(int index) {
while (index <= n + 1) {
tr[index]++;
index += (index & (-index));
}
}
int q(int index) {
int sum = 0;
while (index > 0) {
sum += tr[index];
index -= (index & (-index));
}
return sum;
}
int main() {
int i, an, ans;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> a[i];
b[i] = a[i];
}
sort(b + 1, b + n + 1);
for (i = 1; i <= n; ++i) {
an = lower_bound(b + 1, b + 1 + n, a[i]) - b;
a[i] = an;
}
update(a[1]);
for (i = 2; i <= n; ++i) {
ans = query(a[i]);
an = i - 1;
an = an - ans;
update(a[i]);
drr[i] = an;
}
for (i = 1; i <= n / 2; ++i) {
int temp = a[i];
a[i] = a[n + 1 - i];
a[n + 1 - i] = temp;
}
up(a[1]);
for (i = 2; i <= n; ++i) {
ans = q(a[i]);
up(a[i]);
dr[n - i + 1] = ans;
}
long long int sum = 0;
for (i = 2; i < n; ++i) {
sum += (drr[i] * 1ll * dr[i]);
}
cout << sum << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long q;
cin >> q;
for (long long i = 2LL;
i < static_cast<long long>(sqrt(static_cast<double>(q))) + 1LL; ++i) {
if (q % i == 0LL) {
long long p = q / i;
for (long long j = 2LL;
j < static_cast<long long>(sqrt(static_cast<double>(p))) + 1LL;
++j) {
if (p % j == 0LL) {
cout << "1\n" << i * j << '\n';
return 0;
}
}
cout << "2\n";
return 0;
}
}
cout << "1\n0\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void setup() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(15);
}
int main() {
setup();
int N;
cin >> N;
int O = N;
vector<int> r(N + 1, 0);
while (N > 0) {
int LB = 1 << (31 - __builtin_clz(N));
int M = N;
while ((M - 1) & LB) M--;
int A = M - 1, B = M;
while (B <= N) {
r[A] = B;
r[B] = A;
A--;
B++;
}
N = A;
}
long long ans = 0;
for (int i = 0; i < O + 1; i++) ans += i ^ r[i];
cout << ans << endl;
for (int v : r) cout << v << " ";
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void checkDefine();
long long int n;
int main() {
cin >> n;
cout << n << " ";
for (int i = (1), _b = (n - 1); i <= _b; i++) cout << i << " ";
return 0;
}
void checkDefine() {
long long int n, a[200005];
map<long long int, long long int> m;
cin >> n;
for (int i = (0), _b = (n - 1); i <= _b; i++) {
cin >> a[i];
m[a[i]]++;
}
string s;
cin >> s;
{
cout << "s"
<< " = ";
cout << (s) << endl;
};
{
cout << "a"
<< " = ";
for (int _ = 0, _a = (n); _ < _a; _++) cout << a[_] << ' ';
cout << endl;
};
{
cout << "\"------------\""
<< " = ";
cout << ("------------") << endl;
};
for (__typeof(m.begin()) it = m.begin(); it != m.end(); ++it) {
cout << it->first << " " << it->second << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<vector<int> > v(n);
map<pair<int, int>, vector<pair<int, int> > > A;
for (int i = 0; i < n; ++i) {
v[i].resize(3);
for (int j = 0; j < 3; ++j) {
scanf("%d", &v[i][j]);
}
A[{v[i][0], v[i][1]}].push_back({v[i][2], i});
}
map<int, vector<pair<int, int> > > B;
for (auto &x : A) {
auto &w = x.second;
sort(w.begin(), w.end());
for (int i = 0; i + 1 < w.size(); i += 2) {
printf("%d %d\n", w[i].second + 1, w[i + 1].second + 1);
}
if (w.size() & 1) {
int x = w.back().second;
B[v[x][0]].push_back({v[x][1], x});
}
}
vector<pair<int, int> > C;
for (auto &x : B) {
auto &w = x.second;
sort(w.begin(), w.end());
for (int i = 0; i + 1 < w.size(); i += 2) {
printf("%d %d\n", w[i].second + 1, w[i + 1].second + 1);
}
if (w.size() & 1) {
int x = w.back().second;
C.push_back({v[x][0], x});
}
}
sort(C.begin(), C.end());
for (int i = 0; i + 1 < C.size(); i += 2)
printf("%d %d\n", C[i].second + 1, C[i + 1].second + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
string s;
cin >> n >> m;
cin >> s;
int pos = 0;
for (int i = 1; i < n; i++) {
if (s.substr(0, i) == s.substr(n - i, i)) {
pos = i;
}
}
cout << s;
for (int i = 1; i < m; i++) {
cout << s.substr(pos);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double PI = acos(-1);
double EPS = 1e-7;
int INF = 1000000000;
int MOD = 1000000007;
int MAXINT = 2147483647;
long long INFLL = 1000000000000000000LL;
long long MAXLL = 9223372036854775807LL;
int mx[8] = {-1, 1, 0, 0, -1, -1, 1, 1};
int my[8] = {0, 0, -1, 1, -1, 1, -1, 1};
int pos[100005][256];
char s[100005];
int main() {
int n;
scanf("%d", &n);
int len;
for (int(a) = (1); (a) <= (n); (a)++) {
scanf("%s", s);
len = strlen(s);
for (int(b) = (0); (b) <= (len - 1); (b)++) {
pos[b][s[b]]++;
}
}
for (int(a) = (0); (a) <= (len - 1); (a)++) {
if (pos[a]['?'] == n)
printf("a");
else {
int sisa = n - pos[a]['?'];
int sam = 0;
for (int(b) = (0); (b) <= (255); (b)++) {
if (b != '?' && pos[a][b] == sisa) {
sam = 1;
printf("%c", b);
break;
}
}
if (!sam) printf("?");
}
}
printf("\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long w, h;
int main() {
cin >> w >> h;
cout << (w + w % 2) * (h + h % 2) * (w / 2) / 2 * (h / 2) / 2;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> a[1011];
int ok[1011];
int d[1011];
void readData() {
int p;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p;
a[i].push_back(p);
}
}
int bfs(int s) {
int v;
queue<int> qu;
for (int i = 0; i <= n + 5; i++) {
ok[i] = 0;
}
qu.push(s);
ok[s] = 1;
while (qu.size()) {
int u = qu.front();
qu.pop();
for (int i = 0; i < a[u].size(); i++) {
v = a[u][i];
if (ok[v] == 0) {
ok[v] = 1;
qu.push(v);
}
}
}
return v;
}
int main() {
readData();
for (int i = 1; i <= n; i++) {
cout << bfs(i);
if (i == n) {
cout << endl;
} else
cout << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void segadd(int seg1[1 << 20], int seg2[1 << 20], int seg3[1 << 20], int i,
int j, int k, int a, int b, int c) {
if (a <= j && k <= b) {
seg1[i] += c;
seg2[i] += c;
} else if (!(b <= j || k <= a)) {
segadd(seg1, seg2, seg3, 2 * i + 1, j, (j + k) / 2, a, b, c);
segadd(seg1, seg2, seg3, 2 * i + 2, (j + k) / 2, k, a, b, c);
int k1 = seg1[2 * i + 1], k2 = seg1[2 * i + 2];
if (k1 >= k2) {
seg1[i] = k1 + seg2[i];
seg3[i] = seg3[2 * i + 1];
} else {
seg1[i] = k2 + seg2[i];
seg3[i] = seg3[2 * i + 2];
}
}
}
int main() {
int n;
scanf("%d", &n);
static int L[100000], V[100000], R[100000];
static pair<int, int> P[100000], X[100000];
for (int i = 0; i < n; i++) {
scanf("%d%d%d", L + i, V + i, R + i);
P[i].first = L[i];
P[i].second = i;
X[i].first = V[i];
X[i].second = i;
}
sort(P, P + n);
sort(X, X + n);
static int seg1[1 << 20] = {0}, seg2[1 << 20] = {0}, seg3[1 << 20] = {0};
for (int i = 0; i < 1 << 19; i++) {
seg3[i + (1 << 19) - 1] = i;
}
for (int i = (1 << 19) - 2; i >= 0; i--) {
seg3[i] = seg3[2 * i + 1];
}
int M = -1, mL, mV;
for (int i = 0, j = 0; i < n;) {
int k1 = P[i].first, k2 = X[j].first;
if (k1 <= k2) {
int l = P[i].second;
segadd(seg1, seg2, seg3, 0, 0, 1 << 19, V[l], R[l] + 1, 1);
int p = seg1[0], q = seg3[0];
if (M < p) {
M = p;
mL = P[i].first;
mV = q;
}
i++;
} else {
int l = X[j].second;
segadd(seg1, seg2, seg3, 0, 0, 1 << 19, V[l], R[l] + 1, -1);
j++;
}
}
printf("%d\n", M);
for (int i = 0; i < n; i++) {
if (L[i] <= mL && mL <= V[i] && V[i] <= mV && mV <= R[i]) {
printf("%d ", i + 1);
}
}
putchar('\n');
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
using pii = pair<long long, long long>;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
string b;
cin >> b;
string a = b;
vector<long long> ans;
for (long long i = 0; i + 1 < n; i++) {
if (a[i] == 'W') {
a[i + 1] = a[i + 1] == 'W' ? 'B' : 'W';
ans.push_back(i + 1);
}
}
if (a[n - 1] == 'W') {
ans.clear();
a = b;
for (long long i = 0; i + 1 < n; i++) {
if (a[i] == 'B') {
a[i + 1] = a[i + 1] == 'W' ? 'B' : 'W';
ans.push_back(i + 1);
}
}
if (a[n - 1] == 'B') {
cout << "-1\n";
return 0;
}
}
cout << ans.size() << "\n";
for (long long x : ans) cout << x << " ";
cout << "\n";
return 0;
}
| 2 |
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Code written by Aditya ;) || Codechef/codeforces: @adityaraj5200
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include<bits/stdc++.h>
using namespace std;
//#include<ext/pb_ds/assoc_container.hpp>
//#include<ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
//template<class T> using ordered_set=tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update >;
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define endl "\n"
#define mod 10e9 + 7
#define PI 3.14159265358979323846
#define deb(x) cout<<'>'<<#x<<" = "<<x<<endl
#define deb2(x, y) cout<<'>'<<#x<<" = "<<x<<" , "<<#y<<" = "<<y<<endl
#define all(x) x.begin(), x.end()
#define rall(v) v.rbegin(), v.rend()
#define sortall(x) sort(all(x))
#define lcm(a,b) (a*b)/__gcd(a,b)
#define gcd(a,b) __gcd(a,b)
#define range(a,b) (abs(b-a)+1)
#define gap(a,b) (abs(b-a)-1)
#define pb push_back
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define yes "YES"
#define no "NO"
#define chartoint(ch) ch-'0'
#define digits(n) 1+floor(log10(n))
#define presum(p,a,n) {p[0]=a[0];for(int i=1;i<(n);i++)p[i]=a[i]+p[i-1];}
#define cube(x) (x)*(x)*(x)
#define sq(x) (x)*(x)
#define fill0(a) memset(a,0,sizeof(a))
#define fillneg1(a) memset(a,-1,sizeof(a))
#define fillbig(a) memset(a,63,sizeof(a))
#define setbits(x) __builtin_popcount(x)
#define ctz(x) __builtin_ctz(x)
#define clz(x) __builtin_clz(x)
#define checkbit(x,i) (x&(1<<i)) //select the bit of position i of x
#define lowbit(x) ((x)&((x)^((x)-1))) //get the lowest bit of x
#define tr(x,it) for(auto it = x.begin(); it != x.end(); it++)
#define present(x,val) x.find(val) != x.end()
#define print(x) for(auto it=x.begin();it!=x.end();it++)\
cout<<*it<<' '; cout<<endl
#define in(x, a, b) (a < x && x < b)
#define LinR(x, a, b) (a <= x && x <= b)
#define Lin(x, a, b) (a <= x && x < b)
#define inR(x, a, b) (a < x && x <= b)
#define printii(x) for(auto it=x.begin();it!=x.end();it++)\
cout<<it->first<<' '<<it->second<<endl
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef long double lld;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<long long> vll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<string> vs;
/*/------------------------------ CODE BEGINS ------------------------------/*/
ll solve(){
ll n,m,x;
cin>>n>>m>>x;
ll row,col;
if(x%n==0) row = n;
else row = x%n;
col = ceil((double)x/n);
return ((row-1)*m)+col;
}
/*/------------------------------- CODE ENDS -------------------------------/*/
int main(){
fastio;
// cout << setprecision(12) << fixed;
int tc=1;
cin>>tc;
//precompute();
for(int t=1;t<=tc;t++){
// cout<<"Case #" << t << ": ";
cout<<solve()<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char ask(int u, int v) {
cout << "? " << u << " " << v << endl;
fflush(stdout);
char op[2];
scanf("%s", op);
return op[0];
}
int n;
const int maxn = 200;
int g[maxn + 5][maxn + 5];
int a[maxn + 5], b[maxn + 5], rk[maxn + 5];
bool cmp(const int x, const int y) { return rk[x] > rk[y]; }
void solve(int *a, int *b, int *rk) {
int tmpa[maxn + 5], tmpb[maxn + 5];
for (int i = 1; i <= n; ++i) tmpa[i] = a[i], tmpb[i] = b[i];
int tmp[maxn + 5];
for (int i = 1; i <= n; ++i) tmp[i] = i;
sort(tmp + 1, tmp + n + 1, cmp);
for (int i = 1; i <= n; ++i) a[i] = tmpa[tmp[i]], b[i] = tmpb[tmp[i]];
}
int main() {
int T;
cin >> T;
while (T--) {
cin >> n;
for (int i = 0; i <= 2 * n; ++i)
for (int j = 0; j <= 2 * n; ++j) g[i][j] = 0;
for (int i = 1; i <= 2 * n; i += 2) {
char op = ask(i, i + 1);
if (op == '>')
a[i / 2 + 1] = i, b[i / 2 + 1] = i + 1, g[i][i + 1] = 1;
else
a[i / 2 + 1] = i + 1, b[i / 2 + 1] = i, g[i + 1][i] = 1;
}
for (int i = 1; i <= n; ++i) rk[i] = 0;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j) {
char op = ask(b[i], b[j]);
if (op == '>')
++rk[i], g[b[i]][b[j]] = 1;
else
++rk[j], g[b[j]][b[i]] = 1;
}
solve(a, b, rk);
for (int i = 2; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
char op = ask(a[i], a[j]);
if (op == '>')
g[a[i]][a[j]] = 1;
else
g[a[j]][a[i]] = 1;
}
for (int j = 2; j <= n; ++j)
if (i != j) {
char op = ask(a[i], b[j]);
if (op == '>')
g[a[i]][b[j]] = 1;
else
g[b[j]][a[i]] = 1;
}
}
for (int i = 1; i <= 2 * n; ++i) rk[i] = 0;
for (int i = 1; i <= 2 * n; ++i) {
for (int j = 2; j <= n; ++j)
if (g[i][a[j]]) ++rk[i];
for (int j = 2; j <= n; ++j)
if (g[i][b[j]]) ++rk[i];
}
int res = -1;
for (int i = 2; i <= n; ++i)
if (rk[a[i]] == n - 1) res = a[i];
for (int i = 2; i <= n; ++i)
if (rk[b[i]] == n - 1) res = b[i];
ask(b[1], res);
cout << "!" << endl;
fflush(stdout);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
vector<vector<int>> e;
vector<int> deg;
int n;
int main() {
cin >> n;
e.resize(n);
deg.resize(n);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
--u, --v;
e[u].push_back(v);
e[v].push_back(u);
++deg[u], ++deg[v];
}
int res = n;
while (res > 1) {
int u, v;
for (u = 0; deg[u] != 1; ++u)
;
for (v = u + 1; deg[v] != 1; ++v)
;
cout << "? " << u + 1 << " " << v + 1 << endl;
int w;
cin >> w;
w--;
if (w == u || w == v) {
cout << "! " << w + 1 << endl;
return 0;
}
deg[u] = deg[v] = -1;
for (auto x : e[u]) --deg[x];
for (auto x : e[v]) --deg[x];
res -= 2;
}
int u;
for (u = 0; deg[u] != 0; u++)
;
cout << "! " << u + 1 << endl;
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.