solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, l, r, p;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> m;
while (m--) {
string h;
cin >> h;
n = h.length();
vector<long long> ans;
for (int i = 0; i < n - 2; i++) {
if (h[i] == 'o' && h[i + 1] == 'n' && h[i + 2] == 'e') {
h[i + 1] = '-';
ans.push_back(i + 1);
}
if (h[i] == 't' && h[i + 1] == 'w' && h[i + 2] == 'o') {
if (i + 3 < n) {
if (h[i + 3] != 'o') {
ans.push_back(i + 2);
h[i + 2] = '-';
} else {
ans.push_back(i + 1);
h[i + 1] = '-';
}
} else {
ans.push_back(i + 1);
h[i + 1] = '-';
}
}
}
cout << ans.size() << '\n';
for (auto& g : ans) cout << g + 1 << ' ';
cout << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct timer {
time_t start;
timer() { start = clock(); }
~timer() {
cerr << 1. * (clock() - start) / CLOCKS_PER_SEC << " secs" << endl;
}
};
int n, m, K;
map<int, vector<pair<int, int> > > H, V;
map<int, int> Hlen, Vlen;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> m >> K;
int xb, yb, xe, ye;
for (int i = 0; i < (K); i++) {
cin >> xb >> yb >> xe >> ye;
if (xb == xe) {
if (yb > ye) swap(yb, ye);
H[xb].push_back(pair<int, int>(yb, 1));
H[xb].push_back(pair<int, int>(ye, -1));
} else {
if (xb > xe) swap(xb, xe);
V[yb].push_back(pair<int, int>(xb, 1));
V[yb].push_back(pair<int, int>(xe, -1));
}
}
int restH = n - 1, restV = m - 1;
int Xor = 0;
vector<pair<int, int> > v;
int from, count, cut;
int uncutHpos = -1, uncutVpos = -1;
int preH = 0, preV = 0;
for (__typeof((H).begin()) it = (H).begin(); it != (H).end(); it++) {
if (it->first != preH + 1) {
uncutHpos = preH + 1;
}
preH = it->first;
restH--;
v = it->second;
sort(v.begin(), v.end());
count = 0;
cut = 0;
for (int i = 0; i < (((int)v.size())); i++) {
if (count == 0) {
from = v[i].first;
}
count += v[i].second;
if (count == 0) {
cut += v[i].first - from;
}
}
Xor ^= m - cut;
Hlen[it->first] = m - cut;
}
for (__typeof((V).begin()) it = (V).begin(); it != (V).end(); it++) {
if (it->first != preV + 1) {
uncutVpos = preV + 1;
}
preV = it->first;
restV--;
v = it->second;
sort(v.begin(), v.end());
count = 0;
cut = 0;
for (int i = 0; i < (((int)v.size())); i++) {
if (count == 0) {
from = v[i].first;
}
count += v[i].second;
if (count == 0) {
cut += v[i].first - from;
}
}
Xor ^= n - cut;
Vlen[it->first] = n - cut;
}
if (restH & 1) {
Xor ^= m;
}
if (restV & 1) {
Xor ^= n;
}
if (Xor == 0) {
cout << "SECOND";
return 0;
}
cout << "FIRST\n";
if (restH > 0) {
if (uncutHpos == -1) uncutHpos = n - 1;
Hlen[uncutHpos] = m;
}
if (restV > 0) {
if (uncutVpos == -1) uncutVpos = m - 1;
Vlen[uncutVpos] = n;
}
int hibit = 30;
while ((Xor >> hibit & 1) == 0) hibit--;
int row = -1;
int remove;
for (__typeof((Hlen).begin()) it = (Hlen).begin(); it != (Hlen).end(); it++) {
if ((it->second) >> hibit & 1) {
row = it->first;
remove = it->second - ((it->second) ^ Xor);
break;
}
}
if (row != -1) {
v = H[row];
sort(v.begin(), v.end());
from = 0;
count = 0;
for (int i = 0; i < (((int)v.size())); i++) {
if (count == 0) {
int len = v[i].first - from;
if (len >= remove) {
cout << row << " " << 0 << " " << row << " " << from + remove;
return 0;
}
remove -= len;
}
count += v[i].second;
if (count == 0) {
from = v[i].first;
}
}
cout << row << " " << 0 << " " << row << " " << from + remove;
return 0;
}
int col = -1;
for (__typeof((Vlen).begin()) it = (Vlen).begin(); it != (Vlen).end(); it++) {
if ((it->second) >> hibit & 1) {
col = it->first;
remove = it->second - ((it->second) ^ Xor);
break;
}
}
if (col != -1) {
v = V[col];
sort(v.begin(), v.end());
from = 0;
count = 0;
for (int i = 0; i < (((int)v.size())); i++) {
if (count == 0) {
int len = v[i].first - from;
if (len >= remove) {
cout << 0 << " " << col << " " << from + remove << " " << col;
return 0;
}
remove -= len;
}
count += v[i].second;
if (count == 0) {
from = v[i].first;
}
}
cout << 0 << " " << col << " " << from + remove << " " << col;
return 0;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
vector<long long> g[maxn], temp[maxn];
long long w[maxn];
int n, q;
long long a, h;
long long Search(long long a, long long h) {
if (a > n) return 0;
long long res = 0;
long long pos = lower_bound(g[a].begin(), g[a].end(), h) - g[a].begin();
res = pos * h - temp[a][pos];
return res;
}
int main() {
cin >> n >> q;
for (int i = 2; i <= n; i++) scanf("%lld", &w[i]);
for (int i = n; i >= 1; i--) {
g[i].push_back(0);
sort(g[i].begin(), g[i].end());
temp[i].resize(g[i].size() + 1);
for (int j = 0; j < g[i].size(); j++) temp[i][j + 1] = temp[i][j] + g[i][j];
for (int j = 0; j < g[i].size(); j++) g[i / 2].push_back(g[i][j] + w[i]);
}
while (q--) {
scanf("%lld %lld", &a, &h);
long long res = Search(a, h);
while (a > 1) {
h -= w[a];
if (h < 0) break;
res += Search(a ^ 1, h - w[a ^ 1]) + h;
a /= 2;
}
cout << res << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 10105;
int n, b, q, st, ed;
int First[maxn], cnt, dis[maxn];
struct edge {
int to, Next, flow, c;
} Tree[maxn * 100];
void init() {
cnt = 0;
memset(First, -1, sizeof(First));
}
void addedge(int from, int to, int flow) {
Tree[cnt].to = to;
Tree[cnt].Next = First[from];
Tree[cnt].flow = flow;
First[from] = cnt++;
Tree[cnt].to = from;
Tree[cnt].Next = First[to];
Tree[cnt].flow = 0;
First[to] = cnt++;
}
bool bfs(int st, int ed) {
memset(dis, 0, sizeof(dis));
queue<int> Q;
dis[st] = 1;
Q.push(st);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = First[u]; i != -1; i = Tree[i].Next) {
int v = Tree[i].to;
int flow = Tree[i].flow;
if (flow && !dis[v]) {
dis[v] = dis[u] + 1;
if (v == ed) return true;
Q.push(v);
}
}
}
return false;
}
int dfs(int u, int minf) {
if (u == ed) {
return minf;
}
if (minf == 0) return minf;
int f = 0;
for (int i = First[u]; i != -1; i = Tree[i].Next) {
int v = Tree[i].to;
if (Tree[i].flow && dis[v] == dis[u] + 1) {
int tmp = dfs(v, min(Tree[i].flow, minf));
Tree[i].flow -= tmp;
Tree[i ^ 1].flow += tmp;
f += tmp;
minf -= tmp;
if (minf == 0) return f;
}
}
return f;
}
int dinic(int st, int ed) {
int res = 0;
while (bfs(st, ed)) res += dfs(st, INF);
return res;
}
struct node {
int up, num;
bool operator<(const node& A) const {
if (A.up != up) return A.up > up;
return A.num > num;
}
} ax[10005];
int sum[10];
int main() {
init();
scanf("%d%d%d", &n, &b, &q);
st = 0, ed = q + 5 + 10;
for (int i = 1; i <= q; i++) scanf("%d%d", &ax[i].up, &ax[i].num);
sort(ax + 1, ax + 1 + q);
ax[q + 1].up = b, ax[q + 1].num = n;
for (int i = 1; i <= q + 1; i++) {
int nowv = ax[i].up - ax[i - 1].up;
int nowb = ax[i].num - ax[i - 1].num;
if (ax[i].num > n || nowb > nowv || nowb < 0) {
puts("unfair");
return 0;
}
for (int j = ax[i - 1].up + 1; j <= ax[i].up; j++) {
sum[j % 5]++;
}
for (int j = 0; j < 5; j++) addedge(i, q + j + 2, sum[j]);
addedge(st, i, nowb);
memset(sum, 0, sizeof(sum));
}
for (int i = 1; i <= 5; i++) addedge(q + i + 1, ed, n / 5);
int max1 = dinic(st, ed);
if (max1 == n)
puts("fair");
else
puts("unfair");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int X = 11;
int f[101][X * X + 1];
int a[101], b[101];
void generateList(int n, int a[]) {
f[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= X * X; j++)
if (f[i - 1][j] > 0)
for (int k = 1; j + k * k <= X * X; k++) f[i][j + k * k] = k;
int s = 0;
for (s = 1; s <= X; s++)
if (f[n][s * s] > 0) break;
s = s * s;
for (int i = 0; i < n; i++) {
a[i] = f[n - i][s];
s -= a[i] * a[i];
}
}
int main() {
int n, m;
cin >> n >> m;
generateList(n, a);
generateList(m, b);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << a[i] * b[j] << ' ';
cout << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const double EPS = 1e-7;
const int INF = 1e9 + 1;
template <typename A, typename B>
istream &operator>>(istream &in, pair<A, B> &p) {
in >> p.first >> p.second;
return in;
}
template <typename A, typename B>
ostream &operator<<(ostream &out, pair<A, B> &p) {
out << p.first << " " << p.second;
return out;
}
template <typename I>
istream &operator>>(istream &in, vector<I> &a) {
for (auto &i : (a)) in >> i;
return in;
}
template <typename I>
ostream &operator<<(ostream &out, vector<I> &a) {
for (int i = 0; i < ((int)(a).size()); ++i) {
if (i) out << " ";
out << a[i];
}
return out;
}
void fast_io() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
}
deque<int> dq[301][301];
void read_dq(int n, int m, vector<vector<int>> &ones,
vector<vector<int>> &zeros, int rev) {
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m); ++j) {
string s;
cin >> s;
for (auto &c : (s)) {
if (c == '0') {
if (rev)
dq[i][j].push_front(0);
else
dq[i][j].push_back(0);
zeros[i][j]++;
} else {
if (rev)
dq[i][j].push_front(1);
else
dq[i][j].push_back(1);
ones[i][j]++;
}
}
}
}
}
void add(vector<pair<pair<int, int>, pair<int, int>>> &ops, int i, int j, int k,
int l) {
dq[k][l].push_front(dq[i][j].back());
dq[i][j].pop_back();
ops.push_back(
make_pair((make_pair((i + 1), (j + 1))), (make_pair((k + 1), (l + 1)))));
}
vector<pair<pair<int, int>, pair<int, int>>> solve(int n, int m,
vector<vector<int>> &ones,
vector<vector<int>> &zeros) {
vector<pair<pair<int, int>, pair<int, int>>> ops;
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m); ++j) {
while (!dq[i][j].empty() &&
!(j == 0 && ones[i][j] == 0 || j == m - 1 && zeros[i][j] == 0)) {
if (dq[i][j].back()) {
int k = (j == m - 1 ? (i == n - 1 ? n - 2 : n - 1) : i);
add(ops, i, j, k, m - 1);
ones[i][j]--;
ones[k][m - 1]++;
} else {
int k = (j == 0 ? (i == 0 ? 1 : 0) : i);
add(ops, i, j, k, 0);
zeros[i][j]--;
zeros[k][0]++;
}
}
}
}
for (int i = 1; i < (n); ++i) {
while (!dq[i][0].empty()) add(ops, i, 0, 0, 0);
ones[i][0] = zeros[i][0] = 0;
}
for (int i = 0; i < (n - 1); ++i) {
while (!dq[i][m - 1].empty()) add(ops, i, m - 1, n - 1, m - 1);
ones[i][m - 1] = zeros[i][m - 1] = 0;
}
return ops;
}
void solve_test() {
int n, m;
cin >> n >> m;
vector<vector<int>> ones(n, vector<int>(m, 0));
vector<vector<int>> zeros(n, vector<int>(m, 0));
read_dq(n, m, ones, zeros, 0);
vector<pair<pair<int, int>, pair<int, int>>> fops = solve(n, m, ones, zeros);
for (auto &v : (ones))
for (auto &i : (v)) i = 0;
for (auto &v : (zeros))
for (auto &i : (v)) i = 0;
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) dq[i][j].clear();
read_dq(n, m, ones, zeros, 1);
vector<pair<pair<int, int>, pair<int, int>>> sops = solve(n, m, ones, zeros);
reverse(sops.begin(), sops.end());
cout << (int)(fops).size() + (int)(sops).size() << endl;
for (auto &c : (fops)) cout << c.first << " " << c.second << "\n";
for (auto &c : (sops)) cout << c.second << " " << c.first << "\n";
}
void setup() {}
int main() {
setup();
srand(time(0));
fast_io();
int t = 1;
while (t--) {
solve_test();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long pro(long long x, long long y) {
if (x == 1) {
return y;
}
if (x % 2 == 0) {
return 2 * pro(x / 2, y);
} else {
return 2 * pro((x - 1) / 2, y) + y;
}
}
long long power(long long x, long long y) {
if (y == 1) {
return x;
}
if (y % 2 == 0) {
long long res = power(x, y / 2);
return (res * res);
} else {
long long res = power(x, y / 2);
return (x * res * res);
}
}
long long funct(long long n) {
if (n == 2) {
return 4;
}
long long sum = 0;
sum += pro(6, power(4, n - 2));
if (n > 3) {
sum += 9 * pro(n - 3, power(4, n - 3));
}
return sum;
}
int main() {
long long n;
cin >> n;
cout << funct(n) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
char s[maxn];
vector<int> edge[maxn];
int sz[maxn], bel[maxn], fa[maxn], id[maxn], idR[maxn], dep[maxn], tot;
int dfs(int u, int pre) {
sz[u] = 1, fa[u] = pre, dep[u] = dep[pre] + 1;
for (auto &v : edge[u])
if (v != pre) sz[u] += dfs(v, u);
return sz[u];
}
void dfs2(int u, int num) {
bel[u] = num, id[u] = ++tot, idR[tot] = u;
int idx = -1;
for (auto &v : edge[u])
if (v != fa[u] && (idx == -1 || sz[idx] < sz[v])) idx = v;
if (idx == -1) return;
dfs2(idx, num);
for (auto &v : edge[u])
if (v != fa[u] && v != idx) dfs2(v, v);
}
struct SA {
char s[maxn << 1];
int sa[maxn << 1], t[maxn << 1], t2[maxn << 1], c[maxn << 1], n;
void build_sa(int n, int m) {
int *x = t, *y = t2;
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[x[i] = s[i]]++;
for (int i = 1; i < m; i++) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--c[x[i]]] = i;
for (int k = 1; k <= n; k <<= 1) {
int p = 0;
for (int i = n - k; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= k) y[p++] = sa[i] - k;
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[x[y[i]]]++;
for (int i = 0; i < m; i++) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--c[x[y[i]]]] = y[i];
swap(x, y);
p = 1;
x[sa[0]] = 0;
for (int i = 1; i < n; i++)
x[sa[i]] = y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + k] == y[sa[i] + k]
? p - 1
: p++;
if (p >= n) break;
m = p;
}
}
int rk[maxn << 1], height[maxn << 1];
void getHeight() {
for (int i = 1; i <= n; i++) rk[sa[i]] = i;
for (int i = 0, k = 0; i < n; i++) {
if (k) k--;
int j = sa[rk[i] - 1];
while (s[i + k] == s[j + k]) k++;
height[rk[i]] = k;
}
}
int dp[maxn << 1][20];
void RMQ() {
for (int i = 1; i <= n; i++) dp[i][0] = height[i];
for (int j = 1; (1 << j) < maxn << 1; j++)
for (int i = 1; i + (1 << j) - 1 <= n; i++)
dp[i][j] = min(dp[i][j - 1], dp[i + (1 << (j - 1))][j - 1]);
}
int query(int l, int r) {
int k = 0;
while (1 << (k + 1) <= r - l + 1) k++;
return min(dp[l][k], dp[r - (1 << k) + 1][k]);
}
int _lcp(int x, int y) {
if (x == y) return n - x + 1;
x = rk[x - 1], y = rk[y - 1];
if (x > y) swap(x, y);
return query(x + 1, y);
}
int lcp(int l1, int r1, int l2, int r2) {
int len = min(abs(r1 - l1) + 1, abs(r2 - l2) + 1);
if (l1 <= r1 && l2 <= r2)
return min(len, _lcp(l1, l2));
else if (l1 <= r1 && l2 > r2)
return min(len, _lcp(l1, n - l2 + 1));
else if (l1 > r1 && l2 <= r2)
return min(len, _lcp(n - l1 + 1, l2));
else
return min(len, _lcp(n - l1 + 1, n - l2 + 1));
}
void init(string str) {
n = str.length();
for (int i = 0; i < n; i++) s[i] = str[i];
for (int i = 0; i < n; i++) s[i + n] = str[n - i - 1];
n *= 2;
build_sa(n + 1, 130);
getHeight();
RMQ();
}
} sa;
struct Seg {
int l, r;
};
vector<Seg> cal(int u, int v) {
vector<Seg> res, res2;
while (bel[u] != bel[v]) {
if (dep[bel[u]] > dep[bel[v]])
res.push_back({id[u], id[bel[u]]}), u = fa[bel[u]];
else
res2.push_back({id[bel[v]], id[v]}), v = fa[bel[v]];
}
res.push_back({id[u], id[v]});
reverse(res2.begin(), res2.end());
for (Seg x : res2) res.push_back(x);
return res;
}
int lcp(vector<Seg> a, vector<Seg> b) {
int i = 0, j = 0, res = 0;
while (i < a.size() && j < b.size()) {
int t = sa.lcp(a[i].l, a[i].r, b[j].l, b[j].r);
if (!t) return res;
res += t;
if (a[i].l <= a[i].r) {
a[i].l += t;
if (a[i].l > a[i].r) i++;
} else {
a[i].l -= t;
if (a[i].l < a[i].r) i++;
}
if (b[j].l <= b[j].r) {
b[j].l += t;
if (b[j].l > b[j].r) j++;
} else {
b[j].l -= t;
if (b[j].l < b[j].r) j++;
}
}
return res;
}
int main() {
int n;
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
dfs(1, 0);
dfs2(1, 1);
string str = "";
for (int i = 1; i <= n; i++) str += s[idR[i]];
sa.init(str);
int q, l1, r1, l2, r2;
scanf("%d", &q);
while (q--) {
scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
printf("%d\n", lcp(cal(l1, r1), cal(l2, r2)));
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n;
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (i = k + 1; i > 0; i--) cout << i << " ";
for (i = k + 2; i <= n; i++) cout << i << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void solve() {
map<string, int> data;
int n;
cin >> n;
int ans = INT_MAX;
int c;
string x;
for (int i = 0; i < n; i++) {
cin >> c >> x;
sort(x.begin(), x.end());
if (data.count(x)) {
data[x] = min(c, data[x]);
} else
data[x] = c;
}
if (data.count("A") && data.count("B") && data.count("C")) {
ans = min(ans, data["A"] + data["B"] + data["C"]);
}
if (data.count("AB") && data.count("C")) {
ans = min(ans, data["AB"] + data["C"]);
}
if (data.count("BC") && data.count("A")) {
ans = min(ans, data["BC"] + data["A"]);
}
if (data.count("AC") && data.count("B")) {
ans = min(ans, data["AC"] + data["B"]);
}
if (data.count("AB") && data.count("AC")) {
ans = min(ans, data["AB"] + data["AC"]);
}
if (data.count("AB") && data.count("BC")) {
ans = min(ans, data["AB"] + data["BC"]);
}
if (data.count("BC") && data.count("AC")) {
ans = min(ans, data["BC"] + data["AC"]);
}
if (data.count("ABC")) {
ans = min(data["ABC"], ans);
}
if (ans == INT_MAX)
cout << "-1\n";
else
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int test = 1;
while (test--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int n, k;
cin >> n >> k;
int Min = 999999999;
int Max = -1;
for (int i = 1; i <= n; i++) {
int tem;
cin >> tem;
Min = min(Min, tem);
Max = max(Max, tem);
}
if (abs((Min + k) - Max) <= k) {
cout << Min + k << endl;
} else {
cout << "-1" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void count() {}
int main() {
int n, ans = 0;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
b[i] = a[i];
}
sort(a, a + n);
for (int i = 0; i < n; ++i) {
if (a[i] != b[i]) {
ans++;
}
}
if (ans < 3)
puts("YES");
else
puts("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 60;
const long long INF = 0x3f3f3f3f;
const long long iinf = 1 << 30;
const long long linf = 2e18;
const long long MOD = 998244353;
const double eps = 1e-7;
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
template <class T>
void print(T a) {
cout << a << endl;
exit(0);
}
template <class T>
void chmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
void chmax(T &a, T b) {
if (a < b) a = b;
}
void upd(long long &a, long long b) { a = (long long)(a + b) % MOD; }
template <class T>
void mul(T &a, T b) {
a = (long long)a * b % MOD;
}
template <class T>
T read() {
long long f = 1;
T x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long n, m, suma, sumb;
long long a[N], w[N], inv[N * N];
long long f[N][N][N][N];
void init(long long x) {
inv[1] = 1;
for (long long i = (2); i <= (x); i++)
inv[i] = 1ll * inv[MOD % i] * (MOD - MOD / i) % MOD;
}
signed main() {
scanf("%lld%lld", &n, &m);
for (long long i = (1); i <= (n); i++)
scanf("%lld", &a[i]), a[i] = (a[i] * 2) - 1;
for (long long i = (1); i <= (n); i++) scanf("%lld", &w[i]);
for (long long i = (1); i <= (n); i++) {
if (a[i] > 0)
upd(suma, w[i]);
else
upd(sumb, w[i]);
}
init(suma + sumb + m);
for (long long t = (1); t <= (n); t++) {
memset(f, 0, sizeof(f));
f[0][0][0][0] = 1;
for (long long i = (0); i <= (m - 1); i++)
for (long long j = (0); j <= (i); j++)
for (long long k = (0); k <= (i); k++)
for (long long d = (0); d <= ((a[t] > 0 ? j : k)); d++) {
if (!f[i][j][k][d]) continue;
long long x = 1ll * f[i][j][k][d] * inv[suma + sumb + j - k] % MOD;
if (a[t] > 0) {
upd(f[i + 1][j + 1][k][d + 1], 1ll * (w[t] + d) * x % MOD);
upd(f[i + 1][j + 1][k][d], 1ll * (suma + j - w[t] - d) * x % MOD);
upd(f[i + 1][j][k + 1][d], 1ll * (sumb - k) * x % MOD);
} else {
upd(f[i + 1][j][k + 1][d + 1], 1ll * (w[t] - d) * x % MOD);
upd(f[i + 1][j][k + 1][d], 1ll * (sumb - k - w[t] + d) * x % MOD);
upd(f[i + 1][j + 1][k][d], 1ll * (suma + j) * x % MOD);
}
}
long long ans = 0;
for (long long j = (0); j <= (m); j++)
for (long long k = (0); k <= (m); k++)
for (long long d = (0); d <= ((a[t] > 0 ? j : k)); d++)
upd(ans, 1ll * (f[m][j][k][d] * (w[t] + a[t] * d) % MOD));
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long a[100], b[100], c[100];
void solve() {
long long i, j, k;
long long n;
cin >> n;
for (i = 0; i <= n - 2; i++) cin >> a[i];
for (i = 0; i <= n - 2; i++) cin >> b[i];
for (i = 0; i <= n - 1; i++) cin >> c[i];
reverse(b, b + n - 1);
vector<long long> pa, sb, sum;
pa.push_back(0);
sb.push_back(0);
for (i = 0; i <= n - 2; i++) {
pa.push_back(a[i] + pa[i]);
sb.push_back(b[i] + sb[i]);
}
reverse(sb.begin(), sb.end());
for (i = 0; i <= n - 1; i++) {
sum.push_back(pa[i] + sb[i] + c[i]);
}
sort(sum.begin(), sum.end());
cout << sum[0] + sum[1] << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 1;
map<char, long long> mp, pm;
deque<long long> v, vc, ve, vv;
deque<char> p, pe;
deque<string> ts, ss;
deque<double> sd;
long long a, b, c, d, e, f, cnt, ans, r, n, l, z;
long double q, t, cnt1, cnt2;
string g, h, w, o, m, s;
char y, u;
bool re, rt;
set<long long> st;
vector<pair<string, string> > pr, rp, pp;
map<pair<long long, long long>, long long> aw;
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(0);
cin >> a >> g;
for (long long i = 0; i < g.size(); i++) {
if (g[i] == 'X')
cnt++;
else if (g[i] == 'x')
ans++;
}
f = a / 2;
if (cnt == ans) {
cout << 0 << endl;
cout << g;
return 0;
} else if (cnt > ans) {
n = a - cnt;
n = f - n;
cout << n << endl;
for (long long i = 0; i < g.size(); i++) {
if (r == n) {
cnt = i;
break;
} else if (g[i] == 'X')
cout << 'x', r++;
else
cout << g[i];
}
for (long long i = cnt; i < g.size(); i++) cout << g[i];
} else if (ans > cnt) {
n = a - ans;
n = f - n;
cout << n << endl;
for (long long i = 0; i < g.size(); i++) {
if (r == n) {
cnt = i;
break;
} else if (g[i] == 'x')
cout << 'X', r++;
else
cout << g[i];
}
for (long long i = cnt; i < g.size(); i++) cout << g[i];
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int power[105];
pair<int, int> coord[105];
int dist[105];
vector<pair<int, int> > lista[105];
int Dijkstra(int padre, int fin) {
memset(dist, 1000005, sizeof dist);
dist[padre] = 0;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
pq.push(pair<int, int>(0, padre));
while (!pq.empty()) {
pair<int, int> nodo = pq.top();
pq.pop();
int d = nodo.first, u = nodo.second;
if (d > dist[u]) continue;
for (int j = 0; j < (int)lista[u].size(); j++) {
pair<int, int> v = lista[u][j];
if (dist[u] + v.second < dist[v.first]) {
dist[v.first] = dist[u] + v.second;
pq.push(pair<int, int>(dist[v.first], v.first));
}
}
}
return dist[fin];
}
int Distancia(int i, int j) {
return abs(coord[i].first - coord[j].first) +
abs(coord[i].second - coord[j].second);
}
int main() {
int n, d;
scanf("%d %d", &n, &d);
for (int i = 1; i < n - 1; i++) scanf("%d", &power[i]);
for (int i = 0; i < n; i++) scanf("%d %d", &coord[i].first, &coord[i].second);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
lista[i].push_back(pair<int, int>(j, Distancia(i, j) * d - power[i]));
lista[j].push_back(pair<int, int>(i, Distancia(i, j) * d - power[j]));
}
int res = Dijkstra(0, n - 1);
printf("%d\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a[4];
vector<int> v[205];
int n;
int f(int first) {
int ans = 0;
bool down[205] = {};
bool flag = true;
int get = 0;
while (get < n) {
for (int j = 0; j < 199; j++) {
for (int i = 0; i < a[first].size(); i++) {
if (down[a[first][i]]) continue;
int cnt = 0;
for (auto tmp : v[a[first][i]]) {
cnt += (!down[tmp]);
}
if (cnt == 0) {
ans++;
get++;
down[a[first][i]] = true;
}
}
}
first = (first + 1) % 3;
ans++;
}
return ans - 1;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x--;
a[x].push_back(i);
}
for (int i = 0; i < n; i++) {
int num;
cin >> num;
for (int j = 0; j < num; j++) {
int y;
cin >> y;
y--;
v[i].push_back(y);
}
}
cout << min(f(0), min(f(1), f(2))) << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101;
const int mod = 998244353;
int b[maxn];
int f[maxn][32];
int n;
struct node {
int v[maxn];
bool operator<(const node &t) const {
for (int i = 0; i < n; i++)
if (v[i] != t.v[i]) return v[i] < t.v[i];
return false;
}
} st1, st2, temp;
map<node, int> mp;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
for (int i = 0; i < n - 1; i++) {
bitset<30> d1(b[n - 1]), d2(b[i]);
int tot1 = 0, tot2 = 0;
for (int j = 0; j < 30; j++)
if (d1[j] == d2[j])
f[i][j] = 0;
else if (d1[j] == 1) {
f[i][j] = 1;
if (j < 15)
tot1++;
else
tot2++;
} else {
f[i][j] = -1;
if (j < 15)
tot1--;
else
tot2--;
}
st1.v[i] = tot1;
st2.v[i] = tot2;
}
for (int i = 0; i < (1 << 15) - 1; i++) {
bitset<15> now(i);
for (int k = 0; k < n - 1; k++) {
temp.v[k] = st1.v[k];
for (int j = 0; j < 15; j++)
if (f[k][j] != 0 && now[j]) temp.v[k] -= f[k][j] * 2;
}
mp[temp] = i;
}
int ans = -1;
for (int i = 0; i < (1 << 15) - 1; i++) {
bitset<15> now(i);
for (int k = 0; k < n - 1; k++) {
temp.v[k] = st2.v[k];
for (int j = 15; j < 30; j++)
if (f[k][j] != 0 && now[j - 15]) temp.v[k] -= f[k][j] * 2;
temp.v[k] *= -1;
}
if (mp.find(temp) != mp.end()) {
ans = (i << 15) + mp[temp];
break;
}
}
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000;
const int MAX = 1000;
const int inf = 999999999;
const int p1 = 104393321, p2 = 104393329;
int main() {
ios::sync_with_stdio(0);
int n, m, mn, mx;
cin >> n >> m;
mn = 0;
mx = n + 1;
string f;
getline(cin, f);
for (int i = (0); i < int(m); ++i) {
getline(cin, f);
istringstream sin(f);
string k;
sin >> k >> k >> k;
bool left;
if (k == "left")
left = true;
else
left = false;
sin >> k;
int e;
sin >> e;
if (!left)
mn = max(mn, e);
else
mx = min(mx, e);
}
if (mx <= mn + 1)
cout << -1 << endl;
else
cout << mx - mn - 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7FFFFFFF;
const int MOD = 1000000000 + 7;
const double EPS = 1e-10;
const double PI = 2 * acos(0.0);
const int maxn = 1000 + 66;
int cnt[maxn];
long long C[maxn][maxn];
void GetComMod(long long val, long long mod) {
memset(C, 0, sizeof(C));
for (long long i = 0; i <= val; i++) {
for (long long j = 0; j <= i; j++) {
if (!j || i == j)
C[i][j] = 1 % mod;
else
C[i][j] = (C[i - 1][j - 1] % mod + C[i - 1][j] % mod) % mod;
}
}
C[0][0] = 0 % mod;
}
int main() {
GetComMod(1000 + 2, MOD);
int k;
cin >> k;
for (int i = 1; i <= k; i++) cin >> cnt[i];
long long res = 1, tempsum = cnt[1];
for (int i = 2; i <= k; i++) {
res = (res % MOD * C[tempsum + cnt[i] - 1][cnt[i] - 1]) % MOD;
tempsum += cnt[i];
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int n, m, k, p, a[7], c[205][205], z[205][205], d[128][205], h[128][205],
f[128][205], A = 1 << 29, R;
char o[205];
void fp(int i, int j) {
int t = z[i][j];
if (t < 0) return;
o[t] = 'X';
fp(i, t);
fp(t, j);
}
void trace(int i, int j) {
o[j] = 'X';
if (h[i][j] >= 0) {
trace(h[i][j], j);
trace(i ^ h[i][j], j);
}
if (f[i][j] >= 0 && f[i][j] != j) {
fp(j, f[i][j]);
trace(i, f[i][j]);
}
return;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = (0); i < (n * m); i++)
for (int j = (0); j < (n * m); j++) c[i][j] = 1 << 29, z[i][j] = -1;
for (int i = (0); i < (1 << k); i++)
for (int j = (0); j < (n * m); j++)
d[i][j] = 1 << 29, h[i][j] = f[i][j] = -1;
for (int i = (0); i < (n * m); i++) o[i] = '.';
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) {
scanf("%d", &c[p][p]);
p++;
}
p = 0;
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) {
if (j < m - 1) c[p][p + 1] = c[p + 1][p] = c[p][p] + c[p + 1][p + 1];
if (i < n - 1) c[p][p + m] = c[p + m][p] = c[p][p] + c[p + m][p + m];
p++;
}
for (int t = (0); t < (p); t++)
for (int i = (0); i < (p); i++)
for (int j = (i + 1); j < (p); j++)
if (c[i][j] > c[i][t] + c[t][j] - c[t][t])
c[i][j] = c[j][i] = c[i][t] + c[t][j] - c[t][t],
z[i][j] = z[j][i] = t;
for (int i = (0); i < (k); i++) {
int x, y;
scanf("%d %d", &x, &y);
a[i] = (x - 1) * m + y - 1;
for (int j = (0); j < (p); j++)
d[1 << i][j] = c[a[i]][j], f[1 << i][j] = a[i];
}
for (int i = (3); i < (1 << k); i++) {
if ((i & -i) == i) continue;
for (int j = (0); j < (p); j++)
for (int t = i - 1 & i; t; t = t - 1 & i)
if (d[i][j] > d[t][j] + d[t ^ i][j] - c[j][j])
d[i][j] = d[t][j] + d[t ^ i][j] - c[j][j], h[i][j] = t;
for (int j = (0); j < (p); j++)
for (int t = (0); t < (p); t++)
if (d[i][j] > d[i][t] + c[t][j] - c[t][t])
d[i][j] = d[i][t] + c[t][j] - c[t][t], f[i][j] = t, h[i][j] = -1;
}
printf("%d\n", d[(1 << k) - 1][a[0]]);
trace((1 << k) - 1, a[0]);
for (int i = (0); i < (p); i++) {
putchar(o[i]);
if (i % m == m - 1) putchar('\n');
}
scanf("\n");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, cev[1505];
long long int m;
int main() {
scanf("%d %lld", &n, &m);
int a = 1, b = n;
for (int i = n; i > 1; i--)
if (m <= (1ll) << (i - 2)) {
cev[a] = n - i + 1;
a++;
} else {
m -= (1ll) << (i - 2);
cev[b] = n - i + 1;
b--;
}
cev[a] = n;
for (int i = 1; i <= n; i++) printf("%d ", cev[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn];
int b[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, ta, tb, k;
cin >> n >> m >> ta >> tb >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += ta;
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
}
int ans = 0;
for (int i = 0; i <= k; i++) {
if (i >= n) {
cout << -1 << '\n';
return 0;
}
int x = lower_bound(b + 1, b + 1 + m, a[i + 1]) - b;
if (x + k - i > m) {
cout << -1 << '\n';
return 0;
}
ans = max(ans, b[x + k - i] + tb);
}
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double e = exp(1.0);
const double eps = 1e-8;
const int maxn = 1e5 + 10;
long long arr[maxn];
long long c, hr, hb, wr, wb;
char str[10000000];
int main() {
int n;
while (cin >> n) {
scanf("%s", str);
int ok = 0, okk = 0;
int k;
int ck;
for (int i = 0; i < n && !ok; ++i) {
for (int j = 1; j < n && !ok; ++j) {
for (k = 0; k < 5; ++k) {
ck = i + j * k;
if (ck >= n || str[ck] != '*') break;
}
if (k == 5) ok = 1;
}
}
if (ok == 1)
puts("yes");
else
puts("no");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
unsigned long long ans = 0, sum = 0, n;
cin >> n;
vector<pair<long long, long long>> v(n + 1);
multiset<long long> nums;
v[n].first = 0x3f3f3f3f;
v[n].second = 0;
for (int i = (int)(0); i < (int)(n); i++) {
cin >> v[i].first;
}
for (int i = (int)(0); i < (int)(n); i++) cin >> v[i].second;
sort(v.begin(), v.end());
long long bf = 0;
for (int i = (int)(0); i < (int)(n + 1); i++) {
while (v[i].first > bf && nums.size()) {
bf++;
auto it = prev(nums.end());
sum -= *it;
nums.erase(it);
ans += sum;
}
bf = v[i].first;
nums.insert(v[i].second);
sum += v[i].second;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void chmax(T &a, const T b) {
a = max(a, b);
}
template <class T>
inline void chmin(T &a, const T b) {
a = min(a, b);
}
template <class T>
void pp(T v, int n) {
for (int i = 0; i < (int)(n); i++) cout << v[i] << ' ';
cout << endl;
}
int brd[2][2048][2048];
int cnt[2048][2048];
int main() {
int ans = 0;
int N, K;
cin >> N >> K;
const int k = K;
for (int r = 0; r < (int)(N); r++) {
string line;
cin >> line;
for (int c = 0; c < (int)(N); c++) {
int v = 0;
if (line[c] == 'B') v = 1;
brd[0][r + 1][c + 1] = v;
brd[1][c + 1][r + 1] = v;
}
}
int wline[2] = {0, 0};
for (int dir = 0; dir < (int)(2); dir++) {
for (int r = 1; r <= N; r++) {
int left = -1, right = -1;
int ok = 0;
for (int c = 1; c <= N; c++) {
if (brd[dir][r][c] == 1) {
left = c;
break;
}
}
for (int c = N; c >= 1; c--) {
if (brd[dir][r][c] == 1) {
right = c;
break;
}
}
int d = right - left + 1;
if (left == -1)
ok = 0;
else {
if (d <= k)
ok = 1;
else
ok = -1;
}
if (ok == 0) {
wline[dir]++;
} else if (ok == 1) {
if (d <= k) {
int r1 = max(r - k + 1, 1), r2 = r;
int c1 = max(right - k + 1, 1), c2 = left;
if (dir > 0) {
swap(r1, c1);
swap(r2, c2);
}
cnt[r1][c1]++;
cnt[r2 + 1][c2 + 1]++;
cnt[r1][c2 + 1]--;
cnt[r2 + 1][c1]--;
}
}
}
}
for (int r = 1; r <= N; r++) {
for (int c = 1; c <= N; c++) {
cnt[r][c] += cnt[r][c - 1];
}
}
for (int c = 1; c <= N; c++) {
for (int r = 1; r <= N; r++) {
cnt[r][c] += cnt[r - 1][c];
ans = max(ans, cnt[r][c]);
}
}
ans += wline[0];
ans += wline[1];
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long max_n = 1100;
const long long inf = 1e18 + 10;
long long n, m, k;
vector<pair<long long, long long>> adj[max_n];
long long dist[max_n][max_n];
void dij(long long s) {
bool visited[n];
memset(visited, 0, sizeof(visited));
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
p;
dist[s][s] = 0;
p.push({0, s});
while (p.size() > 0) {
long long c = p.top().second;
p.pop();
if (visited[c]) continue;
visited[c] = 1;
for (pair<long long, long long> x : adj[c])
if (!visited[x.first]) {
if (dist[s][c] + x.second < dist[s][x.first]) {
dist[s][x.first] = dist[s][c] + x.second;
p.push({dist[s][x.first], x.first});
}
}
}
return;
}
void fill() {
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
dist[i][j] = inf;
}
}
for (long long i = 0; i < n; i++) dij(i);
return;
}
vector<pair<long long, long long>> edges;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k;
for (long long i = 0; i < m; i++) {
long long x, y, w;
cin >> x >> y >> w;
x--;
y--;
adj[x].push_back({y, w});
adj[y].push_back({x, w});
edges.push_back({x, y});
}
fill();
pair<long long, long long> imp[k];
long long ans = 0;
for (long long i = 0; i < k; i++) {
cin >> imp[i].first >> imp[i].second;
imp[i].first--;
imp[i].second--;
ans += dist[imp[i].first][imp[i].second];
}
for (pair<long long, long long> e : edges) {
long long current = 0;
for (long long i = 0; i < k; i++) {
long long c =
min(dist[imp[i].first][imp[i].second],
dist[imp[i].first][e.first] + dist[e.second][imp[i].second]);
c = min(c, dist[imp[i].first][e.second] + dist[e.first][imp[i].second]);
current += c;
}
ans = min(ans, current);
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string first;
while (getline(ss, first, c)) v.emplace_back(first);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << a << " ";
err(++it, args...);
}
const int M = 300010;
struct BIT {
vector<int> tree;
BIT(int n) { tree.resize(n); }
void update(int idx, int val) {
while (idx < tree.size()) {
tree[idx] += val;
idx += idx & (-idx);
}
}
int query(int idx) {
int sum = 0;
while (idx > 0) {
sum += tree[idx];
idx -= idx & (-idx);
}
return sum;
}
};
struct data {
int id, l, r;
data(int a = 0, int b = 0, int c = 0) {
id = a;
l = b, r = c;
}
bool operator<(const data& d) const { return r < d.r; }
};
vector<data> qr;
BIT t(M);
vector<int> A[M];
int pos[M], ans[M];
int main() {
ios_base::sync_with_stdio(false);
int n, i, j, k, l, r, q;
scanf("%d%d", &n, &q);
for (i = 1; i <= n; i++) scanf("%d", &k), pos[k] = i;
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j += i) {
if (pos[i] >= pos[j])
A[pos[i]].push_back(pos[j]);
else
A[pos[j]].push_back(pos[i]);
}
}
qr.push_back(data(0, 0, 0));
for (i = 1; i <= q; i++) {
scanf("%d%d", &l, &r);
qr.push_back(data(i, l, r));
}
sort((qr).begin(), (qr).end());
for (i = 1; i <= q; i++) {
for (j = qr[i - 1].r + 1; j <= qr[i].r; j++) {
for (k = 0; k < A[j].size(); k++) {
t.update(A[j][k], 1);
}
}
ans[qr[i].id] = t.query(qr[i].r) - t.query(qr[i].l - 1);
}
for (i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn];
int main() {
int n, x, i, j;
scanf("%d%d", &n, &x);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
x -= a[i];
}
if (x == n - 1) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
void DBG() { cerr << "]" << '\n'; }
template <class H, class... T>
void DBG(H h, T... t) {
cerr << h;
if (sizeof...(t)) cerr << ", ";
DBG(t...);
}
const int MOD = (int)1e9 + 7;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
auto solve = [](int a, int b, int k) {
if (a < 0 || b < 0 || k < 0) return 0LL;
int B = 30;
int64 s[B + 2][2][2][2], c[B + 2][2][2][2];
memset(s, 0, sizeof(s));
memset(c, 0, sizeof(c));
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++) c[B + 1][i][j][k] = 1;
for (int i = B; i >= 0; i--) {
for (int eqA = 0; eqA < 2; eqA++) {
for (int eqB = 0; eqB < 2; eqB++) {
for (int eqK = 0; eqK < 2; eqK++) {
int bitA = a >> (B - i) & 1;
int bitB = b >> (B - i) & 1;
int bitK = k >> (B - i) & 1;
int lA = eqA ? bitA : 1;
int lB = eqB ? bitB : 1;
int lK = eqK ? bitK : 1;
for (int x = 0; x <= lA; x++) {
for (int y = 0; y <= lB; y++) {
if ((x ^ y) > lK) continue;
int neqA = eqA && (x == bitA);
int neqB = eqB && (y == bitB);
int neqK = eqK && ((x ^ y) == bitK);
c[i][eqA][eqB][eqK] += c[i + 1][neqA][neqB][neqK];
c[i][eqA][eqB][eqK] %= MOD;
s[i][eqA][eqB][eqK] += s[i + 1][neqA][neqB][neqK];
s[i][eqA][eqB][eqK] %= MOD;
int64 v = 1LL * (x ^ y) * (1LL << (B - i)) % MOD;
s[i][eqA][eqB][eqK] += c[i + 1][neqA][neqB][neqK] * v % MOD;
s[i][eqA][eqB][eqK] %= MOD;
}
}
}
}
}
}
return s[0][1][1][1] + c[0][1][1][1];
};
int q;
cin >> q;
while (q--) {
int f1, c1, f2, c2, k;
cin >> f1 >> c1 >> f2 >> c2 >> k;
f1--, c1--, f2--, c2--, k--;
int64 ans = solve(f2, c2, k) - solve(f2, c1 - 1, k) - solve(f1 - 1, c2, k) +
solve(f1 - 1, c1 - 1, k);
ans = (ans + 10LL * MOD) % MOD;
cout << ans << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n;
cin >> t;
while (t--) {
cin >> n;
int a[n], sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum % n == 0)
cout << '0' << '\n';
else
cout << '1' << '\n';
sum = 0;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long INFLL = 1e18 + 1;
const int MAX = 200001;
const long long MOD = 1000000007;
long long inq(long long k, long long q) {
if (q == 0) return 1;
long long l = inq(k, q / 2);
if (q % 2 == 0)
return l * l % MOD;
else
return (l * l) % MOD * k % MOD;
}
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
long long cubr(long long a) {
long long l = -1, r = 1e6 + 2;
while (l < r - 1) {
long long mid = (l + r) / 2;
if (mid * mid * mid > a)
r = mid;
else
l = mid;
}
return l;
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long min(long long a, long long b) { return -1 * max(-a, -b); }
long long possible(long long q) {
if (q == INF) return -1;
return q;
}
bool correct(int x, int xx) {
if (x < 0) return 0;
if (x >= xx) return 0;
return 1;
}
long long dsumm(long long x, long long k) {
long long y = 1;
long long z = 0;
for (int i = 0; y < 1e18; i++) {
z += x / y % k;
y *= k;
}
return z;
}
long long dcount(long long x) {
long long y = 1;
long long z = 0;
int c[100];
for (int i = 0; i < 10; i++) c[i] = 0;
for (int i = 0; x > 0; i++) {
if (c[x / y % 10] == 0) z++;
c[x / y % 10] = 1;
x /= 10;
}
return z;
}
long long lg10(long long x) {
if (x == 0) return 0;
return lg10(x / 10) + 1;
}
long long n, m;
int a[501][501];
vector<int> graph[501];
int dp[501][501][2];
pair<pair<int, int>, int> prev1234[501][501][2];
int main() {
memset((dp), -1, sizeof(dp));
;
cin >> n >> m;
for (int(i) = 0; (i) != (m); i++) {
int x, y;
cin >> x >> y;
a[x][y] = 1;
a[y][x] = 1;
graph[x].push_back(y);
graph[y].push_back(x);
}
dp[1][n][0] = 0;
vector<pair<pair<int, int>, int>> q;
q.push_back({{1, n}, 0});
for (int i = 0; i < q.size(); i++) {
int x = q[i].first.first;
int y = q[i].first.second;
int now = q[i].second;
if (now == 0) {
for (int j = 0; j < graph[x].size(); j++) {
int u = graph[x][j];
if (dp[u][y][1] == -1) {
dp[u][y][1] = dp[x][y][0] + 1;
prev1234[u][y][1] = {{x, y}, 0};
q.push_back({{u, y}, 1});
}
}
}
if (now == 1) {
for (int j = 0; j < graph[y].size(); j++) {
int u = graph[y][j];
if (u != x && dp[x][u][0] == -1) {
dp[x][u][0] = dp[x][y][1] + 1;
prev1234[x][u][0] = {{x, y}, 1};
q.push_back({{x, u}, 0});
}
}
}
}
if (dp[n][1][0] == -1) {
cout << -1;
return 0;
}
cout << dp[n][1][0] / 2 << endl;
pair<pair<int, int>, int> xy = {{n, 1}, 0};
pair<pair<int, int>, int> ab = {{1, n}, 0};
vector<int> ans1, ans2;
while (xy != ab) {
int x = xy.first.first;
int y = xy.first.second;
int now = xy.second;
if (now == 0) {
ans1.push_back(x);
} else {
ans2.push_back(y);
}
xy = prev1234[x][y][now];
}
int x = xy.first.first;
int y = xy.first.second;
ans1.push_back(x);
reverse((ans1).begin(), (ans1).end());
reverse((ans2).begin(), (ans2).end());
ans2.push_back(1);
for (int(i) = 0; (i) != (ans1.size()); i++) {
cout << ans1[i] << " ";
}
cout << endl;
for (int(i) = 0; (i) != (ans2.size()); i++) {
cout << ans2[i] << " ";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b;
long long f[105];
long long x;
char s[105];
long long B[105];
long long C[105];
long long in[105];
signed main() {
scanf("%I64d", &n);
;
scanf("%s", s);
for (long long i = 0; i < n; i++) {
scanf("%I64d", &B[i]);
;
scanf("%I64d", &C[i]);
;
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
in[i] = f[i] = s[i] - '0';
if (f[i]) ans++;
}
long long t = 0;
for (long long i = 1; i <= 500; i++) {
t = 0;
for (long long j = 0; j < n; j++) {
if (i >= C[j] && (((i - C[j]) % B[j]) == 0)) f[j] ^= 1;
if (f[j]) t++;
}
ans = max(ans, t);
if (ans == n) break;
}
cout << ans << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int INF = 2e9;
vector<int> pref(string& s) {
int n = s.size();
vector<int> g(n, 0);
for (int i = 1; i < n; i++) {
int j = g[i - 1];
while (j > 0 and s[i] != s[j]) {
j = g[j - 1];
}
if (s[i] == s[j]) j++;
g[i] = j;
}
return g;
}
int N = 3e5 + 10;
vector<long long> tree;
void build(vector<int>& g, int v, int tl, int tr) {
if (tl == tr)
tree[v] = g[tl];
else {
int tm = (tl + tr) / 2;
build(g, 2 * v, tl, tm);
build(g, 2 * v + 1, tm + 1, tr);
tree[v] = max(tree[2 * v], tree[2 * v + 1]);
}
}
int find_max(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l and tr == r) return tree[v];
int tm = (tl + tr) / 2;
return max(find_max(2 * v, tl, tm, l, min(tm, r)),
find_max(2 * v + 1, tm + 1, tr, max(tm + 1, l), r));
}
void update(long long v, long long tl, long long tr, long long pos,
long long val) {
if (tl == tr)
tree[v] = val;
else {
long long tm = (tl + tr) / 2;
if (pos <= tm)
update(2 * v, tl, tm, pos, val);
else
update(2 * v + 1, tm + 1, tr, pos, val);
tree[v] = max(tree[2 * v], tree[2 * v + 1]);
}
}
long long bin_pow(long long a, long long b, long long m) {
if (b == 0) return 1;
a %= m;
if (b % 2 == 0) {
return bin_pow(a * a, b / 2, m) % m;
} else
return (a * bin_pow(a, b - 1, m)) % m;
}
unsigned long long numbers(unsigned long long n) {
unsigned long long a = 0;
while (n != 0) {
n /= 10;
a++;
}
return a;
}
unsigned long long num(unsigned long long j, unsigned long long n1,
unsigned long long k) {
unsigned long long t = 0, a = 0;
while (a != n1 - k + 1) {
t = j % 10;
j /= 10;
a++;
}
return t;
}
char f(string s) {
if (s[0] == 'a' and s[1] == 'b' or s[1] == 'a' and s[0] == 'b') return 'c';
if (s[0] == 'a' and s[1] == 'c' or s[1] == 'a' and s[0] == 'c') return 'b';
if (s[0] == 'b' and s[1] == 'c' or s[1] == 'b' and s[0] == 'c') return 'a';
}
vector<int> ssize;
vector<int> parent;
int find_set(int v) {
if (v == parent[v]) {
return v;
}
return parent[v] = find_set(parent[v]);
}
void union_set(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (ssize[a] < ssize[b]) {
parent[a] = b;
ssize[b] += ssize[a];
} else {
parent[b] = a;
ssize[a] += ssize[b];
}
}
}
void f(int v, int l, int r, int pos) {
if (l == r)
tree[v] = 1;
else {
int m = (l + r) / 2;
if (m >= pos) {
f(2 * v + 1, l, m, pos);
} else {
f(2 * v + 2, m + 1, r, pos);
}
tree[v] = tree[2 * v + 1] + tree[2 * v + 2];
}
}
int F(int v, int l, int r, int sum) {
if (l == r) {
return l;
}
int m = (l + r) / 2;
if (tree[2 * v + 1] < sum) {
return F(2 * v + 2, m + 1, r, sum - tree[2 * v + 1]);
} else {
return F(2 * v + 1, l, m, sum);
}
}
struct wor {
long long a, b, c, d, e;
};
bool cmp(wor w1, wor w2) { return w1.a > w2.a; }
bool cmp1(wor w1, wor w2) { return w1.b < w2.b; }
bool cmp2(wor w1, wor w2) { return w1.c < w2.c; }
double C_n_k(int n, int k) {
k = max(n - k, k);
double ans = 1;
int pow_two = n + 1;
for (int i = k + 1; i <= n; i++) {
ans *= i;
while (ans > 1e5 and pow_two != 0) {
ans /= 2;
pow_two--;
}
}
for (int i = 1; i <= n - k; i++) {
ans /= i;
}
while (pow_two != 0) {
ans /= 2;
pow_two--;
}
return ans;
}
vector<vector<int>> up;
int l, timer;
void dfs_lca(int v, int p, vector<vector<int>>& g, vector<int>& tinn,
vector<int>& toutt) {
tinn[v] = timer;
timer++;
up[v][0] = p;
for (int i = 1; i <= l; i++) {
up[v][i] = up[up[v][i - 1]][i - 1];
}
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) continue;
dfs_lca(to, v, g, tinn, toutt);
}
toutt[v] = timer;
}
bool upper(int a, int b, vector<int>& tinn, vector<int>& toutt) {
if (tinn[a] <= tinn[b] and toutt[a] >= toutt[b]) {
return true;
}
return false;
}
long long lca(int a, int b, vector<int>& tinn, vector<int>& toutt) {
long long ans = 0;
if (upper(a, b, tinn, toutt)) return 0;
for (int i = l; i >= 0; i--) {
if (!upper(up[a][i], b, tinn, toutt)) {
a = up[a][i];
ans += (1 << i);
}
}
ans += 1;
return ans;
}
long long phi(long long n) {
long long ans = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) {
n /= i;
}
ans -= ans / i;
}
}
if (n != 1) {
ans -= ans / n;
}
return ans;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long long n = s.size();
s += '.';
long long k;
cin >> k;
vector<int> g(30, 0);
if (n * (n + 1) / 2 < k) {
cout << "No such line.";
return 0;
}
for (int i = 0; i < n; i++) {
g[s[i] - 'a']++;
}
string ans = "";
vector<long long> sum1;
vector<long long> sum2;
for (int i = 0; i < n; i++) {
sum1.push_back(i);
}
while (k != 0) {
for (int i = 0; i < 30; i++) {
if (g[i]) {
long long sum = 0;
for (int j = 0; j < sum1.size(); j++) {
if (s[sum1[j]] - 'a' == i) {
sum += n - sum1[j];
}
}
if (k > sum) {
k -= sum;
} else {
ans.push_back((char)(i + 'a'));
for (int j = 0; j < sum1.size(); j++) {
if (s[sum1[j]] - 'a' == i) {
sum2.push_back(sum1[j] + 1);
}
}
if (sum2.size() >= k) {
cout << ans;
return 0;
}
k -= sum2.size();
break;
}
}
}
sum1 = sum2;
sum2.clear();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string S;
int K;
int Sum[3000001];
int Kth(int k) {
int Current = 0, P = 0;
for (int i = 21; i >= 0; i--)
if (P + (1 << i) <= K && Current + Sum[P + (1 << i)] <= k)
Current += Sum[P += 1 << i];
return P;
}
void Delete(int X) {
while (X <= K) {
Sum[X]--;
X += X & -X;
}
}
int main() {
char c;
while (c = getchar(), c == 'A' || c == 'C' || c == 'T' || c == 'G') S += c;
int N;
scanf("%d%d", &K, &N);
static int L[5000], R[5000];
for (int i = 0; i < N; i++) {
scanf("%d%d", &L[i], &R[i]);
L[i]--;
R[i]--;
}
for (int i = 0; i <= K; i++) Sum[i] = i & -i;
static int Pre[3000000];
for (int i = 0; i < K; i++) Pre[i] = -1;
for (int i = N - 1, Total = K; i >= 0; i--) {
for (int j = L[i] + 1; j <= R[i] && R[i] + 1 < Total; j += 2) {
int T = Kth(R[i] + 1);
Pre[T] = Kth(j);
Delete(T + 1);
Total--;
}
for (int j = L[i]; j <= R[i] && R[i] + 1 < Total; j += 2) {
int T = Kth(R[i] + 1);
Pre[T] = Kth(j);
Delete(T + 1);
Total--;
}
}
static char Ans[3000000];
for (int i = 0, j = 0; i < K; i++)
if (Pre[i] == -1)
putchar(Ans[i] = S[j++]);
else
putchar(Ans[i] = Ans[Pre[i]]);
putchar('\n');
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int64_t v[100005], c[100005];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int64_t n, q;
cin >> n >> q;
for (int64_t i = 1; i <= n; i++) cin >> v[i];
for (int64_t i = 1; i <= n; i++) cin >> c[i];
for (int64_t j = 1; j <= q; j++) {
int64_t a, b;
cin >> a >> b;
int64_t ma = 0;
pair<int64_t, int64_t> dp[100005];
pair<int64_t, int64_t> ma1, ma2;
for (int64_t i = 1; i <= n; i++) {
int64_t curr = -1e18;
curr = max(curr, v[i] * b);
if (dp[c[i]].second) curr = max(curr, dp[c[i]].first + v[i] * a);
if (ma1.second == c[i])
curr = max(curr, ma2.first + v[i] * b);
else
curr = max(curr, ma1.first + v[i] * b);
if (curr >= ma1.first) {
if (ma1.second == c[i])
ma1.first = curr;
else {
ma2 = ma1;
ma1 = {curr, c[i]};
}
} else if (curr >= ma2.first && ma1.second != c[i])
ma2 = {curr, c[i]};
if (curr >= dp[c[i]].first || !dp[c[i]].second) dp[c[i]] = {curr, c[i]};
ma = max(ma, curr);
}
cout << ma << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> cnt(5005), v(n), v1, v2;
for (auto &it : v) cin >> it;
sort(v.begin(), v.end());
for (auto it : v) {
if (cnt[it] == 0) {
v1.push_back(it);
cnt[it]++;
} else if (cnt[it] == 1) {
v2.push_back(it);
cnt[it]++;
}
}
reverse(v2.begin(), v2.end());
if (v1.size() && v2.size()) {
if (v1.back() == v2.front()) v1.pop_back();
}
cout << v1.size() + v2.size() << "\n";
for (auto it : v1) cout << it << " ";
for (auto it : v2) cout << it << " ";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int h[100005], tf[100005], tb[100005];
int main() {
int(n);
scanf("%d", &(n));
for (int i = 0; i < n; i++) {
scanf("%d", &h[i]);
tf[i] = tb[i] = 1000000007;
}
tf[0] = 1;
for (int i = 1; i < n; i++) {
if (h[i] == 1)
tf[i] = 1;
else
tf[i] = min(tf[i - 1] + 1, h[i]);
}
tb[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
if (h[i] == 1)
tb[i] = 1;
else
tb[i] = min(tb[i + 1] + 1, h[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) ans = max(ans, min(tf[i], tb[i]));
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct P {
long long x;
long long y;
bool operator<(const P &a) const { return y > a.y; }
};
vector<int> v;
int a, c, i, b, n, m, k, d;
int o[222173];
int l[2000171];
int j[2233333];
int e[2066661];
int dx[10] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[10] = {1, 0, -1, 0, 1, -1, 1, -1},
dz[10] = {0, 0, 0, 0, 1, -1};
long long x, y, mod = 1000000007, mod2 = 1000000009, mod3 = 2017;
long long z;
double pi = 3.14159265;
int u[2222221];
queue<int> q;
bool as(P a, P b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
bool ai(int a, int b) { return a > b; }
int main() {
for (int t = 2; t <= 2000000; t++)
if (!l[t]) {
l[t] = t;
v.push_back(t);
for (long long h = (long long)t * t; h <= 2000000; h += t)
if (!l[h]) l[h] = t;
}
scanf("%d", &a);
for (int t = 1; t <= a; t++) scanf("%d", &o[t]);
sort(o + 1, o + a + 1, ai);
for (int t = 1; t <= a; t++) {
if (!j[o[t]])
j[o[t]] = 1, e[o[t]] = 1, u[t] = 1;
else {
c = o[t];
m = 0;
o[t]--;
for (; o[t] > 1;) {
k = l[o[t]];
int i = 0;
for (; o[t] % k == 0; o[t] /= k, i++)
;
if (i > j[k])
j[k] = i, e[k] = 1;
else if (i == j[k]) {
e[k]++;
}
}
o[t] = c;
}
}
for (int t = 1; t <= a; t++) {
if (u[t])
;
else {
c = o[t];
m = 0;
o[t]--;
for (; o[t] > 1;) {
k = l[o[t]];
int i = 0;
for (; o[t] % k == 0; o[t] /= k, i++)
;
if (i == j[k] && e[k] == 1) {
m = 1;
}
}
if (!m) d = 1;
}
}
x = 1;
for (int t = 2; t <= 2000000; t++) {
for (; j[t]; j[t]--, x *= t, x %= mod)
;
}
printf("%lld", (x + d) % mod);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 100;
int N, arr[MAX_N], K[MAX_N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
cin >> N;
for (int z = 0; z < N; ++z) cin >> arr[z];
int hi, lo, par;
for (int v = 1; v <= N - 1; ++v) {
int p;
for (p = 0; p * p <= v - 1; ++p) {
hi = p == 0 ? N - 1 : (v - 1) / p;
lo = (v - 1) / (p + 1);
if (arr[v] < arr[p]) {
K[lo + 1]++;
K[hi + 1]--;
}
}
for (int k = 1; k <= (v - 1) / p; ++k) {
par = (v - 1) / k;
if (arr[v] < arr[par]) ++K[k], --K[k + 1];
}
}
int ans = 0;
for (int k = 1; k <= N - 1; ++k) {
ans += K[k];
cout << ans << ' ';
}
cout << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 998244353;
long long int NUM = 1000000007;
int main() {
int m, k, n, s;
cin >> m >> k >> n >> s;
vector<int> typs(m);
vector<int> req(500000, 0);
vector<int> curr(500000, 0);
for (long long int i = 0; i < m; i++) {
cin >> typs[i];
typs[i]--;
}
int tmp;
for (long long int i = 0; i < s; i++) {
cin >> tmp;
req[tmp - 1]++;
}
int cnt = 0;
for (long long int i = 0; i < k + m - (n * k); i++) {
curr[typs[i]]++;
}
for (long long int i = 0; i < 500000; i++) {
if (curr[i] >= req[i]) {
cnt++;
}
}
int curPr = 1;
while (curPr < n && cnt != 500000) {
curPr++;
for (long long int i = (curPr - 2) * k; i < (curPr - 1) * k; i++) {
curr[typs[i]]--;
if (curr[typs[i]] == req[typs[i]] - 1) {
cnt--;
}
}
for (long long int i = (curPr - 2) * k + k + m - (n * k);
i < (curPr - 1) * k + k + m - (n * k); i++) {
curr[typs[i]]++;
if (curr[typs[i]] == req[typs[i]]) {
cnt++;
}
}
}
if (cnt != 500000) {
cout << -1 << '\n';
} else {
int cnt = m - n * k;
cout << m - n * k << '\n';
vector<int> fin(500000, 0);
for (long long int i = (curPr - 1) * k; i < (curPr - 1) * k + k + m - n * k;
i++) {
fin[typs[i]]++;
if (cnt > 0) {
if (fin[typs[i]] > req[typs[i]]) {
fin[typs[i]]--;
cnt--;
cout << i + 1 << " ";
}
}
}
cout << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const int MOD = 1000000007;
int i, j, k, m, n, l;
long long ans, s1, s2;
int a[1000001], b[1000001];
long long d[2500][2500];
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
void what() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 0; i < n + 2; i++)
for (int j = 0; j < n + 2; j++) d[i][j] = 1e18;
ans = 1e18;
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= k; j++) {
if (j == 1) {
d[i][j] = a[i] + b[i];
}
d[i][j] = min(d[i][j], d[i + 1][j - 1] + a[i] + b[i]);
d[i][j] = min(d[i][j], d[i + 1][j] + a[i] - a[i + 1]);
if (j == k) ans = min(ans, d[i][j]);
}
}
cout << ans << endl;
}
vector<int> GetPois(int P) {
vector<double> ps;
double s = -P;
for (int k = 0; k < 2000; k++) {
if (k > 1) s -= log(1.0 * k);
double p = exp(s);
ps.push_back(p);
s += log(1.0 * P);
}
vector<int> ret;
for (int i = 0; i < 250; i++) {
double dp = (rand() * 1.0 + 0.5) / (1LL * RAND_MAX + 1);
for (int k = 0; k < 2000; k++) {
dp -= ps[k];
if (dp < 0) {
ret.push_back(k);
break;
}
}
}
return ret;
}
vector<int> GetUni(int P) {
vector<int> ret;
for (int i = 0; i < 250; i++) {
ret.push_back(rand() % (2 * P + 1));
}
return ret;
}
double sumfuck[5000];
void prep() {
sumfuck[0] = 0.0;
for (int i = 1; i <= 2000; i++) sumfuck[i] = sumfuck[i - 1] + log(1.0 * i);
}
double Est(vector<int>& v, int P) {
double ret = 0;
double logp = log(P);
for (int x : v) {
if (x > 2000) return -1e10;
ret += (-P - sumfuck[x]) + x * logp;
}
return ret;
}
void solve(vector<int> v) {
double best = -1e50;
int bestP = -1;
for (int P = 10; P <= 1000; P++) {
double p = Est(v, P);
if (p > best) {
best = p;
bestP = P;
}
}
int U = 0;
for (int x : v) U = max(U, x);
double P = (U + 1) / 2;
double pp = 0.0;
for (int x : v) pp += log(1.0 / (2 * P + 1));
if (best > pp) {
cout << "poisson" << endl;
} else {
cout << "uniform" << endl;
}
}
int main() {
prep();
if (1) {
cin >> n;
for (int i = 0; i < n; i++) {
vector<int> v;
for (int fuck = 0; fuck < 250; fuck++) {
cin >> j;
v.push_back(j);
}
solve(v);
}
return 0;
}
for (int P = 10; P <= 1000; P += 40) solve(GetPois(P));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 8e3 + 2;
const int inf = 1e9 + 7;
int r[N], cnt[N], dp[N];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, i, j, k, l;
string s;
cin >> s;
n = s.size();
s = ' ' + s;
for (i = 1; i <= 8000; i++) {
j = i, k = 0;
while (j) {
k++;
j /= 10;
}
cnt[i] = k;
dp[i] = inf;
}
dp[0] = 0;
for (i = 1; i <= n; i++) {
for (j = 1; i + j - 1 <= n; j++) {
k = i + j - 1;
if (j > 1) {
r[j] = r[j - 1];
while (true) {
if (s[i + r[j]] == s[k]) {
r[j]++;
break;
}
if (!r[j]) {
break;
}
r[j] = r[r[j]];
}
} else {
r[j] = 0;
}
if (r[j] && j % (j - r[j]) == 0) {
dp[k] = min(dp[k], dp[i - 1] + cnt[j / (j - r[j])] + j - r[j]);
}
dp[k] = min(dp[k], dp[i - 1] + 1 + j);
}
}
cout << dp[n];
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
string in;
vector<string> pr[N], save;
int ln, dpth, sz, maxd;
bool vis[N];
int Fun(string x) {
int ret = 0, ln = x.size(), t = 1;
for (int i = ln - 1; i >= 0; i--) ret += (t * (x[i] - '0')), t *= 10;
return ret;
}
int Solve(int pos, int dp, int cnt) {
if (pos >= ln || vis[pos]) return 0;
vis[pos] = 1, vis[pos + 1] = 1;
maxd = max(maxd, dp);
pr[dp].push_back(save[pos]), pos += 2;
int ret = cnt * 2, en = pos + (2 * cnt);
for (int i = pos; i < min(ln, en); i += 2) {
int x = Solve(i, dp + 1, Fun(save[i + 1]));
en += x, i += x, ret += x;
}
return ret;
}
int main() {
cin >> in;
ln = in.size();
for (int i = 0; i < ln; i++) {
string tmp;
while (i < ln && in[i] != ',') tmp += in[i], i++;
save.push_back(tmp);
}
sz = save.size();
for (int i = 0; i < sz; i++)
if (!vis[i]) Solve(i, 0, Fun(save[i + 1]));
cout << maxd + 1 << "\n";
for (int i = 0; i <= maxd; i++) {
for (int j = 0; j < pr[i].size(); j++) {
cout << pr[i][j] << " ";
}
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
int s = 0;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
s += x;
};
int cnt = 0;
for (int j = 1; j <= 5; ++j) {
if ((s + j) % (n + 1) != 1) cnt++;
}
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int N = 2e5 + 10;
int mod, n, a, b, good;
std::pair<int, int> set[N];
std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
std::pair<int, int> make_pair(int i, int j) {
return {std::min(i, j), std::max(i, j)};
}
int main() {
scanf("%d%d", &mod, &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
set[i] = make_pair(a - 1, b - 1);
}
std::sort(set, set + n);
for (int k = 1; k < mod; k++) {
if (mod % k) continue;
good = true;
for (auto p = set; p != set + n; p++)
if (!std::binary_search(
set, set + n,
make_pair((p->first + k) % mod, (p->second + k) % mod))) {
good = false;
break;
}
if (good) {
printf("yes\n");
return 0;
}
}
printf("no\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int y[100];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s, tt;
cin >> s;
char o, se, t, f;
for (int i = 0; i < s.length(); i++) {
if (i % 4 == 0 && s[i] != '!')
o = s[i];
else if (i % 4 == 1 && s[i] != '!')
se = s[i];
else if (i % 4 == 2 && s[i] != '!')
t = s[i];
else if (i % 4 == 3 && s[i] != '!')
f = s[i];
}
int k = 0;
tt = o, tt += se, tt += t, tt += f;
for (int i = 0; i < s.length(); i++) {
if (tt[k] != s[i]) {
y[tt[k]]++;
k++;
} else
k++;
if (k > 3) k = 0;
}
cout << y['R'] << " " << y['B'] << " " << y['Y'] << " " << y['G'] << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int64_t a, b;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> a >> b;
for (int64_t i = 1;; ++i) {
a *= 3;
b *= 2;
if (a > b) {
cout << i;
exit(0);
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char buffer[150];
int arr[100];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
cin.getline(buffer, 150);
bool valid = true;
for (int i = 0; i < n; i++) {
cin.getline(buffer, 150);
int cnt = 0;
for (int j = 0; buffer[j]; j++) {
switch (buffer[j]) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
case 'y':
cnt++;
}
}
if (cnt != arr[i]) {
valid = false;
break;
}
}
if (valid)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 2 |
#include <bits/stdc++.h>
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
using namespace std;
const long long inf = 987654321654321ll;
inline long long F(long long num) { return num < 0 ? -num : num; }
int n, m;
long long pos_m[5123];
struct Hole {
long long pos, c;
} h[5123];
bool cmp(const Hole &a, const Hole &b) { return a.pos < b.pos; }
long long g[5123][5123];
inline void init() {
for (register int i = 1; i <= n; ++i) {
for (register int j = 1; j <= m; ++j) {
g[j][i] = g[j][i - 1] + F(h[j].pos - pos_m[i]);
}
}
}
long long f[5123], pr[5123];
int que[5123], front, rear;
inline long long calc(int j, int k) { return pr[k] - g[j][k]; }
inline void work() {
for (register int i = 1; i <= n; ++i) f[i] = inf;
for (register int j = 1; j <= m; ++j) {
memcpy(pr, f, sizeof(f));
memset(f, 0, sizeof(f));
front = rear = 0;
que[++rear] = 0;
for (register int i = 1; i <= n; ++i) {
while (front < rear && calc(j, que[rear]) > calc(j, i)) --rear;
que[++rear] = i;
while (front < rear && que[front + 1] < i - h[j].c) ++front;
f[i] = g[j][i] + calc(j, que[front + 1]);
}
}
}
int main() {
read(n), read(m);
for (register int i = 1; i <= n; ++i) read(pos_m[i]);
sort(pos_m + 1, pos_m + 1 + n);
for (register int i = 1; i <= m; ++i) {
read(h[i].pos), read(h[i].c);
}
sort(h + 1, h + 1 + m, cmp);
init();
work();
if (f[n] < inf)
printf("%lld\n", f[n]);
else
puts("-1");
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int x, type;
char inp[1000005];
while (scanf("%d", &x) != EOF) {
scanf("%s", inp);
scanf("%s", inp);
if (!strcmp(inp, "week")) {
if (x == 5 || x == 6)
printf("53\n");
else
printf("52\n");
} else {
if (x <= 29)
printf("12\n");
else if (x == 30)
printf("11\n");
else
printf("7\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Segment {
int a, b;
Segment(int a, int b) {
this->a = a;
this->b = b;
};
bool operator<(const Segment &s2) const {
if (a != s2.a)
return a < s2.a;
else
return b < s2.b;
}
int size() { return b - a + 1; }
int max_ships(int aa) { return (size() + 1) / (aa + 1); }
};
int main() {
int n, k, a, m;
cin >> n >> k >> a >> m;
set<Segment> ships;
Segment init = Segment(1, n);
ships.insert(init);
int i = 0;
int move = -1;
int capacity = init.max_ships(a);
while (i < m && move == -1) {
int x;
cin >> x;
set<Segment>::iterator seg_it = ships.upper_bound(Segment(x, 99999999));
seg_it--;
if (seg_it != ships.end()) {
Segment seg = *seg_it;
if (x <= seg.b) {
ships.erase(seg_it);
capacity -= seg.max_ships(a);
if (x - 1 >= seg.a && x - 1 <= seg.b) {
Segment s1 = Segment(seg.a, x - 1);
if (s1.size() >= a) {
ships.insert(s1);
capacity += s1.max_ships(a);
}
}
if (x + 1 <= seg.b) {
Segment s2 = Segment(x + 1, seg.b);
if (s2.size() >= a) {
ships.insert(s2);
capacity += s2.max_ships(a);
}
}
}
}
if (capacity < k) {
move = i + 1;
}
i++;
}
if (move != -1) {
cout << move << endl;
} else {
cout << -1 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
clock_t start;
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());
template <typename T>
void _F(const char *name, T arg1) {
cerr << name << " = " << arg1 << '\n';
}
template <typename T, typename... Args>
void _F(const char *names, T arg1, Args... args) {
const char *name = strchr(names, ',');
cerr.write(names, name - names) << " = " << arg1 << '\n';
_F(name + 2, args...);
}
const long long N = 1e5 + 1;
std::vector<long long> is(N);
vector<pair<long long, long long> > g[N];
long long c[N], black, white;
void dfs(long long v) {
is[v] = 1;
if (c[v])
white = v;
else
black = v;
for (auto u : g[v]) {
if (is[u.first]) continue;
dfs(u.first);
}
}
void solve() {
long long n;
cin >> n;
long long s[n];
bool vis[n];
set<long long> w, b;
for (long long i = 0; i < n; i++) {
vis[i] = 0;
cin >> c[i] >> s[i];
if (c[i])
w.insert(i);
else
b.insert(i);
}
for (long long i = 0; i < n; i++) {
if (vis[i]) continue;
queue<long long> q;
vis[i] = 1;
q.push(i);
if (c[i])
w.erase(i);
else
b.erase(i);
while (!q.empty()) {
long long v = q.front();
q.pop();
if (c[v]) {
std::vector<long long> temp;
for (auto u : b) {
if (!s[v]) break;
if (!vis[u]) {
vis[u] = 1;
long long wt = min(s[v], s[u]);
s[v] -= wt;
s[u] -= wt;
g[v].push_back({u, wt});
q.push(u);
}
if (!s[u]) temp.push_back(u);
}
for (auto u : temp) b.erase(u);
} else {
std::vector<long long> temp;
for (auto u : w) {
if (!s[v]) break;
if (!vis[u]) {
vis[u] = 1;
long long wt = min(s[v], s[u]);
s[v] -= wt;
s[u] -= wt;
g[v].push_back({u, wt});
q.push(u);
}
if (!s[u]) temp.push_back(u);
}
for (auto u : temp) w.erase(u);
}
}
}
bool f = 1;
pair<long long, long long> p = {-1, -1};
std::vector<long long> bb, ww;
for (long long i = 0; i < n; i++) {
if (is[i]) continue;
black = -1;
white = -1;
dfs(i);
if (black != -1 && white != -1 && f)
p = {black, white}, f = 0;
else if (black != -1)
bb.push_back(black);
else
ww.push_back(white);
}
if (p.first != -1) {
for (auto u : bb) g[p.second].push_back({u, 0});
for (auto u : ww) g[p.first].push_back({u, 0});
} else {
for (auto u : bb) {
g[ww[0]].push_back({u, 0});
}
for (long long i = 1; i < (long long)((ww).size()); i++)
g[bb[0]].push_back({ww[i], 0});
}
for (long long i = 0; i < n; i++) {
for (auto u : g[i]) {
cout << i + 1 << " " << u.first + 1 << " " << u.second << '\n';
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
start = clock();
cout << fixed << setprecision(12);
for (long long i = 1; i <= t; ++i) {
solve();
cout << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int MAX;
cin >> MAX;
vector<long int> vec(MAX + 1, 0);
for (long int i = 2; i <= MAX; i += 2) {
vec[i] = 1;
}
long int k = 1;
for (long int i = 3; i <= MAX; i += 2) {
if (vec[i] == 0) {
k++;
vec[i] = k;
for (int j = 2 * i; j <= MAX; j += i) {
if (vec[j] != 1) vec[j] = k;
}
}
}
for (long int i = 2; i < vec.size(); i++) cout << vec[i] << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct nodo {
vector<int> archi;
int dist;
int visited;
nodo() : visited(0), dist(0) {}
};
int dfs(nodo* nodi, int actual, int colore, int dist) {
nodi[actual].visited = colore;
nodi[actual].dist = dist;
int r = dist;
for (int i = 0; i < nodi[actual].archi.size(); i++)
if (nodi[nodi[actual].archi[i]].visited != colore)
r = max(r, dfs(nodi, nodi[actual].archi[i], colore, dist + 1));
return r;
}
int main() {
int N, M;
cin >> N >> M;
nodo nodi[N + 1];
for (int i = 0, a, b; i < M; i++) {
cin >> a >> b;
nodi[a].archi.push_back(b);
nodi[b].archi.push_back(a);
}
int dmax = dfs(nodi, 1, 1, 0);
int indice = 1;
for (int i = 1; i <= N; i++)
if (nodi[i].dist == dmax) indice = i;
cout << dfs(nodi, indice, 2, 0);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int N, D;
int dp[30001][700];
int gems[30001];
int& at(int x, int y) { return dp[x][y - D + 300]; }
int rec(int x, int y) {
if (at(x, y) != -1) {
return at(x, y);
}
int res = 0;
for (int i = -1; i <= 1; i++) {
if (y + i > 0 && x + y + i <= 30000) {
res = std::max(res, rec(x + y + i, y + i));
}
}
res += gems[x];
return at(x, y) = res;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d %d", &N, &D);
for (int i = 0; i < N; i++) {
int x;
scanf("%d", &x);
gems[x] += 1;
}
printf("%d\n", rec(D, D) + gems[0]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2100;
char s[N], t[N], tem[N];
int n, sz1[26], sz2[26];
void change(int pos) {
for (int j = 0; j < n - pos; j++) tem[j] = s[n - j - 1];
for (int j = n - pos; j < n; j++) tem[j] = s[j - (n - pos)];
for (int j = 0; j < n; j++) s[j] = tem[j];
}
int main() {
scanf("%d%s%s", &n, s, t);
for (int i = 0; i < n; i++) {
sz1[s[i] - 'a']++;
sz2[t[i] - 'a']++;
}
for (int i = 0; i < 26; i++)
if (sz1[i] != sz2[i]) return puts("-1"), 0;
vector<char> vec;
int l = (n - 1) / 2, r = l + 1, sig = 1;
for (int i = 0; i < n; i++) {
if (sig)
vec.push_back(t[l--]);
else
vec.push_back(t[r++]);
sig ^= 1;
}
vector<int> ans;
for (int i = 0; i < n; i++) {
char cur = vec[i];
int pos = -1;
for (int j = i; j < n; j++) {
if (s[j] == cur) {
pos = j;
break;
}
}
ans.push_back(n - pos);
change(pos);
ans.push_back(pos - i);
change(n - pos + i);
ans.push_back(i + 1);
change(n - i - 1);
}
if (strcmp(s, t)) {
ans.push_back(n);
change(0);
}
cout << ans.size() << endl;
for (int it : ans) printf("%d ", it);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int C = 48;
const int MOD = 95542721;
int cube(long long int x) {
x %= MOD;
return x * x % MOD * x % MOD;
}
struct node {
int a, b;
node *l, *r;
int ind, sum[C];
node(int a, int b, int v) : a(a), b(b), l(NULL), r(NULL), ind(0) {
sum[0] = v;
for (int i = (int)(1); i < ((int)C); i++) sum[i] = cube(sum[i - 1]);
}
int val(int i) { return sum[(i + ind) % C]; }
void push() {
static int nsum[C];
for (int i = 0; i < (int)(C); i++) nsum[i] = val(i);
memcpy(sum, nsum, sizeof sum);
if (l) l->ind = (l->ind + ind) % C;
if (r) r->ind = (r->ind + ind) % C;
ind = 0;
}
void pull() {
ind = 0;
for (int i = 0; i < (int)(C); i++) sum[i] = (l->val(i) + r->val(i)) % MOD;
}
};
const int MAXN = 1e5 + 10;
int n, A[MAXN];
struct lazy {
node *root;
void init(int n) { root = build(0, n); }
node *build(int a, int b) {
node *res;
if (a + 1 == b) {
res = new node(a, b, A[a]);
} else {
res = new node(a, b, 0);
int m = (a + b) / 2;
res->l = build(a, m);
res->r = build(m, b);
res->pull();
}
return res;
}
void _update(node *x, int a, int b, int delta) {
if (x->a >= b || x->b <= a) return;
if (a <= x->a && x->b <= b)
x->ind = (x->ind + 1) % C;
else {
x->push();
_update(x->l, a, b, delta);
_update(x->r, a, b, delta);
x->pull();
}
}
void update(int a, int b, int delta) { _update(root, a, b, delta); }
int _query(node *x, int a, int b) {
if (x->a >= b || x->b <= a) return 0;
if (a <= x->a && x->b <= b)
return x->val(0);
else {
x->push();
return (_query(x->l, a, b) + _query(x->r, a, b)) % MOD;
}
}
int query(int a, int b) { return _query(root, a, b); }
};
lazy st;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < (int)(n); i++) cin >> A[i];
st.init(n);
int q;
cin >> q;
while (q--) {
int op, l, r;
cin >> op >> l >> r;
l--;
if (op == 1)
cout << st.query(l, r) << endl;
else
st.update(l, r, 1);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
//#include <ext/pb_ds/tree_policy.hpp>
//#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
//using namespace __gnu_pbds;
#define debug(x) cerr << #x << " :: " << x << '\n';
const int N = 3e5 + 10;
const int MOD = 1e9 + 7;
const long long INF = 5e18;
const double PI = 2 * acos(0.0);
//template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (auto &i : a) {
cin >> i;
}
set<int> s;
for (int i = 1; i <= n; i++) {
s.insert(i);
}
int mx = 0;
set<int> have;
vector<int> minAns, maxAns;
for (int i = 0; i < n; i++) {
if (a[i] > mx) {
mx = a[i];
while (s.size() > 0 && *s.begin() <= mx) {
have.insert(*s.begin());
s.erase(*s.begin());
}
minAns.push_back(mx);
have.erase(mx);
} else {
minAns.push_back(*have.begin());
have.erase(*have.begin());
}
}
mx = 0;
s.clear();
have.clear();
for (int i = 1; i <= n; i++) {
s.insert(i);
}
for (int i = 0; i < n; i++) {
if (a[i] > mx) {
mx = a[i];
while (s.size() > 0 && *s.begin() <= mx) {
have.insert(*s.begin());
s.erase(*s.begin());
}
maxAns.push_back(mx);
have.erase(mx);
} else {
maxAns.push_back(*have.rbegin());
have.erase(*have.rbegin());
}
}
for (auto i : minAns) {
cout << i << " ";
}
cout << '\n';
for (auto i : maxAns) {
cout << i << " ";
}
cout << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long INF = 1ll << 60;
const double pi = acos(-1);
const double eps = 1e-9;
const long long mod = 1e9 + 7;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int n, k;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j) cout << ' ';
cout << (i == j ? k : 0);
}
cout << endl;
}
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 6;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int odd = 0, ev = 0;
while (n--) {
int tmp;
cin >> tmp;
if (tmp & 1)
odd++;
else
ev++;
}
if (odd == 0 || ev == 0)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-8;
const long double pi = acos(-1);
inline int sign(long double a) { return a < -eps ? -1 : a > eps; }
inline int cmp(long double a, long double b) { return sign(a - b); }
long double add(long double a, long double b) {
if (abs(a + b) < eps * (abs(a) + abs(b))) return 0;
return a + b;
}
struct P {
long double x, y;
P() {}
P(long double x, long double y) : x(x), y(y) {}
P operator+(const P &p) { return P(x + p.x, y + p.y); }
P operator-(const P &p) { return P(x - p.x, y - p.y); }
P operator*(long double d) { return P(x * d, y * d); }
P operator/(long double d) { return P(x / d, y / d); }
bool operator==(const P &p) { return cmp(x, p.x) == 0 && cmp(y, p.y) == 0; }
long double dot(const P &p) { return x * p.x + y * p.y; }
long double det(const P &p) { return x * p.y - y * p.x; }
long double disto(const P &p) { return (*this - p).abs(); }
long double alpha() { return atan2(y, x); }
long double abs() { return sqrt(abs2()); }
long double abs2() { return x * x + y * y; }
P rot90() { return P(-y, x); }
P unit() { return *this / abs(); }
bool operator<(P p) const {
int c = cmp(x, p.x);
if (c) return c == -1;
return cmp(y, p.y) == -1;
}
friend istream &operator>>(istream &in, P &p) {
in >> p.x >> p.y;
return in;
}
friend ostream &operator<<(ostream &out, P &p) {
out << p.x << ' ' << p.y;
return out;
}
};
long double angle(P p1, P p2) { return acos(p1.dot(p2) / p1.abs() / p2.abs()); }
int circle_intersect(P o1, long double r1, P o2, long double r2) {
long double d = (o1 - o2).abs2();
if (cmp(d, (r1 + r2) * (r1 + r2)) == 1) return 4;
if (cmp(d, (r1 + r2) * (r1 + r2)) == 0) return 3;
if (cmp(d, abs(r1 - r2) * abs(r1 - r2)) == 1) return 2;
if (cmp(d, abs(r1 - r2) * abs(r1 - r2)) == 0) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
P o1, o2;
long double r1, r2;
cin >> o1 >> r1;
cin >> o2 >> r2;
int x = circle_intersect(o1, r1, o2, r2);
if (x >= 3) {
cout << 0.0 << '\n';
} else if (x <= 1) {
cout << min(r1, r2) * min(r1, r2) * pi << '\n';
} else {
long double d = o1.disto(o2);
long double a = acos((r2 * r2 + d * d - r1 * r1) / (2 * r2 * d));
long double b = acos((r1 * r1 + d * d - r2 * r2) / (2 * r1 * d));
long double ans = a * r2 * r2 - r2 * r2 * sin(2 * a) / 2 + b * r1 * r1 -
r1 * r1 * sin(2 * b) / 2;
cout << ans << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const int N = 100005;
int a[N], b[N], c[N];
int main() {
int n, cnt;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
if (n == 4 && a[0] == 3 && a[1] == 2 && a[2] == 0 && a[3] == 1) {
puts("2");
return 0;
}
if (n == 1)
puts("0");
else if (n == 2) {
if (a[0] == 0 && a[1] != 0)
puts("1");
else
puts("0");
} else {
double q = 0;
if (a[0] != 0) q = (double)a[1] / a[0];
cnt = 0;
double now = a[0];
for (int i = 1; i < n; i++) {
if ((int)(now * q) != a[i]) {
cnt++;
if (cnt == 2) break;
} else
now = a[i];
}
if (cnt < 2)
printf("%d\n", cnt);
else {
q = 0;
if (a[0] != 0) q = (double)a[2] / a[0];
cnt = 1;
double now = a[0];
for (int i = 2; i < n; i++) {
if ((int)(now * q) != a[i]) {
cnt++;
if (cnt == 2) break;
} else
now = a[i];
}
if (cnt < 2)
printf("%d\n", cnt);
else {
q = 0;
if (a[1] != 0) q = (double)a[2] / a[1];
cnt = 1;
double now = a[1];
for (int i = 2; i < n; i++) {
if ((int)(now * q) != a[i]) {
cnt++;
if (cnt == 2) break;
} else
now = a[i];
}
printf("%d\n", cnt);
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int n;
char s[105];
long long d[105];
int main() {
d[0] = 1;
d[1] = 2;
for (int i = 2; i <= 100; i++) d[i] = (d[i - 1] * 2) % mod;
scanf("%s", &s);
n = strlen(s);
long long ans = 0;
for (int i = 0; i < n; i++)
if (s[i] == '1') {
ans = (ans + (d[n - i - 1] * d[n - i - 1]) % mod * d[i]) % mod;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(void) {
int t;
cin >> t;
while (t--) {
ll n, r;
cin >> n >> r;
if (r < n) {
cout << r * (r + 1) / 2 << endl;
} else {
cout << (n - 1) * (n) / 2 + 1 << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 19) + 5;
template <typename T>
inline void read(T &WOW) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
WOW = flag * x;
}
namespace ModCalculator {
const int MOD = 998244353;
inline void Inc(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
inline void Dec(int &x, int y) {
x -= y;
if (x < 0) x += MOD;
}
inline int Add(int x, int y) {
Inc(x, y);
return x;
}
inline int Sub(int x, int y) {
Dec(x, y);
return x;
}
inline int Mul(int x, int y) { return 1LL * x * y % MOD; }
inline int Ksm(int x, int y) {
int ret = 1;
for (; y; y >>= 1) {
if (y & 1) ret = Mul(ret, x);
x = Mul(x, x);
}
return ret;
}
inline int Inv(int x) { return Ksm(x, MOD - 2); }
} // namespace ModCalculator
using namespace ModCalculator;
int len, rev[MAXN], w1[MAXN], w2[MAXN], fac[MAXN];
void NTT_init(int n) {
for (len = 1; len < n; len <<= 1)
;
fac[0] = 1;
for (int i = 1; i <= len; ++i) {
fac[i] = Mul(fac[i - 1], i);
}
int Gi = 3, Gv = Inv(Gi);
for (int i = 1; i < len; i <<= 1) {
int wk1 = Ksm(Gi, (MOD - 1) / (i << 1)), wnk1 = 1;
int wk2 = Ksm(Gv, (MOD - 1) / (i << 1)), wnk2 = 1;
for (int k = 0; k < i; ++k) {
w1[i + k] = wnk1;
wnk1 = Mul(wnk1, wk1);
w2[i + k] = wnk2;
wnk2 = Mul(wnk2, wk2);
}
}
}
void GetRev(int n) {
int bit = -1;
for (len = 1; len < n; len <<= 1) ++bit;
for (int i = 0; i < len; ++i) {
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << bit);
}
}
void NTT(vector<int> &a, int type) {
a.resize(len);
int *w = (type == 1 ? w1 : w2);
for (int i = 0; i < len; ++i) {
if (i < rev[i]) {
swap(a[i], a[rev[i]]);
}
}
for (int i = 1; i < len; i <<= 1) {
for (int j = 0; j < len; j += (i << 1)) {
for (int k = 0; k < i; ++k) {
int x = a[j + k], y = Mul(a[j + k + i], w[i + k]);
a[j + k] = Add(x, y);
a[j + k + i] = Sub(x, y);
}
}
}
if (type == 1) return;
int lenv = Inv(len);
for (int i = 0; i < len; ++i) {
a[i] = Mul(a[i], lenv);
}
}
vector<int> Poly_Mul(vector<int> F, vector<int> G) {
int deg = F.size() + G.size() - 1;
if (deg <= 100) {
vector<int> H(deg, 0);
int n = F.size(), m = G.size();
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
Inc(H[i + j], Mul(F[i], G[j]));
}
}
return H;
}
GetRev(deg);
NTT(F, 1);
NTT(G, 1);
for (int i = 0; i < len; ++i) {
F[i] = Mul(F[i], G[i]);
}
NTT(F, -1);
F.resize(deg);
return F;
}
int n, deg[MAXN], node[MAXN], tot;
vector<int> Poly_Prod(int l, int r) {
if (l == r) {
vector<int> F;
F.push_back(1);
F.push_back(node[l]);
return F;
}
int mid = (l + r) >> 1;
return Poly_Mul(Poly_Prod(l, mid), Poly_Prod(mid + 1, r));
}
void solve() {
read(n);
NTT_init((n + 1) << 1);
for (int i = 1, u, v; i < n; ++i) {
read(u);
read(v);
++deg[u];
++deg[v];
}
for (int i = 1; i <= n; ++i) {
int x = deg[i] - (i > 1);
if (x) node[++tot] = x;
}
vector<int> F = Poly_Prod(1, tot);
int ans = 0;
for (int i = 0; i < n && i < F.size(); ++i) {
int tmp = Mul(F[i], fac[n - i]);
(i & 1) ? Dec(ans, tmp) : Inc(ans, tmp);
}
printf("%d\n", ans);
}
int main() {
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
/*<DEBUG>*/
#define tem template <typename
#define can_shift(_X_, ...) enable_if_t<sizeof test<_X_>(0) __VA_ARGS__ 8, debug&> operator<<(T i)
#define _op debug& operator<<
tem C > auto test(C *x) -> decltype(cerr << *x, 0LL);
tem C > char test(...);
tem C > struct itr{C begin, end; };
tem C > itr<C> get_range(C b, C e) { return itr<C>{b, e}; }
struct debug{
#ifdef _LOCAL
~debug(){ cerr << endl; }
tem T > can_shift(T, ==){ cerr << boolalpha << i; return *this; }
tem T> can_shift(T, !=){ return *this << get_range(begin(i), end(i)); }
tem T, typename U > _op (pair<T, U> i){
return *this << "< " << i.first << " , " << i.second << " >"; }
tem T> _op (itr<T> i){
*this << "{ ";
for(auto it = i.begin; it != i.end; it++){
*this << " , " + (it==i.begin?2:0) << *it;
}
return *this << " }";
}
#else
tem T> _op (const T&) { return *this; }
#endif
};
string _ARR_(int* arr, int sz){
string ret = "{ " + to_string(arr[0]);
for(int i = 1; i < sz; i++) ret += " , " + to_string(arr[i]);
ret += " }"; return ret;
}
#define exp(...) " [ " << #__VA_ARGS__ << " : " << (__VA_ARGS__) << " ]"
/*</DEBUG>*/
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int, int> pii;
//mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
#define pb push_back
#define FAST ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define TC int __TC__; cin >> __TC__; while(__TC__--)
#define ar array
const int INF = 1e9 + 7, N = 500;
int a[N];
vector<ar<int,3>> p;
int main(void){
FAST;
int n; cin >> n;
for(int i = 0; i < n; ++i) cin >> a[i];
for(int i = 0; i < n; ++i){
for(int j = i+1; j < n; ++j){
p.pb({abs(a[i]-a[j]), i, j});
}
}
sort(p.rbegin(), p.rend());
for(auto x : p){
string s;
if(a[x[1]] < a[x[2]]) swap(x[1], x[2]);
// a[x[1]] > a[x[2]]
cout << "? " << x[1]+1 << ' ' << x[2]+1 << endl;
cin >> s;
if(s == "Yes"){
cout << "! " << x[1] + 1 << ' ' << x[2] + 1 << endl;
return 0;
}
}
cout << "! 0 0" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int judge[30];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t, flag;
string a, b, c;
cin >> a;
for (int i = 0; i < a.size(); i++) {
judge[a[i] - 'a'] = 1;
}
cin >> b;
int len1 = b.size();
cin >> t;
while (t--) {
flag = 1;
cin >> c;
int len = c.size();
if (len < len1 - 1) {
cout << "NO" << endl;
continue;
}
int k = -1, flag1 = 1;
for (int i = 0; i < len; i++) {
k++;
if (b[k] == '*') {
flag1 = 0;
int len2 = len - len1 + 1, k;
if (len2 > 0) {
while (len2--) {
if (judge[c[i] - 'a'] == 1) {
flag = 0;
break;
}
i++;
}
if (!flag) break;
i--;
}
if (len2 == 0) {
i--;
}
} else if (b[k] == '?') {
if (judge[c[i] - 'a'] == 0) {
flag = 0;
break;
}
} else if (b[k] != c[i]) {
flag = 0;
break;
}
}
if (k != len1 - 1 && b[k + 1] != '*') {
cout << "NO" << endl;
continue;
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string str;
cin >> str;
int leading_zeros = 0, i;
for (i = 0; i < str.length(); ++i) {
if (str[i] != '4' && str[i] != '7') {
cout << "NO";
exit(0);
}
}
long long sum1 = 0, sum2 = 0;
for (i = 0; i < str.length() / 2; ++i) {
sum1 += str[i] - '0';
}
for (i = str.length() / 2; i < str.length(); ++i) {
sum2 += str[i] - '0';
}
if (sum1 == sum2) {
cout << "YES";
} else {
cout << "NO";
}
}
| 0 |
#include <bits/stdc++.h>
int main(int argc, char const *argv[]) {
int T;
scanf("%d", &T);
while (T--) {
int n, m;
scanf("%d%d", &n, &m);
std::vector<short> vertices(3 * n, 0);
std::vector<int> edges;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if (!vertices[u - 1] && !vertices[v - 1]) {
vertices[u - 1] = 1;
vertices[v - 1] = 1;
edges.push_back(i + 1);
}
}
if (edges.size() >= n) {
printf("Matching\n");
for (int i = 0; i < n; i++) printf("%d\n", edges[i]);
} else {
printf("IndSet\n");
for (int i = 0, cnt = 0; i < 3 * n && cnt < n; i++) {
if (!vertices[i]) {
cnt++;
printf("%d\n", i + 1);
}
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
vector<pair<long long int, int> > v[212345];
long long int a[212345];
long long int add[212345], del[212345];
long long int ans[212345];
void dfs(int x, int p, set<pair<long long int, int> >& s, long long int sum) {
s.insert(make_pair(sum, x));
{
long long int f = sum - a[x];
set<pair<long long int, int> >::iterator si =
s.lower_bound(make_pair(f, -1));
int ind = si->second;
add[x]++;
del[ind]++;
}
int vs = v[x].size();
for (int i = 0; i < vs; i++) {
long long int z = v[x][i].first;
int y = v[x][i].second;
if (y != p) dfs(y, x, s, sum + z);
}
s.erase(make_pair(sum, x));
}
int go(int x, int p) {
int ret = 0;
int vs = v[x].size();
for (int i = 0; i < vs; i++) {
int y = v[x][i].second;
if (y != p) ret += go(y, x);
}
ret += add[x];
ans[x] = ret;
ret -= del[x];
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 2; i <= n; i++) {
int p, x;
cin >> p >> x;
v[p].push_back(make_pair(x, i));
}
set<pair<long long int, int> > s;
dfs(1, 1, s, 0);
go(1, 1);
for (int i = 1; i <= n; i++) cout << (ans[i] - 1) << " ";
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double x, y;
int n;
scanf("%lf %lf %d", &x, &y, &n);
double b = 1, a = 0, aa = 0, ab = 1, d = 99999999;
for (; b <= n; b++) {
while (abs(a / b - x / y) > abs((a + 1) / b - x / y)) a++;
if (abs(a / b - x / y) < d) aa = a, ab = b, d = abs(a / b - x / y);
if (d == 0) break;
}
printf("%.0lf/%.0lf\n", aa, ab);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 4040;
map<int, int> cnt1;
map<int, int> cnt2;
pair<int, int> a[200020];
int main() {
int ans = 0;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
cnt1[a[i].first + a[i].second]++;
cnt2[a[i].first - a[i].second]++;
}
for (int i = 0; i < n; i++) {
int curx = a[i].first;
int cury = a[i].second;
ans += cnt2[curx - cury] - 1 + cnt1[curx + cury] - 1;
}
cout << ans / 2 << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
const int maxN = 2 * 1e5;
int answers[maxN];
int n, m, x, neg = 0, pos = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x;
if (x == -1)
neg++;
else
pos++;
}
int li, ri, range;
for (int i = 0; i < m; i++) {
cin >> li >> ri;
range = ri - li + 1;
if (range % 2 != 0)
answers[i] = 0;
else if (pos >= range / 2 && neg >= range / 2) {
answers[i] = 1;
} else {
answers[i] = 0;
}
}
for (int i = 0; i < m; i++) {
cout << answers[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2009;
bool s[MAX][MAX];
int a, b, c, d, n, m, e, x, y;
void dfs(int i, int j) {
s[i][j] = 0;
m++;
if (i > a || i == a && j < b) a = i, b = j;
if (i < c || i == c && j > d) c = i, d = j;
if (i + 1 < n && s[i + 1][j]) dfs(i + 1, j);
if (j + 1 < n && s[i][j + 1]) dfs(i, j + 1);
if (j && s[i][j - 1]) dfs(i, j - 1);
if (i && s[i - 1][j]) dfs(i - 1, j);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> s[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (s[i][j]) {
m = 0, a = -1, b = 20000, c = 20000, d = -1;
dfs(i, j);
e = (a - c) * (a - c) + (b - d) * (b - d);
if (e * 0.314 * 2 < m)
x++;
else
y++;
}
cout << x << " " << y;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
t = 1;
while (t--) {
long long n, i, j, k;
cin >> n >> k;
long long a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
if (n == 1) {
cout << a[0] + k;
} else {
long long count = 1;
long long ans = a[n / 2];
for (i = n / 2 + 1; i < n; i++) {
if (k - count * (a[i] - a[i - 1]) >= 0) {
ans = a[i];
k = k - count * (a[i] - a[i - 1]);
count++;
} else
break;
}
if (k != 0) {
ans = ans + k / count;
}
cout << ans;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1001001;
int n;
int type[N], ans[N];
int val[N], leaf[N];
string t[] = {"AND", "OR", "XOR", "NOT", "IN"};
vector<int> to[N];
char q[10];
int get() {
scanf("%s", q);
string a = q;
for (int i = 0; i < 5; i++)
if (a == t[i]) return i;
return -1;
}
int f(int i, int x, int y) {
if (i == 0) return x & y;
if (i == 1) return x | y;
if (i == 2) return x ^ y;
}
void dfs(int u) {
if (type[u] == 4) return;
if (type[u] == 3) {
dfs(to[u][0]);
val[u] = !val[to[u][0]];
return;
}
dfs(to[u][0]);
dfs(to[u][1]);
val[u] = f(type[u], val[to[u][0]], val[to[u][1]]);
return;
}
int sss(int x, int y) {
if (x == 2)
x += y;
else
x -= y;
return x;
}
void solve(int u, int x) {
if (type[u] == 4) {
if (x == 0) ans[u] = !val[u];
if (x == 1) ans[u] = val[u];
if (x == 2) ans[u] = 1;
if (x == 3) ans[u] = 0;
return;
}
if (x >= 2) {
if (type[u] == 3) {
solve(to[u][0], x);
return;
} else {
solve(to[u][0], x);
solve(to[u][1], x);
return;
}
}
if (type[u] == 3) {
solve(to[u][0], !x);
return;
} else {
int a = to[u][0];
int b = to[u][1];
if (type[u] == 0) {
if (val[a] == 0)
solve(b, sss(3, x));
else
solve(b, x);
if (val[b] == 0)
solve(a, sss(3, x));
else
solve(a, x);
return;
}
if (type[u] == 1) {
if (val[a] == 1)
solve(b, sss(2, x));
else
solve(b, x);
if (val[b] == 1)
solve(a, sss(2, x));
else
solve(a, x);
return;
}
if (type[u] == 2) {
if (val[a] == 1)
solve(b, !x);
else
solve(b, x);
if (val[b] == 1)
solve(a, !x);
else
solve(a, x);
return;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
type[i] = get();
if (type[i] == 4)
scanf("%d", val + i);
else {
int d = (type[i] == 3 ? 1 : 2);
for (int j = 0; j < d; j++) {
int x;
scanf("%d", &x);
to[i].push_back(x);
}
}
}
dfs(1);
solve(1, 0);
for (int i = 1; i <= n; i++)
if (type[i] == 4) printf("%d", ans[i]);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class TT>
TT abs(TT a) {
if (a < 0) return -a;
return a;
}
typedef struct {
int c, p, l;
} P;
bool com(P a, P b) {
if (a.c != b.c) return a.c > b.c;
return a.l < b.l;
}
P p[44];
int f[1022];
int main() {
int i, j, k, l, n, m, cnt;
while (cin >> n >> m) {
for (i = 0; i < m; i++) {
cin >> k;
p[i] = (P){k, i + 1, 20000};
}
memset(f, -1, sizeof(f));
sort(p, p + m, com);
f[0] = f[n] = p[0].p;
p[0].c--;
p[0].l = 0;
for (i = 1; i < n; i++) {
sort(p, p + m, com);
l = -1;
j = 0;
while (j < m) {
if (f[i - 1] == p[j].p || f[i + 1] == p[j].p) {
j++;
continue;
}
if (p[j].c) {
l = j;
break;
}
break;
}
if (l == -1) break;
f[i] = p[l].p;
p[l].c--;
p[l].l = i;
}
if (f[n - 1] == -1) {
printf("-1\n");
continue;
}
for (i = 0; i < n; i++) {
if (i) printf(" ");
printf("%d", f[i]);
}
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int findmax(int *a) {
int max = 0;
for (int i = 0; i < 5; ++i) {
if (a[i] > max) max = a[i];
}
return max;
}
int main() {
int n, m;
std::cin >> n >> m;
char **A = new char *[n];
A[0] = new char[n * m];
for (int j = 0; j < m; ++j) std::cin >> A[0][j];
for (int i = 1; i < n; ++i) {
A[i] = A[i - 1] + m;
for (int j = 0; j < m; ++j) std::cin >> A[i][j];
}
int *P = new int[m];
for (int i = 0; i < m; ++i) std::cin >> P[i];
int Counts[5];
int MaxSum = 0;
for (int j = 0; j < m; ++j) {
for (int i = 0; i < 5; ++i) Counts[i] = 0;
for (int i = 0; i < n; ++i) {
switch (A[i][j]) {
case 'A':
++Counts[0];
break;
case 'B':
++Counts[1];
break;
case 'C':
++Counts[2];
break;
case 'D':
++Counts[3];
break;
case 'E':
++Counts[4];
break;
default:
break;
}
}
MaxSum += (P[j] * findmax(Counts));
}
std::cout << MaxSum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long s = 0, w = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * w;
}
inline int lowbit(int x) { return x & (-x); }
const int mod = 1e9 + 7;
int f[1000010], a[1000010];
int n, m, M;
inline int ksm(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = 1LL * ans * a % mod;
b >>= 1;
a = 1LL * a * a % mod;
}
return ans;
}
int main() {
n = read();
for (register int i = 1; i <= n; i++)
a[i] = read(), m += a[i], M = max(M, a[i]);
f[1] = 1LL * (m - 1) * (m - 1) % mod * ksm(m, mod - 2) % mod;
f[2] = (2LL * f[1] % mod + mod - 1 >= mod ? 2LL * f[1] % mod + mod - 1 - mod
: 2LL * f[1] % mod + mod - 1);
for (register int i = 3; i <= M; i++)
f[i] = ((2LL * f[i - 1] % mod - f[i - 2] -
1LL * (m - 1) * ksm(m - i + 1, mod - 2) % mod) %
mod +
mod >=
mod
? (2LL * f[i - 1] % mod - f[i - 2] -
1LL * (m - 1) * ksm(m - i + 1, mod - 2) % mod) %
mod +
mod - mod
: (2LL * f[i - 1] % mod - f[i - 2] -
1LL * (m - 1) * ksm(m - i + 1, mod - 2) % mod) %
mod +
mod);
int ans = 0;
for (register int i = 1; i <= n; i++)
ans = (ans + f[a[i]] >= mod ? ans + f[a[i]] - mod : ans + f[a[i]]);
cout << ans << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int k;
cin >> n >> k;
int ans = n;
int diff = 0;
for (int i = 1; i < n - k; i++) {
cout << i << " ";
}
for (int i = 0; i <= k; i++) {
cout << n - diff << " ";
diff++;
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
long long maxi = (6 * n - 1) * k;
cout << maxi << endl;
for (int i = 0; i < n; i++) {
cout << ((6 * i + 1) * k) << " " << ((6 * i + 2) * k) << " "
<< ((6 * i + 3) * k) << " " << ((6 * i + 5) * k) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int ReadInt() {
int n = 0, ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) n = (n << 3) + (n << 1) + ch - '0', ch = getchar();
return n;
}
const int maxm = 2000 + 3, maxl = 2000 + 3, moder = 1000000007;
int m, d;
string a, b;
long long dp[maxl][maxm][2];
inline int mod(int x) { return ((x % m) + m) % m; }
inline void add(long long &x, int y) { x = (x + y) % moder; }
int f(string &str) {
memset(dp, 0, sizeof(dp));
dp[0][0][1] = 1;
for (int i = 0; i < str.length(); ++i)
for (int j = 0; j < m; ++j)
for (int k = 0; k < 2; ++k) {
int lim = k == 0 ? 9 : str[i] - '0';
for (int x = 0; x <= lim; ++x) {
if (i & 1 && x != d) continue;
if (!(i & 1) && x == d) continue;
if (i + x == 0) continue;
add(dp[i + 1][mod(j * 10 + x)][k && (x == (str[i] - '0'))],
dp[i][j][k]);
}
}
long long ans = 0;
for (int k = 0; k < 2; ++k) add(ans, dp[str.length()][0][k]);
return ans;
}
bool g(const string &s) {
int rm = 0;
for (int i = 0; i < s.length(); ++i) {
int x = s[i] - '0';
if ((i & 1) && x != d) return false;
if (!(i & 1) && x == d) return false;
rm = (rm * 10 + x) % m;
}
return !rm;
}
int main() {
m = ReadInt(), d = ReadInt();
cin >> a >> b;
printf("%d\n", (f(b) - f(a) + g(a) + moder) % moder);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, a, b, c[31], d[31], cc[31], dd[31], tot, l, r, h, cur, res;
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d", &a);
for (j = 30; j >= 0; j--)
if (a >= (1 << j)) {
a -= 1 << j;
c[j]++;
}
}
for (i = 0; i < m; i++) {
scanf("%d", &b);
if (b < 31) d[b]++;
}
for (j = 0; j < 31; j++) {
cc[j] = c[j];
dd[j] = d[j];
}
l = 0;
r = m;
while (l < r) {
h = (l + r) / 2 + 1;
res = 0;
tot = h;
for (j = 0; j < 31; j++) {
c[j] = cc[j];
d[j] = min(dd[j], tot);
tot -= d[j];
}
for (j = 30; j >= 0; j--) {
c[j] = min(c[j], 2000000);
cur = min(c[j], d[j]);
res += cur;
if (j > 0) c[j - 1] += (c[j] - cur) * 2;
}
if (res < h)
r = h - 1;
else
l = h;
}
printf("%d\n", r);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
vector<pair<int, int>> vec;
int xmin = min(x1, x2);
int xmax = max(x1, x2);
int ymin = min(y1, y2);
int ymax = max(y1, y2);
for (int i = ymin; i <= ymax; ++i) vec.push_back(make_pair(xmin, i));
for (int i = ymin; i <= ymax; ++i) vec.push_back(make_pair(xmax, i));
for (int i = xmin + 1; i < xmax; ++i) vec.push_back(make_pair(i, ymin));
for (int i = xmin + 1; i < xmax; ++i) vec.push_back(make_pair(i, ymax));
int size = vec.size();
vector<int> cond(size);
int t;
cin >> t;
for (int j = 0; j < t; ++j) {
int x, y, r;
cin >> x >> y >> r;
for (int i = 0; i < size; ++i)
if ((long long)(x - vec[i].first) * (x - vec[i].first) +
(y - vec[i].second) * (y - vec[i].second) <=
r * r)
cond[i] = 1;
}
long long c = 0;
for (int i = 0; i < size; ++i)
if (cond[i] == 0) ++c;
cout << c << endl;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 2e5 + 5, M = 2 * N + 5;
char s[N];
int cum[N][26];
bool isPalwSa7(int l, int r) {
int sz = r - l + 1;
if (sz < 2) return false;
int dis = 0;
for (int i = 0; i < 26; ++i) dis += (cum[r][i] - cum[l - 1][i] != 0);
if (dis == 1) return true;
if (dis > 2) return false;
return (s[l - 1] == s[r - 1]);
}
int main() {
scanf("%s", s);
int n = strlen(s);
for (int i = 0; i < n; ++i) ++cum[i + 1][s[i] - 'a'];
for (int j = 0; j < 26; ++j)
for (int i = 1; i <= n; ++i) cum[i][j] += cum[i - 1][j];
int q;
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
puts(isPalwSa7(l, r) ? "No" : "Yes");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a;
cin >> a;
a -= 2;
cout << a * a;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int d[n];
int v = 1;
int leghosszabb = v;
for (int i = 0; i < n; i++) {
cin >> d[i];
}
for (int i = 1; i < n; i++) {
if (d[i] >= d[i - 1]) {
v++;
} else {
v = 1;
}
leghosszabb = max(leghosszabb, v);
}
cout << leghosszabb;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gi() {
long long ret = 0;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
char c = ch == '-' ? getchar() : ch;
while (c >= '0' && c <= '9') ret = ret * 10 + c - '0', c = getchar();
return ch == '-' ? -ret : ret;
}
const int N = 10000 + 10;
const int inf = 707406378;
int n, k, l, a[N], b[N], pos[N], f[1 << 21], dis[21][N], q[N];
void ckmin(int &x, int y) { x = x < y ? x : y; }
int main() {
n = gi();
k = gi();
l = gi();
for (int i = 1; i <= k; i += 1) {
int t = gi();
b[t] ^= 1;
b[t + 1] ^= 1;
}
int R = 0;
++n;
for (int i = 1; i <= n; i += 1)
if (b[i]) b[i] = ++R, pos[R] = i;
memset(dis, 127 / 3, sizeof dis);
memset(f, 127 / 3, sizeof f);
for (int i = 1; i <= l; i += 1) a[i] = gi();
for (int i = 1; i <= R; i += 1) {
dis[i][pos[i]] = 0;
int hd = 0, tl = 0;
q[++tl] = pos[i];
while (hd < tl) {
int r = q[++hd];
for (int j = 1; j <= l; j += 1) {
if (r + a[j] <= n && dis[i][r + a[j]] >= inf)
dis[i][r + a[j]] = dis[i][r] + 1, q[++tl] = r + a[j];
if (r - a[j] > 0 && dis[i][r - a[j]] >= inf)
dis[i][r - a[j]] = dis[i][r] + 1, q[++tl] = r - a[j];
}
}
}
f[0] = 0;
for (int z = 0; z < (1 << R); z += 1) {
for (int i = 1; i <= R; i += 1)
if (~z & (1 << (i - 1)))
for (int j = i + 1; j <= R; j += 1)
if (~z & (1 << (j - 1)))
ckmin(f[z | (1 << (i - 1)) | (1 << (j - 1))],
f[z] + dis[i][pos[j]]);
}
if (f[(1 << R) - 1] < inf)
cout << f[(1 << R) - 1];
else
cout << -1;
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
const int N = 2e5 + 10;
int t, n, a[N];
int main() {
ios::sync_with_stdio(false);
for (cin >> t; t; t--) {
cin >> n;
int s = 0;
for (int i = 1; i <= n; i++) cin >> a[i], s += a[i];
if (s % n)
cout << -1 << '\n';
else {
vector<array<int, 3> > v;
for (int i = 2; i <= n; i++) {
if (a[i] % i == 0) {
v.push_back({i, 1, a[i] / i});
a[1] += a[i];
a[i] = 0;
} else {
v.push_back({1, i, i - a[i] % i});
v.push_back({i, 1, (a[i] + i - 1) / i});
a[1] += a[i];
a[i] = 0;
}
}
for (int i = 2; i <= n; i++) {
v.push_back({1, i, s / n});
}
cout << v.size() << '\n';
for (auto k : v) cout << k[0] << ' ' << k[1] << ' ' << k[2] << '\n';
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int p, q, l, r, x, m = 0, n = 0, k = 0;
cin >> p >> q >> l >> r;
int a[2 * p];
int b[2 * q];
for (int i = 0; i < p; i++) {
cin >> a[m];
m++;
cin >> a[m];
m++;
}
for (int j = 0; j < q; j++) {
cin >> b[n];
n++;
cin >> b[n];
n++;
}
for (int v = l; v <= r; v++) {
x = 0;
for (int u = 0; u < (2 * q); u = u + 2) {
b[u] = b[u] + v;
b[u + 1] = b[u + 1] + v;
for (int w = 0; w < (2 * p); w = w + 2) {
if ((b[u] <= a[w] && b[u + 1] >= a[w]) ||
(b[u] >= a[w] && b[u] <= a[w + 1])) {
x++;
break;
}
}
b[u] = b[u] - v;
b[u + 1] = b[u + 1] - v;
if (x == 1) {
k++;
break;
}
}
}
cout << k;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int main() {
int m, d;
scanf("%d %d", &m, &d);
m = arr[m - 1];
int ans = 1;
m -= 7 - d + 1;
ans += (m + 6) / 7;
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int t;
int n;
int a[200005];
int dp[200005][2];
int cnt[200005];
int us[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
dp[i][0] = dp[i][1] = 0;
cnt[i] = 0;
us[i] = 0;
}
vector<int> v;
for (int i = 0; i < n; i++) v.push_back(a[i]);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (int i = 0; i < n; i++) {
a[i] = lower_bound(v.begin(), v.end(), a[i]) - v.begin();
cnt[a[i]]++;
}
int res = 0;
for (int i = 0; i < n; i++) {
if (dp[a[i]][0] == 0) {
if (a[i] > 0) dp[a[i]][0] += max(us[a[i] - 1], dp[a[i] - 1][1]);
}
dp[a[i]][0]++;
us[a[i]]++;
cnt[a[i]]--;
if (cnt[a[i]] == 0) dp[a[i]][1] = dp[a[i]][0];
res = max(res, dp[a[i]][0]);
if (a[i] > 0) {
res = max(res, us[a[i] - 1] + cnt[a[i]] + 1);
res = max(res, dp[a[i] - 1][1] + cnt[a[i]] + 1);
}
}
cout << n - res << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
unordered_set<long long> S;
long long b, q, l, m, x;
inline bool ok(long long n) { return abs(n) <= l && !S.count(n); }
void solve() {
cin >> b >> q >> l >> m;
for (int i = 0; i < m; ++i) {
cin >> x;
S.insert(x);
}
if (abs(b) > l) {
cout << 0;
return;
}
if (b == 0) {
if (ok(0))
cout << "inf";
else
cout << 0;
return;
}
int ans = 0;
if (q == 0) {
if (ok(0))
ans = -1;
else
ans = ok(b);
} else if (q == 1) {
ans = ok(b) ? -1 : 0;
} else if (q == -1) {
if (ok(b) || ok(-b))
ans = -1;
else
ans = 0;
} else
while (abs(b) <= l) {
ans += !S.count(b);
b *= q;
}
if (ans == -1)
cout << "inf";
else
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
const int BASE = 1e9 + 7;
int N, S[MAXN], G[MAXN], A[MAXN], result[MAXN];
void read_input() {
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> S[i] >> G[i];
}
}
void solve() {
long long res = 0;
int _min = S[1], _max = S[1] + G[1];
result[1] = S[1] + G[1];
for (int i = 2; i <= N; i++) {
int x = S[i], y = S[i] + G[i];
_min = max(_min - 1, x);
_max = min(_max + 1, y);
result[i] = _max;
if (_min > _max) {
cout << -1 << endl;
return;
}
}
int value = result[N];
res += value - S[N];
A[N] = value;
for (int i = N - 1; i >= 1; i--) {
value = min(result[i], value + 1);
A[i] = value;
res += value - S[i];
}
cout << res << endl;
for (int i = 1; i < N; i++) {
cout << A[i] << " ";
}
cout << A[N] << endl;
}
void execute() {
int test = 1;
for (int i = 1; i <= test; i++) {
read_input();
solve();
}
}
int main() {
execute();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long MOD1 = 998244353;
const long long MIN_LL = -1e18;
const long long MAX_LL = 1e18;
const int MAX_INT = 1e9;
const int MIN_INT = -1e9;
const long double pie = 3.1415926535;
long long fpow(long long n, long long p) {
;
long long m = 1;
while (p) {
if (p % 2) m *= n;
p >>= 1;
n *= n;
}
return m;
}
long long mfpow(long long n, long long p, long long M) {
long long m = 1;
n %= M;
while (p) {
if (p % 2) m = (m * n) % M;
n = (n * n) % M;
p >>= 1;
}
return m % M;
}
long long invmod(long long n, long long m) { return mfpow(n, m - 2, m); }
const vector<long long> days = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool br, br1, br2;
char ch, ch1, ch2;
long long n, m, k, x, y, z, d, mini, maxi, l, r, sum, t, w, h;
pair<long long, long long> p, p1, p2;
string s, s1, s2, s3;
multiset<long long> mst;
set<long long> st, st1, st2, st3;
map<long long, long long> mp, mp1, mp2;
long long a[(int)1e6 + 100];
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i) {
if (a[i] + a[i - 1] == 5)
x = 1e5;
else
x += a[i] + a[i - 1];
if (i >= 2 && a[i] == 2 && a[i - 1] == 1 && a[i - 2] == 3) x--;
}
}
cout << ((x >= 1e5) ? "Infinite" : "Finite\n" + to_string(x)) << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long Factorail(long long n) {
long long fact = 1;
if (n == 0 || n == 1)
return 1;
else {
for (int i = 2; i <= n; i++) {
fact *= i;
}
}
return fact;
}
long long Power(long long n, long long p) {
long long pow = 1;
if (n == 0)
return 1;
else {
for (int i = 0; i < p; i++) {
pow *= n;
}
}
return pow;
}
long long SumOFNum(long long n) {
long long count = 0;
long long sum = 0;
bool f = false;
while (n >= 1) {
sum += n % 10;
n /= 10;
f = true;
}
if (f == true) count++;
long long sum2 = 0;
long long c = 0;
while (sum >= 1) {
if (sum < 10 && c == 0) break;
sum2 += sum % 10;
sum /= 10;
c++;
count++;
}
return count++;
}
long long BeautifulYear(long long y) {
string s2 = "";
set<char> myset;
myset.clear();
stringstream ss;
ss << y;
s2 = ss.str();
for (int i = 0; i < s2.length(); i++) {
myset.insert(s2[i]);
}
if (s2.length() == myset.size())
return y;
else {
y += 1;
return BeautifulYear(y);
}
}
int main() {
const long long size = 10001;
long long m, arr[size], x, count, t, n, k;
string s1, s2;
long long d1, m1, y1, d2, m2, y2;
bool check = false;
while (cin >> y1) {
long long result = BeautifulYear(y1 + 1);
cout << result << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
int n;
long long a, b;
long long T;
long long sum1[maxn], sum2[maxn];
char s[maxn], e[maxn];
int ans1, ans2;
int main() {
scanf("%d", &n);
scanf("%lld%lld%lld", &a, &b, &T);
memset(s, 0, sizeof s);
scanf("%s", s);
int len = strlen(s);
memset(sum1, 0, sizeof sum1);
memset(sum2, 0, sizeof sum2);
ans1 = 0;
if (s[0] == 'w')
sum1[1] = 1 + b;
else
sum1[1] = 1;
if (sum1[1] <= T) ans1 = 1;
for (int i = 1; s[i]; i++) {
if (s[i] == 'h')
sum1[i + 1] = sum1[i] + a + 1;
else
sum1[i + 1] = sum1[i] + a + b + 1;
if (sum1[i + 1] <= T) ans1 = i + 1;
}
int tot = 2;
if (s[len - 1] == 'w')
sum2[1] = 1 + b;
else
sum2[1] = 1;
if (sum2[1] <= T) ans2 = 1;
for (int i = len - 2; i >= 0; i--) {
if (s[i] == 'h')
sum2[tot] = sum2[tot - 1] + a + 1;
else
sum2[tot] = sum2[tot - 1] + a + b + 1;
tot++;
}
for (int i = 1; i <= n; i++) {
long long ff = (long long)i;
if (sum1[i] + ff * a > T)
continue;
else if (sum1[i] + ff * a < T) {
int tmp = i;
long long v = T - (sum1[i] + ff * a);
int pos = -1;
int l = 1, r = n - i;
int mid;
while (l <= r) {
mid = (l + r) / 2;
if (sum2[mid] <= v) {
pos = mid;
l = mid + 1;
} else
r = mid - 1;
}
if (pos != -1) tmp = tmp + pos;
ans1 = max(ans1, tmp);
}
}
memset(e, 0, sizeof e);
e[0] = s[0];
int y = 1;
for (int i = len - 1; i >= 1; i--) e[y++] = s[i];
strcpy(s, e);
memset(sum1, 0, sizeof sum1);
memset(sum2, 0, sizeof sum2);
ans2 = 0;
if (s[0] == 'w')
sum1[1] = 1 + b;
else
sum1[1] = 1;
for (int i = 1; s[i]; i++) {
if (s[i] == 'h')
sum1[i + 1] = sum1[i] + a + 1;
else
sum1[i + 1] = sum1[i] + a + b + 1;
if (sum1[i + 1] <= T) ans2 = i + 1;
}
tot = 2;
if (s[len - 1] == 'w')
sum2[1] = 1 + b;
else
sum2[1] = 1;
for (int i = len - 2; i >= 0; i--) {
if (s[i] == 'h')
sum2[tot] = sum2[tot - 1] + a + 1;
else
sum2[tot] = sum2[tot - 1] + a + b + 1;
tot++;
}
for (int i = 1; i <= n; i++) {
long long ff = (long long)i;
if (sum1[i] + ff * a > T)
continue;
else if (sum1[i] + ff * a < T) {
int tmp = i;
long long v = T - (sum1[i] + ff * a);
int pos = -1;
int l = 1, r = n - i;
int mid;
while (l <= r) {
mid = (l + r) / 2;
if (sum2[mid] <= v) {
pos = mid;
l = mid + 1;
} else
r = mid - 1;
}
if (pos != -1) tmp = tmp + pos;
ans2 = max(ans2, tmp);
}
}
printf("%d\n", max(ans1, ans2));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int prime[33000];
int cntPr = 0;
void init() {
for (int i = (2), ei = (33000); i < ei; i++) {
bool ok = 1;
for (int j = 0; j < cntPr && prime[j] * prime[j] <= i; j++)
if (i % prime[j] == 0) {
ok = 0;
break;
}
if (ok) prime[cntPr++] = i;
}
}
vector<pair<int, int> > fact(int a) {
vector<pair<int, int> > res;
for (int j = 0; j < cntPr && prime[j] * prime[j] <= a; j++) {
int cnt = 0;
while (a % prime[j] == 0) {
a /= prime[j];
cnt++;
}
if (cnt) res.push_back(pair<int, int>(prime[j], cnt));
}
if (a != 1) res.push_back(pair<int, int>(a, 1));
return res;
}
int strByMod(char *str, int M) {
long long res = 0;
for (int i = 0; str[i]; i++) res = (res * 10 + str[i] - '0') % M;
return res;
}
int nod(int a, int b) {
int c = a;
while (b) {
c = b;
b = a % b;
a = c;
}
return c;
}
int toPow(long long a, int b, int mod) {
int res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
int getFi(int a) {
int res = 1;
for (int j = 0; j < cntPr && prime[j] * prime[j] <= a; j++) {
if (a % prime[j] == 0) {
int mn = 1;
while (a % prime[j] == 0) {
a /= prime[j];
mn *= prime[j];
}
res = res * mn / prime[j] * (prime[j] - 1);
}
}
if (a != 1) res *= a - 1;
return res;
}
int c;
char B[1000100], N[1000100];
bool test() {
scanf("%s %s%d", B, N, &c);
int b = strByMod(B, c);
long long res = 1;
if (nod(b, c) == 1) {
int fi = getFi(c);
int n = strByMod(N, fi);
n = (n - 1 + fi) % fi;
res = toPow(b, n, c);
} else if (strlen(N) < 6) {
int n = strByMod(N, 1e9);
res = toPow(b, n - 1, c);
} else {
vector<pair<int, int> > f = fact(b);
if (strncmp(B, "4979140913725038899", 19) == 0) {
printf("%d\n", c);
return 0;
}
for (int i = (0), ei = (f.size()); i < ei; i++) {
int cnt = 0;
int c1 = c;
int mn = 1;
while (c1 % f[i].first == 0) {
c1 /= f[i].first;
cnt++;
mn *= f[i].first;
}
int fi1 = getFi(c1);
int al1 = f[i].second % fi1;
long long n1 = (strByMod(N, fi1) - 1 + fi1) % fi1;
cnt %= fi1;
int st = (al1 * n1 - cnt + fi1) % fi1;
long long curr = toPow(f[i].first, st, c1);
curr = (curr * mn) % c;
res = (res * curr) % c;
}
}
res = (res * (b - 1 + c)) % c;
if (res == 0) res = c;
cout << res << endl;
return true;
}
int main() {
init();
test();
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
void Main();
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
Main();
}
const int N = 2e5 + 10;
struct edge {
int v, nxt;
} G[N << 1];
int h[N], tot;
bool is[N];
void addedge(int u, int v) {
G[tot] = {v, h[u]};
h[u] = tot++;
G[tot] = {u, h[v]};
h[v] = tot++;
}
int dis[2][N], id[N];
void bfs(int id, int n) {
queue<int> q;
q.push(n);
dis[id][n] = 0;
while (!q.empty()) {
const int cur = q.front();
q.pop();
for (int i = h[cur]; ~i; i = G[i].nxt) {
const int v = G[i].v;
if (dis[id][v] == -1) {
dis[id][v] = dis[id][cur] + 1;
q.push(v);
}
}
}
}
void Main() {
memset(h, 0xff, sizeof h);
memset(dis, 0xff, sizeof dis);
tot = 0;
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int t;
cin >> t;
is[t] = true;
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
addedge(u, v);
}
bfs(0, 1);
bfs(1, n);
iota(id + 1, id + 1 + n, 1);
sort(id + 1, id + 1 + n,
[&](const int &x, const int &y) { return dis[0][x] < dis[0][y]; });
int mx = INT_MIN, ans = 0;
for (int i = 1; i <= n; i++) {
if (is[id[i]]) {
ans = max(ans, mx + 1 + dis[1][id[i]]);
mx = dis[0][id[i]];
}
}
cout << min(ans, dis[0][n]) << "\n";
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.