solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
bool check(string s) {
sort(s.begin(), s.end());
for (int i = 1; i < s.size(); ++i)
if (s[i] - s[i - 1] != 1 || s[i] == s[i - 1]) return false;
return true;
}
int main() {
int n;
cin >> n;
while (n--) {
string s;
cin >> s;
if (check(s))
cout << "YES";
else
cout << "NO";
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
int a[200000];
bool q[200000];
vector<pair<int, int> > g[200000], og[200000];
int d[400000], vrest[200000], vmx[200000], vmx2[200000], vterm[200000];
int term[400000];
int s[400000], t[400000];
void dfs(int v, int p, int ind) {
if (d[ind] != -1) return;
if (!q[v]) {
term[ind] = 1;
d[ind] = 0;
return;
}
term[ind] = 0;
int mxterm = 0, mxterm2 = 0;
int rest = 0;
if (vrest[v] == -1) {
for (int i = 0; i < (int)(g[v].size()); ++i)
if (g[v][i].first != p) {
pair<int, int> &to = g[v][i];
dfs(to.first, v, to.second);
if (term[to.second]) {
term[ind] = 1;
++vterm[v];
if (d[to.second] > mxterm) {
mxterm2 = mxterm;
mxterm = d[to.second];
} else {
mxterm2 = max(mxterm2, d[to.second]);
}
} else {
rest += d[to.second];
}
swap(g[v][i], g[v][g[v].size() - 1]);
g[v].pop_back();
--i;
}
vmx[v] = mxterm;
vmx2[v] = mxterm2;
vrest[v] = rest;
} else {
mxterm = (term[ind ^ 1] && vmx[v] == d[ind ^ 1]) ? vmx2[v] : vmx[v];
rest = vrest[v];
if (!term[ind ^ 1]) rest -= d[ind ^ 1];
term[ind] = (vterm[v] - term[ind ^ 1]) > 0;
pair<int, int> &to = g[v][0];
dfs(to.first, v, to.second);
if (term[to.second]) {
term[ind] = 1;
mxterm = max(mxterm, d[to.second]);
} else {
rest += d[to.second];
}
}
d[ind] = 1 + mxterm + rest;
}
bool solve(int x) {
for (int i = 0; i < (int)(n); ++i) q[i] = a[i] >= x;
memset(d, -1, sizeof d);
memset(term, 0, sizeof term);
memset(vrest, -1, sizeof vrest);
memset(vterm, 0, sizeof vterm);
for (int i = 0; i < (int)(m); ++i)
if (d[i] == -1) {
dfs(t[i], s[i], i);
}
for (int i = 0; i < (int)(n); ++i)
if (q[i]) {
int mxterm = 0;
int rest = 0;
for (pair<int, int> to : g[i]) {
if (term[to.second])
mxterm = max(mxterm, d[to.second]);
else
rest += d[to.second];
}
if (1 + rest + mxterm >= k) return true;
}
return false;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < (int)(n); ++i) scanf("%d", a + i);
for (int i = 0; i < (int)(n - 1); ++i) {
int from, to;
scanf("%d%d", &from, &to), --from, --to;
g[from].push_back(make_pair(to, 2 * i));
g[to].push_back(make_pair(from, 2 * i + 1));
s[2 * i] = from;
t[2 * i] = to;
s[2 * i + 1] = to;
t[2 * i + 1] = from;
}
m = 2 * n - 2;
int lo = 1, hi = 1000000, mid;
for (int i = 0; i < (int)(n); ++i) og[i] = g[i];
while (lo < hi) {
mid = (lo + hi + 1) >> 1;
if (solve(mid))
lo = mid;
else
hi = mid - 1;
for (int i = 0; i < (int)(n); ++i) g[i] = og[i];
}
printf("%d\n", lo);
return 0;
}
| 9 |
#include <bits/stdc++.h>
const char dl = '\n';
const long double eps = 0.00000001;
const long long MOD = 1e9 + 7;
const long long mod = 998244353;
const double PI = 3.141592653589793238463;
const long double pi = 4 * atan(1.0);
using namespace std;
void debug() { cout << endl; }
template <typename H, typename... T>
void debug(H p, T... t) {
std::cout << p << " ";
debug(t...);
}
string second, t;
int ans;
int n, m, k, q;
map<int, vector<int>> mapa;
map<int, bool> was;
int main() {
fflush(stdin);
cout << fixed, cout.precision(18);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, j;
cin >> n;
int a[n + 5];
set<int> seta;
for (i = 1; i <= n; ++i) cin >> a[i], seta.insert(a[i]);
for (i = 1; i <= n; ++i) mapa[a[i]].push_back(i);
for (auto it : mapa) {
auto ve = it.second;
int sz = (int)ve.size();
if ((int)ve.size() == 1) {
ans = max(ans, ve[0] - 1);
ans = max(ans, n - ve[0]);
continue;
}
int cur = ve[0];
for (i = n; i > ve[0]; --i) {
if (a[i] != it.first) {
ans = max(ans, abs(i - ve[0]));
break;
}
}
for (i = 1; i < ve[0]; ++i) {
if (a[i] != it.first) {
ans = max(ans, abs(i - ve[0]));
break;
}
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T gi() {
T f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return f * x;
}
const int INF = 0x3f3f3f3f, N = 200003, M = N << 1;
int n;
int tot, head[N], ver[M], nxt[M];
int mx, id, dis[N], pre[N];
bool vis[N];
int fa[N], dep[N], son[N], sz[N], topp[N];
int seq[N], cnt;
vector<int> zj;
struct Ans {
int a, b, c;
};
vector<Ans> Program;
int dep1[N];
inline void add(int u, int v) {
ver[++tot] = v, nxt[tot] = head[u], head[u] = tot;
}
inline void bfs(int u) {
queue<int> q;
q.push(u);
memset(dis, 0, sizeof dis);
memset(vis, false, sizeof vis);
memset(pre, 0, sizeof pre);
vis[u] = true;
mx = id = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = nxt[i]) {
int v = ver[i];
if (vis[v]) continue;
vis[v] = true;
dis[v] = dis[u] + 1;
pre[v] = u;
if (dis[v] > mx) mx = dis[v], id = v;
q.push(v);
}
}
}
void dfs_dep(int u, int f) {
dep1[u] = dep1[f] + 1;
for (int i = head[u]; i; i = nxt[i]) {
int v = ver[i];
if (v == f) continue;
dfs_dep(v, u);
}
}
inline bool cmp(int x, int y) { return dep1[x] > dep1[y]; }
namespace LCA {
void dfs1(int u, int f) {
sz[u] = 1, dep[u] = dep[f] + 1, fa[u] = f;
for (int i = head[u]; i; i = nxt[i]) {
int v = ver[i];
if (v == f) continue;
dfs1(v, u);
sz[u] += sz[v];
if (sz[v] > sz[son[u]]) son[u] = v;
}
}
void dfs2(int u, int f) {
topp[u] = f;
if (!son[u]) return;
dfs2(son[u], f);
for (int i = head[u]; i; i = nxt[i]) {
int v = ver[i];
if (v == fa[u] || v == son[u]) continue;
dfs2(v, v);
}
}
int getLCA(int u, int v) {
while (topp[u] != topp[v]) {
if (dep[topp[u]] < dep[topp[v]]) swap(u, v);
u = fa[topp[u]];
}
if (dep[u] < dep[v]) return u;
return v;
}
} // namespace LCA
int main() {
n = gi<int>();
for (int i = 1; i < n; i += 1) {
int u = gi<int>(), v = gi<int>();
add(u, v), add(v, u);
}
bfs(1);
int lft = id;
bfs(lft);
int rght = id;
LCA ::dfs1(1, 0);
LCA ::dfs2(1, 1);
memset(vis, false, sizeof vis);
int now = rght;
vis[now] = true;
zj.push_back(now);
while (now != lft) now = pre[now], vis[now] = true, zj.push_back(now);
for (int i = 1; i <= n; i += 1)
if (!vis[i]) seq[++cnt] = i;
dfs_dep(lft, 0);
sort(seq + 1, seq + 1 + cnt, cmp);
long long ans = 0;
for (int i = 1; i <= cnt; i += 1) {
int u = seq[i];
int lca1 = LCA ::getLCA(u, lft), lca2 = LCA ::getLCA(u, rght);
int dis1 = dep[u] + dep[lft] - 2 * dep[lca1],
dis2 = dep[u] + dep[rght] - 2 * dep[lca2];
if (dis1 >= dis2)
ans += dis1, Program.push_back((Ans){u, lft, u});
else
ans += dis2, Program.push_back((Ans){u, rght, u});
}
for (int i = 0; i < (int)zj.size() - 1; i += 1)
ans += mx - i, Program.push_back((Ans){zj[i], lft, zj[i]});
printf("%lld\n", ans);
for (int i = 0; i < n - 1; i += 1)
printf("%d %d %d\n", Program[i].a, Program[i].b, Program[i].c);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
string p[N];
bool b[N][26];
int wrk(int x, char c) {
if (x == 0) return 0;
int s, q, t = 0, _t = 0, l = p[x].length();
for (int i = 0; i < l; i++)
if (p[x][i] == c)
++t;
else
break;
if (t == l) return (l + 1) * wrk(x - 1, c) + l;
for (int i = l - 1; i; i--)
if (p[x][i] == c)
++_t;
else
break;
s = q = p[x][0] == c;
for (int i = 1; i < l; i++)
if (p[x][i] == c)
++q;
else
s = max(s, q), q = 0;
s = max(s, q);
return max((b[x - 1][c - 'a'] ? (((x != 1) ? (t + _t) : max(t, _t)) + 1) : 0),
s);
}
int main() {
int i, j, l, t = 1, ans = 1;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> p[i];
l = p[i].length();
for (j = 0; j < 26; j++) b[i][j] = b[i - 1][j];
for (j = 0; j < l; j++) b[i][p[i][j] - 'a'] = 1;
}
for (i = 1; i < l; i++)
if (p[n][i] == p[n][i - 1])
++t;
else
ans = max(ans, t), t = 1;
cout << max(max(wrk(n, p[n][0]), wrk(n, p[n][l - 1])), max(ans, t));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, x, y, prex[maxn], prey[maxn], ans = -1;
string s;
bool check(int val) {
for (int l = 1, r = val; r <= n; l++, r++) {
int dx = prex[n] - (prex[r] - prex[l - 1]);
int dy = prey[n] - (prey[r] - prey[l - 1]);
if (abs(dx - x) + abs(dy - y) <= val &&
(val - abs(dx - x) - abs(dy - y)) % 2 == 0)
return true;
}
return false;
}
int main() {
cin >> n >> s >> x >> y;
for (int i = 1; i <= n; i++) {
prex[i] = prex[i - 1];
prey[i] = prey[i - 1];
if (s[i - 1] == 'U') prey[i]++;
if (s[i - 1] == 'D') prey[i]--;
if (s[i - 1] == 'L') prex[i]--;
if (s[i - 1] == 'R') prex[i]++;
}
int l = 0, r = n;
while (l <= r) {
int mid = l + r >> 1;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1005;
int x[mx];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> x[i];
double ret = 0;
for (int i = 1; i <= m; i++) {
int a, b;
double c;
cin >> a >> b >> c;
ret = max(ret, (x[a] + x[b]) / c);
}
cout << setprecision(10) << fixed << ret << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int a[1000010];
vector<int> b;
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, d;
scanf("%d%d", &n, &d);
int lim = gcd(d, n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int ans = 0;
for (int r = 0; r < lim; r++) {
b.clear(), b.push_back(a[r]);
int cnt = a[r];
for (int i = (r + d) % n; i != r; i = (i + d) % n) {
b.push_back(a[i]), cnt += a[i];
}
if (cnt == b.size()) {
printf("-1\n");
goto END;
}
for (int beg = 0; beg < b.size(); beg++) {
if (b[beg] == 0) {
for (int i = beg; i < beg + b.size(); i++) {
if (!b[i % b.size()]) continue;
int j = i;
while (j < beg + b.size() && b[j % b.size()]) j++;
ans = max(ans, j - i), i = j - 1;
}
break;
}
}
}
printf("%d\n", ans);
END:;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int maxN = 5;
int a[maxN][maxN];
int n;
pair<int, int> order[] = {
make_pair(0, 0), make_pair(0, 1), make_pair(0, 2), make_pair(0, 3),
make_pair(1, 0), make_pair(2, 0), make_pair(3, 0), make_pair(2, 1),
make_pair(1, 2), make_pair(1, 1), make_pair(3, 1), make_pair(1, 3),
make_pair(2, 2), make_pair(3, 2), make_pair(3, 3), make_pair(2, 3)};
multiset<int> S;
int sum = 0;
void rec(int have) {
if (have == n * n) {
printf("%d\n", sum);
for (int i = 0; i < n; ++i, printf("\n"))
for (int j = 0; j < n; ++j) printf("%d ", a[i][j]);
exit(0);
return;
}
int x = order[have].first, y = order[have].second;
if (have < 4) {
vector<int> order;
for (multiset<int>::iterator it = S.begin(); it != S.end(); ++it) {
order.push_back(*it);
}
for (int i = 0; i < order.size(); ++i)
if (i == 0 || order[i] > order[i - 1]) {
a[x][y] = order[i];
S.erase(S.find(order[i]));
rec(have + 1);
S.insert(order[i]);
}
return;
}
if (have == 4) {
sum = a[0][0] + a[0][1] + a[0][2] + a[0][3];
}
if (have == 6) {
int t = sum - a[0][0] - a[1][0] - a[2][0];
if (S.find(t) != S.end()) {
S.erase(S.find(t));
a[x][y] = t;
rec(have + 1);
S.insert(t);
}
return;
}
if (have == 8) {
int t = sum - a[3][0] - a[2][1] - a[0][3];
if (S.find(t) != S.end()) {
S.erase(S.find(t));
a[x][y] = t;
rec(have + 1);
S.insert(t);
}
return;
}
if (have == 10) {
int t = sum - a[0][1] - a[1][1] - a[2][1];
if (S.find(t) != S.end()) {
S.erase(S.find(t));
a[x][y] = t;
rec(have + 1);
S.insert(t);
}
return;
}
if (have == 11) {
int t = sum - a[1][0] - a[1][1] - a[1][2];
if (S.find(t) != S.end()) {
S.erase(S.find(t));
a[x][y] = t;
rec(have + 1);
S.insert(t);
}
return;
}
if (have == 13) {
int t = sum - a[0][2] - a[1][2] - a[2][2];
if (S.find(t) != S.end()) {
S.erase(S.find(t));
a[x][y] = t;
rec(have + 1);
S.insert(t);
}
return;
}
if (have == 14) {
int t = sum - a[3][0] - a[3][1] - a[3][2];
int t2 = sum - a[0][0] - a[1][1] - a[2][2];
if (t == t2 && S.find(t) != S.end()) {
S.erase(S.find(t));
a[x][y] = t;
rec(have + 1);
S.insert(t);
}
return;
}
if (have == 15) {
int t = sum - a[2][0] - a[2][1] - a[2][2];
int t2 = sum - a[0][3] - a[1][3] - a[3][3];
if (t == t2 && S.find(t) != S.end()) {
S.erase(S.find(t));
a[x][y] = t;
rec(have + 1);
S.insert(t);
}
return;
}
vector<int> order;
for (multiset<int>::iterator it = S.begin(); it != S.end(); ++it) {
order.push_back(*it);
}
for (int i = 0; i < order.size(); ++i)
if (i == 0 || order[i] > order[i - 1]) {
a[x][y] = order[i];
S.erase(S.find(order[i]));
rec(have + 1);
S.insert(order[i]);
}
return;
}
int b[maxN * maxN];
void solve_trivial() {
sort(b, b + (n * n));
do {
for (int i = 0; i < n * n; ++i) a[i / n][i % n] = b[i];
set<int> S;
for (int i = 0; i < n; ++i) {
int sum = 0;
for (int j = 0; j < n; ++j) sum += a[i][j];
S.insert(sum);
sum = 0;
for (int j = 0; j < n; ++j) sum += a[j][i];
S.insert(sum);
}
int s1 = 0, s2 = 0;
for (int i = 0; i < n; ++i) s1 += a[i][i], s2 += a[i][n - 1 - i];
S.insert(s1);
S.insert(s2);
if (S.size() == 1) {
printf("%d\n", *S.begin());
for (int i = 0; i < n; ++i, printf("\n"))
for (int j = 0; j < n; ++j) printf("%d ", a[i][j]);
return;
}
} while (next_permutation(b, b + n * n));
}
void solve_clever() {
for (int i = 0; i < n * n; ++i) S.insert(b[i]);
rec(0);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n * n; ++i) scanf("%d", &b[i]);
if (n <= 3) {
solve_trivial();
} else {
solve_clever();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char buf[100010];
int N;
int a[100010];
int four[20];
bool found[(1 << 20)];
int graph[4][4];
void check(int d) {
int i, j;
for ((i) = 0; (i) < (int)(four[d]); (i)++) found[i] = false;
for ((i) = 0; (i) < (int)(N - d + 1); (i)++) {
int tmp = 0;
for ((j) = 0; (j) < (int)(d); (j)++) tmp = tmp * 4 + a[i + j];
found[tmp] = true;
}
for ((i) = 0; (i) < (int)(four[d]); (i)++)
if (!found[i]) {
int s = i / four[d - 1];
int t = i % 4;
graph[s][t] = min(graph[s][t], d - 1);
}
}
struct matrix {
long long a[4][4];
};
matrix prod(matrix A, matrix B) {
matrix C;
int i, j, k;
for ((i) = 0; (i) < (int)(4); (i)++)
for ((j) = 0; (j) < (int)(4); (j)++) C.a[i][j] = (1ll << 60);
for ((i) = 0; (i) < (int)(4); (i)++)
for ((j) = 0; (j) < (int)(4); (j)++)
for ((k) = 0; (k) < (int)(4); (k)++)
C.a[i][k] = min(C.a[i][k], A.a[i][j] + B.a[j][k]);
return C;
}
long long shortest_path(long long K) {
int i, j;
matrix A;
for ((i) = 0; (i) < (int)(4); (i)++)
for ((j) = 0; (j) < (int)(4); (j)++) A.a[i][j] = graph[i][j];
matrix O;
for ((i) = 0; (i) < (int)(4); (i)++)
for ((j) = 0; (j) < (int)(4); (j)++) O.a[i][j] = 0;
for ((i) = 0; (i) < (int)(60); (i)++) {
if (K & (1ll << i)) O = prod(O, A);
A = prod(A, A);
}
long long ans = (1ll << 60);
for ((i) = 0; (i) < (int)(4); (i)++)
for ((j) = 0; (j) < (int)(4); (j)++) ans = min(ans, O.a[i][j]);
return ans;
}
int main(void) {
int i, j;
long long X;
cin >> X;
scanf("%s", buf);
while (buf[N] != '\0') {
a[N] = buf[N] - 'A';
N++;
}
for ((i) = 0; (i) < (int)(16); (i)++) four[i] = (1 << (2 * i));
for ((i) = 0; (i) < (int)(4); (i)++)
for ((j) = 0; (j) < (int)(4); (j)++) graph[i][j] = 10;
for (i = 2; i <= 10; i++) check(i);
long long low = 0, high = (1ll << 60);
while (high - low > 1) {
long long mid = (low + high) / 2;
long long tmp = shortest_path(mid);
if (tmp <= X - 1)
low = mid;
else
high = mid;
}
cout << low + 1 << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<int> edges[200003];
int level[200003];
bool is[200003];
map<pair<int, int>, int> mp;
vector<string> ans;
vector<int> tr[200003];
bool aaa[200003];
void bfs(int lvl);
void gen(int pos, int lvl) {
if (k <= 0) return;
if (pos == tr[lvl].size()) {
bfs(lvl + 1);
return;
}
for (int i : edges[tr[lvl][pos]])
if (level[i] == lvl - 1) {
is[mp[make_pair(i, tr[lvl][pos])]] = true;
gen(pos + 1, lvl);
is[mp[make_pair(i, tr[lvl][pos])]] = false;
}
}
void bfs(int lvl) {
if (k <= 0) return;
if (tr[lvl - 1].empty()) {
string curr;
for (int i = 1; i <= m; i++) curr += (char)(is[i] + '0');
ans.push_back(curr);
k--;
return;
}
for (int i : tr[lvl - 1]) {
for (int j : edges[i])
if (!level[j]) {
level[j] = lvl;
if (!aaa[lvl]) tr[lvl].push_back(j);
}
}
aaa[lvl] = true;
gen(0, lvl);
for (int i : tr[lvl]) level[i] = 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
edges[a].push_back(b);
edges[b].push_back(a);
mp[make_pair(a, b)] = mp[make_pair(b, a)] = i;
}
vector<int> v;
v.push_back(1);
level[1] = 1;
aaa[1] = true;
tr[1].push_back(1);
bfs(2);
cout << ans.size() << endl;
for (auto i : ans) cout << i << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long T;
long long x;
string s;
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> T;
for (int t = 0; t < T; t++) {
cin >> x;
cin >> s;
long long ans = s.size(), len = s.size();
for (int i = 0; i < x; i++) {
long long c = s[i] - '0', e = min(len, x);
ans += (ans - (i + 1) + 1000000007) * (c - 1) % 1000000007,
ans %= 1000000007;
if (len < 10000000) {
len += (len - i - 1) * (c - 1);
if (len >= 10000000) len = 10000000;
}
for (int j = 0; j < c - 1; j++) {
for (int k = i + 1; k < e; k++) {
s += s[k];
if (s.size() >= x) goto end;
}
}
end:;
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long cmmdc(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long n, a, b, q;
int main() {
scanf("%I64d%I64d%I64d", &n, &a, &b);
long long k = cmmdc(a, b);
long long ca = a / k;
q = min(a, b) - 1;
if (n / ca >= b) {
ca = ca * b;
long long x = n / ca, z;
z = q + (x - 1) * (q + 1) + min(q + 1, n - x * ca + 1);
long long h = cmmdc(z, n);
printf("%I64d/%I64d", z / h, n / h);
} else {
long long h = cmmdc(q, n);
if (q < n)
printf("%I64d/%I64d", q / h, n / h);
else
printf("1/1");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int p[1111111], c1[1111111], c1i[1111111], c2[1111111], c2i[1111111];
int main() {
for (int i = 0; i < 1111111; i++) c1[i] = c2[i] = c1i[i] = c2i[i] = -1;
int n;
scanf("%d", &n);
p[1] = -1;
for (int i = 0; i < n; i++) {
scanf("%d", &p[i + 2]);
int pa = p[i + 2];
int cur = 0, prev = i + 2;
while (pa != -1) {
if (cur >= c1[pa]) {
if (c1i[pa] != prev) {
c2[pa] = c1[pa];
c2i[pa] = c1i[pa];
}
if (c1i[pa] == prev && cur == c1[pa]) break;
c1[pa] = cur;
c1i[pa] = prev;
} else if (cur > c2[pa]) {
c2[pa] = cur;
c2i[pa] = prev;
} else {
break;
}
if (c2[pa] == -1) {
cur = c1[pa];
} else {
cur = c2[pa] + 1;
if (c1[pa] > cur) cur = c1[pa];
}
prev = pa;
pa = p[pa];
}
printf("%d ", c1[1] + 1);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char p[101000], q[101000];
int w[101000], c[4], n, s[4];
long long res, mod = 1000000007, res2;
long long f[301000], invf[301000];
long long power(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) r = r * a % mod;
a = a * a % mod;
b >>= 1;
}
return r;
}
long long comb(int a, int b) {
if (a < 0 || b < 0 || a < b) return 0;
return f[a] * invf[b] % mod * invf[a - b] % mod;
}
long long combh(int a, int b) {
if (a == 0 && b == 0) return 1;
return comb(a + b - 1, b);
}
void goo(int l) {
int i, t[4];
for (i = 0; i < 4; i++) {
t[i] = c[i] - s[i];
if (t[i] < 0) return;
}
if (t[1] > t[2] + 1 || t[1] < t[2]) return;
int cc = t[1] + t[2];
long long r1 = 1;
long long r2 = combh((cc + 2) / 2, t[0]);
long long r3 = combh((cc + 1) / 2, t[3]);
res = (res + r1 * r2 % mod * r3) % mod;
}
void doo(int ck) {
int i, prv = -1;
int lll = c[0] + c[1] + c[2] + c[3] + 1;
if (lll > n) return;
if (lll != n) {
for (i = n - 1; i >= 0; i--) w[i] = 1;
n = lll;
ck = 1;
}
for (i = 0; i < 4; i++) s[i] = 0;
for (i = n - 1; i >= 0; i--) {
if (i != (n - 1) && w[i] == 1) {
s[prv * 2 + 0]++;
goo(i);
s[prv * 2 + 0]--;
}
if (prv != -1) {
s[prv * 2 + w[i]]++;
}
prv = w[i];
}
if (ck) {
if (s[0] == c[0] && s[1] == c[1] && s[2] == c[2] && s[3] == c[3]) res++;
}
}
void pro(char *a, int ck) {
int i;
for (i = 0; a[i]; i++)
;
n = i;
for (i = 0; i < n; i++) w[n - i - 1] = a[i] - '0';
res = 0;
doo(ck);
}
int main() {
int i, j;
f[0] = 1;
for (i = 1; i <= 300000; i++) f[i] = f[i - 1] * i % mod;
invf[i - 1] = power(f[i - 1], mod - 2);
for (i = 300000; i >= 1; i--) invf[i - 1] = invf[i] * i % mod;
scanf("%s%s", p, q);
scanf("%d%d%d%d", &c[0], &c[1], &c[2], &c[3]);
pro(p, 0);
res2 = res;
pro(q, 1);
printf("%lld\n", (res - res2 + mod) % mod);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
constexpr int N = 1e5 + 5;
constexpr LL INF = 1e18;
vector<pair<pair<int, int>, int>> roads;
vector<pair<int, int>> trains;
vector<pair<int, int>> E[N];
int inD[N];
LL dist[N];
void SPFA() {
for (int i = 0; i < N; i++) dist[i] = INF;
dist[1] = 0;
queue<int> Q;
Q.emplace(1);
bitset<N> inQ;
inQ[1] = true;
while (!Q.empty()) {
int a = Q.front();
Q.pop();
inQ[a] = false;
for (const auto &p : E[a]) {
int b = p.first, w = p.second;
if (dist[b] > dist[a] + w) {
dist[b] = dist[a] + w;
if (!inQ[b]) {
inQ[b] = true;
Q.push(b);
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
E[u].emplace_back(v, w);
E[v].emplace_back(u, w);
roads.emplace_back(make_pair(u, v), w);
roads.emplace_back(make_pair(v, u), w);
}
for (int i = 0; i < k; i++) {
int v, w;
cin >> v >> w;
E[1].emplace_back(v, w);
E[v].emplace_back(1, w);
trains.emplace_back(v, w);
}
SPFA();
for (auto p : roads) {
int u, v, w;
u = p.first.first, v = p.first.second, w = p.second;
if (dist[u] + w == dist[v]) {
inD[v]++;
}
}
int result = 0;
for (auto p : trains) {
if (dist[p.first] == p.second) {
inD[p.first]++;
if (inD[p.first] > 1) {
result++;
inD[p.first]--;
}
} else
result++;
}
cout << result << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
stack<int> sk;
bool trash[1000 * 1000 + 10];
int main() {
string s;
cin >> s;
int ans = -1, cnt = 1, tmp = 0;
for (int i = 0; i < (int)s.size(); i++) {
if (s[i] == '(')
sk.push(i);
else if (!sk.empty())
sk.pop();
else
trash[i] = true;
}
while (!sk.empty()) {
trash[sk.top()] = true;
sk.pop();
}
for (int i = 0; i < (int)s.size(); i++) {
if (trash[i])
tmp = 0;
else
tmp++;
if (tmp > ans) {
ans = tmp;
cnt = 1;
} else if (tmp == ans)
cnt++;
}
if (ans == 0) cnt = 1;
cout << ans << " " << cnt << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int n, num = 0;
int count(int m) {
if (m > n) return 0;
num++;
count(m * 10);
count(m * 10 + 1);
return 0;
}
int main() {
scanf("%d", &n);
count(1);
printf("%d\n", num);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 100;
const int mod = 1e9 + 7;
vector<pair<int, int> > g[N];
int dsu[N], rang[N], used[N];
const int T = 20;
int up[T][N];
int pred(int a) { return a == dsu[a] ? a : dsu[a] = pred(dsu[a]); }
void unite(int a, int b) {
a = pred(a);
b = pred(b);
if (rang[a] > rang[b]) {
swap(a, b);
}
dsu[a] = b;
rang[b] += rang[a];
}
int _sz[N], pred_tree[N];
int val[N];
int timer = 0;
int tin[N], tout[N];
void dfs(int v, int p = -1) {
used[v] = 1;
_sz[v] = 1;
tin[v] = timer++;
for (auto to : g[v]) {
if (to.first == p) {
continue;
}
up[0][to.first] = v;
val[to.first] = val[v] ^ to.second;
pred_tree[to.first] = v;
dfs(to.first, v);
_sz[v] += _sz[to.first];
}
tout[v] = timer++;
}
int mass[N];
int idx[N], st[N], en[N];
int Tree[4 * N], Tree_push[4 * N];
int it = 0, it1 = 0;
void dfs1(int v, int p = -1) {
int maxv = -1;
for (auto to : g[v]) {
if (to.first == p) {
continue;
}
if (maxv == -1 || _sz[to.first] > _sz[maxv]) {
maxv = to.first;
}
}
if (maxv != -1) {
idx[maxv] = it;
mass[it++] = maxv;
st[maxv] = st[v];
dfs1(maxv, v);
}
for (auto to : g[v]) {
if (to.first == p || maxv == to.first) {
continue;
}
idx[to.first] = it;
st[to.first] = it;
mass[it++] = to.first;
dfs1(to.first, v);
}
}
bool pr(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
void push(int v) {
Tree[v * 2] |= Tree_push[v];
Tree[v * 2 + 1] |= Tree_push[v];
Tree_push[v * 2] |= Tree_push[v];
Tree_push[v * 2 + 1] |= Tree_push[v];
}
int ask(int v, int l, int r, int al, int ar) {
if (l >= al && r <= ar) {
return Tree[v];
}
if (l <= ar && r >= al) {
push(v);
return ask(v * 2, l, (r + l) / 2, al, ar) +
ask(v * 2 + 1, (r + l) / 2 + 1, r, al, ar);
}
return 0;
}
void update(int v, int l, int r, int al, int ar) {
if (l >= al && r <= ar) {
Tree[v] = 1;
Tree_push[v] = 1;
} else if (l <= ar && r >= al) {
push(v);
update(v * 2, l, (r + l) / 2, al, ar);
update(v * 2 + 1, (r + l) / 2 + 1, r, al, ar);
Tree[v] = Tree[v] | Tree[v * 2] | Tree[v * 2 + 1];
}
}
int n, q;
bool up_(int a, int b) {
if (a == b) {
return 0;
}
while (1) {
if (pr(mass[st[a]], b)) {
if (ask(1, 0, n - 1, idx[b] + 1, idx[a])) {
return 1;
}
return 0;
} else {
if (ask(1, 0, n - 1, st[a], idx[a])) {
return 1;
}
a = pred_tree[mass[st[a]]];
}
}
}
void add(int a, int b) {
if (a == b) {
return;
}
while (1) {
if (pr(mass[st[a]], b)) {
update(1, 0, n - 1, idx[b] + 1, idx[a]);
break;
} else {
update(1, 0, n - 1, st[a], idx[a]);
a = pred_tree[mass[st[a]]];
}
}
}
int lca(int a, int b) {
if (pr(a, b)) {
return a;
}
for (int j = T - 1; j >= 0; j--) {
if (!pr(up[j][a], b)) {
a = up[j][a];
}
}
return up[0][a];
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 0; i < n; i++) {
dsu[i] = i;
rang[i] = 1;
}
vector<bool> ans(q);
vector<vector<int> > vec;
for (int i = 0; i < q; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
vec.push_back({a, b, c});
if (pred(a) != pred(b)) {
g[a].push_back({b, c});
g[b].push_back({a, c});
unite(a, b);
ans[i] = 1;
}
}
for (int i = 0; i < n; i++) {
if (!used[i]) {
up[0][i] = i;
dfs(i);
st[i] = it;
idx[i] = it;
mass[it++] = i;
dfs1(i);
}
}
for (int i = 1; i < T; i++) {
for (int j = 0; j < n; j++) {
up[i][j] = up[i - 1][up[i - 1][j]];
}
}
for (int i = 0; i < q; i++) {
if (ans[i]) {
continue;
}
int a = vec[i][0];
int b = vec[i][1];
int c = vec[i][2];
if ((val[a] ^ val[b] ^ c) == 0) {
continue;
}
int t = lca(a, b);
if (!up_(a, t) && !up_(b, t)) {
ans[i] = 1;
add(a, t);
add(b, t);
}
}
for (int i = 0; i < q; i++) {
if (ans[i]) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (n == 2) {
if (a[0] > a[1]) {
cout << "NO\n";
return;
} else {
cout << "YES\n";
return;
}
}
int c = 0;
for (int i = 1; i < n; i++) {
if (a[i] < a[i - 1]) c++;
}
if (c == n - 1) {
cout << "NO\n";
return;
}
cout << "YES\n";
}
int main() {
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char c[10];
int main() {
int k;
cin >> k;
if (k % 2 == 1) {
cout << -1;
return 0;
}
c[0] = 'w';
c[1] = 'b';
for (int i = 0; i < k; i++)
for (int j = 0; j < k / 2; j++)
for (int g = 0; g < 2; g++) {
for (int f = 0; f < k / 2; f++)
cout << c[(i + j + f) % 2] << c[(i + j + f) % 2];
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5001;
int n;
long long memo[N][N];
long long vs[N];
vector<long long> arr;
long long oo = 100000000000000000LL;
long long solve(int idx, int f) {
if (idx == n) return 0;
long long ret = memo[idx][f];
if (ret != -1) return ret;
ret = oo;
if (f + 1 < n) ret = min(ret, solve(idx, f + 1));
ret = min(ret, (solve(idx + 1, f) + abs(vs[idx] - arr[f])));
return memo[idx][f] = ret;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> vs[i];
vs[i] -= i;
arr.push_back(vs[i]);
}
sort(arr.begin(), arr.end());
for (int i = 0; i < n; i++) memo[n][i] = 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = n - 1; j >= 0; j--) {
long long ret = oo;
if (j + 1 < n) ret = min(ret, memo[i][j + 1]);
ret = min(ret, memo[i + 1][j] + abs(vs[i] - arr[j]));
memo[i][j] = ret;
}
}
cout << memo[0][0] << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << '{';
for (int i = (0), __i = (((int)(vec).size())); i < __i; i++) {
os << vec[i];
if (i + 1 != ((int)(vec).size())) os << ',';
}
os << '}';
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &par) {
os << '(' << par.first << ',' << par.second << ')';
return os;
}
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
template <class T>
T sqr(T x) {
return x * x;
}
long long a[100000];
long long get_var(long long a, long long b) {
long long res = 1;
for (int i = (0), __i = (b); i < __i; i++) res *= a - i;
for (int i = (0), __i = (b); i < __i; i++) res /= b - i;
return res;
}
int main() {
ios::sync_with_stdio(false);
long long n;
cin >> n;
for (int i = (0), __i = (n); i < __i; i++) cin >> a[i];
sort(a, a + n);
int a1 = a[0];
int a2 = a[1];
int a3 = a[2];
int cnt = 1;
for (int i = (3), __i = (n); i < __i; i++) {
if (a[i] != a[2]) break;
cnt++;
}
if (a3 == a2) {
if (a3 == a1)
cout << get_var(cnt + 2, 3);
else
cout << get_var(cnt + 1, 2);
} else
cout << cnt;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
map<int, int> a, fan, zhen;
set<int> a1;
set<int>::iterator it;
int main() {
int n, ma = -0x3f3f3f3f;
scanf("%d", &n);
int z, f;
int cnt = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d", &z, &f);
if (z == f) {
a[z]++;
zhen[z]++;
} else {
a[z]++;
a[f]++;
zhen[z]++;
fan[f]++;
}
ma = max(ma, a[z]);
ma = max(ma, a[f]);
if (a[z] >= (n + 1) / 2) a1.insert(z);
if (a[f] >= (n + 1) / 2) a1.insert(f);
}
if (ma < (n + 1) / 2)
printf("-1\n");
else {
int ans = 0x3f3f3f3f, t;
for (it = a1.begin(); it != a1.end(); it++) {
t = 0;
if (zhen[*it] < (n + 1) / 2) t = (n + 1) / 2 - zhen[*it];
ans = min(ans, t);
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long binpow(long long a, long long m) {
long long product = 1;
long long mult = a;
while (m > 0) {
if (m % 2 == 1) {
product = (product % 1000000007 * mult % 1000000007) % 1000000007;
}
m = m / 2;
mult = (mult % 1000000007 * mult % 1000000007) % 1000000007;
}
product = product % 1000000007;
return product;
}
int main() {
int n;
cin >> n;
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
int x[4];
for (int j = 0; j < 4; j++) {
cin >> x[j];
}
if (x[0] % 2 == 0 && x[1] % 2 == 0)
cout << 1 << endl;
else if (abs(x[0] % 2) == 1 && x[1] % 2 == 0)
cout << 2 << endl;
else if (x[0] % 2 == 0 && abs(x[1] % 2) == 1)
cout << 3 << endl;
else
cout << 4 << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int P, N, M, Q, id, cnt;
string dummy, line, name;
string NAME[1100];
map<string, int> C[1100], R[1100];
vector<pair<string, int> > sol;
int num(string s) {
int ret = 0;
stringstream ss(s);
ss >> ret;
return ret;
}
int main() {
cin >> P >> N >> M >> Q;
for (int I = 0; I < N; I++) {
cin >> dummy;
}
getline(cin, dummy);
for (int I = 0; I < M; I++) {
getline(cin, line);
int pos = line.find(":");
name = line.substr(0, pos);
line = line.substr(pos + 2);
NAME[I] = name;
bool ok = true;
while (ok) {
pos = line.find(" ");
name = line.substr(0, pos);
line = line.substr(pos + 1);
pos = int(line.find(","));
if (pos < 0) {
cnt = num(line);
ok = false;
} else {
cnt = num(line.substr(0, pos));
line = line.substr(pos + 2);
}
R[I][name] = cnt;
}
}
while (Q--) {
cin >> id;
cin >> name;
C[id][name]++;
for (int a = 0; a < M; a++) {
bool ok = true;
for (typeof((R[a]).begin()) it = (R[a]).begin(); it != (R[a]).end();
it++) {
name = it->first;
if (C[id][name] < it->second) {
ok = false;
break;
}
}
if (ok) {
for (typeof((R[a]).begin()) it = (R[a]).begin(); it != (R[a]).end();
it++) {
name = it->first;
C[id][name] -= it->second;
}
C[id][NAME[a]]++;
}
}
}
for (int id = 1; id <= P; id++) {
sol.clear();
for (typeof((C[id]).begin()) it = (C[id]).begin(); it != (C[id]).end();
it++)
if (it->second > 0)
sol.push_back(pair<string, int>(it->first, it->second));
cout << int((sol).size()) << endl;
for (typeof((sol).begin()) it = (sol).begin(); it != (sol).end(); it++)
cout << it->first << " " << it->second << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, c, d;
int maxx = 1 << 29;
int minn = -maxx;
int flag = 0;
bool judge() {
if (minn <= maxx)
return true;
else
return false;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &c, &d);
if (d == 1) {
if (maxx < 1900) {
printf("Impossible\n");
return 0;
}
minn = max(minn, 1900);
} else {
if (minn >= 1900) {
printf("Impossible\n");
return 0;
}
maxx = min(maxx, 1899);
flag = 1;
}
minn += c;
maxx += c;
if (!judge()) {
printf("Impossible\n");
return 0;
}
}
if (!flag)
printf("Infinity\n");
else
printf("%d\n", maxx);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int ans;
bool vis[10];
int u[10], v[10], w[10];
int main() {
long long x;
u[1] = 1;
v[1] = 3;
w[1] = 0;
u[2] = 4;
v[2] = 15;
w[2] = 1;
u[3] = 16;
v[3] = 81;
w[3] = 2;
u[4] = 82;
v[4] = 6723;
w[4] = 0;
u[5] = 6724;
v[5] = 50625;
w[5] = 3;
u[6] = 50626;
v[6] = 899999;
w[6] = 1;
while (cin >> n) {
ans = 0;
for (int i = 0; i < n; ++i) {
cin >> x;
int tmp = 0;
if (x <= 899999) {
for (int j = 1; j <= 6; ++j)
if (x >= u[j] && x <= v[j]) {
tmp = w[j];
break;
}
} else {
memset(vis, false, sizeof(vis));
int r = sqrt(x);
int l = sqrt(r);
while ((long long)l * l * l * l < x) l++;
for (int j = 1; j <= 6; ++j) {
if (r < u[j] || l > v[j]) continue;
vis[w[j]] = true;
}
int j = 0;
while (vis[j]) j++;
tmp = j;
}
ans ^= tmp;
}
cout << (ans ? "Furlo" : "Rublo") << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[100005];
int main() {
long long int i, j, k;
long long int n, m;
long long int a, b;
cin >> n >> k;
memset(dp, 0, sizeof(dp));
i = 1;
while (i < k) {
dp[i] = 1;
i++;
}
dp[k] = 2;
for (i = k + 1; i < 100005; i++) {
dp[i] = (dp[i - k] % 1000000007 + dp[i - 1] % 1000000007) % 1000000007;
}
for (i = 1; i < 100005; i++) {
dp[i] = (dp[i] % 1000000007 + dp[i - 1] % 1000000007) % 1000000007;
}
for (i = 0; i < n; i++) {
cin >> a >> b;
k = (dp[b] - dp[a - 1]) % 1000000007;
if (k < 0) k += 1000000007;
cout << k << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int BT = 1048576;
int itree[BT * 2];
void restore(int p) {
p += BT;
while (p) {
itree[p]++;
p >>= 1;
}
}
int find_pos(int val) {
unsigned int p = val + BT;
while (itree[p] == 0) {
p = (p + 1) >> 1;
}
while (p < BT) {
if (itree[p * 2] != 0) {
p = p * 2;
} else {
p = p * 2 + 1;
}
}
int res = p - BT;
while (p) {
itree[p]--;
p >>= 1;
}
return res;
}
int main() {
int n;
scanf("%d", &n);
vector<vector<int>> graph(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
graph[a].push_back(b);
graph[b].push_back(a);
}
for (int i = BT; i < 2 * BT; i++) {
itree[i] = 1;
}
for (int i = BT - 1; i >= 1; i--) {
itree[i] = itree[i * 2] + itree[i * 2 + 1];
}
int ans = 0;
vector<int> depth(n, -1);
depth[0] = 0;
for (auto root : graph[0]) {
queue<int> q;
depth[root] = 1;
q.push(root);
vector<int> inspection;
while (!q.empty()) {
int cur = q.front();
q.pop();
if (graph[cur].size() == 1) {
inspection.push_back(cur);
}
for (auto next : graph[cur]) {
if (depth[next] != -1) continue;
depth[next] = depth[cur] + 1;
q.push(next);
}
}
vector<int> backup;
for (auto i : inspection) {
int level = depth[i];
int p = find_pos(level);
backup.push_back(p);
ans = max(ans, p);
}
for (auto p : backup) {
restore(p);
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
const int MOD = 998244353;
const int DEBUG = 0;
inline int inc(int a, int b) {
return (a + b >= MOD) ? (a + b - MOD) : (a + b);
}
inline int dec(int a, int b) { return (a >= b) ? (a - b) : (a + MOD - b); }
inline int mul(int a, int b) { return 1LL * a * b % MOD; }
inline int power(int x, int k) {
int tmp = 1;
while (k) {
if (k & 1) tmp = mul(tmp, x);
x = mul(x, x);
k >>= 1;
}
return tmp;
}
int n, k, Ans, a[maxn], dp[maxn][maxn], sum[maxn][maxn];
inline void solve(int x) {
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= n; j++) dp[i][j] = sum[i][j] = 0;
}
for (int i = 1; i <= n; i++) dp[1][i] = 1;
for (int i = 1; i <= n; i++) sum[1][i] = inc(sum[1][i - 1], dp[1][i]);
for (int i = 2; i <= k; i++) {
sum[i][0] = 0;
int l = 1;
for (int j = 1; j <= n; j++) {
while (a[l] <= a[j] - x) l++;
dp[i][j] = sum[i - 1][l - 1];
sum[i][j] = inc(sum[i][j - 1], dp[i][j]);
}
}
int now = 0;
for (int i = 1; i <= n; i++) now = inc(now, dp[k][i]);
Ans = inc(Ans, now);
if (DEBUG) printf("%d %d\n", x, now);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
Ans = 0;
for (int i = 1; i <= a[n] / (k - 1); i++) {
solve(i);
}
printf("%d\n", Ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, d[200010];
int main() {
int sum = 0, cnt = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &d[i]);
sum += d[i];
}
if (sum % n == 0) {
sum /= n;
for (int i = 1; i <= n; i++)
if (d[i] == sum) cnt++;
printf("%d\n", cnt);
for (int i = 1; i <= n; i++, cnt--)
if (d[i] == sum) {
printf("%d", i);
if (cnt)
printf(" ");
else
printf("\n");
}
} else
printf("0\n\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 32, M = 2e5 + 10;
int q[N], qz[M];
bool insert(int x) {
for (int i = N - 1; i >= 0; --i) {
if ((x >> i) & 1) {
if (!q[i]) {
q[i] = x;
return true;
} else
x ^= q[i];
}
}
return false;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &qz[i]);
for (int i = 1; i <= n; ++i) qz[i] ^= qz[i - 1];
int ans = 0;
if (!qz[n]) return printf("-1\n"), 0;
for (int i = n; i >= 1; --i) {
if (insert(qz[i])) ans++;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int multiply(int x, int y) {
if (y)
return (x + multiply(x, y - 1));
else
return 0;
}
int pow(int a, int b) {
if (b)
return multiply(a, pow(a, b - 1));
else
return 1;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, k, l1, r1, l2, r2;
cin >> n >> k >> l1 >> r1 >> l2 >> r2;
long long int leftt = max(l1, l2), rightt = min(r1, r2);
long long int totalt = max(0LL, rightt - leftt);
k -= totalt * n;
if (k <= 0) {
cout << 0;
} else {
long long int x_0 = max(0LL, leftt - rightt);
long long int x_1 = max(r1, r2) - min(l1, l2) - totalt;
if (x_1 > x_0) {
long long int d = min(n, k / x_1);
long long int ans = d * (x_0 + x_1);
k -= d * x_1;
if (d == 0 || (d < n && k + x_0 < 2 * k)) {
ans += k + x_0;
k = 0;
}
ans += 2 * k;
cout << ans;
} else {
long long int ans = x_0;
if (k < x_1) {
ans += k;
k = 0;
} else {
ans += x_1;
k -= x_1;
}
ans += 2 * k;
cout << ans;
}
}
cout << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long arr[200009], res[200009];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n / 2; i++) scanf("%lld", &arr[i]);
res[1] = 0, res[n] = arr[1];
long long last = arr[1];
for (int i = 2; i <= (n / 2); i++) {
if (last > arr[i]) {
res[i] = res[i - 1];
res[n - i + 1] = (arr[i] - res[i]);
} else {
res[i] = res[i - 1] + (arr[i] - last);
res[n - i + 1] = (arr[i] - res[i]);
}
last = arr[i];
}
for (int i = 1; i <= n; i++) printf("%lld ", res[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cin >> x;
int answer = 0;
for (int i = 0; i <= 1000000; i++) {
if (x > 5) {
answer += 1;
x -= 5;
} else {
answer += 1;
break;
}
}
cout << answer << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long int INF = 1e18;
const int N = 100005;
const int MOD = 1e9 + 7;
const double EPS = 1e-6;
const double PI = acos(-1.0);
vector<long long int> V;
void dfs(long long int x) {
V.push_back(x);
if (x > inf) return;
dfs(10 * x + 4);
dfs(10 * x + 7);
}
long long int Binary_Search(long long int val) {
long long int lo = 0, hi = V.size() - 1;
long long int ret = 0;
while (lo <= hi) {
long long int mid = (lo + hi) >> 1;
if (V[mid] >= val) {
ret = V[mid];
hi = mid - 1;
} else
lo = mid + 1;
}
return ret;
}
int main(int argc, char const *argv[]) {
dfs(0);
sort(V.begin(), V.end());
long long int l, r;
cin >> l >> r;
long long int ans = 0;
while (l <= r) {
long long int val = Binary_Search(l);
if (val >= r) {
ans += (r - l + 1) * val;
l = r + 1;
} else {
ans += (val - l + 1) * val;
l = val + 1;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, ans = 0;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (k >= n) {
cout << a[n - 1];
return 0;
}
int s = 2 * k - n;
if (s > 0) {
ans = a[n - 1];
}
int f = 0, b = n - s - 1;
while (f <= b) {
int c = a[f] + a[b];
ans = max(c, ans);
f++;
b--;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long N = 55, M = 100005, P = 998244353;
long long n, m, l[N], r[N], f[N][M], ans[M];
signed main() {
std::cin >> n >> m;
for (long long i = 1; i <= n; i++) std::cin >> l[i] >> r[i];
for (long long g = m / n; g >= 1; g--) {
for (long long i = 0; i <= n; i++)
for (long long j = 0; j <= m / g + 1; j++) f[i][j] = 0;
for (long long j = 0; j <= m / g + 1; j++) f[0][j] = 1;
for (long long i = 1; i <= n; i++) {
long long L = (l[i] + g - 1) / g, R = r[i] / g;
for (long long a = L; a <= m / g + 1; a++) {
long long cl = std::max(a - R, 0ll), cr = a - L;
if (cl > cr)
f[i][a] = 0;
else
f[i][a] = (f[i - 1][cr] - (cl ? f[i - 1][cl - 1] : 0) + P) % P;
if (a > 0) f[i][a] = (f[i][a] + f[i][a - 1]) % P;
}
}
ans[g] = f[n][m / g];
for (long long i = 2 * g; i <= m; i += g)
ans[g] = (ans[g] - ans[i] + P) % P;
}
std::cout << ans[1];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, a;
double minn = 1000000;
int x, y;
double suan(int q, int w) {
double av = 180.0 * (n - 2) / n;
double a1 = 180.0 * (q - 2) - (q - 2) * av;
a1 = a1 / 2.0;
double a2 = 180.0 * (n - w) - (n - w) * av;
a2 /= 2.0;
return av - (a1 + a2);
}
int main() {
scanf("%d%d", &n, &a);
for (int i = 2; i < n; i++) {
double v = 100000;
int z = 0;
int l = i + 1;
int r = n;
while (r >= l) {
int m = (r + l) / 2;
double k = suan(i, m);
if (abs(k - a) < v) {
v = abs(k - a);
z = m;
}
if (k < a) {
l = m + 1;
} else if (k > a) {
r = m - 1;
} else
break;
}
if (v < minn) {
minn = v;
x = i;
y = z;
}
}
printf("%d 1 %d", x, y);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline bool compare(long long int i, long long int j) { return i < j; }
template <typename T>
T gcd(T a, T b);
template <typename T>
T modpow(T number, T power, T mod_value);
struct Information {
deque<long long int> dq, sum;
Information() {
dq.clear();
sum.resize(5, 0);
}
};
const long long int maxN = 2e5;
const long long int maxB = 320;
const long long int INF = 1e14;
long long int current_total;
Information block[maxB];
long long int get_block(long long int n) { return n / maxB; }
void add(long long int num) {
long long int bl = -1;
for (bl = 0; bl < (maxB); bl++) {
if ((block[bl].dq.size() < maxB) || (block[bl].dq.back() > num)) break;
}
if (block[bl].dq.size() < maxB) {
block[bl].dq.push_back(num);
long long int i = block[bl].dq.size() - 1;
for (; i > 0; i--) {
if (block[bl].dq[i] < block[bl].dq[i - 1])
swap(block[bl].dq[i], block[bl].dq[i - 1]);
else
break;
}
block[bl].sum.clear();
block[bl].sum.resize(5, 0);
for (i = 0; i < (block[bl].dq.size()); i++)
block[bl].sum[i % 5] += block[bl].dq[i];
} else {
block[bl].dq.push_back(num);
long long int i = block[bl].dq.size() - 1;
for (; i > 0; i--) {
if (block[bl].dq[i] < block[bl].dq[i - 1])
swap(block[bl].dq[i], block[bl].dq[i - 1]);
else
break;
}
long long int extra = block[bl].dq.back();
block[bl].dq.pop_back();
block[bl].sum.clear();
block[bl].sum.resize(5, 0);
for (i = 0; i < (block[bl].dq.size()); i++)
block[bl].sum[i % 5] += block[bl].dq[i];
for (++bl; bl < maxB; ++bl) {
block[bl].dq.push_front(extra);
long long int bck = block[bl].sum.back();
block[bl].sum.pop_back();
block[bl].sum.push_front(bck);
block[bl].sum[0] += extra;
if (block[bl].dq.size() > maxB) {
extra = block[bl].dq.back();
block[bl].dq.pop_back();
block[bl].sum[0] -= extra;
} else
break;
}
}
}
void del(long long int num) {
long long int bl = -1;
for (bl = 0; bl < (maxB); bl++) {
if (block[bl].dq.back() >= num) break;
}
assert(bl >= 0 && bl < maxB);
if (block[bl + 1].dq.size() == 0) {
long long int i;
for (i = 0;; i++) {
if (block[bl].dq[i] == num) break;
}
for (++i; i < block[bl].dq.size(); i++) {
swap(block[bl].dq[i], block[bl].dq[i - 1]);
}
block[bl].dq.pop_back();
block[bl].sum.clear();
block[bl].sum.resize(5, 0);
for (i = 0; i < (block[bl].dq.size()); i++)
block[bl].sum[i % 5] += block[bl].dq[i];
} else {
long long int extra = block[bl + 1].dq.front();
block[bl + 1].dq.pop_front();
long long int i;
for (i = 0;; i++) {
if (block[bl].dq[i] == num) break;
}
for (++i; i < block[bl].dq.size(); i++) {
swap(block[bl].dq[i], block[bl].dq[i - 1]);
}
block[bl].dq.pop_back();
block[bl].dq.push_back(extra);
block[bl].sum.clear();
block[bl].sum.resize(5, 0);
for (i = 0; i < (block[bl].dq.size()); i++)
block[bl].sum[i % 5] += block[bl].dq[i];
for (++bl; bl < maxB; ++bl) {
block[bl].sum[0] -= extra;
long long int frnt = block[bl].sum.front();
block[bl].sum.pop_front();
block[bl].sum.push_back(frnt);
if (!block[bl + 1].dq.empty()) {
extra = block[bl + 1].dq.front();
block[bl + 1].dq.pop_front();
block[bl].dq.push_back(extra);
block[bl].sum[4] += extra;
} else
break;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int number_of_test_case = 1, test_case;
for (test_case = 1; test_case <= number_of_test_case; test_case++) {
long long int i, j, value, n;
string op;
cin >> n;
current_total = 0;
for (i = 0; i < (n); i++) {
cin >> op;
if (op == "add") {
cin >> value;
add(value);
current_total++;
} else if (op == "del") {
cin >> value;
del(value);
current_total--;
} else if (op == "sum") {
long long int total_block = get_block(current_total) + 1;
long long int sum = 0;
for (j = 0; j < (total_block); j++) sum += block[j].sum[2];
cout << sum << "\n";
}
}
}
return 0;
}
template <typename T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T>
T modpow(T number, T power, T mod_value) {
if (power == 0) return 1 % mod_value;
long long int u = modpow(number, power / 2, mod_value);
u = (u * u) % mod_value;
if (power % 2 == 1) u = (u * number) % mod_value;
return u;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const int INF = 1e9;
struct Tree {
struct Node {
pair<int, int> res;
pair<int, int> mnl;
pair<int, int> mnr;
int updl;
int updr;
};
vector<Node> data;
int sz;
void init(int n) {
sz = n;
data.resize(sz * 4);
for (int i = 0; i < sz * 4; i++) {
data[i].res = make_pair(INF, -1);
data[i].mnl = make_pair(INF, -1);
data[i].mnr = make_pair(INF, -1);
data[i].updl = data[i].updr = -1;
}
}
void apply(int v, int rr, int value, int type) {
if (type == 1) {
data[v].updl = value;
data[v].mnl = make_pair(-value - (rr - 1), 1);
data[v].res = data[v].mnr;
data[v].res.first -= value;
} else if (type == 2) {
data[v].updr = value;
data[v].mnr = make_pair(value - (rr - 1), 1);
data[v].res = data[v].mnl;
data[v].res.first += value;
} else
assert(false);
}
void push(int v, int ll, int rr) {
if (data[v].updl != -1) {
apply(v * 2 + 1, (ll + rr) / 2, data[v].updl, 1);
apply(v * 2 + 2, rr, data[v].updl, 1);
data[v].updl = -1;
}
if (data[v].updr != -1) {
apply(v * 2 + 1, (ll + rr) / 2, data[v].updr, 2);
apply(v * 2 + 2, rr, data[v].updr, 2);
data[v].updr = -1;
}
}
Node merge(Node r1, Node r2) {
Node g;
g.updl = g.updr = -1;
pair<int, int> res;
pair<int, int> mnl;
pair<int, int> mnr;
res = make_pair(min(r1.res.first, r2.res.first), 0);
if (res.first == r1.res.first) res.second += r1.res.second;
if (res.first == r2.res.first) res.second += r2.res.second;
mnl = make_pair(min(r1.mnl.first, r2.mnl.first), 0);
if (mnl.first == r1.mnl.first) mnl.second += r1.mnl.second;
if (mnl.first == r2.mnl.first) mnl.second += r2.mnl.second;
mnr = make_pair(min(r1.mnr.first, r2.mnr.first), 0);
if (mnr.first == r1.mnr.first) mnr.second += r1.mnr.second;
if (mnr.first == r2.mnr.first) mnr.second += r2.mnr.second;
g.res = res;
g.mnl = mnl;
g.mnr = mnr;
return g;
}
void set(int v, int ll, int rr, int l, int r, int value, int type) {
if (r <= ll || rr <= l) return;
if (l <= ll && rr <= r) {
apply(v, rr, value, type);
return;
}
push(v, ll, rr);
set(v * 2 + 1, ll, (ll + rr) / 2, l, r, value, type);
set(v * 2 + 2, (ll + rr) / 2, rr, l, r, value, type);
data[v] = merge(data[v * 2 + 1], data[v * 2 + 2]);
}
void set(int l, int r, int value, int type) {
set(0, 0, sz, l, r, value, type);
}
};
int n;
int a[N];
Tree t;
void read() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
a[x] = y;
}
}
void solve() {
t.init(n);
vector<pair<int, int> > stackL;
vector<pair<int, int> > stackR;
stackL.push_back(make_pair(-1, n));
stackR.push_back(make_pair(n, n));
long long answer = 0;
for (int i = n - 1; i >= 0; i--) {
int h = a[i];
for (; !stackL.empty() && h < stackL.back().first; stackL.pop_back())
;
assert(!stackL.empty());
t.set(i, stackL.back().second, h, 1);
stackL.push_back(make_pair(h, i));
for (; !stackR.empty() && h > stackR.back().first; stackR.pop_back())
;
assert(!stackR.empty());
t.set(i, stackR.back().second, h, 2);
stackR.push_back(make_pair(h, i));
auto r = t.data[0].res;
assert(r.first >= -i);
if (r.first == -i) answer += r.second;
}
cout << answer << endl;
}
void printAns() {}
void stress() {}
int main() {
if (1) {
for (int tt = 0; tt < 1; tt++) {
read();
solve();
printAns();
}
} else {
stress();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 10;
int n, t, r;
int arr[N];
struct node {
int L, R, idx;
node() { L = R = idx = 0; }
node(int a, int b, int c) { L = a, R = b, idx = c; }
bool operator<(const node &a) const {
if (L / r != a.L / r) return L / r < a.L / r;
return R < a.R;
}
} q[N];
int cnt[N * 10];
long long ans, res[N];
void add(int v) {
ans -= 1ll * cnt[v] * cnt[v] * v;
cnt[v]++;
ans += 1ll * cnt[v] * cnt[v] * v;
}
void remove(int v) {
ans -= 1ll * cnt[v] * cnt[v] * v;
cnt[v]--;
ans += 1ll * cnt[v] * cnt[v] * v;
}
int main(int argc, char *args[]) {
scanf("%d%d", &n, &t);
for (int i = 0; i < n; ++i) scanf("%d", arr + i);
for (int x, y, i = 0; i < t; ++i) {
scanf("%d%d", &x, &y);
x--, y--;
q[i] = node(x, y, i);
}
r = n / (int)sqrt(t) + 1;
sort(q, q + t);
int curL = 0, curR = 0;
ans = arr[0];
cnt[arr[0]]++;
for (int i = 0; i < t; ++i) {
int L = q[i].L, R = q[i].R;
while (curR < R) add(arr[++curR]);
while (curL > L) add(arr[--curL]);
while (L > curL) remove(arr[curL++]);
while (R < curR) remove(arr[curR--]);
res[q[i].idx] = ans;
}
for (int i = 0; i < t; ++i) printf("%lld\n", res[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long read() {
long long x;
scanf("%lld", &x);
return x;
}
signed main() {
long long T = read();
while (T--) {
long long n = read(), m = read();
long long k1 = n * m;
long long x1 = read(), y1_ = read(), x2 = read(), y2 = read();
long long x = abs(x1 - x2);
long long y = abs(y1_ - y2);
long long t1 = n - x;
long long t2 = m - y;
long long k2 = t1 * t2;
t1 = n - 2 * x;
t2 = m - 2 * y;
long long k3 = t1 * t2;
if (t1 < 0 || t2 < 0) k3 = 0;
cout << k1 - k2 * 2 + k3 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int m, r;
cin >> m >> r;
double ans = 0.00;
ans += 2.00 * r * m;
ans += (2.00 + sqrt(2)) * r * (m - 1) * 2;
ans += sqrt(2) * 2 * r * (m * m - m - (m - 1) * 2);
long long int map[100000] = {0};
map[0] = 1;
for (long long int i = 1; i < m - 2; i++) {
map[i] = map[i - 1] + (i + 1) * (i + 2) / 2;
}
if (m >= 3) ans += 4.00 * r * map[m - 3];
cout << fixed << setprecision(10) << ans / m / m << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 512345;
long long n, a[MAXN], psum[MAXN], p1[MAXN], p2[MAXN];
void input();
void prep();
int main() {
input();
if (psum[n - 1] % 3 != 0 || n < 3) {
cout << 0 << endl;
return 0;
}
long long p1 = 0, s = psum[n - 1] / 3, ans = 0;
for (int i = 0; i < n - 1; i++) {
if (psum[i] == 2 * s) ans += p1;
if (psum[i] == s) p1++;
}
cout << ans << endl;
return 0;
}
void input() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i == 0)
psum[i] = a[i];
else
psum[i] = psum[i - 1] + a[i];
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
ll mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
ld mx = 0.0;
ld count = 0.0;
cin >> n;
for (int i = 0; i < n; i++) {
ld a;
cin >> a;
count += a;
mx = max(mx, count / (i + 1));
}
cout << mx << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x;
cin >> x;
return x;
}
const int MAX_N = 15;
const int MAX_F = (1 << (MAX_N - 2)) + 4;
int n, m, nQ, id[MAX_N];
bool isEdge[MAX_N][MAX_N], isParent[MAX_N][MAX_N], isNotParent[MAX_N][MAX_N],
isLCA[MAX_N][MAX_N][MAX_N];
bool ok1[MAX_F][MAX_N], ok2[MAX_F][MAX_N], ok3[MAX_F][MAX_N][MAX_N],
ok4[MAX_F][MAX_F], ok5[MAX_F][MAX_N];
long long f[MAX_F][MAX_N];
inline bool check_0(int u, int v, int r) {
if (u == v && r != u) return 0;
if ((u == 1 || v == 1) && r != 1) return 0;
return 1;
}
void init(int nMask) {
memset(ok1, 0, sizeof(ok1));
memset(ok2, 0, sizeof(ok2));
memset(ok3, 0, sizeof(ok3));
memset(ok4, 0, sizeof(ok4));
memset(ok5, 0, sizeof(ok5));
for (long long x = (0); x <= (nMask); ++x)
for (long long i = (1); i <= (n); ++i)
if (x & id[i]) {
ok1[x][i] = 1;
for (long long j = (1); j <= (n); ++j)
if (j != i && (x & id[j]))
if (isParent[j][i] || isNotParent[i][j]) {
ok1[x][i] = 0;
break;
}
}
for (long long x = (0); x <= (nMask); ++x)
for (long long i = (1); i <= (n); ++i)
if (!(x & id[i])) {
ok2[x][i] = 1;
for (long long j = (1); j <= (n); ++j)
if (x & id[j])
if (isParent[j][i] || isParent[i][j] || isEdge[j][i] ||
isEdge[i][j]) {
ok2[x][i] = 0;
break;
}
}
for (long long x = (0); x <= (nMask); ++x)
for (long long i = (1); i <= (n); ++i)
if (x & id[i])
for (long long r = (1); r <= (n); ++r)
if (!(x & id[r])) {
ok3[x][i][r] = 1;
for (long long j = (1); j <= (n); ++j)
if (j != i && (x & id[j]))
if (isEdge[r][j]) {
ok3[x][i][r] = 0;
break;
}
}
for (long long x = (0); x <= (nMask); ++x) {
for (long long y = (0); y <= (nMask); ++y)
if (!(x & y)) {
ok4[x][y] = 1;
for (long long i = (1); i <= (n); ++i)
if (x & id[i]) {
for (long long j = (1); j <= (n); ++j)
if (y & id[j])
if (isParent[i][j] || isParent[j][i] || isEdge[i][j] ||
isEdge[j][i]) {
ok4[x][y] = 0;
break;
}
if (!ok4[x][y]) break;
}
}
}
for (long long x = (0); x <= (nMask); ++x)
for (long long r = (1); r <= (n); ++r)
if (!(x & id[r])) {
ok5[x][r] = 1;
for (long long i = (1); i <= (n); ++i)
if (ok5[x][r])
if (x & id[i])
for (long long j = (1); j <= (n); ++j)
if (x & id[j])
if (i != j)
if (isLCA[r][i][j]) {
ok5[x][r] = 0;
break;
}
}
}
inline bool check(int mask, int r, int newMask, int newR) {
int x = mask - newMask;
return ok1[newMask][newR] && ok2[x][newR] && ok3[newMask][newR][r] &&
ok4[newMask][x] && ok5[newMask][r];
}
long long solve(int mask, int par) {
if (mask == 0) return 1;
if (f[mask][par] > -1) return f[mask][par];
long long ans = 0;
int x = 0;
do {
if (x > 0 && __builtin_clz(x) == __builtin_clz(mask))
for (long long r = (1); r <= (n); ++r)
if (x & id[r]) {
if (!check(mask, par, x, r)) continue;
long long t = solve(x - id[r], r) * solve(mask - x, par);
ans += t;
}
x = (x + 1 + (~mask)) & mask;
} while (x);
return f[mask][par] = ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(9);
cout.setf(ios::fixed, ios::floatfield);
memset(isEdge, 0, sizeof(isEdge));
memset(isParent, 0, sizeof(isParent));
memset(isNotParent, 0, sizeof(isNotParent));
memset(isLCA, 0, sizeof(isLCA));
cin >> n >> m >> nQ;
for (long long i = (1); i <= (n); ++i) id[i] = 1 << (i - 1);
while (m--) {
int u, v;
cin >> u >> v;
isEdge[u][v] = isEdge[v][u] = 1;
}
while (nQ--) {
int u, v, r;
cin >> u >> v >> r;
if (!check_0(u, v, r)) {
cout << 0 << '\n';
return 0;
}
if (r != u) isNotParent[u][v] = 1;
if (r != v) isNotParent[v][u] = 1;
isParent[r][u] = isParent[r][v] = 1;
if (r != u && r != v) isLCA[r][u][v] = isLCA[r][v][u] = 1;
}
for (long long i = (1); i <= (n); ++i) isParent[i][i] = isNotParent[i][i] = 0;
memset(f, -1, sizeof(f));
int mask = 0;
for (long long i = (2); i <= (n); ++i) mask |= id[i];
init(mask);
cout << solve(mask, 1) << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[5010];
int p[5010];
int d[5010][5010];
int main() {
cin.tie(0);
cin.sync_with_stdio(false);
int n;
cin >> n;
int prev[5010];
int prev2[5010];
for (int i = 0; i < n; i++) {
cin >> a[i];
prev[i] = a[i];
}
p[0] = a[0];
for (int i = 1; i < n; i++) p[i] = p[i - 1] ^ a[i];
for (int i = 2; i <= n; i++) {
for (int j = 0; j <= n - i; j++) {
prev2[j] = prev[j] ^ prev[j + 1];
d[j][j + i - 1] = prev2[j];
}
for (int j = 0; j <= n - i; j++) prev[j] = prev2[j];
}
for (int i = 0; i < n; i++) d[i][i] = a[i];
for (int k = 1; k <= n; k++)
for (int i = 0; i < n - k; i++) {
if (i < n) d[i][i + k] = max(d[i][i + k], d[i + 1][i + k]);
if (i + k - 1 >= 0) d[i][i + k] = max(d[i][i + k], d[i][i + k - 1]);
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int x1;
int x2;
cin >> x1 >> x2;
x1--;
x2--;
cout << d[x1][x2] << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
void print() { cout << "\n"; }
template <typename T, typename... Types>
void print(T var1, Types... var2) {
cout << var1 << " ";
print(var2...);
}
template <typename T>
T fceil(T a, T b) {
return (T)(a + b - 1) / b;
}
template <typename T>
void printvec(vector<T> v) {
for (int i = 0; i < (int)v.size(); i++) {
cout << v[i] << " ";
}
cout << "\n";
}
template <typename T>
void printarr(T a[], int n) {
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n % 3 == 0) {
cout << n / 3 << " ";
cout << 0 << " ";
cout << 0 << "\n";
} else if (n % 5 == 0) {
cout << 0 << " ";
cout << n / 5 << " ";
cout << 0 << "\n";
} else if (n % 7 == 0) {
cout << 0 << " ";
cout << 0 << " ";
cout << n / 7 << "\n";
} else {
unordered_map<int, int> m;
for (int i = 0; i < n; i++) {
m[n - (3 * i)] = 1;
}
int flag = 0;
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (m[5 * j + 7 * k] == 1) {
cout << (n - (5 * j + 7 * k)) / 3 << " ";
cout << j << " ";
cout << k << "\n";
flag = 1;
break;
}
}
if (flag == 1) {
break;
}
}
if (flag) {
continue;
} else {
cout << -1 << "\n";
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a[i] = x;
}
long long cnt = 1;
long long ans = 0;
for (int i = 0; i < n; i++) {
if (i < n - 1 && a[i] == a[i + 1])
cnt++;
else {
ans += (cnt * (cnt + 1)) / 2;
cnt = 1;
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int sieve[1000003 + 5];
long long int num_primes[1000005] = {0};
void calc_sieve() {
for (long long int i = 0; i <= 1000003; i++) sieve[i] = 0;
sieve[0] = sieve[1] = 1;
for (long long int i = 2; i <= 1000003; i++) {
num_primes[i] = num_primes[i - 1];
if (sieve[i] == 0) {
num_primes[i]++;
for (long long int j = i + i; j <= 1000003; j = j + i) sieve[j]++;
}
}
}
long long int ans = -1;
bool check(long long int a, long long int b, long long int l, long long int k) {
for (long long int i = a; i <= b - l + 1; i++) {
if (num_primes[i + l - 1] - num_primes[i - 1] < k) return false;
}
ans = l;
return true;
}
void binary_search_primes(long long int a, long long int b, long long int k,
long long int start, long long int end) {
if (end - start <= 1) {
if (!check(a, b, start, k)) check(a, b, end, k);
return;
}
long long int mid = (start + end) / 2;
if (check(a, b, mid, k)) {
binary_search_primes(a, b, k, start, mid - 1);
} else {
binary_search_primes(a, b, k, mid + 1, end);
}
}
int main() {
calc_sieve();
long long int a, b, k;
cin >> a >> b >> k;
binary_search_primes(a, b, k, 1, b - a + 1);
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long read() {
long long s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
inline void print(long long *f, long long len) {
for (long long i = 0; i < len; i++) printf("%lld ", f[i]);
puts("");
}
long long f[303030], w[101010], sum;
const long long mod = 1e9 + 7;
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long inv(long long x) { return qpow(x, mod - 2); }
long long F(long long x) { return (m - 1) * (m - x) % mod * f[x - 1] % mod; }
signed main() {
n = read();
long long mx = -1;
for (long long i = 1, iend = n; i <= iend; ++i)
w[i] = read(), m += w[i], mx = max(mx, w[i]);
f[0] = inv(m);
for (long long i = 1, iend = min(mx, m - 1); i <= iend; ++i)
f[i] = f[i - 1] + inv(m - i), f[i] %= mod;
long long ans = 0;
for (long long i = 1, iend = n; i <= iend; ++i) ans += F(w[i]), ans %= mod;
cout << ans;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a;
b = a;
reverse(b.begin(), b.end());
printf("%s%s\n", a.c_str(), b.c_str());
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, l, r, mn = 0, mx = 0;
cin >> n >> l >> r;
mn = 1 * (n - (min(l, n)) + 1);
for (int i = 0; i < min(l, n) - 1; i++) {
mn += (1 << (i + 1));
}
for (int i = 0; i < n; i++) {
if ((i + 1) <= r)
mx += (1 << i);
else
mx += (1 << (r - 1));
}
cout << mn << " " << mx << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a = n / 2;
int b = n % 2;
int rem = m - (a + b) % m;
rem = rem % m;
if (rem <= a) {
cout << (a + rem + b) << endl;
} else {
cout << "-1" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:36777216")
template <class T>
inline void RD(T &);
template <class T>
inline void OT(const T &);
inline long long RD() {
long long x;
RD(x);
return x;
}
template <class T>
inline T &_RD(T &x) {
RD(x);
return x;
}
inline void RC(char &c) { scanf(" %c", &c); }
inline char RC() {
char c;
RC(c);
return c;
}
inline char _RC(char &c) {
RC(c);
return c;
}
inline void RF(double &x) { scanf("%lf", &x); };
inline double RF() {
double x;
RF(x);
return x;
}
inline double _RF(double &x) {
RD(x);
return x;
}
inline void RS(char *s) { scanf("%s", s); }
inline char *_RS(char *s) {
scanf("%s", s);
return s;
}
template <class T0, class T1>
inline void RD(T0 &x0, T1 &x1) {
RD(x0), RD(x1);
}
template <class T0, class T1, class T2>
inline void RD(T0 &x0, T1 &x1, T2 &x2) {
RD(x0), RD(x1), RD(x2);
}
template <class T0, class T1, class T2, class T3>
inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3) {
RD(x0), RD(x1), RD(x2), RD(x3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6);
}
template <class T0, class T1>
inline void OT(T0 &x0, T1 &x1) {
OT(x0), OT(x1);
}
template <class T0, class T1, class T2>
inline void OT(T0 &x0, T1 &x1, T2 &x2) {
OT(x0), OT(x1), OT(x2);
}
template <class T0, class T1, class T2, class T3>
inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3) {
OT(x0), OT(x1), OT(x2), OT(x3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);
}
inline void RF(double &a, double &b) { RF(a), RF(b); }
inline void RF(double &a, double &b, double &c) { RF(a), RF(b), RF(c); }
inline void RS(char *s1, char *s2) { RS(s1), RS(s2); }
inline void RS(char *s1, char *s2, char *s3) { RS(s1), RS(s2), RS(s3); }
template <class T>
inline void RST(T &A) {
memset(A, 0, sizeof(A));
}
template <class T0, class T1>
inline void RST(T0 &A0, T1 &A1) {
RST(A0), RST(A1);
}
template <class T0, class T1, class T2>
inline void RST(T0 &A0, T1 &A1, T2 &A2) {
RST(A0), RST(A1), RST(A2);
}
template <class T0, class T1, class T2, class T3>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
RST(A0), RST(A1), RST(A2), RST(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);
}
template <class T>
inline void CLR(priority_queue<T, vector<T>, less<T> > &Q) {
while (!Q.empty()) Q.pop();
}
template <class T>
inline void CLR(priority_queue<T, vector<T>, greater<T> > &Q) {
while (!Q.empty()) Q.pop();
}
template <class T>
inline void CLR(T &A) {
A.clear();
}
template <class T0, class T1>
inline void CLR(T0 &A0, T1 &A1) {
CLR(A0), CLR(A1);
}
template <class T0, class T1, class T2>
inline void CLR(T0 &A0, T1 &A1, T2 &A2) {
CLR(A0), CLR(A1), CLR(A2);
}
template <class T0, class T1, class T2, class T3>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);
}
template <class T>
inline void CLR(T &A, int n) {
for (int i = 0; i < int(n); ++i) CLR(A[i]);
}
template <class T>
inline void FLC(T &A, int x) {
memset(A, x, sizeof(A));
}
template <class T0, class T1>
inline void FLC(T0 &A0, T1 &A1, int x) {
FLC(A0, x), FLC(A1, x);
}
template <class T0, class T1, class T2>
inline void FLC(T0 &A0, T1 &A1, T2 &A2) {
FLC(A0), FLC(A1), FLC(A2);
}
template <class T0, class T1, class T2, class T3>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5), FLC(A6);
}
template <class T>
inline void SRT(T &A) {
sort(A.begin(), A.end());
}
template <class T, class C>
inline void SRT(T &A, C B) {
sort(A.begin(), A.end(), B);
}
const int MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-9;
const double OO = 1e15;
const double PI = acos(-1.0);
template <class T>
inline void checkMin(T &a, const T b) {
if (b < a) a = b;
}
template <class T>
inline void checkMax(T &a, const T b) {
if (b > a) a = b;
}
template <class T, class C>
inline void checkMin(T &a, const T b, C c) {
if (c(b, a)) a = b;
}
template <class T, class C>
inline void checkMax(T &a, const T b, C c) {
if (c(a, b)) a = b;
}
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
template <class T>
inline T sqr(T a) {
return a * a;
}
template <class T>
inline T cub(T a) {
return a * a * a;
}
int Ceil(int x, int y) { return (x - 1) / y + 1; }
inline bool _1(int x, int i) { return x & 1 << i; }
inline bool _1(long long x, int i) { return x & 1LL << i; }
inline long long _1(int i) { return 1LL << i; }
inline long long _U(int i) { return _1(i) - 1; };
template <class T>
inline T low_bit(T x) {
return x & -x;
}
template <class T>
inline T high_bit(T x) {
T p = low_bit(x);
while (p != x) x -= p, p = low_bit(x);
return p;
}
template <class T>
inline T cover_bit(T x) {
T p = 1;
while (p < x) p <<= 1;
return p;
}
inline int count_bits(int x) {
x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1);
x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2);
x = (x & 0x0f0f0f0f) + ((x & 0xf0f0f0f0) >> 4);
x = (x & 0x00ff00ff) + ((x & 0xff00ff00) >> 8);
x = (x & 0x0000ffff) + ((x & 0xffff0000) >> 16);
return x;
}
inline int count_bits(long long x) {
x = (x & 0x5555555555555555LL) + ((x & 0xaaaaaaaaaaaaaaaaLL) >> 1);
x = (x & 0x3333333333333333LL) + ((x & 0xccccccccccccccccLL) >> 2);
x = (x & 0x0f0f0f0f0f0f0f0fLL) + ((x & 0xf0f0f0f0f0f0f0f0LL) >> 4);
x = (x & 0x00ff00ff00ff00ffLL) + ((x & 0xff00ff00ff00ff00LL) >> 8);
x = (x & 0x0000ffff0000ffffLL) + ((x & 0xffff0000ffff0000LL) >> 16);
x = (x & 0x00000000ffffffffLL) + ((x & 0xffffffff00000000LL) >> 32);
return x;
}
int reverse_bits(int x) {
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa);
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc);
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0);
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00);
x = ((x >> 16) & 0x0000ffff) | ((x << 16) & 0xffff0000);
return x;
}
long long reverse_bits(long long x) {
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL);
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL);
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL);
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL);
x = ((x >> 16) & 0x0000ffff0000ffffLL) | ((x << 16) & 0xffff0000ffff0000LL);
x = ((x >> 32) & 0x00000000ffffffffLL) | ((x << 32) & 0xffffffff00000000LL);
return x;
}
inline void INC(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
inline int sum(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
inline void DEC(int &a, int b) {
a -= b;
if (a < 0) a += MOD;
}
inline int dff(int a, int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
inline void MUL(int &a, int b) { a = (long long)a * b % MOD; }
inline int pdt(int a, int b) { return (long long)a * b % MOD; }
inline int sum(int a, int b, int c) { return sum(sum(a, b), c); }
inline int sum(int a, int b, int c, int d) { return sum(sum(a, b), sum(c, d)); }
inline int pow(int a, long long b) {
int c(1);
while (b) {
if (b & 1) MUL(c, a);
MUL(a, a), b >>= 1;
}
return c;
}
template <class T>
inline T pow(T a, long long b) {
T c(1);
while (b) {
if (b & 1) c *= a;
a *= a, b >>= 1;
}
return c;
}
inline int _I(int b) {
int a = MOD, x1 = 0, x2 = 1, q;
while (true) {
q = a / b, a %= b;
if (!a) return (x2 + MOD) % MOD;
DEC(x1, pdt(q, x2));
q = b / a, b %= a;
if (!b) return (x1 + MOD) % MOD;
DEC(x2, pdt(q, x1));
}
}
inline void DIA(int &a, int b) { MUL(a, _I(b)); }
inline int qtt(int a, int b) { return pdt(a, _I(b)); }
inline int phi(int n) {
int res = n;
for (int i = 2; sqr(i) <= n; ++i)
if (!(n % i)) {
DEC(res, qtt(res, i));
do {
n /= i;
} while (!(n % i));
}
if (n != 1) DEC(res, qtt(res, n));
return res;
}
inline int rand32() {
return (bool(rand() & 1) << 30) | (rand() << 15) + rand();
}
inline int random32(int l, int r) { return rand32() % (r - l + 1) + l; }
inline int random(int l, int r) { return rand() % (r - l + 1) + l; }
int dice() { return rand() % 6; }
bool coin() { return rand() % 2; }
template <class T>
inline void RD(T &x) {
char c;
for (c = getchar(); c < '0'; c = getchar())
;
x = c - '0';
for (c = getchar(); c >= '0'; c = getchar()) x = x * 10 + c - '0';
}
int ____Case;
template <class T>
inline void OT(const T &x) {
printf("%d ", x);
}
int Got[1005], Left[1005];
double f[1005][1005];
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<pair<int, int> > g;
g.reserve(1005);
for (int i = 0; i < m; i++) {
scanf("%d", &Left[i]);
for (int j = 0; j < Left[i]; j++) {
int c;
scanf("%d", &c);
g.push_back(make_pair(c, i));
}
}
int t = g.size();
sort(g.begin(), g.end(), greater<pair<int, int> >());
int d = g[n - 1].first, i;
long double p = 1;
for (i = 0; g[i].first != d; i++) {
int name = g[i].second;
p *= (double)++Got[name] / Left[name]--;
}
vector<int> id;
id.reserve(1005);
int l = n - i;
for (; i < t && g[i].first == d; i++) {
id.push_back(g[i].second);
}
int s = id.size();
double Q[1005];
for (int i = 0; i < s; i++) {
Q[i] = (Got[id[i]] + 1.) / (Left[id[i]] ? Left[id[i]] : 1);
}
f[0][0] = 1;
for (int i = 0; i < int(s); ++i)
for (int b____ = int(min(i, l)), j = 0; j <= b____; ++j) {
f[i + 1][j] += f[i][j] * (i - j + 1) / (i + 1);
f[i + 1][j + 1] += f[i][j] * Q[i] * (j + 1) / (i + 1);
}
cout << fixed << setprecision(9) << p * f[s][l] << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N, L, K;
double memo[200 + 1][200 + 1][2 * (200 + 1)];
bool visit[200 + 1][200 + 1][2 * (200 + 1)];
float p[200 + 1];
int a[200 + 1];
double prob(int d, int w, int c) {
if (d == N + 1) return (w >= L && c >= 0) ? 1.0 : 0.0;
if (!visit[d][w][c + 200]) {
memo[d][w][c + 200] = p[d] * prob(d + 1, w + 1, min(N, c + a[d])) +
(1 - p[d]) * prob(d + 1, w, c);
visit[d][w][c + 200] = true;
}
return memo[d][w][c + 200];
}
void clearVisit() {
for (int i = 0; i < 200 + 1; i++) {
for (int j = 0; j < 200 + 1; j++) {
for (int k = 0; k < 2 * (200 + 1); k++) {
visit[i][j][k] = false;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
clearVisit();
cin >> N >> L >> K;
for (int i = 1; i <= N; i++) cin >> p[i];
for (int i = 1; i <= N; i++) p[i] = p[i] / 100.0;
for (int i = 1; i <= N; i++) cin >> a[i];
std::cout << std::fixed;
std::cout << std::setprecision(12);
cout << prob(1, 0, K) << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400000 + 10;
const double eps = 1e-9;
const double pi = acos(-1);
int n;
long long k;
struct Vec {
int x, y;
double d() { return x * x + y * y; }
} p[N];
vector<double> v;
int id(double x) { return lower_bound(v.begin(), v.end(), x) - v.begin() + 1; }
int bit[N];
void add(int x, int k) {
while (x < N) {
bit[x] += k;
x += x & (-x);
}
}
int sum(int x) {
int ans = 0;
while (x > 0) {
ans += bit[x];
x -= x & (-x);
}
return ans;
}
long long cal(vector<pair<double, double> > vec) {
memset(bit, 0, sizeof(bit));
sort(vec.begin(), vec.end());
v.clear();
for (auto p : vec) {
v.push_back(p.first);
v.push_back(p.second);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
long long res = 0;
for (auto p : vec) {
res += sum(id(p.second)) - sum(id(p.first));
add(id(p.second), 1);
}
return res;
}
double check(double x) {
vector<pair<double, double> > vec;
long long tot = 1LL * n * (n - 1) / 2, cnt = 0;
for (int i = 1; i <= n; i++) {
if (p[i].d() > x * x - eps) {
double dis = sqrt(p[i].d());
double theta = acos(x / dis);
double mid = atan2(p[i].y, p[i].x);
int pre = vec.size();
if (mid < 0) mid += 2 * pi;
if (mid + theta > 2 * pi) {
vec.push_back(make_pair(mid + theta - 2 * pi, mid - theta));
} else if (mid - theta < 0) {
vec.push_back(make_pair(mid + theta, mid - theta + 2 * pi));
} else {
vec.push_back(make_pair(mid - theta, mid + theta));
}
int cur = vec.size();
}
}
tot -= cal(vec);
return tot >= k;
}
int main() {
scanf("%d%lld", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i].x, &p[i].y);
}
double lef = 0, rig = 2e4;
for (int i = 1; i <= 100; i++) {
double mid = (lef + rig) / 2;
if (check(mid))
rig = mid;
else
lef = mid;
}
printf("%.8f\n", rig);
}
| 12 |
#include<bits/stdc++.h>
typedef int LL;
typedef double dl;
#define opt operator
#define pb push_back
#define pii std::pair<LL,LL>
const LL maxn=1e5+9,mod=998244353,inf=0x3f3f3f3f;
LL Read(){
LL x(0),f(1); char c=getchar();
while(c<'0' || c>'9'){
if(c=='-') f=-1; c=getchar();
}
while(c>='0' && c<='9'){
x=(x<<3ll)+(x<<1ll)+c-'0'; c=getchar();
}return x*f;
}
void Chkmin(LL &x,LL y){
if(y<x) x=y;
}
void Chkmax(LL &x,LL y){
if(y>x) x=y;
}
LL add(LL x,LL y){
return x+=y,x>=mod?x-mod:x;
}
LL dec(LL x,LL y){
return x-=y,x<0?x+mod:x;
}
LL mul(LL x,LL y){
return 1ll*x*y%mod;
}
LL Pow(LL base,LL b){
LL ret(1); while(b){
if(b&1) ret=mul(ret,base); base=mul(base,base); b>>=1;
}return ret;
}
LL n,m;
namespace Sgt{
LL nod;
LL mi[maxn*100],son[maxn*100][2];
void Modify(LL &nw,LL l,LL r,LL x,LL v){
// printf("(%d,%d)%d,%d\n",l,r,x,v);
if(!nw) mi[nw=++nod]=m+1;
Chkmin(mi[nw],v);
if(l==r) return;
LL mid(l+r>>1);
if(x<=mid) Modify(son[nw][0],l,mid,x,v);
else Modify(son[nw][1],mid+1,r,x,v);
}
LL Query(LL nw,LL l,LL r,LL lt,LL rt){
if(!nw) return m+1;
if(lt<=l && rt>=r) return mi[nw];
LL mid(l+r>>1);
if(rt<=mid) return Query(son[nw][0],l,mid,lt,rt);
if(lt>mid) return Query(son[nw][1],mid+1,r,lt,rt);
return std::min(Query(son[nw][0],l,mid,lt,rt),Query(son[nw][1],mid+1,r,lt,rt));
}
}
namespace Bit{
LL N;
LL root[maxn];
void Init(LL N0){
N=N0;
}
LL Lowbit(LL x){
return x&(-x);
}
void Modify(LL x,LL r,LL id){
for(;x;x-=Lowbit(x)){
Sgt::Modify(root[x],1,n,r,id);
}
}
LL Query(LL x,LL r){
LL l(x);
LL ret(m+1);
for(;x<=N;x+=Lowbit(x)){
Chkmin(ret,Sgt::Query(root[x],1,n,l,r));
}
return ret;
}
}
pii range[maxn];
std::vector<LL> Q[maxn];
void Init(){
n=Read(); m=Read();
for(LL i=1;i<=m;++i){
LL l(Read()),r(Read());
range[i]=pii(l,r);
Q[r-l+1].pb(i);
}
}
struct node{
LL t,l,r;
bool opt < (const node A)const{
return t<A.t;
}
};
LL Get(LL len){
for(LL i=0;i<Q[len].size();++i){
LL id(Q[len][i]);
Bit::Modify(range[id].first,range[id].second,id);
}
static std::queue<node> que;
LL tot(0);
{
LL x(Bit::Query(1,n));
if(x==m+1) return 0;
que.push((node){x,1,n});
}
LL ret(0);
while(que.size()){
LL id(que.front().t),lt(que.front().l),rt(que.front().r); que.pop();
LL l(range[id].first),r(range[id].second);
ret+=r-l+1;
--l;
if(lt<=l && l-lt+1>=len){
LL x(Bit::Query(lt,l));
if(x^(m+1)){
que.push((node){x,lt,l});
}
}
++r;
if(r<=rt && rt-r+1>=len){
LL x(Bit::Query(r,rt));
if(x^(m+1)){
que.push((node){x,r,rt});
}
}
}
return ret;
}
void Solve(){
Sgt::mi[0]=m+1;
static LL ans[maxn];
Bit::Init(n);
for(LL i=n;i>=1;--i){
ans[i]=Get(i);
}
for(LL i=1;i<=n;++i){
printf("%d\n",ans[i]);
}
}
int main(){
// freopen("y1.txt","r",stdin);
Init();
Solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
const int N = 1000006;
int n;
int a[N];
int qq;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
scanf("%d", &qq);
while (qq--) {
int x;
scanf("%d", &x);
a[x] *= (-1);
}
stack<int> s;
for (int i = n; i >= 1; --i) {
if (a[i] < 0) {
s.push(-a[i]);
} else {
if (!s.empty() && s.top() == a[i]) {
s.pop();
} else {
a[i] *= (-1);
s.push(-a[i]);
}
}
}
if (!s.empty()) {
printf("NO\n");
return 0;
}
printf("YES\n");
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
typedef char* cstr;
const int oo = (~0u) >> 1;
const long long int ooll = (~0ull) >> 1;
const double inf = 1e100;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <typename type>
inline bool cmax(type& a, const type& b) {
return a < b ? a = b, true : false;
}
template <typename type>
inline bool cmin(type& a, const type& b) {
return a > b ? a = b, true : false;
}
template <typename type>
inline int sgn(const type& first) {
return (first > 0) - (first < 0);
}
template <>
inline int sgn(const double& first) {
return (first > +eps) - (first < -eps);
}
template <typename type>
void inc(vector<type>& st, int first, type inc) {
while (first < ((int)(st).size()))
st[first] += inc, first += (first) & (-(first));
}
template <typename type>
type sum(vector<type>& st, int first) {
type s = 0;
while (first > 0) s += st[first], first -= (first) & (-(first));
return s;
}
bool first(long long int a, long long int b) {
if (a == 0)
return false;
else if (first(b % a, a))
return (b / a) % (a + 1) % 2 == 0;
else
return true;
}
int main() {
int t;
cin >> t;
while (t--) {
long long int a, b;
cin >> a >> b;
if (a > b) swap(a, b);
cout << (first(a, b) ? "First" : "Second") << endl;
}
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("avx")
using namespace std;
template <typename T>
inline bool cmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool cmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
int inp() {
int x = 0, f = 1;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x * f;
}
struct comp {
double r, i;
inline comp() {}
inline comp(double a, double b) : r(a), i(b) {}
};
const int N = (1 << 19), MaxN = (N << 1) + 10;
const int K = 32767, L = 15;
int P;
inline comp add(comp a, comp b) { return comp(a.r + b.r, a.i + b.i); }
inline comp sub(comp a, comp b) { return comp(a.r - b.r, a.i - b.i); }
inline comp mul(comp a, comp b) {
return comp(a.r * b.r - a.i * b.i, a.r * b.i + a.i * b.r);
}
inline comp div(comp a, double b) { return comp(a.r / b, a.i / b); }
inline comp conj(comp x) { return comp(x.r, -x.i); }
inline int add(int x, int y) {
return x + (long long)y >= P ? x + (long long)y - P : x + y;
}
inline int sub(int x, int y) { return x >= y ? x - y : x - (long long)y + P; }
inline int mul(int x, int y) { return (long long)x * y % P; }
int exp(int x, long long n) {
int res = 1;
for (; n; n >>= 1) {
if (n & 1) res = mul(res, x);
x = mul(x, x);
}
return res;
}
comp eps[MaxN];
void init() {
double pi = acos(-1);
for (int i = 0; i < N; i++)
eps[i] = comp(cos(2 * pi * i / N), sin(2 * pi * i / N));
}
inline void trans(int n, comp x[], comp w[]) {
for (int i = 0, j = 0; i != n; i++) {
if (i < j) std::swap(x[i], x[j]);
for (int l = n >> 1; (j ^= l) < l; l >>= 1)
;
}
for (int i = 2; i <= n; i <<= 1) {
int l = i >> 1, d = N / i;
for (int j = 0; j != n; j += i)
for (int k = 0; k != l; k++) {
comp t = mul(x[j + k + l], w[d * k]);
x[j + k + l] = sub(x[j + k], t);
x[j + k] = add(x[j + k], t);
}
}
}
inline void dft(int n, comp x[]) { trans(n, x, eps); }
inline void idft(int n, comp x[]) {
trans(n, x, eps);
reverse(x + 1, x + n);
for (int i = 0; i < n; i++) x[i] = div(x[i], n);
}
int t[MaxN];
void conv(int na, int a[], int nb, int b[], int nc, int c[], int same = 0) {
int n, i, j;
if ((long long)na * nb <= 1e4) {
for (i = 0; i < nc; i++) t[i] = 0;
for (i = 0; i < na; i++)
for (j = 0; j < nb && j + i < nc; j++)
t[i + j] = add(t[i + j], mul(a[i], b[j]));
for (i = 0; i <= nc; i++) c[i] = t[i];
return;
}
static comp x[MaxN], y[MaxN], z[MaxN], w[MaxN];
for (n = 1; n < na + nb - 1; n <<= 1)
;
for (i = 0; i < n; i++) {
x[i] = i < na ? comp(a[i] & K, a[i] >> L) : comp(0, 0);
y[i] = i < nb ? comp(b[i] & K, b[i] >> L) : comp(0, 0);
}
dft(n, x);
if (!same)
dft(n, y);
else
for (i = 0; i < n; i++) y[i] = x[i];
comp r0(0.5, 0), r1(0, -0.5), r(0, 1);
for (i = 0; i < n; i++) {
int j = (n - i) & (n - 1);
comp x0, x1, y0, y1;
x0 = mul(add(x[i], conj(x[j])), r0);
x1 = mul(sub(x[i], conj(x[j])), r1);
y0 = mul(add(y[i], conj(y[j])), r0);
y1 = mul(sub(y[i], conj(y[j])), r1);
z[i] = mul(x0, add(y0, mul(y1, r)));
w[i] = mul(x1, add(y0, mul(y1, r)));
}
idft(n, z);
idft(n, w);
for (i = 0; i < nc; i++) {
int c00 = (long long)(z[i].r + 0.5) % P,
c01 = (long long)(z[i].i + 0.5) % P;
int c10 = (long long)(w[i].r + 0.5) % P,
c11 = (long long)(w[i].i + 0.5) % P;
c[i] = ((((long long)c11 << L) + c01 + c10 << L) + c00) % P;
}
}
int nL;
int n, l, r, x[MaxN], y[MaxN];
void pow(int x[], int y[], int n) {
y[0] = 1;
int sN = 3;
nL = 1;
for (; n; n >>= 1) {
if (n & 1)
conv(sN, x, nL, y, min(nL + sN, 2 * ::n + 3), y),
nL = min(nL + sN, 2 * ::n + 3);
conv(sN, x, sN, x, min(sN << 1, 2 * ::n + 3), x, 1);
sN = min(sN << 1, 2 * ::n + 3);
}
}
int res(int x) { return y[x + n]; }
int main() {
int ans;
init();
cin >> n >> P >> l >> r;
x[0] = x[1] = x[2] = 1;
pow(x, y, n);
ans = ((long long)res(l) + res(l + 1) - res(r + 1) - res(r + 2)) % P;
cout << ((long long)ans + P) % P << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
vector<int> aux(n * n);
for (int i = 1; i <= n * n; i++) {
v.push_back(i);
}
for (int i = 0; i < n; i++) {
for (int j = 0 + n * i; j < n / 2 + n * i; j++) {
cout << v[j] << " " << v[v.size() - 1 - j] << " ";
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct CumulativeSum {
vector<T> data;
CumulativeSum(int sz) : data(sz, 0){};
void add(int k, int x) { data[k] += x; }
void build() {
for (int i = 1; i < data.size(); i++) {
data[i] += data[i - 1];
}
}
T query(int k) {
if (k < 0) return (0);
return (data[min(k, (int)data.size() - 1)]);
}
};
const int mod = 1e9 + 7;
inline long long modPow(long long x, long long n) {
if (n == 0) return (1);
long long ret = modPow(x, n / 2);
(ret *= ret) %= mod;
if (n & 1) (ret *= x) %= mod;
return (ret);
}
inline long long modInv(long long a) { return (modPow(a, mod - 2)); }
static long long fact[404040], rfact[404040];
int main() {
fact[0] = rfact[0] = 1;
for (int i = 1; i < 404040; i++) {
fact[i] = fact[i - 1] * i % mod;
rfact[i] = modInv(fact[i]);
}
string S;
cin >> S;
int N = (int)S.size();
CumulativeSum<int> open(N), close(N);
for (int i = 0; i < S.size(); i++) {
if (S[i] == '(')
open.add(i, 1);
else
close.add(i, 1);
}
open.build();
close.build();
long long ret = 0;
for (int i = 0; i < N; i++) {
if (S[i] == '(') {
int l = open.query(i), r = close.query(N) - close.query(i);
(ret += fact[l + r - 1] * r % mod * rfact[l] % mod * rfact[r] % mod) %=
mod;
}
}
cout << ret << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct cels {
int pils1;
int pils2;
int att;
};
int main() {
int pilsetu_sk;
int celu_sk;
int noliktavu_sk;
cels celi[100000];
bool irNol[100000] = {false};
int cur_nol_ind;
int rez;
scanf("%d %d %d", &pilsetu_sk, &celu_sk, &noliktavu_sk);
rez = -1;
if (noliktavu_sk > 0 && noliktavu_sk < pilsetu_sk) {
for (int i = 0; i < celu_sk; i++) {
scanf("%d %d %d", &celi[i].pils1, &celi[i].pils2, &celi[i].att);
}
for (int i = 0; i < noliktavu_sk; i++) {
scanf("%d", &cur_nol_ind);
irNol[--cur_nol_ind] = true;
}
for (int i = 0; i < celu_sk; i++) {
if ((irNol[celi[i].pils1 - 1] != irNol[celi[i].pils2 - 1]) &&
(rez == -1 || celi[i].att < rez)) {
rez = celi[i].att;
}
}
}
printf("%d\n", rez);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long T, x, y, z;
cin >> T;
for (int tc = 1; tc <= T; tc++) {
int n, k;
cin >> n >> k;
string s;
while (s.length() < n) {
for (int i = 0; i < k; i++) {
char c = (char)('a' + i);
s += c;
if (s.length() == n) break;
}
if (s.length() == n) break;
}
cout << s;
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
bool state = true;
long long int i = 1;
while (state) {
if (((i * (i + 1)) / 2) <= n) {
++i;
} else {
--i;
state = false;
}
}
cout << i << endl;
long long int q = n - ((i * (i + 1)) / 2);
for (int j = i; j >= 1; --j) {
if (q > 0) {
cout << j + 1 << " ";
--q;
} else {
cout << j << " ";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long m, long long n) {
long long r;
while (n != 0) {
r = m % n;
m = n;
n = r;
}
return m;
}
int main() {
double r1 = 0, p1 = 0, p2 = 6000;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
double a;
cin >> a;
r1 = max(r1, a);
}
cin >> n;
for (int i = 0; i < n; i++) {
double a;
cin >> a;
p1 = max(p1, a);
}
cin >> n;
for (int i = 0; i < n; i++) {
double a;
cin >> a;
p2 = min(p2, a);
}
double A, B;
cin >> A >> B;
double r2;
r2 = (r1 * r1) / (((A * p2) / (B * p1)) + 1);
r2 = sqrt(r2);
printf("%0.10f\n", r2);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 520;
long long zi[30][N], cnt[N];
long long findl(long long x, long long l, long long r, long long A[]) {
while (l < r) {
long long mid = l + r >> 1;
if (A[mid] > x)
r = mid;
else
l = mid + 1;
}
return A[l];
}
int main() {
long long t;
cin >> t;
while (t--) {
memset(cnt, 0, sizeof(cnt));
string A, B;
cin >> A >> B;
for (long long i = 0; i < A.size(); i++) {
long long a = A[i] - 'a';
zi[a][cnt[a]++] = i;
}
long long cntl = 1;
long long l = -1;
long long flag = 0;
for (long long i = 0; i < B.size(); i++) {
long long x = B[i] - 'a';
if (cnt[x] == 0) {
flag = -1;
break;
}
long long res = findl(l, 0, cnt[x] - 1, zi[x]);
if (res <= l) {
cntl++;
l = findl(-1, 0, cnt[x] - 1, zi[x]);
} else
l = res;
}
if (flag)
cout << "-1" << endl;
else
cout << cntl << endl;
}
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx,avx2,tune=native")
template <typename T>
using Prior = std::priority_queue<T>;
template <typename T>
using prior = std::priority_queue<T, std::vector<T>, std::greater<T>>;
using namespace std;
void pre() {}
void solve() {
int n, k;
cin >> n >> k;
vector<long long> arr(n);
for (auto& x : arr) cin >> x;
vector<vector<long long>> dp(n, vector<long long>(n + 1));
for (int j = 1; j <= n; ++j)
dp[0][j] = dp[0][j - 1] + (bool)(arr[j - 1] == j);
if (dp[0].back() >= k) return cout << 0 << '\n', void();
for (int i = 1; i < n; ++i) {
for (int j = i + 1; j <= n; ++j)
dp[i][j] =
max(dp[i - 1][j - 1], dp[i][j - 1] + (bool)(arr[j - 1] == j - i));
if (dp[i].back() >= k) return cout << i << '\n', void();
}
cout << -1 << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
pre();
int _ = 1;
cin >> _;
vector<long long> __(_);
iota(begin(__), end(__), 1);
for (auto i : __) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[7999][2] = {0};
int stack_set[7999][2] = {0};
int rick[7999];
int morty[7999];
int n, r, m;
int next_index(int current) { return current % (n); }
void printA(int a[7999][2], int n, int j) {
for (int i = 1; i < n; ++i) {
int next = a[i][j];
if (next == 1) {
printf("Win ");
} else if (next == -1) {
printf("Lose ");
} else {
printf("Loop ");
}
}
printf("\n");
}
int prev_index(int value) {
if (value < 0) {
return value + n;
}
return value;
}
int other_person(int p) { return (p + 1) % 2; }
void bfs_solve(deque<pair<int, int> >& stack) {
while (!stack.empty()) {
int index = stack.front().first;
int person = stack.front().second;
stack_set[index][person] = 0;
stack.pop_front();
if (arr[index][person] != 0) {
continue;
}
int min_value_found = 1;
bool assigned = false;
int* moves;
int* other_moves;
int limit;
int other_limit;
if (person == 1) {
moves = &morty[0];
other_moves = &rick[0];
limit = m;
other_limit = r;
} else {
moves = &rick[0];
other_moves = &morty[0];
limit = r;
other_limit = m;
}
for (int i = 0; i < limit; ++i) {
int next_pos = (index + *(moves + i)) % n;
if (arr[next_pos][other_person(person)] == -1) {
arr[index][person] = 1;
assigned = true;
}
min_value_found =
min(min_value_found, arr[next_pos][other_person(person)]);
}
if (!assigned && min_value_found == 1) {
arr[index][person] = -1;
assigned = true;
}
if (assigned) {
for (int j = 0; j < other_limit; ++j) {
pair<int, int> next_pair = make_pair(
prev_index(index - *(other_moves + j)), other_person(person));
if (arr[next_pair.first][next_pair.second] == 0 &&
stack_set[next_pair.first][next_pair.second] == 0) {
stack.push_back(next_pair);
stack_set[next_pair.first][next_pair.second] = 1;
}
}
}
}
}
int main() {
scanf("%d", &n);
scanf("%d", &r);
deque<pair<int, int> > stack;
pair<int, int> to_add;
for (int i = 0; i < r; ++i) {
scanf("%d", &rick[i]);
to_add = make_pair(prev_index(0 - rick[i]), 0);
stack.push_back(to_add);
stack_set[to_add.first][to_add.second] = 1;
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
scanf("%d", &morty[i]);
to_add = make_pair(prev_index(0 - morty[i]), 1);
stack.push_back(to_add);
stack_set[to_add.first][to_add.second] = 1;
}
arr[0][0] = -1;
arr[0][1] = -1;
bfs_solve(stack);
printA(arr, n, 0);
printA(arr, n, 1);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
queue<long long> q;
map<long long, vector<long long> > m;
int cnt;
bool solve = true;
void factor(long long ele, long long turn) {
if (ele == 1) {
cout << 1 << " ";
cnt++;
if (cnt == 100000) {
solve = false;
}
return;
}
if (m[ele].size() == 0) {
int i;
vector<long long> v;
for (i = 1; i <= sqrt(ele); i++) {
if (i != sqrt(ele) && ele % i == 0) {
v.push_back(i);
v.push_back(ele / i);
} else if (ele % i == 0) {
v.push_back(i);
}
}
sort(v.begin(), v.end());
m[ele] = v;
}
if (turn == 1) {
int i;
for (i = 0; i < m[ele].size(); i++) {
cout << m[ele][i] << " ";
cnt++;
if (cnt == 100000) {
solve = false;
return;
}
}
} else {
int i;
for (i = 0; i < m[ele].size(); i++) {
factor(m[ele][i], turn - 1);
if (!solve) {
return;
}
}
}
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
int i, j, sz;
long long n, k, ele;
cin >> n >> k;
if (n == 1 || k == 0) {
cout << n;
return 0;
}
factor(n, k);
}
| 7 |
#include <bits/stdc++.h>
int ar[100005];
int main() {
int n, m;
scanf("%d %d", &n, &m);
int x, y, z;
for (int i = 0; i < m; i++) {
int sum = 0;
scanf("%d %d %d", &x, &y, &z);
int c;
c = 0;
if (ar[x] == 0) c++;
if (ar[y] == 0) c++;
if (ar[z] == 0) c++;
if (c == 3) {
ar[x] = 1;
ar[y] = 2;
ar[z] = 3;
} else if (ar[x] == 0 && c == 1)
ar[x] = 6 - ar[y] - ar[z];
else if (c == 1 && ar[z] == 0)
ar[z] = 6 - ar[x] - ar[y];
else if (ar[y] == 0 && c == 1)
ar[y] = 6 - ar[x] - ar[z];
else if (c == 2) {
sum = ar[x] + ar[y] + ar[z];
if (sum == 1) {
if (ar[x] != 0) {
ar[y] = 2;
ar[z] = 3;
} else if (ar[y] != 0) {
ar[x] = 2;
ar[z] = 3;
} else if (ar[z] != 0) {
ar[x] = 2;
ar[y] = 3;
}
} else if (sum == 2) {
if (ar[x] != 0) {
ar[y] = 1;
ar[z] = 3;
} else if (ar[y] != 0) {
ar[x] = 1;
ar[z] = 3;
} else if (ar[z] != 0) {
ar[x] = 1;
ar[y] = 3;
}
} else if (sum == 3) {
if (ar[x] != 0) {
ar[y] = 1;
ar[z] = 2;
} else if (ar[y] != 0) {
ar[x] = 1;
ar[z] = 2;
} else if (ar[z] != 0) {
ar[x] = 1;
ar[y] = 2;
}
}
}
}
for (int i = 1; i <= n; i++) printf("%d ", ar[i]);
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int mxN = 1e5;
int main() {
long long n, m, k;
long long ans = 0;
cin >> n >> m >> k;
if (n < m) swap(n, m);
if (k > n + m - 2) {
cout << -1;
return 0;
}
if (k >= n) {
ans = max(ans, m / (k - n + 2));
}
if (k < m) {
ans = max(ans, n * (m / (k + 1)));
}
if (k < n) {
ans = max(ans, m * (n / (k + 1)));
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
template <typename T>
void UpdateMin(T& a, const T b) {
a = std::min(a, b);
}
template <typename T>
void UpdateMax(T& a, const T b) {
a = std::max(a, b);
}
static const long double Eps = 1.0e-09;
template <typename T>
bool IsEqual(const T a, const T b) {
return std::abs(a - b) < Eps;
}
template <typename T>
bool IsGreater(const T a, const T b) {
return a > b + Eps;
}
template <typename T>
bool IsLess(const T a, const T b) {
return a + Eps < b;
}
template <typename T>
std::string ToStr(const T& val) {
std::ostringstream ostr;
ostr << val;
return ostr.str();
}
template <typename T>
bool FromStr(const std::string& str, T& val) {
std::istringstream istr(str);
istr >> val;
return !!istr;
}
template <typename T>
std::istream& operator>>(std::istream& ist, std::vector<T>& data) {
;
for (size_t i = 0; i < data.size(); i++) {
ist >> data[i];
}
return ist;
}
template <typename T>
T Read(std::istream& ist) {
;
T val;
ist >> val;
return val;
}
template <typename T>
std::ostream& operator<<(std::ostream& ost, const std::vector<T>& data) {
for (size_t i = 0; i < data.size(); i++) {
if (i != 0) {
ost << ' ';
}
ost << data[i];
}
return ost;
}
template <size_t id>
class StopWatch {};
size_t GetMaxLength(const std::vector<int32_t>& a) {
const int32_t PINF = std::numeric_limits<int32_t>::max();
const int32_t MINF = std::numeric_limits<int32_t>::min();
const size_t n = a.size();
std::vector<int32_t> d(n + 1);
d[0] = MINF;
for (size_t i = 1; i < d.size(); ++i) {
d[i] = PINF;
}
for (size_t i = 0; i < n; i++) {
const int32_t v = a[i];
const size_t j =
std::distance(d.begin(), std::upper_bound(d.begin(), d.end(), v));
if ((d[j - 1] <= v) && (v < d[j])) {
d[j] = v;
}
}
size_t ans = 0;
for (size_t i = 0; i < d.size(); i++) {
if (d[i] != PINF) {
ans = i;
}
}
return ans;
}
bool Solve(std::istream& ist, std::ostream& ost, const bool multipleTestMode) {
StopWatch<1> sw;
(void)sw;
size_t n;
ist >> n;
if (multipleTestMode && !ist) return false;
uint64_t t;
ist >> t;
std::vector<int32_t> a(n);
ist >> a;
std::map<int32_t, size_t> c;
for (size_t i = 0; i < a.size(); i++) {
c[a[i]] += 1;
}
const uint64_t limit = 5000;
const uint64_t mult = std::min(t, limit);
std::vector<int32_t> b;
for (size_t i = 0; i < mult; i++) {
b.insert(b.end(), a.begin(), a.end());
}
uint64_t ans = GetMaxLength(b);
if (t > limit) {
b.insert(b.end(), a.begin(), a.end());
const uint64_t nextAns = GetMaxLength(b);
const uint64_t d = nextAns - ans;
ans += (t - limit) * d;
}
ost << ans << std::endl;
return multipleTestMode;
}
int main(int argc, const char* argv[]) {
std::ios_base::sync_with_stdio(false);
std::istream* ist = &std::cin;
std::ostream* ost = &std::cout;
std::unique_ptr<std::istream> fileInput;
if (argc > 1) {
fileInput.reset(new std::ifstream(argv[1]));
if (!(*fileInput)) {
std::cout << "File not found: " << argv[1] << std::endl;
}
ist = fileInput.get();
}
Solve(*ist, *ost, false);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int x1[100];
int y_1[100];
int x2[100], y2[100];
long long mx[300], my[300];
int main() {
int n;
cin >> n;
int i, j, k;
for (i = 0; i < n; i++) {
cin >> x1[i] >> y_1[i] >> x2[i] >> y2[i];
if (x1[i] > x2[i]) swap(x1[i], x2[i]);
if (y_1[i] > y2[i]) swap(y_1[i], y2[i]);
}
int x, y;
int res = 1;
for (int h = 1; h < n; h++) {
bool ok = true;
double s = 0, cx = 0, cy = 0;
for (i = h; i > 0; i--) {
double a = x2[i] - x1[i];
a = a * a * a;
cx += a * (x2[i] + x1[i]) / 2.0;
cy += a * (y2[i] + y_1[i]) / 2.0;
s += a;
double xx = cx / s;
double yy = cy / s;
j = i - 1;
if (xx < x1[j] || xx > x2[j] || yy < y_1[j] || yy > y2[j]) ok = false;
}
if (!ok) {
break;
} else
res = h + 1;
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, s[7];
long long lin[100005][1 << 7], cov[1 << 7];
char ch[100005], ans[100005];
vector<long long> e[100005];
bool hall(long long x) {
for (long long ss = 0; ss <= (1 << 6) - 1; ss++) {
long long sum = 0;
for (long long i = 1; i <= 6; i++)
if (ss >> i - 1 & 1) sum += s[i];
if (lin[x][ss] < sum) return 0;
}
return 1;
}
signed main() {
scanf("%s", ch + 1);
n = strlen(ch + 1);
for (long long i = 1; i <= n; i++) s[ch[i] - 'a' + 1]++;
cin >> m;
for (long long i = 1, p; i <= m; i++) {
string pat;
cin >> p >> pat;
for (long long j = 0; j < pat.length(); j++)
e[p].push_back(pat[j] - 'a' + 1), cov[p] |= 1 << pat[j] - 'a';
}
for (long long i = 1; i <= n; i++)
if (e[i].size() == 0) {
cov[i] = (1 << 6) - 1;
for (long long j = 1; j <= 6; j++) e[i].push_back(j);
}
for (long long i = n; i >= 1; i--) {
for (long long s = 0; s <= (1 << 6) - 1; s++)
if (s & cov[i])
lin[i][s] = lin[i + 1][s] + 1;
else
lin[i][s] = lin[i + 1][s];
}
for (long long i = 1; i <= n; i++) {
sort(e[i].begin(), e[i].end());
for (long long j = 0; j < e[i].size(); j++) {
s[e[i][j]]--;
if (hall(i + 1)) {
ans[i] = (char)(e[i][j] + 'a' - 1);
break;
}
s[e[i][j]]++;
}
}
if (strlen(ans + 1) < n) return puts("Impossible"), 0;
for (long long i = 1; i <= n; i++) cout << ans[i];
return puts(""), 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x;
vector<int> arr[20000];
set<int> ans[205];
bool done[205] = {false};
bool yeah[20000][205] = {false};
int main() {
scanf("%d", &n);
m = n * (n - 1) / 2;
for (int(i) = 0, _n = (m); (i) < _n; (i)++) {
scanf("%d", &k);
for (int(_) = 0, _n = (k); (_) < _n; (_)++) {
scanf("%d", &x);
arr[i].push_back(x);
yeah[i][x] = true;
}
sort(arr[i].begin(), arr[i].end());
}
if (n == 2) {
printf("1 %d\n", arr[0][0]);
printf("%d", arr[0].size() - 1);
for (int(i) = (1), _n = (arr[0].size() - 1); (i) <= _n; (i)++)
printf(" %d", arr[0][i]);
puts("");
return 0;
}
for (int(t) = 0, _n = (n); (t) < _n; (t)++) {
int i = 0, key;
set<int> a, b;
while (true) {
for (int(j) = 0, _n = (arr[i].size()); (j) < _n; (j)++)
if (!done[arr[i][j]]) a.insert(arr[i][j]);
if (!a.empty()) {
key = *a.begin();
break;
}
i++;
}
int j = i + 1;
while (j < m) {
if (yeah[j][key]) {
for (int(k) = 0, _n = (arr[j].size()); (k) < _n; (k)++)
if (a.find(arr[j][k]) != a.end()) b.insert(arr[j][k]);
break;
}
j++;
}
for (__typeof((b).begin()) it = (b).begin(); it != (b).end(); it++)
done[*it] = true;
ans[t] = b;
}
for (int(i) = 0, _n = (n); (i) < _n; (i)++) {
printf("%d", ans[i].size());
for (__typeof((ans[i]).begin()) it = (ans[i]).begin(); it != (ans[i]).end();
it++)
printf(" %d", *it);
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T SQR(T x) {
return x * x;
}
template <class T>
inline string TOSTR(const T &x) {
stringstream ss;
ss << x;
return ss.str();
}
template <class T>
void UPDATE_MIN(T &x, T y) {
if (y < x) {
x = y;
}
}
template <class T>
void UPDATE_MAX(T &x, T y) {
if (x < y) {
x = y;
}
}
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long powmod(long long a, long long p, long long m) {
long long r = 1;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
const int MOD = 1000 * 1000 * 1000 + 7;
const double PI = 3.1415926535897932384626433832795l;
long long n, m, k;
long long p10[10000];
long long p9_10[10000];
long long counts_a[100] = {};
long long counts_b[100] = {};
long long *counts, *counts2;
int main() {
cin >> n >> k >> m;
long long a10 = 1, a9_10 = 1;
for (int(i) = 0; (i) < (int)(n); (i)++) {
p10[i] = a10;
p9_10[i] = a9_10;
a10 = (a10 * 10LL) % k;
a9_10 = (a9_10 * ((i == 0) ? 9LL : 10LL)) % m;
}
counts = counts_a;
counts2 = counts_b;
counts[0] = 1;
long long res = 0;
for (int(i) = 0; (i) < (int)(n); (i)++) {
for (int(j) = 0; (j) < (int)(k); (j)++) counts2[j] = 0;
for (int(r) = 0; (r) < (int)(k); (r)++) {
int mind = ((i == n) ? 1 : 0);
for (int(d) = mind; (d) < (int)(10); (d)++) {
long long r2 = (d * p10[i] + r) % k;
counts2[r2] = (counts2[r2] + counts[r]) % m;
}
}
res += (counts2[0] - 1) * p9_10[n - i - 1];
res %= m;
while (res < 0) res += m;
counts2[0] = 1;
{
__typeof(counts) tmp = counts;
counts = counts2;
counts2 = tmp;
};
}
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int main() {
ios_base::sync_with_stdio(false);
int i, j, n, m, k, t;
cin >> t;
while (t--) {
string s;
cin >> n >> m >> s;
for (i = 0; i < n; i += 2) {
if (s[i] == ')') {
j = i;
k = i;
while (s[j] != '(') j++;
reverse(s.begin() + i, s.begin() + j + 1);
} else if (s[i] == '(') {
j = i;
k = i + 1;
while (s[j] != ')') j++;
reverse(s.begin() + i + 1, s.begin() + j + 1);
}
v.push_back({k + 1, j + 1});
}
m = n / 2 - m;
for (i = 1; i <= m; i++) v.push_back({2 * i, 2 * i + 1});
cout << v.size() << endl;
for (i = 0; i < v.size(); i++)
cout << v[i].first << ' ' << v[i].second << endl;
v.clear();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dirx[8] = {0, 0, 1, -1, 1, 1, -1, -1};
int diry[8] = {1, -1, 0, 0, 1, -1, 1, -1};
string tostring(long long n) {
if (!n) return "0";
string ans = "";
while (n != 0) {
ans += (n % 10) + '0';
n /= 10;
}
reverse(ans.begin(), ans.end());
return ans;
}
const int till = 666667;
struct st {
char color;
int redToken;
int blueToken;
} ar[18];
int n, cur[18], last[18], ans;
double prob(int a, int b, double temp) {
double t = b - a;
t /= temp;
return exp(t);
}
double randReal() {
double t = rand();
t /= RAND_MAX;
return t;
}
int chk() {
int tot = n, redToken = 0, blueToken = 0, redCard = 0, blueCard = 0;
for (int i = 1; i <= n; i++) {
int idx = cur[i];
int redLagbe = max(0, ar[idx].redToken - redCard);
int blueLagbe = max(0, ar[idx].blueToken - blueCard);
int redKenaLagbe = max(0, redLagbe - redToken);
int blueKenaLagbe = max(0, blueLagbe - blueToken);
int kenaLagbe = max(redKenaLagbe, blueKenaLagbe);
tot += kenaLagbe;
redToken += (kenaLagbe - redLagbe);
blueToken += (kenaLagbe - blueLagbe);
(ar[idx].color == 'R') ? redCard++ : blueCard++;
}
return tot;
}
void simAnn() {
srand(time(0));
double temperature = 6666667;
int k = 0;
ans = chk();
int curAns = ans;
while (++k <= till) {
for (int i = 1; i <= n; i++) last[i] = cur[i];
int m = 3;
while (m--) {
int a = (rand() % n) + 1, b = (rand() % n) + 1;
swap(cur[a], cur[b]);
}
int t = chk();
if (t < ans) ans = t;
if (t < curAns)
curAns = t;
else {
double p = prob(t, curAns, temperature);
if (randReal() <= p) {
curAns = t;
} else {
for (int i = 1; i <= n; i++) cur[i] = last[i];
}
}
if (temperature > 1e-20) temperature *= 0.97;
}
printf("%d\n", ans);
}
int main() {
int a, b;
char ch;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
cin >> ch >> a >> b;
ar[i].color = ch;
ar[i].redToken = a;
ar[i].blueToken = b;
}
for (int i = 1; i <= n; i++) cur[i] = i;
simAnn();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct DSU {
vector<pair<int, pair<int, int>>> resParent;
vector<pair<int, int>> resSize;
vector<pair<int, int>> parent;
vector<int> size;
DSU(int n) {
parent = vector<pair<int, int>>(n + 1);
size = vector<int>(n + 1);
for (int i = 1; i <= n; i++) {
make_set(i);
}
}
void make_set(int n) {
parent[n] = {n, 0};
size[n] = 1;
}
pair<int, int> find(int n) {
if (parent[n].first != n) {
pair<int, int> pa = find(parent[n].first);
pa.second ^= parent[n].second;
resParent.emplace_back(n, parent[n]);
parent[n] = pa;
}
return parent[n];
}
bool make_union(int a, int b) {
pair<int, int> pa = find(a);
pair<int, int> pb = find(b);
a = pa.first;
b = pb.first;
int p1 = pa.second;
int p2 = pb.second;
if (a == b && p1 == p2) {
return true;
}
if (size[a] < size[b]) {
swap(a, b);
}
size[a] += b;
resParent.emplace_back(b, parent[b]);
parent[b] = {a, p1 ^ p2 ^ 1};
resSize.emplace_back(a, b);
return false;
}
};
void solve() {
int n, m;
long long k;
scanf("%d %d %lld", &n, &m, &k);
vector<bool> bi(n + 1);
vector<int> vals(n + 1);
map<pair<int, int>, vector<pair<int, int>>> map;
for (int i = 1; i <= n; i++) {
scanf("%d", &vals[i]);
}
int a, b;
DSU dsu(n);
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
if (vals[a] != vals[b]) {
map[{min(vals[a], vals[b]), max(vals[a], vals[b])}].push_back({a, b});
continue;
}
if (dsu.make_union(a, b) && !bi[vals[a]]) {
bi[vals[a]] = true;
k--;
}
}
long long ans = 1LL * (k * (k - 1)) / 2;
for (auto& test : map) {
if (bi[test.first.first] || bi[test.first.second]) {
continue;
}
int rp = dsu.resParent.size();
int rs = dsu.resSize.size();
for (auto& arr : test.second) {
if (dsu.make_union(arr.first, arr.second)) {
ans--;
break;
}
}
while (dsu.resSize.size() != rs) {
dsu.size[dsu.resSize.back().first] -= dsu.size[dsu.resSize.back().second];
dsu.resSize.pop_back();
}
while (dsu.resParent.size() != rp) {
dsu.parent[dsu.resParent.back().first] = dsu.resParent.back().second;
dsu.resParent.pop_back();
}
}
printf("%lld\n", ans);
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int k;
cin >> k;
cout << 3 << " " << 4 << endl;
int x1 = 262143, x2 = 131072;
cout << x1 << " " << k << " " << k << " " << 0 << endl;
cout << x2 << " " << 0 << " " << k << " " << 0 << endl;
cout << x2 << " " << x2 << " " << x1 << " " << k << endl;
return 0;
}
| 4 |
#include <iostream>
using namespace std;
const int N = 105;
char s[N];
int main() {
int t;
scanf("%d ", &t);
while(t --) {
int n, k;
scanf("%d %d ", &n, &k);
scanf("%s ", s);
int start = 0, end = n - 1;
while(k > 0 && start < end) {
if(s[start ++] != s[end --]) break;
k --;
}
if(k || start > end) printf("NO\n");
else printf("YES\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005, M = 1e5;
int n, m, a[N], b[N], pri[M], f[N];
int c1[N], c2[N], v[M + 5];
map<int, int> ache, vis, c;
int main() {
for (int i = 2; i <= M; ++i) {
if (!v[i]) pri[++pri[0]] = i;
for (int j = 1; j <= pri[0] && i * pri[j] <= M; ++j) {
v[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
}
}
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1, x; i <= m; ++i) scanf("%d", &x), ache[x] = 1;
for (int id = 1; id <= n; ++id) {
int x = a[id];
for (int i = 1; i <= pri[0] && pri[i] * pri[i] <= x; ++i)
if (x % pri[i] == 0) {
int pw = 0;
++vis[pri[i]];
while (x % pri[i] == 0) x /= pri[i], ++pw;
c[pri[i]] = id == 1 ? pw : min(c[pri[i]], pw);
if (vis[pri[i]] == id) {
if (ache[pri[i]])
c2[id] += c[pri[i]];
else
c1[id] += c[pri[i]];
}
if (ache[pri[i]])
f[id] -= pw;
else
f[id] += pw;
}
if (x > 1) {
++vis[x], c[x] = id == 1 ? 1 : min(c[x], 1);
if (vis[x] == id) {
if (ache[x])
c2[id] += c[x];
else
++c1[id];
}
if (ache[x])
--f[id];
else
++f[id];
}
}
int ans = 0, pmx = -1e8;
for (int i = n; i; --i)
ans += max(f[i], max(f[i] + c2[i] - c1[i], f[i] + pmx)),
pmx = max(pmx, c2[i] - c1[i]);
printf("%d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[1001000];
long long ans;
int a[1001000], n, b[1001000], m, cc[233], cnt[4][4], l = 1, r;
void cg(int x, int v) { cnt[b[x - 1]][b[x]] += v; }
int main() {
cc['B'] = 1, cc['G'] = 2, cc['R'] = 3;
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) a[i] = cc[s[i]];
scanf("%s", s + 1);
m = strlen(s + 1);
for (int i = 1; i <= m; ++i) b[i] = cc[s[i]];
for (int i = 1; i <= n; ++i) {
if (b[l] == a[i - 1] && l <= m) cg(l++, -1);
if (b[r] == a[i - 1] && r < m) cg(++r, 1);
for (; b[r] != a[i] && r < m;) cg(++r, 1);
if (l > r) continue;
cg(l++, -1);
ans += 1 + r - l + 1;
if (a[i] != a[i - 1]) ans -= cnt[a[i]][a[i - 1]];
cg(--l, 1);
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int main() {
int n;
cin >> n;
long long *arr = new long long[n];
long long abd = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
abd = arr[0];
long long abd1 = 0;
for (long long i = 1; i < n; i++) {
abd1 = abd1 + arr[i] * i - abd;
abd += arr[i];
}
abd1 *= 2;
abd1 += abd;
cout << abd1 / gcd(abd1, n) << " " << n / gcd(abd1, n) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[110];
long long p, q, k, ansx, ansy;
struct mat {
long long m[110][110];
mat() { memset(m, 0, sizeof(m)); };
} ans, tmp;
inline void add(long long &x, long long y) {
if (y >= 1000000007) y -= 1000000007;
x += y;
if (x >= 1000000007) x -= 1000000007;
}
inline mat mul(mat a, mat b) {
mat res;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
for (int k = 0; k <= n; k++)
add(res.m[i][j], a.m[i][k] * b.m[k][j] % 1000000007);
return res;
}
inline mat mpower(mat a, long long b) {
mat res;
for (int i = 0; i <= n; i++) res.m[i][i] = 1ll;
while (b) {
if (b & 1ll) res = mul(res, a);
a = mul(a, a);
b >>= 1ll;
}
return res;
}
inline long long power(long long a, long long b) {
long long res = 1ll;
while (b) {
if (b & 1ll) res = res * a % 1000000007;
a = a * a % 1000000007;
b >>= 1ll;
}
return res;
}
int main() {
scanf("%d%lld", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == 0) p++;
}
for (int i = 1; i <= p; i++)
if (a[i] == 0) q++;
ans.m[0][q] = 1ll;
for (int i = 0; i <= p; i++) {
if (i) tmp.m[i - 1][i] = (long long)(p - i + 1) * (p - i + 1) % 1000000007;
add(tmp.m[i][i], (long long)i * (p - i) % 1000000007 +
(long long)(p - i) * (n - p - p + i) % 1000000007);
add(tmp.m[i][i], (long long)p * (p - 1) / 2 % 1000000007 +
(long long)(n - p) * (n - p - 1) / 2 % 1000000007);
if (i != p)
tmp.m[i + 1][i] = (long long)(i + 1) * (n - p - p + i + 1) % 1000000007;
}
tmp = mpower(tmp, k);
ans = mul(ans, tmp);
ansx = ans.m[0][p];
for (int i = 0; i <= p; i++) add(ansy, ans.m[0][i]);
printf("%lld\n", ansx * power(ansy, 1000000007 - 2) % 1000000007);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 510;
int MOD;
int dp[MAXN][MAXN];
int N, M, B;
int s[MAXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M >> B >> MOD;
for (int i = 1; i <= N; i++) cin >> s[i];
dp[0][0] = 1;
for (int i = 1; i <= N; i++)
for (int pre = 1; pre <= M; pre++)
for (int b = s[i]; b <= B; b++)
dp[pre][b] = (dp[pre][b] + dp[pre - 1][b - s[i]]) % MOD;
int res = 0;
for (int i = 0; i <= B; i++) res = (res + dp[M][i]) % MOD;
cout << res << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int maxh = 0, reg = 0, h, stre = 0, i, t, n, pp[2000], dmg[2000], ans_t[2000],
ans_n[2000], ans_k = 0;
bool use[2000];
int main() {
scanf("%d%d%d", &n, &maxh, ®);
h = maxh;
for (i = 0; i < n; i++) scanf("%d%d", &pp[i], &dmg[i]);
for (t = 0; t < 3000; t++) {
h += -stre + reg;
h = min(maxh, h);
if (h <= 0) {
printf("YES\n");
printf("%d %d\n", t, ans_k);
for (i = 0; i < ans_k; i++) printf("%d %d\n", ans_t[i], ans_n[i]);
return 0;
}
int x = -1;
for (i = 0; i < n; i++)
if (!use[i] && (h * 100 <= maxh * pp[i]) && (x < 0 || dmg[i] > dmg[x]))
x = i;
if (x >= 0) {
ans_t[ans_k] = t;
ans_n[ans_k] = x + 1;
ans_k++;
use[x] = 1;
stre += dmg[x];
}
}
printf("NO\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int counter[200020];
int times[200020];
int tot = 0;
inline void fr(int &to) {
char t = getchar();
to ^= to;
while (t > 47) {
to = (to << 3) + (to << 1) + t - 48;
t = getchar();
}
}
int main() {
int n, T, diff;
int best = 0;
fr(n);
fr(T);
for (int i = 0; i < n; i++) fr(times[i]), times[i] = max(times[i], i + 1);
for (int i = 0; i < n; i++) {
tot -= counter[i];
diff = T - times[i];
if (diff > 0) {
tot++;
if (i + diff < n) counter[i + diff]++;
}
best = max(best, tot);
}
printf("%d\n", best);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j = 1, x, y, t = 0;
cin >> n >> k;
int a[n];
cin >> x;
y = x;
for (i = 1; i < n; i++) {
cin >> x;
if (x == y) {
a[j] = i;
j++;
t = 1;
}
y = x;
}
a[0] = 0;
a[j] = n;
j++;
int max = a[1] - a[0];
if (k == 1)
cout << 1;
else if (t == 0 || n == 1)
cout << n;
else {
for (i = 2; i < j; i++) {
if (a[i] - a[i - 1] > max) max = a[i] - a[i - 1];
}
cout << max;
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, a, n) for(int i=(a); i<(n); ++i)
#define per(i, a, n) for(int i=(a); i>(n); --i)
#define pb emplace_back
#define mp make_pair
#define clr(a, b) memset(a, b, sizeof(a))
#define all(x) (x).begin(),(x).end()
#define lowbit(x) (x & -x)
#define fi first
#define se second
#define lson o<<1
#define rson o<<1|1
#define gmid l[o]+r[o]>>1
using LL = long long;
using ULL = unsigned long long;
using pii = pair<int,int>;
using PLL = pair<LL, LL>;
using UI = unsigned int;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double EPS = 1e-8;
const double PI = acos(-1.0);
const int N = 2e5 + 10;
int T, n, k, m, a[N];
bool vis[N];
bool ok(){
if((n - m) % (k - 1) != 0){
return 0;
}
if(m == n) return 1;
rep(i, 1, n+1) vis[i] = 0;
rep(i, 0, m){
vis[a[i]] = 1;
}
int d = (k - 1) / 2;
int lft, rgt;
int c = 0;
rep(i, 1, n+1){
if(!vis[i]){
lft = i;
++c;
if(c == d) break;
}
}
c = 0;
per(i, n, 0){
if(!vis[i]){
rgt = i;
++c;
if(c == d) break;
}
}
rep(i, lft+1, rgt){
if(vis[i]) return 1;
}
return 0;
}
int main(){
scanf("%d", &T);
while(T--){
scanf("%d %d %d", &n, &k, &m);
rep(i, 0, m){
scanf("%d", a+i);
}
puts(ok()?"YES":"NO");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> p, q, r, s;
vector<pair<long long, long long> > poz, neg;
void out(long long a, long long b, long long c, long long d) {
cout.flush() << a << " " << b << " " << c << " " << d << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (long long i = 3; i <= n; i++) {
out(2, 1, 2, i);
long long x, y;
cin >> x;
out(1, 1, 2, i);
cin >> y;
if (x > 0) {
poz.push_back({y, i});
} else {
neg.push_back({y, i});
}
}
sort(poz.begin(), poz.end());
sort(neg.begin(), neg.end());
long long a = poz.size(), b = neg.size();
for (long long i = 0; i < b - 1; i++) {
long long x;
long long se = neg[i].second;
out(2, 1, se, neg[i + 1].second);
cin >> x;
if (x == 1) {
p.push_back(se);
} else {
q.push_back(se);
}
}
if (b > 0) {
p.push_back(neg[b - 1].second);
}
for (long long i = 0; i < a - 1; i++) {
long long x;
long long se = poz[i].second;
out(2, 1, se, poz[i + 1].second);
cin >> x;
if (x == 1) {
r.push_back(se);
} else {
s.push_back(se);
}
}
if (a > 0) {
r.push_back(poz[a - 1].second);
}
cout << 0 << " " << 1 << " ";
for (long long i = 0; i < p.size(); i++) {
cout << p[i] << " ";
}
a = q.size(), b = s.size();
for (long long i = a - 1; i >= 0; i--) {
cout << q[i] << " ";
}
cout << 2 << " ";
for (long long i = 0; i < r.size(); i++) {
cout << r[i] << " ";
}
for (long long i = b - 1; i >= 0; i--) {
cout << s[i] << " ";
}
cout.flush() << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long MOD;
struct matr {
const static int n = 2;
long long a[n][n];
static matr tmp, tmp2;
void print() {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
fprintf(stderr,
"%lld"
"%c",
a[i][j], " \n"[j == n - 1]);
}
void ONE() {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) a[i][j] = (i == j);
}
void operator*=(const matr &m) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
tmp.a[i][j] = 0;
for (int y = 0; y < n; y++)
tmp.a[i][j] = (tmp.a[i][j] + a[i][y] * m.a[y][j]) % MOD;
}
memcpy(a, tmp.a, sizeof(a));
}
void operator^=(long long pw) {
tmp2 = *this;
ONE();
for (; pw; pw >>= 1) {
if (pw & 1) *this *= tmp2;
tmp2 *= tmp2;
}
}
};
matr matr::tmp, matr::tmp2;
int main() {
long long m, l, r, k;
while (scanf("%lld"
"%lld"
"%lld"
"%lld",
&m, &l, &r, &k) >= 1) {
long long pw = -1;
long long K = (long long)sqrt(r + 0.0) + 5;
for (long long x = 1; x <= K; x++) {
long long cur = r / x - (l - 1) / x;
if (cur >= k) pw = max(x, pw);
}
for (long long t = 1; t <= K; t++) {
long long x = r / t;
if (!x) break;
long long cur = r / x - (l - 1) / x;
if (cur >= k) pw = max(x, pw);
}
MOD = m;
matr m;
m.a[0][0] = m.a[0][1] = m.a[1][0] = 1;
m.a[1][1] = 0;
m ^= pw;
printf(
"%lld"
"\n",
m.a[0][1]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
multiset<long long> mp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
long long el;
cin >> el;
mp.insert(el);
}
long long cur = 0;
deque<long long> ar;
long long prev = (*mp.begin());
int ans = 0;
int ans_i = 0;
for (auto el : mp) {
ar.push_back(el);
cur += (el - prev) * (ar.size() - 1);
while (cur > k) {
int f = *ar.begin();
ar.pop_front();
cur -= el - f;
}
if (ar.size() > ans) {
ans = ar.size();
ans_i = el;
}
prev = el;
}
cout << ans << ' ' << ans_i << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 19;
const long long P = 1e9 + 7;
long long L[N], R[N], Q[N], D[N];
int n;
long long power(long long a, long long b) {
long long ans = 1;
for (; b; b >>= 1, a = a * a % P)
if (b & 1) ans = ans * a % P;
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &L[i]);
for (int i = 1; i <= n; ++i) scanf("%lld", &R[i]);
for (int i = 1; i <= n; ++i) D[i] = R[i] - L[i] + 1;
L[n + 1] = 0;
R[n + 1] = 0;
D[n + 1] = 1;
++n;
for (int i = 1; i <= n; ++i) D[i] = power(D[i], P - 2);
long long Ex = 0, Dx = 0;
for (int i = 1; i < n; ++i) {
long long dl = max(L[i], L[i + 1]), dr = min(R[i], R[i + 1]);
Q[i] = 1;
if (dl <= dr)
Q[i] = (Q[i] - (dr - dl + 1) % P * D[i] % P * D[i + 1] % P + P) % P;
Ex = (Ex + Q[i]) % P;
Dx = (Dx + Q[i] * (1 - Q[i] + P) % P) % P;
}
for (int i = 1; i < n - 1; ++i) {
Dx = (Dx + 2 * (Q[i] + Q[i + 1] - 1 + P)) % P;
long long dl = max({L[i], L[i + 1], L[i + 2]}),
dr = min({R[i], R[i + 1], R[i + 2]});
if (dl <= dr) {
Dx = (Dx +
2 * (dr - dl + 1) % P * D[i] % P * D[i + 1] % P * D[i + 2] % P) %
P;
}
Dx = (Dx - 2 * Q[i] % P * Q[i + 1] % P + P) % P;
}
printf("%lld\n", (Ex * Ex % P + Dx) % P);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int cnt[1010], a[1010], ans[1010 << 1], k;
void change(int pos, int val) {
cnt[a[pos]]--;
cnt[val]++;
a[pos] = val;
}
int main() {
int t, n, i, tot, j;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (i = 1; i <= n; i++) cnt[i] = 0;
for (i = 1; i <= n; i++) scanf("%d", &a[i]), cnt[a[i]]++;
tot = 0, k = 0;
for (i = 1; i <= n; i++)
if (a[i] == i) tot++;
if (tot == n) {
printf("0\n\n");
continue;
}
while (1) {
for (i = 0; i <= n; i++)
if (!cnt[i]) break;
if (i == 0) {
for (j = 1; j <= n; j++)
if (a[j] != j) break;
ans[++k] = j, change(j, 0);
} else {
ans[++k] = i, change(i, i), tot++;
if (tot == n) break;
}
}
printf("%d\n", k);
for (i = 1; i <= k; i++) printf("%d ", ans[i]);
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
bool prime[1000001];
long long f[200005];
long long pow1(long long x, long long y) {
long long res = 1;
x = x % mod;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
long long divide(long long n) { return pow1(n, mod - 2); }
long long ncr(long long n, long long r) {
if (n < r) return 0;
return (f[n] * ((divide(f[r]) * divide(f[n - r])) % mod)) % mod;
}
void sieve() {
memset(prime, true, sizeof(prime));
for (long long i = 2; i * i <= 1000000; i++)
if (prime[i])
for (long long j = i * i; j <= 1000000; j += i) prime[j] = false;
prime[0] = prime[1] = false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, i, j, x = 0, y = 0, ti = 0;
cin >> n;
vector<pair<long long, long long>> a(n);
for (i = 0; i < n; i++) cin >> a[i].first;
for (i = 0; i < n; i++) cin >> a[i].second;
sort(a.begin(), a.end());
multiset<long long, greater<long long>> m;
j = 0;
while (j < n || m.size()) {
if (m.empty()) x = a[j].first;
while (j < n && x == a[j].first) {
y += a[j].second;
m.insert(a[j].second);
j++;
}
y -= *(m.begin());
ti += y;
m.erase(m.begin());
x++;
}
cout << ti << endl;
return 0;
}
void factorize(long long n, set<pair<long long, long long>> s) {
long long count = 0;
while (!(n % 2)) {
n >>= 1;
count++;
}
if (count) s.insert(make_pair(2, count));
for (long long i = 3; i <= sqrt(n); i += 2) {
count = 0;
while (n % i == 0) {
count++;
n = n / i;
}
if (count) s.insert(make_pair(i, count));
}
if (n > 2) s.insert(make_pair(n, 1));
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.