solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
inline long long md(long long m, long long v) { return ((v % m) + m) % m; }
const int MAX = 8200;
const int NOT = 1e9;
void solve() {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
vector<vector<int> > idx(MAX + 1);
for (int i = 0; i < n; i++) {
idx[arr[i]].push_back(i);
}
vector<int> dp(MAX + 1, NOT);
dp[0] = -1;
for (int a = 1; a <= MAX; a++) {
int I = a % 2, J = 1 - I;
if ((int)(idx[a]).size() == 0) continue;
int upper = idx[a].back();
dp[a] = min(dp[a], idx[a].front());
for (int b = 1; b <= MAX; b++) {
int target = a ^ b;
if (target > MAX) continue;
if (dp[target] < upper) {
int where =
int(lower_bound((idx[a]).begin(), (idx[a]).end(), dp[target]) -
begin(idx[a]));
dp[b] = min(dp[b], idx[a][where]);
}
}
}
vector<int> ans;
for (int i = 0; i <= MAX; i++) {
if (dp[i] != NOT) ans.push_back(i);
}
cout << (int)(ans).size() << "\n";
for (int i : ans) cout << i << ' ';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, s;
long long p;
vector<long long> a, b, k;
long long f(long long x) {
if (x < 0) return -1;
long long ans = 0;
long long y = p - x;
x *= s;
y *= s;
for (long long i = 0; i < n; ++i) {
long long t = k[i];
if (a[i] > b[i]) {
long long d = min(t, x);
ans += d * a[i];
x -= d;
t -= d;
ans += t * b[i];
y -= t;
} else {
long long d = min(t, y);
ans += d * b[i];
y -= d;
t -= d;
ans += t * a[i];
x -= t;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> s;
a.resize(n);
b.resize(n);
k.resize(n);
long long c = 0;
vector<pair<int, pair<int, int> > > v(n);
vector<int> a1(n), k1(n), b1(n);
for (long long i = 0; i < n; ++i) {
cin >> k[i] >> a[i] >> b[i];
a1[i] = a[i];
b1[i] = b[i];
k1[i] = k[i];
v[i] = {abs(b[i] - a[i]), {max(a[i], b[i]), i}};
c += k[i];
}
sort(v.rbegin(), v.rend());
for (int i = 0; i < n; ++i) {
k[i] = k1[v[i].second.second];
a[i] = a1[v[i].second.second];
b[i] = b1[v[i].second.second];
}
for (int i = 0; i < n; ++i) {
}
p = ceil(1.0 * c / s);
long long l = -1, r = p + 1, EPS = 1;
while (r - l >= EPS) {
long long m1 = l + (r - l) / 3, m2 = r - (r - l) / 3;
if (f(m1) < f(m2)) {
l = m1 + 1;
} else
r = m2 - 1;
}
cout << max(f(l), f(r));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to, pre;
} e[100005 * 2];
int h[100005] = {0}, cou = 0, sz[100005], ms[100005], sum, rt, col[100005];
bool vis[100005];
void Addedge(int from, int to) {
cou++;
e[cou] = ((Edge){to, h[from]});
h[from] = cou;
}
void calc(int x, int fa) {
sz[x] = 0;
int i, v;
for (i = h[x]; i; i = e[i].pre) {
v = e[i].to;
if (!vis[v] && v != fa) {
calc(v, x);
sz[x] += sz[v];
}
}
sz[x]++;
}
void getr(int x, int fa) {
sz[x] = ms[x] = 0;
int i, v;
for (i = h[x]; i; i = e[i].pre) {
v = e[i].to;
if (!vis[v] && v != fa) {
getr(v, x);
ms[x] = max(ms[x], sz[v]);
sz[x] += sz[v];
}
}
sz[x]++;
ms[x] = max(ms[x], sum - sz[x]);
if (ms[x] < ms[rt]) rt = x;
}
void fz(int x, int depth) {
int i, v;
vis[x] = 1;
col[x] = depth;
for (i = h[x]; i; i = e[i].pre) {
v = e[i].to;
if (!vis[v]) {
calc(v, x);
rt = 0;
sum = sz[v];
getr(v, x);
fz(rt, depth + 1);
}
}
}
vector<int> G[100005], son[100005];
int out[100005], num[100005];
pair<int, int> bg[100005];
stack<int> s;
bool cmp(int a, int b) { return bg[a] < bg[b]; }
int main() {
int n, m, i, j, k, a, b, cnt = 0, x;
cin >> n >> m;
for (i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
if (a > b) swap(a, b);
G[a].push_back(b);
}
cnt++;
bg[1] = make_pair(n, 1);
s.push(1);
for (i = 1; i <= n; i++) {
while (out[i]) {
cnt++;
bg[cnt] = make_pair(i, s.top());
k = s.size();
for (j = 0; j < son[k].size(); j++) {
Addedge(cnt, son[k][j]);
Addedge(son[k][j], cnt);
}
son[k].clear();
s.pop();
son[k - 1].push_back(cnt);
out[i]--;
}
sort(G[i].begin(), G[i].end());
reverse(G[i].begin(), G[i].end());
for (j = 0; j < G[i].size(); j++) {
x = G[i][j];
out[x]++;
s.push(i);
}
}
k = 1;
for (j = 0; j < son[k].size(); j++) {
Addedge(1, son[k][j]);
Addedge(son[k][j], 1);
}
son[k].clear();
s.pop();
for (i = 1; i <= cnt; i++) num[i] = i;
sort(num + 1, num + 1 + cnt, cmp);
ms[0] = cnt + 1;
rt = 0;
sum = cnt;
getr(1, 0);
fz(rt, 1);
for (i = 1; i <= cnt; i++) {
printf("%d ", col[num[i]]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
long long p[maxn], q[maxn], c[maxn], n, a, b;
int cmp(int x, int y) { return x > y; }
int main() {
cin >> n >> a >> b;
int t = a + b;
for (int i = 0; i < n; i++) {
cin >> p[i];
}
for (int i = 0; i < n; i++) {
cin >> q[i];
}
for (int i = 0; i < n; i++) {
c[i] = abs(p[i] - q[i]);
}
sort(c, c + n, cmp);
while (t) {
c[0] = abs(c[0] - 1);
t--;
sort(c, c + n, cmp);
}
long long res = 0;
for (int i = 0; i < n; i++) {
res += c[i] * c[i];
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, first, sec, c = 0;
cin >> n;
vector<int> v;
vector<int> u;
while (n--) {
cin >> a >> b;
v.push_back(a);
u.push_back(b);
}
for (int i = 0; i < v.size(); i++) {
for (int j = 0; j < u.size(); j++) {
if (v[i] == u[j]) {
c += 1;
}
}
}
cout << c;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, p;
vector<long long> v;
long long pp(long long g) {
if (g < 0)
return g = g * (-1);
else
return g;
}
int main() {
cin >> n >> a;
for (int i = 1; i <= n; i++) {
cin >> p;
v.push_back(p);
}
sort(v.begin(), v.end());
long long ans = 1000000000;
if (n == 1) {
cout << "0" << endl;
return 0;
}
if (n == 2) {
ans = min(pp(a - v[0]), pp(a - v[1]));
cout << ans << endl;
return 0;
}
if (v[n - 2] <= a && v[n - 1] >= a) {
ans = min(ans, pp(v[0] - a));
ans = min(ans, 2 * pp(v[1] - a) + pp(v[n - 1] - a));
ans = min(ans, pp(v[1] - a) + 2 * pp(v[n - 1] - a));
cout << ans << endl;
return 0;
}
if (v[n - 1] < a) {
ans = min(ans, pp(v[1] - a));
cout << ans << endl;
return 0;
}
if (v[1] >= a && v[0] <= a) {
ans = min(ans, pp(v[n - 1] - a));
ans = min(ans, 2 * pp(v[n - 2] - a) + pp(v[0] - a));
ans = min(ans, pp(v[n - 2] - a) + 2 * pp(v[0] - a));
cout << ans << endl;
return 0;
}
if (v[0] > a) {
ans = min(ans, pp(v[n - 2] - a));
cout << ans << endl;
return 0;
}
ans = min(ans, 2 * pp(a - v[0]) + pp(a - v[n - 2]));
ans = min(ans, pp(a - v[0]) + 2 * pp(a - v[n - 2]));
ans = min(ans, 2 * pp(a - v[n - 1]) + pp(a - v[1]));
ans = min(ans, pp(a - v[n - 1]) + 2 * pp(a - v[1]));
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 7340033;
long long n, k;
long long DP[100][1009], dp[100][1009];
long long DFS(int h, int k);
long long dfs(int h, int k) {
long long &d = dp[h][k];
if (~d) return d;
d = 0;
for (int i = 0; i <= k; i++)
d = (d + DFS(h - 1, i) * DFS(h - 1, k - i)) % mod;
return d;
}
long long DFS(int h, int k) {
long long &d = DP[h][k];
if (~d) return d;
if (h == 0) {
if (k == 0) return d = 1;
return d = 0;
}
if (k == 0) return 1;
d = 0;
for (int i = 0; i < k; i++) d = (d + dfs(h, i) * dfs(h, k - 1 - i)) % mod;
return d;
}
void pre() {
memset(dp, -1, sizeof(dp));
memset(DP, -1, sizeof(DP));
for (int i = 0; i <= 30; i++)
for (int j = 0; j <= 1000; j++) DFS(i, j);
}
int main() {
int w;
cin >> w;
pre();
while (w--) {
int n, k;
cin >> n >> k;
int cnt = 0;
while (n > 1 && (n & 1)) cnt++, n >>= 1;
cout << DFS(cnt, k) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T Bigmod(T b, T p, T m) {
if (p == 0)
return 1;
else if (!(p & 1))
return (Bigmod(b, p / 2, m)) * (Bigmod(b, p / 2, m)) % m;
else
return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
int checkprime(int n) {
long long ck = 0;
for (int j = 2; j * j <= n; j++) {
if (n % j == 0) {
ck = 1;
break;
}
}
if (ck == 0)
return 1;
else
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
if (checkprime(n))
cout << "1" << endl;
else if (n % 2 == 0) {
cout << "2";
} else if (checkprime(n - 2))
cout << "2" << endl;
else
cout << "3" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> gr[500 * 1000 + 10];
vector<int> dep[500 * 1000 + 10];
char s[500 * 1000 + 10];
int depthx[500 * 1000 + 10];
int in[500 * 1000 + 10], out[500 * 1000 + 10];
int timex = 1;
void dfstime(int v, int d) {
in[v] = timex++;
for (int i = 0; i < (int)gr[v].size(); ++i) {
int to = gr[v][i];
dep[d].push_back(to);
depthx[to] = d;
dfstime(to, d + 1);
}
out[v] = timex++;
}
bool isOk(int v, int pr) { return in[pr] < in[v] && out[pr] > out[v]; }
bool isLeft(int v, int pr) { return out[v] < in[pr]; }
map<pair<int, int>, int> mem;
int let[26];
void run(int h, int v) {
int l = 0, r = (int)dep[h].size() - 1;
int left = -1;
while (l <= r) {
int m = l + r >> 1;
if (isOk(dep[h][m], v)) {
left = m;
r = m - 1;
} else if (isLeft(dep[h][m], v)) {
l = m + 1;
} else {
r = m - 1;
}
}
if (left == -1) {
mem[make_pair(h, v)] = 1;
puts("Yes");
return;
}
int right = -1;
l = 0;
r = (int)dep[h].size() - 1;
while (l <= r) {
int m = l + r >> 1;
if (isOk(dep[h][m], v)) {
right = m;
l = m + 1;
} else if (isLeft(dep[h][m], v)) {
l = m + 1;
} else {
r = m - 1;
}
}
if (right == -1) {
mem[make_pair(h, v)] = 1;
puts("Yes");
return;
}
memset(let, 0, sizeof(let));
for (int k = left; k <= right; ++k) {
int vnum = dep[h][k];
let[s[vnum] - 'a']++;
}
int x = 0;
for (int i = 0; i < 26; ++i) {
x += let[i] & 1;
}
if (x <= 1) {
mem[make_pair(h, v)] = 1;
puts("Yes");
} else {
mem[make_pair(h, v)] = -1;
puts("No");
}
}
int main() {
int totvertex, totqueries;
scanf("%d %d", &totvertex, &totqueries);
for (int i = 1; i < totvertex; ++i) {
int v;
scanf("%d", &v);
v--;
gr[v].push_back(i);
}
scanf("%s", s);
dfstime(0, 1);
for (int i = 0; i < totqueries; ++i) {
int v, h;
scanf("%d %d", &v, &h);
v--;
h--;
if (depthx[v] >= h) {
puts("Yes");
continue;
}
int x = mem[make_pair(h, v)];
if (x == 1) {
puts("Yes");
continue;
}
if (x == -1) {
puts("No");
continue;
}
run(h, v);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int K;
string S;
bool usd[256] = {};
vector<int> stf;
cin >> K >> S;
for (size_t i = 0; i < S.size(); i++) {
if (stf.size() < K && !usd[S[i]]) {
usd[S[i]] = true;
stf.push_back(i);
}
}
if (stf.size() < K) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (int i = 0; i < K; i++)
cout << S.substr(stf[i], i == K - 1 ? 999 : stf[i + 1] - stf[i]) << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
int a[100005], b[100005], c[100005], d[100005];
map<int, int> id;
vector<int> vp[100005 * 2];
int cmp(int x, int y) {
if (b[x] == b[y]) return x < y;
return b[x] > b[y];
}
int ans[100005];
int M;
int T[1 << 20];
int getMin(int x, int y) { return b[x] < b[y] ? x : y; }
void update(int l, int id) {
l += M;
T[l] = id;
while (l > 1) {
T[l >> 1] = getMin(T[l], T[l ^ 1]);
l >>= 1;
}
}
int qy(int l, int r) {
int ans = 0;
for (l = l + M - 1, r = r + M + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (~l & 1) ans = getMin(ans, T[l ^ 1]);
if (r & 1) ans = getMin(ans, T[r ^ 1]);
}
return ans;
}
void fmain() {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++)
scanf("%d%d%d%d", a + i, b + i, c + i, d + i);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
id[a[i]];
id[c[i]];
}
int cnt = 1;
for (auto &p : id) p.second = cnt++;
id[0];
for (int(i) = 1; (i) <= (int)(n); (i)++) {
a[i] = id[a[i]];
c[i] = id[c[i]];
}
for (int(i) = 1; (i) <= (int)(n); (i)++) vp[a[i]].push_back(i);
for (int(i) = 1; (i) <= (int)(cnt); (i)++)
sort(vp[i].begin(), vp[i].end(), cmp);
for (M = 1; cnt + 2 > M; M <<= 1)
;
b[0] = (1 << 30);
for (int(i) = 1; (i) <= (int)(cnt); (i)++)
if (!vp[i].empty()) {
update(i, vp[i].back());
vp[i].pop_back();
}
queue<pair<pair<int, int>, int>> q;
q.push({{1, 0}, 0});
memset(ans, -1, sizeof ans);
while (!q.empty()) {
int ta = q.front().first.first, tb = q.front().first.second;
int preId = q.front().second;
q.pop();
while (1) {
int tmp = qy(1, ta);
if (tmp == 0) break;
if (b[tmp] > tb) break;
ans[tmp] = preId;
int nxt = 0;
if (!vp[a[tmp]].empty()) {
nxt = vp[a[tmp]].back();
vp[a[tmp]].pop_back();
}
update(a[tmp], nxt);
q.push({{c[tmp], d[tmp]}, tmp});
}
}
if (ans[n] == -1)
puts("-1");
else {
vector<int> vv;
for (int i = n; i > 0; i = ans[i]) {
vv.push_back(i);
}
printf("%d\n", vv.size());
for (int j = vv.size() - 1; j >= 0; j--) printf("%d ", vv[j]);
}
}
int main() {
fmain();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N, K, H;
int weight[100010], v[100010], id[100010];
vector<pair<pair<int, int>, int> > p;
int ans[100010], ans2[100010];
bool check(double t) {
int i, j = 0;
for ((i) = 0; (i) < (int)(K); (i)++) {
while (j < N && v[j] < (i + 1.0) / t) j++;
if (j == N) return false;
ans2[i] = j;
j++;
}
for ((i) = 0; (i) < (int)(K); (i)++) ans[i] = ans2[i];
return true;
}
int main(void) {
int iter, i;
scanf("%d%d%d", &N, &K, &H);
for ((i) = 0; (i) < (int)(N); (i)++) scanf("%d", &weight[i]);
for ((i) = 0; (i) < (int)(N); (i)++) scanf("%d", &v[i]);
for ((i) = 0; (i) < (int)(N); (i)++)
p.push_back(make_pair(make_pair(weight[i], v[i]), i));
sort(p.begin(), p.end());
for ((i) = 0; (i) < (int)(N); (i)++) {
v[i] = p[i].first.second;
id[i] = p[i].second;
}
double low = 0.0, high = 1.0E+6, mid;
for ((iter) = 0; (iter) < (int)(100); (iter)++) {
double mid = (high + low) / 2.0;
if (check(mid))
high = mid;
else
low = mid;
}
for ((i) = 0; (i) < (int)(K); (i)++) {
printf("%d", id[ans[i]] + 1);
if (i == K - 1)
printf("\n");
else
printf(" ");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct xy {
xy() : x(0), y(0) {}
xy(int x, int y) : x(x), y(y) {}
int x, y;
};
bool compx(xy a, xy b) {
if (a.x < b.x)
return true;
else
return false;
}
bool compy(xy a, xy b) {
if (a.y < b.y)
return true;
else
return false;
}
int main(int argc, const char* argv[]) {
int cases;
cin >> cases;
while (cases--) {
int num;
scanf("%d", &num);
vector<xy> coords;
coords.push_back(xy(0, 0));
for (int i = 0; i < num; ++i) {
int x, y;
scanf("%d%d", &x, &y);
coords.push_back(xy(x, y));
}
sort(coords.begin(), coords.end(), compx);
stable_sort(coords.begin(), coords.end(), compy);
string out;
bool ok = true;
for (int i = 1; i <= num; ++i) {
int diffx = coords[i].x - coords[i - 1].x;
int diffy = coords[i].y - coords[i - 1].y;
if (diffx < 0 || diffy < 0) {
ok = false;
break;
}
while (diffx--) out += 'R';
while (diffy--) out += 'U';
}
if (ok) {
cout << "YES" << endl;
cout << out << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, T b) {
return b > a ? a = b, 1 : 0;
}
inline int read() {
int x(0), sgn(1);
char ch(getchar());
for (; !isdigit(ch); ch = getchar())
if (ch == '-') sgn = -1;
for (; isdigit(ch); ch = getchar()) x = (x * 10) + (ch ^ 48);
return x * sgn;
}
void File() {}
const int N = 5e5 + 1e3, Blk = 1010, Mod = 19260817;
int n, Hash[N];
char str[N];
bitset<N> dp[Blk];
bitset<Mod> Table;
int main() {
File();
n = read();
scanf("%s", str + 1);
int lim = min(1000, int(sqrt(n)) * 2), ans = 1;
for (register int i = (1), iend = (int)(n); i <= iend; ++i)
dp[1][i] = true, Hash[i] = str[i] - 'a' + 1;
for (register int i = (2), iend = (int)(lim); i <= iend; ++i) {
Table.reset();
for (register int j = (n - i + 1), jend = (int)(1); j >= jend; --j) {
if (dp[i - 1][i + j]) Table[Hash[i + j]] = true;
if (Table[Hash[j]] || Table[Hash[j + 1]]) ans = i, dp[i][j] = true;
}
for (register int j = (1), jend = (int)(n - i + 1); j <= jend; ++j)
Hash[j] = (Hash[j] * 233ll + (str[i + j - 1] - 'a' + 1)) % Mod;
}
printf("%d\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int vis[500045];
std::vector<int> a[500045];
std::vector<int> order;
void dfs1(int pos, int par) {
if (vis[pos]) return;
vis[pos] = 1;
order.push_back(pos);
for (int i = 0; i < a[pos].size(); i++) {
if (a[pos][i] != par) {
dfs1(a[pos][i], pos);
}
}
}
int dfs(int pos, int par) {
int deg = 1;
if (par == 0) {
deg = 0;
}
for (int i = 0; i < a[pos].size(); i++) {
if (a[pos][i] == par) continue;
deg += dfs(a[pos][i], pos);
}
if (deg % 2 == 0) {
a[pos].push_back(par);
dfs1(pos, par);
return 0;
} else {
return 1;
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int p[n];
for (int i = 1; i <= n; i++) {
cin >> p[i];
if (p[i] == 0) continue;
a[i].push_back(p[i]);
a[p[i]].push_back(i);
}
dfs(1, 0);
if (order.size() != n) {
cout << "NO\n";
return 0;
} else {
cout << "YES\n";
for (int i = 0; i < n; i++) {
cout << order[i] << " ";
}
cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dp[5005][5005], f1[5005], f2[5005], f3[5005];
char s1[5005], s2[5005];
void Calc(char *a, char *b, int dp[][5005], int f[]) {
int n = strlen(a), m = strlen(b);
for (int i = n; i >= 0; i--)
for (int j = m; j >= 0; j--) {
if (i == n || j == m)
dp[i][j] = 0;
else if (a[i] == b[j])
dp[i][j] = 1 + dp[i + 1][j + 1];
else
dp[i][j] = 0;
}
for (int i = (0); i < (n); i++) {
f[i] = 1;
for (int j = (0); j < (n); j++)
if (j != i) f[i] = max(f[i], 1 + dp[i][j]);
}
}
int main() {
scanf("%s%s", s1, s2);
Calc(s1, s1, dp, f1);
Calc(s2, s2, dp, f2);
Calc(s1, s2, dp, f3);
int n = strlen(s1), m = strlen(s2), ret = n + m, f = 1;
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++)
if (dp[i][j] >= f1[i] && dp[i][j] >= f2[j]) {
f = 0;
ret = min(ret, max(f1[i], f2[j]));
}
if (f)
printf("-1\n");
else
printf("%d\n", ret);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const long long Inf = 1e10;
const int P = 1e9 + 7;
const int N = 10005;
inline long long IN() {
long long x = 0;
int ch = 0, f = 0;
for (ch = getchar(); ch != -1 && (ch < 48 || ch > 57); ch = getchar())
f = (ch == '-');
for (; ch >= 48 && ch <= 57; ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return f ? (-x) : x;
}
template <typename T>
inline int chkmin(T &a, const T &b) {
if (b < a) return a = b, 1;
return 0;
}
template <typename T>
inline int chkmax(T &a, const T &b) {
if (b > a) return a = b, 1;
return 0;
}
void renew(int &x, const int &y) {
x += y;
if (x >= P) x -= P;
if (x < 0) x += P;
}
int Pow(int x, int y, int p) {
int a = 1;
for (; y; y >>= 1, x = (long long)x * x % p)
if (y & 1) a = (long long)a * x % p;
return a;
}
int n, m, fr;
int perm[N];
struct po {
double x, y, nrm;
int c;
po() {}
po(double x, double y, int z) : x(x), y(y), c(z) { nrm = x * x + y * y; }
po operator-(const po &a) const { return po(x - a.x, y - a.y, c); }
} A[N], B[N], C[N << 1];
struct eve {
double x;
int pr;
} S[N << 1];
int tot;
void Ins(double l, double r, int w) {
if (w == 1) {
S[++tot] = (eve){l, -3};
S[++tot] = (eve){r, 3};
} else {
S[++tot] = (eve){l, -1};
S[++tot] = (eve){r, 1};
}
}
void Insert(double l, double r, int w) {
if (l < 0) l += 2 * M_PI;
if (l >= 2 * M_PI) l -= 2 * M_PI;
if (r < 0) r += 2 * M_PI;
if (r >= 2 * M_PI) r -= 2 * M_PI;
if (l < +r) {
Ins(l, r, w);
} else {
Ins(l, 2 * M_PI, w);
Ins(0, r, w);
}
}
int cmp(const eve &a, const eve &b) {
if (a.x != b.x) return a.x < b.x;
return a.pr < b.pr;
}
int cnt, flag;
int check(double rad) {
tot = 0;
for (int j = (int)(1); j <= (int)(cnt); j++) {
double d = sqrt(C[j].nrm);
if (C[j].nrm > 4 * rad * rad) continue;
if (C[j].c && C[j].nrm >= 4 * rad * rad) continue;
double a = atan2(C[j].y, C[j].x);
double b = acos(d / (2 * rad));
Insert(a - b, a + b, C[j].c);
}
if (!flag) {
S[++tot] = (eve){0, -1};
}
sort(S + 1, S + tot + 1, cmp);
int totr = 0, totb = 0;
for (int i = (int)(1); i <= (int)(tot); i++) {
if (totr && !totb) return 1;
if (S[i].x == 2 * M_PI) break;
if (S[i].pr == -1) totr++;
if (S[i].pr == 1) totr--;
if (S[i].pr == -3) totb++;
if (S[i].pr == 3) totb--;
if (totr && !totb) return 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (int)(1); i <= (int)(n); i++) {
int x, y;
scanf("%d%d", &x, &y);
A[i] = po(x, y, 0);
}
for (int i = (int)(1); i <= (int)(m); i++) {
int x, y;
scanf("%d%d", &x, &y);
B[i] = po(x, y, 1);
}
for (int i = (int)(1); i <= (int)(n); i++) perm[i] = i;
random_shuffle(perm + 1, perm + n + 1);
double ans = 0;
for (int i = (int)(1); i <= (int)(n); i++) {
int fr = perm[i];
flag = 0;
cnt = 0;
for (int j = (int)(1); j <= (int)(n); j++)
if (j ^ fr) C[++cnt] = A[j] - A[fr];
for (int j = (int)(1); j <= (int)(m); j++) C[++cnt] = B[j] - A[fr];
if (!check(ans)) continue;
if (check(1e15)) {
puts("-1");
return 0;
}
double r = ans + 1;
for (; check(r); r *= 2)
;
double l = ans;
for (int i = (int)(1); i <= (int)(60); i++) {
double md = (l + r) / 2;
if (check(md)) {
l = md;
} else {
r = md;
}
}
ans = l;
}
for (int i = (int)(1); i <= (int)(m); i++) perm[i] = i;
random_shuffle(perm + 1, perm + m + 1);
for (int i = (int)(1); i <= (int)(m); i++) {
int fr = perm[i];
flag = 1;
cnt = 0;
for (int j = (int)(1); j <= (int)(n); j++) C[++cnt] = A[j] - B[fr];
for (int j = (int)(1); j <= (int)(m); j++)
if (j ^ fr) C[++cnt] = B[j] - B[fr];
if (!check(ans)) continue;
if (check(1e15)) {
puts("-1");
return 0;
}
double r = ans + 1;
for (; check(r); r *= 2)
;
double l = ans;
for (int i = (int)(1); i <= (int)(60); i++) {
double md = (l + r) / 2;
if (check(md)) {
l = md;
} else {
r = md;
}
}
ans = l;
}
printf("%.20lf\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> in;
int MAX = -1;
void update() {
stack<int> S;
S.push(1000000010);
for (int i = N - 1; i >= 0; --i) {
while (in[i] > S.top()) S.pop();
if (S.top() != 1000000010) (MAX) = max((MAX), (S.top() ^ in[i]));
S.push(in[i]);
}
}
int main() {
scanf("%d", &N);
in.resize(N);
for (int i = 0; i < N; ++i) scanf("%d", &in[i]);
update();
reverse(in.begin(), in.end());
update();
cout << MAX << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int x;
vector<int> v;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
v.push_back(x);
}
vector<int> vv(n);
vv[n - 1] = v[n - 1];
for (int i = n - 2; i >= 0; i--) vv[i] = min(v[i], vv[i + 1]);
for (int i = 0; i < v.size(); i++) {
int ans = lower_bound(vv.begin() + i, vv.end(), v[i]) - vv.begin() - i - 2;
if (ans < -1)
printf("-1 ");
else
printf("%d ", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 500000;
const int MAX_C = 200000;
const int MOD = 1000003;
int fs[MAX_N + MAX_C + 1], invfs[MAX_N + MAX_C + 1];
int powmod(int a, int n) {
int pm = 1;
while (n > 0) {
if (n & 1) pm = (long long)pm * a % MOD;
a = (long long)a * a % MOD;
n >>= 1;
}
return pm;
}
inline int nck(int n, int k) {
return (long long)fs[n] * invfs[n - k] % MOD * invfs[k] % MOD;
}
void prepare_fracs(int n) {
fs[0] = invfs[0] = 1;
for (int i = 1; i <= n; i++) {
fs[i] = (long long)fs[i - 1] * i % MOD;
invfs[i] = powmod(fs[i], MOD - 2);
}
}
int main() {
int n, c;
scanf("%d%d", &n, &c);
prepare_fracs(n + c);
int sum = 0;
for (int i = 1; i <= n; i++) sum = (sum + nck(i + c - 1, c - 1)) % MOD;
printf("%d\n", sum);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed long long int a[200001], n, m, i, x, k;
signed long long int cautbin(signed long long int val) {
signed long long int step = (1 << 18), start = 0;
for (; step; step >>= 1) {
signed long long int index = step + start;
if (index > n) continue;
if (a[index] <= val) start = index;
}
return start;
}
int main() {
cin >> n;
cin >> m;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (i = 1; i <= m; i++) {
cin >> x;
cout << cautbin(x) << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string str;
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cin >> str;
for (int i = 0; i <= str.size() - 1; i++) {
if (str[i] == '1' || (str[i] == '4' && i > 0 && str[i - 1] == '1') ||
(str[i] == '4' && i > 1 && str[i - 1] == '4' && str[i - 2] == '1')) {
continue;
} else {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
for (int i = 1; i <= 1000000000; i++) {
if (i % 2 == 1) {
if (a >= i) {
a -= i;
} else {
cout << "Vladik";
return 0;
}
} else {
if (b >= i) {
b -= i;
} else {
cout << "Valera";
return 0;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (i % 2 == 1 && j % 2 == 1)
printf("W");
else if (i % 2 == 0 && j % 2 == 0)
printf("W");
else
printf("B");
}
printf("\n");
}
return 0;
}
| 1 |
//author: mr_detective
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0);
#define endl "\n"
#define MOD 1000000007
#define ll long long int
int main(){
IOS;
ll t;
cin >> t;
while(t--){
ll n;
cin >> n;
ll a[n+1] , b[n+1] ,t[n+1] , arrival =0, depart =0 ,wait , traveltime ;
a[0] = 0 , b[0] = 0, t[0] = 0;
for (ll i = 1; i <= n; ++i)
{
cin >> a[i] >> b[i];
}
for (ll i = 1; i <=n; ++i)
{
cin>> t[i];
}
for (ll i = 1; i <= n; i++)
{
arrival = abs(a[i] - b[i-1]) + t[i] + depart;
wait = ceil((double)(abs(a[i] - b[i]))/2);
depart = max(arrival+wait , (ll)b[i]);
}
cout << arrival << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> graph, tgraph;
vector<bool> vis;
vector<int> cost, order, scc;
int n, m;
long long amount, ways;
void dfs1(int u) {
vis[u] = true;
for (auto to : graph[u])
if (!vis[to]) dfs1(to);
order.push_back(u);
}
void dfs2(int u) {
vis[u] = true;
scc.push_back(u);
for (auto to : tgraph[u])
if (!vis[to]) dfs2(to);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
graph.resize(n + 1);
tgraph.resize(n + 1);
vis.resize(n + 1, false);
cost.resize(n + 1);
amount = 0;
ways = 1;
for (int i = 1; i <= n; i++) cin >> cost[i];
cin >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
graph[u].push_back(v);
tgraph[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs1(i);
vis.assign(n + 1, false);
for (auto i = order.rbegin(); i != order.rend(); i++) {
if (!vis[*i]) {
dfs2(*i);
int temp = INT_MAX, lowNodes = 0;
for (auto x : scc) temp = min(temp, cost[x]);
amount += temp;
for (auto x : scc)
if (cost[x] == temp) lowNodes++;
ways *= lowNodes % 1000000007;
scc.clear();
}
}
cout << amount << " " << ways % 1000000007;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const double eps = 0.000001;
int q(int i, int j, vector<int> &ps) {
if (i > j) return 0;
if (i) return ps[j] - ps[i - 1];
return ps[j];
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
vector<int> ps(n + 1, 0);
int ans = 0;
for (int i = 0; i < n; i++) {
ps[i + 1] = ps[i] + (int)(s[i] == 'a');
}
for (int i = 0; i < n; i++) {
for (int j = i; j <= n; j++) {
int cr = i - q(0, i, ps) + (n - j) - q(j + 1, n, ps) + q(i + 1, j, ps);
ans = max(ans, n - cr);
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, po[22][3], l, r;
double dp[1 << 20];
const double pi = acos(-1);
const double eps = 1e-7;
double cal(double l, double x, double y, double a) {
double afa = a * 1.0 / 180 * pi;
if (abs(a - 90) < eps && x <= l) return r;
if (l - x > eps) {
double theta = atan((l - x) / y);
if ((theta + afa - pi / 2) > eps) return r;
double res = y * tan(theta + afa) + x;
if (res - r > eps)
return r;
else
return res;
} else {
double theta = atan((x - l) / y);
double res = x + y * tan(afa - theta);
if (res - r > eps)
return r;
else
return res;
}
}
int main() {
cin >> n >> l >> r;
for (int i = 0; i < n; i++) cin >> po[i][0] >> po[i][1] >> po[i][2];
dp[0] = l;
double ans = l;
int lim = 1 << n;
for (int i = 1; i < lim; i++) {
dp[i] = l;
for (int j = 0; j < n; j++)
if (i & (1 << j)) {
double rr = cal(dp[i ^ (1 << j)], po[j][0], po[j][1], po[j][2]);
if (dp[i] <= rr) dp[i] = rr;
}
if (ans < dp[i]) ans = dp[i];
}
printf("%.8lf\n", ans - l);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 111;
int a[maxn], b[maxn], c[maxn], id[maxn], d[111][2009], pre[111][2009], num = 0;
void pri(int xx, int mx) {
if (xx == 0) {
printf("%d\n", num);
return;
}
if (pre[xx][mx] != mx) num++;
pri(xx - 1, pre[xx][mx]);
if (pre[xx][mx] != mx) {
printf("%d ", id[xx]);
}
}
int main() {
int n, mx = 0, ma = 0, xx;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
id[i] = i;
}
sort(id + 1, id + n + 1, [](int x, int y) { return b[x] < b[y]; });
int sum = 0;
for (int i = 1; i <= n; ++i) {
int x = id[i];
for (int k = 0; k < 2009; ++k) d[i][k] = d[i - 1][k], pre[i][k] = k;
for (int j = b[x]; j > a[x]; --j) {
if (d[i - 1][j - a[x]] + c[x] > d[i][j]) {
d[i][j] = d[i - 1][j - a[x]] + c[x];
pre[i][j] = j - a[x];
}
}
}
for (int i = 0; i < 2009; ++i) {
if (d[n][i] > ma) ma = d[n][i], mx = i;
}
printf("%d\n", ma);
pri(n, mx);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 1000 * 1000 * 1000 + 7;
const int N = 100005;
const double PI = acos(-1.0);
const double eps = 1e-9;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
struct LIS_T {
int n, *a, dep[N], f[N], c[N], cnt, t;
vector<int> V[N];
inline void Clear() {
for (int i = (0); i <= (n); ++i)
dep[i] = 0, f[i] = -1, c[i] = 0, V[i].clear();
cnt = 0;
}
inline void I(int x) {
t = dep[x] = lower_bound(c + 1, c + cnt + 1, x) - c;
c[t] = x, V[t].push_back(x), f[x] = c[t - 1], cnt += (t > cnt);
}
inline void Build() {
for (int i = (1); i <= (n); ++i) I(a[i]);
}
inline void Init(int _a[], int _n) {
a = _a, n = _n;
Clear();
Build();
}
};
LIS_T T;
int n, m, a[N], _T, cnt;
vector<int> ans[N];
bool v[N];
inline void Del() {
for (int x = T.c[T.cnt]; x; x = T.f[x]) v[x] = 0;
m = n, n = 0, ans[++cnt].clear();
for (int i = (1); i <= (m); ++i)
if (v[a[i]])
a[++n] = a[i];
else
ans[cnt].push_back(a[i]);
}
int main() {
scanf("%d", &_T);
while (_T--) {
scanf("%d", &n), cnt = 0;
for (int i = (1); i <= (n); ++i) scanf("%d", &a[i]), v[i] = 1;
while (n) {
T.Init(a, n);
if ((long long)T.cnt * (T.cnt + 1) / 2 > n)
Del();
else {
for (int i = (1); i <= (T.cnt); ++i) ans[++cnt] = T.V[i];
break;
}
}
printf("%d\n", cnt);
for (int i = (1); i <= (cnt); ++i) {
printf("%d", ans[i].size());
for (auto t : ans[i]) printf(" %d", t);
printf("\n");
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
string mon[] = {"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"};
int main() {
string month;
int n, s;
while (cin >> month >> s) {
for (n = 0; n < 12; n++) {
if (mon[n] == month) break;
}
cout << mon[(n + s) % 12] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int t, n, p, c[200005], d[200005];
long long a[200005], b[200005], ans;
map<long long, int> mm;
inline void updatec(int x) {
for (; x <= p; x += (x & -x)) ++c[x];
return;
}
inline int getc(int x) {
int res = 0;
for (; x; x -= (x & -x)) res += c[x];
return res;
}
inline void updated(int x) {
for (; x; x -= (x & -x)) ++d[x];
return;
}
inline int getd(int x) {
int res = 0;
for (; x <= p; x += (x & -x)) res += d[x];
return res;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> t;
while (t--) {
ans = p = 0;
mm.clear();
cin >> n;
memset(c, 0, sizeof c), memset(d, 0, sizeof d);
for (int i = 1; i <= n; i++) cin >> a[i], b[i] = a[i];
sort(b + 1, b + n + 1);
for (int i = 1; i <= n; i++)
if (!mm[b[i]]) mm[b[i]] = ++p;
for (int i = 1; i <= n; i++) {
if (getc(mm[a[i]] - 1) < getd(mm[a[i]] + 1)) {
ans += getc(mm[a[i]] - 1);
} else {
ans += getd(mm[a[i]] + 1);
}
updatec(mm[a[i]]), updated(mm[a[i]]);
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int v[21];
void main2() {
int n, a, b;
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int ans = 0;
bool can = 1;
for (int i = 0; i < n / 2; i++) {
if (v[i] != 2 || v[n - 1 - i] != 2) {
if (v[i] != 2 && v[n - 1 - i] != 2)
can &= (v[i] == v[n - 1 - i]);
else {
if (v[i] == 0 || v[n - 1 - i] == 0) ans += a;
if (v[i] == 1 || v[n - 1 - i] == 1) ans += b;
}
} else {
ans += 2 * min(a, b);
}
}
if ((n & 1) && v[n / 2] == 2) ans += min(a, b);
cout << (can ? ans : -1) << endl;
}
int main() {
main2();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long fpow(long long n, long long k, long long p = 1000000007) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
long long inv(long long a, long long p = 1000000007) {
return fpow(a, p - 2, p);
}
long long Sqrt(long long x) {
if (x == 0 || x == 1) return x;
long long start = 1, end = x, ans;
while (start <= end) {
long long mid = (start + end) / 2;
if (mid * mid == x) return mid;
if (mid * mid < x) {
start = mid + 1;
ans = mid;
} else
end = mid - 1;
}
return ans;
}
long long power(long long x, long long y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return power(x, y / 2) * power(x, y / 2);
else
return x * power(x, y / 2) * power(x, y / 2);
}
long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
void in(long long &no) {
bool neg = false;
register long long c;
no = 0;
c = getchar();
if (c == '-') {
neg = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) no = no * 10 + c - 48;
if (neg) no *= -1;
}
long long maxx(long long a, long long b) {
if (a > b) return a;
return b;
}
int main() {
long long i, n, k, x;
cin >> n;
vector<long long> v1, v2;
v1.push_back(1);
v2.push_back(1e6);
for (int i = (0); i < (n); i++) {
cin >> x;
if (x > 500000) {
v2.push_back(x);
} else
v1.push_back(x);
}
long long a, b;
a = (*max_element(v1.begin(), v1.end()));
b = (*min_element(v2.begin(), v2.end()));
cout << maxx(1e6 - b, a - 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s_r[300010];
int a, b, c;
char s1[300010], s2[300010];
int h1[300], h2[300];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> s1 >> s2;
int i1 = 0, i2 = 0;
int l = strlen(s1);
for (int i = 0; i < l; ++i) h1[s1[i]]++;
for (int j = 0; j < l; ++j) h2[s2[j]]++;
for (int i = 0; i < 300; ++i) {
for (; h1[i]; h1[i]--) s1[i1++] = i;
}
for (int i = 0; i < 300; ++i) {
for (; h2[i]; h2[i]--) s2[i2++] = i;
}
i1 = 0, i2 = l - 1;
int end = l - 1;
int x = 0;
int N = l;
for (int i = 0; i <= end;) {
if (x == 0) {
if (s1[i1] < s2[i2]) {
s_r[i] = s1[i1];
i1++;
++i;
} else {
s_r[end] = s1[i1 + N / 2 - (N % 2 == 0)];
end--;
}
} else {
if (s1[i1] < s2[i2]) {
s_r[i] = s2[i2];
i2--;
++i;
} else {
s_r[end] = s2[i2 - N / 2 + (N % 2 == 0)];
end--;
}
}
x ^= 1;
--N;
}
cout << s_r;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 7;
int main() {
long long t;
cin >> t;
while (t--) {
int a[N];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int l[N];
int r[N];
int k = 0;
for (int i = 0; i < n; i++) {
int mx = 0;
for (int j = 1; j < n - i; j++)
if (a[mx] < a[j]) mx = j;
if (mx != n - i - 1) {
l[k] = mx + 1;
r[k] = n - i;
k++;
int t = a[mx];
for (int j = mx; j < n - i - 1; j++) a[j] = a[j + 1];
a[n - i - 1] = t;
}
}
cout << k << endl;
for (int i = 0; i < k; i++) cout << l[i] << ' ' << r[i] << ' ' << 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, c, n, k;
scanf("%d%d%d%d\n", &r, &c, &n, &k);
int a[r][c];
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
a[i][j] = 0;
}
}
int x, y;
for (int i = 0; i < n; i++) {
scanf("%d %d\n", &x, &y);
a[x - 1][y - 1] = 1;
}
int ans = 0, lsum;
for (int r1 = 0; r1 < r; r1++)
for (int r2 = r1 + 1; r2 < r + 1; r2++)
for (int c1 = 0; c1 < c; c1++)
for (int c2 = c1 + 1; c2 < c + 1; c2++) {
lsum = 0;
for (int i = r1; i < r2; i++)
for (int j = c1; j < c2; j++) lsum += a[i][j];
if (lsum >= k) ans++;
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename Tk, typename Tv>
ostream& operator<<(ostream& os, const pair<Tk, Tv>& p) {
os << "{" << p.first << ',' << p.second << "}";
return os;
}
const int MAX = 100005;
const int INF = 1000000000;
long long power(long long n, long long m, long long MOD) {
if (m == 0) return 1;
long long x = power(n, m / 2, MOD);
if (!(m & 1))
return (x * x) % MOD;
else
return (((x * x) % MOD) * n) % MOD;
}
const long long Bi = 100000007;
const long long M = 1000000009;
const long long invB = power(Bi, M - 2, M);
long long getHash(pair<char, int> x) {
return ((x.first - 'a') * 256 + x.second) % M;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<pair<char, long long> > A, B;
for (int i = 0; i < n; i++) {
char s[2];
int count;
scanf("%d-%s", &count, s);
char c = s[0];
if (i > 0) {
if (c == A.back().first) {
A.back().second += count;
} else {
A.push_back(make_pair(c, count));
}
} else {
A.push_back(make_pair(c, count));
}
}
for (int i = 0; i < m; i++) {
char s[2];
int count;
scanf("%d-%s", &count, s);
char c = s[0];
if (i > 0) {
if (c == B.back().first) {
B.back().second += count;
} else {
B.push_back(make_pair(c, count));
}
} else {
B.push_back(make_pair(c, count));
}
}
n = A.size(), m = B.size();
if (n < m) {
cout << 0 << endl;
return 0;
}
if (m > 2) {
long long h = 0;
for (int i = m - 2; i >= 1; i--) {
h *= Bi;
h %= M;
h += getHash(B[i]);
h %= M;
}
long long g = 0;
for (int i = m - 2; i >= 1; i--) {
g *= Bi;
g %= M;
g += getHash(A[i]);
g %= M;
}
long long count = 0;
if (h == g) {
if ((A[0].first == B[0].first) && (A[m - 1].first == B[m - 1].first)) {
if ((A[0].second >= B[0].second) &&
(A[m - 1].second >= B[m - 1].second)) {
count++;
}
}
}
for (int i = m - 1; i < n - 1; i++) {
g += (M - getHash(A[i - m + 2])) % M;
g %= M;
g *= invB;
g %= M;
g += (getHash(A[i]) * power(Bi, m - 3, M)) % M;
g %= M;
if (h == g) {
if ((A[i - m + 2].first == B[0].first) &&
(A[i + 1].first == B[m - 1].first)) {
if ((A[i - m + 2].second >= B[0].second) &&
(A[i + 1].second >= B[m - 1].second)) {
count++;
}
}
}
}
printf("%lld\n", count);
} else if (m == 2) {
long long count = 0;
for (int i = 1; i < n; i++) {
if ((A[i - 1].first == B[0].first) && (A[i].first == B[1].first)) {
if ((A[i - 1].second >= B[0].second) && (A[i].second >= B[1].second)) {
count++;
}
}
}
printf("%lld\n", count);
} else {
long long count = 0;
for (int i = 0; i < n; i++) {
if (A[i].first == B[0].first) {
if (A[i].second >= B[0].second) {
count += A[i].second - B[0].second + 1;
}
}
}
printf("%lld\n", count);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
const long long mod = 1000003;
long long f[1010];
long long p(int n) {
long long res = 1ll;
for (int i = 0; i < n; i++) res = res * 2ll % mod;
return res;
}
long long calc(int n) {
if (n == 0) return 0ll;
if (n == 1) return 3ll;
long long res = p(n - 1) * p(n - 1) % mod;
res += calc(n - 1) * 3ll % mod;
res %= mod;
return f[n] = res;
}
int main() {
int n;
cin >> n;
memset(f, -1, sizeof(f));
long long a = calc(n);
long long b = p(n) * p(n) % mod;
cout << (b - a + mod) % mod << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int powmod(int a, int b) {
int tmp = 1;
for (; b; b >>= 1) {
if (b & 1) tmp = tmp * a;
a = a * a;
}
return tmp;
}
template <class T>
inline void R(T &xx) {
xx = 0;
char ch = getchar();
bool F = 0;
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') F = 1, ch = getchar();
while (ch >= '0' && ch <= '9')
xx = xx + xx + (xx << 3) + ch - 48, ch = getchar();
if (F) xx = -xx;
}
inline pair<int, int> operator+(const pair<int, int> &a,
const pair<int, int> &b) {
return make_pair(a.first + b.first, a.second + b.second);
}
inline pair<int, int> operator-(const pair<int, int> &a,
const pair<int, int> &b) {
return make_pair(a.first - b.first, a.second - b.second);
}
int n, BG, H[100011], nxt[100011], c[100011], fa[100011], g[100011];
pair<int, int> f[100011][2], An[100011], q[100011], ans;
int len, ss;
bool vis[100011];
void dp(int u) {
vis[u] = 1, f[u][0] = f[u][1] = make_pair(0, 0), g[u] = 0;
pair<int, int> mx(0, 0), t;
for (int v = H[u]; v; v = nxt[v])
if (v != BG) {
dp(v), f[u][0] = f[u][0] + f[v][1];
t = f[v][0] - f[v][1] + make_pair(1, c[u] != c[v]);
if (t > mx) mx = t, g[u] = v;
}
f[u][1] = f[u][0] + mx;
}
void get(int u, int t) {
for (int v = H[u]; v; v = nxt[v])
if (v != BG)
if (t && v == g[u])
q[ss++] = make_pair(u, v), get(v, 0);
else
get(v, 1);
}
void work(int u) {
for (; !vis[u]; u = fa[u]) vis[u] = 1;
pair<int, int> res(0, 0);
for (int i = 0; i < (int)(2); i++) {
BG = u, dp(u);
if (f[u][1] > res) res = f[u][1], ss = 0, get(u, 1);
u = fa[u];
}
ans = ans + res;
for (int i = 0; i < (int)(ss); i++) An[len++] = q[i];
}
int main() {
R(n);
for (int i = (1); i <= (n); i++)
R(fa[i]), R(c[i]), nxt[i] = H[fa[i]], H[fa[i]] = i;
for (int i = (1); i <= (n); i++)
if (!vis[i]) work(i);
printf("%d %d\n", ans.first, ans.second);
for (int i = 0; i < (int)(len); i++)
printf("%d %d\n", An[i].first, An[i].second);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
long long x, y;
};
int n, p, q;
pt projects[100000];
pt cp[100000];
int m;
bool pcmp(const pt &a, const pt &b) {
if (a.x < b.x) return true;
if (a.x > b.x) return false;
return a.y < b.y;
}
long long cross(long long vx, long long vy, long long wx, long long wy) {
return vx * wy - vy * wx;
}
bool turnsup(pt &a, pt &b, pt &c) {
return (cross(b.x - a.x, b.y - a.y, c.x - a.x, c.y - a.y) > 0);
}
void solve_testcase() {
sort(projects, projects + n, pcmp);
m = 1;
for (int i = 0; i < n; i++) {
while (i < n - 1 && projects[i + 1].x == projects[i].x) i++;
while ((m > 1 && cp[m - 1].y <= projects[i].y) ||
(m > 2 && turnsup(cp[m - 2], cp[m - 1], projects[i])))
m--;
cp[m] = projects[i];
m++;
}
cp[0].x = 0;
cp[0].y = cp[1].y;
cp[m].x = cp[m - 1].x;
cp[m].y = 0;
int l = 0;
while (cross(p, q, cp[l].x, cp[l].y) > 0) l++;
long long x1 = cp[l - 1].x;
long long y1 = cp[l - 1].y;
long long x2 = cp[l].x;
long long y2 = cp[l].y;
long long num = cross(x1 - x2, y1 - y2, (long long)p, (long long)q);
long long denom = cross(x1, y1, x2, y2);
double res =
(double)(num / denom) + ((double)(num % denom)) / ((double)denom);
printf("%.10f\n", res);
}
bool read_testcase() {
if (scanf("%d %d %d\n", &n, &p, &q) != 3) return false;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
projects[i].x = x;
projects[i].y = y;
}
return true;
}
int main(int argc, char **argv) {
if (argc > 1 && argv[1][0] != 'x') freopen(argv[1], "r", stdin);
if (argc > 2) freopen(argv[2], "w", stdout);
int T = 1;
clock_t cur, prev = clock();
while (read_testcase()) {
fprintf(stderr, ">>>Solving testcase %d<<<<\n", T);
solve_testcase();
cur = clock();
int dur = (cur - prev) * 1000 / CLOCKS_PER_SEC;
fprintf(stderr, "____Case %d done in %dms.\n", T, dur);
prev = cur;
T++;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, p, s, q, t, i, j, k, x, y, z, c, d, l, r, lst, a, b, ans, mn, mx, cnt,
l1, l2;
int main() {
cin >> t;
for (q = 0; q < t; q++) {
cin >> d;
if (d < 4 && d > 0)
cout << "N\n";
else {
cout << "Y ";
cout << setprecision(15)
<< double(double(d - sqrt(d * (d - 4))) / double(2)) << " ";
cout << setprecision(15)
<< double(d - double(d - sqrt(d * (d - 4))) / double(2)) << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
vector<pair<int, int>> b;
for (int i = 1; i <= 100; i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
if (abs(a[j] - i) > 1) sum += abs(a[j] - i) - 1;
}
b.push_back(make_pair(sum, i));
}
sort(b.begin(), b.end());
cout << b[0].second << " " << b[0].first;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<long long> v;
void solve(long long x, int l) {
if (l == 11) return;
if (x > 0) v.push_back(x);
solve(x * 10 + 4, l + 1);
solve(x * 10 + 7, l + 1);
}
int main() {
cin >> n;
solve(0, 0);
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++)
if (v[i] == n) return cout << i + 1, 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000,100000000000")
using namespace std;
const long long inf = 1e18 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-12;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
int n, m;
char s[3005][3005];
long long f[3005][3005];
long long cnt(int x, int y, int x1, int y1) {
memset(f, 0, sizeof f);
if (s[x][y] == '.') f[x][y] = 1;
for (int i = x; i <= x1; i++)
for (int j = y; j <= y1; j++)
if (f[i][j]) {
if (s[i + 1][j] == '.') f[i + 1][j] += f[i][j];
if (s[i][j + 1] == '.') f[i][j + 1] += f[i][j];
f[i + 1][j] %= mod;
f[i][j + 1] %= mod;
}
return f[x1][y1];
}
int main(void) {
scanf("%d%d", &n, &m);
gets(s[0]);
for (long long(i) = 0; (i) < (long long)(n); (i)++) gets(s[i]);
long long ans = cnt(0, 1, n - 2, m - 1) * cnt(1, 0, n - 1, m - 2) -
cnt(0, 1, n - 1, m - 2) * cnt(1, 0, n - 2, m - 1);
ans %= mod;
if (ans < 0) ans += mod;
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int main() {
long long n;
cin >> n;
long long x[n], h[n];
for (long long i = 0; i < n; i++) {
cin >> x[i] >> h[i];
}
long long ans = 0;
long long xl = -9999999999;
for (long long i = 0; i < n - 1; i++) {
if (x[i] - h[i] > xl) {
xl = x[i];
ans++;
} else if (x[i] + h[i] < x[i + 1]) {
xl = x[i] + h[i];
ans++;
}
if (xl < x[i]) xl = x[i];
}
cout << ans + 1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int d[70][70][70], ans[70][70][70];
int m, n, r;
const int INF = 1 << 30;
void floyd(int t) {
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
d[t][i][j] = min(d[t][i][j], d[t][i][k] + d[t][k][j]);
}
int main() {
cin >> n >> m >> r;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) cin >> d[i][j][k];
floyd(i);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
ans[1][i][j] = INF;
for (int k = 1; k <= m; k++) ans[1][i][j] = min(ans[1][i][j], d[k][i][j]);
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) {
ans[i][j][k] = INF;
for (int t = 1; t <= n; t++)
ans[i][j][k] = min(ans[i][j][k], ans[i - 1][j][t] + ans[1][t][k]);
}
}
int a, b, c;
while (r--) {
cin >> a >> b >> c;
c++;
if (c >= n) c = n;
cout << ans[c][a][b] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct point : pair<int, int> {
point() { cin >> first >> second; }
};
struct sum : pair<long long, long long> {
sum(long long a = 0, long long b = 0) { first = a, second = b; }
friend sum operator+(const sum& a, const point& p) {
return sum(a.first + p.first, a.second + p.second);
}
friend sum operator+(const sum& a, const sum& p) {
return sum(a.first + p.first, a.second + p.second);
}
friend sum operator/(const sum& a, int n) {
return sum(a.first / n, a.second / n);
}
friend ostream& operator<<(ostream& out, const sum& p) {
return out << p.first << ' ' << p.second;
}
};
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
int n;
cin >> n;
vector<point> x(n << 1);
cout << accumulate(x.begin(), x.end(), sum()) / n;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int ct[32];
int main() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; ++i) {
cin >> a[i];
for (long long k = 0; k < 32; ++k) {
long long x = (long long)((long long)1 << k);
if ((a[i] & x) == x) ct[k]++;
}
}
long long mx = 0;
long long ind = 0;
for (long long i = 0; i < n; ++i) {
for (long long k = 0; k < 32; ++k) {
long long x = (long long)((long long)1 << k);
if ((a[i] & x) == x) ct[k]--;
}
long long num = 0;
for (long long k = 0; k < 32; ++k) {
long long x = (long long)((long long)1 << k);
if (ct[k] > 0) {
num += x;
}
}
long long h = a[i] - (a[i] & num);
if (mx < h) {
mx = h;
ind = i;
}
for (long long k = 0; k < 32; ++k) {
long long x = (long long)((long long)1 << k);
if ((a[i] & x) == x) ct[k]++;
}
}
cout << a[ind] << " ";
for (int i = 0; i < n; ++i) {
if (i != ind) cout << a[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, m, t;
cin >> a >> m;
while (a < 10000000 && a % m) {
a += (a % m);
}
if (a % m == 0)
cout << "Yes";
else
cout << "No";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
int a[111111];
int d[111111];
void solve(istream& cin, ostream& cout) {
int n, k;
cin >> n >> k;
for (int i = (0); i < int(n); ++i) {
cin >> a[i];
--a[i];
if (a[i] == -1) {
d[i] = 1 + min(k, i) + min(k, n - i - 1);
} else {
int x1 = min(n - 1, i + k);
int x2 = min(n - 1, a[i] + k);
int x3 = 0;
if (i - a[i] - 1 > k) {
x3 = min(k, i - a[i] - 1 - k);
}
d[i] = d[a[i]] + min(x1 - i + 1, x1 - x2) + x3;
}
cout << d[i] << " ";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve(cin, cout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int fd[507][507], n, m, x, y, c = 0;
string s;
cin >> n >> m >> x >> y >> s;
cout << "1"
<< " ";
int l = s.length();
for (int i = 0; i < l - 1; i++) {
fd[x][y] = 1;
if (s[i] == 'U' && x > 1) x--;
if (s[i] == 'D' && x < n) x++;
if (s[i] == 'L' && y > 1) y--;
if (s[i] == 'R' && y < m) y++;
if (fd[x][y] == 1)
cout << "0"
<< " ";
else {
cout << "1"
<< " ";
c++;
}
}
cout << n * m - c - 1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int in[105];
int main() {
int n, l;
scanf("%d %d", &n, &l);
for (int i = 0; i < n; i++) scanf("%d", &in[i]);
int maxx = 0;
for (int h = l; h <= 100; h++) {
int w = 0;
for (int i = 0; i < n; i++) {
w += in[i] / h;
}
maxx = max(maxx, w * h);
}
printf("%d\n", maxx);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long w[100008], pref[100008];
int main() {
long long n, l, r, ql, qr;
cin >> n >> l >> r >> ql >> qr;
pref[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> w[i];
pref[i] = pref[i - 1] + w[i];
}
long long ans = 100000000000000000LL;
for (int i = 0; i <= n; i++) {
long long left_sum = pref[i];
long long right_sum = pref[n] - left_sum;
ans = min(ans, left_sum * l + right_sum * r + max(0LL, 2 * i - n - 1) * ql +
max(0LL, n - 2 * i - 1) * qr);
}
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 50, MAXM = 2e7 + 50, INF = 0x3f3f3f3f, MOD = 1e9 + 9,
BASE = 4e5;
const double eps = 1e-9;
int read() {
int cnt = 0, flag = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') flag = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
cnt = (cnt << 1) + (cnt << 3) + (c ^ 48);
c = getchar();
}
return flag * cnt;
}
void write(int x) {
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
int N, a[MAXN], cnt[31], ans[MAXN], Ans = 0;
bool check(int x) {
for (int i = 30; i >= 0; --i)
if (cnt[i] % x != 0) return false;
return true;
}
void Init() {
N = read();
for (int i = 1; i <= N; ++i) a[i] = read();
}
void Solve() {
Ans = 0;
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= N; ++i)
for (int j = 30; j >= 0; --j)
if ((a[i] >> j) & 1) ++cnt[j];
for (int i = 1; i <= N; ++i)
if (check(i)) ans[++Ans] = i;
}
void Print() {
for (int i = 1; i <= Ans; ++i) printf("%d ", ans[i]);
printf("\n");
}
int main() {
int T = read();
while (T--) {
Init();
Solve();
Print();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, k, m, n, x, y, z;
int s;
cin >> s;
for (int i = 1; i <= s; i++) {
cin >> a >> b >> c >> d >> k;
n = a / c;
if (a % c != 0) {
x = n + 1;
} else {
x = n;
}
m = b / d;
if (b % d != 0) {
y = m + 1;
} else {
y = m;
}
z = x + y;
if (z <= k) {
cout << x << " " << y << endl;
} else {
cout << "-1" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double g = 10.0, eps = 1e-12;
const int N = 3000 + 10, maxn = 90000 + 10, inf = 0x3f3f3f3f;
long long quick(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % 1000000007;
a = a * a % 1000000007;
b /= 2;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
if (n % 2 != m % 2 && k == -1) {
cout << 0 << endl;
return 0;
}
long long ans = quick(2, n - 1);
ans = quick(ans, m - 1);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long double pi = 3.14159265359;
long long gcd(long long a, long long b) {
if (b == 0) return a;
gcd(b, a % b);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int N;
cin >> N;
if (N < 6)
cout << -1 << "\n";
else if (N == 6) {
cout << 1 << " " << 2 << "\n";
cout << 2 << " " << 3 << "\n";
cout << 2 << " " << 4 << "\n";
cout << 4 << " " << 5 << "\n";
cout << 4 << " " << 6 << "\n";
} else {
cout << 1 << " " << 2 << "\n";
cout << 2 << " " << 3 << "\n";
cout << 2 << " " << 4 << "\n";
cout << 4 << " " << 5 << "\n";
cout << 4 << " " << 6 << "\n";
cout << 4 << " " << 7 << "\n";
for (int i = N - 7, j = 8; i > 0; i--, j++) {
cout << 4 << " " << j << "\n";
}
}
for (int i = 1; i <= N - 1; i++) {
cout << i << " " << i + 1 << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, x;
long long res, r2;
vector<long long> V, V2;
long long P[2][200002];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> x;
long long a = 1;
for (int i = 0; i < k; i++) a *= x;
for (int i = 0; i < n; i++) {
int b;
cin >> b;
V.push_back(b);
V2.push_back(b * a);
}
for (int i = 0; i < (int)V.size(); i++) {
res |= V[i];
P[0][i] = res;
}
res = 0;
for (int i = (int)V.size() - 1; i >= 0; i--) {
res |= V[i];
P[1][i] = res;
}
for (int i = 0; i < (int)V.size(); i++) {
long long tmp;
if (i == 0)
tmp = V2[i] | P[1][i + 1];
else
tmp = (P[0][i - 1] | V2[i]) | P[1][i + 1];
if (tmp > r2) r2 = tmp;
}
cout << r2 << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int k, n, cnt;
int a[200005];
pair<long long, pair<int, int> > t[200005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> k;
for (int seq = 1; seq <= k; ++seq) {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
long long sum = accumulate(a + 1, a + n + 1, 0ll);
for (int i = 1; i <= n; ++i) t[++cnt] = {sum - a[i], {seq, i}};
}
sort(t + 1, t + cnt + 1);
for (int i = 2; i <= cnt; ++i)
if (t[i].first == t[i - 1].first &&
t[i].second.first != t[i - 1].second.first) {
cout << "YES\n";
cout << t[i].second.first << " " << t[i].second.second << "\n";
cout << t[i - 1].second.first << " " << t[i - 1].second.second << "\n";
return 0;
}
cout << "NO\n";
}
template <typename T>
inline void read(T &x) {
char c;
bool nega = 0;
while ((!isdigit(c = getchar())) && (c != '-'))
;
if (c == '-') {
nega = 1;
c = getchar();
}
x = c - 48;
while (isdigit(c = getchar())) x = x * 10 + c - 48;
if (nega) x = -x;
}
template <typename T>
inline void writep(T x) {
if (x > 9) writep(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
writep(x);
putchar(' ');
}
template <typename T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct ht {
int x1;
int x2;
int y;
bool operator<(const ht &rhs) const { return (x1 < rhs.x1); }
};
int v[100005];
ht h[100005];
int x[100005 << 2];
int xn;
struct BIT {
int b[100005 << 2];
int n;
BIT(int _n) {
n = _n + 1;
memset(b, 0, sizeof(b));
}
void add(int x) {
while (x > 0) {
b[x]++;
x -= (x & -x);
}
}
int sum(int x) {
int ans = 0;
while (x <= n) {
ans += b[x];
x += (x & -x);
}
return (ans);
}
};
int main() {
int n, m;
memset(v, 0, sizeof(v));
memset(h, 0, sizeof(h));
memset(x, 0, sizeof(x));
scanf("%d %d", &n, &m);
xn = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &v[i]);
x[xn++] = v[i];
}
v[++n] = 1000000000;
x[xn++] = v[n++];
sort(v, v + n);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &h[i].x1, &h[i].x2, &h[i].y);
x[xn++] = h[i].x2;
}
sort(h, h + m);
sort(x, x + xn);
xn = unique(x, x + xn) - x;
BIT bt(xn);
for (int i = 0; i < m; i++) {
if (h[i].x1 == 1) {
bt.add(lower_bound(x, x + xn, h[i].x2) - x);
}
}
int i = 0;
int j = 0;
int ans = INT_MAX;
for (; i < n - 1; i++) {
ans = min(ans, bt.sum(lower_bound(x, x + xn, v[i + 1]) - x) + i);
}
printf("%d\n", ans);
return (0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[1000001];
int p[1000001];
int fa[1000001];
int e[1000001];
int fact(int x) {
int i = 0;
int s = 0;
while (x != 1 && e[i] * e[i] <= x) {
int sign = 0;
while (x % e[i] == 0) {
sign = 1;
x /= e[i];
}
if (sign) p[s++] = e[i];
++i;
}
if (x != 1) p[s++] = x;
return s;
}
void fact_p(int x) {
int i = 0;
int s = 0;
while (x != 1 && e[i] * e[i] <= x) {
int sign = 0;
while (x % e[i] == 0) {
sign = 1;
x /= e[i];
}
if (sign) a[e[i]] = 0;
++i;
}
if (x != 1) a[x] = 0;
}
int pe[1000001];
void pr(int m) {
int i = 2;
int w = 0;
while (i <= m) {
for (int j = i; j <= m; j += i) pe[j] = 1;
e[w++] = i;
while (pe[i]) ++i;
}
}
int main() {
int n, m;
scanf("%d %d\n", &n, &m);
pr(n);
for (int i = 0; i < (m); i++) {
char k;
int x;
scanf("%c %d\n", &k, &x);
if (k == '+') {
if (fa[x]) {
printf("Already on\n");
continue;
}
int s = fact(x), sign = 0;
for (int i = 0; i < (s); i++)
if (a[p[i]]) {
printf("Conflict with ");
printf("%d\n", a[p[i]]);
sign = 1;
break;
}
if (!sign) {
fa[x] = 1;
printf("Success\n");
for (int i = 0; i < (s); i++) a[p[i]] = x;
}
} else {
if (!fa[x]) {
printf("Already off\n");
continue;
}
printf("Success\n");
fa[x] = 0;
fact_p(x);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int T;
T = 1;
while (T--) {
long long int n, x;
cin >> n >> x;
std::map<long long int, long long int> m;
vector<long long int> v(n);
for (int i = 0; i < n; ++i) {
long long int x;
cin >> x;
v[i] = x;
m[x]++;
}
map<long long int, long long int> d;
d.clear();
long long int ans = 0;
for (int i = 0; i < n; ++i) {
long long int g = v[i] ^ x;
if (d[g] == 0 && d[v[i]] == 0) {
if (g == v[i]) {
ans += (m[g] * (m[g] - 1)) / 2;
} else
ans += m[g] * m[v[i]];
}
d[g] = 1;
d[v[i]] = 1;
}
cout << ans;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
n = k + 1;
map<int, int> cnt;
for (int i = 0; i < n; ++i) {
printf("? ");
for (int j = 0; j < n; ++j)
if (i != j) printf("%d ", j + 1);
printf("\n");
fflush(stdout);
int pos, val;
scanf("%d %d", &pos, &val);
++cnt[val];
}
int m = n - cnt.begin()->second;
printf("! %d\n", m);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
long long n, ar[100050], asr[100050], asn;
map<long long, int> mii;
int main(void) {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ar[i];
if (mii.count(ar[i]))
mii[ar[i]]++;
else
mii[ar[i]] = 1;
}
for (auto i : mii) {
asr[asn++] = i.first;
}
map<long long, int> mii2(mii);
for (int i = 0, j = 1; j < n; j++) {
while (i < j && mii2[asr[j]] > 0) {
while (i < j && mii[asr[i]] <= 0) i++;
if (i >= j) break;
int sub = min(mii[asr[i]], mii2[asr[j]]);
ans += sub;
mii[asr[i]] -= sub;
mii2[asr[j]] -= sub;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
cin >> n >> m;
for (i = 0; i < n; i++) {
cout << "5";
}
cout << endl;
for (i = 0; i < n - 1; i++) {
cout << "4";
}
cout << "5" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int main() {
int n, len, maxm, i, num;
char a[maxn];
while (scanf("%d", &n) != EOF) {
getchar();
gets(a);
maxm = -1;
len = strlen(a);
num = 0;
for (i = 0; i < len; i++) {
if (a[i] != ' ') {
if (a[i] >= 'A' && a[i] <= 'Z') num++;
} else {
maxm = max(num, maxm);
num = 0;
}
}
maxm = max(maxm, num);
printf("%d\n", maxm);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, c;
cin >> m >> n;
c = m * n;
cout << c / 2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long n;
int mapa[100], pos, conti;
long long divi[100], a, b, c, aa, bb, cc;
void busca(int ind) {
if (ind >= pos) {
if ((c + b - a) % 2LL == 0LL && c + b - a > 0LL) {
cc = (c + b - a) >> 1LL;
bb = c - cc;
aa = b - cc;
if (aa > 0LL && bb > 0LL && aa + bb == a) {
conti++;
}
}
} else {
long long aux = 1LL, bux = 1LL, cux = 1LL;
for (int i = 0; i <= mapa[ind]; i++) {
bux = 1LL;
for (int j = 0; j <= mapa[ind] - i; j++) {
cux = 1LL;
for (int k = 1; k <= mapa[ind] - i - j; k++) {
c *= divi[ind];
cux *= divi[ind];
}
{ busca(ind + 1); }
c /= cux;
b *= divi[ind];
bux *= divi[ind];
}
b /= bux;
a *= divi[ind];
aux *= divi[ind];
}
a /= aux;
}
}
int main() {
scanf("%I64d", &n);
if (n % 3LL != 0) {
printf("0");
return 0;
}
n /= 3LL;
pos = 0;
long long i = 2LL, aux = n;
while (i <= aux) {
int cont = 0;
while (aux % i == 0LL) {
aux /= i;
cont++;
}
if (cont > 0) {
divi[pos] = i;
mapa[pos] = cont;
pos++;
}
i++;
}
a = b = c = 1LL;
busca(0);
printf("%d", conti);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5, mod = 1e9 + 7;
int n, q, x, a[N], b[N], f[N], d[N], g[N], dp[N], t[N], ans;
set<int> s;
void M(int x, int y) {
for (; x <= 2 * n; x += x & -x) (t[x] += y) %= mod;
}
int Q(int x) {
int r = 0;
for (; x; x -= x & -x) (r += t[x]) %= mod;
return r;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i], &b[i]), f[i] = i;
sort(f + 1, f + n + 1, [&](int x, int y) { return a[x] < a[y]; });
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%d", &x), d[x] = 1, s.insert(b[x]);
for (int i = 1; i <= n; i++) {
x = f[i], g[x] = s.size() && b[x] <= *s.rbegin();
if (d[x]) s.erase(b[x]);
}
for (int i = 1; i <= n; i++)
x = f[i], M(b[x], dp[x] = (mod + g[x] + Q(2 * n) - Q(b[x])) % mod),
(ans += dp[x]) %= mod;
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)4e5 + 7;
int curnode = 2;
int par[22][N];
long long parsum[22][N];
long long last = 0;
long long weight[N];
void add(int node, long long w) {
weight[curnode] = w;
if (weight[curnode] <= weight[node]) {
par[0][curnode] = node;
} else {
int from = node;
for (int i = 20; i >= 0; i--) {
if (weight[curnode] > weight[par[i][from]]) {
from = par[i][from];
}
}
par[0][curnode] = par[0][from];
}
parsum[0][curnode] =
((par[0][curnode] == 0) ? 1e15 : weight[par[0][curnode]]);
for (int i = 1; i <= 20; i++) {
par[i][curnode] = par[i - 1][par[i - 1][curnode]];
parsum[i][curnode] =
(par[i][curnode] == 0)
? 1e15
: parsum[i - 1][curnode] + parsum[i - 1][par[i - 1][curnode]];
}
curnode++;
}
int getans(int node, long long x) {
int ans = 1;
if (weight[node] > x) {
ans = 0;
} else {
x -= weight[node];
for (int i = 20; i >= 0; i--) {
if (parsum[i][node] <= x) {
ans += (1 << i);
x -= parsum[i][node];
node = par[i][node];
}
}
}
return ans;
}
int main() {
int q;
scanf("%d", &q);
weight[0] = 1e18;
for (int i = 0; i <= 20; i++) {
parsum[i][1] = 1e15;
}
while (q--) {
int tp;
scanf("%d", &tp);
long long p, q;
scanf("%I64d %I64d", &p, &q);
if (tp == 1) {
p ^= last;
q ^= last;
add(p, q);
} else {
p ^= last;
q ^= last;
last = getans(p, q);
printf("%I64d\n", last);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, r, x, arr[20];
cin >> n >> l >> r >> x;
for (int i = 0; i < n; i++) cin >> arr[i];
int ans = 0;
for (long long i = 1 << n; i >= 0; i--) {
int sum = 0, mn = 9999999, mx = -1;
for (int j = 0; j < n; j++) {
if (((1LL) << j) & i) {
sum += arr[j];
mn = min(mn, arr[j]);
mx = max(mx, arr[j]);
}
}
if (sum >= l and sum <= r and mx - mn >= x) ans++;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
static const int maxn = 3000 + 5;
static const int maxm = 6000 + 5;
static int n, c;
static int suf[maxn], pre[maxm], tar[maxm], e;
static int vis[maxn], dep[maxn], dis[maxn];
static int deg[maxn], que[maxn], head, tail;
static double ans;
inline int read() {
int k = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
k = k * 10 + c - '0';
c = getchar();
}
return k * f;
}
void dfs(int u) {
vis[u] = 1;
for (int i = suf[u]; i; i = pre[i])
if (!vis[tar[i]]) {
dep[tar[i]] = dep[u] + 1;
if (!dis[tar[i]]) {
dis[tar[i]] = dis[u] + 1;
ans += 1.0 / dis[tar[i]];
} else
ans += 1.0 / dep[tar[i]] - 2.0 / (dis[tar[i]] + dep[tar[i]] + c - 2);
dfs(tar[i]);
}
vis[u] = 0;
}
int main() {
n = read();
for (int u, v, i = 1; i <= n; ++i) {
++deg[u = read() + 1];
++deg[v = read() + 1];
pre[++e] = suf[u], suf[u] = e, tar[e] = v;
pre[++e] = suf[v], suf[v] = e, tar[e] = u;
}
for (int i = 1; i <= n; ++i)
if (deg[i] == 1) que[tail++] = i;
while (head != tail)
for (int i = suf[que[head++]]; i; i = pre[i])
if (--deg[tar[i]] == 1) que[tail++] = tar[i];
c = n - tail;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) dis[j] = dep[j] = 0;
dis[i] = dep[i] = 1;
dfs(i);
}
printf("%.10lf", ans + n);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 4000;
int n, r[Maxn];
vector<int> a;
void input() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> r[i];
a.push_back(r[i]);
}
}
void solve() {
sort(a.begin(), a.end());
for (int i = 0; i < n; i++)
for (int j = 1; j < n + 1; j++)
if (r[i] == a[n - j]) {
cout << j << " ";
break;
}
cout << endl;
}
int main() {
input();
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200001], p, rn, cnt[200001] = {0}, rem[200001], done[200001] = {0};
int main() {
cin >> n;
for (int i = (0); i < (n); i++) {
cin >> a[i];
cnt[a[i]]++;
}
rn = 0;
for (int i = (1); i < (n + 1); i++) {
if (cnt[i] == 0) {
rem[rn++] = i;
}
}
p = 0;
for (int i = (0); i < (n); i++) {
if (p == rn) break;
if (cnt[a[i]] > 1) {
if (a[i] > rem[p] || done[a[i]]) {
cnt[a[i]]--;
cnt[rem[p]]++;
a[i] = rem[p];
p++;
} else {
done[a[i]] = 1;
}
}
}
cout << rn << '\n';
for (int i = (0); i < (n); i++) {
if (i) cout << ' ';
cout << a[i];
}
cout << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, b, p, x, y;
while (scanf("%d%d%d", &n, &b, &p) != EOF) {
y = n * p;
x = 0;
int now = 1;
while (n != 1) {
now = 1;
while (now <= n) now *= 2;
now /= 2;
x += now * b;
x += now / 2;
now /= 2;
n -= now;
}
printf("%d %d\n", x, y);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
template <class T>
T gcd(T x, T y) {
while (T t = x % y) x = y, y = t;
return y;
}
const double eps = 1e-9;
const double PI = acos(-1.);
const int INF = 1000000000;
const int MOD = 1000000007;
const double E = 2.7182818284590452353602874713527;
bool isdig(char x) { return x >= '0' && x <= '9'; }
bool isup(char x) { return x >= 'A' && x <= 'Z'; }
bool isdown(char x) { return x >= 'a' && x <= 'z'; }
bool islet(char x) { return isup(x) || isdown(x); }
struct Edge {
int u, v, w, next;
};
Edge edge[20005];
int head[105], en;
int N, D;
int val[105];
pair<int, int> pt[105];
void insert(int u, int v, int w) {
edge[en].u = u;
edge[en].v = v;
edge[en].w = w;
edge[en].next = head[u];
head[u] = en++;
}
void get_data() {
cin >> N >> D;
for (int i = 1; i <= N - 2; i++) cin >> val[i];
val[0] = 0;
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
pt[i] = make_pair(a, b);
}
for (int i = 0; i < N; i++) head[i] = -1;
en = 0;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j <= N - 1; j++) {
int w = abs(pt[i].first - pt[j].first) + abs(pt[i].second - pt[j].second);
insert(i, j, w);
insert(j, i, w);
}
}
}
int dis[105];
bool mk[105];
bool inque[105];
queue<int> que;
bool ok(int ini) {
memset(mk, 0, sizeof(mk));
memset(inque, 0, sizeof(inque));
while (((int)(que).size())) que.pop();
dis[0] = 0;
mk[0] = 1;
que.push(0);
inque[0] = 1;
val[0] = ini;
while (((int)(que).size())) {
int i, u, v;
u = que.front();
que.pop();
inque[u] = 0;
if (u == N - 1) break;
for (i = head[u]; i != -1; i = edge[i].next) {
v = edge[i].v;
if (!v) continue;
int w = dis[u] + val[u] - edge[i].w * D;
if (w < 0) continue;
if (!mk[v] || dis[v] < w) {
dis[v] = w;
mk[v] = 1;
if (!inque[v]) {
inque[v] = 1;
que.push(v);
}
}
}
}
return mk[N - 1];
}
void run() {
int h = INF, l = 0, mid;
while (h > l) {
mid = (h + l) / 2;
if (ok(mid))
h = mid;
else
l = mid + 1;
}
cout << h << endl;
}
int main() {
{
get_data();
run();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
cout << n / 2520;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 10;
int n, m;
long long c[MAXN], g[MAXN], a1[MAXN], a2[MAXN], b1[MAXN], b2[MAXN];
inline void work(long long x, int n, long long *d1, long long *d2) {
if (n == 0) {
d1[n] = d2[n] = 0;
return;
}
if (n == 1) {
d1[n] = (x == 2);
d2[n] = (x == 1);
return;
}
if (x <= c[n - 1]) {
work(x, n - 1, d1, d2);
d1[n] = min(d1[n - 1], d2[n - 1] + 2);
d2[n] = min(d2[n - 1], d1[n - 1]) + 1 + g[n - 2];
} else {
work(x - c[n - 1], n - 2, d1, d2);
d1[n] = d1[n - 2] + 1;
d2[n] = d2[n - 2];
}
}
inline long long dis(long long u, long long v, int n) {
if (n <= 1) return (u != v);
if (u <= c[n - 1]) {
if (v > c[n - 1])
return min(a1[n - 1], a2[n - 1]) + b1[n - 2] + 1;
else
return min(dis(u, v, n - 1),
min(a1[n - 1] + b2[n - 1], b1[n - 1] + a2[n - 1]) + 2);
} else
return dis(u - c[n - 1], v - c[n - 1], n - 2);
}
void lucky() {
scanf("%d %d", &m, &n);
n = min(n, 80);
}
int main() {
long long u, v;
lucky();
c[0] = 1;
c[1] = 2;
for (int i = 2; i <= n; i++) c[i] = c[i - 1] + c[i - 2];
g[0] = 0;
g[1] = g[2] = 1;
for (int i = 3; i <= n; i++) g[i] = g[i - 2] + 1;
while (m--) {
scanf(
"%lld"
"%lld",
&u, &v);
if (u > v) swap(u, v);
work(u, n, a1, a2);
work(v, n, b1, b2);
printf(
"%lld"
"\n",
dis(u, v, n));
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
const long long INF = 1ll << 60;
long long dp[N], pd[N], n, c, p[N], s[N];
int main() {
while (scanf("%I64d%I64d", &n, &c) == 2) {
for (int i = 1; i <= n; i++) scanf("%I64d", &p[i]);
for (int i = 1; i <= n; i++) scanf("%I64d", &s[i]);
for (int i = 1; i <= n; i++) dp[i] = INF;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) pd[j] = dp[j], dp[j] = INF;
for (int j = 0; j < i; j++) {
dp[j] = min(pd[j] + p[i] + j * c, dp[j]);
dp[j + 1] = min(pd[j] + s[i], dp[j + 1]);
}
}
long long ans = INF;
for (int i = 0; i <= n; i++) ans = min(ans, dp[i]);
printf("%I64d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
struct Vertex {
int v;
bool marked;
int degree;
Vertex(int v = 0) : v{v}, marked{false}, degree{0} {}
};
struct Graph {
int n;
std::vector<std::list<int> > adj;
std::vector<Vertex> V;
Graph(int n)
: n{n}, adj{std::vector<std::list<int> >(n)}, V{std::vector<Vertex>(n)} {
for (int i = 0; i < n; i++) V[i] = Vertex{i};
}
void addDirectedEdge(int v, int w) { adj[v].push_back(w); }
};
std::vector<int> topologicalSort(const Graph& G) {
std::vector<int> result;
result.reserve(G.n);
std::list<int> list;
std::vector<int> incomingEdges(G.n);
for (Vertex w : G.V) {
if (!w.marked) continue;
incomingEdges[w.v] = w.degree;
if (incomingEdges[w.v] == 0) list.push_back(w.v);
}
while (!list.empty()) {
int v = list.back();
list.pop_back();
result.push_back(v);
for (int i : G.adj[v]) {
incomingEdges[i]--;
if (incomingEdges[i] == 0) list.push_back(i);
}
}
return result;
}
void dfs(Graph& G, int v) {
G.V[v].marked = true;
for (int i : G.adj[v]) {
if (!G.V[i].marked) {
dfs(G, i);
}
}
}
void makeDegree(Graph& G) {
for (int i = 0; i < G.n; i++) {
if (!G.V[i].marked) continue;
for (int j : G.adj[i]) {
G.V[j].degree++;
}
}
}
int main() {
int numOfVertices;
int numOfMainVertices;
scanf("%d%d", &numOfVertices, &numOfMainVertices);
std::vector<int> mainVertex(numOfMainVertices);
for (int i = 0; i < numOfMainVertices; i++) {
int pom;
scanf("%d", &pom);
mainVertex[i] = pom - 1;
}
Graph G(numOfVertices);
for (int i = 0; i < numOfVertices; i++) {
int numOfNeigh;
scanf("%d", &numOfNeigh);
if (numOfNeigh == 0) continue;
for (int j = 0; j < numOfNeigh; j++) {
int neigh;
scanf("%d", &neigh);
G.addDirectedEdge(i, neigh - 1);
}
}
for (int i : mainVertex) dfs(G, i);
makeDegree(G);
unsigned long long numOfMarked = 0;
for (Vertex i : G.V) {
if (i.marked) numOfMarked++;
}
std::vector<int> topSort = topologicalSort(G);
if (topSort.size() == 0 || numOfMarked != topSort.size()) {
printf("%d\n", -1);
return 0;
}
printf("%lu\n", topSort.size());
while (!topSort.empty()) {
int i = topSort.back();
topSort.pop_back();
printf("%d\n", i + 1);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
deque<long long> a;
int main() {
ios::sync_with_stdio(0);
cin >> n;
a.resize(n);
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
a.push_front(0);
a.push_back(1001);
long long len = 1, mx = 1;
for (long long i = 1; i < n + 2; ++i) {
if (a[i] == a[i - 1] + 1) {
++len;
} else {
len = 1;
}
mx = max(mx, len);
}
cout << max(0LL, mx - 2) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Event {
int type;
int time;
int enemy;
int newHealth;
Event() = default;
Event(int _type, int _time, int _enemy, int _newHealth)
: type(_type), time(_time), enemy(_enemy), newHealth(_newHealth) {}
};
auto cmp = [](const Event& l, const Event& r) { return l.time > r.time; };
int n, m;
int bounty, increase, damage;
unordered_set<int> killedEnemies;
priority_queue<Event, vector<Event>, decltype(cmp)> events(cmp);
int trueRegenerated[100000];
int maxHealths[100000];
int regens[100000];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
cin >> bounty >> increase >> damage;
for (int i = 0; i < n; ++i) {
int health;
cin >> maxHealths[i] >> health >> regens[i];
events.emplace(2, 0, i, health);
}
for (int i = 0; i < m; ++i) {
Event e;
e.type = 2;
cin >> e.time >> e.enemy >> e.newHealth;
e.enemy -= 1;
Event empty = e;
empty.type = 0;
empty.time -= 1;
if (empty.time >= 0) events.emplace(move(empty));
events.emplace(move(e));
}
long long ans = 0;
while (!events.empty()) {
const Event event = move(events.top());
events.pop();
if (event.type == 0)
;
else if (event.type == 1) {
if (trueRegenerated[event.enemy] == event.time)
killedEnemies.erase(event.enemy);
} else if (event.type == 2) {
if (event.newHealth <= damage) {
killedEnemies.emplace(event.enemy);
if (maxHealths[event.enemy] > damage && regens[event.enemy] > 0) {
events.emplace(
1,
event.time + (damage - event.newHealth) / regens[event.enemy] + 1,
event.enemy, damage + 1);
if ((damage - event.newHealth) / regens[event.enemy] >= 1)
events.emplace(
0,
event.time + (damage - event.newHealth) / regens[event.enemy],
-1, 0);
trueRegenerated[event.enemy] =
event.time + (damage - event.newHealth) / regens[event.enemy] + 1;
}
} else
killedEnemies.erase(event.enemy);
}
if (events.empty() || event.time < events.top().time) {
long long tmp =
(long long)killedEnemies.size() *
((long long)bounty + (long long)event.time * (long long)increase);
if (tmp > ans) ans = tmp;
}
}
if (killedEnemies.size() >= 1 && increase > 0)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c[1234567], d, e, i, j, n;
map<long long, long long> m;
string s;
cin >> a >> b;
cout << "YES" << endl;
for (i = a; i <= b; i += 2) {
cout << i << " " << i + 1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)(998244353);
const long long ll_inf = (long long)(1e18 + 420);
const long long N = (long long)(2e5 + 10);
const double eps = (double)(1e-9);
const double pi = (double)(3.14159265358979);
inline void boost() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
inline void fr() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
int n;
int q;
int main() {
cin >> q;
for (int i = 1; i <= q; ++i) {
string second;
cin >> n >> second;
if ((n == 2 && second[0] < second[1]) || (n > 2)) {
cout << "YES" << endl;
cout << 2 << endl;
cout << second[0] << " ";
for (int j = 1; j < second.size(); ++j) {
cout << second[j];
}
cout << endl;
} else {
cout << "NO" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, s1, s2;
s = "qwertyuiopasdfghjkl;zxcvbnm,./";
map<char, int> m;
cin >> s1 >> s2;
for (int i = 0; i < s.size(); i++) {
m[s[i]] = i;
}
if (s1 == "R") {
for (int i = 0; i < s2.size(); i++) {
if (s2[i] == 'q' || s2[i] == 'q' || s2[i] == 'z')
cout << s2[i];
else
cout << s[m[s2[i]] - 1];
}
cout << endl;
} else {
for (int i = 0; i < s2.size(); i++) {
if (s2[i] == 'p' || s2[i] == ';' || s2[i] == '/')
cout << s2[i];
else
cout << s[m[s2[i]] + 1];
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> a[100005];
bool compare(pair<long long, long long> p1, pair<long long, long long> p2) {
if (p1.first == p2.first) return p1.second < p2.second;
return p1.first < p2.first;
}
long long sum[100005];
long long b[100005];
long long b2[100005];
int main() {
long long n, A, cf, cm, m;
long long xp, xl;
long long ans = -1;
cin >> n >> A >> cf >> cm >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i].first;
a[i].second = i;
b2[i] = a[i].first;
}
sort(a + 1, a + n + 1, compare);
for (int i = 1; i <= n; i++)
sum[i] = sum[i - 1] + a[i].first, b[i] = a[i].first;
for (long long p = n; p >= 0; p--) {
long long left = A * (n - p) - (sum[n] - sum[p]);
left = m - left;
if (left < 0) break;
long long l = 0;
long long r = A;
long long mid;
while (l < r) {
mid = (l + r + 1) >> 1;
long long x = lower_bound(b + 1, b + p + 1, mid) - b - 1;
if (mid * x - sum[x] <= left)
l = mid;
else
r = mid - 1;
}
if (cf * (n - p) + cm * l > ans) {
ans = cf * (n - p) + cm * l;
xp = p;
xl = l;
}
}
cout << ans << endl;
for (int i = 1; i <= n; i++)
if (b2[i] < xl) b2[i] = xl;
for (int i = n; i > xp; i--) {
b2[a[i].second] = A;
}
for (int i = 1; i <= n; i++) cout << b2[i] << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool f = false;
struct node {
int id;
int val;
} p[300005];
bool cmp(node a, node b) { return a.val < b.val; }
int n;
void solve(int x1, int x2, int flag) {
for (int i = 1; i <= n; ++i) {
int num = x1 / p[i].val;
if (x1 % p[i].val) num++;
if (num + i - 1 >= n) continue;
int tmp = p[num + i].val;
int num1 = x2 / tmp;
if (x2 % tmp) num1++;
if (num1 + num + i - 1 > n) continue;
if (f) continue;
f = true;
cout << "Yes" << endl;
if (!flag) {
cout << num << " " << num1 << endl;
for (int j = i; j <= num + i - 1; ++j) cout << p[j].id << " ";
cout << endl;
for (int j = num + i; j <= num1 + num + i - 1; ++j)
cout << p[j].id << " ";
} else {
cout << num1 << " " << num << endl;
for (int j = num + i; j <= num1 + num + i - 1; ++j)
cout << p[j].id << " ";
cout << endl;
for (int j = i; j <= num + i - 1; ++j) cout << p[j].id << " ";
}
}
}
int main() {
int x1, x2;
cin >> n >> x1 >> x2;
for (int i = 1; i <= n; ++i) {
cin >> p[i].val;
p[i].id = i;
}
sort(p + 1, p + n + 1, cmp);
solve(x1, x2, 0);
solve(x2, x1, 1);
if (!f) cout << "No" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed long long int bit[200000 + 5];
signed long long int read(int idx) {
signed long long int sum = 0;
if (idx == 0) return 0;
while (idx > 0) {
sum += bit[idx];
idx -= (idx & -idx);
}
return sum;
}
void update(int idx, int val) {
while (idx <= 200000) {
bit[idx] += val;
idx += (idx & -idx);
}
}
vector<pair<int, int> > Q[200000 + 5];
int where[200000 + 5];
vector<int> good[200000 + 5];
signed long long int ans[200000 + 5];
int main() {
int N, q, x, L, R;
cin >> N >> q;
for (int i = 1; i <= N; ++i) {
scanf("%d", &x);
where[x] = i;
}
for (int i = 1; i <= N; ++i) {
for (int j = i; j <= N; j += i) {
if (where[j] < where[i]) {
good[where[i]].push_back(where[j]);
} else {
good[where[j]].push_back(where[i]);
}
}
}
for (int i = 1; i <= q; ++i) {
scanf("%d", &L);
scanf("%d", &R);
Q[R].push_back(make_pair(L, i));
}
for (int i = 1; i <= N; ++i) {
for (int j = 0; j < good[i].size(); ++j) {
update(good[i][j], 1);
}
for (int j = 0; j < Q[i].size(); ++j) {
ans[Q[i][j].second] = read(N) - read(Q[i][j].first - 1);
}
}
for (int i = 1; i <= q; ++i) {
printf("%lld\n", ans[i]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> zfunc(string s) {
int n = (int)s.size();
vector<int> z(n, 0);
for (int i = 1, l = 0, r = 0; i < n; i++) {
if (i < r) {
z[i] = min(r - i, z[i - l]);
} else {
z[i] = 0;
}
while (i + z[i] < n && s[i + z[i]] == s[z[i]]) z[i]++;
if (i + z[i] > r) {
l = i;
r = i + z[i];
}
}
return z;
}
struct state {
int len, link, jbg, fpos;
map<char, int> next;
basic_string<int> inv_link;
};
const int MAXLEN = 100005;
state st[MAXLEN * 2];
int sz, last;
void sa_init() {
st[0].len = 0;
st[0].link = -1;
sz++;
last = 0;
}
void sa_extend(char c) {
int cur = sz++;
st[cur].fpos = st[cur].len = st[last].len + 1;
int p = last;
while (p != -1 && !st[p].next.count(c)) {
st[p].next[c] = cur;
p = st[p].link;
}
if (p == -1) {
st[cur].link = 0;
} else {
int q = st[p].next[c];
if (st[p].len + 1 == st[q].len) {
st[cur].link = q;
} else {
int clone = sz++;
st[clone] = st[q];
st[clone].len = st[p].len + 1;
while (p != -1 && st[p].next[c] == q) {
st[p].next[c] = clone;
p = st[p].link;
}
st[q].link = st[cur].link = clone;
}
}
last = cur;
}
int lol[100005];
void dfs(int x) {
lol[st[x].fpos] = max(lol[st[x].fpos], st[x].jbg);
for (int y : st[x].inv_link) {
st[y].jbg = max(st[y].jbg, st[x].jbg);
dfs(y);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
string p, s;
cin >> p >> s;
p = p.substr(1);
auto z = zfunc(s);
z.push_back(0);
sa_init();
for (char x : p) sa_extend(x);
long long sol = (long long)(p.size() + 1) * (long long)s.size();
int w = 0, n = s.size();
for (int i = 0; i < n; i++) {
char c = s[i];
if (!st[w].next.count(c)) break;
w = st[w].next[c];
st[w].jbg = z[i + 1];
}
for (int i = 1; i < sz; i++) st[st[i].link].inv_link += i;
dfs(0);
sol -= accumulate(lol, lol + 100005, 0ll);
cout << sol << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> diff(n);
long long sum = 0;
for (int i = 0; i < (int)(n); ++i) {
long long a, b;
cin >> a >> b;
sum += a;
diff[i] = a - b;
}
sort(diff.rbegin(), diff.rend());
int resp = 0;
int j = 0;
while (sum > m && j < n) {
resp++;
sum -= diff[j];
j++;
}
if (sum > m)
cout << -1 << endl;
else
cout << resp << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int gc() {
static const int BUF = 1e7;
static char buf[BUF], *bg = buf + BUF, *ed = bg;
if (bg == ed) fread(bg = buf, 1, BUF, stdin);
return *bg++;
}
inline int ri() {
int x = 0, f = 1, c = gc();
for (; c < 48 || c > 57; f = c == '-' ? -1 : f, c = gc())
;
for (; c > 47 && c < 58; x = x * 10 + c - 48, c = gc())
;
return x * f;
}
const int inf = 1e9 + 9;
const long long mod = 1e9 + 7;
const int maxN = 1e5 + 7;
int n;
int s[maxN];
int ans[maxN];
int main() {
while (cin >> n) {
int max_1 = -1, min_1 = inf, highBit = 0;
int ans = -1;
for (int i = (1); i <= (n); ++i) {
cin >> s[i];
highBit |= s[i];
max_1 = max(max_1, s[i]);
min_1 = min(min_1, s[i]);
}
while (highBit & ~((highBit) & (-highBit)))
highBit &= ~((highBit) & (-highBit));
while (!((max_1 & highBit) ^ (min_1 & highBit))) {
max_1 &= ~highBit;
min_1 &= ~highBit;
highBit >>= 1;
}
for (int i = (1); i <= (n); ++i) {
if (s[i] & highBit) {
int tmp_max = -1;
for (int j = (i + 1); j <= (n); ++j) {
if (s[j] & highBit) {
i = j - 1;
break;
}
tmp_max = max(tmp_max, s[j]);
ans = max(ans, tmp_max ^ s[i]);
}
}
}
for (int i = (n); i >= (1); --i) {
if (s[i] & highBit) {
int tmp_max = -1;
for (int j = (i - 1); j >= (1); --j) {
if (s[j] & highBit) {
i = j + 1;
break;
}
tmp_max = max(tmp_max, s[j]);
ans = max(ans, tmp_max ^ s[i]);
}
}
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5, M = 1e6 + 5, C = 1e3 + 5, MOD = 1e9 + 7,
OO = 1e9 + 5;
long long a, b, x1, x2, y_1, y2;
long long addLine(long long mul, long long x) { return mul * a - x; }
long long subLine(long long mul, long long x) { return mul * b + x; }
pair<long long, long long> getLines(long long x, long long y) {
long long st = -OO, en = OO;
while (st <= en) {
long long mid = (st + en) / 2;
if (addLine(mid, x) < y) {
st = mid + 1;
} else {
en = mid - 1;
}
}
pair<long long, long long> res;
res.first = st - 1;
st = -OO, en = OO;
while (st <= en) {
long long mid = (st + en) / 2;
if (subLine(mid, x) < y) {
st = mid + 1;
} else {
en = mid - 1;
}
}
res.second = st - 1;
return res;
}
int main() {
cin.sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> a >> b >> x1 >> y_1 >> x2 >> y2;
a *= 2;
b *= 2;
pair<long long, long long> pt1 = getLines(x1, y_1);
pair<long long, long long> pt2 = getLines(x2, y2);
long long diff1 = abs(pt1.first - pt2.first);
long long diff2 = abs(pt1.second - pt2.second);
cout << max(diff1, diff2) << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int add(int x, int y) {
return ((x + y) % 1000000007 + 1000000007) % 1000000007;
}
int mul(int x, int y) { return (long long)x * y % 1000000007; }
int mypow(int x, int c) {
int ret = 1;
while (c > 0) {
if (c & 1) {
ret = mul(ret, x);
}
c /= 2;
x = mul(x, x);
}
return ret;
}
vector<int> plist[305];
int seg[400005 * 4], lazy[400005 * 4];
int a[400005];
void init(int pos, int l, int r) {
lazy[pos] = 1;
if (l == r) {
seg[pos] = a[l];
return;
}
int mid = (l + r) / 2;
init(pos * 2, l, mid);
init(pos * 2 + 1, mid + 1, r);
seg[pos] = mul(seg[pos * 2], seg[pos * 2 + 1]);
}
void push(int pos, int l, int r) {
if (lazy[pos] != 1) {
seg[pos] = mul(mypow(lazy[pos], r - l + 1), seg[pos]);
if (l != r) {
lazy[pos * 2] = mul(lazy[pos], lazy[pos * 2]);
lazy[pos * 2 + 1] = mul(lazy[pos], lazy[pos * 2 + 1]);
}
lazy[pos] = 1;
}
}
void update(int pos, int l, int r, int ql, int qr, int val) {
push(pos, l, r);
if (r < ql || qr < l) {
return;
}
if (ql <= l && r <= qr) {
lazy[pos] = val;
push(pos, l, r);
return;
}
int mid = (l + r) / 2;
update(pos * 2, l, mid, ql, qr, val);
update(pos * 2 + 1, mid + 1, r, ql, qr, val);
seg[pos] = mul(seg[pos * 2], seg[pos * 2 + 1]);
}
int query(int pos, int l, int r, int ql, int qr) {
push(pos, l, r);
if (r < ql || qr < l) {
return 1;
}
if (ql <= l && r <= qr) {
return seg[pos];
}
int mid = (l + r) / 2;
return mul(query(pos * 2, l, mid, ql, qr),
query(pos * 2 + 1, mid + 1, r, ql, qr));
}
int value[305], mm[305];
int pen[65][400005];
void update(int ind, int p) {
while (ind < 400005) {
pen[p][ind] += 1;
ind += ind & (-ind);
}
}
int query(int ind, int p) {
int ret = 0;
while (ind > 0) {
ret += pen[p][ind];
ind = ind & (ind - 1);
}
return ret;
}
void find(int p, int l, int r) {
int v = query(l - 1, p);
while (true) {
int nind, ind = 0;
int sum = 0;
for (int i = 18; i >= 0; --i) {
nind = (1 << i) + ind;
if (nind <= l - 1 ||
(nind >= l && sum + pen[p][nind] == v + nind - l + 1)) {
ind = nind;
sum += pen[p][nind];
}
}
if (ind + 1 <= r) {
update(ind + 1, p);
} else {
break;
}
}
}
void solve() {
int cc = 0;
for (int i = 2; i < 305; ++i) {
if (plist[i].size() == 0) {
for (int j = i; j < 305; j += i) {
plist[j].push_back(i);
}
value[i] = cc;
mm[cc++] = mul(i - 1, mypow(i, 1000000007 - 2));
}
}
int n, q;
scanf("%d %d ", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d ", &a[i]);
for (int x : plist[a[i]]) {
find(value[x], i, i);
}
}
init(1, 1, n);
char op[100];
int l, r;
while (q--) {
scanf(" %s %d %d ", op, &l, &r);
if (op[0] == 'T') {
int ret = query(1, 1, n, l, r);
for (int i = 0; i < cc; ++i) {
if (query(r, i) - query(l - 1, i) > 0) {
ret = mul(ret, mm[i]);
}
}
printf("%d\n", ret);
} else {
int x;
scanf("%d ", &x);
update(1, 1, n, l, r, x);
for (int p : plist[x]) {
find(value[p], l, r);
}
}
}
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long fact[14];
void initFact() {
fact[0] = 1;
for (int i = (int)(1), _m = (int)(14); i < _m; ++i) fact[i] = fact[i - 1] * i;
}
int digits[11], n;
int dp[11][2][2];
int rec(int indx, int smaller, bool first) {
if (indx == n) return first;
int &ret = dp[indx][smaller][first];
if (ret != -1) return ret;
ret = 0;
if (!first) ret += rec(indx + 1, true, false);
if (smaller || 4 <= digits[indx])
ret += rec(indx + 1, smaller || (4 < digits[indx]), true);
if (smaller || 7 <= digits[indx])
ret += rec(indx + 1, smaller || (7 < digits[indx]), true);
return ret;
}
int countAll(int num) {
n = 0;
while (num) digits[n++] = num % 10, num /= 10;
reverse(digits, digits + n);
memset(dp, -1, sizeof dp);
return rec(0, 0, 0);
}
bool lucky(int n) {
while (n)
if (n % 10 == 4 || n % 10 == 7)
n /= 10;
else
return false;
return true;
}
vector<int> getPerm(vector<int> numbers, int k) {
if (k == 0 || !numbers.size()) return numbers;
int soso = fact[numbers.size() - 1];
int koko = numbers[(k / soso)];
numbers.erase(numbers.begin() + (k / soso));
vector<int> ret = getPerm(numbers, k % soso);
ret.insert(ret.begin(), koko);
return ret;
}
int main() {
initFact();
int res, start, n, k;
vector<int> perm;
while (cin >> n >> k) {
if (n <= 13 && fact[n] < k) {
cout << -1 << endl;
continue;
}
start = 0;
for (int i = (int)(1), _m = (int)(14); i < _m; ++i)
if (fact[i] >= k) {
start = i;
break;
}
start = n - start + 1;
res = countAll(start - 1);
perm.clear();
for (int i = (int)(start), _m = (int)(n + 1); i < _m; ++i)
perm.push_back(i);
perm = getPerm(perm, k - 1);
for (int pos = (int)(start), _m = (int)(n + 1); pos < _m; ++pos) {
if (lucky(pos) && lucky(perm[pos - start])) ++res;
}
cout << res << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, mx = 0, a[200007], b[200007], q;
vector<pair<int, pair<int, int>>> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n;
for (long long i = 1; i <= (long long)n; ++i) cin >> a[i];
cin >> q;
for (long long i = 1; i <= (long long)q; ++i) {
int h, x, y;
cin >> h;
if (h == 1) {
cin >> x >> y;
v.push_back({1, {x, y}});
} else {
cin >> x;
v.push_back({2, {x, -1}});
}
}
reverse(((v).begin()), ((v).end()));
int mx = 0;
for (long long i = 0; i <= (long long)q - 1; ++i) {
pair<int, pair<int, int>> p = v[i];
if (p.first == 1) {
if (b[p.second.first]) continue;
a[p.second.first] = max(mx, p.second.second);
b[p.second.first] = 1;
} else
mx = max(mx, p.second.first);
}
for (long long i = 1; i <= (long long)n; ++i) {
if (!b[i]) a[i] = max(a[i], mx);
cout << a[i] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3405, mo = 1e9 + 7;
int a[N], b[N], c[N], f[N][N][2][2], p, k, cnt, n, m, ans;
char s[N];
int main() {
scanf("%d%d%s", &p, &k, s);
n = strlen(s);
for (int i = 0; i < n; i++) a[n - i] = s[i] - '0';
for (m = 0; !(n == 1 && a[1] == 0);) {
int res = 0;
memset(c, 0, sizeof(c));
for (int i = n; i; i--) {
c[i] = ((long long)res * 10 + a[i]) / p;
res = ((long long)res * 10 + a[i]) % p;
}
b[m++] = res;
memcpy(a, c, sizeof(a));
for (; n > 1 && !a[n]; n--)
;
}
f[m][0][1][0] = 1;
for (int i = m - 1; i >= 0; i--) {
for (int j = 0; j < m - i; j++) {
int t00 = (long long)p * (p + 1) / 2 % mo,
t01 = (long long)(p - 1) * p / 2 % mo,
t10 = ((long long)p * p - t00) % mo,
t11 = ((long long)p * p - t01) % mo;
f[i][j][0][0] = (f[i][j][0][0] + (long long)f[i + 1][j][0][0] * t00 +
(long long)f[i + 1][j][0][1] * t10) %
mo;
f[i][j + 1][0][1] =
(f[i][j + 1][0][1] + (long long)f[i + 1][j][0][0] * t01 +
(long long)f[i + 1][j][0][1] * t11) %
mo;
if (!b[i]) {
f[i][j][1][0] = (f[i][j][1][0] + f[i + 1][j][1][0] +
(long long)f[i + 1][j][1][1] * (p - 1)) %
mo;
f[i][j + 1][1][1] =
(f[i][j + 1][1][1] + (long long)f[i + 1][j][1][1] * p) % mo;
continue;
}
t00 = (long long)b[i] * (b[i] + 1) / 2 % mo;
t01 = (long long)(b[i] - 1) * b[i] / 2 % mo;
t10 = (long long)(p + p - b[i] - 1) * b[i] / 2 % mo;
t11 = (long long)(p + p - b[i] + 1) * b[i] / 2 % mo;
f[i][j][0][0] = (f[i][j][0][0] + (long long)f[i + 1][j][1][0] * t00 +
(long long)f[i + 1][j][1][1] * t10) %
mo;
f[i][j + 1][0][1] =
(f[i][j + 1][0][1] + (long long)f[i + 1][j][1][0] * t01 +
(long long)f[i + 1][j][1][1] * t11) %
mo;
f[i][j][1][0] =
(f[i][j][1][0] + (long long)f[i + 1][j][1][0] * (b[i] + 1) +
(long long)f[i + 1][j][1][1] * (p - b[i] - 1)) %
mo;
f[i][j + 1][1][1] =
(f[i][j + 1][1][1] + (long long)f[i + 1][j][1][0] * b[i] +
(long long)f[i + 1][j][1][1] * (p - b[i])) %
mo;
}
}
ans = 0;
for (int i = k; i <= m; i++)
ans = (ans + f[0][i][0][0] + (long long)f[0][i][1][0]) % mo;
printf("%d\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
const long long int inf = 1000000000000000000;
#pragma GCC optimize("-O3")
long long int gen() {
long long int temp;
cin >> temp;
return temp;
}
long long int power(long long int a, long long int b, long long int m) {
long long int res = 1;
a %= m;
while (b > 0) {
if (b & 1) {
res = (res * a) % m;
b--;
}
a = (a * a) % m;
b = b >> 1;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
long long int getNearestPrime(long long int num) {
while (true) {
bool flag = true;
for (long long int i = 2; i * i <= num; i++) {
if (num % i == 0) {
flag = false;
break;
}
}
if (flag) break;
num++;
}
return num;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
vector<pair<long long int, long long int> > edj;
for (long long int i = 1; i < n; i += 1) edj.push_back({i, i + 1});
edj.push_back({n, 1});
long long int pr = getNearestPrime(edj.size());
long long int dif = pr - edj.size();
long long int st = 1;
while (dif) {
edj.push_back({st, st + 2});
dif--;
if (dif) {
edj.push_back({st + 1, st + 3});
dif--;
}
st += 4;
}
cout << edj.size() << "\n";
for (long long int i = 0; i < edj.size(); i += 1)
cout << edj[i].first << " " << edj[i].second << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000007;
class SuffAut {
public:
vector<map<char, int>> go;
vector<int> link;
vector<long long> len;
int last;
vector<vector<int>> a;
vector<long long> din;
int n;
void make_link(int l, int r) { link[l] = r; }
int add_vertex(int len1, map<char, int> go1 = map<char, int>(),
int link1 = 0) {
a.push_back(vector<int>());
go.push_back(go1);
len.push_back(len1 + 1);
din.push_back(0);
link.push_back(-1);
make_link(len.size() - 1, link1);
return len.size() - 1;
}
SuffAut() {
cin >> n;
add_vertex(-1);
last = 0;
}
void add_letter(char c, int d) {
int p = last;
last = add_vertex(len[last]);
din[last] = d;
while (!go[p].count(c)) {
go[p][c] = last;
p = link[p];
}
if (go[p][c] == last) {
make_link(last, 0);
return;
}
int q = go[p][c];
if (len[q] == len[p] + 1) {
make_link(last, q);
return;
}
int cl = add_vertex(len[p], go[q], link[q]);
make_link(last, cl);
make_link(q, cl);
while (go[p][c] == q) {
go[p][c] = cl;
p = link[p];
}
}
int dfs(int v) {
for (int to : a[v]) {
if (to == v) continue;
din[v] += dfs(to);
}
return din[v];
}
void solve() {
string s, s1;
cin >> s >> s1;
for (int i = 0; i < int(s.size()); i++) add_letter(s[i], '1' - s1[i]);
for (int i = 0; i < int(link.size()); i++) a[link[i]].push_back(i);
dfs(0);
long long mx = 0;
for (int i = 0; i < int(len.size()); i++) mx = max(mx, len[i] * din[i]);
cout << mx << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
SuffAut sa;
sa.solve();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char S[1000001];
set<pair<int, int>> st;
set<pair<int, char>> points;
int N;
int val[1000001];
void update(int ind) {
set<pair<int, char>>::iterator it = points.lower_bound({ind, 'a' - 1});
int cnt = 0;
char C = it->second;
it++;
if (it != points.end()) {
if (C != it->second) cnt++;
}
it--;
if (it != points.begin()) {
it--;
if (C != it->second) cnt++;
}
st.erase({-val[ind], ind});
val[ind] = cnt;
st.insert({-val[ind], ind});
}
int main() {
scanf("%s", S);
N = strlen(S);
for (int i = 0; i < N; i++) {
int cnt = 0;
if (i > 0 && S[i] != S[i - 1]) cnt++;
if (i + 1 < N && S[i] != S[i + 1]) cnt++;
val[i] = cnt;
points.insert({i, S[i]});
st.insert({-cnt, i});
}
for (int ans = 0;; ans++) {
vector<int> todo;
vector<int> pos;
for (set<pair<int, int>>::iterator it = st.begin(); it != st.end(); it++) {
if (it->first < 0)
todo.push_back(it->second);
else
break;
}
if (todo.empty()) {
cout << ans << '\n';
return 0;
}
for (int i = 0; i < todo.size(); i++) {
points.erase({todo[i], S[todo[i]]});
st.erase({-val[todo[i]], todo[i]});
}
set<int> toupdate;
for (int i = 0; i < todo.size(); i++) {
int X = todo[i];
set<pair<int, char>>::iterator it = points.lower_bound({X, S[X]});
if (it != points.end()) {
update(it->first);
}
if (it != points.begin()) {
it--;
update(it->first);
}
}
}
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.